mod.rs

use std::sync::Arc;
use swayfmt::{config::user_def::FieldAlignment, Formatter};

/// Checks if the formatter is producing the same output when given it's output.
fn test_stability(formatted_input: String, formatter: Formatter) -> bool {
    let mut formatter = formatter;
    let formatted_sway_code =
        Formatter::format(&mut formatter, Arc::from(formatted_input.clone()), None).unwrap();
    formatted_input == formatted_sway_code
}

#[test]
fn test_const() {
    let sway_code_to_format = r#"contract;
pub const TEST:u16=10;"#;
    let correct_sway_code = r#"contract;
pub const TEST: u16 = 10;
"#;
    let mut formatter = Formatter::default();
    let formatted_sway_code =
        Formatter::format(&mut formatter, Arc::from(sway_code_to_format), None).unwrap();
    assert_eq!(correct_sway_code, formatted_sway_code);
    assert!(test_stability(formatted_sway_code, formatter));
}

#[test]
fn test_struct_alignment() {
    let sway_code_to_format = r#"contract;
pub struct Foo<T, P> {
   barbazfoo: u64,
   baz  : bool,
}
"#;
    let correct_sway_code = r#"contract;
pub struct Foo<T, P> {
    barbazfoo : u64,
    baz       : bool,
}
"#;

    let mut formatter = Formatter::default();
    formatter.config.structures.field_alignment = FieldAlignment::AlignFields(40);
    let formatted_sway_code =
        Formatter::format(&mut formatter, Arc::from(sway_code_to_format), None).unwrap();
    assert_eq!(correct_sway_code, formatted_sway_code);
    assert!(test_stability(formatted_sway_code, formatter));
}
#[test]
fn test_struct() {
    let sway_code_to_format = r#"contract;
pub struct Foo {
    bar: u64,
    baz: bool
}
"#;
    let correct_sway_code = r#"contract;
pub struct Foo {
    bar: u64,
    baz: bool,
}
"#;
    let mut formatter = Formatter::default();
    let formatted_sway_code =
        Formatter::format(&mut formatter, Arc::from(sway_code_to_format), None).unwrap();
    assert_eq!(correct_sway_code, formatted_sway_code);
    assert!(test_stability(formatted_sway_code, formatter));
}

#[test]
fn test_enum_without_variant_alignment() {
    let sway_code_to_format = r#"contract;

enum Color {
    Blue: (), Green: (),
            Red: (),
    Silver: (),
                    Grey: () }
        "#;
    let correct_sway_code = r#"contract;

enum Color {
    Blue: (),
    Green: (),
    Red: (),
    Silver: (),
    Grey: (),
}
"#;
    let mut formatter = Formatter::default();
    let formatted_sway_code =
        Formatter::format(&mut formatter, Arc::from(sway_code_to_format), None).unwrap();
    assert_eq!(correct_sway_code, formatted_sway_code);
    assert!(test_stability(formatted_sway_code, formatter));
}
#[test]
fn test_enum_with_variant_alignment() {
    let sway_code_to_format = r#"contract;

enum Color {
    Blue: (), Green: (),
            Red: (),
    Silver: (),
                    Grey: (), }
        "#;
    let correct_sway_code = r#"contract;

enum Color {
    Blue   : (),
    Green  : (),
    Red    : (),
    Silver : (),
    Grey   : (),
}
"#;

    // Creating a config with enum_variant_align_threshold that exceeds longest variant length
    let mut formatter = Formatter::default();
    formatter.config.structures.field_alignment = FieldAlignment::AlignFields(20);

    let formatted_sway_code =
        Formatter::format(&mut formatter, Arc::from(sway_code_to_format), None).unwrap();
    assert_eq!(correct_sway_code, formatted_sway_code);
    assert!(test_stability(formatted_sway_code, formatter));
}
#[test]
fn test_item_abi_with_generics_and_attributes() {
    let sway_code_to_format = r#"contract;

abi StorageMapExample {
    #[storage(write)]fn insert_into_map1(key: u64, value: u64);

fn hello(key: u64, value: u64);
}"#;
    let correct_sway_code = r#"contract;

abi StorageMapExample {
    #[storage(write)]
    fn insert_into_map1(key: u64, value: u64);

    fn hello(key: u64, value: u64);
}
"#;
    let mut formatter = Formatter::default();
    let formatted_sway_code =
        Formatter::format(&mut formatter, Arc::from(sway_code_to_format), None).unwrap();
    assert_eq!(correct_sway_code, formatted_sway_code);
    assert!(test_stability(formatted_sway_code, formatter));
}

