[swift] fix broken swift test build (#7633) (#7634)

* [swift] fix broken swift test build (#7633) * [swift] fix unused variable (#7633) * [swift] update generated code (#7633) * [swift] add binary & json test for nan, inf, -inf for swift (#7633) * [swift] use just '.infinity' instead of '+.infinity' (#7633) * [swift] remove commented code (#7633) Co-authored-by: Derek Bailey <derekbailey@google.com> Co-authored-by: mustiikhalil <26250654+mustiikhalil@users.noreply.github.com>
2026-06-22 15:28:52 +00:00 · 2022-11-11 20:36:47 +03:00
parent 879622fc57
commit 74756e5d1b
7 changed files with 389 additions and 98 deletions
--- a/tests/nan_inf_test.fbs
+++ b/tests/nan_inf_test.fbs
@@ -0,0 +1,14 @@
+namespace Swift.Tests;
+
+table NanInfTable
+{
+  default_nan:double = nan;
+  default_inf:double = inf;
+  default_ninf:double = -inf;
+  value_nan:double;
+  value_inf:double;
+  value_ninf:double;
+  value:double;
+}
+
+root_type NanInfTable;
--- a/tests/swift/Wasm.tests/Tests/FlatBuffers.Test.Swift.WasmTests/monster_test_generated.swift
+++ b/tests/swift/Wasm.tests/Tests/FlatBuffers.Test.Swift.WasmTests/monster_test_generated.swift
@@ -1184,6 +1184,14 @@ public struct MyGame_Example_Monster: FlatBufferObject, Verifiable, ObjectAPIPac
    case nativeInline = 106
    case longEnumNonEnumDefault = 108
    case longEnumNormalDefault = 110
+    case nanDefault = 112
+    case infDefault = 114
+    case positiveInfDefault = 116
+    case infinityDefault = 118
+    case positiveInfinityDefault = 120
+    case negativeInfDefault = 122
+    case negativeInfinityDefault = 124
+    case doubleInfDefault = 126
    var v: Int32 { Int32(self.rawValue) }
    var p: VOffset { self.rawValue }
  }
@@ -1334,7 +1342,23 @@ public struct MyGame_Example_Monster: FlatBufferObject, Verifiable, ObjectAPIPac
  @discardableResult public func mutate(longEnumNonEnumDefault: MyGame_Example_LongEnum) -> Bool {let o = _accessor.offset(VTOFFSET.longEnumNonEnumDefault.v);  return _accessor.mutate(longEnumNonEnumDefault.rawValue, index: o) }
  public var longEnumNormalDefault: MyGame_Example_LongEnum { let o = _accessor.offset(VTOFFSET.longEnumNormalDefault.v); return o == 0 ? .longone : MyGame_Example_LongEnum(rawValue: _accessor.readBuffer(of: UInt64.self, at: o)) ?? .longone }
  @discardableResult public func mutate(longEnumNormalDefault: MyGame_Example_LongEnum) -> Bool {let o = _accessor.offset(VTOFFSET.longEnumNormalDefault.v);  return _accessor.mutate(longEnumNormalDefault.rawValue, index: o) }
-  public static func startMonster(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 54) }
+  public var nanDefault: Float32 { let o = _accessor.offset(VTOFFSET.nanDefault.v); return o == 0 ? .nan : _accessor.readBuffer(of: Float32.self, at: o) }
+  @discardableResult public func mutate(nanDefault: Float32) -> Bool {let o = _accessor.offset(VTOFFSET.nanDefault.v);  return _accessor.mutate(nanDefault, index: o) }
+  public var infDefault: Float32 { let o = _accessor.offset(VTOFFSET.infDefault.v); return o == 0 ? +.infinity : _accessor.readBuffer(of: Float32.self, at: o) }
+  @discardableResult public func mutate(infDefault: Float32) -> Bool {let o = _accessor.offset(VTOFFSET.infDefault.v);  return _accessor.mutate(infDefault, index: o) }
+  public var positiveInfDefault: Float32 { let o = _accessor.offset(VTOFFSET.positiveInfDefault.v); return o == 0 ? +.infinity : _accessor.readBuffer(of: Float32.self, at: o) }
+  @discardableResult public func mutate(positiveInfDefault: Float32) -> Bool {let o = _accessor.offset(VTOFFSET.positiveInfDefault.v);  return _accessor.mutate(positiveInfDefault, index: o) }
+  public var infinityDefault: Float32 { let o = _accessor.offset(VTOFFSET.infinityDefault.v); return o == 0 ? +.infinity : _accessor.readBuffer(of: Float32.self, at: o) }
+  @discardableResult public func mutate(infinityDefault: Float32) -> Bool {let o = _accessor.offset(VTOFFSET.infinityDefault.v);  return _accessor.mutate(infinityDefault, index: o) }
+  public var positiveInfinityDefault: Float32 { let o = _accessor.offset(VTOFFSET.positiveInfinityDefault.v); return o == 0 ? +.infinity : _accessor.readBuffer(of: Float32.self, at: o) }
+  @discardableResult public func mutate(positiveInfinityDefault: Float32) -> Bool {let o = _accessor.offset(VTOFFSET.positiveInfinityDefault.v);  return _accessor.mutate(positiveInfinityDefault, index: o) }
+  public var negativeInfDefault: Float32 { let o = _accessor.offset(VTOFFSET.negativeInfDefault.v); return o == 0 ? -.infinity : _accessor.readBuffer(of: Float32.self, at: o) }
+  @discardableResult public func mutate(negativeInfDefault: Float32) -> Bool {let o = _accessor.offset(VTOFFSET.negativeInfDefault.v);  return _accessor.mutate(negativeInfDefault, index: o) }
+  public var negativeInfinityDefault: Float32 { let o = _accessor.offset(VTOFFSET.negativeInfinityDefault.v); return o == 0 ? -.infinity : _accessor.readBuffer(of: Float32.self, at: o) }
+  @discardableResult public func mutate(negativeInfinityDefault: Float32) -> Bool {let o = _accessor.offset(VTOFFSET.negativeInfinityDefault.v);  return _accessor.mutate(negativeInfinityDefault, index: o) }
+  public var doubleInfDefault: Double { let o = _accessor.offset(VTOFFSET.doubleInfDefault.v); return o == 0 ? +.infinity : _accessor.readBuffer(of: Double.self, at: o) }
+  @discardableResult public func mutate(doubleInfDefault: Double) -> Bool {let o = _accessor.offset(VTOFFSET.doubleInfDefault.v);  return _accessor.mutate(doubleInfDefault, index: o) }
+  public static func startMonster(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 62) }
  public static func add(pos: MyGame_Example_Vec3?, _ fbb: inout FlatBufferBuilder) { guard let pos = pos else { return }; fbb.create(struct: pos, position: VTOFFSET.pos.p) }
  public static func add(mana: Int16, _ fbb: inout FlatBufferBuilder) { fbb.add(element: mana, def: 150, at: VTOFFSET.mana.p) }
  public static func add(hp: Int16, _ fbb: inout FlatBufferBuilder) { fbb.add(element: hp, def: 100, at: VTOFFSET.hp.p) }
