paysages3d/src/tests/FractalNoise_Test.cpp

#include "BaseTestCase.h"

#include "FractalNoise.h"

class TestFractalNoise : public FractalNoise {
  public:
    TestFractalNoise(double value = 0.0) : FractalNoise(), value(value) {
        NoiseState state;
        state.resetOffsets();
        setState(state);

        calls = 0;
    }

    virtual double getBase3d(double x, double y, double z) const override {
        ((TestFractalNoise *)this)->calls++;
        return value + x + y + z;
    }

  public:
    int calls;

  private:
    double value;
};

TEST(FractalNoise, AutoBase2d) {
    TestFractalNoise noise(0.2);

    double result = noise.getBase2d(0.4, 0.1);

    ASSERT_EQ(1, noise.calls);
    EXPECT_DOUBLE_EQ(0.7, result);
}

TEST(FractalNoise, AutoBase1d) {
    TestFractalNoise noise(0.2);

    double result = noise.getBase1d(0.4);

    ASSERT_EQ(1, noise.calls);
    EXPECT_DOUBLE_EQ(0.6, result);
}

TEST(FractalNoise, NoStep) {
    TestFractalNoise noise(0.1);

    double result = noise.get1d(1.1, 1.0);

    ASSERT_EQ(0, noise.calls);
    EXPECT_DOUBLE_EQ(0.0, result);
}

TEST(FractalNoise, SingleStep) {
    TestFractalNoise noise(0.1);

    double result = noise.get1d(0.7, 1.0);

    ASSERT_EQ(1, noise.calls);
    EXPECT_DOUBLE_EQ(1.1, result);
}

TEST(FractalNoise, Sum2Steps) {
    TestFractalNoise noise(0.1);

    double result = noise.get1d(0.3, 1.0);

    ASSERT_EQ(2, noise.calls);
    EXPECT_DOUBLE_EQ(1.1 + 1.05, result);
}

TEST(FractalNoise, Sum3Steps) {
    TestFractalNoise noise(0.1);

    double result = noise.get1d(0.2, 1.0);

    ASSERT_EQ(3, noise.calls);
    EXPECT_DOUBLE_EQ(1.1 + 1.05 + 1.025, result);
}

TEST(FractalNoise, InitialScaling) {
    TestFractalNoise noise(0.8);
    noise.setScaling(0.5);

    double result = noise.get1d(0.2, 1.0);

    ASSERT_EQ(2, noise.calls);
    EXPECT_DOUBLE_EQ(1.4 + 1.2, result);
}

TEST(FractalNoise, InitialHeight) {
    TestFractalNoise noise(0.8);
    noise.setScaling(1.0, 0.5);

    double result = noise.get1d(0.2, 1.0);

    ASSERT_EQ(2, noise.calls);
    EXPECT_DOUBLE_EQ(0.9 + 0.7, result);
}

TEST(FractalNoise, InitialScalingAndHeight) {
    TestFractalNoise noise(0.8);
    noise.setScaling(0.5, 0.5);

    double result = noise.get1d(0.1, 1.0);

    ASSERT_EQ(2, noise.calls);
    EXPECT_DOUBLE_EQ(0.7 + 0.6, result);
}

TEST(FractalNoise, StepScaling) {
    TestFractalNoise noise(0.1);
    noise.setStep(0.8);

    double result = noise.get1d(0.55, 1.0);

    ASSERT_EQ(3, noise.calls);
    EXPECT_DOUBLE_EQ(1.1 + 1.08 + 1.064, result);
}

TEST(FractalNoise, StepHeight) {
    TestFractalNoise noise(0.1);
    noise.setStep(0.5, 0.8);

    double result = noise.get1d(0.4, 1.0);

    ASSERT_EQ(2, noise.calls);
    EXPECT_DOUBLE_EQ(1.1 + 0.84, result);
}

TEST(FractalNoise, StepScalingAndHeight) {
    TestFractalNoise noise(0.8);
    noise.setStep(0.5, 0.5);

    double result = noise.get1d(0.05, 1.0);

    ASSERT_EQ(3, noise.calls);
    EXPECT_DOUBLE_EQ(1.8 + 0.7 + 0.3, result);
}

TEST(FractalNoise, StateOffset) {
    TestFractalNoise noise(0.8);
    NoiseState state;
    state.resetOffsets(0.2);
    noise.setState(state);

    double result = noise.get1d(0.4, 1.0);

    ASSERT_EQ(2, noise.calls);
    EXPECT_DOUBLE_EQ(2.0 + 1.5, result);
}

TEST(FractalNoise, StateOffsetIter) {
    TestFractalNoise noise(0.8);
    NoiseState state;
    state.setLevel(0, 0.1, 0.1, 0.1);
    state.setLevel(1, 0.6, 0.6, 0.6);
    noise.setState(state);

    double result = noise.get1d(0.4, 1.0);

    ASSERT_EQ(2, noise.calls);
    EXPECT_DOUBLE_EQ(1.9 + 1.7, result);
}

TEST(FractalNoise, StateOffsetLoop) {
    TestFractalNoise noise(0.8);
    NoiseState state;
    state.setLevelCount(2);
    state.setLevel(0, 0.1, 0.1, 0.1);
    state.setLevel(1, 0.6, 0.6, 0.6);
    noise.setState(state);

    double result = noise.get1d(0.2, 1.0);

    ASSERT_EQ(3, noise.calls);
    EXPECT_DOUBLE_EQ(1.9 + 1.7 + 1.225, result);
}

TEST(FractalNoise, Noise2d) {
    TestFractalNoise noise(0.8);
    NoiseState state;
    state.setLevelCount(2);
    state.setLevel(0, 0.1, 0.2, 0.3);
    state.setLevel(1, 0.6, 0.7, 0.8);
    noise.setState(state);

    double result = noise.get2d(0.4, 1.0, 0.5);

    ASSERT_EQ(2, noise.calls);
    EXPECT_DOUBLE_EQ(2.6 + 2.55, result);
}

TEST(FractalNoise, Noise3d) {
    TestFractalNoise noise(0.8);
    NoiseState state;
    state.setLevelCount(2);
    state.setLevel(0, 0.1, 0.2, 0.3);
    state.setLevel(1, 0.6, 0.7, 0.8);
    noise.setState(state);

    double result = noise.get3d(0.4, 1.0, 0.5, 0.3);

    ASSERT_EQ(2, noise.calls);
    EXPECT_DOUBLE_EQ(3.2 + 3.25, result);
}

TEST(FractalNoise, estimateRange) {
    TestFractalNoise noise(0.8);
    noise.setScaling(1.0, 1.0);
    noise.setStep(0.1);

    double min, max;

    noise.estimateRange(&min, &max, 10.0);
    EXPECT_DOUBLE_EQ(0.0, min);
    EXPECT_DOUBLE_EQ(0.0, max);

    noise.estimateRange(&min, &max, 0.5);
    EXPECT_DOUBLE_EQ(-0.5, min);
    EXPECT_DOUBLE_EQ(0.5, max);

    noise.estimateRange(&min, &max, 0.05);
    EXPECT_DOUBLE_EQ(-0.55, min);
    EXPECT_DOUBLE_EQ(0.55, max);

    noise.estimateRange(&min, &max, 0.005);
    EXPECT_DOUBLE_EQ(-0.555, min);
    EXPECT_DOUBLE_EQ(0.555, max);
}