#[test]
fn test_multi_items() {
    let sway_code_to_format = r#"contract;

pub const TEST: u16 = 10;
pub const TEST1: u16 = 10;"#;
    let correct_sway_code = r#"contract;

pub const TEST: u16 = 10;
pub const TEST1: u16 = 10;
"#;

    let mut formatter = Formatter::default();
    let formatted_sway_code =
        Formatter::format(&mut formatter, Arc::from(sway_code_to_format), None).unwrap();
    assert_eq!(correct_sway_code, formatted_sway_code);
    assert!(test_stability(formatted_sway_code, formatter));
}
#[test]
fn test_ty_formatting() {
    let sway_code_to_format = r#"contract;

enum TestTy {
    Infer:
    _,
    Array : [u8;
    40],
    String:         str[
    4
    ],
    PathType     : root::
example::
    type,
    TupleNil: (),
    Tuple: (   u64,
        u32
    ),
}"#;
    let correct_sway_code = r#"contract;

enum TestTy {
    Infer: _,
    Array: [u8; 40],
    String: str[4],
    PathType: root::example::type,
    TupleNil: (),
    Tuple: (u64, u32),
}
"#;
    let mut formatter = Formatter::default();
    let formatted_sway_code =
        Formatter::format(&mut formatter, Arc::from(sway_code_to_format), None).unwrap();
    assert_eq!(correct_sway_code, formatted_sway_code);
    assert!(test_stability(formatted_sway_code, formatter));
}
#[test]
fn test_storage_without_alignment() {
    let sway_code_to_format = r#"contract;
        struct Type1 {
            foo: u64,
        }

        struct Type2 {
            bar: u64,
        }

        storage {
         var1: Type1=Type1{ foo: 8 },
              var2: Type2=Type2{ bar: 9 },
        }
        "#;
    let correct_sway_code = r#"contract;
struct Type1 {
    foo: u64,
}

struct Type2 {
    bar: u64,
}

storage {
    var1: Type1 = Type1 { foo: 8 },
    var2: Type2 = Type2 { bar: 9 },
}
"#;

    let mut formatter = Formatter::default();
    let formatted_sway_code =
        Formatter::format(&mut formatter, Arc::from(sway_code_to_format), None).unwrap();
    assert_eq!(correct_sway_code, formatted_sway_code);
    assert!(test_stability(formatted_sway_code, formatter));
}
#[test]
fn test_storage_with_alignment() {
    let sway_code_to_format = r#"contract;
struct Type1 {
    foo: u64,
}

struct Type2 {
    bar: u64,
}

storage {
 long_var_name: Type1=Type1{ foo: 8 },
      var2: Type2=Type2{ bar: 9 },
}
"#;
    let correct_sway_code = r#"contract;
struct Type1 {
    foo : u64,
}

struct Type2 {
    bar : u64,
}

storage {
    long_var_name : Type1 = Type1 { foo: 8 },
    var2          : Type2 = Type2 { bar: 9 },
}
"#;

    let mut formatter = Formatter::default();
    formatter.config.structures.field_alignment = FieldAlignment::AlignFields(50);
    let formatted_sway_code =
        Formatter::format(&mut formatter, Arc::from(sway_code_to_format), None).unwrap();
    assert_eq!(correct_sway_code, formatted_sway_code);
    assert!(test_stability(formatted_sway_code, formatter));
}
#[test]
fn test_storage_initializer() {
    let sway_code_to_format = r#"contract;

struct Type1 {
    x: u64,
    y: u64,
}

struct Type2 {
    w: b256,
    z: bool,
}

storage {
    var1: Type1 = Type1 {



        x: 0,

        y:
        0,
        },
    var2: Type2 = Type2 { w: 0x0000000000000000000000000000000000000000000000000000000000000000,z: false,
    },
}"#;
    let correct_sway_code = r#"contract;

struct Type1 {
    x: u64,
    y: u64,
}

struct Type2 {
    w: b256,
    z: bool,
}

storage {
    var1: Type1 = Type1 { x: 0, y: 0 },
    var2: Type2 = Type2 {
        w: 0x0000000000000000000000000000000000000000000000000000000000000000,
        z: false,
    },
}
"#;
    let mut formatter = Formatter::default();
    let formatted_sway_code =
        Formatter::format(&mut formatter, Arc::from(sway_code_to_format), None).unwrap();
    assert_eq!(correct_sway_code, formatted_sway_code);
    assert!(test_stability(formatted_sway_code, formatter));
}
#[test]
fn test_item_fn() {
    let sway_code_to_format = r#"contract;

pub fn hello( person: String ) -> String {let greeting = 42;greeting.to_string()}
fn goodbye() -> usize {let farewell: usize = 5; farewell }"#;
    let correct_sway_code = r#"contract;

pub fn hello(person: String) -> String {
    let greeting = 42;
    greeting.to_string()
}
fn goodbye() -> usize {
    let farewell: usize = 5;
    farewell
}
"#;
    let mut formatter = Formatter::default();
    let formatted_sway_code =
        Formatter::format(&mut formatter, Arc::from(sway_code_to_format), None).unwrap();
    assert_eq!(correct_sway_code, formatted_sway_code);
    assert!(test_stability(formatted_sway_code, formatter));
}
#[test]
fn test_same_line_where() {
    let sway_code_to_format = r#"contract;

pub fn hello( person: String ) -> String where T: Eq,{let greeting = 42;greeting.to_string()}"#;
    let correct_sway_code = r#"contract;

pub fn hello(person: String) -> String
where
    T: Eq,
{
    let greeting = 42;
    greeting.to_string()
}
"#;
    let mut formatter = Formatter::default();
    let formatted_sway_code =
        Formatter::format(&mut formatter, Arc::from(sway_code_to_format), None).unwrap();
    assert_eq!(correct_sway_code, formatted_sway_code);
    assert!(test_stability(formatted_sway_code, formatter));
}
#[test]
fn test_trait_and_super_trait() {
    let sway_code_to_format = r#"library traits;

trait Person{ fn name( self )->String;fn age( self )->usize; }
trait Student:Person {fn university(self) -> String;}
trait Programmer {fn fav_language(self) -> String;}
trait CompSciStudent: Programmer+Student {fn git_username(self) -> String;}
trait TraitWithGenerics<T> where T: String {fn from(b: T) -> Self;}"#;
    let correct_sway_code = r#"library traits;

trait Person {
    fn name(self) -> String;
    fn age(self) -> usize;
}
trait Student: Person {
    fn university(self) -> String;
}
trait Programmer {
    fn fav_language(self) -> String;
}
trait CompSciStudent: Programmer + Student {
    fn git_username(self) -> String;
}
trait TraitWithGenerics<T>
where
    T: String
{
    fn from(b: T) -> Self;
}
"#;
    let mut formatter = Formatter::default();
    let formatted_sway_code =
        Formatter::format(&mut formatter, Arc::from(sway_code_to_format), None).unwrap();
    assert_eq!(correct_sway_code, formatted_sway_code);
    assert!(test_stability(formatted_sway_code, formatter));
}
#[test]
fn test_method_calls() {
    let sway_code_to_format = r#"script;

struct Opts {
    gas: u64,
    coins: u64,
    id: ContractId,
}

fn  main(       ) -> bool{
    let default_gas  = 1_000_000_000_000           ;let fuelcoin_id = ContractId::from(0x018f59fe434b323a5054e7bb41de983f4926a3c5d3e4e1f9f33b5f0f0e611889);

    let balance_test_id = ContractId :: from( 0x597e5ddb1a6bec92a96a73e4f0bc6f6e3e7b21f5e03e1c812cd63cffac480463 ) ;

    let fuel_coin = abi(    TestFuelCoin, fuelcoin_id.into(       ) ) ;

    assert(fuelcoin_balance == 0);

    fuel_coin.mint        {
        gas:             default_gas
    }

    (11);

    fuelcoin_balance = balance_of(fuelcoin_id, fuelcoin_id);
    assert( fuelcoin_balance   == 11 ) ;

    fuel_coin.burn {
        gas: default_gas
    }
    (7);

    fuelcoin_balance = balance_of(fuelcoin_id, fuelcoin_id);
    assert(fuelcoin_balance == 4);

    fuel_coin.force_transfer {
        gas: default_gas
    }
    (3, fuelcoin_id, balance_test_id);

    fuelcoin_balance = balance_of(fuelcoin_id, fuelcoin_id);
    let balance_test_contract_balance = balance_of(fuelcoin_id, balance_test_id);
    assert(fuelcoin_balance == 1);
    assert(balance_test_contract_balance == 3);

    true
}"#;

    let correct_sway_code = r#"script;

struct Opts {
    gas: u64,
    coins: u64,
    id: ContractId,
}

fn main() -> bool {
    let default_gas = 1_000_000_000_000;
    let fuelcoin_id = ContractId::from(0x018f59fe434b323a5054e7bb41de983f4926a3c5d3e4e1f9f33b5f0f0e611889);

    let balance_test_id = ContractId::from(0x597e5ddb1a6bec92a96a73e4f0bc6f6e3e7b21f5e03e1c812cd63cffac480463);

    let fuel_coin = abi(TestFuelCoin, fuelcoin_id.into());

    assert(fuelcoin_balance == 0);

    fuel_coin.mint { gas: default_gas }(11);

    fuelcoin_balance = balance_of(fuelcoin_id, fuelcoin_id);
    assert(fuelcoin_balance == 11);

    fuel_coin.burn { gas: default_gas }(7);

    fuelcoin_balance = balance_of(fuelcoin_id, fuelcoin_id);
    assert(fuelcoin_balance == 4);

    fuel_coin.force_transfer { gas: default_gas }(3, fuelcoin_id, balance_test_id);

    fuelcoin_balance = balance_of(fuelcoin_id, fuelcoin_id);
    let balance_test_contract_balance = balance_of(fuelcoin_id, balance_test_id);
    assert(fuelcoin_balance == 1);
    assert(balance_test_contract_balance == 3);

    true
}
"#;
    let mut formatter = Formatter::default();
    formatter.config.structures.small_structures_single_line = true;
    formatter.config.whitespace.max_width = 220;
    let formatted_sway_code =
        Formatter::format(&mut formatter, Arc::from(sway_code_to_format), None).unwrap();
    assert_eq!(correct_sway_code, formatted_sway_code);
    assert!(test_stability(formatted_sway_code, formatter));
}