@@ -1398,6 +1422,14 @@ public struct MyGame_Example_Monster: FlatBufferObject, Verifiable, ObjectAPIPac
  public static func add(nativeInline: MyGame_Example_Test?, _ fbb: inout FlatBufferBuilder) { guard let nativeInline = nativeInline else { return }; fbb.create(struct: nativeInline, position: VTOFFSET.nativeInline.p) }
  public static func add(longEnumNonEnumDefault: MyGame_Example_LongEnum, _ fbb: inout FlatBufferBuilder) { fbb.add(element: longEnumNonEnumDefault.rawValue, def: 0, at: VTOFFSET.longEnumNonEnumDefault.p) }
  public static func add(longEnumNormalDefault: MyGame_Example_LongEnum, _ fbb: inout FlatBufferBuilder) { fbb.add(element: longEnumNormalDefault.rawValue, def: 2, at: VTOFFSET.longEnumNormalDefault.p) }
+  public static func add(nanDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: nanDefault, def: .nan, at: VTOFFSET.nanDefault.p) }
+  public static func add(infDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: infDefault, def: +.infinity, at: VTOFFSET.infDefault.p) }
+  public static func add(positiveInfDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: positiveInfDefault, def: +.infinity, at: VTOFFSET.positiveInfDefault.p) }
+  public static func add(infinityDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: infinityDefault, def: +.infinity, at: VTOFFSET.infinityDefault.p) }
+  public static func add(positiveInfinityDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: positiveInfinityDefault, def: +.infinity, at: VTOFFSET.positiveInfinityDefault.p) }
+  public static func add(negativeInfDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: negativeInfDefault, def: -.infinity, at: VTOFFSET.negativeInfDefault.p) }
+  public static func add(negativeInfinityDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: negativeInfinityDefault, def: -.infinity, at: VTOFFSET.negativeInfinityDefault.p) }
+  public static func add(doubleInfDefault: Double, _ fbb: inout FlatBufferBuilder) { fbb.add(element: doubleInfDefault, def: +.infinity, at: VTOFFSET.doubleInfDefault.p) }
  public static func endMonster(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); fbb.require(table: end, fields: [10]); return end }
  public static func createMonster(
    _ fbb: inout FlatBufferBuilder,
@@ -1453,7 +1485,15 @@ public struct MyGame_Example_Monster: FlatBufferObject, Verifiable, ObjectAPIPac
    scalarKeySortedTablesVectorOffset scalarKeySortedTables: Offset = Offset(),
    nativeInline: MyGame_Example_Test? = nil,
    longEnumNonEnumDefault: MyGame_Example_LongEnum = .longone,
-    longEnumNormalDefault: MyGame_Example_LongEnum = .longone
+    longEnumNormalDefault: MyGame_Example_LongEnum = .longone,
+    nanDefault: Float32 = .nan,
+    infDefault: Float32 = +.infinity,
+    positiveInfDefault: Float32 = +.infinity,
+    infinityDefault: Float32 = +.infinity,
+    positiveInfinityDefault: Float32 = +.infinity,
+    negativeInfDefault: Float32 = -.infinity,
+    negativeInfinityDefault: Float32 = -.infinity,
+    doubleInfDefault: Double = +.infinity
  ) -> Offset {
    let __start = MyGame_Example_Monster.startMonster(&fbb)
    MyGame_Example_Monster.add(pos: pos, &fbb)
@@ -1509,6 +1549,14 @@ public struct MyGame_Example_Monster: FlatBufferObject, Verifiable, ObjectAPIPac
    MyGame_Example_Monster.add(nativeInline: nativeInline, &fbb)
    MyGame_Example_Monster.add(longEnumNonEnumDefault: longEnumNonEnumDefault, &fbb)
    MyGame_Example_Monster.add(longEnumNormalDefault: longEnumNormalDefault, &fbb)
+    MyGame_Example_Monster.add(nanDefault: nanDefault, &fbb)
+    MyGame_Example_Monster.add(infDefault: infDefault, &fbb)
+    MyGame_Example_Monster.add(positiveInfDefault: positiveInfDefault, &fbb)
+    MyGame_Example_Monster.add(infinityDefault: infinityDefault, &fbb)
+    MyGame_Example_Monster.add(positiveInfinityDefault: positiveInfinityDefault, &fbb)
+    MyGame_Example_Monster.add(negativeInfDefault: negativeInfDefault, &fbb)
+    MyGame_Example_Monster.add(negativeInfinityDefault: negativeInfinityDefault, &fbb)
+    MyGame_Example_Monster.add(doubleInfDefault: doubleInfDefault, &fbb)
    return MyGame_Example_Monster.endMonster(&fbb, start: __start)
  }
  public static func sortVectorOfMonster(offsets:[Offset], _ fbb: inout FlatBufferBuilder) -> Offset {
@@ -1668,6 +1716,14 @@ public struct MyGame_Example_Monster: FlatBufferObject, Verifiable, ObjectAPIPac
    MyGame_Example_Monster.add(nativeInline: obj.nativeInline, &builder)
    MyGame_Example_Monster.add(longEnumNonEnumDefault: obj.longEnumNonEnumDefault, &builder)
    MyGame_Example_Monster.add(longEnumNormalDefault: obj.longEnumNormalDefault, &builder)
+    MyGame_Example_Monster.add(nanDefault: obj.nanDefault, &builder)
+    MyGame_Example_Monster.add(infDefault: obj.infDefault, &builder)
+    MyGame_Example_Monster.add(positiveInfDefault: obj.positiveInfDefault, &builder)
+    MyGame_Example_Monster.add(infinityDefault: obj.infinityDefault, &builder)
+    MyGame_Example_Monster.add(positiveInfinityDefault: obj.positiveInfinityDefault, &builder)
+    MyGame_Example_Monster.add(negativeInfDefault: obj.negativeInfDefault, &builder)
+    MyGame_Example_Monster.add(negativeInfinityDefault: obj.negativeInfinityDefault, &builder)
+    MyGame_Example_Monster.add(doubleInfDefault: obj.doubleInfDefault, &builder)
    return MyGame_Example_Monster.endMonster(&builder, start: __root)
  }

