From 4b2d45150f24cd166afdeb5f6c769712fe3b57c4 Mon Sep 17 00:00:00 2001 From: Vladimir Morozov Date: Mon, 18 May 2020 08:06:44 -0700 Subject: [PATCH] Add support for 0..n args in native module callbacks (#4929) * Support 0..n args in native module callbacks * Change files --- ...0-05-17-09-26-39-MS_CallbackMultiArgs.json | 8 + .../NativeModuleTest.cpp | 139 +++++++ .../NoAttributeNativeModuleTest.cpp | 139 +++++++ .../ReactModuleBuilderMock.h | 110 ++---- .../TurboModuleTest.cpp | 357 ++++++++++++++---- .../Microsoft.ReactNative.Cxx/NativeModules.h | 2 + ...osoft.ReactNative.IntegrationTests.vcxproj | 1 - .../NativeModuleTest.cs | 259 ++++++++++--- .../NoAttributeNativeModuleTest.cs | 350 ++++++++++++++--- .../ReactModuleBuilderMock.cs | 52 ++- .../JSValueGenerator.cs | 12 +- .../ReactMethodInfo.cs | 25 +- 12 files changed, 1162 insertions(+), 292 deletions(-) create mode 100644 change/react-native-windows-2020-05-17-09-26-39-MS_CallbackMultiArgs.json diff --git a/change/react-native-windows-2020-05-17-09-26-39-MS_CallbackMultiArgs.json b/change/react-native-windows-2020-05-17-09-26-39-MS_CallbackMultiArgs.json new file mode 100644 index 00000000000..3a160551071 --- /dev/null +++ b/change/react-native-windows-2020-05-17-09-26-39-MS_CallbackMultiArgs.json @@ -0,0 +1,8 @@ +{ + "type": "prerelease", + "comment": "Support 0..n args in native module callbacks", + "packageName": "react-native-windows", + "email": "vmorozov@microsoft.com", + "dependentChangeType": "patch", + "date": "2020-05-17T16:26:39.781Z" +} diff --git a/vnext/Microsoft.ReactNative.Cxx.UnitTests/NativeModuleTest.cpp b/vnext/Microsoft.ReactNative.Cxx.UnitTests/NativeModuleTest.cpp index cb15f7eaa11..8ab06a582a4 100644 --- a/vnext/Microsoft.ReactNative.Cxx.UnitTests/NativeModuleTest.cpp +++ b/vnext/Microsoft.ReactNative.Cxx.UnitTests/NativeModuleTest.cpp @@ -152,6 +152,21 @@ struct SimpleNativeModule { resolve("Static Hello_2"); } + REACT_METHOD(CallbackZeroArgs) + void CallbackZeroArgs(std::function const &resolve) noexcept { + resolve(); + } + + REACT_METHOD(CallbackTwoArgs) + void CallbackTwoArgs(std::function const &resolve) noexcept { + resolve(1, 2); + } + + REACT_METHOD(CallbackThreeArgs) + void CallbackThreeArgs(std::function const &resolve) noexcept { + resolve(1, 2, "Hello"); + } + REACT_METHOD(DivideCallbacks) void DivideCallbacks( int x, @@ -312,6 +327,44 @@ struct SimpleNativeModule { reject("Goodbye"); } + REACT_METHOD(TwoCallbacksZeroArgs1) + void TwoCallbacksZeroArgs1(std::function const &resolve, std::function const & /*reject*/) noexcept { + resolve(); + } + + REACT_METHOD(TwoCallbacksZeroArgs2) + void TwoCallbacksZeroArgs2(std::function const & /*resolve*/, std::function const &reject) noexcept { + reject(); + } + + REACT_METHOD(TwoCallbacksTwoArgs1) + void TwoCallbacksTwoArgs1( + std::function const &resolve, + std::function const & /*reject*/) noexcept { + resolve(1, 2); + } + + REACT_METHOD(TwoCallbacksTwoArgs2) + void TwoCallbacksTwoArgs2( + std::function const & /*resolve*/, + std::function const &reject) noexcept { + reject(1, 2); + } + + REACT_METHOD(TwoCallbacksThreeArgs1) + void TwoCallbacksThreeArgs1( + std::function const &resolve, + std::function const & /*reject*/) noexcept { + resolve(1, 2, "Hello"); + } + + REACT_METHOD(TwoCallbacksThreeArgs2) + void TwoCallbacksThreeArgs2( + std::function const & /*resolve*/, + std::function const &reject) noexcept { + reject(1, 2, "Hello"); + } + REACT_METHOD(DividePromise) void DividePromise(int x, int y, React::ReactPromise const &result) noexcept { if (y != 0) { @@ -746,6 +799,30 @@ TEST_CLASS (NativeModuleTest) { TestCheck(m_builderMock.IsResolveCallbackCalled()); } + TEST_METHOD(TestMethodCall_CallbackZeroArgs) { + m_builderMock.Call1(L"CallbackZeroArgs", std::function([]() noexcept {})); + TestCheck(m_builderMock.IsResolveCallbackCalled()); + } + + TEST_METHOD(TestMethodCall_CallbackTwoArgs) { + m_builderMock.Call1(L"CallbackTwoArgs", std::function([](int p1, int p2) noexcept { + TestCheckEqual(1, p1); + TestCheckEqual(2, p2); + })); + TestCheck(m_builderMock.IsResolveCallbackCalled()); + } + + TEST_METHOD(TestMethodCall_CallbackThreeArgs) { + m_builderMock.Call1( + L"CallbackThreeArgs", + std::function([](int p1, int p2, std::string const &p3) noexcept { + TestCheckEqual(1, p1); + TestCheckEqual(2, p2); + TestCheckEqual("Hello", p3); + })); + TestCheck(m_builderMock.IsResolveCallbackCalled()); + } + TEST_METHOD(TestMethodCall_DivideCallbacks) { m_builderMock.Call2( L"DivideCallbacks", @@ -990,6 +1067,68 @@ TEST_CLASS (NativeModuleTest) { TestCheck(m_builderMock.IsRejectCallbackCalled()); } + TEST_METHOD(TestMethodCall_TwoCallbacksZeroArgs1) { + m_builderMock.Call2(L"TwoCallbacksZeroArgs1", std::function([]() noexcept {}), std::function([ + ]() noexcept { TestCheckFail(); })); + TestCheck(m_builderMock.IsResolveCallbackCalled()); + } + + TEST_METHOD(TestMethodCall_TwoCallbacksZeroArgs2) { + m_builderMock.Call2( + L"TwoCallbacksZeroArgs2", + std::function([]() noexcept { TestCheckFail(); }), + std::function([]() noexcept {})); + TestCheck(m_builderMock.IsRejectCallbackCalled()); + } + + TEST_METHOD(TestMethodCall_TwoCallbacksTwoArgs1) { + m_builderMock.Call2( + L"TwoCallbacksTwoArgs1", + std::function([](int p1, int p2) noexcept { + TestCheckEqual(1, p1); + TestCheckEqual(2, p2); + }), + std::function([](int /*p1*/, int /*p2*/) noexcept { TestCheckFail(); })); + TestCheck(m_builderMock.IsResolveCallbackCalled()); + } + + TEST_METHOD(TestMethodCall_TwoCallbacksTwoArgs2) { + m_builderMock.Call2( + L"TwoCallbacksTwoArgs2", + std::function([](int /*p1*/, int /*p2*/) noexcept { TestCheckFail(); }), + std::function([](int p1, int p2) noexcept { + TestCheckEqual(1, p1); + TestCheckEqual(2, p2); + })); + TestCheck(m_builderMock.IsRejectCallbackCalled()); + } + + TEST_METHOD(TestMethodCall_TwoCallbacksThreeArgs1) { + m_builderMock.Call2( + L"TwoCallbacksThreeArgs1", + std::function([](int p1, int p2, std::string const &p3) noexcept { + TestCheckEqual(1, p1); + TestCheckEqual(2, p2); + TestCheckEqual("Hello", p3); + }), + std::function( + [](int /*p1*/, int /*p2*/, std::string const & /*p3*/) noexcept { TestCheckFail(); })); + TestCheck(m_builderMock.IsResolveCallbackCalled()); + } + + TEST_METHOD(TestMethodCall_TwoCallbacksThreeArgs2) { + m_builderMock.Call2( + L"TwoCallbacksThreeArgs2", + std::function( + [](int /*p1*/, int /*p2*/, std::string const & /*p3*/) noexcept { TestCheckFail(); }), + std::function([](int p1, int p2, std::string const &p3) noexcept { + TestCheckEqual(1, p1); + TestCheckEqual(2, p2); + TestCheckEqual("Hello", p3); + })); + TestCheck(m_builderMock.IsRejectCallbackCalled()); + } + TEST_METHOD(TestMethodCall_DividePromise) { m_builderMock.Call2( L"DividePromise", diff --git a/vnext/Microsoft.ReactNative.Cxx.UnitTests/NoAttributeNativeModuleTest.cpp b/vnext/Microsoft.ReactNative.Cxx.UnitTests/NoAttributeNativeModuleTest.cpp index dd4859ab2df..1496c3f355d 100644 --- a/vnext/Microsoft.ReactNative.Cxx.UnitTests/NoAttributeNativeModuleTest.cpp +++ b/vnext/Microsoft.ReactNative.Cxx.UnitTests/NoAttributeNativeModuleTest.cpp @@ -135,6 +135,18 @@ struct SimpleNativeModule2 { resolve("Static Hello_2"); } + void CallbackZeroArgs(std::function const &resolve) noexcept { + resolve(); + } + + void CallbackTwoArgs(std::function const &resolve) noexcept { + resolve(1, 2); + } + + void CallbackThreeArgs(std::function const &resolve) noexcept { + resolve(1, 2, "Hello"); + } + void DivideCallbacks( int x, int y, @@ -281,6 +293,38 @@ struct SimpleNativeModule2 { reject("Goodbye"); } + void TwoCallbacksZeroArgs1(std::function const &resolve, std::function const & /*reject*/) noexcept { + resolve(); + } + + void TwoCallbacksZeroArgs2(std::function const & /*resolve*/, std::function const &reject) noexcept { + reject(); + } + + void TwoCallbacksTwoArgs1( + std::function const &resolve, + std::function const & /*reject*/) noexcept { + resolve(1, 2); + } + + void TwoCallbacksTwoArgs2( + std::function const & /*resolve*/, + std::function const &reject) noexcept { + reject(1, 2); + } + + void TwoCallbacksThreeArgs1( + std::function const &resolve, + std::function const & /*reject*/) noexcept { + resolve(1, 2, "Hello"); + } + + void TwoCallbacksThreeArgs2( + std::function const & /*resolve*/, + std::function const &reject) noexcept { + reject(1, 2, "Hello"); + } + void DividePromise(int x, int y, React::ReactPromise const &result) noexcept { if (y != 0) { result.Resolve(x / y); @@ -535,6 +579,9 @@ void GetReactModuleInfo(SimpleNativeModule2 *, React::ReactModuleBuilder([]() noexcept {})); + TestCheck(m_builderMock.IsResolveCallbackCalled()); + } + + TEST_METHOD(TestMethodCall_CallbackTwoArgs) { + m_builderMock.Call1(L"CallbackTwoArgs", std::function([](int p1, int p2) noexcept { + TestCheckEqual(1, p1); + TestCheckEqual(2, p2); + })); + TestCheck(m_builderMock.IsResolveCallbackCalled()); + } + + TEST_METHOD(TestMethodCall_CallbackThreeArgs) { + m_builderMock.Call1( + L"CallbackThreeArgs", + std::function([](int p1, int p2, std::string const &p3) noexcept { + TestCheckEqual(1, p1); + TestCheckEqual(2, p2); + TestCheckEqual("Hello", p3); + })); + TestCheck(m_builderMock.IsResolveCallbackCalled()); + } + TEST_METHOD(TestMethodCall_DivideCallbacks) { m_builderMock.Call2( L"DivideCallbacks", @@ -997,6 +1074,68 @@ TEST_CLASS (NoAttributeNativeModuleTest) { TestCheck(m_builderMock.IsRejectCallbackCalled()); } + TEST_METHOD(TestMethodCall_TwoCallbacksZeroArgs1) { + m_builderMock.Call2(L"TwoCallbacksZeroArgs1", std::function([]() noexcept {}), std::function([ + ]() noexcept { TestCheckFail(); })); + TestCheck(m_builderMock.IsResolveCallbackCalled()); + } + + TEST_METHOD(TestMethodCall_TwoCallbacksZeroArgs2) { + m_builderMock.Call2( + L"TwoCallbacksZeroArgs2", + std::function([]() noexcept { TestCheckFail(); }), + std::function([]() noexcept {})); + TestCheck(m_builderMock.IsRejectCallbackCalled()); + } + + TEST_METHOD(TestMethodCall_TwoCallbacksTwoArgs1) { + m_builderMock.Call2( + L"TwoCallbacksTwoArgs1", + std::function([](int p1, int p2) noexcept { + TestCheckEqual(1, p1); + TestCheckEqual(2, p2); + }), + std::function([](int /*p1*/, int /*p2*/) noexcept { TestCheckFail(); })); + TestCheck(m_builderMock.IsResolveCallbackCalled()); + } + + TEST_METHOD(TestMethodCall_TwoCallbacksTwoArgs2) { + m_builderMock.Call2( + L"TwoCallbacksTwoArgs2", + std::function([](int /*p1*/, int /*p2*/) noexcept { TestCheckFail(); }), + std::function([](int p1, int p2) noexcept { + TestCheckEqual(1, p1); + TestCheckEqual(2, p2); + })); + TestCheck(m_builderMock.IsRejectCallbackCalled()); + } + + TEST_METHOD(TestMethodCall_TwoCallbacksThreeArgs1) { + m_builderMock.Call2( + L"TwoCallbacksThreeArgs1", + std::function([](int p1, int p2, std::string const &p3) noexcept { + TestCheckEqual(1, p1); + TestCheckEqual(2, p2); + TestCheckEqual("Hello", p3); + }), + std::function( + [](int /*p1*/, int /*p2*/, std::string const & /*p3*/) noexcept { TestCheckFail(); })); + TestCheck(m_builderMock.IsResolveCallbackCalled()); + } + + TEST_METHOD(TestMethodCall_TwoCallbacksThreeArgs2) { + m_builderMock.Call2( + L"TwoCallbacksThreeArgs2", + std::function( + [](int /*p1*/, int /*p2*/, std::string const & /*p3*/) noexcept { TestCheckFail(); }), + std::function([](int p1, int p2, std::string const &p3) noexcept { + TestCheckEqual(1, p1); + TestCheckEqual(2, p2); + TestCheckEqual("Hello", p3); + })); + TestCheck(m_builderMock.IsRejectCallbackCalled()); + } + TEST_METHOD(TestMethodCall_DividePromise) { m_builderMock.Call2( L"DividePromise", diff --git a/vnext/Microsoft.ReactNative.Cxx.UnitTests/ReactModuleBuilderMock.h b/vnext/Microsoft.ReactNative.Cxx.UnitTests/ReactModuleBuilderMock.h index af25432766f..01ffc906a3d 100644 --- a/vnext/Microsoft.ReactNative.Cxx.UnitTests/ReactModuleBuilderMock.h +++ b/vnext/Microsoft.ReactNative.Cxx.UnitTests/ReactModuleBuilderMock.h @@ -8,6 +8,7 @@ #include #include "JSValue.h" +#include "NativeModules.h" #undef GetCurrentTime #include "Windows.UI.Xaml.h" @@ -23,26 +24,15 @@ struct ReactModuleBuilderMock { template void Call0(std::wstring const &methodName, TArgs &&... args) noexcept; - template + template Mso::Future - Call1(std::wstring const &methodName, std::function &&resolve, TArgs &&... args) noexcept; + Call1(std::wstring const &methodName, std::function &&resolve, TArgs &&... args) noexcept; - template - Mso::Future - Call1(std::wstring const &methodName, std::function const &resolve, TArgs &&... args) noexcept; - - template + template Mso::Future Call2( std::wstring const &methodName, - std::function const &resolve, - std::function const &reject, - TArgs &&... args) noexcept; - - template - Mso::Future Call2( - std::wstring const &methodName, - std::function const &resolve, - std::function const &reject, + std::function const &resolve, + std::function const &reject, TArgs &&... args) noexcept; template @@ -96,15 +86,16 @@ struct ReactModuleBuilderMock { static IJSValueReader ArgReader(TArgs &&... args) noexcept; static IJSValueReader CreateArgReader(std::function const &argWriter) noexcept; - template + template MethodResultCallback ResolveCallback( - std::function const &resolve, + std::function const &resolve, + std::index_sequence, Mso::Promise const &promise) noexcept; - MethodResultCallback ResolveCallback( - std::function const &resolve, + template + MethodResultCallback RejectCallback( + std::function const &reject, + std::index_sequence, Mso::Promise const &promise) noexcept; - template - MethodResultCallback RejectCallback(std::function const &reject, Mso::Promise const &promise) noexcept; private: IReactContext m_reactContext{nullptr}; @@ -168,60 +159,35 @@ inline void ReactModuleBuilderMock::Call0(std::wstring const &methodName, TArgs } } -template -inline Mso::Future ReactModuleBuilderMock::Call1( - std::wstring const &methodName, - std::function &&resolve, - TArgs &&... args) noexcept { - Mso::Promise promise; - if (auto method = GetMethod1(methodName)) { - method(ArgReader(std::forward(args)...), ArgWriter(), ResolveCallback(resolve, promise), nullptr); - } - return promise.AsFuture(); -} - -template +template inline Mso::Future ReactModuleBuilderMock::Call1( std::wstring const &methodName, - std::function const &resolve, + std::function &&resolve, TArgs &&... args) noexcept { Mso::Promise promise; if (auto method = GetMethod1(methodName)) { - method(ArgReader(std::forward(args)...), ArgWriter(), ResolveCallback(resolve, promise), nullptr); - } - return promise.AsFuture(); -} - -template -inline Mso::Future ReactModuleBuilderMock::Call2( - std::wstring const &methodName, - std::function const &resolve, - std::function const &reject, - TArgs &&... args) noexcept { - Mso::Promise promise; - if (auto method = GetMethod2(methodName)) { method( ArgReader(std::forward(args)...), ArgWriter(), - ResolveCallback(resolve, promise), - RejectCallback(reject, promise)); + ResolveCallback(resolve, std::make_index_sequence{}, promise), + nullptr); } return promise.AsFuture(); } -template +template inline Mso::Future ReactModuleBuilderMock::Call2( std::wstring const &methodName, - std::function const &resolve, - std::function const &reject, + std::function const &resolve, + std::function const &reject, TArgs &&... args) noexcept { Mso::Promise promise; if (auto method = GetMethod2(methodName)) { method( ArgReader(std::forward(args)...), ArgWriter(), - ResolveCallback(resolve, promise), - RejectCallback(reject, promise)); + ResolveCallback(resolve, std::make_index_sequence{}, promise), + RejectCallback(reject, std::make_index_sequence{}, promise)); } return promise.AsFuture(); } @@ -243,37 +209,29 @@ inline /*static*/ IJSValueReader ReactModuleBuilderMock::ArgReader(TArgs &&... a }); } -template +template inline MethodResultCallback ReactModuleBuilderMock::ResolveCallback( - std::function const &resolve, + std::function const &resolve, + std::index_sequence, Mso::Promise const &promise) noexcept { return [ this, resolve, promise ](IJSValueWriter const &writer) noexcept { - std::remove_const_t> arg; - ReadArgs(MakeJSValueTreeReader(TakeJSValue(writer)), arg); - resolve(arg); - m_isResolveCallbackCalled = true; - promise.TrySetValue(true); - }; -} - -inline MethodResultCallback ReactModuleBuilderMock::ResolveCallback( - std::function const &resolve, - Mso::Promise const &promise) noexcept { - return [ this, resolve, promise ](IJSValueWriter const & /*writer*/) noexcept { - resolve(); + std::tuple...> args; + ReadArgs(MakeJSValueTreeReader(TakeJSValue(writer)), std::get(args)...); + resolve(std::get(args)...); m_isResolveCallbackCalled = true; promise.TrySetValue(true); }; } -template +template inline MethodResultCallback ReactModuleBuilderMock::RejectCallback( - std::function const &reject, + std::function const &reject, + std::index_sequence, Mso::Promise const &promise) noexcept { return [ this, reject, promise ](IJSValueWriter const &writer) noexcept { - std::remove_const_t> arg; - ReadArgs(MakeJSValueTreeReader(TakeJSValue(writer)), arg); - reject(arg); + std::tuple...> args; + ReadArgs(MakeJSValueTreeReader(TakeJSValue(writer)), std::get(args)...); + reject(std::get(args)...); m_isRejectCallbackCalled = true; promise.TrySetValue(false); }; diff --git a/vnext/Microsoft.ReactNative.Cxx.UnitTests/TurboModuleTest.cpp b/vnext/Microsoft.ReactNative.Cxx.UnitTests/TurboModuleTest.cpp index f9f5c597724..f7f380912dd 100644 --- a/vnext/Microsoft.ReactNative.Cxx.UnitTests/TurboModuleTest.cpp +++ b/vnext/Microsoft.ReactNative.Cxx.UnitTests/TurboModuleTest.cpp @@ -151,6 +151,21 @@ struct MyTurboModule { resolve("Static Hello_2"); } + REACT_METHOD(CallbackZeroArgs) + void CallbackZeroArgs(std::function const &resolve) noexcept { + resolve(); + } + + REACT_METHOD(CallbackTwoArgs) + void CallbackTwoArgs(std::function const &resolve) noexcept { + resolve(1, 2); + } + + REACT_METHOD(CallbackThreeArgs) + void CallbackThreeArgs(std::function const &resolve) noexcept { + resolve(1, 2, "Hello"); + } + REACT_METHOD(DivideCallbacks) void DivideCallbacks( int x, @@ -311,6 +326,44 @@ struct MyTurboModule { reject("Goodbye"); } + REACT_METHOD(TwoCallbacksZeroArgs1) + void TwoCallbacksZeroArgs1(std::function const &resolve, std::function const & /*reject*/) noexcept { + resolve(); + } + + REACT_METHOD(TwoCallbacksZeroArgs2) + void TwoCallbacksZeroArgs2(std::function const & /*resolve*/, std::function const &reject) noexcept { + reject(); + } + + REACT_METHOD(TwoCallbacksTwoArgs1) + void TwoCallbacksTwoArgs1( + std::function const &resolve, + std::function const & /*reject*/) noexcept { + resolve(1, 2); + } + + REACT_METHOD(TwoCallbacksTwoArgs2) + void TwoCallbacksTwoArgs2( + std::function const & /*resolve*/, + std::function const &reject) noexcept { + reject(1, 2); + } + + REACT_METHOD(TwoCallbacksThreeArgs1) + void TwoCallbacksThreeArgs1( + std::function const &resolve, + std::function const & /*reject*/) noexcept { + resolve(1, 2, "Hello"); + } + + REACT_METHOD(TwoCallbacksThreeArgs2) + void TwoCallbacksThreeArgs2( + std::function const & /*resolve*/, + std::function const &reject) noexcept { + reject(1, 2, "Hello"); + } + REACT_METHOD(DividePromise) void DividePromise(int x, int y, React::ReactPromise const &result) noexcept { if (y != 0) { @@ -618,42 +671,55 @@ struct MyTurboModuleSpec : winrt::Microsoft::ReactNative::TurboModuleSpec { Method) noexcept>{21, L"StaticNegateDispatchQueueCallback"}, Method) noexcept>{22, L"StaticNegateFutureCallback"}, Method) noexcept>{23, L"StaticSayHelloCallback"}, - Method, Callback) noexcept>{24, L"DivideCallbacks"}, - Method, Callback) noexcept>{25, L"NegateCallbacks"}, - Method, Callback) noexcept>{26, L"NegateAsyncCallbacks"}, - Method, Callback) noexcept>{27, L"NegateDispatchQueueCallbacks"}, - Method, Callback) noexcept>{28, L"NegateFutureCallbacks"}, - Method, Callback) noexcept>{29, L"ResolveSayHelloCallbacks"}, - Method, Callback) noexcept>{30, L"RejectSayHelloCallbacks"}, - Method, Callback) noexcept>{31, L"StaticDivideCallbacks"}, - Method, Callback) noexcept>{32, L"StaticNegateCallbacks"}, - Method, Callback) noexcept>{33, L"StaticNegateAsyncCallbacks"}, - Method, Callback) noexcept>{34, L"StaticNegateDispatchQueueCallbacks"}, - Method, Callback) noexcept>{35, L"StaticNegateFutureCallbacks"}, - Method, Callback) noexcept>{36, L"StaticResolveSayHelloCallbacks"}, - Method, Callback) noexcept>{37, L"StaticRejectSayHelloCallbacks"}, - Method) noexcept>{38, L"DividePromise"}, - Method) noexcept>{39, L"NegatePromise"}, - Method) noexcept>{40, L"NegateAsyncPromise"}, - Method) noexcept>{41, L"NegateDispatchQueuePromise"}, - Method) noexcept>{42, L"NegateFuturePromise"}, - Method) noexcept>{43, L"voidPromise"}, - Method) noexcept>{44, L"ResolveSayHelloPromise"}, - Method) noexcept>{45, L"RejectSayHelloPromise"}, - Method) noexcept>{46, L"StaticDividePromise"}, - Method) noexcept>{47, L"StaticNegatePromise"}, - Method) noexcept>{48, L"StaticNegateAsyncPromise"}, - Method) noexcept>{49, L"StaticNegateDispatchQueuePromise"}, - Method) noexcept>{50, L"StaticNegateFuturePromise"}, - Method) noexcept>{51, L"staticVoidPromise"}, - Method) noexcept>{52, L"StaticResolveSayHelloPromise"}, - Method) noexcept>{53, L"StaticRejectSayHelloPromise"}, - SyncMethod{54, L"AddSync"}, - SyncMethod{55, L"NegateSync"}, - SyncMethod{56, L"SayHelloSync"}, - SyncMethod{57, L"StaticAddSync"}, - SyncMethod{58, L"StaticNegateSync"}, - SyncMethod{59, L"StaticSayHelloSync"}, + Method) noexcept>{24, L"CallbackZeroArgs"}, + Method) noexcept>{25, L"CallbackTwoArgs"}, + Method) noexcept>{26, L"CallbackThreeArgs"}, + Method, Callback) noexcept>{27, L"DivideCallbacks"}, + Method, Callback) noexcept>{28, L"NegateCallbacks"}, + Method, Callback) noexcept>{29, L"NegateAsyncCallbacks"}, + Method, Callback) noexcept>{30, L"NegateDispatchQueueCallbacks"}, + Method, Callback) noexcept>{31, L"NegateFutureCallbacks"}, + Method, Callback) noexcept>{32, L"ResolveSayHelloCallbacks"}, + Method, Callback) noexcept>{33, L"RejectSayHelloCallbacks"}, + Method, Callback) noexcept>{34, L"StaticDivideCallbacks"}, + Method, Callback) noexcept>{35, L"StaticNegateCallbacks"}, + Method, Callback) noexcept>{36, L"StaticNegateAsyncCallbacks"}, + Method, Callback) noexcept>{37, L"StaticNegateDispatchQueueCallbacks"}, + Method, Callback) noexcept>{38, L"StaticNegateFutureCallbacks"}, + Method, Callback) noexcept>{39, L"StaticResolveSayHelloCallbacks"}, + Method, Callback) noexcept>{40, L"StaticRejectSayHelloCallbacks"}, + Method, Callback<>) noexcept>{41, L"TwoCallbacksZeroArgs1"}, + Method, Callback<>) noexcept>{42, L"TwoCallbacksZeroArgs2"}, + Method, Callback) noexcept>{43, L"TwoCallbacksTwoArgs1"}, + Method, Callback) noexcept>{44, L"TwoCallbacksTwoArgs2"}, + Method, Callback) noexcept>{ + 45, + L"TwoCallbacksThreeArgs1"}, + Method, Callback) noexcept>{ + 46, + L"TwoCallbacksThreeArgs2"}, + Method) noexcept>{47, L"DividePromise"}, + Method) noexcept>{48, L"NegatePromise"}, + Method) noexcept>{49, L"NegateAsyncPromise"}, + Method) noexcept>{50, L"NegateDispatchQueuePromise"}, + Method) noexcept>{51, L"NegateFuturePromise"}, + Method) noexcept>{52, L"voidPromise"}, + Method) noexcept>{53, L"ResolveSayHelloPromise"}, + Method) noexcept>{54, L"RejectSayHelloPromise"}, + Method) noexcept>{55, L"StaticDividePromise"}, + Method) noexcept>{56, L"StaticNegatePromise"}, + Method) noexcept>{57, L"StaticNegateAsyncPromise"}, + Method) noexcept>{58, L"StaticNegateDispatchQueuePromise"}, + Method) noexcept>{59, L"StaticNegateFuturePromise"}, + Method) noexcept>{60, L"staticVoidPromise"}, + Method) noexcept>{61, L"StaticResolveSayHelloPromise"}, + Method) noexcept>{62, L"StaticRejectSayHelloPromise"}, + SyncMethod{63, L"AddSync"}, + SyncMethod{64, L"NegateSync"}, + SyncMethod{65, L"SayHelloSync"}, + SyncMethod{66, L"StaticAddSync"}, + SyncMethod{67, L"StaticNegateSync"}, + SyncMethod{68, L"StaticSayHelloSync"}, }; template @@ -866,241 +932,304 @@ struct MyTurboModuleSpec : winrt::Microsoft::ReactNative::TurboModuleSpec { " REACT_METHOD(StaticSayHelloCallback) static winrt::fire_and_forget StaticSayHelloCallback(ReactCallback) noexcept {/*implementation*/}\n"); REACT_SHOW_METHOD_SPEC_ERRORS( 24, + "CallbackZeroArgs", + " REACT_METHOD(CallbackZeroArgs) void CallbackZeroArgs(ReactCallback<>) noexcept {/*implementation*/}\n" + " REACT_METHOD(CallbackZeroArgs) winrt::fire_and_forget CallbackZeroArgs(ReactCallback<>) noexcept {/*implementation*/}\n" + " REACT_METHOD(CallbackZeroArgs) static void CallbackZeroArgs(ReactCallback<>) noexcept {/*implementation*/}\n" + " REACT_METHOD(CallbackZeroArgs) static winrt::fire_and_forget CallbackZeroArgs(ReactCallback<>) noexcept {/*implementation*/}\n"); + REACT_SHOW_METHOD_SPEC_ERRORS( + 25, + "CallbackTwoArgs", + " REACT_METHOD(CallbackTwoArgs) void CallbackTwoArgs(ReactCallback) noexcept {/*implementation*/}\n" + " REACT_METHOD(CallbackTwoArgs) winrt::fire_and_forget CallbackTwoArgs(ReactCallback) noexcept {/*implementation*/}\n" + " REACT_METHOD(CallbackTwoArgs) static void CallbackTwoArgs(ReactCallback) noexcept {/*implementation*/}\n" + " REACT_METHOD(CallbackTwoArgs) static winrt::fire_and_forget CallbackTwoArgs(ReactCallback) noexcept {/*implementation*/}\n"); + REACT_SHOW_METHOD_SPEC_ERRORS( + 26, + "CallbackThreeArgs", + " REACT_METHOD(CallbackThreeArgs) void CallbackThreeArgs(ReactCallback) noexcept {/*implementation*/}\n" + " REACT_METHOD(CallbackThreeArgs) winrt::fire_and_forget CallbackThreeArgs(ReactCallback) noexcept {/*implementation*/}\n" + " REACT_METHOD(CallbackThreeArgs) static void CallbackThreeArgs(ReactCallback) noexcept {/*implementation*/}\n" + " REACT_METHOD(CallbackThreeArgs) static winrt::fire_and_forget CallbackThreeArgs(ReactCallback) noexcept {/*implementation*/}\n"); + REACT_SHOW_METHOD_SPEC_ERRORS( + 27, "DivideCallbacks", " REACT_METHOD(DivideCallbacks) void DivideCallbacks(int, int, ReactCallback, ReactCallback) noexcept {/*implementation*/}\n" " REACT_METHOD(DivideCallbacks) winrt::fire_and_forget DivideCallbacks(int, int, ReactCallback, ReactCallback) noexcept {/*implementation*/}\n" " REACT_METHOD(DivideCallbacks) static void DivideCallbacks(int, int, ReactCallback, ReactCallback) noexcept {/*implementation*/}\n" " REACT_METHOD(DivideCallbacks) static winrt::fire_and_forget DivideCallbacks(int, int, ReactCallback, ReactCallback) noexcept {/*implementation*/}\n"); REACT_SHOW_METHOD_SPEC_ERRORS( - 25, + 28, "NegateCallbacks", " REACT_METHOD(NegateCallbacks) void NegateCallbacks(int, ReactCallback, ReactCallback) noexcept {/*implementation*/}\n" " REACT_METHOD(NegateCallbacks) winrt::fire_and_forget NegateCallbacks(int, ReactCallback, ReactCallback) noexcept {/*implementation*/}\n" " REACT_METHOD(NegateCallbacks) static void NegateCallbacks(int, ReactCallback, ReactCallback) noexcept {/*implementation*/}\n" " REACT_METHOD(NegateCallbacks) static winrt::fire_and_forget NegateCallbacks(int, ReactCallback, ReactCallback) noexcept {/*implementation*/}\n"); REACT_SHOW_METHOD_SPEC_ERRORS( - 26, + 29, "NegateAsyncCallbacks", " REACT_METHOD(NegateAsyncCallbacks) void NegateAsyncCallbacks(int, ReactCallback, ReactCallback) noexcept {/*implementation*/}\n" " REACT_METHOD(NegateAsyncCallbacks) winrt::fire_and_forget NegateAsyncCallbacks(int, ReactCallback, ReactCallback) noexcept {/*implementation*/}\n" " REACT_METHOD(NegateAsyncCallbacks) static void NegateAsyncCallbacks(int, ReactCallback, ReactCallback) noexcept {/*implementation*/}\n" " REACT_METHOD(NegateAsyncCallbacks) static winrt::fire_and_forget NegateAsyncCallbacks(int, ReactCallback, ReactCallback) noexcept {/*implementation*/}\n"); REACT_SHOW_METHOD_SPEC_ERRORS( - 27, + 30, "NegateDispatchQueueCallbacks", " REACT_METHOD(NegateDispatchQueueCallbacks) void NegateDispatchQueueCallbacks(int, ReactCallback, ReactCallback) noexcept {/*implementation*/}\n" " REACT_METHOD(NegateDispatchQueueCallbacks) winrt::fire_and_forget NegateDispatchQueueCallbacks(int, ReactCallback, ReactCallback) noexcept {/*implementation*/}\n" " REACT_METHOD(NegateDispatchQueueCallbacks) static void NegateDispatchQueueCallbacks(int, ReactCallback, ReactCallback) noexcept {/*implementation*/}\n" " REACT_METHOD(NegateDispatchQueueCallbacks) static winrt::fire_and_forget NegateDispatchQueueCallbacks(int, ReactCallback, ReactCallback) noexcept {/*implementation*/}\n"); REACT_SHOW_METHOD_SPEC_ERRORS( - 28, + 31, "NegateFutureCallbacks", " REACT_METHOD(NegateFutureCallbacks) void NegateFutureCallbacks(int, ReactCallback, ReactCallback) noexcept {/*implementation*/}\n" " REACT_METHOD(NegateFutureCallbacks) winrt::fire_and_forget NegateFutureCallbacks(int, ReactCallback, ReactCallback) noexcept {/*implementation*/}\n" " REACT_METHOD(NegateFutureCallbacks) static void NegateFutureCallbacks(int, ReactCallback, ReactCallback) noexcept {/*implementation*/}\n" " REACT_METHOD(NegateFutureCallbacks) static winrt::fire_and_forget NegateFutureCallbacks(int, ReactCallback, ReactCallback) noexcept {/*implementation*/}\n"); REACT_SHOW_METHOD_SPEC_ERRORS( - 29, + 32, "ResolveSayHelloCallbacks", " REACT_METHOD(ResolveSayHelloCallbacks) void ResolveSayHelloCallbacks(ReactCallback, ReactCallback) noexcept {/*implementation*/}\n" " REACT_METHOD(ResolveSayHelloCallbacks) winrt::fire_and_forget ResolveSayHelloCallbacks(ReactCallback, ReactCallback) noexcept {/*implementation*/}\n" " REACT_METHOD(ResolveSayHelloCallbacks) static void ResolveSayHelloCallbacks(ReactCallback, ReactCallback) noexcept {/*implementation*/}\n" " REACT_METHOD(ResolveSayHelloCallbacks) static winrt::fire_and_forget ResolveSayHelloCallbacks(ReactCallback, ReactCallback) noexcept {/*implementation*/}\n"); REACT_SHOW_METHOD_SPEC_ERRORS( - 30, + 33, "RejectSayHelloCallbacks", " REACT_METHOD(RejectSayHelloCallbacks) void RejectSayHelloCallbacks(ReactCallback, ReactCallback) noexcept {/*implementation*/}\n" " REACT_METHOD(RejectSayHelloCallbacks) winrt::fire_and_forget RejectSayHelloCallbacks(ReactCallback, ReactCallback) noexcept {/*implementation*/}\n" " REACT_METHOD(RejectSayHelloCallbacks) static void RejectSayHelloCallbacks(ReactCallback, ReactCallback) noexcept {/*implementation*/}\n" " REACT_METHOD(RejectSayHelloCallbacks) static winrt::fire_and_forget RejectSayHelloCallbacks(ReactCallback, ReactCallback) noexcept {/*implementation*/}\n"); REACT_SHOW_METHOD_SPEC_ERRORS( - 31, + 34, "StaticDivideCallbacks", " REACT_METHOD(StaticDivideCallbacks) void StaticDivideCallbacks(int, int, ReactCallback, ReactCallback) noexcept {/*implementation*/}\n" " REACT_METHOD(StaticDivideCallbacks) winrt::fire_and_forget StaticDivideCallbacks(int, int, ReactCallback, ReactCallback) noexcept {/*implementation*/}\n" " REACT_METHOD(StaticDivideCallbacks) static void StaticDivideCallbacks(int, int, ReactCallback, ReactCallback) noexcept {/*implementation*/}\n" " REACT_METHOD(StaticDivideCallbacks) static winrt::fire_and_forget StaticDivideCallbacks(int, int, ReactCallback, ReactCallback) noexcept {/*implementation*/}\n"); REACT_SHOW_METHOD_SPEC_ERRORS( - 32, + 35, "StaticNegateCallbacks", " REACT_METHOD(StaticNegateCallbacks) void StaticNegateCallbacks(int, ReactCallback, ReactCallback) noexcept {/*implementation*/}\n" " REACT_METHOD(StaticNegateCallbacks) winrt::fire_and_forget StaticNegateCallbacks(int, ReactCallback, ReactCallback) noexcept {/*implementation*/}\n" " REACT_METHOD(StaticNegateCallbacks) static void StaticNegateCallbacks(int, ReactCallback, ReactCallback) noexcept {/*implementation*/}\n" " REACT_METHOD(StaticNegateCallbacks) static winrt::fire_and_forget StaticNegateCallbacks(int, ReactCallback, ReactCallback) noexcept {/*implementation*/}\n"); REACT_SHOW_METHOD_SPEC_ERRORS( - 33, + 36, "StaticNegateAsyncCallbacks", " REACT_METHOD(StaticNegateAsyncCallbacks) void StaticNegateAsyncCallbacks(int, ReactCallback, ReactCallback) noexcept {/*implementation*/}\n" " REACT_METHOD(StaticNegateAsyncCallbacks) winrt::fire_and_forget StaticNegateAsyncCallbacks(int, ReactCallback, ReactCallback) noexcept {/*implementation*/}\n" " REACT_METHOD(StaticNegateAsyncCallbacks) static void StaticNegateAsyncCallbacks(int, ReactCallback, ReactCallback) noexcept {/*implementation*/}\n" " REACT_METHOD(StaticNegateAsyncCallbacks) static winrt::fire_and_forget StaticNegateAsyncCallbacks(int, ReactCallback, ReactCallback) noexcept {/*implementation*/}\n"); REACT_SHOW_METHOD_SPEC_ERRORS( - 34, + 37, "StaticNegateDispatchQueueCallbacks", " REACT_METHOD(StaticNegateDispatchQueueCallbacks) void StaticNegateDispatchQueueCallbacks(int, ReactCallback, ReactCallback) noexcept {/*implementation*/}\n" " REACT_METHOD(StaticNegateDispatchQueueCallbacks) winrt::fire_and_forget StaticNegateDispatchQueueCallbacks(int, ReactCallback, ReactCallback) noexcept {/*implementation*/}\n" " REACT_METHOD(StaticNegateDispatchQueueCallbacks) static void StaticNegateDispatchQueueCallbacks(int, ReactCallback, ReactCallback) noexcept {/*implementation*/}\n" " REACT_METHOD(StaticNegateDispatchQueueCallbacks) static winrt::fire_and_forget StaticNegateDispatchQueueCallbacks(int, ReactCallback, ReactCallback) noexcept {/*implementation*/}\n"); REACT_SHOW_METHOD_SPEC_ERRORS( - 35, + 38, "StaticNegateFutureCallbacks", " REACT_METHOD(StaticNegateFutureCallbacks) void StaticNegateFutureCallbacks(int, ReactCallback, ReactCallback) noexcept {/*implementation*/}\n" " REACT_METHOD(StaticNegateFutureCallbacks) winrt::fire_and_forget StaticNegateFutureCallbacks(int, ReactCallback, ReactCallback) noexcept {/*implementation*/}\n" " REACT_METHOD(StaticNegateFutureCallbacks) static void StaticNegateFutureCallbacks(int, ReactCallback, ReactCallback) noexcept {/*implementation*/}\n" " REACT_METHOD(StaticNegateFutureCallbacks) static winrt::fire_and_forget StaticNegateFutureCallbacks(int, ReactCallback, ReactCallback) noexcept {/*implementation*/}\n"); REACT_SHOW_METHOD_SPEC_ERRORS( - 36, + 39, "StaticResolveSayHelloCallbacks", " REACT_METHOD(StaticResolveSayHelloCallbacks) void StaticResolveSayHelloCallbacks(ReactCallback, ReactCallback) noexcept {/*implementation*/}\n" " REACT_METHOD(StaticResolveSayHelloCallbacks) winrt::fire_and_forget StaticResolveSayHelloCallbacks(ReactCallback, ReactCallback) noexcept {/*implementation*/}\n" " REACT_METHOD(StaticResolveSayHelloCallbacks) static void StaticResolveSayHelloCallbacks(ReactCallback, ReactCallback) noexcept {/*implementation*/}\n" " REACT_METHOD(StaticResolveSayHelloCallbacks) static winrt::fire_and_forget StaticResolveSayHelloCallbacks(ReactCallback, ReactCallback) noexcept {/*implementation*/}\n"); REACT_SHOW_METHOD_SPEC_ERRORS( - 37, + 40, "StaticRejectSayHelloCallbacks", " REACT_METHOD(StaticRejectSayHelloCallbacks) void StaticRejectSayHelloCallbacks(ReactCallback, ReactCallback) noexcept {/*implementation*/}\n" " REACT_METHOD(StaticRejectSayHelloCallbacks) winrt::fire_and_forget StaticRejectSayHelloCallbacks(ReactCallback, ReactCallback) noexcept {/*implementation*/}\n" " REACT_METHOD(StaticRejectSayHelloCallbacks) static void StaticRejectSayHelloCallbacks(ReactCallback, ReactCallback) noexcept {/*implementation*/}\n" " REACT_METHOD(StaticRejectSayHelloCallbacks) static winrt::fire_and_forget StaticRejectSayHelloCallbacks(ReactCallback, ReactCallback) noexcept {/*implementation*/}\n"); REACT_SHOW_METHOD_SPEC_ERRORS( - 38, + 41, + "TwoCallbacksZeroArgs1", + " REACT_METHOD(TwoCallbacksZeroArgs1) void TwoCallbacksZeroArgs1(ReactCallback<>, ReactCallback<>) noexcept {/*implementation*/}\n" + " REACT_METHOD(TwoCallbacksZeroArgs1) winrt::fire_and_forget TwoCallbacksZeroArgs1(ReactCallback<>, ReactCallback<>) noexcept {/*implementation*/}\n" + " REACT_METHOD(TwoCallbacksZeroArgs1) static void TwoCallbacksZeroArgs1(ReactCallback<>, ReactCallback<>) noexcept {/*implementation*/}\n" + " REACT_METHOD(TwoCallbacksZeroArgs1) static winrt::fire_and_forget TwoCallbacksZeroArgs1(ReactCallback<>, ReactCallback<>) noexcept {/*implementation*/}\n"); + REACT_SHOW_METHOD_SPEC_ERRORS( + 42, + "TwoCallbacksZeroArgs2", + " REACT_METHOD(TwoCallbacksZeroArgs2) void TwoCallbacksZeroArgs2(ReactCallback<>, ReactCallback<>) noexcept {/*implementation*/}\n" + " REACT_METHOD(TwoCallbacksZeroArgs2) winrt::fire_and_forget TwoCallbacksZeroArgs2(ReactCallback<>, ReactCallback<>) noexcept {/*implementation*/}\n" + " REACT_METHOD(TwoCallbacksZeroArgs2) static void TwoCallbacksZeroArgs2(ReactCallback<>, ReactCallback<>) noexcept {/*implementation*/}\n" + " REACT_METHOD(TwoCallbacksZeroArgs2) static winrt::fire_and_forget TwoCallbacksZeroArgs2(ReactCallback<>, ReactCallback<>) noexcept {/*implementation*/}\n"); + REACT_SHOW_METHOD_SPEC_ERRORS( + 43, + "TwoCallbacksTwoArgs1", + " REACT_METHOD(TwoCallbacksTwoArgs1) void TwoCallbacksTwoArgs1(ReactCallback, ReactCallback) noexcept {/*implementation*/}\n" + " REACT_METHOD(TwoCallbacksTwoArgs1) winrt::fire_and_forget TwoCallbacksTwoArgs1(ReactCallback, ReactCallback) noexcept {/*implementation*/}\n" + " REACT_METHOD(TwoCallbacksTwoArgs1) static void TwoCallbacksTwoArgs1(ReactCallback, ReactCallback) noexcept {/*implementation*/}\n" + " REACT_METHOD(TwoCallbacksTwoArgs1) static winrt::fire_and_forget TwoCallbacksTwoArgs1(ReactCallback, ReactCallback) noexcept {/*implementation*/}\n"); + REACT_SHOW_METHOD_SPEC_ERRORS( + 44, + "TwoCallbacksTwoArgs2", + " REACT_METHOD(TwoCallbacksTwoArgs2) void TwoCallbacksTwoArgs2(ReactCallback, ReactCallback) noexcept {/*implementation*/}\n" + " REACT_METHOD(TwoCallbacksTwoArgs2) winrt::fire_and_forget TwoCallbacksTwoArgs2(ReactCallback, ReactCallback) noexcept {/*implementation*/}\n" + " REACT_METHOD(TwoCallbacksTwoArgs2) static void TwoCallbacksTwoArgs2(ReactCallback, ReactCallback) noexcept {/*implementation*/}\n" + " REACT_METHOD(TwoCallbacksTwoArgs2) static winrt::fire_and_forget TwoCallbacksTwoArgs2(ReactCallback, ReactCallback) noexcept {/*implementation*/}\n"); + REACT_SHOW_METHOD_SPEC_ERRORS( + 45, + "TwoCallbacksThreeArgs1", + " REACT_METHOD(TwoCallbacksThreeArgs1) void TwoCallbacksThreeArgs1(ReactCallback, ReactCallback) noexcept {/*implementation*/}\n" + " REACT_METHOD(TwoCallbacksThreeArgs1) winrt::fire_and_forget TwoCallbacksThreeArgs1(ReactCallback, ReactCallback) noexcept {/*implementation*/}\n" + " REACT_METHOD(TwoCallbacksThreeArgs1) static void TwoCallbacksThreeArgs1(ReactCallback, ReactCallback) noexcept {/*implementation*/}\n" + " REACT_METHOD(TwoCallbacksThreeArgs1) static winrt::fire_and_forget TwoCallbacksThreeArgs1(ReactCallback, ReactCallback) noexcept {/*implementation*/}\n"); + REACT_SHOW_METHOD_SPEC_ERRORS( + 46, + "TwoCallbacksThreeArgs2", + " REACT_METHOD(TwoCallbacksThreeArgs2) void TwoCallbacksThreeArgs2(ReactCallback, ReactCallback) noexcept {/*implementation*/}\n" + " REACT_METHOD(TwoCallbacksThreeArgs2) winrt::fire_and_forget TwoCallbacksThreeArgs2(ReactCallback, ReactCallback) noexcept {/*implementation*/}\n" + " REACT_METHOD(TwoCallbacksThreeArgs2) static void TwoCallbacksThreeArgs2(ReactCallback, ReactCallback) noexcept {/*implementation*/}\n" + " REACT_METHOD(TwoCallbacksThreeArgs2) static winrt::fire_and_forget TwoCallbacksThreeArgs2(ReactCallback, ReactCallback) noexcept {/*implementation*/}\n"); + REACT_SHOW_METHOD_SPEC_ERRORS( + 47, "DividePromise", " REACT_METHOD(DividePromise) void DividePromise(int, int, ReactPromise) noexcept {/*implementation*/}\n" " REACT_METHOD(DividePromise) winrt::fire_and_forget DividePromise(int, int, ReactPromise) noexcept {/*implementation*/}\n" " REACT_METHOD(DividePromise) static void DividePromise(int, int, ReactPromise) noexcept {/*implementation*/}\n" " REACT_METHOD(DividePromise) static winrt::fire_and_forget DividePromise(int, int, ReactPromise) noexcept {/*implementation*/}\n"); REACT_SHOW_METHOD_SPEC_ERRORS( - 39, + 48, "NegatePromise", " REACT_METHOD(NegatePromise) void NegatePromise(int, ReactPromise) noexcept {/*implementation*/}\n" " REACT_METHOD(NegatePromise) winrt::fire_and_forget NegatePromise(int, ReactPromise) noexcept {/*implementation*/}\n" " REACT_METHOD(NegatePromise) static void NegatePromise(int, ReactPromise) noexcept {/*implementation*/}\n" " REACT_METHOD(NegatePromise) static winrt::fire_and_forget NegatePromise(int, ReactPromise) noexcept {/*implementation*/}\n"); REACT_SHOW_METHOD_SPEC_ERRORS( - 40, + 49, "NegateAsyncPromise", " REACT_METHOD(NegateAsyncPromise) void NegateAsyncPromise(int, ReactPromise) noexcept {/*implementation*/}\n" " REACT_METHOD(NegateAsyncPromise) winrt::fire_and_forget NegateAsyncPromise(int, ReactPromise) noexcept {/*implementation*/}\n" " REACT_METHOD(NegateAsyncPromise) static void NegateAsyncPromise(int, ReactPromise) noexcept {/*implementation*/}\n" " REACT_METHOD(NegateAsyncPromise) static winrt::fire_and_forget NegateAsyncPromise(int, ReactPromise) noexcept {/*implementation*/}\n"); REACT_SHOW_METHOD_SPEC_ERRORS( - 41, + 50, "NegateDispatchQueuePromise", " REACT_METHOD(NegateDispatchQueuePromise) void NegateDispatchQueuePromise(int, ReactPromise) noexcept {/*implementation*/}\n" " REACT_METHOD(NegateDispatchQueuePromise) winrt::fire_and_forget NegateDispatchQueuePromise(int, ReactPromise) noexcept {/*implementation*/}\n" " REACT_METHOD(NegateDispatchQueuePromise) static void NegateDispatchQueuePromise(int, ReactPromise) noexcept {/*implementation*/}\n" " REACT_METHOD(NegateDispatchQueuePromise) static winrt::fire_and_forget NegateDispatchQueuePromise(int, ReactPromise) noexcept {/*implementation*/}\n"); REACT_SHOW_METHOD_SPEC_ERRORS( - 42, + 51, "NegateFuturePromise", " REACT_METHOD(NegateFuturePromise) void NegateFuturePromise(int, ReactPromise) noexcept {/*implementation*/}\n" " REACT_METHOD(NegateFuturePromise) winrt::fire_and_forget NegateFuturePromise(int, ReactPromise) noexcept {/*implementation*/}\n" " REACT_METHOD(NegateFuturePromise) static void NegateFuturePromise(int, ReactPromise) noexcept {/*implementation*/}\n" " REACT_METHOD(NegateFuturePromise) static winrt::fire_and_forget NegateFuturePromise(int, ReactPromise) noexcept {/*implementation*/}\n"); REACT_SHOW_METHOD_SPEC_ERRORS( - 43, + 52, "voidPromise", " REACT_METHOD(voidPromise) void voidPromise(int, ReactPromise) noexcept {/*implementation*/}\n" " REACT_METHOD(voidPromise) winrt::fire_and_forget voidPromise(int, ReactPromise) noexcept {/*implementation*/}\n" " REACT_METHOD(voidPromise) static void voidPromise(int, ReactPromise) noexcept {/*implementation*/}\n" " REACT_METHOD(voidPromise) static winrt::fire_and_forget voidPromise(int, ReactPromise) noexcept {/*implementation*/}\n"); REACT_SHOW_METHOD_SPEC_ERRORS( - 44, + 53, "ResolveSayHelloPromise", " REACT_METHOD(ResolveSayHelloPromise) void ResolveSayHelloPromise(ReactPromise) noexcept {/*implementation*/}\n" " REACT_METHOD(ResolveSayHelloPromise) winrt::fire_and_forget ResolveSayHelloPromise(ReactPromise) noexcept {/*implementation*/}\n" " REACT_METHOD(ResolveSayHelloPromise) static void ResolveSayHelloPromise(ReactPromise) noexcept {/*implementation*/}\n" " REACT_METHOD(ResolveSayHelloPromise) static winrt::fire_and_forget ResolveSayHelloPromise(ReactPromise) noexcept {/*implementation*/}\n"); REACT_SHOW_METHOD_SPEC_ERRORS( - 45, + 54, "RejectSayHelloPromise", " REACT_METHOD(RejectSayHelloPromise) void RejectSayHelloPromise(ReactPromise) noexcept {/*implementation*/}\n" " REACT_METHOD(RejectSayHelloPromise) winrt::fire_and_forget RejectSayHelloPromise(ReactPromise) noexcept {/*implementation*/}\n" " REACT_METHOD(RejectSayHelloPromise) static void RejectSayHelloPromise(ReactPromise) noexcept {/*implementation*/}\n" " REACT_METHOD(RejectSayHelloPromise) static winrt::fire_and_forget RejectSayHelloPromise(ReactPromise) noexcept {/*implementation*/}\n"); REACT_SHOW_METHOD_SPEC_ERRORS( - 46, + 55, "StaticDividePromise", " REACT_METHOD(StaticDividePromise) void StaticDividePromise(int, int, ReactPromise) noexcept {/*implementation*/}\n" " REACT_METHOD(StaticDividePromise) winrt::fire_and_forget StaticDividePromise(int, int, ReactPromise) noexcept {/*implementation*/}\n" " REACT_METHOD(StaticDividePromise) static void StaticDividePromise(int, int, ReactPromise) noexcept {/*implementation*/}\n" " REACT_METHOD(StaticDividePromise) static winrt::fire_and_forget StaticDividePromise(int, int, ReactPromise) noexcept {/*implementation*/}\n"); REACT_SHOW_METHOD_SPEC_ERRORS( - 47, + 56, "StaticNegatePromise", " REACT_METHOD(StaticNegatePromise) void StaticNegatePromise(int, ReactPromise) noexcept {/*implementation*/}\n" " REACT_METHOD(StaticNegatePromise) winrt::fire_and_forget StaticNegatePromise(int, ReactPromise) noexcept {/*implementation*/}\n" " REACT_METHOD(StaticNegatePromise) static void StaticNegatePromise(int, ReactPromise) noexcept {/*implementation*/}\n" " REACT_METHOD(StaticNegatePromise) static winrt::fire_and_forget StaticNegatePromise(int, ReactPromise) noexcept {/*implementation*/}\n"); REACT_SHOW_METHOD_SPEC_ERRORS( - 48, + 57, "StaticNegateAsyncPromise", " REACT_METHOD(StaticNegateAsyncPromise) void StaticNegateAsyncPromise(int, ReactPromise) noexcept {/*implementation*/}\n" " REACT_METHOD(StaticNegateAsyncPromise) winrt::fire_and_forget StaticNegateAsyncPromise(int, ReactPromise) noexcept {/*implementation*/}\n" " REACT_METHOD(StaticNegateAsyncPromise) static void StaticNegateAsyncPromise(int, ReactPromise) noexcept {/*implementation*/}\n" " REACT_METHOD(StaticNegateAsyncPromise) static winrt::fire_and_forget StaticNegateAsyncPromise(int, ReactPromise) noexcept {/*implementation*/}\n"); REACT_SHOW_METHOD_SPEC_ERRORS( - 49, + 58, "StaticNegateDispatchQueuePromise", " REACT_METHOD(StaticNegateDispatchQueuePromise) void StaticNegateDispatchQueuePromise(int, ReactPromise) noexcept {/*implementation*/}\n" " REACT_METHOD(StaticNegateDispatchQueuePromise) winrt::fire_and_forget StaticNegateDispatchQueuePromise(int, ReactPromise) noexcept {/*implementation*/}\n" " REACT_METHOD(StaticNegateDispatchQueuePromise) static void StaticNegateDispatchQueuePromise(int, ReactPromise) noexcept {/*implementation*/}\n" " REACT_METHOD(StaticNegateDispatchQueuePromise) static winrt::fire_and_forget StaticNegateDispatchQueuePromise(int, ReactPromise) noexcept {/*implementation*/}\n"); REACT_SHOW_METHOD_SPEC_ERRORS( - 50, + 59, "StaticNegateFuturePromise", " REACT_METHOD(StaticNegateFuturePromise) void StaticNegateFuturePromise(int, ReactPromise) noexcept {/*implementation*/}\n" " REACT_METHOD(StaticNegateFuturePromise) winrt::fire_and_forget StaticNegateFuturePromise(int, ReactPromise) noexcept {/*implementation*/}\n" " REACT_METHOD(StaticNegateFuturePromise) static void StaticNegateFuturePromise(int, ReactPromise) noexcept {/*implementation*/}\n" " REACT_METHOD(StaticNegateFuturePromise) static winrt::fire_and_forget StaticNegateFuturePromise(int, ReactPromise) noexcept {/*implementation*/}\n"); REACT_SHOW_METHOD_SPEC_ERRORS( - 51, + 60, "staticVoidPromise", " REACT_METHOD(staticVoidPromise) void staticVoidPromise(int, ReactPromise) noexcept {/*implementation*/}\n" " REACT_METHOD(staticVoidPromise) winrt::fire_and_forget staticVoidPromise(int, ReactPromise) noexcept {/*implementation*/}\n" " REACT_METHOD(staticVoidPromise) static void staticVoidPromise(int, ReactPromise) noexcept {/*implementation*/}\n" " REACT_METHOD(staticVoidPromise) static winrt::fire_and_forget staticVoidPromise(int, ReactPromise) noexcept {/*implementation*/}\n"); REACT_SHOW_METHOD_SPEC_ERRORS( - 52, + 61, "StaticResolveSayHelloPromise", " REACT_METHOD(StaticResolveSayHelloPromise) void StaticResolveSayHelloPromise(ReactPromise) noexcept {/*implementation*/}\n" " REACT_METHOD(StaticResolveSayHelloPromise) winrt::fire_and_forget StaticResolveSayHelloPromise(ReactPromise) noexcept {/*implementation*/}\n" " REACT_METHOD(StaticResolveSayHelloPromise) static void StaticResolveSayHelloPromise(ReactPromise) noexcept {/*implementation*/}\n" " REACT_METHOD(StaticResolveSayHelloPromise) static winrt::fire_and_forget StaticResolveSayHelloPromise(ReactPromise) noexcept {/*implementation*/}\n"); REACT_SHOW_METHOD_SPEC_ERRORS( - 53, + 62, "StaticRejectSayHelloPromise", " REACT_METHOD(StaticRejectSayHelloPromise) void StaticRejectSayHelloPromise(ReactPromise) noexcept {/*implementation*/}\n" " REACT_METHOD(StaticRejectSayHelloPromise) winrt::fire_and_forget StaticRejectSayHelloPromise(ReactPromise) noexcept {/*implementation*/}\n" " REACT_METHOD(StaticRejectSayHelloPromise) static void StaticRejectSayHelloPromise(ReactPromise) noexcept {/*implementation*/}\n" " REACT_METHOD(StaticRejectSayHelloPromise) static winrt::fire_and_forget StaticRejectSayHelloPromise(ReactPromise) noexcept {/*implementation*/}\n"); REACT_SHOW_SYNC_METHOD_SPEC_ERRORS( - 54, + 63, "AddSync", " REACT_METHOD(AddSync) int AddSync(int, int) noexcept {/*implementation*/}\n" " REACT_METHOD(AddSync) static int AddSync(int, int) noexcept {/*implementation*/}\n"); REACT_SHOW_SYNC_METHOD_SPEC_ERRORS( - 55, + 64, "NegateSync", " REACT_METHOD(NegateSync) int NegateSync(int) noexcept {/*implementation*/}\n" " REACT_METHOD(NegateSync) static int NegateSync(int) noexcept {/*implementation*/}\n"); REACT_SHOW_SYNC_METHOD_SPEC_ERRORS( - 56, + 65, "SayHelloSync", " REACT_METHOD(SayHelloSync) std::string SayHelloSync() noexcept {/*implementation*/}\n" " REACT_METHOD(SayHelloSync) static std::string SayHelloSync() noexcept {/*implementation*/}\n"); REACT_SHOW_SYNC_METHOD_SPEC_ERRORS( - 57, + 66, "StaticAddSync", " REACT_METHOD(StaticAddSync) int StaticAddSync(int, int) noexcept {/*implementation*/}\n" " REACT_METHOD(StaticAddSync) static int StaticAddSync(int, int) noexcept {/*implementation*/}\n"); REACT_SHOW_SYNC_METHOD_SPEC_ERRORS( - 58, + 67, "StaticNegateSync", " REACT_METHOD(StaticNegateSync) int StaticNegateSync(int) noexcept {/*implementation*/}\n" " REACT_METHOD(StaticNegateSync) static int StaticNegateSync(int) noexcept {/*implementation*/}\n"); REACT_SHOW_SYNC_METHOD_SPEC_ERRORS( - 59, + 68, "StaticSayHelloSync", " REACT_METHOD(StaticSayHelloSync) std::string StaticSayHelloSync() noexcept {/*implementation*/}\n" " REACT_METHOD(StaticSayHelloSync) static std::string StaticSayHelloSync() noexcept {/*implementation*/}\n"); @@ -1265,6 +1394,30 @@ TEST_CLASS (TurboModuleTest) { TestCheck(m_builderMock.IsResolveCallbackCalled()); } + TEST_METHOD(TestMethodCall_CallbackZeroArgs) { + m_builderMock.Call1(L"CallbackZeroArgs", std::function([]() noexcept {})); + TestCheck(m_builderMock.IsResolveCallbackCalled()); + } + + TEST_METHOD(TestMethodCall_CallbackTwoArgs) { + m_builderMock.Call1(L"CallbackTwoArgs", std::function([](int p1, int p2) noexcept { + TestCheckEqual(1, p1); + TestCheckEqual(2, p2); + })); + TestCheck(m_builderMock.IsResolveCallbackCalled()); + } + + TEST_METHOD(TestMethodCall_CallbackThreeArgs) { + m_builderMock.Call1( + L"CallbackThreeArgs", + std::function([](int p1, int p2, std::string const &p3) noexcept { + TestCheckEqual(1, p1); + TestCheckEqual(2, p2); + TestCheckEqual("Hello", p3); + })); + TestCheck(m_builderMock.IsResolveCallbackCalled()); + } + TEST_METHOD(TestMethodCall_DivideCallbacks) { m_builderMock.Call2( L"DivideCallbacks", @@ -1509,6 +1662,68 @@ TEST_CLASS (TurboModuleTest) { TestCheck(m_builderMock.IsRejectCallbackCalled()); } + TEST_METHOD(TestMethodCall_TwoCallbacksZeroArgs1) { + m_builderMock.Call2(L"TwoCallbacksZeroArgs1", std::function([]() noexcept {}), std::function([ + ]() noexcept { TestCheckFail(); })); + TestCheck(m_builderMock.IsResolveCallbackCalled()); + } + + TEST_METHOD(TestMethodCall_TwoCallbacksZeroArgs2) { + m_builderMock.Call2( + L"TwoCallbacksZeroArgs2", + std::function([]() noexcept { TestCheckFail(); }), + std::function([]() noexcept {})); + TestCheck(m_builderMock.IsRejectCallbackCalled()); + } + + TEST_METHOD(TestMethodCall_TwoCallbacksTwoArgs1) { + m_builderMock.Call2( + L"TwoCallbacksTwoArgs1", + std::function([](int p1, int p2) noexcept { + TestCheckEqual(1, p1); + TestCheckEqual(2, p2); + }), + std::function([](int /*p1*/, int /*p2*/) noexcept { TestCheckFail(); })); + TestCheck(m_builderMock.IsResolveCallbackCalled()); + } + + TEST_METHOD(TestMethodCall_TwoCallbacksTwoArgs2) { + m_builderMock.Call2( + L"TwoCallbacksTwoArgs2", + std::function([](int /*p1*/, int /*p2*/) noexcept { TestCheckFail(); }), + std::function([](int p1, int p2) noexcept { + TestCheckEqual(1, p1); + TestCheckEqual(2, p2); + })); + TestCheck(m_builderMock.IsRejectCallbackCalled()); + } + + TEST_METHOD(TestMethodCall_TwoCallbacksThreeArgs1) { + m_builderMock.Call2( + L"TwoCallbacksThreeArgs1", + std::function([](int p1, int p2, std::string const &p3) noexcept { + TestCheckEqual(1, p1); + TestCheckEqual(2, p2); + TestCheckEqual("Hello", p3); + }), + std::function( + [](int /*p1*/, int /*p2*/, std::string const & /*p3*/) noexcept { TestCheckFail(); })); + TestCheck(m_builderMock.IsResolveCallbackCalled()); + } + + TEST_METHOD(TestMethodCall_TwoCallbacksThreeArgs2) { + m_builderMock.Call2( + L"TwoCallbacksThreeArgs2", + std::function( + [](int /*p1*/, int /*p2*/, std::string const & /*p3*/) noexcept { TestCheckFail(); }), + std::function([](int p1, int p2, std::string const &p3) noexcept { + TestCheckEqual(1, p1); + TestCheckEqual(2, p2); + TestCheckEqual("Hello", p3); + })); + TestCheck(m_builderMock.IsRejectCallbackCalled()); + } + TEST_METHOD(TestMethodCall_DividePromise) { m_builderMock.Call2( L"DividePromise", diff --git a/vnext/Microsoft.ReactNative.Cxx/NativeModules.h b/vnext/Microsoft.ReactNative.Cxx/NativeModules.h index 3e590f3037c..6d76e18f4ca 100644 --- a/vnext/Microsoft.ReactNative.Cxx/NativeModules.h +++ b/vnext/Microsoft.ReactNative.Cxx/NativeModules.h @@ -205,6 +205,7 @@ struct GetCallbackSignatureImpl> { template struct CallbackCreator; +// Callback signature without noexcept template