#[test]
fn test_struct_comments() {
    let sway_code_to_format = r#"contract;
// This is a comment, for this one to be placed correctly we need to have Module visitor implemented
pub struct Foo { // Here is a comment



    // Trying some ASCII art
    baz:u64,




    bazzz:u64

             //  ________ ___  ___  _______   ___               ___       ________  ________  ________
             // |\  _____\\  \|\  \|\  ___ \ |\  \             |\  \     |\   __  \|\   __  \|\   ____\
             // \ \  \__/\ \  \\\  \ \   __/|\ \  \            \ \  \    \ \  \|\  \ \  \|\ /\ \  \___|_
             //  \ \   __\\ \  \\\  \ \  \_|/_\ \  \            \ \  \    \ \   __  \ \   __  \ \_____  \
             //   \ \  \_| \ \  \\\  \ \  \_|\ \ \  \____        \ \  \____\ \  \ \  \ \  \|\  \|____|\  \
             //    \ \__\   \ \_______\ \_______\ \_______\       \ \_______\ \__\ \__\ \_______\____\_\  \
             //     \|__|    \|_______|\|_______|\|_______|        \|_______|\|__|\|__|\|_______|\_________\
             //                                                                                  \|_________|
}
// This is a comment
"#;
    let correct_sway_code = r#"contract;
// This is a comment, for this one to be placed correctly we need to have Module visitor implemented
pub struct Foo { // Here is a comment
    // Trying some ASCII art
    baz: u64,
    bazzz: u64,
             //  ________ ___  ___  _______   ___               ___       ________  ________  ________
             // |\  _____\\  \|\  \|\  ___ \ |\  \             |\  \     |\   __  \|\   __  \|\   ____\
             // \ \  \__/\ \  \\\  \ \   __/|\ \  \            \ \  \    \ \  \|\  \ \  \|\ /\ \  \___|_
             //  \ \   __\\ \  \\\  \ \  \_|/_\ \  \            \ \  \    \ \   __  \ \   __  \ \_____  \
             //   \ \  \_| \ \  \\\  \ \  \_|\ \ \  \____        \ \  \____\ \  \ \  \ \  \|\  \|____|\  \
             //    \ \__\   \ \_______\ \_______\ \_______\       \ \_______\ \__\ \__\ \_______\____\_\  \
             //     \|__|    \|_______|\|_______|\|_______|        \|_______|\|__|\|__|\|_______|\_________\
             //                                                                                  \|_________|
}
// This is a comment
"#;
    let mut formatter = Formatter::default();
    let formatted_sway_code =
        Formatter::format(&mut formatter, Arc::from(sway_code_to_format), None).unwrap();
    assert_eq!(correct_sway_code, formatted_sway_code);
    assert!(test_stability(formatted_sway_code, formatter));
}