@@ -1756,6 +1812,14 @@ public struct MyGame_Example_Monster: FlatBufferObject, Verifiable, ObjectAPIPac
    try _v.visit(field: VTOFFSET.nativeInline.p, fieldName: "nativeInline", required: false, type: MyGame_Example_Test.self)
    try _v.visit(field: VTOFFSET.longEnumNonEnumDefault.p, fieldName: "longEnumNonEnumDefault", required: false, type: MyGame_Example_LongEnum.self)
    try _v.visit(field: VTOFFSET.longEnumNormalDefault.p, fieldName: "longEnumNormalDefault", required: false, type: MyGame_Example_LongEnum.self)
+    try _v.visit(field: VTOFFSET.nanDefault.p, fieldName: "nanDefault", required: false, type: Float32.self)
+    try _v.visit(field: VTOFFSET.infDefault.p, fieldName: "infDefault", required: false, type: Float32.self)
+    try _v.visit(field: VTOFFSET.positiveInfDefault.p, fieldName: "positiveInfDefault", required: false, type: Float32.self)
+    try _v.visit(field: VTOFFSET.infinityDefault.p, fieldName: "infinityDefault", required: false, type: Float32.self)
+    try _v.visit(field: VTOFFSET.positiveInfinityDefault.p, fieldName: "positiveInfinityDefault", required: false, type: Float32.self)
+    try _v.visit(field: VTOFFSET.negativeInfDefault.p, fieldName: "negativeInfDefault", required: false, type: Float32.self)
+    try _v.visit(field: VTOFFSET.negativeInfinityDefault.p, fieldName: "negativeInfinityDefault", required: false, type: Float32.self)
+    try _v.visit(field: VTOFFSET.doubleInfDefault.p, fieldName: "doubleInfDefault", required: false, type: Double.self)
    _v.finish()
  }
 }
