mirror of
https://github.com/SerenityOS/serenity
synced 2026-04-25 17:15:42 +02:00
0cd71f1d91
The tests show that mod(a, b) takes on the sign of b while a % b takes on the sign of a. As b is usually a positive constant, mod() is useful when you want a guaranteed positive result. mod() matches the semantics of % in Python. Also, mod(a, b) == mod(a, abs(b)) modulo b, while a % b != abs(a) % b modulo b. So mod() makes it easier to get a guaranteed-positive result even if the sign of b is unknown. No behavior change.
197 lines
4.6 KiB
C++
197 lines
4.6 KiB
C++
/*
|
|
* Copyright (c) 2021, Tim Flynn <trflynn89@serenityos.org>
|
|
*
|
|
* SPDX-License-Identifier: BSD-2-Clause
|
|
*/
|
|
|
|
#include <LibTest/TestSuite.h>
|
|
|
|
#include <AK/Optional.h>
|
|
#include <AK/StdLibExtras.h>
|
|
#include <AK/StringView.h>
|
|
#include <AK/Variant.h>
|
|
#include <AK/Vector.h>
|
|
|
|
TEST_CASE(ceil_div)
|
|
{
|
|
EXPECT_EQ(ceil_div(0, 1), 0);
|
|
EXPECT_EQ(ceil_div(1, 1), 1);
|
|
EXPECT_EQ(ceil_div(2, 1), 2);
|
|
EXPECT_EQ(ceil_div(3, 1), 3);
|
|
EXPECT_EQ(ceil_div(4, 1), 4);
|
|
|
|
EXPECT_EQ(ceil_div(-0, 1), 0);
|
|
EXPECT_EQ(ceil_div(-1, 1), -1);
|
|
EXPECT_EQ(ceil_div(-2, 1), -2);
|
|
EXPECT_EQ(ceil_div(-3, 1), -3);
|
|
EXPECT_EQ(ceil_div(-4, 1), -4);
|
|
|
|
EXPECT_EQ(ceil_div(0, -1), 0);
|
|
EXPECT_EQ(ceil_div(1, -1), -1);
|
|
EXPECT_EQ(ceil_div(2, -1), -2);
|
|
EXPECT_EQ(ceil_div(3, -1), -3);
|
|
EXPECT_EQ(ceil_div(4, -1), -4);
|
|
|
|
EXPECT_EQ(ceil_div(-0, -1), 0);
|
|
EXPECT_EQ(ceil_div(-1, -1), 1);
|
|
EXPECT_EQ(ceil_div(-2, -1), 2);
|
|
EXPECT_EQ(ceil_div(-3, -1), 3);
|
|
EXPECT_EQ(ceil_div(-4, -1), 4);
|
|
|
|
EXPECT_EQ(ceil_div(0, 2), 0);
|
|
EXPECT_EQ(ceil_div(1, 2), 1);
|
|
EXPECT_EQ(ceil_div(2, 2), 1);
|
|
EXPECT_EQ(ceil_div(3, 2), 2);
|
|
EXPECT_EQ(ceil_div(4, 2), 2);
|
|
|
|
EXPECT_EQ(ceil_div(-0, 2), 0);
|
|
EXPECT_EQ(ceil_div(-1, 2), 0);
|
|
EXPECT_EQ(ceil_div(-2, 2), -1);
|
|
EXPECT_EQ(ceil_div(-3, 2), -1);
|
|
EXPECT_EQ(ceil_div(-4, 2), -2);
|
|
|
|
EXPECT_EQ(ceil_div(0, -2), 0);
|
|
EXPECT_EQ(ceil_div(1, -2), 0);
|
|
EXPECT_EQ(ceil_div(2, -2), -1);
|
|
EXPECT_EQ(ceil_div(3, -2), -1);
|
|
EXPECT_EQ(ceil_div(4, -2), -2);
|
|
|
|
EXPECT_EQ(ceil_div(-0, -2), 0);
|
|
EXPECT_EQ(ceil_div(-1, -2), 1);
|
|
EXPECT_EQ(ceil_div(-2, -2), 1);
|
|
EXPECT_EQ(ceil_div(-3, -2), 2);
|
|
EXPECT_EQ(ceil_div(-4, -2), 2);
|
|
}
|
|
|
|
TEST_CASE(floor_div)
|
|
{
|
|
EXPECT_EQ(floor_div(0, 1), 0);
|
|
EXPECT_EQ(floor_div(1, 1), 1);
|
|
EXPECT_EQ(floor_div(2, 1), 2);
|
|
EXPECT_EQ(floor_div(3, 1), 3);
|
|
EXPECT_EQ(floor_div(4, 1), 4);
|
|
|
|
EXPECT_EQ(floor_div(-0, 1), 0);
|
|
EXPECT_EQ(floor_div(-1, 1), -1);
|
|
EXPECT_EQ(floor_div(-2, 1), -2);
|
|
EXPECT_EQ(floor_div(-3, 1), -3);
|
|
EXPECT_EQ(floor_div(-4, 1), -4);
|
|
|
|
EXPECT_EQ(floor_div(0, -1), 0);
|
|
EXPECT_EQ(floor_div(1, -1), -1);
|
|
EXPECT_EQ(floor_div(2, -1), -2);
|
|
EXPECT_EQ(floor_div(3, -1), -3);
|
|
EXPECT_EQ(floor_div(4, -1), -4);
|
|
|
|
EXPECT_EQ(floor_div(-0, -1), 0);
|
|
EXPECT_EQ(floor_div(-1, -1), 1);
|
|
EXPECT_EQ(floor_div(-2, -1), 2);
|
|
EXPECT_EQ(floor_div(-3, -1), 3);
|
|
EXPECT_EQ(floor_div(-4, -1), 4);
|
|
|
|
EXPECT_EQ(floor_div(0, 2), 0);
|
|
EXPECT_EQ(floor_div(1, 2), 0);
|
|
EXPECT_EQ(floor_div(2, 2), 1);
|
|
EXPECT_EQ(floor_div(3, 2), 1);
|
|
EXPECT_EQ(floor_div(4, 2), 2);
|
|
|
|
EXPECT_EQ(floor_div(-0, 2), 0);
|
|
EXPECT_EQ(floor_div(-1, 2), -1);
|
|
EXPECT_EQ(floor_div(-2, 2), -1);
|
|
EXPECT_EQ(floor_div(-3, 2), -2);
|
|
EXPECT_EQ(floor_div(-4, 2), -2);
|
|
|
|
EXPECT_EQ(floor_div(0, -2), 0);
|
|
EXPECT_EQ(floor_div(1, -2), -1);
|
|
EXPECT_EQ(floor_div(2, -2), -1);
|
|
EXPECT_EQ(floor_div(3, -2), -2);
|
|
EXPECT_EQ(floor_div(4, -2), -2);
|
|
|
|
EXPECT_EQ(floor_div(-0, -2), 0);
|
|
EXPECT_EQ(floor_div(-1, -2), 0);
|
|
EXPECT_EQ(floor_div(-2, -2), 1);
|
|
EXPECT_EQ(floor_div(-3, -2), 1);
|
|
EXPECT_EQ(floor_div(-4, -2), 2);
|
|
}
|
|
|
|
TEST_CASE(mix)
|
|
{
|
|
double a = 1.0;
|
|
double b = 3.0;
|
|
|
|
EXPECT_APPROXIMATE(mix(a, b, 0.0), 1.0);
|
|
EXPECT_APPROXIMATE(mix(a, b, 0.5), 2.0);
|
|
EXPECT_APPROXIMATE(mix(a, b, 1.0), 3.0);
|
|
|
|
EXPECT_APPROXIMATE(mix(b, a, 0.0), 3.0);
|
|
EXPECT_APPROXIMATE(mix(b, a, 0.5), 2.0);
|
|
EXPECT_APPROXIMATE(mix(b, a, 1.0), 1.0);
|
|
}
|
|
|
|
TEST_CASE(mod)
|
|
{
|
|
EXPECT_EQ(mod(5, 3), 2);
|
|
EXPECT_EQ(mod(-5, 3), 1);
|
|
EXPECT_EQ(-5 % 3, -2);
|
|
EXPECT_EQ(mod(5, -3), -1);
|
|
EXPECT_EQ(5 % -3, 2);
|
|
EXPECT_EQ(mod(-5, -3), -2);
|
|
EXPECT_EQ(-5 % -3, -2);
|
|
|
|
EXPECT_EQ(mod(4, 2), 0);
|
|
EXPECT_EQ(mod(-4, 2), 0);
|
|
EXPECT_EQ(mod(4, -2), 0);
|
|
EXPECT_EQ(mod(-4, -2), 0);
|
|
|
|
EXPECT_EQ(mod(1, 1), 0);
|
|
EXPECT_EQ(mod(-1, 1), 0);
|
|
EXPECT_EQ(mod(1, -1), 0);
|
|
EXPECT_EQ(mod(-1, -1), 0);
|
|
|
|
EXPECT_EQ(mod(0, 5), 0);
|
|
EXPECT_EQ(mod(0, -5), 0);
|
|
}
|
|
|
|
TEST_CASE(swap)
|
|
{
|
|
int i = 4;
|
|
int j = 6;
|
|
|
|
swap(i, j);
|
|
|
|
EXPECT_EQ(i, 6);
|
|
EXPECT_EQ(j, 4);
|
|
}
|
|
|
|
TEST_CASE(swap_same_value)
|
|
{
|
|
|
|
int i = 4;
|
|
swap(i, i);
|
|
EXPECT_EQ(i, 4);
|
|
}
|
|
|
|
TEST_CASE(swap_same_complex_object)
|
|
{
|
|
struct Type1 {
|
|
StringView foo;
|
|
};
|
|
struct Type2 {
|
|
Optional<Type1> foo;
|
|
Vector<Type1> bar;
|
|
};
|
|
|
|
Variant<Type1, Type2> value1 { Type1 { "hello"sv } };
|
|
Variant<Type1, Type2> value2 { Type2 { {}, { { "goodbye"sv } } } };
|
|
|
|
swap(value1, value2);
|
|
|
|
EXPECT(value1.has<Type2>());
|
|
EXPECT(value2.has<Type1>());
|
|
|
|
swap(value1, value1);
|
|
|
|
EXPECT(value1.has<Type2>());
|
|
EXPECT(value2.has<Type1>());
|
|
}
|