#[test]
fn comments_empty_struct() {
    let sway_code_to_format = r#"contract;

struct AlignMyComments {
    // Align here please
        // Overindented comment
// Underindented comment
}"#;

    let correct_sway_code = r#"contract;

struct AlignMyComments {
    // Align here please
    // Overindented comment
    // Underindented comment
}
"#;

    let mut formatter = Formatter::default();
    let formatted_sway_code =
        Formatter::format(&mut formatter, Arc::from(sway_code_to_format), None).unwrap();
    assert_eq!(correct_sway_code, formatted_sway_code);
    assert!(test_stability(formatted_sway_code, formatter));
}

#[test]
fn comments_empty_traits() {
    let sway_code_to_format = r#"contract;

trait AlignMyComments {
    // Align here please
        // Overindented comment
// Underindented comment
}"#;

    let correct_sway_code = r#"contract;

trait AlignMyComments {
    // Align here please
    // Overindented comment
    // Underindented comment
}
"#;

    let mut formatter = Formatter::default();
    let formatted_sway_code =
        Formatter::format(&mut formatter, Arc::from(sway_code_to_format), None).unwrap();
    assert_eq!(correct_sway_code, formatted_sway_code);
    assert!(test_stability(formatted_sway_code, formatter));
}

#[test]
fn test_enum_comments() {
    let sway_code_to_format = r#"contract;
pub enum Bazz { // Here is a comment
    // Trying some ASCII art
    baz: (),





    bazzz: (),//-----
              //--D--
              //-----
}
"#;
    let correct_sway_code = r#"contract;
pub enum Bazz { // Here is a comment
    // Trying some ASCII art
    baz: (),
    bazzz: (),//-----
              //--D--
              //-----
}
"#;
    let mut formatter = Formatter::default();
    let formatted_sway_code =
        Formatter::format(&mut formatter, Arc::from(sway_code_to_format), None).unwrap();
    assert_eq!(correct_sway_code, formatted_sway_code);
    assert!(test_stability(formatted_sway_code, formatter));
}

#[test]
fn test_fn_comments() {
    let sway_code_to_format = r#"contract;
// This is a comment before a fn
// This is another comment before a fn
fn hello_world( baz: /* this is a comment */ u64) { let x = 5; // This is a comment inside the block
}
"#;
    let correct_sway_code = r#"contract;
// This is a comment before a fn
// This is another comment before a fn
fn hello_world(baz: /* this is a comment */ u64) {
    let x = 5; // This is a comment inside the block
}
"#;

    let mut formatter = Formatter::default();
    let formatted_sway_code =
        Formatter::format(&mut formatter, Arc::from(sway_code_to_format), None).unwrap();
    assert_eq!(correct_sway_code, formatted_sway_code);
    assert!(test_stability(formatted_sway_code, formatter));
}

