More tests for scalars constructor. (#9694)

Summary: #8366

Reviewed By: bsoyluoglu

Differential Revision: D71930535

Co-authored-by: Anthony Shoumikhin <[email protected]>

Author: kirklandsign

extension/apple/ExecuTorch/__tests__/ModuleTest.swift

@@ -59,17 +59,9 @@ class ModuleTest: XCTestCase {
       return
     }
     let module = Module(filePath: modelPath)
-    var inputData: [Float] = [1.0]
-    let inputTensor = inputData.withUnsafeMutableBytes {
-      Tensor(bytesNoCopy: $0.baseAddress!, shape:[1], dataType: .float)
-    }
-    let inputs = [inputTensor, inputTensor]
+    let inputs = [Tensor([1], dataType: .float), Tensor([1], dataType: .float)]
     var outputs: [Value]?
     XCTAssertNoThrow(outputs = try module.forward(inputs))
-    var outputData: [Float] = [2.0]
-    let outputTensor = outputData.withUnsafeMutableBytes {
-      Tensor(bytesNoCopy: $0.baseAddress!, shape:[1], dataType: .float, shapeDynamism: .static)
-    }
-    XCTAssertEqual(outputs?[0].tensor, outputTensor)
+    XCTAssertEqual(outputs?[0].tensor, Tensor([2], dataType: .float, shapeDynamism: .static))
   }
 }

extension/apple/ExecuTorch/__tests__/TensorTest.swift

@@ -224,6 +224,71 @@ class TensorTest: XCTestCase {
     XCTAssertFalse(tensor4.isEqual(tensor2.copy()))
   }
 
+  func testInitScalarsUInt8() {
+    let data: [UInt8] = [1, 2, 3, 4, 5, 6]
+    let tensor = Tensor(data.map(NSNumber.init), dataType: .byte)
+    XCTAssertEqual(tensor.dataType, .byte)
+    XCTAssertEqual(tensor.shape, [6])
+    XCTAssertEqual(tensor.strides, [1])
+    XCTAssertEqual(tensor.dimensionOrder, [0])
+    XCTAssertEqual(tensor.count, 6)
+    tensor.bytes { pointer, count, dataType in
+      XCTAssertEqual(Array(UnsafeBufferPointer(start: pointer.assumingMemoryBound(to: UInt8.self), count: count)), data)
+    }
+  }
+
+  func testInitScalarsInt8() {
+    let data: [Int8] = [1, 2, 3, 4, 5, 6]
+    let tensor = Tensor(data.map(NSNumber.init), dataType: .char)
+    XCTAssertEqual(tensor.dataType, .char)
+    XCTAssertEqual(tensor.shape, [6])
+    XCTAssertEqual(tensor.strides, [1])
+    XCTAssertEqual(tensor.dimensionOrder, [0])
+    XCTAssertEqual(tensor.count, 6)
+    tensor.bytes { pointer, count, dataType in
+      XCTAssertEqual(Array(UnsafeBufferPointer(start: pointer.assumingMemoryBound(to: Int8.self), count: count)), data)
+    }
+  }
+
+  func testInitScalarsInt16() {
+    let data: [Int16] = [1, 2, 3, 4, 5, 6]
+    let tensor = Tensor(data.map(NSNumber.init))
+    XCTAssertEqual(tensor.dataType, .short)
+    XCTAssertEqual(tensor.shape, [6])
+    XCTAssertEqual(tensor.strides, [1])
+    XCTAssertEqual(tensor.dimensionOrder, [0])
+    XCTAssertEqual(tensor.count, 6)
+    tensor.bytes { pointer, count, dataType in
+      XCTAssertEqual(Array(UnsafeBufferPointer(start: pointer.assumingMemoryBound(to: Int16.self), count: count)), data)
+    }
+  }
+
+  func testInitScalarsInt32() {
+    let data: [Int32] = [1, 2, 3, 4, 5, 6]
+    let tensor = Tensor(data.map(NSNumber.init))
+    XCTAssertEqual(tensor.dataType, .int)
+    XCTAssertEqual(tensor.shape, [6])
+    XCTAssertEqual(tensor.strides, [1])
+    XCTAssertEqual(tensor.dimensionOrder, [0])
+    XCTAssertEqual(tensor.count, 6)
+    tensor.bytes { pointer, count, dataType in
+      XCTAssertEqual(Array(UnsafeBufferPointer(start: pointer.assumingMemoryBound(to: Int32.self), count: count)), data)
+    }
+  }
+
+  func testInitScalarsInt64() {
+    let data: [Int64] = [1, 2, 3, 4, 5, 6]
+    let tensor = Tensor(data.map(NSNumber.init))
+    XCTAssertEqual(tensor.dataType, .long)
+    XCTAssertEqual(tensor.shape, [6])
+    XCTAssertEqual(tensor.strides, [1])
+    XCTAssertEqual(tensor.dimensionOrder, [0])
+    XCTAssertEqual(tensor.count, 6)
+    tensor.bytes { pointer, count, dataType in
+      XCTAssertEqual(Array(UnsafeBufferPointer(start: pointer.assumingMemoryBound(to: Int64.self), count: count)), data)
+    }
+  }
+
   func testInitScalarsFloat() {
     let data: [Float] = [1, 2, 3, 4, 5, 6]
     let tensor = Tensor(data.map(NSNumber.init))
@@ -236,4 +301,95 @@ class TensorTest: XCTestCase {
       XCTAssertEqual(Array(UnsafeBufferPointer(start: pointer.assumingMemoryBound(to: Float.self), count: count)), data)
     }
   }
