stof 0.3.24

//
// Copyright 2024 Formata, Inc. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//

#[test]
fn set_constructor() {
    let a = set(1, 2, 3);
    let b = set(a);
    assertEq(a, b);
    assertEq(a.len(), 3);
}

#[test]
fn append() {
    let a: set = set([1, 2]);
    let b = set([2, 3]);
    a.append(b);
    assertEq(a, set(1, 2, 3));
    assertEq(b, set(2, 3));
}

#[test]
fn append_boxed() {
    let a: Box<set> = set([1, 2]);
    let b = box(set([2, 3]));
    a.append(b);
    assertEq(a, set(1, 2, 3));
    assertEq(b, set());
}

#[test]
fn clear() {
    let a = set(1, 2, 3);
    assertEq(a.len(), 3);
    a.clear();
    assertEq(a.len(), 0);
}

#[test]
fn contains() {
    let a = set(('a', 10), true, 'hello', 5);
    assert(a.contains(('a', 10)));
    assert(a.contains(true));
    assertNot(a.contains(false));
    assert(a.contains('hello'));
    assertNot(a.contains('dne'));
    assert(a.contains(5));
    assertNot(a.contains(5.1));
}

#[test]
fn first_last() {
    let a = set(10, 232, 23, 1, 83, -2, 289);
    assertEq(a.first(), -2);
    assertEq(a.last(), 289);
}

#[test]
fn insert() {
    let a = set();
    assert(a.insert(10));
    assertNot(a.insert(10));
    assertEq(a, set(10));
}

#[test]
fn take() {
    let a = set(10);
    assertEq(a.take(2), null);
    assertEq(a.take(10), 10);
    assertEq(a.len(), 0);
}

#[test]
fn split() {
    let a = set(0, 1, 2, 3, 4, 5, 6);
    let b = a.split(3);
    assertEq(a, set(0, 1, 2));
    assertEq(b, set(3, 4, 5, 6));

    let c = b.split(0);
    assertEq(b, set());
    assertEq(c, set(3, 4, 5, 6));

    let d = c.split(7);
    assertEq(c, set(3, 4, 5, 6));
    assertEq(d, set());
}

#[test]
fn empty_any() {
    let a = set();
    assert(a.empty());
    assertNot(a.any());

    a.insert(10);
    assert(a.any());
    assertNot(a.empty());
}

#[test]
fn len() {
    let a = set();
    assertEq(a.len(), 0);
    a.insert(10);
    assertEq(a.len(), 1);
}

#[test]
fn at() {
    let a = set(0, 1, 2, 3, 4, 5, 6, 7);
    assertEq(a.at(1), 1);
    assertEq(a[5], 5);

    let count = 0;
    for (val in a) {
        if (first) assertEq(val, 0);
        if (last) assertEq(val, 7);
        count += 1;
    }
    assertEq(count, 8);
}

#[test]
fn pop_first() {
    let a = set(0, 1, 2, 3, 4);
    assertEq(a.popFirst(), 0);
    assertEq(a.popFirst(), 1);
    assertEq(a.len(), 3);
}

#[test]
fn pop_last() {
    let a = set(0, 1, 2, 3, 4);
    assertEq(a.popLast(), 4);
    assertEq(a.popLast(), 3);
    assertEq(a.len(), 3);
}

#[test]
fn remove() {
    let a = set(1, 2, 3, 4);
    assert(a.remove(3));
    assertNot(a.remove(3));
    assertEq(a.len(), 3);
}

#[test]
fn retain() {
    let a = 0..10 as set;
    a.retain((val: int): bool => val % 2 == 0);
    assertEq(a, set(0, 2, 4, 6, 8));
}

#[test]
fn union() {
    let a = set(1, 2);
    let b = set(2, 3);

    let c = a.union(b);
    let d = a + b;
    assertEq(c, d);
    assertEq(c, set(1, 2, 3));
}

#[test]
fn difference() {
    let a = set(1, 2);
    let b = set(2, 3);

    let c = a.difference(b);
    let d = a - b;
    assertEq(c, d);
    assertEq(c, set(1));
}

#[test]
fn intersection() {
    let a = set(1, 2);
    let b = set(2, 3);

    let c = a.intersection(b);
    let d = a * b;
    assertEq(c, d);
    assertEq(c, set(2));
}

#[test]
fn symmetric_diff() {
    let a = set(1, 2);
    let b = set(2, 3);

    let c = a.symmetricDifference(b);
    let d = a % b;
    assertEq(c, d);
    assertEq(c, set(1, 3));
}

#[test]
fn disjoint() {
    let a = set(1, 2);
    let b = set(2, 3);
    let c = set(3, 4);
    assert(a.disjoint(c));
    assert(c.disjoint(a));
    assertNot(a.disjoint(b));
    assertNot(b.disjoint(a));
    assertNot(b.disjoint(c));
}

#[test]
fn subset() {
    let a = set(1, 2);
    let b = set(1, 2, 3);
    assert(a.subset(b));
    assertNot(b.subset(a));
}

#[test]
fn superset() {
    let a = set(1, 2);
    let b = set(1, 2, 3);
    assertNot(a.superset(b));
    assert(b.superset(a));
}