#[test]
fn test_abi_comments() {
    let sway_code_to_format = r#"contract;
// This is an abi
abi StorageMapExample {
    // insert_into_map is blah blah
    #[storage(write)] // this is some other comment
    fn insert_into_map(key: u64, value: u64);
    // this is the last comment inside the StorageMapExample
}"#;
    let correct_sway_code = r#"contract;
// This is an abi
abi StorageMapExample {
    // insert_into_map is blah blah
    #[storage(write)] // this is some other comment
    fn insert_into_map(key: u64, value: u64);
    // this is the last comment inside the StorageMapExample
}
"#;
    let mut formatter = Formatter::default();
    let formatted_sway_code =
        Formatter::format(&mut formatter, Arc::from(sway_code_to_format), None).unwrap();
    assert_eq!(correct_sway_code, formatted_sway_code);
    assert!(test_stability(formatted_sway_code, formatter));
}

#[test]
fn test_const_comments() {
    let sway_code_to_format = r#"contract;
pub const /* TEST: blah blah tests */ TEST: u16 = 10; // This is a comment next to a const"#;
    let correct_sway_code = r#"contract;
pub const /* TEST: blah blah tests */ TEST: u16 = 10; // This is a comment next to a const
"#;
    let mut formatter = Formatter::default();
    let formatted_sway_code =
        Formatter::format(&mut formatter, Arc::from(sway_code_to_format), None).unwrap();
    assert_eq!(correct_sway_code, formatted_sway_code);
    assert!(test_stability(formatted_sway_code, formatter));
}
#[test]
fn test_storage_comments() {
    let sway_code_to_format = r#"contract;

struct Type1 {
    foo: u64,
}
struct Type2 {
    bar: u64,
}
storage {
    // Testing a comment inside storage
    long_var_name: Type1=Type1{ foo: 8},
    // Testing another comment
    var2: Type2 = Type2{bar:9} // This is the last comment
}"#;
    let correct_sway_code = r#"contract;

struct Type1 {
    foo: u64,
}
struct Type2 {
    bar: u64,
}
storage {
    // Testing a comment inside storage
    long_var_name: Type1 = Type1 { foo: 8 },
    // Testing another comment
    var2: Type2 = Type2 { bar: 9 }, // This is the last comment
}
"#;
    let mut formatter = Formatter::default();
    let formatted_sway_code =
        Formatter::format(&mut formatter, Arc::from(sway_code_to_format), None).unwrap();
    assert_eq!(correct_sway_code, formatted_sway_code);
    assert!(test_stability(formatted_sway_code, formatter));
}

#[test]
fn test_trait_comments() {
    let sway_code_to_format = r#"contract;
// This is the programmer trait
trait Programmer {
    // Returns fav languages of this Programmer.
    fn fav_language(self) -> String;
}"#;
    let correct_sway_code = r#"contract;
// This is the programmer trait
trait Programmer {
    // Returns fav languages of this Programmer.
    fn fav_language(self) -> String;
}
"#;

    let mut formatter = Formatter::default();
    let formatted_sway_code =
        Formatter::format(&mut formatter, Arc::from(sway_code_to_format), None).unwrap();
    assert_eq!(correct_sway_code, formatted_sway_code);
    assert!(test_stability(formatted_sway_code, formatter));
}

#[test]
fn test_where_comment() {
    let sway_code_to_format = r#"contract;

pub fn hello( person: String ) -> String where /* This is next to where */ T: Eq, /*Here is a comment*/{let greeting = 42;greeting.to_string()}"#;
    let correct_sway_code = r#"contract;

pub fn hello(person: String) -> String
where /* This is next to where */
    T: Eq, /*Here is a comment*/
{
    let greeting = 42;
    greeting.to_string()
}
"#;
    let mut formatter = Formatter::default();
    let formatted_sway_code =
        Formatter::format(&mut formatter, Arc::from(sway_code_to_format), None).unwrap();
    assert_eq!(correct_sway_code, formatted_sway_code);
    assert!(test_stability(formatted_sway_code, formatter));
}
#[test]
fn test_impl() {
    let sway_code_to_format = r#"script;

struct Foo {
    bar: u64,
    baz: bool,
}

trait Qux {
    fn is_baz_true(self) -> bool;
}

impl<A ,     B>    Qux<A, B> for
Foo
where
    A    : Qux,
    B: Qux    ,
{fn is_baz_true(self) -> bool {
        self.baz
    }}"#;
    let correct_sway_code = r#"script;

struct Foo {
    bar: u64,
    baz: bool,
}

trait Qux {
    fn is_baz_true(self) -> bool;
}

impl<A, B> Qux<A, B> for Foo where
    A: Qux,
    B: Qux,
{
    fn is_baz_true(self) -> bool {
        self.baz
    }
}
"#;
    let mut formatter = Formatter::default();
    let formatted_sway_code =
        Formatter::format(&mut formatter, Arc::from(sway_code_to_format), None).unwrap();
    assert_eq!(correct_sway_code, formatted_sway_code);
    assert!(test_stability(formatted_sway_code, formatter));
}

#[test]
fn test_impl_without_generics() {
    let sway_code_to_format = r#"script;

struct Foo {
    bar: u64,
    baz: bool,
}

trait Qux {
    fn is_baz_true(self) -> bool;
}

impl   Qux for
Foo
{fn is_baz_true(self) -> bool {
        self.baz
    }}"#;
    let correct_sway_code = r#"script;

struct Foo {
    bar: u64,
    baz: bool,
}

trait Qux {
    fn is_baz_true(self) -> bool;
}

impl Qux for Foo {
    fn is_baz_true(self) -> bool {
        self.baz
    }
}
"#;
    let mut formatter = Formatter::default();
    let formatted_sway_code =
        Formatter::format(&mut formatter, Arc::from(sway_code_to_format), None).unwrap();
    assert_eq!(correct_sway_code, formatted_sway_code);
    assert!(test_stability(formatted_sway_code, formatter));
}

