Add comprehensive tests for oneOf discriminator-first decoding

- Add 5 unit and integration tests for Swift5 generator
- Add 5 unit and integration tests for Swift6 generator
- Tests validate CodegenModel discriminator properties
- Tests validate generated Swift code contains discriminator-first decoding
- Tests verify fallback to sequential try? when no discriminator
- Tests use existing oneOfDiscriminator.yaml spec

Tests cover:
- Discriminator property extraction
- Enum discriminator mapping
- Generated code patterns (switch on discriminator value)
- Backward compatibility (sequential try? without discriminator)

Author: lastMove

modules/openapi-generator/src/test/java/org/openapitools/codegen/swift5/Swift5ClientCodegenTest.java

@@ -317,4 +317,192 @@ public void oneOfFormParameterTest() {
 
     }
 
+    @Test(description = "test oneOf model with discriminator properties", enabled = true)
+    public void oneOfWithDiscriminatorModelTest() {
+        final OpenAPI openAPI = TestUtils.parseFlattenSpec("src/test/resources/3_0/oneOfDiscriminator.yaml");
+        final DefaultCodegen codegen = new Swift5ClientCodegen();
+        codegen.setOpenAPI(openAPI);
+
+        final Schema schema = openAPI.getComponents().getSchemas().get("FruitReqDisc");
+        final CodegenModel cm = codegen.fromModel("FruitReqDisc", schema);
+
+        Assert.assertNotNull(cm.discriminator, "Discriminator should not be null");
+        Assert.assertEquals(cm.discriminator.getPropertyName(), "fruitType");
+        Assert.assertEquals(cm.discriminator.getPropertyBaseName(), "fruitType");
+        Assert.assertTrue(cm.getHasDiscriminatorWithNonEmptyMapping(),
+                "Should have discriminator with non-empty mapping");
+
+        java.util.Set<org.openapitools.codegen.CodegenDiscriminator.MappedModel> mappedModels =
+                cm.discriminator.getMappedModels();
+        Assert.assertEquals(mappedModels.size(), 2, "Should have 2 mapped models");
+
+        java.util.Set<String> modelNames = new java.util.HashSet<>();
+        for (org.openapitools.codegen.CodegenDiscriminator.MappedModel mm : mappedModels) {
+            modelNames.add(mm.getModelName());
+        }
+        Assert.assertTrue(modelNames.contains("AppleReqDisc"), "Should contain AppleReqDisc");
+        Assert.assertTrue(modelNames.contains("BananaReqDisc"), "Should contain BananaReqDisc");
+    }
+
+    @Test(description = "test oneOf model with enum discriminator mapping", enabled = true)
+    public void oneOfWithEnumDiscriminatorMappingModelTest() {
+        final OpenAPI openAPI = TestUtils.parseFlattenSpec("src/test/resources/3_0/oneOfDiscriminator.yaml");
+        final DefaultCodegen codegen = new Swift5ClientCodegen();
+        codegen.setOpenAPI(openAPI);
+
+        final Schema schema = openAPI.getComponents().getSchemas().get("FruitOneOfEnumMappingDisc");
+        final CodegenModel cm = codegen.fromModel("FruitOneOfEnumMappingDisc", schema);
+
+        Assert.assertNotNull(cm.discriminator, "Discriminator should not be null");
+        Assert.assertEquals(cm.discriminator.getPropertyName(), "fruitType");
+        Assert.assertTrue(cm.getHasDiscriminatorWithNonEmptyMapping(),
+                "Should have discriminator with non-empty mapping");
+
+        java.util.Set<org.openapitools.codegen.CodegenDiscriminator.MappedModel> mappedModels =
+                cm.discriminator.getMappedModels();
+        Assert.assertEquals(mappedModels.size(), 2, "Should have 2 mapped models");
+
+        java.util.Map<String, String> mappings = new java.util.HashMap<>();
+        for (org.openapitools.codegen.CodegenDiscriminator.MappedModel mm : mappedModels) {
+            mappings.put(mm.getMappingName(), mm.getModelName());
+        }
+        Assert.assertTrue(mappings.containsKey("APPLE"), "Should have APPLE mapping");
+        Assert.assertTrue(mappings.containsKey("BANANA"), "Should have BANANA mapping");
+        Assert.assertEquals(mappings.get("APPLE"), "AppleOneOfEnumMappingDisc");
+        Assert.assertEquals(mappings.get("BANANA"), "BananaOneOfEnumMappingDisc");
+    }
+
+    @Test(description = "test oneOf generates discriminator-first decoding", enabled = true)
+    public void oneOfDiscriminatorFirstDecodingTest() throws IOException {
+        Path target = Files.createTempDirectory("test");
+        File output = target.toFile();
+        try {
+            final CodegenConfigurator configurator = new CodegenConfigurator()
+                    .setGeneratorName("swift5")
+                    .setInputSpec("src/test/resources/3_0/oneOfDiscriminator.yaml")
+                    .setOutputDir(target.toAbsolutePath().toString());
+
+            final ClientOptInput clientOptInput = configurator.toClientOptInput();
+            DefaultGenerator generator = new DefaultGenerator(false);
+            generator.setGeneratorPropertyDefault(CodegenConstants.MODELS, "true");
+            generator.setGeneratorPropertyDefault(CodegenConstants.APIS, "false");
+            generator.setGeneratorPropertyDefault(CodegenConstants.SUPPORTING_FILES, "false");
+
+            List<File> files = generator.opts(clientOptInput).generate();
+
+            File modelFile = files.stream()
+                    .filter(f -> f.getName().equals("FruitReqDisc.swift"))
+                    .findFirst()
+                    .orElseThrow(() -> new RuntimeException("FruitReqDisc.swift not found"));
+
+            String content = Files.readString(modelFile.toPath());
+
+            Assert.assertTrue(content.contains("private enum DiscriminatorCodingKey: String, CodingKey"),
+                    "Missing DiscriminatorCodingKey enum");
+            Assert.assertTrue(content.contains("case fruitType ="),
+                    "Missing fruitType discriminator key");
+            Assert.assertTrue(content.contains("let keyedContainer = try decoder.container(keyedBy: DiscriminatorCodingKey.self)"),
+                    "Missing keyedContainer for discriminator");
+            Assert.assertTrue(content.contains("let discriminatorValue = try keyedContainer.decode(String.self, forKey: .fruitType)"),
+                    "Missing discriminator value extraction");
+            Assert.assertTrue(content.contains("switch discriminatorValue"),
+                    "Missing switch on discriminator value");
+            Assert.assertTrue(content.contains("case \"AppleReqDisc\":"),
+                    "Missing AppleReqDisc case");
+            Assert.assertTrue(content.contains("self = .typeAppleReqDisc(try AppleReqDisc(from: decoder))"),
+                    "Missing AppleReqDisc initialization");
+            Assert.assertTrue(content.contains("case \"BananaReqDisc\":"),
+                    "Missing BananaReqDisc case");
+            Assert.assertTrue(content.contains("self = .typeBananaReqDisc(try BananaReqDisc(from: decoder))"),
+                    "Missing BananaReqDisc initialization");
+            Assert.assertFalse(content.contains("if let value = try? container.decode(AppleReqDisc.self)"),
+                    "Should NOT have sequential try? decoding when discriminator exists");
+
+        } finally {
+            output.deleteOnExit();
+        }
+    }
+
+    @Test(description = "test oneOf with enum mapping generates correct discriminator cases", enabled = true)
+    public void oneOfEnumMappingDiscriminatorDecodingTest() throws IOException {
+        Path target = Files.createTempDirectory("test");
+        File output = target.toFile();
+        try {
+            final CodegenConfigurator configurator = new CodegenConfigurator()
+                    .setGeneratorName("swift5")
+                    .setInputSpec("src/test/resources/3_0/oneOfDiscriminator.yaml")
+                    .setOutputDir(target.toAbsolutePath().toString());
+
+            final ClientOptInput clientOptInput = configurator.toClientOptInput();
+            DefaultGenerator generator = new DefaultGenerator(false);
+            generator.setGeneratorPropertyDefault(CodegenConstants.MODELS, "true");
+            generator.setGeneratorPropertyDefault(CodegenConstants.APIS, "false");
+            generator.setGeneratorPropertyDefault(CodegenConstants.SUPPORTING_FILES, "false");
+
+            List<File> files = generator.opts(clientOptInput).generate();
+
+            File modelFile = files.stream()
+                    .filter(f -> f.getName().equals("FruitOneOfEnumMappingDisc.swift"))
+                    .findFirst()
+                    .orElseThrow(() -> new RuntimeException("FruitOneOfEnumMappingDisc.swift not found"));
+
+            String content = Files.readString(modelFile.toPath());
+
+            Assert.assertTrue(content.contains("case \"APPLE\":"),
+                    "Missing APPLE enum mapping case");
+            Assert.assertTrue(content.contains("self = .typeAppleOneOfEnumMappingDisc(try AppleOneOfEnumMappingDisc(from: decoder))"),
+                    "Missing AppleOneOfEnumMappingDisc initialization with APPLE mapping");
+            Assert.assertTrue(content.contains("case \"BANANA\":"),
+                    "Missing BANANA enum mapping case");
+            Assert.assertTrue(content.contains("self = .typeBananaOneOfEnumMappingDisc(try BananaOneOfEnumMappingDisc(from: decoder))"),
+                    "Missing BananaOneOfEnumMappingDisc initialization with BANANA mapping");
+
+        } finally {
+            output.deleteOnExit();
+        }
+    }
+
+    @Test(description = "test oneOf without discriminator uses sequential try decoding", enabled = true)
+    public void oneOfWithoutDiscriminatorFallbackTest() throws IOException {
+        Path target = Files.createTempDirectory("test");
+        File output = target.toFile();
+        try {
+            final CodegenConfigurator configurator = new CodegenConfigurator()
+                    .setGeneratorName("swift5")
+                    .setInputSpec("src/test/resources/3_0/oneOf.yaml")
+                    .setOutputDir(target.toAbsolutePath().toString());
+
+            final ClientOptInput clientOptInput = configurator.toClientOptInput();
+            DefaultGenerator generator = new DefaultGenerator(false);
+            generator.setGeneratorPropertyDefault(CodegenConstants.MODELS, "true");
+            generator.setGeneratorPropertyDefault(CodegenConstants.APIS, "false");
+            generator.setGeneratorPropertyDefault(CodegenConstants.SUPPORTING_FILES, "false");
+
+            List<File> files = generator.opts(clientOptInput).generate();
+
+            File modelFile = files.stream()
+                    .filter(f -> f.getName().equals("Fruit.swift"))
+                    .findFirst()
+                    .orElseThrow(() -> new RuntimeException("Fruit.swift not found"));
+
+            String content = Files.readString(modelFile.toPath());
+
+            Assert.assertTrue(content.contains("let container = try decoder.singleValueContainer()"),
+                    "Missing singleValueContainer for fallback");
+            Assert.assertTrue(content.contains("if let value = try? container.decode("),
+                    "Missing sequential try? decoding pattern");
+            Assert.assertTrue(content.contains("} else if let value = try? container.decode("),
+                    "Missing else if try? decoding pattern");
+            Assert.assertFalse(content.contains("private enum DiscriminatorCodingKey"),
+                    "Should NOT have DiscriminatorCodingKey when no discriminator");
+            Assert.assertFalse(content.contains("keyedContainer"),
+                    "Should NOT have keyedContainer when no discriminator");
+            Assert.assertFalse(content.contains("discriminatorValue"),
+                    "Should NOT have discriminatorValue when no discriminator");
+
+        } finally {
+            output.deleteOnExit();
+        }
+    }
+
 }