@@ -1816,6 +1880,14 @@ extension MyGame_Example_Monster: Encodable {
    case nativeInline = "native_inline"
    case longEnumNonEnumDefault = "long_enum_non_enum_default"
    case longEnumNormalDefault = "long_enum_normal_default"
+    case nanDefault = "nan_default"
+    case infDefault = "inf_default"
+    case positiveInfDefault = "positive_inf_default"
+    case infinityDefault = "infinity_default"
+    case positiveInfinityDefault = "positive_infinity_default"
+    case negativeInfDefault = "negative_inf_default"
+    case negativeInfinityDefault = "negative_infinity_default"
+    case doubleInfDefault = "double_inf_default"
  }
  public func encode(to encoder: Encoder) throws {
    var container = encoder.container(keyedBy: CodingKeys.self)
@@ -2033,6 +2105,30 @@ extension MyGame_Example_Monster: Encodable {
    if longEnumNormalDefault != .longone {
      try container.encodeIfPresent(longEnumNormalDefault, forKey: .longEnumNormalDefault)
    }
+    if !nanDefault.isNaN {
+      try container.encodeIfPresent(nanDefault, forKey: .nanDefault)
+    }
+    if infDefault != +.infinity {
+      try container.encodeIfPresent(infDefault, forKey: .infDefault)
+    }
+    if positiveInfDefault != +.infinity {
+      try container.encodeIfPresent(positiveInfDefault, forKey: .positiveInfDefault)
+    }
+    if infinityDefault != +.infinity {
+      try container.encodeIfPresent(infinityDefault, forKey: .infinityDefault)
+    }
+    if positiveInfinityDefault != +.infinity {
+      try container.encodeIfPresent(positiveInfinityDefault, forKey: .positiveInfinityDefault)
+    }
+    if negativeInfDefault != -.infinity {
+      try container.encodeIfPresent(negativeInfDefault, forKey: .negativeInfDefault)
+    }
+    if negativeInfinityDefault != -.infinity {
+      try container.encodeIfPresent(negativeInfinityDefault, forKey: .negativeInfinityDefault)
+    }
+    if doubleInfDefault != +.infinity {
+      try container.encodeIfPresent(doubleInfDefault, forKey: .doubleInfDefault)
+    }
  }
 }