#[test]
fn test_newline_sequence_formatting() {
    let sway_code_to_format = r#"script;

fn main() {
    let number: u64 = 10;

    let number2: u64 = 20;



    let number3: u64 = 30;



}"#;

    let correct_sway_code = r#"script;

fn main() {
    let number: u64 = 10;

    let number2: u64 = 20;

    let number3: u64 = 30;
}
"#;

    let mut formatter = Formatter::default();
    let formatted_sway_code =
        Formatter::format(&mut formatter, Arc::from(sway_code_to_format), None).unwrap();
    assert_eq!(correct_sway_code, formatted_sway_code);
    assert!(test_stability(formatted_sway_code, formatter));
}

#[test]
fn test_doc_comments() {
    let sway_code_to_format = r#"script;

enum Color {
    /// Blue color
    blue: (),
    /// Red color
    red: ()
}
/// This is the main function
fn main() {
}"#;

    let correct_sway_code = r#"script;

enum Color {
    /// Blue color
    blue: (),
    /// Red color
    red: (),
}
/// This is the main function
fn main() {}
"#;

    let mut formatter = Formatter::default();
    let formatted_sway_code =
        Formatter::format(&mut formatter, Arc::from(sway_code_to_format), None).unwrap();
    assert_eq!(correct_sway_code, formatted_sway_code);
    assert!(test_stability(formatted_sway_code, formatter));
}

#[test]
fn test_newline_comment_handler_interaction() {
    let sway_code_to_format = r#"script;

// use statements
use std::*;

fn main() {
    // Array of integers with type ascription
let array_of_integers: [u8;
5] = [1, 2, 3, 4, 5];


    // Array of strings
    let array_of_strings = [ "Bob", "Jan", "Ron"];
}
"#;

    let correct_sway_code = r#"script;

// use statements
use std::*;

fn main() {
    // Array of integers with type ascription
    let array_of_integers: [u8; 5] = [1, 2, 3, 4, 5];

    // Array of strings
    let array_of_strings = ["Bob", "Jan", "Ron"];
}
"#;

    let mut formatter = Formatter::default();
    let formatted_sway_code =
        Formatter::format(&mut formatter, Arc::from(sway_code_to_format), None).unwrap();
    assert_eq!(correct_sway_code, formatted_sway_code);
    assert!(test_stability(formatted_sway_code, formatter));
}
#[test]
fn comments_before_module_kind() {
    let sway_code_to_format = r#"// something about module kind
// something else about module kind
library test_module_kind_with_comments;"#;
    let correct_sway_code = r#"// something about module kind
// something else about module kind
library test_module_kind_with_comments;
"#;
    let mut formatter = Formatter::default();
    let formatted_sway_code =
        Formatter::format(&mut formatter, Arc::from(sway_code_to_format), None).unwrap();
    assert_eq!(correct_sway_code, formatted_sway_code);
    assert!(test_stability(formatted_sway_code, formatter));
}
#[test]
fn newline_before_comments() {
    let sway_code_to_format = r#"


// something about module kind
// something else about module kind
library test_module_kind_with_comments;"#;
    let correct_sway_code = r#"// something about module kind
// something else about module kind
library test_module_kind_with_comments;
"#;
    let mut formatter = Formatter::default();
    let formatted_sway_code =
        Formatter::format(&mut formatter, Arc::from(sway_code_to_format), None).unwrap();
    assert_eq!(correct_sway_code, formatted_sway_code);
    assert!(test_stability(formatted_sway_code, formatter));
}
#[test]
fn test_destructure_structs() {
    let sway_code_to_format = r#"library test_destructure_structs;

struct Point {
    x: u64,
    y: u64,
}
struct TupleInStruct {
    nested_tuple: (u64, (u32, (bool, str[2]))),
}
fn struct_destructuring() {
    let point1 = Point { x: 0, y: 0 };
    let Point{x, y} = point1;
    let point2 = Point { x: 18446744073709551615, y: 18446744073709551615};
    let Point{extremely_long_var_name, other_really_long_var_name} = point2;
    let tuple_in_struct = TupleInStruct {
        nested_tuple: (
            42u64,
            (42u32, (true, "ok"))
        ),
    };
    let TupleInStruct {
        nested_tuple: (a, (b, (c, d))),
    } = tuple_in_struct;
}
"#;
    let correct_sway_code = r#"library test_destructure_structs;

struct Point {
    x: u64,
    y: u64,
}
struct TupleInStruct {
    nested_tuple: (u64, (u32, (bool, str[2]))),
}
fn struct_destructuring() {
    let point1 = Point { x: 0, y: 0 };
    let Point { x, y } = point1;
    let point2 = Point {
        x: 18446744073709551615,
        y: 18446744073709551615,
    };
    let Point {
        extremely_long_var_name,
        other_really_long_var_name,
    } = point2;
    let tuple_in_struct = TupleInStruct {
        nested_tuple: (42u64, (42u32, (true, "ok"))),
    };
    let TupleInStruct {
        nested_tuple: (a, (b, (c, d))),
    } = tuple_in_struct;
}
"#;
    let mut formatter = Formatter::default();
    let formatted_sway_code =
        Formatter::format(&mut formatter, Arc::from(sway_code_to_format), None).unwrap();
    assert_eq!(correct_sway_code, formatted_sway_code);
    assert!(test_stability(formatted_sway_code, formatter));
}
#[test]
fn test_multiline_collections() {
    let sway_code_to_format = r#"library test_multiline_collections;
fn func_with_multiline_collections() {
    let x = (
        "hello",
        "world",
    );
}
"#;
    let correct_sway_code = r#"library test_multiline_collections;
fn func_with_multiline_collections() {
    let x = ("hello", "world");
}
"#;
    let mut formatter = Formatter::default();
    let formatted_sway_code =
        Formatter::format(&mut formatter, Arc::from(sway_code_to_format), None).unwrap();
    assert_eq!(correct_sway_code, formatted_sway_code);
    assert!(test_stability(formatted_sway_code, formatter));
}

