format comment, expect_failure, macro... (#185)

Author: zcy1024

book/move-basics/testing.md

@@ -14,19 +14,22 @@ the bytecode and are never published.
 ```move
 module book::testing;
 
+#[test_only]
+use std::unit_test::assert_eq;
+
 // The test attribute is placed before the `fun` keyword (can be both above or
 // right before the `fun` keyword, as in `#[test] fun my_test() { ... }`)
 // The name of the test in this case would be `book::testing::simple_test`.
 #[test]
 fun simple_test() {
     let sum = 2 + 2;
-    assert!(sum == 4);
+    assert_eq!(sum, 4);
 }
 
 // The name of this test would be `book::testing::more_advanced_test`.
 #[test] fun more_advanced_test() {
     let sum = 2 + 2 + 2;
-    assert!(sum == 4);
+    assert_eq!(sum, 4);
 }
 ```
 
@@ -94,6 +97,9 @@ where the `#[test_only]` attribute comes in handy.
 ```move
 module book::testing;
 
+#[test_only]
+use std::unit_test::assert_eq;
+
 // Public function which uses the `secret` function.
 public fun multiply_by_secret(x: u64): u64 {
     x * secret()
@@ -114,7 +120,7 @@ public fun secret_for_testing(): u64 {
 // In the test environment we have access to the `secret_for_testing` function.
 fun test_multiply_by_secret() {
     let expected = secret_for_testing() * 2;
-    assert!(multiply_by_secret(2) == expected);
+    assert_eq!(multiply_by_secret(2), expected);
 }
 ```
 

book/programmability/witness-pattern.md