@@ -2088,6 +2184,14 @@ public class MyGame_Example_MonsterT: NativeObject {
  public var nativeInline: MyGame_Example_Test?
  public var longEnumNonEnumDefault: MyGame_Example_LongEnum
  public var longEnumNormalDefault: MyGame_Example_LongEnum
+  public var nanDefault: Float32
+  public var infDefault: Float32
+  public var positiveInfDefault: Float32
+  public var infinityDefault: Float32
+  public var positiveInfinityDefault: Float32
+  public var negativeInfDefault: Float32
+  public var negativeInfinityDefault: Float32
+  public var doubleInfDefault: Double

  public init(_ _t: inout MyGame_Example_Monster) {
    pos = _t.pos
@@ -2240,6 +2344,14 @@ public class MyGame_Example_MonsterT: NativeObject {
    nativeInline = _t.nativeInline
    longEnumNonEnumDefault = _t.longEnumNonEnumDefault
    longEnumNormalDefault = _t.longEnumNormalDefault
+    nanDefault = _t.nanDefault
+    infDefault = _t.infDefault
+    positiveInfDefault = _t.positiveInfDefault
+    infinityDefault = _t.infinityDefault
+    positiveInfinityDefault = _t.positiveInfinityDefault
+    negativeInfDefault = _t.negativeInfDefault
+    negativeInfinityDefault = _t.negativeInfinityDefault
+    doubleInfDefault = _t.doubleInfDefault
  }

  public init() {
@@ -2290,6 +2402,14 @@ public class MyGame_Example_MonsterT: NativeObject {
    nativeInline = MyGame_Example_Test()
    longEnumNonEnumDefault = .longone
    longEnumNormalDefault = .longone
+    nanDefault = .nan
+    infDefault = +.infinity
+    positiveInfDefault = +.infinity
+    infinityDefault = +.infinity
+    positiveInfinityDefault = +.infinity
+    negativeInfDefault = -.infinity
+    negativeInfinityDefault = -.infinity
+    doubleInfDefault = +.infinity
  }

  public func serialize() -> ByteBuffer { return serialize(type: MyGame_Example_Monster.self) }
--- a/tests/swift/tests/Tests/FlatBuffers.Test.SwiftTests/FlatBuffersNanInfTests.swift
+++ b/tests/swift/tests/Tests/FlatBuffers.Test.SwiftTests/FlatBuffersNanInfTests.swift
@@ -0,0 +1,68 @@
+/*
+ * Copyright 2022 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import XCTest
+@testable import FlatBuffers
+
+final class FlatBuffersNanInfTests: XCTestCase {
+
+    func createTestTable() -> FlatBufferBuilder {
+        var fbb = FlatBufferBuilder()
+        let msg = Swift_Tests_NanInfTable.createNanInfTable(&fbb,
+            valueNan: .nan,
+            valueInf: .infinity,
+            valueNinf: -.infinity,
+            value: 100.0
+        )
+        fbb.finish(offset: msg)
+        return fbb
+    }
+
+    func testInfNanBinary() {
+        let fbb = createTestTable()
+        let data = fbb.sizedByteArray
+        
+        let table = Swift_Tests_NanInfTable.getRootAsNanInfTable(bb: ByteBuffer(bytes: data))
+        XCTAssert(table.defaultNan.isNaN)
+        XCTAssertEqual(table.defaultInf, .infinity)
+        XCTAssertEqual(table.defaultNinf, -.infinity)
+        XCTAssert(table.valueNan.isNaN)
+        XCTAssertEqual(table.valueInf, .infinity)
+        XCTAssertEqual(table.valueNinf, -.infinity)
+        XCTAssertEqual(table.value, 100.0)
+    }
+    
+    func testInfNanJSON() {
+        let fbb = createTestTable()
+        var bb = fbb.sizedBuffer
+        do {
+            let reader: Swift_Tests_NanInfTable = try getCheckedRoot(byteBuffer: &bb)
+            let encoder = JSONEncoder()
+            encoder.keyEncodingStrategy = .convertToSnakeCase
+            encoder.nonConformingFloatEncodingStrategy =
+                .convertToString(positiveInfinity: "inf", negativeInfinity: "-inf", nan: "nan")
+            let data = try encoder.encode(reader)
+            XCTAssertEqual(data, jsonData.data(using: .utf8))
+        } catch {
+            XCTFail(error.localizedDescription)
+        }
+    }
+    
+    var jsonData: String {
+        "{\"value_inf\":\"inf\",\"value\":100,\"value_nan\":\"nan\",\"value_ninf\":\"-inf\"}"
+    }
+    
+}
--- a/tests/swift/tests/Tests/FlatBuffers.Test.SwiftTests/monster_test_generated.swift
+++ b/tests/swift/tests/Tests/FlatBuffers.Test.SwiftTests/monster_test_generated.swift
@@ -1342,21 +1342,21 @@ public struct MyGame_Example_Monster: FlatBufferObject, Verifiable, ObjectAPIPac
  @discardableResult public func mutate(longEnumNonEnumDefault: MyGame_Example_LongEnum) -> Bool {let o = _accessor.offset(VTOFFSET.longEnumNonEnumDefault.v);  return _accessor.mutate(longEnumNonEnumDefault.rawValue, index: o) }
  public var longEnumNormalDefault: MyGame_Example_LongEnum { let o = _accessor.offset(VTOFFSET.longEnumNormalDefault.v); return o == 0 ? .longone : MyGame_Example_LongEnum(rawValue: _accessor.readBuffer(of: UInt64.self, at: o)) ?? .longone }
  @discardableResult public func mutate(longEnumNormalDefault: MyGame_Example_LongEnum) -> Bool {let o = _accessor.offset(VTOFFSET.longEnumNormalDefault.v);  return _accessor.mutate(longEnumNormalDefault.rawValue, index: o) }
-  public var nanDefault: Float32 { let o = _accessor.offset(VTOFFSET.nanDefault.v); return o == 0 ? nan : _accessor.readBuffer(of: Float32.self, at: o) }
+  public var nanDefault: Float32 { let o = _accessor.offset(VTOFFSET.nanDefault.v); return o == 0 ? .nan : _accessor.readBuffer(of: Float32.self, at: o) }
  @discardableResult public func mutate(nanDefault: Float32) -> Bool {let o = _accessor.offset(VTOFFSET.nanDefault.v);  return _accessor.mutate(nanDefault, index: o) }
-  public var infDefault: Float32 { let o = _accessor.offset(VTOFFSET.infDefault.v); return o == 0 ? inf : _accessor.readBuffer(of: Float32.self, at: o) }
+  public var infDefault: Float32 { let o = _accessor.offset(VTOFFSET.infDefault.v); return o == 0 ? .infinity : _accessor.readBuffer(of: Float32.self, at: o) }
  @discardableResult public func mutate(infDefault: Float32) -> Bool {let o = _accessor.offset(VTOFFSET.infDefault.v);  return _accessor.mutate(infDefault, index: o) }
-  public var positiveInfDefault: Float32 { let o = _accessor.offset(VTOFFSET.positiveInfDefault.v); return o == 0 ? +inf : _accessor.readBuffer(of: Float32.self, at: o) }
+  public var positiveInfDefault: Float32 { let o = _accessor.offset(VTOFFSET.positiveInfDefault.v); return o == 0 ? .infinity : _accessor.readBuffer(of: Float32.self, at: o) }
  @discardableResult public func mutate(positiveInfDefault: Float32) -> Bool {let o = _accessor.offset(VTOFFSET.positiveInfDefault.v);  return _accessor.mutate(positiveInfDefault, index: o) }
-  public var infinityDefault: Float32 { let o = _accessor.offset(VTOFFSET.infinityDefault.v); return o == 0 ? infinity : _accessor.readBuffer(of: Float32.self, at: o) }
+  public var infinityDefault: Float32 { let o = _accessor.offset(VTOFFSET.infinityDefault.v); return o == 0 ? .infinity : _accessor.readBuffer(of: Float32.self, at: o) }
  @discardableResult public func mutate(infinityDefault: Float32) -> Bool {let o = _accessor.offset(VTOFFSET.infinityDefault.v);  return _accessor.mutate(infinityDefault, index: o) }
-  public var positiveInfinityDefault: Float32 { let o = _accessor.offset(VTOFFSET.positiveInfinityDefault.v); return o == 0 ? +infinity : _accessor.readBuffer(of: Float32.self, at: o) }
+  public var positiveInfinityDefault: Float32 { let o = _accessor.offset(VTOFFSET.positiveInfinityDefault.v); return o == 0 ? .infinity : _accessor.readBuffer(of: Float32.self, at: o) }
  @discardableResult public func mutate(positiveInfinityDefault: Float32) -> Bool {let o = _accessor.offset(VTOFFSET.positiveInfinityDefault.v);  return _accessor.mutate(positiveInfinityDefault, index: o) }
-  public var negativeInfDefault: Float32 { let o = _accessor.offset(VTOFFSET.negativeInfDefault.v); return o == 0 ? -inf : _accessor.readBuffer(of: Float32.self, at: o) }
+  public var negativeInfDefault: Float32 { let o = _accessor.offset(VTOFFSET.negativeInfDefault.v); return o == 0 ? -.infinity : _accessor.readBuffer(of: Float32.self, at: o) }
  @discardableResult public func mutate(negativeInfDefault: Float32) -> Bool {let o = _accessor.offset(VTOFFSET.negativeInfDefault.v);  return _accessor.mutate(negativeInfDefault, index: o) }
-  public var negativeInfinityDefault: Float32 { let o = _accessor.offset(VTOFFSET.negativeInfinityDefault.v); return o == 0 ? -infinity : _accessor.readBuffer(of: Float32.self, at: o) }
+  public var negativeInfinityDefault: Float32 { let o = _accessor.offset(VTOFFSET.negativeInfinityDefault.v); return o == 0 ? -.infinity : _accessor.readBuffer(of: Float32.self, at: o) }
  @discardableResult public func mutate(negativeInfinityDefault: Float32) -> Bool {let o = _accessor.offset(VTOFFSET.negativeInfinityDefault.v);  return _accessor.mutate(negativeInfinityDefault, index: o) }
-  public var doubleInfDefault: Double { let o = _accessor.offset(VTOFFSET.doubleInfDefault.v); return o == 0 ? inf : _accessor.readBuffer(of: Double.self, at: o) }
+  public var doubleInfDefault: Double { let o = _accessor.offset(VTOFFSET.doubleInfDefault.v); return o == 0 ? .infinity : _accessor.readBuffer(of: Double.self, at: o) }
  @discardableResult public func mutate(doubleInfDefault: Double) -> Bool {let o = _accessor.offset(VTOFFSET.doubleInfDefault.v);  return _accessor.mutate(doubleInfDefault, index: o) }
  public static func startMonster(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 62) }
  public static func add(pos: MyGame_Example_Vec3?, _ fbb: inout FlatBufferBuilder) { guard let pos = pos else { return }; fbb.create(struct: pos, position: VTOFFSET.pos.p) }
@@ -1422,14 +1422,14 @@ public struct MyGame_Example_Monster: FlatBufferObject, Verifiable, ObjectAPIPac
  public static func add(nativeInline: MyGame_Example_Test?, _ fbb: inout FlatBufferBuilder) { guard let nativeInline = nativeInline else { return }; fbb.create(struct: nativeInline, position: VTOFFSET.nativeInline.p) }
  public static func add(longEnumNonEnumDefault: MyGame_Example_LongEnum, _ fbb: inout FlatBufferBuilder) { fbb.add(element: longEnumNonEnumDefault.rawValue, def: 0, at: VTOFFSET.longEnumNonEnumDefault.p) }
  public static func add(longEnumNormalDefault: MyGame_Example_LongEnum, _ fbb: inout FlatBufferBuilder) { fbb.add(element: longEnumNormalDefault.rawValue, def: 2, at: VTOFFSET.longEnumNormalDefault.p) }
-  public static func add(nanDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: nanDefault, def: nan, at: VTOFFSET.nanDefault.p) }
-  public static func add(infDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: infDefault, def: inf, at: VTOFFSET.infDefault.p) }
-  public static func add(positiveInfDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: positiveInfDefault, def: +inf, at: VTOFFSET.positiveInfDefault.p) }
-  public static func add(infinityDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: infinityDefault, def: infinity, at: VTOFFSET.infinityDefault.p) }
-  public static func add(positiveInfinityDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: positiveInfinityDefault, def: +infinity, at: VTOFFSET.positiveInfinityDefault.p) }
-  public static func add(negativeInfDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: negativeInfDefault, def: -inf, at: VTOFFSET.negativeInfDefault.p) }
-  public static func add(negativeInfinityDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: negativeInfinityDefault, def: -infinity, at: VTOFFSET.negativeInfinityDefault.p) }
-  public static func add(doubleInfDefault: Double, _ fbb: inout FlatBufferBuilder) { fbb.add(element: doubleInfDefault, def: inf, at: VTOFFSET.doubleInfDefault.p) }
+  public static func add(nanDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: nanDefault, def: .nan, at: VTOFFSET.nanDefault.p) }
+  public static func add(infDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: infDefault, def: .infinity, at: VTOFFSET.infDefault.p) }
+  public static func add(positiveInfDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: positiveInfDefault, def: .infinity, at: VTOFFSET.positiveInfDefault.p) }
+  public static func add(infinityDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: infinityDefault, def: .infinity, at: VTOFFSET.infinityDefault.p) }
+  public static func add(positiveInfinityDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: positiveInfinityDefault, def: .infinity, at: VTOFFSET.positiveInfinityDefault.p) }
+  public static func add(negativeInfDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: negativeInfDefault, def: -.infinity, at: VTOFFSET.negativeInfDefault.p) }
+  public static func add(negativeInfinityDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: negativeInfinityDefault, def: -.infinity, at: VTOFFSET.negativeInfinityDefault.p) }
+  public static func add(doubleInfDefault: Double, _ fbb: inout FlatBufferBuilder) { fbb.add(element: doubleInfDefault, def: .infinity, at: VTOFFSET.doubleInfDefault.p) }
  public static func endMonster(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); fbb.require(table: end, fields: [10]); return end }
  public static func createMonster(
    _ fbb: inout FlatBufferBuilder,
@@ -1486,14 +1486,14 @@ public struct MyGame_Example_Monster: FlatBufferObject, Verifiable, ObjectAPIPac
    nativeInline: MyGame_Example_Test? = nil,
    longEnumNonEnumDefault: MyGame_Example_LongEnum = .longone,
    longEnumNormalDefault: MyGame_Example_LongEnum = .longone,
-    nanDefault: Float32 = nan,
-    infDefault: Float32 = inf,
-    positiveInfDefault: Float32 = +inf,
-    infinityDefault: Float32 = infinity,
-    positiveInfinityDefault: Float32 = +infinity,
-    negativeInfDefault: Float32 = -inf,
-    negativeInfinityDefault: Float32 = -infinity,
-    doubleInfDefault: Double = inf
+    nanDefault: Float32 = .nan,
+    infDefault: Float32 = .infinity,
+    positiveInfDefault: Float32 = .infinity,
+    infinityDefault: Float32 = .infinity,
+    positiveInfinityDefault: Float32 = .infinity,
+    negativeInfDefault: Float32 = -.infinity,
+    negativeInfinityDefault: Float32 = -.infinity,
+    doubleInfDefault: Double = .infinity
  ) -> Offset {
    let __start = MyGame_Example_Monster.startMonster(&fbb)
    MyGame_Example_Monster.add(pos: pos, &fbb)
@@ -2105,28 +2105,28 @@ extension MyGame_Example_Monster: Encodable {
    if longEnumNormalDefault != .longone {
      try container.encodeIfPresent(longEnumNormalDefault, forKey: .longEnumNormalDefault)
    }
-    if nanDefault != nan {
+    if !nanDefault.isNaN {
      try container.encodeIfPresent(nanDefault, forKey: .nanDefault)
    }
-    if infDefault != inf {
+    if infDefault != .infinity {
      try container.encodeIfPresent(infDefault, forKey: .infDefault)
    }
-    if positiveInfDefault != +inf {
+    if positiveInfDefault != .infinity {
      try container.encodeIfPresent(positiveInfDefault, forKey: .positiveInfDefault)
    }
-    if infinityDefault != infinity {
+    if infinityDefault != .infinity {
      try container.encodeIfPresent(infinityDefault, forKey: .infinityDefault)
    }
-    if positiveInfinityDefault != +infinity {
+    if positiveInfinityDefault != .infinity {
      try container.encodeIfPresent(positiveInfinityDefault, forKey: .positiveInfinityDefault)
    }
-    if negativeInfDefault != -inf {
+    if negativeInfDefault != -.infinity {
      try container.encodeIfPresent(negativeInfDefault, forKey: .negativeInfDefault)
    }
-    if negativeInfinityDefault != -infinity {
+    if negativeInfinityDefault != -.infinity {
      try container.encodeIfPresent(negativeInfinityDefault, forKey: .negativeInfinityDefault)
    }
-    if doubleInfDefault != inf {
+    if doubleInfDefault != .infinity {
      try container.encodeIfPresent(doubleInfDefault, forKey: .doubleInfDefault)
    }
  }
@@ -2402,14 +2402,14 @@ public class MyGame_Example_MonsterT: NativeObject {
    nativeInline = MyGame_Example_Test()
    longEnumNonEnumDefault = .longone
    longEnumNormalDefault = .longone
-    nanDefault = nan
-    infDefault = inf
-    positiveInfDefault = +inf
-    infinityDefault = infinity
-    positiveInfinityDefault = +infinity
-    negativeInfDefault = -inf
-    negativeInfinityDefault = -infinity
-    doubleInfDefault = inf
+    nanDefault = .nan
+    infDefault = .infinity
+    positiveInfDefault = .infinity
+    infinityDefault = .infinity
+    positiveInfinityDefault = .infinity
+    negativeInfDefault = -.infinity
+    negativeInfinityDefault = -.infinity
+    doubleInfDefault = .infinity
  }

  public func serialize() -> ByteBuffer { return serialize(type: MyGame_Example_Monster.self) }
--- a/tests/swift/tests/Tests/FlatBuffers.Test.SwiftTests/nan_inf_test_generated.swift
+++ b/tests/swift/tests/Tests/FlatBuffers.Test.SwiftTests/nan_inf_test_generated.swift
@@ -0,0 +1,116 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+// swiftlint:disable all
+// swiftformat:disable all
+
+import FlatBuffers
+
+public struct Swift_Tests_NanInfTable: FlatBufferObject, Verifiable {
+
+  static func validateVersion() { FlatBuffersVersion_22_10_26() }
+  public var __buffer: ByteBuffer! { return _accessor.bb }
+  private var _accessor: Table
+
+  public static func getRootAsNanInfTable(bb: ByteBuffer) -> Swift_Tests_NanInfTable { return Swift_Tests_NanInfTable(Table(bb: bb, position: Int32(bb.read(def: UOffset.self, position: bb.reader)) + Int32(bb.reader))) }
+
+  private init(_ t: Table) { _accessor = t }
+  public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
+
+  private enum VTOFFSET: VOffset {
+    case defaultNan = 4
+    case defaultInf = 6
+    case defaultNinf = 8
+    case valueNan = 10
+    case valueInf = 12
+    case valueNinf = 14
+    case value = 16
+    var v: Int32 { Int32(self.rawValue) }
+    var p: VOffset { self.rawValue }
+  }
+
+  public var defaultNan: Double { let o = _accessor.offset(VTOFFSET.defaultNan.v); return o == 0 ? .nan : _accessor.readBuffer(of: Double.self, at: o) }
+  public var defaultInf: Double { let o = _accessor.offset(VTOFFSET.defaultInf.v); return o == 0 ? .infinity : _accessor.readBuffer(of: Double.self, at: o) }
+  public var defaultNinf: Double { let o = _accessor.offset(VTOFFSET.defaultNinf.v); return o == 0 ? -.infinity : _accessor.readBuffer(of: Double.self, at: o) }
+  public var valueNan: Double { let o = _accessor.offset(VTOFFSET.valueNan.v); return o == 0 ? 0.0 : _accessor.readBuffer(of: Double.self, at: o) }
+  public var valueInf: Double { let o = _accessor.offset(VTOFFSET.valueInf.v); return o == 0 ? 0.0 : _accessor.readBuffer(of: Double.self, at: o) }
+  public var valueNinf: Double { let o = _accessor.offset(VTOFFSET.valueNinf.v); return o == 0 ? 0.0 : _accessor.readBuffer(of: Double.self, at: o) }
+  public var value: Double { let o = _accessor.offset(VTOFFSET.value.v); return o == 0 ? 0.0 : _accessor.readBuffer(of: Double.self, at: o) }
+  public static func startNanInfTable(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 7) }
+  public static func add(defaultNan: Double, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultNan, def: .nan, at: VTOFFSET.defaultNan.p) }
+  public static func add(defaultInf: Double, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultInf, def: .infinity, at: VTOFFSET.defaultInf.p) }
+  public static func add(defaultNinf: Double, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultNinf, def: -.infinity, at: VTOFFSET.defaultNinf.p) }
+  public static func add(valueNan: Double, _ fbb: inout FlatBufferBuilder) { fbb.add(element: valueNan, def: 0.0, at: VTOFFSET.valueNan.p) }
+  public static func add(valueInf: Double, _ fbb: inout FlatBufferBuilder) { fbb.add(element: valueInf, def: 0.0, at: VTOFFSET.valueInf.p) }
+  public static func add(valueNinf: Double, _ fbb: inout FlatBufferBuilder) { fbb.add(element: valueNinf, def: 0.0, at: VTOFFSET.valueNinf.p) }
+  public static func add(value: Double, _ fbb: inout FlatBufferBuilder) { fbb.add(element: value, def: 0.0, at: VTOFFSET.value.p) }
+  public static func endNanInfTable(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); return end }
+  public static func createNanInfTable(
+    _ fbb: inout FlatBufferBuilder,
+    defaultNan: Double = .nan,
+    defaultInf: Double = .infinity,
+    defaultNinf: Double = -.infinity,
+    valueNan: Double = 0.0,
+    valueInf: Double = 0.0,
+    valueNinf: Double = 0.0,
+    value: Double = 0.0
+  ) -> Offset {
+    let __start = Swift_Tests_NanInfTable.startNanInfTable(&fbb)
+    Swift_Tests_NanInfTable.add(defaultNan: defaultNan, &fbb)
+    Swift_Tests_NanInfTable.add(defaultInf: defaultInf, &fbb)
+    Swift_Tests_NanInfTable.add(defaultNinf: defaultNinf, &fbb)
+    Swift_Tests_NanInfTable.add(valueNan: valueNan, &fbb)
+    Swift_Tests_NanInfTable.add(valueInf: valueInf, &fbb)
+    Swift_Tests_NanInfTable.add(valueNinf: valueNinf, &fbb)
+    Swift_Tests_NanInfTable.add(value: value, &fbb)
+    return Swift_Tests_NanInfTable.endNanInfTable(&fbb, start: __start)
+  }
+
+  public static func verify<T>(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable {
+    var _v = try verifier.visitTable(at: position)
+    try _v.visit(field: VTOFFSET.defaultNan.p, fieldName: "defaultNan", required: false, type: Double.self)
+    try _v.visit(field: VTOFFSET.defaultInf.p, fieldName: "defaultInf", required: false, type: Double.self)
+    try _v.visit(field: VTOFFSET.defaultNinf.p, fieldName: "defaultNinf", required: false, type: Double.self)
+    try _v.visit(field: VTOFFSET.valueNan.p, fieldName: "valueNan", required: false, type: Double.self)
+    try _v.visit(field: VTOFFSET.valueInf.p, fieldName: "valueInf", required: false, type: Double.self)
+    try _v.visit(field: VTOFFSET.valueNinf.p, fieldName: "valueNinf", required: false, type: Double.self)
+    try _v.visit(field: VTOFFSET.value.p, fieldName: "value", required: false, type: Double.self)
+    _v.finish()
+  }
+}
+
+extension Swift_Tests_NanInfTable: Encodable {
+
+  enum CodingKeys: String, CodingKey {
+    case defaultNan = "default_nan"
+    case defaultInf = "default_inf"
+    case defaultNinf = "default_ninf"
+    case valueNan = "value_nan"
+    case valueInf = "value_inf"
+    case valueNinf = "value_ninf"
+    case value = "value"
+  }
+  public func encode(to encoder: Encoder) throws {
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    if !defaultNan.isNaN {
+      try container.encodeIfPresent(defaultNan, forKey: .defaultNan)
+    }
+    if defaultInf != .infinity {
+      try container.encodeIfPresent(defaultInf, forKey: .defaultInf)
+    }
+    if defaultNinf != -.infinity {
+      try container.encodeIfPresent(defaultNinf, forKey: .defaultNinf)
+    }
+    if valueNan != 0.0 {
+      try container.encodeIfPresent(valueNan, forKey: .valueNan)
+    }
+    if valueInf != 0.0 {
+      try container.encodeIfPresent(valueInf, forKey: .valueInf)
+    }
+    if valueNinf != 0.0 {
+      try container.encodeIfPresent(valueNinf, forKey: .valueNinf)
+    }
+    if value != 0.0 {
+      try container.encodeIfPresent(value, forKey: .value)
+    }
+  }
+}
+