#[test]
fn comments_between_if_else() {
    let sway_code_to_format = r#"script;

fn main() {
    if pledge_history_index != 0 {
        // This is a comment
        storage.pledge_history.insert((user, pledge_history_index), pledge);
    }
    // This is also a comment,
    // but multiline
    else if true {
        // This is yet another comment
        storage.pledge_count.insert(user, pledge_count + 1);
    }
    // This is the last comment
    else {
        storage.pledge_count.insert(user, pledge_count + 1);
    }
}
"#;

    let correct_sway_code = r#"script;

fn main() {
    if pledge_history_index != 0 {
        // This is a comment
        storage.pledge_history.insert((user, pledge_history_index), pledge);
    }
    // This is also a comment,
    // but multiline
    else if true {
        // This is yet another comment
        storage.pledge_count.insert(user, pledge_count + 1);
    }
    // This is the last comment
    else {
        storage.pledge_count.insert(user, pledge_count + 1);
    }
}
"#;
    let mut formatter = Formatter::default();
    let formatted_sway_code =
        Formatter::format(&mut formatter, Arc::from(sway_code_to_format), None).unwrap();
    assert_eq!(correct_sway_code, formatted_sway_code);
    assert!(test_stability(formatted_sway_code, formatter));
}
#[test]
fn test_parameterless_attributes() {
    let sway_code_to_format = r#"library my_lib;

abi MyContract {
    #[test]
    fn foo();
}
"#;
    let correct_sway_code = r#"library my_lib;

abi MyContract {
    #[test]
    fn foo();
}
"#;
    let mut formatter = Formatter::default();
    let formatted_sway_code =
        Formatter::format(&mut formatter, Arc::from(sway_code_to_format), None).unwrap();
    assert_eq!(correct_sway_code, formatted_sway_code);
    assert!(test_stability(formatted_sway_code, formatter));
}

#[test]
fn test_traits_with_def_block() {
    let sway_code_to_format = r#"script;

pub trait Foo {
    fn foo(self, other: Self);
} {
    fn bar(self, other: Self) {}
}

fn main() {}
"#;
    let correct_sway_code = r#"script;

pub trait Foo {
    fn foo(self, other: Self);
} {
    fn bar(self, other: Self) {}
}

fn main() {}
"#;
    let mut formatter = Formatter::default();
    let formatted_sway_code =
        Formatter::format(&mut formatter, Arc::from(sway_code_to_format), None).unwrap();
    assert_eq!(correct_sway_code, formatted_sway_code);
    assert!(test_stability(formatted_sway_code, formatter));
}

#[test]
fn test_if_else_multiline_to_inline() {
    let sway_code_to_format = r#"script;

fn main() {
    if foo    {
           let x = 1;
    } else    {
        bar(y)   ;
    }
}
"#;
    let correct_sway_code = r#"script;

fn main() {
    if foo { let x = 1; } else { bar(y); }
}
"#;
    let mut formatter = Formatter::default();
    let formatted_sway_code =
        Formatter::format(&mut formatter, Arc::from(sway_code_to_format), None).unwrap();
    println!("formatted: {formatted_sway_code}");
    assert_eq!(correct_sway_code, formatted_sway_code);
    assert!(test_stability(formatted_sway_code, formatter));
}

#[test]
fn test_if_else_retain_multiline() {
    let sway_code_to_format = r#"script;

fn main() {
    if foo    {
           let really_long_variable = 1;
    } else    {
        bar(y)   ;
    }
}
"#;
    let correct_sway_code = r#"script;

fn main() {
    if foo {
        let really_long_variable = 1;
    } else {
        bar(y);
    }
}
"#;
    let mut formatter = Formatter::default();
    let formatted_sway_code =
        Formatter::format(&mut formatter, Arc::from(sway_code_to_format), None).unwrap();
    assert_eq!(correct_sway_code, formatted_sway_code);
    assert!(test_stability(formatted_sway_code, formatter));
}

