Increase test coverage on std-lib

.github/workflows/ci.yml

@@ -462,7 +462,7 @@ jobs:
       - name: Install Forc
         run: cargo install --locked --debug --path ./forc
       - name: Run Unit Tests
-        run: forc build --path sway-lib-core && forc test --path sway-lib-core && forc build --path sway-lib-std && forc test --path sway-lib-std
+        run: forc build --path sway-lib-core && forc test --path sway-lib-core && forc build --path sway-lib-std && forc test --path sway-lib-std && forc build --path test/src/in_language_tests & forc test --path test/src/in_language_tests
 
   forc-pkg-fuels-deps-check:
     runs-on: ubuntu-latest

sway-lib-std/src/address.sw

@@ -125,35 +125,3 @@ impl Hash for Address {
         bits.hash(state);
     }
 }
-
-#[test]
-fn test_address_from_b256() {
-    use ::assert::assert;
-
-    let my_address = Address::from(0x0000000000000000000000000000000000000000000000000000000000000001);
-    assert(
-        my_address
-            .bits() == 0x0000000000000000000000000000000000000000000000000000000000000001,
-    );
-}
-
-#[test]
-fn test_address_into_b256() {
-    use ::assert::assert;
-    use ::convert::Into;
-
-    let address = Address::from(0x0000000000000000000000000000000000000000000000000000000000000001);
-    let b256_data: b256 = address.into();
-    assert(b256_data == 0x0000000000000000000000000000000000000000000000000000000000000001);
-}
-
-#[test]
-fn test_address_zero() {
-    use ::assert::assert;
-
-    let address = Address::zero();
-    assert(address.is_zero());
-
-    let other_address = Address::from(0x0000000000000000000000000000000000000000000000000000000000000001);
-    assert(!other_address.is_zero());
-}

sway-lib-std/src/array_conversions/b256.sw

@@ -173,55 +173,3 @@ impl b256 {
         }
     }
 }
-
-#[test]
-fn test_b256_from_le_bytes() {
-    let bytes = [
-        32_u8, 31_u8, 30_u8, 29_u8, 28_u8, 27_u8, 26_u8, 25_u8, 24_u8, 23_u8, 22_u8,
-        21_u8, 20_u8, 19_u8, 18_u8, 17_u8, 16_u8, 15_u8, 14_u8, 13_u8, 12_u8, 11_u8,
-        10_u8, 9_u8, 8_u8, 7_u8, 6_u8, 5_u8, 4_u8, 3_u8, 2_u8, 1_u8,
-    ];
-
-    let x = b256::from_le_bytes(bytes);
-
-    assert(x == 0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20);
-}
-
-#[test]
-fn test_b256_to_le_bytes() {
-    let x: b256 = 0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20;
-
-    let bytes = x.to_le_bytes();
-
-    let mut i: u8 = 0;
-    while i < 32_u8 {
-        assert(bytes[i.as_u64()] == 32_u8 - i);
-        i += 1_u8;
-    }
-}
-
-#[test]
-fn test_b256_from_be_bytes() {
-    let bytes = [
-        1_u8, 2_u8, 3_u8, 4_u8, 5_u8, 6_u8, 7_u8, 8_u8, 9_u8, 10_u8, 11_u8, 12_u8,
-        13_u8, 14_u8, 15_u8, 16_u8, 17_u8, 18_u8, 19_u8, 20_u8, 21_u8, 22_u8, 23_u8,
-        24_u8, 25_u8, 26_u8, 27_u8, 28_u8, 29_u8, 30_u8, 31_u8, 32_u8,
-    ];
-
-    let x = b256::from_be_bytes(bytes);
-
-    assert(x == 0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20);
-}
-
-#[test]
-fn test_b256_to_be_bytes() {
-    let x: b256 = 0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20;
-
-    let bytes = x.to_be_bytes();
-
-    let mut i: u8 = 0;
-    while i < 32_u8 {
-        assert(bytes[i.as_u64()] == i + 1_u8);
-        i += 1_u8;
-    }
-}

sway-lib-std/src/array_conversions/u16.sw

@@ -122,37 +122,3 @@ impl u16 {
         }
     }
 }
