Correcting argument order in assertEqual and XCTAssertEqual (#392)

And fixes extra whitespace.

Author: Shashi456

Tests/TensorFlowTests/LayerTests.swift

@@ -373,8 +373,8 @@ final class LayerTests: XCTestCase {
 
         let weightBatched = Tensor<Float>(shape: [2, 2, 3], scalars: (0..<12).map(Float.init))
         let biasBatched = Tensor<Float>([[1.0, 2.0, 3.0]])
-        let layerBatched = Dense<Float>(weight: weightBatched, 
-                                        bias: biasBatched, 
+        let layerBatched = Dense<Float>(weight: weightBatched,
+                                        bias: biasBatched,
                                         activation: identity)
         let inputBatched = Tensor<Float>(shape: [2, 2], scalars: (0..<4).map(Float.init))
         let outputBatched = layerBatched.inferring(from: inputBatched)
@@ -420,7 +420,7 @@ final class LayerTests: XCTestCase {
         let expected = Tensor<Float>([[0.0], [0.7615942], [0.9640276], [0.9950547], [0.9993292]])
         XCTAssertEqual(output, expected)
     }
-    
+
     func testBatchNorm() {
         let x = Tensor<Float>([
             [  -1.0474433,  -0.11914538,  -0.08634827,   0.15446888,    1.0572497],
@@ -474,7 +474,7 @@ final class LayerTests: XCTestCase {
                         accuracy: 1e-5)
         }
     }
-    
+
     func testLayerNorm() {
         let x = Tensor<Float>([
             [  -1.0474433,  -0.11914538,  -0.08634827,   0.15446888,    1.0572497],
@@ -485,6 +485,7 @@ final class LayerTests: XCTestCase {
         let lnLayer = LayerNorm<Float>(featureCount: 5, axis: 1)
         let value = lnLayer(x)
         let grad = gradient(at: x, lnLayer) { $1($0).squared().sum() }
+
         // Uses the same values as `testBatchNorm()` above because `LayerNorm` with features on axis
         // `1` is equivalent to `BatchNorm` with features on axis `0`.
         assertEqual(

Tests/TensorFlowTests/LazyTensorTests.swift

@@ -61,7 +61,7 @@ final class LazyTensorTests: XCTestCase {
             let expectedLiveOps = Set<LazyTensorOperationRef>(
                 expectedLive.map { LazyTensorOperationRef($0) }
             )
-            XCTAssertEqual(expectedLiveOps, actualLiveOps)
+            XCTAssertEqual(actualLiveOps, expectedLiveOps)
         }
 
         func assertAll(_ expectedAll: [LazyTensorOperation]) {
@@ -72,7 +72,7 @@ final class LazyTensorTests: XCTestCase {
             let expectedAllOps = Set<LazyTensorOperationRef>(
                 expectedAll.map { LazyTensorOperationRef($0) }
             )
-            XCTAssertEqual(expectedAllOps, actualAllOps)
+            XCTAssertEqual(actualAllOps, expectedAllOps)
         }
 
         let op0 = LazyTensorOperation(

Tests/TensorFlowTests/OperatorTests/BasicTests.swift

@@ -289,7 +289,7 @@ final class BasicOperatorTests: XCTestCase {
         XCTAssertEqual(array3D.scalars, Array(stride(from: 40.0, to: 60, by: 1)))
         XCTAssertEqual(
             array2D.scalars,
-            Array(stride(from: 20.0, to: 25, by: 1)) + 
+            Array(stride(from: 20.0, to: 25, by: 1)) +
             Array(stride(from: 30.0, to: 35, by: 1)))
         XCTAssertEqual(array1D.scalars, Array(stride(from: 1.0, to: 5, by: 2)))
     }
@@ -310,7 +310,7 @@ final class BasicOperatorTests: XCTestCase {
         let array3D = slice3D.array
         let array2D = slice2D.array
         let array1D = slice1D.array
-		
+
         /// Test shapes
         XCTAssertEqual(array3D.shape, [1, 4, 5])
         XCTAssertEqual(array2D.shape, [2, 5])
@@ -362,7 +362,7 @@ final class BasicOperatorTests: XCTestCase {
         XCTAssertEqual(concatenated.array, ShapedArray(shape: [4, 3], scalars: Array(0..<12)))
         XCTAssertEqual(concatenated0.array, ShapedArray(shape: [4, 3], scalars: Array(0..<12)))
         XCTAssertEqual(
-            concatenated1.array, 
+            concatenated1.array,
             ShapedArray(shape: [2, 6], scalars: [0, 1, 2, 6, 7, 8, 3, 4, 5, 9, 10, 11]))
     }
 
@@ -457,12 +457,12 @@ final class BasicOperatorTests: XCTestCase {
         let z = x.unbroadcasted(like: y)
         XCTAssertEqual(z.array, ShapedArray<Float>(repeating: 8, shape: [3, 1, 5]))
     }
-    
+
     func testUnbroadcast3x3To1x3() {
         func foo(tensor: Tensor<Float>, shape: Tensor<Int32>) -> Tensor<Float> {
             tensor.unbroadcasted(toShape: shape)
         }
-        
+
         // [3,3] -> [1,3]
         let atTensor: Tensor<Float> = [
             [1, 2, 3],
@@ -471,26 +471,26 @@ final class BasicOperatorTests: XCTestCase {
         let pb: (Tensor<Float>) -> Tensor<Float> = pullback(at: atTensor) { x in
             foo(tensor: x, shape: [1, 3])
         }
-        
+
         // Same shape as parameter of pullback
         var inputTensor: Tensor<Float> = [[1, 2, 3]]
         var expected: Tensor<Float> = atTensor
-        XCTAssertEqual(expected, pb(inputTensor))
+        XCTAssertEqual(pb(inputTensor), expected)
         // Different shape than parameter of pullback
         inputTensor = [2]
         expected = [
             [2, 2, 2],
             [2, 2, 2],
             [2, 2, 2]]
-        XCTAssertEqual(expected, pb(inputTensor))
-        
+        XCTAssertEqual(pb(inputTensor), expected)
+
         // Same shape as tensor we are differentiating at
         inputTensor = [
             [8, 1, 3],
             [8, 1, 3],
             [8, 1, 3]]
         expected = inputTensor
-        XCTAssertEqual(expected, pb(inputTensor))
+        XCTAssertEqual(pb(inputTensor), expected)
     }
 
     func testSliceUpdate() {
@@ -518,81 +518,81 @@ final class BasicOperatorTests: XCTestCase {
         target .= Tensor(repeating: 1, shape: [1, 3, 1])
         XCTAssertEqual(target, Tensor(repeating: 1, shape: [2, 3, 4]))
     }
-  
+
     func testBroadcast3x0To3x3() {
         func foo(tensor: Tensor<Float>, shape: Tensor<Int32>) -> Tensor<Float> {
             tensor.broadcasted(toShape: shape)
         }
-        
+
         // [3,] -> [3,3]
         let pb: (Tensor<Float>) -> Tensor<Float> = pullback(at: [99, 33, 55]) { x in
             foo(tensor: x, shape: [3, 3])
         }
-        
+
         // Same shape as parameter of pullback
         var inputTensor: Tensor<Float> = [
             [1, 2, 3],
             [1, 2, 3],
             [1, 2, 3]]
         var expected: Tensor<Float> = [3, 6, 9]
-        XCTAssertEqual(expected, pb(inputTensor))
-        
+        XCTAssertEqual(pb(inputTensor), expected)
+
         // Different shape than parameter of pullback
         inputTensor = [
             [1, 2, 3],
             [1, 2, 3],
             [1, 2, 3],
             [1, 2, 3]]
         expected = [4, 8, 12]
-        XCTAssertEqual(expected, pb(inputTensor))
-        
+        XCTAssertEqual(pb(inputTensor), expected)
+
         // Same shape as tensor we are differentiating at
         inputTensor = [1, 2, 3]
         expected = [1, 2, 3]
-        XCTAssertEqual(expected, pb(inputTensor))
-        
+        XCTAssertEqual(pb(inputTensor), expected)
+
         // Extremely padded shape as tensor we are differentiating at
         inputTensor = [[[[[[1, 2, 3]]]]]]
         expected = [1, 2, 3]
-        XCTAssertEqual(expected, pb(inputTensor))
+        XCTAssertEqual(pb(inputTensor), expected)
     }
-    
+
     func testBroadcast3x1To3x3() {
         func foo(tensor: Tensor<Float>, shape: Tensor<Int32>) -> Tensor<Float> {
             tensor.broadcasted(toShape: shape)
         }
-    
+
         // [3,1] -> [3x3]
         let pb: (Tensor<Float>) -> Tensor<Float> = pullback(at: [[99, 33, 55]]) { x in
             foo(tensor: x, shape: [3, 3])
         }
-        
+
         // Same shape as parameter of pullback
         var inputTensor: Tensor<Float> = [
             [1, 2, 3],
             [1, 2, 3],
             [1, 2, 3]]
         var expected: Tensor<Float> = [[3, 6, 9]]
-        XCTAssertEqual(expected, pb(inputTensor))
-        
+        XCTAssertEqual(pb(inputTensor), expected)
+
         // Different shape than parameter of pullback
         inputTensor = [
             [1, 2, 3],
             [1, 2, 3],
             [1, 2, 3],
             [1, 2, 3]]
         expected = [[4, 8, 12]]
-        XCTAssertEqual(expected, pb(inputTensor))
-        
+        XCTAssertEqual(pb(inputTensor), expected)
+
         // Same shape as tensor we are differentiating at
         inputTensor = [[1, 2, 3]]
         expected = [[1, 2, 3]]
-        XCTAssertEqual(expected, pb(inputTensor))
-        
+        XCTAssertEqual(pb(inputTensor), expected)
+
         // Extremely padded shape of tensor we are differentiating at
         inputTensor = [[[[[[1, 2, 3]]]]]]
         expected = [[1, 2, 3]]
-        XCTAssertEqual(expected, pb(inputTensor))
+        XCTAssertEqual(pb(inputTensor), expected)
     }
 
     static var allTests = [

Tests/TensorFlowTests/OperatorTests/MathTests.swift

@@ -81,8 +81,8 @@ final class MathOperatorTests: XCTestCase {
         let target = Tensor<Double>([1, 2, 3, 4, 5]).sum()
         let gradTarget = Tensor<Double>([-0.5,  -4.0, -13.5, -32.0, -62.5])
         let (value, grad) = valueWithGradient(at: x) { rsqrt($0).sum() }
-        XCTAssertEqual(target, value)       
-        XCTAssertEqual(gradTarget, grad)
+        XCTAssertEqual(value, target)
+        XCTAssertEqual(grad, gradTarget)
     }
 
     func testLog1p() {
@@ -463,19 +463,19 @@ final class MathOperatorTests: XCTestCase {
             let a = Tensor<Float>(randomNormal: TensorShape(shape))
             let (q, r) = a.qrDecomposition()
             let aReconstituted = matmul(q,r)
-            assertEqual(a, aReconstituted, accuracy: 1e-5)
+            assertEqual(aReconstituted, a, accuracy: 1e-5)
 
             let (qFull, rFull) = a.qrDecomposition(fullMatrices: true)
             let aReconstitutedFull = matmul(qFull, rFull)
-            assertEqual(a, aReconstitutedFull, accuracy: 1e-5)
+            assertEqual(aReconstitutedFull, a, accuracy: 1e-5)
         }
     }
 
     func testDiagonalPart() {
         // Test on 2-D matrix.
         let t1 = Tensor<Float>(shape: [4, 4], scalars: (1...16).map(Float.init))
         let target1 = Tensor<Float>([1, 6, 11, 16])
-        XCTAssertEqual(target1, t1.diagonalPart())
+        XCTAssertEqual(t1.diagonalPart(), target1)
 
         // Test on 4-D tensor.
         let t2 = Tensor<Float>([[[[1.0, 0.0, 0.0, 0.0],
@@ -495,7 +495,7 @@ final class MathOperatorTests: XCTestCase {
                                  [[0.0, 0.0, 0.0, 0.0],
                                   [0.0, 0.0, 0.0, 8.0]]]])
         let target2 = Tensor<Float>([[1, 2, 3, 4], [5, 6, 7, 8]])
-        XCTAssertEqual(target2, t2.diagonalPart())
+        XCTAssertEqual(t2.diagonalPart(), target2)
     }
 
     func testBroadcastedAddGradient() {