+
+  func testInitScalarsDouble() {
+    let data: [Double] = [1, 2, 3, 4, 5, 6]
+    let tensor = Tensor(data.map(NSNumber.init))
+    XCTAssertEqual(tensor.dataType, .double)
+    XCTAssertEqual(tensor.shape, [6])
+    XCTAssertEqual(tensor.strides, [1])
+    XCTAssertEqual(tensor.dimensionOrder, [0])
+    XCTAssertEqual(tensor.count, 6)
+    tensor.bytes { pointer, count, dataType in
+      XCTAssertEqual(Array(UnsafeBufferPointer(start: pointer.assumingMemoryBound(to: Double.self), count: count)), data)
+    }
+  }
+
+  func testInitScalarsBool() {
+    let data: [Bool] = [true, false, true, false, true, false]
+    let tensor = Tensor(data.map(NSNumber.init), dataType: .bool)
+    XCTAssertEqual(tensor.dataType, .bool)
+    XCTAssertEqual(tensor.shape, [6])
+    XCTAssertEqual(tensor.strides, [1])
+    XCTAssertEqual(tensor.dimensionOrder, [0])
+    XCTAssertEqual(tensor.count, 6)
+    tensor.bytes { pointer, count, dataType in
+      XCTAssertEqual(Array(UnsafeBufferPointer(start: pointer.assumingMemoryBound(to: Bool.self), count: count)), data)
+    }
+  }
+
+  func testInitScalarsUInt16() {
+    let data: [UInt16] = [1, 2, 3, 4, 5, 6]
+    let tensor = Tensor(data.map(NSNumber.init), dataType: .uInt16)
+    XCTAssertEqual(tensor.dataType, .uInt16)
+    XCTAssertEqual(tensor.shape, [6])
+    XCTAssertEqual(tensor.strides, [1])
+    XCTAssertEqual(tensor.dimensionOrder, [0])
+    XCTAssertEqual(tensor.count, 6)
+    tensor.bytes { pointer, count, dataType in
+      XCTAssertEqual(Array(UnsafeBufferPointer(start: pointer.assumingMemoryBound(to: UInt16.self), count: count)), data)
+    }
+  }
+
+  func testInitScalarsUInt32() {
+    let data: [UInt32] = [1, 2, 3, 4, 5, 6]
+    let tensor = Tensor(data.map(NSNumber.init), dataType: .uInt32)
+    XCTAssertEqual(tensor.dataType, .uInt32)
+    XCTAssertEqual(tensor.shape, [6])
+    XCTAssertEqual(tensor.strides, [1])
+    XCTAssertEqual(tensor.dimensionOrder, [0])
+    XCTAssertEqual(tensor.count, 6)
+    tensor.bytes { pointer, count, dataType in
+      XCTAssertEqual(Array(UnsafeBufferPointer(start: pointer.assumingMemoryBound(to: UInt32.self), count: count)), data)
+    }
+  }
+
+  func testInitScalarsUInt64() {
+    let data: [UInt64] = [1, 2, 3, 4, 5, 6]
+    let tensor = Tensor(data.map(NSNumber.init), dataType: .uInt64)
+    XCTAssertEqual(tensor.dataType, .uInt64)
+    XCTAssertEqual(tensor.shape, [6])
+    XCTAssertEqual(tensor.strides, [1])
+    XCTAssertEqual(tensor.dimensionOrder, [0])
+    XCTAssertEqual(tensor.count, 6)
+    tensor.bytes { pointer, count, dataType in
+      XCTAssertEqual(Array(UnsafeBufferPointer(start: pointer.assumingMemoryBound(to: UInt64.self), count: count)), data)
+    }
+  }
+
+  func testInitScalarsInt() {
+    let data: [Int] = [1, 2, 3, 4, 5, 6]
+    let tensor = Tensor(data.map(NSNumber.init), dataType: .long)
+    XCTAssertEqual(tensor.dataType, .long)
+    XCTAssertEqual(tensor.shape, [6])
+    XCTAssertEqual(tensor.strides, [1])
+    XCTAssertEqual(tensor.dimensionOrder, [0])
+    XCTAssertEqual(tensor.count, 6)
+    tensor.bytes { pointer, count, dataType in
+      XCTAssertEqual(Array(UnsafeBufferPointer(start: pointer.assumingMemoryBound(to: Int.self), count: count)), data)
+    }
+  }
+
+  func testInitScalarsUInt() {
+    let data: [UInt] = [1, 2, 3, 4, 5, 6]
+    let tensor = Tensor(data.map(NSNumber.init), dataType: .uInt64)
+    XCTAssertEqual(tensor.dataType, .uInt64)
+    XCTAssertEqual(tensor.shape, [6])
+    XCTAssertEqual(tensor.strides, [1])
+    XCTAssertEqual(tensor.dimensionOrder, [0])
+    XCTAssertEqual(tensor.count, 6)
+    tensor.bytes { pointer, count, dataType in
+      XCTAssertEqual(Array(UnsafeBufferPointer(start: pointer.assumingMemoryBound(to: UInt.self), count: count)), data)
+    }
+  }
 }

extension/apple/ExecuTorch/__tests__/ValueTest.swift

@@ -17,10 +17,7 @@ class ValueTest: XCTestCase {
   }
 
   func testTensor() {
-    var data: [Float] = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0]
-    let tensor = data.withUnsafeMutableBytes {
-      Tensor(bytesNoCopy: $0.baseAddress!, shape: [2, 3], dataType: .float)
-    }
+    let tensor = Tensor([1.0, 2.0, 3.0, 4.0, 5.0, 6.0])
     let value = Value(tensor)
     XCTAssertTrue(value.isTensor)
     XCTAssertEqual(value.tensor, tensor)