-
-#[test]
-fn test_u16_to_le_bytes() {
-    let x: u16 = 513;
-    let result = x.to_le_bytes();
-
-    assert(result[0] == 1_u8);
-    assert(result[1] == 2_u8);
-}
-
-#[test]
-fn test_u16_from_le_bytes() {
-    let bytes = [1_u8, 2_u8];
-    let result = u16::from_le_bytes(bytes);
-
-    assert(result == 513_u16);
-}
-
-#[test]
-fn test_u16_to_be_bytes() {
-    let x: u16 = 513;
-    let result = x.to_be_bytes();
-
-    assert(result[0] == 2_u8);
-    assert(result[1] == 1_u8);
-}
-
-#[test]
-fn test_u16_from_be_bytes() {
-    let bytes = [2_u8, 1_u8];
-    let result = u16::from_be_bytes(bytes);
-
-    assert(result == 513_u16);
-}

sway-lib-std/src/array_conversions/u256.sw

@@ -172,55 +172,3 @@ impl u256 {
         }
     }
 }
-
-#[test]
-fn test_u256_from_le_bytes() {
-    let bytes = [
-        32_u8, 31_u8, 30_u8, 29_u8, 28_u8, 27_u8, 26_u8, 25_u8, 24_u8, 23_u8, 22_u8,
-        21_u8, 20_u8, 19_u8, 18_u8, 17_u8, 16_u8, 15_u8, 14_u8, 13_u8, 12_u8, 11_u8,
-        10_u8, 9_u8, 8_u8, 7_u8, 6_u8, 5_u8, 4_u8, 3_u8, 2_u8, 1_u8,
-    ];
-
-    let x = u256::from_le_bytes(bytes);
-
-    assert(x == 0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20u256);
-}
-
-#[test]
-fn test_u256_to_le_bytes() {
-    let x: u256 = 0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20u256;
-
-    let bytes = x.to_le_bytes();
-
-    let mut i: u8 = 0;
-    while i < 32_u8 {
-        assert(bytes[i.as_u64()] == 32_u8 - i);
-        i += 1_u8;
-    }
-}
-
-#[test]
-fn test_u256_from_be_bytes() {
-    let bytes = [
-        1_u8, 2_u8, 3_u8, 4_u8, 5_u8, 6_u8, 7_u8, 8_u8, 9_u8, 10_u8, 11_u8, 12_u8,
-        13_u8, 14_u8, 15_u8, 16_u8, 17_u8, 18_u8, 19_u8, 20_u8, 21_u8, 22_u8, 23_u8,
-        24_u8, 25_u8, 26_u8, 27_u8, 28_u8, 29_u8, 30_u8, 31_u8, 32_u8,
-    ];
-
-    let x = u256::from_be_bytes(bytes);
-
-    assert(x == 0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20u256);
-}
-
-#[test]
-fn test_u256_to_be_bytes() {
-    let x: u256 = 0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20u256;
-
-    let bytes = x.to_be_bytes();
-
-    let mut i: u8 = 0;
-    while i < 32_u8 {
-        assert(bytes[i.as_u64()] == i + 1_u8);
-        i += 1_u8;
-    }
-}

sway-lib-std/src/array_conversions/u32.sw

@@ -189,41 +189,3 @@ impl u32 {
         }
     }
 }
-
-#[test]
-fn test_u32_to_le_bytes() {
-    let x: u32 = 67305985;
-    let result = x.to_le_bytes();
-
-    assert(result[0] == 1_u8);
-    assert(result[1] == 2_u8);
-    assert(result[2] == 3_u8);
-    assert(result[3] == 4_u8);
-}
-
-#[test]
-fn test_u32_from_le_bytes() {
-    let bytes = [1_u8, 2_u8, 3_u8, 4_u8];
-    let result = u32::from_le_bytes(bytes);
-
-    assert(result == 67305985_u32);
-}
-
-#[test]
-fn test_u32_to_be_bytes() {
-    let x: u32 = 67305985;
-    let result = x.to_be_bytes();
-
-    assert(result[0] == 4_u8);
-    assert(result[1] == 3_u8);
-    assert(result[2] == 2_u8);
-    assert(result[3] == 1_u8);
-}
-
-#[test]
-fn test_u32_from_be_bytes() {
-    let bytes = [4_u8, 3_u8, 2_u8, 1_u8];
-    let result = u32::from_be_bytes(bytes);
-
-    assert(result == 67305985_u32);
-}

sway-lib-std/src/array_conversions/u64.sw

@@ -257,49 +257,3 @@ impl u64 {
         }
     }
 }
