fix: align variant fixtures with generated specs

mrousavy · mrousavy · commit 7af0ecc4413e · 2026-06-29T22:46:03.000+02:00
diff --git a/example/src/getTests.ts b/example/src/getTests.ts
@@ -1174,9 +1174,11 @@ export function getTests(
       // @ts-expect-error
       it(() => testObject.bounceVariantUnionEnum({})).didThrow()
     ),
-    createTest('bounceVariantUnionEnum(...) throws at wrong type (boolean)', () =>
-      // @ts-expect-error
-      it(() => testObject.bounceVariantUnionEnum(true)).didThrow()
+    createTest(
+      'bounceVariantUnionEnum(...) throws at wrong type (boolean)',
+      () =>
+        // @ts-expect-error
+        it(() => testObject.bounceVariantUnionEnum(true)).didThrow()
     ),
     createTest('getVariantWeirdNumbersEnum(...) converts enum', () =>
       it(() => testObject.getVariantWeirdNumbersEnum(WeirdNumbersEnum.C))
@@ -1261,18 +1263,23 @@ export function getTests(
           testObject.getVariantHybrid({ someValue: 55 })
         ).didThrow()
     ),
-    createTest('getVariantHybridEnum(...) converts Hybrid', () =>
-      // @ts-expect-error TypeScript spazzes out since it can be both types of HybridObject
-      it(() => testObject.getVariantHybridEnum(testObject))
-        .didNotThrow()
-        // @ts-expect-error
-        .toContain('getVariantHybridEnum')
-    ),
-    createTest('getVariantHybridEnum(...) converts string union enum', () =>
-      it(() => testObject.getVariantHybridEnum('electric'))
-        .didNotThrow()
-        .equals('electric')
-    ),
+    ...('getVariantHybridEnum' in testObject
+      ? [
+          createTest('getVariantHybridEnum(...) converts Hybrid', () =>
+            it(() => testObject.getVariantHybridEnum(testObject))
+              .didNotThrow()
+              // @ts-expect-error Assertion typing does not preserve HybridObject keys here.
+              .toContain('getVariantHybridEnum')
+          ),
+          createTest(
+            'getVariantHybridEnum(...) converts string union enum',
+            () =>
+              it(() => testObject.getVariantHybridEnum('electric'))
+                .didNotThrow()
+                .equals('electric')
+          ),
+        ]
+      : []),
     createTest('passNamedVariant(...) works', () =>
       it(() => testObject.passNamedVariant('Hello world!'))
         .didNotThrow()
diff --git a/packages/react-native-nitro-test/android/src/main/java/com/margelo/nitro/test/HybridTestObjectKotlin.kt b/packages/react-native-nitro-test/android/src/main/java/com/margelo/nitro/test/HybridTestObjectKotlin.kt
@@ -30,7 +30,7 @@ class HybridTestObjectKotlin : HybridTestObjectSwiftKotlinSpec() {
   override var optionalHybrid: HybridTestObjectSwiftKotlinSpec? = null
   override val thisObject: HybridTestObjectSwiftKotlinSpec
     get() = this
-  override var someVariant: Variant_String_Double = Variant_String_Double.create(55.05)
+  override var someVariant: Variant_Double_String = Variant_Double_String.create(55.05)
   override var optionalArray: Array<String>? = null
   override var optionalEnum: Powertrain? = null
   override var optionalOldEnum: OldEnum? = null
@@ -497,13 +497,13 @@ class HybridTestObjectKotlin : HybridTestObjectSwiftKotlinSpec() {
     return Promise.async { createArrayBuffer() }
   }
 
-  override fun passVariant(either: Variant_Boolean_DoubleArray_Array_String__String_Double): Variant_String_Double {
+  override fun passVariant(either: Variant_Boolean_DoubleArray_Array_String__Double_String): Variant_Double_String {
     return either.match(
-      { bool -> Variant_String_Double.create("holds something else!") },
-      { doubleArray -> Variant_String_Double.create("holds something else!") },
-      { stringArray -> Variant_String_Double.create("holds something else!") },
-      { string -> Variant_String_Double.create(string) },
-      { double -> Variant_String_Double.create(double) },
+      { bool -> Variant_Double_String.create("holds something else!") },
+      { doubleArray -> Variant_Double_String.create("holds something else!") },
+      { stringArray -> Variant_Double_String.create("holds something else!") },
+      { double -> Variant_Double_String.create(double) },
+      { string -> Variant_Double_String.create(string) },
     )
   }
 
@@ -515,19 +515,19 @@ class HybridTestObjectKotlin : HybridTestObjectSwiftKotlinSpec() {
     return variant
   }
 
-  override fun getVariantEnum(variant: Variant_Boolean_OldEnum): Variant_Boolean_OldEnum {
+  override fun getVariantEnum(variant: Variant_OldEnum_Boolean): Variant_OldEnum_Boolean {
     return variant
   }
 
   override fun bounceVariantUnionEnum(variant: Variant_Powertrain_Car): Variant_Powertrain_Car {
     return variant
   }
 
-  override fun getVariantWeirdNumbersEnum(variant: Variant_Boolean_WeirdNumbersEnum): Variant_Boolean_WeirdNumbersEnum {
+  override fun getVariantWeirdNumbersEnum(variant: Variant_WeirdNumbersEnum_Boolean): Variant_WeirdNumbersEnum_Boolean {
     return variant
   }
 
-  override fun getVariantObjects(variant: Variant_Car_Person): Variant_Car_Person {
+  override fun getVariantObjects(variant: Variant_Person_Car): Variant_Person_Car {
     return variant
   }
 
diff --git a/packages/react-native-nitro-test/cpp/HybridTestObjectCpp.cpp b/packages/react-native-nitro-test/cpp/HybridTestObjectCpp.cpp
@@ -107,11 +107,11 @@ void HybridTestObjectCpp::setOptionalHybrid(const std::optional<std::shared_ptr<
   _optionalHybrid = optionalHybrid;
 }
 
-std::variant<std::string, double> HybridTestObjectCpp::getSomeVariant() {
+std::variant<double, std::string> HybridTestObjectCpp::getSomeVariant() {
   return _variant;
 }
 
-void HybridTestObjectCpp::setSomeVariant(const std::variant<std::string, double>& variant) {
+void HybridTestObjectCpp::setSomeVariant(const std::variant<double, std::string>& variant) {
   _variant = variant;
 }
 
@@ -366,8 +366,8 @@ std::chrono::system_clock::time_point HybridTestObjectCpp::currentDate() {
   return std::chrono::system_clock::now();
 }
 
-std::variant<std::string, double>
-HybridTestObjectCpp::passVariant(const std::variant<bool, std::vector<double>, std::vector<std::string>, std::string, double>& either) {
+std::variant<double, std::string>
+HybridTestObjectCpp::passVariant(const std::variant<bool, std::vector<double>, std::vector<std::string>, double, std::string>& either) {
   if (std::holds_alternative<std::string>(either)) {
     return std::get<std::string>(either);
   } else if (std::holds_alternative<double>(either)) {
@@ -386,19 +386,19 @@ ComplexVariant HybridTestObjectCpp::bounceComplexVariant(const ComplexVariant& v
   return variant;
 }
 
-std::variant<bool, OldEnum> HybridTestObjectCpp::getVariantEnum(const std::variant<bool, OldEnum>& variant) {
+std::variant<OldEnum, bool> HybridTestObjectCpp::getVariantEnum(const std::variant<OldEnum, bool>& variant) {
   return variant;
 }
 
 std::variant<Powertrain, Car> HybridTestObjectCpp::bounceVariantUnionEnum(const std::variant<Powertrain, Car>& variant) {
   return variant;
 }
 
-std::variant<bool, WeirdNumbersEnum> HybridTestObjectCpp::getVariantWeirdNumbersEnum(const std::variant<bool, WeirdNumbersEnum>& variant) {
+std::variant<WeirdNumbersEnum, bool> HybridTestObjectCpp::getVariantWeirdNumbersEnum(const std::variant<WeirdNumbersEnum, bool>& variant) {
   return variant;
 }
 
-std::variant<Car, Person> HybridTestObjectCpp::getVariantObjects(const std::variant<Car, Person>& variant) {
+std::variant<Person, Car> HybridTestObjectCpp::getVariantObjects(const std::variant<Person, Car>& variant) {
   return variant;
 }
 
diff --git a/packages/react-native-nitro-test/cpp/HybridTestObjectCpp.hpp b/packages/react-native-nitro-test/cpp/HybridTestObjectCpp.hpp
@@ -32,7 +32,7 @@ class HybridTestObjectCpp : public HybridTestObjectCppSpec {
   NullType _null = nitro::null;
   std::optional<std::string> _optionalString;
   std::variant<nitro::NullType, std::string> _nullableString;
-  std::variant<std::string, double> _variant;
+  std::variant<double, std::string> _variant;
   std::tuple<double, std::string> _tuple;
   std::optional<std::vector<std::string>> _optionalArray;
   std::optional<std::shared_ptr<HybridTestObjectCppSpec>> _optionalHybrid;
@@ -74,8 +74,8 @@ class HybridTestObjectCpp : public HybridTestObjectCppSpec {
   void setStringOrNull(const std::variant<nitro::NullType, std::string>& stringOrNull) override;
   std::optional<std::vector<std::string>> getOptionalArray() override;
   void setOptionalArray(const std::optional<std::vector<std::string>>& optionalArray) override;
-  std::variant<std::string, double> getSomeVariant() override;
-  void setSomeVariant(const std::variant<std::string, double>& variant) override;
+  std::variant<double, std::string> getSomeVariant() override;
+  void setSomeVariant(const std::variant<double, std::string>& variant) override;
   std::variant<std::string, Car> passNamedVariant(const std::variant<std::string, Car>& variant) override;
   std::variant<std::shared_ptr<HybridBaseSpec>, OptionalWrapper>
   passAllEmptyObjectVariant(const std::variant<std::shared_ptr<HybridBaseSpec>, OptionalWrapper>& variant) override;
@@ -121,8 +121,8 @@ class HybridTestObjectCpp : public HybridTestObjectCppSpec {
   bool tryTrailingOptional(double num, const std::string& str, std::optional<bool> boo) override;
   std::chrono::system_clock::time_point add1Hour(std::chrono::system_clock::time_point date) override;
   std::chrono::system_clock::time_point currentDate() override;
-  std::variant<std::string, double>
-  passVariant(const std::variant<bool, std::vector<double>, std::vector<std::string>, std::string, double>& either) override;
+  std::variant<double, std::string>
+  passVariant(const std::variant<bool, std::vector<double>, std::vector<std::string>, double, std::string>& either) override;
 
   std::vector<std::string> bounceStrings(const std::vector<std::string>& array) override;
   std::vector<double> bounceNumbers(const std::vector<double>& array) override;
@@ -140,10 +140,10 @@ class HybridTestObjectCpp : public HybridTestObjectCppSpec {
   std::vector<std::shared_ptr<Promise<double>>> bouncePromises(const std::vector<std::shared_ptr<Promise<double>>>& promises) override;
   std::vector<std::shared_ptr<ArrayBuffer>> bounceArrayBuffers(const std::vector<std::shared_ptr<ArrayBuffer>>& arrayBuffers) override;
 
-  std::variant<bool, OldEnum> getVariantEnum(const std::variant<bool, OldEnum>& variant) override;
+  std::variant<OldEnum, bool> getVariantEnum(const std::variant<OldEnum, bool>& variant) override;
   std::variant<Powertrain, Car> bounceVariantUnionEnum(const std::variant<Powertrain, Car>& variant) override;
-  std::variant<bool, WeirdNumbersEnum> getVariantWeirdNumbersEnum(const std::variant<bool, WeirdNumbersEnum>& variant) override;
-  std::variant<Car, Person> getVariantObjects(const std::variant<Car, Person>& variant) override;
+  std::variant<WeirdNumbersEnum, bool> getVariantWeirdNumbersEnum(const std::variant<WeirdNumbersEnum, bool>& variant) override;
+  std::variant<Person, Car> getVariantObjects(const std::variant<Person, Car>& variant) override;
   std::variant<std::shared_ptr<HybridTestObjectCppSpec>, Person>
   getVariantHybrid(const std::variant<std::shared_ptr<HybridTestObjectCppSpec>, Person>& variant) override;
   std::variant<std::shared_ptr<HybridTestObjectCppSpec>, Powertrain>
diff --git a/packages/react-native-nitro-test/ios/HybridTestObjectSwift.swift b/packages/react-native-nitro-test/ios/HybridTestObjectSwift.swift
@@ -11,7 +11,7 @@ import NitroTestExternal
 class HybridTestObjectSwift: HybridTestObjectSwiftKotlinSpec {
   var optionalArray: [String]? = []
 
-  var someVariant: Variant_String_Double = .second(55)
+  var someVariant: Variant_Double_String = .first(55)
 
   var numberValue: Double = 0.0
 
@@ -338,16 +338,16 @@ class HybridTestObjectSwift: HybridTestObjectSwiftKotlinSpec {
     return variant
   }
 
-  func passVariant(either: Variant_Bool__Double___String__String_Double) throws
-    -> Variant_String_Double
+  func passVariant(either: Variant_Bool__Double___String__Double_String) throws
+    -> Variant_Double_String
   {
     switch either {
-    case .fourth(let string):
-      return .first(string)
-    case .fifth(let double):
-      return .second(double)
+    case .fourth(let double):
+      return .first(double)
+    case .fifth(let string):
+      return .second(string)
     default:
-      return .first("holds something else!")
+      return .second("holds something else!")
     }
   }
 
@@ -361,21 +361,21 @@ class HybridTestObjectSwift: HybridTestObjectSwiftKotlinSpec {
     return variant
   }
 
-  func getVariantEnum(variant: Variant_Bool_OldEnum) throws -> Variant_Bool_OldEnum {
+  func getVariantEnum(variant: Variant_OldEnum_Bool) throws -> Variant_OldEnum_Bool {
     return variant
   }
 
   func bounceVariantUnionEnum(variant: Variant_Powertrain_Car) throws -> Variant_Powertrain_Car {
     return variant
   }
 
-  func getVariantWeirdNumbersEnum(variant: Variant_Bool_WeirdNumbersEnum) throws
-    -> Variant_Bool_WeirdNumbersEnum
+  func getVariantWeirdNumbersEnum(variant: Variant_WeirdNumbersEnum_Bool) throws
+    -> Variant_WeirdNumbersEnum_Bool
   {
     return variant
   }
 
-  func getVariantObjects(variant: Variant_Car_Person) throws -> Variant_Car_Person {
+  func getVariantObjects(variant: Variant_Person_Car) throws -> Variant_Person_Car {
     return variant
   }
 

Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,7 @@ class HybridTestObjectKotlin : HybridTestObjectSwiftKotlinSpec() {`
`30`	`30`	`override var optionalHybrid: HybridTestObjectSwiftKotlinSpec? = null`
`31`	`31`	`override val thisObject: HybridTestObjectSwiftKotlinSpec`
`32`	`32`	`get() = this`
`33`		`- override var someVariant: Variant_String_Double = Variant_String_Double.create(55.05)`
	`33`	`+ override var someVariant: Variant_Double_String = Variant_Double_String.create(55.05)`
`34`	`34`	`override var optionalArray: Array<String>? = null`
`35`	`35`	`override var optionalEnum: Powertrain? = null`
`36`	`36`	`override var optionalOldEnum: OldEnum? = null`
`@@ -497,13 +497,13 @@ class HybridTestObjectKotlin : HybridTestObjectSwiftKotlinSpec() {`
`497`	`497`	`return Promise.async { createArrayBuffer() }`
`498`	`498`	`}`
`499`	`499`
`500`		`- override fun passVariant(either: Variant_Boolean_DoubleArray_Array_String__String_Double): Variant_String_Double {`
	`500`	`+ override fun passVariant(either: Variant_Boolean_DoubleArray_Array_String__Double_String): Variant_Double_String {`
`501`	`501`	`return either.match(`
`502`		`- { bool -> Variant_String_Double.create("holds something else!") },`
`503`		`- { doubleArray -> Variant_String_Double.create("holds something else!") },`
`504`		`- { stringArray -> Variant_String_Double.create("holds something else!") },`
`505`		`- { string -> Variant_String_Double.create(string) },`
`506`		`- { double -> Variant_String_Double.create(double) },`
	`502`	`+ { bool -> Variant_Double_String.create("holds something else!") },`
	`503`	`+ { doubleArray -> Variant_Double_String.create("holds something else!") },`
	`504`	`+ { stringArray -> Variant_Double_String.create("holds something else!") },`
	`505`	`+ { double -> Variant_Double_String.create(double) },`
	`506`	`+ { string -> Variant_Double_String.create(string) },`
`507`	`507`	`)`
`508`	`508`	`}`
`509`	`509`
`@@ -515,19 +515,19 @@ class HybridTestObjectKotlin : HybridTestObjectSwiftKotlinSpec() {`
`515`	`515`	`return variant`
`516`	`516`	`}`
`517`	`517`
`518`		`- override fun getVariantEnum(variant: Variant_Boolean_OldEnum): Variant_Boolean_OldEnum {`
	`518`	`+ override fun getVariantEnum(variant: Variant_OldEnum_Boolean): Variant_OldEnum_Boolean {`
`519`	`519`	`return variant`
`520`	`520`	`}`
`521`	`521`
`522`	`522`	`override fun bounceVariantUnionEnum(variant: Variant_Powertrain_Car): Variant_Powertrain_Car {`
`523`	`523`	`return variant`
`524`	`524`	`}`
`525`	`525`
`526`		`- override fun getVariantWeirdNumbersEnum(variant: Variant_Boolean_WeirdNumbersEnum): Variant_Boolean_WeirdNumbersEnum {`
	`526`	`+ override fun getVariantWeirdNumbersEnum(variant: Variant_WeirdNumbersEnum_Boolean): Variant_WeirdNumbersEnum_Boolean {`
`527`	`527`	`return variant`
`528`	`528`	`}`
`529`	`529`
`530`		`- override fun getVariantObjects(variant: Variant_Car_Person): Variant_Car_Person {`
	`530`	`+ override fun getVariantObjects(variant: Variant_Person_Car): Variant_Person_Car {`
`531`	`531`	`return variant`
`532`	`532`	`}`
`533`	`533`
Original file line number	Diff line number	Diff line change
`@@ -107,11 +107,11 @@ void HybridTestObjectCpp::setOptionalHybrid(const std::optional<std::shared_ptr<`
`107`	`107`	`_optionalHybrid = optionalHybrid;`
`108`	`108`	`}`
`109`	`109`
`110`		`-std::variant<std::string, double> HybridTestObjectCpp::getSomeVariant() {`
	`110`	`+std::variant<double, std::string> HybridTestObjectCpp::getSomeVariant() {`
`111`	`111`	`return _variant;`
`112`	`112`	`}`
`113`	`113`
`114`		`-void HybridTestObjectCpp::setSomeVariant(const std::variant<std::string, double>& variant) {`
	`114`	`+void HybridTestObjectCpp::setSomeVariant(const std::variant<double, std::string>& variant) {`
`115`	`115`	`_variant = variant;`
`116`	`116`	`}`
`117`	`117`
`@@ -366,8 +366,8 @@ std::chrono::system_clock::time_point HybridTestObjectCpp::currentDate() {`
`366`	`366`	`return std::chrono::system_clock::now();`
`367`	`367`	`}`
`368`	`368`
`369`		`-std::variant<std::string, double>`
`370`		`-HybridTestObjectCpp::passVariant(const std::variant<bool, std::vector<double>, std::vector<std::string>, std::string, double>& either) {`
	`369`	`+std::variant<double, std::string>`
	`370`	`+HybridTestObjectCpp::passVariant(const std::variant<bool, std::vector<double>, std::vector<std::string>, double, std::string>& either) {`
`371`	`371`	`if (std::holds_alternative<std::string>(either)) {`
`372`	`372`	`return std::get<std::string>(either);`
`373`	`373`	`} else if (std::holds_alternative<double>(either)) {`
`@@ -386,19 +386,19 @@ ComplexVariant HybridTestObjectCpp::bounceComplexVariant(const ComplexVariant& v`
`386`	`386`	`return variant;`
`387`	`387`	`}`
`388`	`388`
`389`		`-std::variant<bool, OldEnum> HybridTestObjectCpp::getVariantEnum(const std::variant<bool, OldEnum>& variant) {`
	`389`	`+std::variant<OldEnum, bool> HybridTestObjectCpp::getVariantEnum(const std::variant<OldEnum, bool>& variant) {`
`390`	`390`	`return variant;`
`391`	`391`	`}`
`392`	`392`
`393`	`393`	`std::variant<Powertrain, Car> HybridTestObjectCpp::bounceVariantUnionEnum(const std::variant<Powertrain, Car>& variant) {`
`394`	`394`	`return variant;`
`395`	`395`	`}`
`396`	`396`
`397`		`-std::variant<bool, WeirdNumbersEnum> HybridTestObjectCpp::getVariantWeirdNumbersEnum(const std::variant<bool, WeirdNumbersEnum>& variant) {`
	`397`	`+std::variant<WeirdNumbersEnum, bool> HybridTestObjectCpp::getVariantWeirdNumbersEnum(const std::variant<WeirdNumbersEnum, bool>& variant) {`
`398`	`398`	`return variant;`
`399`	`399`	`}`
`400`	`400`
`401`		`-std::variant<Car, Person> HybridTestObjectCpp::getVariantObjects(const std::variant<Car, Person>& variant) {`
	`401`	`+std::variant<Person, Car> HybridTestObjectCpp::getVariantObjects(const std::variant<Person, Car>& variant) {`
`402`	`402`	`return variant;`
`403`	`403`	`}`
`404`	`404`
Original file line number	Diff line number	Diff line change
`@@ -11,7 +11,7 @@ import NitroTestExternal`
`11`	`11`	`class HybridTestObjectSwift: HybridTestObjectSwiftKotlinSpec {`
`12`	`12`	`var optionalArray: [String]? = []`
`13`	`13`
`14`		`- var someVariant: Variant_String_Double = .second(55)`
	`14`	`+ var someVariant: Variant_Double_String = .first(55)`
`15`	`15`
`16`	`16`	`var numberValue: Double = 0.0`
`17`	`17`
`@@ -338,16 +338,16 @@ class HybridTestObjectSwift: HybridTestObjectSwiftKotlinSpec {`
`338`	`338`	`return variant`
`339`	`339`	`}`
`340`	`340`
`341`		`- func passVariant(either: Variant_Bool__Double___String__String_Double) throws`
`342`		`- -> Variant_String_Double`
	`341`	`+ func passVariant(either: Variant_Bool__Double___String__Double_String) throws`
	`342`	`+ -> Variant_Double_String`
`343`	`343`	`{`
`344`	`344`	`switch either {`
`345`		`- case .fourth(let string):`
`346`		`- return .first(string)`
`347`		`- case .fifth(let double):`
`348`		`- return .second(double)`
	`345`	`+ case .fourth(let double):`
	`346`	`+ return .first(double)`
	`347`	`+ case .fifth(let string):`
	`348`	`+ return .second(string)`
`349`	`349`	`default:`
`350`		`- return .first("holds something else!")`
	`350`	`+ return .second("holds something else!")`
`351`	`351`	`}`
`352`	`352`	`}`
`353`	`353`
`@@ -361,21 +361,21 @@ class HybridTestObjectSwift: HybridTestObjectSwiftKotlinSpec {`
`361`	`361`	`return variant`
`362`	`362`	`}`
`363`	`363`
`364`		`- func getVariantEnum(variant: Variant_Bool_OldEnum) throws -> Variant_Bool_OldEnum {`
	`364`	`+ func getVariantEnum(variant: Variant_OldEnum_Bool) throws -> Variant_OldEnum_Bool {`
`365`	`365`	`return variant`
`366`	`366`	`}`
`367`	`367`
`368`	`368`	`func bounceVariantUnionEnum(variant: Variant_Powertrain_Car) throws -> Variant_Powertrain_Car {`
`369`	`369`	`return variant`
`370`	`370`	`}`
`371`	`371`
`372`		`- func getVariantWeirdNumbersEnum(variant: Variant_Bool_WeirdNumbersEnum) throws`
`373`		`- -> Variant_Bool_WeirdNumbersEnum`
	`372`	`+ func getVariantWeirdNumbersEnum(variant: Variant_WeirdNumbersEnum_Bool) throws`
	`373`	`+ -> Variant_WeirdNumbersEnum_Bool`
`374`	`374`	`{`
`375`	`375`	`return variant`
`376`	`376`	`}`
`377`	`377`
`378`		`- func getVariantObjects(variant: Variant_Car_Person) throws -> Variant_Car_Person {`
	`378`	`+ func getVariantObjects(variant: Variant_Person_Car) throws -> Variant_Person_Car {`
`379`	`379`	`return variant`
`380`	`380`	`}`
`381`	`381`