#[test]
fn test_multiple_comma_separated_attributes() {
    let sway_code_to_format = r#"library my_lib;

#[test, inline(always), storage(read, write), payable]
fn foo() {}
"#;
    let correct_sway_code = r#"library my_lib;

#[test, inline(always), storage(read, write), payable]
fn foo() {}
"#;
    let mut formatter = Formatter::default();
    let formatted_sway_code =
        Formatter::format(&mut formatter, Arc::from(sway_code_to_format), None).unwrap();
    assert_eq!(correct_sway_code, formatted_sway_code);
    assert!(test_stability(formatted_sway_code, formatter));
}

#[test]
fn test_stack_of_comma_separated_attributes1() {
    let sway_code_to_format = r#"library my_lib;

/// this is a doc comment
#[storage(read, write), payable]
#[test, inline(always)]
fn foo() {}
"#;
    let correct_sway_code = r#"library my_lib;

/// this is a doc comment
#[storage(read, write), payable]
#[test, inline(always)]
fn foo() {}
"#;
    let mut formatter = Formatter::default();
    let formatted_sway_code =
        Formatter::format(&mut formatter, Arc::from(sway_code_to_format), None).unwrap();
    assert_eq!(correct_sway_code, formatted_sway_code);
    assert!(test_stability(formatted_sway_code, formatter));
}

#[test]
fn test_stack_of_comma_separated_attributes2() {
    let sway_code_to_format = r#"library my_lib;

/// this is a doc comment
#[storage(read, write)]
#[payable]
#[test]
#[inline(always)]
fn foo() {}
"#;
    let correct_sway_code = r#"library my_lib;

/// this is a doc comment
#[storage(read, write)]
#[payable]
#[test]
#[inline(always)]
fn foo() {}
"#;
    let mut formatter = Formatter::default();
    let formatted_sway_code =
        Formatter::format(&mut formatter, Arc::from(sway_code_to_format), None).unwrap();
    assert_eq!(correct_sway_code, formatted_sway_code);
    assert!(test_stability(formatted_sway_code, formatter));
}

#[test]
fn test_comment_between_closing_brace_and_else() {
    let sway_code_to_format = r#"contract;

impl MyContract for Contract {
    fn is_blue() -> bool {
        if self == PrimaryColor::Blue {
            true
        }
            // Overindented comment, underindented else
    else if self == PrimaryColor::Red {
            true
        } // Trailing multiline comment should be newlined
    // Underindented comment
            // Overindented else
                else {
            false
        }
    }
}"#;

    let correct_sway_code = r#"contract;

impl MyContract for Contract {
    fn is_blue() -> bool {
        if self == PrimaryColor::Blue {
            true
        }
        // Overindented comment, underindented else
        else if self == PrimaryColor::Red {
            true
        }
        // Trailing multiline comment should be newlined
        // Underindented comment
        // Overindented else
        else {
            false
        }
    }
}
"#;
    let mut formatter = Formatter::default();
    let formatted_sway_code =
        Formatter::format(&mut formatter, Arc::from(sway_code_to_format), None).unwrap();
    assert_eq!(correct_sway_code, formatted_sway_code);
    assert!(test_stability(formatted_sway_code, formatter));
}

#[test]
fn test_comment_between_if_else_inline_to_multiline() {
    let sway_code_to_format = r#"contract;

impl MyContract for Contract {
    fn is_blue() -> bool {
            if self == PrimaryColor::Blue { true }
        // TODO remove this else when exhaustive ifs are checked for
    else { false }
    }
}"#;

    let correct_sway_code = r#"contract;

impl MyContract for Contract {
    fn is_blue() -> bool {
        if self == PrimaryColor::Blue {
            true
        }
        // TODO remove this else when exhaustive ifs are checked for
        else {
            false
        }
    }
}
"#;
    let mut formatter = Formatter::default();
    let formatted_sway_code =
        Formatter::format(&mut formatter, Arc::from(sway_code_to_format), None).unwrap();
    assert_eq!(correct_sway_code, formatted_sway_code);
    assert!(test_stability(formatted_sway_code, formatter));
}

#[test]
fn test_asm_block() {
    let sway_code_to_format = r#"library my_lib;

fn foo() {
    asm(r1: self, r2: other, r3, r4) {
        addi r3 zero i32;
        meq r4 r1 r2 r3;
        r4: bool
    }
}
"#;
    let correct_sway_code = r#"library my_lib;

fn foo() {
    asm(r1: self, r2: other, r3, r4) {
        addi r3 zero i32;
        meq  r4 r1 r2 r3;
        r4: bool
    }
}
"#;
    let mut formatter = Formatter::default();
    let formatted_sway_code =
        Formatter::format(&mut formatter, Arc::from(sway_code_to_format), None).unwrap();
    assert_eq!(correct_sway_code, formatted_sway_code);
    assert!(test_stability(formatted_sway_code, formatter));
}
#[test]
fn test_empty_blocks() {
    let sway_code_to_format = r#"contract;
        
fn contents() {
    let i = {    };
    match i {
    }
    if true {    }
}
fn empty() {}
"#;
    let correct_sway_code = r#"contract;

fn contents() {
    let i = {};
    match i {}
    if true {}
}
fn empty() {}
"#;
    let mut formatter = Formatter::default();
    let formatted_sway_code =
        Formatter::format(&mut formatter, Arc::from(sway_code_to_format), None).unwrap();
    assert_eq!(correct_sway_code, formatted_sway_code);
    assert!(test_stability(formatted_sway_code, formatter));
}