vlad.os/fp-3-itmo
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix property testing

Browse Source 
+rnd generators
This commit is contained in:
vladislav
2025-12-06 15:39:08 +03:00
parent 9c0b3c444c
commit c76be5f222
3 changed files with 236 additions and 158 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
lab2/gleam.toml
View File

@@ -14,6 +14,7 @@ version = "1.0.0"
[dependencies]
gleam_stdlib = ">= 0.44.0 and < 2.0.0"
prng = ">= 4.0.1 and < 5.0.0"
[dev-dependencies]
gleeunit = ">= 1.0.0 and < 2.0.0"

4
lab2/manifest.toml
View File

@@ -2,10 +2,14 @@
# You typically do not need to edit this file
packages = [
{ name = "gleam_bitwise", version = "1.3.1", build_tools = ["gleam"], requirements = [], otp_app = "gleam_bitwise", source = "hex", outer_checksum = "B36E1D3188D7F594C7FD4F43D0D2CE17561DE896202017548578B16FE1FE9EFC" },
{ name = "gleam_stdlib", version = "0.67.1", build_tools = ["gleam"], requirements = [], otp_app = "gleam_stdlib", source = "hex", outer_checksum = "6CE3E4189A8B8EC2F73AB61A2FBDE49F159D6C9C61C49E3B3082E439F260D3D0" },
{ name = "gleam_yielder", version = "1.1.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleam_yielder", source = "hex", outer_checksum = "8E4E4ECFA7982859F430C57F549200C7749823C106759F4A19A78AEA6687717A" },
{ name = "gleeunit", version = "1.9.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleeunit", source = "hex", outer_checksum = "DA9553CE58B67924B3C631F96FE3370C49EB6D6DC6B384EC4862CC4AAA718F3C" },
{ name = "prng", version = "4.0.1", build_tools = ["gleam"], requirements = ["gleam_bitwise", "gleam_stdlib", "gleam_yielder"], otp_app = "prng", source = "hex", outer_checksum = "695AB70E4BE713042062E901975FC08D1EC725B85B808D4786A14C406ADFBCF1" },
]
[requirements]
gleam_stdlib = { version = ">= 0.44.0 and < 2.0.0" }
gleeunit = { version = ">= 1.0.0 and < 2.0.0" }
prng = { version = ">= 4.0.1 and < 5.0.0" }

389
lab2/test/lab2_test.gleam
View File