-
-#[test]
-fn test_u64_to_le_bytes() {
-    let x: u64 = 578437695752307201;
-    let result = x.to_le_bytes();
-
-    assert(result[0] == 1_u8);
-    assert(result[1] == 2_u8);
-    assert(result[2] == 3_u8);
-    assert(result[3] == 4_u8);
-    assert(result[4] == 5_u8);
-    assert(result[5] == 6_u8);
-    assert(result[6] == 7_u8);
-    assert(result[7] == 8_u8);
-}
-
-#[test]
-fn test_u64_from_le_bytes() {
-    let bytes = [1_u8, 2_u8, 3_u8, 4_u8, 5_u8, 6_u8, 7_u8, 8_u8];
-    let result = u64::from_le_bytes(bytes);
-
-    assert(result == 578437695752307201);
-}
-
-#[test]
-fn test_u64_to_be_bytes() {
-    let x: u64 = 578437695752307201;
-    let result = x.to_be_bytes();
-
-    assert(result[0] == 8_u8);
-    assert(result[1] == 7_u8);
-    assert(result[2] == 6_u8);
-    assert(result[3] == 5_u8);
-    assert(result[4] == 4_u8);
-    assert(result[5] == 3_u8);
-    assert(result[6] == 2_u8);
-    assert(result[7] == 1_u8);
-}
-
-#[test]
-fn test_u64_from_be_bytes() {
-    let bytes = [8_u8, 7_u8, 6_u8, 5_u8, 4_u8, 3_u8, 2_u8, 1_u8];
-    let result = u64::from_be_bytes(bytes);
-
-    assert(result == 578437695752307201);
-}

sway-lib-std/src/asset_id.sw

@@ -97,6 +97,11 @@ impl AssetId {
 
     /// Creates a new AssetId with the default SubId for the current contract.
     ///
+    /// # Additional Information
+    ///
+    /// **WARNING** If called in an external context, this will **not** return a correct AssetId.
+    /// If called externally, will actually use the Transaction Id as a the ContractId.
+    ///
     /// # Returns
     ///
     /// * [AssetId] - The AssetId of the asset. Computed by hashing the ContractId and the default SubId.
@@ -240,67 +245,3 @@ impl From<AssetId> for b256 {
         id.bits()
     }
 }
-
-#[test()]
-fn test_hasher_sha256_asset_id() {
-    use ::assert::assert;
-    let mut hasher = Hasher::new();
-    AssetId::from(0x0000000000000000000000000000000000000000000000000000000000000000)
-        .hash(hasher);
-    let s256 = hasher.sha256();
-    assert(s256 == 0x66687aadf862bd776c8fc18b8e9f8e20089714856ee233b3902a591d0d5f2925);
-
-    let mut hasher = Hasher::new();
-    AssetId::from(0x0000000000000000000000000000000000000000000000000000000000000001)
-        .hash(hasher);
-    let s256 = hasher.sha256();
-    assert(s256 == 0xec4916dd28fc4c10d78e287ca5d9cc51ee1ae73cbfde08c6b37324cbfaac8bc5);
-}
-
-#[test()]
-fn test_hasher_sha256_contract_id() {
-    use ::assert::assert;
-    let mut hasher = Hasher::new();
-    ContractId::from(0x0000000000000000000000000000000000000000000000000000000000000000)
-        .hash(hasher);
-    let s256 = hasher.sha256();
-    assert(s256 == 0x66687aadf862bd776c8fc18b8e9f8e20089714856ee233b3902a591d0d5f2925);
-
-    let mut hasher = Hasher::new();
-    ContractId::from(0x0000000000000000000000000000000000000000000000000000000000000001)
-        .hash(hasher);
-    let s256 = hasher.sha256();
-    assert(s256 == 0xec4916dd28fc4c10d78e287ca5d9cc51ee1ae73cbfde08c6b37324cbfaac8bc5);
-}
-
-#[test]
-fn test_asset_id_from_b256() {
-    use ::assert::assert;
-
-    let my_asset = AssetId::from(0x0000000000000000000000000000000000000000000000000000000000000001);
-    assert(
-        my_asset
-            .bits() == 0x0000000000000000000000000000000000000000000000000000000000000001,
-    );
-}
-
-#[test]
-fn test_asset_id_into_b256() {
-    use ::assert::assert;
-    use ::convert::Into;
-
-    let asset = AssetId::from(0x0000000000000000000000000000000000000000000000000000000000000001);
-    let b256_data: b256 = asset.into();
-    assert(b256_data == 0x0000000000000000000000000000000000000000000000000000000000000001);
-}
-
-#[test]
-fn test_asset_id_zero() {
-    use ::assert::assert;
-
-    let asset = AssetId::zero();
-    assert(asset.is_zero());
-
-    let other_assert = AssetId::from(0x0000000000000000000000000000000000000000000000000000000000000001);
-    assert(!other_assert.is_zero());
-}