@@ -96,7 +96,7 @@ public struct Balance<phantom T> has store {
 
 /// Increase supply by `value` and create a new `Balance<T>` with this value.
 public fun increase_supply<T>(self: &mut Supply<T>, value: u64): Balance<T> {
-    assert!(value < (18446744073709551615u64 - self.value), EOverflow);
+    assert!(value < (std::u64::max_value!() - self.value), EOverflow);
     self.value = self.value + value;
     Balance { value }
 }

book/your-first-move/hello-world.md

@@ -148,18 +148,7 @@ excludes comments and some identifiers (for example, for constants).
 To demonstrate these features, let's replace the contents of the _sources/hello_world.move_ file
 with the following:
 
-```move
-/// The module `hello_world` under named address `hello_world`.
-/// The named address is set in the `Move.toml`.
-module hello_world::hello_world;
-
-// Imports the `String` type from the Standard Library
-use std::string::String;
-
-/// Returns the "Hello, World!" as a `String`.
-public fun hello_world(): String {
-    b"Hello, World!".to_string()
-}
+```move file=packages/hello_world/sources/hello_world.move anchor=source
 ```
 
 During compilation, the code is built, but not run. A compiled package only includes functions that
@@ -201,16 +190,7 @@ the compiler. We explain tests in depth in the [Testing](./../move-basics/testin
 
 Replace the contents of the `tests/hello_world_tests.move` with the following content:
 
-```move
-#[test_only]
-module hello_world::hello_world_tests;
-
-use hello_world::hello_world;
-
-#[test]
-fun test_hello_world() {
-    assert!(hello_world::hello_world() == b"Hello, World!".to_string(), 0);
-}
+```move file=packages/hello_world/tests/hello_world_tests.move anchor=test
 ```
 
 Here we import the `hello_world` module, and call its `hello_world` function to test that the output

packages/hello_world/sources/hello_world.move

@@ -1,3 +1,4 @@
+// ANCHOR: source
 /// The module `hello_world` under named address `hello_world`.
 /// The named address is set in the `Move.toml`.
 module hello_world::hello_world;
@@ -9,3 +10,4 @@ use std::string::String;
 public fun hello_world(): String {
     b"Hello, World!".to_string()
 }
+// ANCHOR_END: source

packages/hello_world/tests/hello_world_tests.move

@@ -1,9 +1,13 @@
+// ANCHOR: test
 #[test_only]
 module hello_world::hello_world_tests;
 
+use std::unit_test::assert_eq;
+
 use hello_world::hello_world;
 
 #[test]
 fun test_hello_world() {
-    assert!(hello_world::hello_world() == b"Hello, World!".to_string(), 0);
+    assert_eq!(hello_world::hello_world(), b"Hello, World!".to_string());
 }
+// ANCHOR_END: test

packages/samples/examples/buffer.move

@@ -1,51 +1,46 @@
 // Copyright (c) Mysten Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-module book::buffer {
-    /// Error returned when the buffer is overflowed.
-    const EBufferOverflow: u64 = 0;
-
-    /// The Buffer struct represents a growable buffer.
-    public struct Buffer {
-        data: vector<u8>,
-        expected_len: Option<u64>
-    }
-
-    /// Creates a new empty buffer.
-    public fun new(): Buffer {
-        Buffer { data: vector[], expected_len: option::none() }
-    }
-
-    /// Creates a new empty buffer with the specified capacity (in bytes).
-    /// If the buffer is overflowed, tx aborts with `EBufferOverflow`.
-    public fun alloc(len: u64): Buffer {
-        Buffer { data: vector[], expected_len: option::some(len) }
-    }
-
-    /// Pushes the given data to the end of the buffer.
-    public fun push(self: &mut Buffer, data: vector<u8>) {
-        if (option::is_some(&self.expected_len)) {
-            let max_len = *option::borrow(&self.expected_len);
-            let future_len = self.len() + vector::length(&data);
-            assert!(future_len <= max_len, EBufferOverflow);
-        };
-
-        vector::append(&mut self.data, data)
-    }
-
-    /// Unwraps the buffer and returns the underlying vector.
-    public fun unwrap(self: Buffer): vector<u8> {
-        let Buffer { data, expected_len: _ } = self;
-        data
-    }
-
-    /// Returns the length of the buffer.
-    public fun len(self: &Buffer): u64 {
-        vector::length(&self.data)
-    }
-
-    /// Returns `true` if the buffer is empty.
-    public fun is_empty(self: &Buffer): bool {
-        vector::is_empty(&self.data)
-    }
+module book::buffer;
+
+/// Error returned when the buffer is overflowed.
+const EBufferOverflow: u64 = 0;
+
+/// The Buffer struct represents a growable buffer.
+public struct Buffer {
+    data: vector<u8>,
+    expected_len: Option<u64>
+}
+
+/// Creates a new empty buffer.
+public fun new(): Buffer {
+    Buffer { data: vector[], expected_len: option::none() }
+}
+
+/// Creates a new empty buffer with the specified capacity (in bytes).
+/// If the buffer is overflowed, tx aborts with `EBufferOverflow`.
+public fun alloc(len: u64): Buffer {
+    Buffer { data: vector[], expected_len: option::some(len) }
+}
+
+/// Pushes the given data to the end of the buffer.
+public fun push(self: &mut Buffer, data: vector<u8>) {
+    self.expected_len.do_ref!(|max_len| assert!(self.len() + data.length() <= *max_len, EBufferOverflow));
+    self.data.append(data)
+}
+
+/// Unwraps the buffer and returns the underlying vector.
+public fun unwrap(self: Buffer): vector<u8> {
+    let Buffer { data, expected_len: _ } = self;
+    data
+}
+
+/// Returns the length of the buffer.
+public fun len(self: &Buffer): u64 {
+    self.data.length()
+}
+
+/// Returns `true` if the buffer is empty.
+public fun is_empty(self: &Buffer): bool {
+    self.data.is_empty()
 }

packages/samples/examples/ticket.move

@@ -1,44 +1,44 @@
 // Copyright (c) Mysten Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-module book::ticket {
-    /// A Ticket for an event or a service. Non-transferable by default and
-    /// the usage varies based on the application.
-    public struct Ticket<T: store + drop> has key {
-        id: UID,
-        used: bool,
-        metadata: T
-    }
+module book::ticket;
 
-    /// Create a new Ticket with the metadata and the context.
-    /// No need for a Witness here!
-    public fun new<T: store + drop>(metadata: T, ctx: &mut TxContext): Ticket<T> {
-        Ticket {
-            id: object::new(ctx),
-            used: false,
-            metadata
-        }
-    }
+/// A Ticket for an event or a service. Non-transferable by default and
+/// the usage varies based on the application.
+public struct Ticket<T: store + drop> has key {
+    id: UID,
+    used: bool,
+    metadata: T
+}
 
-    /// Consume the Ticket. Requires a Witness of the metadata type.
-    /// May or may not be implemented by the application.
-    public fun consume<T: store + drop>(_meta: T, ticket: &mut Ticket<T>) {
-        ticket.used = true;
+/// Create a new Ticket with the metadata and the context.
+/// No need for a Witness here!
+public fun new<T: store + drop>(metadata: T, ctx: &mut TxContext): Ticket<T> {
+    Ticket {
+        id: object::new(ctx),
+        used: false,
+        metadata
     }
+}
 
-    /// Transfer the Ticket to another user. Requires a Witness of the metadata type.
-    /// May or may not be implemented by the application.
-    public fun transfer<T: store + drop>(_meta: T, ticket: Ticket<T>, to: address) {
-        transfer::transfer(ticket, to)
-    }
+/// Consume the Ticket. Requires a Witness of the metadata type.
+/// May or may not be implemented by the application.
+public fun consume<T: store + drop>(_meta: T, ticket: &mut Ticket<T>) {
+    ticket.used = true;
+}
 
-    /// Get the metadata of the Ticket.
-    public fun metadata<T: store + drop>(ticket: &Ticket<T>): &T {
-        &ticket.metadata
-    }
+/// Transfer the Ticket to another user. Requires a Witness of the metadata type.
+/// May or may not be implemented by the application.
+public fun transfer<T: store + drop>(_meta: T, ticket: Ticket<T>, to: address) {
+    transfer::transfer(ticket, to)
+}
 
-    /// Check if the Ticket has been used.
-    public fun is_used<T: store + drop>(ticket: &Ticket<T>): bool {
-        ticket.used
-    }
+/// Get the metadata of the Ticket.
+public fun metadata<T: store + drop>(ticket: &Ticket<T>): &T {
+    &ticket.metadata
+}
+
+/// Check if the Ticket has been used.
+public fun is_used<T: store + drop>(ticket: &Ticket<T>): bool {
+    ticket.used
 }

packages/samples/sources/move-basics/constants-shop-price.move

@@ -6,6 +6,9 @@ module book::shop_price;
 
 use sui::{coin::Coin, sui::SUI};
 
+/// Trying to purchase an item at an incorrect price.
+const EWrongPrice: u64 = 0;
+
 /// The price of an item in the shop.
 const ITEM_PRICE: u64 = 100;
 /// The owner of the shop, an address.
@@ -16,7 +19,7 @@ public struct Item {}
 
 /// Purchase an item from the shop.
 public fun purchase(coin: Coin<SUI>): Item {
-    assert!(coin.value() == ITEM_PRICE);
+    assert!(coin.value() == ITEM_PRICE, EWrongPrice);
 
     transfer::public_transfer(coin, SHOP_OWNER);
 

packages/samples/sources/move-basics/control-flow.move

@@ -1,10 +1,14 @@
 // Copyright (c) Mysten Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
+#[allow(unused_function)]
 // ANCHOR: module
 module book::control_flow;
 // ANCHOR_END: module
 
+#[test_only]
+use std::unit_test::assert_eq;
+
 // ANCHOR: if_condition
 #[test]
 fun test_if() {
@@ -26,7 +30,7 @@ fun test_if_else() {
         0
     };
 
-    assert!(y == 1);
+    assert_eq!(y, 1);
 }
 // ANCHOR_END: if_else
 // ANCHOR: while_loop
@@ -50,9 +54,9 @@ fun while_loop(mut x: u8): u8 {
 
 #[test]
 fun test_while() {
-    assert!(while_loop(0) == 10); // 10 times
-    assert!(while_loop(5) == 5);  // 5 times
-    assert!(while_loop(10) == 0); // loop never executed
+    assert_eq!(while_loop(0), 10); // 10 times
+    assert_eq!(while_loop(5), 5); // 5 times
+    assert_eq!(while_loop(10), 0); // loop never executed
 }
 // ANCHOR_END: while_loop
 // ANCHOR: infinite_while
@@ -66,7 +70,7 @@ fun test_infinite_while() {
     };
 
     // This line will never be executed.
-    assert!(x == 5);
+    assert_eq!(x, 5);
 }
 // ANCHOR_END: infinite_while
 #[allow(dead_code)]
@@ -81,7 +85,7 @@ fun test_infinite_loop() {
     };
 
     // This line will never be executed.
-    assert!(x == 5);
+    assert_eq!(x, 5);
 }
 // ANCHOR_END: infinite_loop
 // ANCHOR: break_loop
@@ -99,7 +103,7 @@ fun test_break_loop() {
         }
     };
 
-    assert!(x == 5);
+    assert_eq!(x, 5);
 }
 // ANCHOR_END: break_loop
 // ANCHOR: continue_loop
@@ -124,7 +128,7 @@ fun test_continue_loop() {
         }
     };
 
-    assert!(x == 10); // 10
+    assert_eq!(x, 10) // 10
 }
 // ANCHOR_END: continue_loop
 // ANCHOR: return_statement
@@ -144,8 +148,8 @@ fun is_positive(x: u8): bool {
 
 #[test]
 fun test_return() {
-    assert!(is_positive(5) == false);
-    assert!(is_positive(0) == false);
-    assert!(is_positive(1) == true);
+    assert_eq!(is_positive(5), false);
+    assert_eq!(is_positive(0), false);
+    assert_eq!(is_positive(1), true);
 }
 // ANCHOR_END: return_statement