@@ -6,6 +6,8 @@ import gleam/string
import gleeunit
import gleeunit/should
import lab2
import prng/random
import prng/seed
pub fn main() {
gleeunit.main()
@@ -24,160 +26,249 @@ fn string_equal(a: String, b: String) -> Bool {
a == b
}
// Тест создания пустого дерева
// Генерация случайных данных
fn gk() -> Int {
int.random(1000) - 500
}
fn gv() -> String {
let length = int.random(32)
let generator: random.Generator(Int) = random.int(97, 122)
let seed = seed.new(42)
// random string of given length
string.join(
list.repeat("", length)
|> list.map(fn(_) {
let code = random.sample(generator, seed)
let assert Ok(cp) = string.utf_codepoint(code)
string.from_utf_codepoints([cp])
}),
"",
)
}
/// Тест создания пустого дерева
pub fn empty_tree_test() {
let tree = lab2.empty()
lab2.is_empty(tree) |> should.be_true
lab2.size(tree) |> should.equal(0)
}
// Тест вставки одного элемента
/// Тест вставки одного элемента
pub fn single_insert_test() {
let key = gk()
let value = gv()
let tree =
lab2.empty()
|> lab2.insert(5, "five", int_compare)
|> lab2.insert(key, value, int_compare)
lab2.is_empty(tree) |> should.be_false
lab2.size(tree) |> should.equal(1)
lab2.lookup(tree, 5, int_compare) |> should.equal(option.Some("five"))
lab2.lookup(tree, 10, int_compare) |> should.equal(option.None)
lab2.lookup(tree, key, int_compare) |> should.equal(option.Some(value))
lab2.lookup(tree, gk(), int_compare) |> should.equal(option.None)
}
// Тест множественных вставок
/// Тест множественных вставок
pub fn multiple_insert_test() {
let k1 = gk()
let v1 = gv()
let k2 = gk()
let v2 = gv()
let k3 = gk()
let v3 = gv()
let k4 = gk()
let v4 = gv()
let k5 = gk()
let v5 = gv()
let tree =
lab2.empty()
|> lab2.insert(5, "five", int_compare)
|> lab2.insert(3, "three", int_compare)
|> lab2.insert(7, "seven", int_compare)
|> lab2.insert(1, "one", int_compare)
|> lab2.insert(9, "nine", int_compare)
|> lab2.insert(k1, v1, int_compare)
|> lab2.insert(k2, v2, int_compare)
|> lab2.insert(k3, v3, int_compare)
|> lab2.insert(k4, v4, int_compare)
|> lab2.insert(k5, v5, int_compare)
lab2.size(tree) |> should.equal(5)
lab2.lookup(tree, 1, int_compare) |> should.equal(option.Some("one"))
lab2.lookup(tree, 3, int_compare) |> should.equal(option.Some("three"))
lab2.lookup(tree, 5, int_compare) |> should.equal(option.Some("five"))
lab2.lookup(tree, 7, int_compare) |> should.equal(option.Some("seven"))
lab2.lookup(tree, 9, int_compare) |> should.equal(option.Some("nine"))
lab2.lookup(tree, k1, int_compare) |> should.equal(option.Some(v1))
lab2.lookup(tree, k2, int_compare) |> should.equal(option.Some(v2))
lab2.lookup(tree, k3, int_compare) |> should.equal(option.Some(v3))
lab2.lookup(tree, k4, int_compare) |> should.equal(option.Some(v4))
lab2.lookup(tree, k5, int_compare) |> should.equal(option.Some(v5))
}
// Тест удаления элементов
/// Тест удаления элементов
pub fn delete_test() {
let k1 = gk()
let v1 = gv()
let k2 = gk()
let v2 = gv()
let k3 = gk()
let v3 = gv()
let tree =
lab2.empty()
|> lab2.insert(5, "five", int_compare)
|> lab2.insert(3, "three", int_compare)
|> lab2.insert(7, "seven", int_compare)
|> lab2.delete(3, int_compare)
|> lab2.insert(k1, v1, int_compare)
|> lab2.insert(k2, v2, int_compare)
|> lab2.insert(k3, v3, int_compare)
|> lab2.delete(k2, int_compare)
lab2.size(tree) |> should.equal(2)
lab2.lookup(tree, 3, int_compare) |> should.equal(option.None)
lab2.lookup(tree, 5, int_compare) |> should.equal(option.Some("five"))
lab2.lookup(tree, 7, int_compare) |> should.equal(option.Some("seven"))
lab2.lookup(tree, k2, int_compare) |> should.equal(option.None)
lab2.lookup(tree, k1, int_compare) |> should.equal(option.Some(v1))
lab2.lookup(tree, k3, int_compare) |> should.equal(option.Some(v3))
}
// Тест фильтрации
/// Тест фильтрации
pub fn filter_test() {
let k1 = gk() * 2 + 1
let v1 = gv()
let k2 = gk() * 2
let v2 = gv()
let k3 = gk() * 2 + 1
let v3 = gv()
let k4 = gk() * 2
let v4 = gv()
let k5 = gk() * 2 + 1
let v5 = gv()
let tree =
lab2.empty()
|> lab2.insert(1, "one", int_compare)
|> lab2.insert(2, "two", int_compare)
|> lab2.insert(3, "three", int_compare)
|> lab2.insert(4, "four", int_compare)
|> lab2.insert(5, "five", int_compare)
|> lab2.insert(k1, v1, int_compare)
|> lab2.insert(k2, v2, int_compare)
|> lab2.insert(k3, v3, int_compare)
|> lab2.insert(k4, v4, int_compare)
|> lab2.insert(k5, v5, int_compare)
let filtered = lab2.filter(tree, fn(key, _) { key % 2 == 0 }, int_compare)
lab2.size(filtered) |> should.equal(2)
lab2.contains(filtered, 2, int_compare) |> should.be_true
lab2.contains(filtered, 4, int_compare) |> should.be_true
lab2.contains(filtered, 1, int_compare) |> should.be_false
lab2.contains(filtered, k2, int_compare) |> should.be_true
lab2.contains(filtered, k4, int_compare) |> should.be_true
lab2.contains(filtered, k1, int_compare) |> should.be_false
}
// Тест отображения
/// Тест отображения
pub fn map_test() {
let k1 = gk()
let v1 = gk()
let k2 = gk()
let v2 = gk()
let k3 = gk()
let v3 = gk()
let tree =
lab2.empty()
|> lab2.insert(1, 10, int_compare)
|> lab2.insert(2, 20, int_compare)
|> lab2.insert(3, 30, int_compare)
|> lab2.insert(k1, v1, int_compare)
|> lab2.insert(k2, v2, int_compare)
|> lab2.insert(k3, v3, int_compare)
let mapped = lab2.map(tree, fn(value) { value * 2 })
lab2.lookup(mapped, 1, int_compare) |> should.equal(option.Some(20))
lab2.lookup(mapped, 2, int_compare) |> should.equal(option.Some(40))
lab2.lookup(mapped, 3, int_compare) |> should.equal(option.Some(60))
lab2.lookup(mapped, k1, int_compare) |> should.equal(option.Some(v1 * 2))
lab2.lookup(mapped, k2, int_compare) |> should.equal(option.Some(v2 * 2))
lab2.lookup(mapped, k3, int_compare) |> should.equal(option.Some(v3 * 2))
}
// Тест левой свёртки
/// Тест левой свёртки
pub fn fold_left_test() {
let k1 = gk()
let v1 = gk()
let k2 = gk()
let v2 = gk()
let k3 = gk()
let v3 = gk()
let tree =
lab2.empty()
|> lab2.insert(1, 10, int_compare)
|> lab2.insert(2, 20, int_compare)
|> lab2.insert(3, 30, int_compare)
|> lab2.insert(k1, v1, int_compare)
|> lab2.insert(k2, v2, int_compare)
|> lab2.insert(k3, v3, int_compare)
let sum = lab2.fold_left(tree, 0, fn(acc, _, value) { acc + value })
sum |> should.equal(60)
sum |> should.equal(v1 + v2 + v3)
}
// Тест правой свёртки
/// Тест правой свёртки
pub fn fold_right_test() {
let k1 = gk()
let v1 = gv()
let k2 = gk()
let v2 = gv()
let k3 = gk()
let v3 = gv()
let tree =
lab2.empty()
|> lab2.insert(1, "a", int_compare)
|> lab2.insert(2, "b", int_compare)
|> lab2.insert(3, "c", int_compare)
|> lab2.insert(k1, v1, int_compare)
|> lab2.insert(k2, v2, int_compare)
|> lab2.insert(k3, v3, int_compare)
let result = lab2.fold_right(tree, "", fn(_, value, acc) { value <> acc })
// Порядок может отличаться в зависимости от структуры дерева
result |> string.length |> should.equal(3)
result
|> string.length
|> should.equal(string.length(v1) + string.length(v2) + string.length(v3))
}
// Тест преобразования в список и обратно
/// Тест преобразования в список и обратно
pub fn to_from_list_test() {
let original_list = [#(1, "one"), #(2, "two"), #(3, "three")]
let k1 = gk()
let v1 = gv()
let k2 = gk()
let v2 = gv()
let k3 = gk()
let v3 = gv()
let original_list = [#(k1, v1), #(k2, v2), #(k3, v3)]
let tree = lab2.from_list(original_list, int_compare)
let result_list = lab2.to_list(tree)
lab2.size(tree) |> should.equal(3)
list.length(result_list) |> should.equal(3)
lab2.contains(tree, 1, int_compare) |> should.be_true
lab2.contains(tree, 2, int_compare) |> should.be_true
lab2.contains(tree, 3, int_compare) |> should.be_true
lab2.contains(tree, k1, int_compare) |> should.be_true
lab2.contains(tree, k2, int_compare) |> should.be_true
lab2.contains(tree, k3, int_compare) |> should.be_true
}
// Тесты свойств моноида
// Тест нейтрального элемента (левая единица)
/// Тест нейтрального элемента (левая единица)
pub fn monoid_left_identity_test() {
let k1 = gk()
let v1 = gv()
let k2 = gk()
let v2 = gv()
let tree =
lab2.empty()
|> lab2.insert(1, "one", int_compare)
|> lab2.insert(2, "two", int_compare)
|> lab2.insert(k1, v1, int_compare)
|> lab2.insert(k2, v2, int_compare)
let result = lab2.concat(lab2.mempty(), tree, int_compare)
let result = lab2.concat(lab2.empty(), tree, int_compare)
lab2.equal(tree, result, int_equal, string_equal) |> should.be_true
}
// Тест нейтрального элемента (правая единица)
/// Тест нейтрального элемента (правая единица)
pub fn monoid_right_identity_test() {
let k1 = gk()
let v1 = gv()
let k2 = gk()
let v2 = gv()
let tree =
lab2.empty()
|> lab2.insert(1, "one", int_compare)
|> lab2.insert(2, "two", int_compare)
|> lab2.insert(k1, v1, int_compare)
|> lab2.insert(k2, v2, int_compare)
let result = lab2.concat(tree, lab2.mempty(), int_compare)
let result = lab2.concat(tree, lab2.empty(), int_compare)
lab2.equal(tree, result, int_equal, string_equal) |> should.be_true
}
// Тест ассоциативности
/// Тест ассоциативности
pub fn monoid_associativity_test() {
let tree1 = lab2.empty() |> lab2.insert(1, "one", int_compare)
let tree2 = lab2.empty() |> lab2.insert(2, "two", int_compare)
let tree3 = lab2.empty() |> lab2.insert(3, "three", int_compare)
let k1 = gk()
let v1 = gv()
let k2 = gk()
let v2 = gv()
let k3 = gk()
let v3 = gv()
let tree1 = lab2.empty() |> lab2.insert(k1, v1, int_compare)
let tree2 = lab2.empty() |> lab2.insert(k2, v2, int_compare)
let tree3 = lab2.empty() |> lab2.insert(k3, v3, int_compare)
let left_assoc =
lab2.concat(lab2.concat(tree1, tree2, int_compare), tree3, int_compare)
@@ -187,31 +278,20 @@ pub fn monoid_associativity_test() {
// Проверяем, что оба дерева содержат одинаковые элементы
lab2.size(left_assoc) |> should.equal(3)
lab2.size(right_assoc) |> should.equal(3)
lab2.contains(left_assoc, 1, int_compare) |> should.be_true
lab2.contains(left_assoc, 2, int_compare) |> should.be_true
lab2.contains(left_assoc, 3, int_compare) |> should.be_true
lab2.contains(right_assoc, 1, int_compare) |> should.be_true
lab2.contains(right_assoc, 2, int_compare) |> should.be_true
lab2.contains(right_assoc, 3, int_compare) |> should.be_true
lab2.contains(left_assoc, k1, int_compare) |> should.be_true
lab2.contains(left_assoc, k2, int_compare) |> should.be_true
lab2.contains(left_assoc, k3, int_compare) |> should.be_true
lab2.contains(right_assoc, k1, int_compare) |> should.be_true
lab2.contains(right_assoc, k2, int_compare) |> should.be_true
lab2.contains(right_assoc, k3, int_compare) |> should.be_true
}
// Тест инвариантов красно-чёрного дерева (упрощённая проверка)
/// Тест инвариантов красно-чёрного дерева (упрощённая проверка)
pub fn red_black_invariant_test() {
// Создаём большое дерево и проверяем, что поиск работает корректно
let tree =
lab2.from_list(
[
#(1, "one"),
#(2, "two"),
#(3, "three"),
#(4, "four"),
#(5, "five"),
#(6, "six"),
#(7, "seven"),
#(8, "eight"),
#(9, "nine"),
#(10, "ten"),
],
list.map(list.range(1, 10), fn(i) { #(i, gv()) }),
int_compare,
)
@@ -219,31 +299,34 @@ pub fn red_black_invariant_test() {
// Проверяем, что все элементы можно найти
let all_found =
list.all([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], fn(key) {
list.all(list.range(1, 10), fn(key) {
lab2.contains(tree, key, int_compare)
})
all_found |> should.be_true
}
// Тест обновления существующего ключа
/// Тест обновления существующего ключа
pub fn update_existing_key_test() {
let key = gk()
let old_value = gv()
let new_value = gv()
let tree =
lab2.empty()
|> lab2.insert(1, "old", int_compare)
|> lab2.insert(1, "new", int_compare)
|> lab2.insert(key, old_value, int_compare)
|> lab2.insert(key, new_value, int_compare)
lab2.size(tree) |> should.equal(1)
lab2.lookup(tree, 1, int_compare) |> should.equal(option.Some("new"))
lab2.lookup(tree, key, int_compare) |> should.equal(option.Some(new_value))
}
// Тест свойства: insert -> lookup должен возвращать вставленное значение
/// Тест свойства: insert -> lookup должен возвращать вставленное значение
pub fn insert_lookup_property_test() {
let test_cases = [
#(1, "one"),
#(42, "forty-two"),
#(0, "zero"),
#(-5, "minus-five"),
#(gk(), gv()),
#(gk(), gv()),
#(gk(), gv()),
#(gk(), gv()),
]
list.each(test_cases, fn(test_case) {
@@ -253,30 +336,33 @@ pub fn insert_lookup_property_test() {
})
}
// Тест свойства: size увеличивается при вставке новых элементов
/// Тест свойства: size увеличивается при вставке новых элементов
pub fn insert_size_property_test() {
let key1 = gk()
let key2 = gk()
let key3 = gk()
let tree = lab2.empty()
lab2.size(tree) |> should.equal(0)
let tree1 = lab2.insert(tree, 1, "one", int_compare)
let tree1 = lab2.insert(tree, key1, gv(), int_compare)
lab2.size(tree1) |> should.equal(1)
let tree2 = lab2.insert(tree1, 2, "two", int_compare)
let tree2 = lab2.insert(tree1, key2, gv(), int_compare)
lab2.size(tree2) |> should.equal(2)
let tree3 = lab2.insert(tree2, 3, "three", int_compare)
let tree3 = lab2.insert(tree2, key3, gv(), int_compare)
lab2.size(tree3) |> should.equal(3)
// Вставка существующего ключа не должна увеличивать размер
let tree4 = lab2.insert(tree3, 2, "two-updated", int_compare)
let tree4 = lab2.insert(tree3, key2, gv(), int_compare)
lab2.size(tree4) |> should.equal(3)
}
// Тест свойства: filter сохраняет порядок и структуру
/// Тест свойства: filter сохраняет порядок и структуру
pub fn filter_property_test() {
let original =
lab2.from_list(
[#(1, "a"), #(2, "b"), #(3, "c"), #(4, "d"), #(5, "e")],
list.map(list.range(1, 5), fn(i) { #(i, gv()) }),
int_compare,
)
@@ -296,9 +382,15 @@ pub fn filter_property_test() {
lab2.contains(partial_filter, 5, int_compare) |> should.be_true
}
// Тест свойства: map сохраняет структуру дерева
/// Тест свойства: map сохраняет структуру дерева
pub fn map_property_test() {
let original = lab2.from_list([#(1, 10), #(2, 20), #(3, 30)], int_compare)
let k1 = gk()
let v1 = gk()
let k2 = gk()
let v2 = gk()
let k3 = gk()
let v3 = gk()
let original = lab2.from_list([#(k1, v1), #(k2, v2), #(k3, v3)], int_compare)
// Тождественное отображение
let identity_map = lab2.map(original, fn(x) { x })
@@ -307,22 +399,24 @@ pub fn map_property_test() {
// Отображение с изменением
let doubled = lab2.map(original, fn(x) { x * 2 })
lab2.size(doubled) |> should.equal(lab2.size(original))
lab2.lookup(doubled, 1, int_compare) |> should.equal(option.Some(20))
lab2.lookup(doubled, 2, int_compare) |> should.equal(option.Some(40))
lab2.lookup(doubled, 3, int_compare) |> should.equal(option.Some(60))
lab2.lookup(doubled, k1, int_compare) |> should.equal(option.Some(v1 * 2))
lab2.lookup(doubled, k2, int_compare) |> should.equal(option.Some(v2 * 2))
lab2.lookup(doubled, k3, int_compare) |> should.equal(option.Some(v3 * 2))
}
// Тест свойства: fold_left и fold_right дают корректные результаты
/// Тест свойства: fold_left и fold_right дают корректные результаты
pub fn fold_property_test() {
let tree =
lab2.from_list([#(1, 1), #(2, 2), #(3, 3), #(4, 4), #(5, 5)], int_compare)
let values = list.map(list.range(1, 5), fn(_) { gk() })
let tree = lab2.from_list(list.zip(list.range(1, 5), values), int_compare)
let expected_sum = list.fold(values, 0, fn(acc, v) { acc + v })
// Сумма всех значений
let sum_left = lab2.fold_left(tree, 0, fn(acc, _, value) { acc + value })
let sum_right = lab2.fold_right(tree, 0, fn(_, value, acc) { acc + value })
sum_left |> should.equal(15)
sum_right |> should.equal(15)
sum_left |> should.equal(expected_sum)
sum_right |> should.equal(expected_sum)
// Количество элементов
let count_left = lab2.fold_left(tree, 0, fn(acc, _, _) { acc + 1 })
@@ -332,15 +426,24 @@ pub fn fold_property_test() {
count_right |> should.equal(5)
}
// Тест свойства: to_list -> from_list должно давать эквивалентное дерево
/// Тест свойства: to_list -> from_list должно давать эквивалентное дерево
pub fn list_roundtrip_property_test() {
let original_list = [#(3, "c"), #(1, "a"), #(4, "d"), #(2, "b")]
let k1 = gk()
let v1 = gv()
let k2 = gk()
let v2 = gv()
let k3 = gk()
let v3 = gv()
let k4 = gk()
let v4 = gv()
let original_list = [#(k1, v1), #(k2, v2), #(k3, v3), #(k4, v4)]
let tree = lab2.from_list(original_list, int_compare)
let result_list = lab2.to_list(tree)
let restored_tree = lab2.from_list(result_list, int_compare)
lab2.size(tree) |> should.equal(lab2.size(restored_tree))
lab2.equal(tree, restored_tree, int_equal, string_equal) |> should.be_true
lab2.semantic_equal(tree, restored_tree, int_compare, string_equal)
|> should.be_true
// Проверяем, что все элементы присутствуют
list.each(original_list, fn(item) {
@@ -350,10 +453,18 @@ pub fn list_roundtrip_property_test() {
})
}
// Тест инвариантов моноида (коммутативность для деревьев с разными ключами)
/// Тест инвариантов моноида (коммутативность для деревьев с разными ключами)
pub fn monoid_commutativity_test() {
let tree1 = lab2.from_list([#(1, "a"), #(2, "b")], int_compare)
let tree2 = lab2.from_list([#(3, "c"), #(4, "d")], int_compare)
let k1 = gk()
let v1 = gv()
let k2 = gk()
let v2 = gv()
let k3 = gk()
let v3 = gv()
let k4 = gk()
let v4 = gv()
let tree1 = lab2.from_list([#(k1, v1), #(k2, v2)], int_compare)
let tree2 = lab2.from_list([#(k3, v3), #(k4, v4)], int_compare)
let concat1 = lab2.concat(tree1, tree2, int_compare)
let concat2 = lab2.concat(tree2, tree1, int_compare)
@@ -363,47 +474,9 @@ pub fn monoid_commutativity_test() {
lab2.size(concat2) |> should.equal(4)
// Оба дерева должны содержать все элементы
[1, 2, 3, 4]
[k1, k2, k3, k4]
|> list.each(fn(key) {
lab2.contains(concat1, key, int_compare) |> should.be_true
lab2.contains(concat2, key, int_compare) |> should.be_true
})
}
// Тест семантического равенства деревьев
// Проверяет, что деревья с одинаковым содержимым, но разной структурой считаются равными
pub fn semantic_equal_test() {
// Создаём два дерева с одинаковыми данными, но разным порядком вставки
let tree1 =
lab2.empty()
|> lab2.insert(2, "two", int_compare)
|> lab2.insert(1, "one", int_compare)
|> lab2.insert(3, "three", int_compare)
let tree2 =
lab2.empty()
|> lab2.insert(1, "one", int_compare)
|> lab2.insert(3, "three", int_compare)
|> lab2.insert(2, "two", int_compare)
// Семантически они должны быть равны
lab2.semantic_equal(tree1, tree2, int_compare, string_equal) |> should.be_true
// Структурно они могут быть разными (зависит от балансировки)
// lab2.equal(tree1, tree2, int_equal, string_equal) может быть false
}
// Тест структурного равенства без учёта цветов узлов
pub fn structure_equal_test() {
let tree1 =
lab2.empty()
|> lab2.insert(2, "two", int_compare)
|> lab2.insert(1, "one", int_compare)
let tree2 =
lab2.empty()
|> lab2.insert(2, "two", int_compare)
|> lab2.insert(1, "one", int_compare)
// Структурно должны быть равны (игнорируя цвета)
lab2.structure_equal(tree1, tree2, int_equal, string_equal) |> should.be_true
}