waalge
/
aiken
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

reorder tests to match order of functions

This commit is contained in:
microproofs 2024-03-05 17:49:49 -05:00 committed by Kasey
parent fab6d5aff7
commit eb709d6fc3
1 changed files with 109 additions and 109 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

218
crates/uplc/src/optimize/shrinker.rs
View File

@ -1803,82 +1803,6 @@ mod tests {
assert_eq!(actual, expected); assert_eq!(actual, expected);
} }
#[test]
fn wrap_data_reduce_i_data() {
let mut program: Program<Name> = Program {
version: (1, 0, 0),
term: Term::equals_data()
.apply(Term::i_data().apply(Term::un_i_data().apply(Term::Constant(
Constant::Data(PlutusData::BigInt(BigInt::Int(5.into()))).into(),
))))
.apply(Term::i_data().apply(Term::integer(1.into())))
.lambda("x"),
};
let mut interner = CodeGenInterner::new();
interner.program(&mut program);
let mut expected = Program {
version: (1, 0, 0),
term: Term::equals_data()
.apply(Term::Constant(
Constant::Data(PlutusData::BigInt(BigInt::Int(5.into()))).into(),
))
.apply(Term::data(Data::integer(1.into())))
.lambda("x"),
};
let mut interner = CodeGenInterner::new();
interner.program(&mut expected);
let expected: Program<NamedDeBruijn> = expected.try_into().unwrap();
let actual = program.cast_data_reducer();
let actual: Program<NamedDeBruijn> = actual.try_into().unwrap();
assert_eq!(actual, expected);
}
#[test]
fn wrap_data_reduce_un_i_data() {
let mut program: Program<Name> = Program {
version: (1, 0, 0),
term: Term::equals_integer()
.apply(Term::un_i_data().apply(Term::i_data().apply(Term::integer(1.into()))))
.apply(Term::un_i_data().apply(Term::Constant(
Constant::Data(PlutusData::BigInt(BigInt::Int(5.into()))).into(),
)))
.lambda("x"),
};
let mut interner = CodeGenInterner::new();
interner.program(&mut program);
let mut expected = Program {
version: (1, 0, 0),
term: Term::equals_integer()
.apply(Term::integer(1.into()))
.apply(Term::integer(5.into()))
.lambda("x"),
};
let mut interner = CodeGenInterner::new();
interner.program(&mut expected);
let expected: Program<NamedDeBruijn> = expected.try_into().unwrap();
let actual = program.cast_data_reducer();
let actual: Program<NamedDeBruijn> = actual.try_into().unwrap();
assert_eq!(actual, expected);
}
#[test] #[test]
fn builtin_force_reduce_list_builtins() { fn builtin_force_reduce_list_builtins() {
let program: Program<Name> = Program { let program: Program<Name> = Program {
@ -1985,38 +1909,6 @@ mod tests {
assert_eq!(actual, expected); assert_eq!(actual, expected);
} }
#[test]
fn inline_reduce_delay_sha() {
let mut program: Program<Name> = Program {
version: (1, 0, 0),
term: Term::sha2_256()
.apply(Term::var("x"))
.lambda("x")
.apply(Term::byte_string(vec![]).delay()),
};
let mut interner = CodeGenInterner::new();
interner.program(&mut program);
let mut expected = Program {
version: (1, 0, 0),
term: Term::sha2_256().apply(Term::byte_string(vec![]).delay()),
};
let mut interner = CodeGenInterner::new();
interner.program(&mut expected);
let expected: Program<NamedDeBruijn> = expected.try_into().unwrap();
let actual = program.inline_reducer();
let actual: Program<NamedDeBruijn> = actual.try_into().unwrap();
assert_eq!(actual, expected);
}
#[test] #[test]
fn identity_reduce_0_occurrence() { fn identity_reduce_0_occurrence() {
let mut program: Program<Name> = Program { let mut program: Program<Name> = Program {
@ -2055,7 +1947,7 @@ mod tests {
} }
#[test] #[test]
fn inline_reduce_identity_param() { fn identity_reduce_param() {
let mut program: Program<Name> = Program { let mut program: Program<Name> = Program {
version: (1, 0, 0), version: (1, 0, 0),
term: Term::sha2_256() term: Term::sha2_256()
@ -2115,6 +2007,114 @@ mod tests {
assert_eq!(actual, expected); assert_eq!(actual, expected);
} }
#[test]
fn inline_reduce_delay_sha() {
let mut program: Program<Name> = Program {
version: (1, 0, 0),
term: Term::sha2_256()
.apply(Term::var("x"))
.lambda("x")
.apply(Term::byte_string(vec![]).delay()),
};
let mut interner = CodeGenInterner::new();
interner.program(&mut program);
let mut expected = Program {
version: (1, 0, 0),
term: Term::sha2_256().apply(Term::byte_string(vec![]).delay()),
};
let mut interner = CodeGenInterner::new();
interner.program(&mut expected);
let expected: Program<NamedDeBruijn> = expected.try_into().unwrap();
let actual = program.inline_reducer();
let actual: Program<NamedDeBruijn> = actual.try_into().unwrap();
assert_eq!(actual, expected);
}
#[test]
fn wrap_data_reduce_i_data() {
let mut program: Program<Name> = Program {
version: (1, 0, 0),
term: Term::equals_data()
.apply(Term::i_data().apply(Term::un_i_data().apply(Term::Constant(
Constant::Data(PlutusData::BigInt(BigInt::Int(5.into()))).into(),
))))
.apply(Term::i_data().apply(Term::integer(1.into())))
.lambda("x"),
};
let mut interner = CodeGenInterner::new();
interner.program(&mut program);
let mut expected = Program {
version: (1, 0, 0),
term: Term::equals_data()
.apply(Term::Constant(
Constant::Data(PlutusData::BigInt(BigInt::Int(5.into()))).into(),
))
.apply(Term::data(Data::integer(1.into())))
.lambda("x"),
};
let mut interner = CodeGenInterner::new();
interner.program(&mut expected);
let expected: Program<NamedDeBruijn> = expected.try_into().unwrap();
let actual = program.cast_data_reducer();
let actual: Program<NamedDeBruijn> = actual.try_into().unwrap();
assert_eq!(actual, expected);
}
#[test]
fn wrap_data_reduce_un_i_data() {
let mut program: Program<Name> = Program {
version: (1, 0, 0),
term: Term::equals_integer()
.apply(Term::un_i_data().apply(Term::i_data().apply(Term::integer(1.into()))))
.apply(Term::un_i_data().apply(Term::Constant(
Constant::Data(PlutusData::BigInt(BigInt::Int(5.into()))).into(),
)))
.lambda("x"),
};
let mut interner = CodeGenInterner::new();
interner.program(&mut program);
let mut expected = Program {
version: (1, 0, 0),
term: Term::equals_integer()
.apply(Term::integer(1.into()))
.apply(Term::integer(5.into()))
.lambda("x"),
};
let mut interner = CodeGenInterner::new();
interner.program(&mut expected);
let expected: Program<NamedDeBruijn> = expected.try_into().unwrap();
let actual = program.cast_data_reducer();
let actual: Program<NamedDeBruijn> = actual.try_into().unwrap();
assert_eq!(actual, expected);
}
#[test] #[test]
fn curry_reducer_test_1() { fn curry_reducer_test_1() {
let mut program: Program<Name> = Program { let mut program: Program<Name> = Program {