PointTest.cpp File Reference

#include "include/core/SkPoint.h"
#include "include/core/SkRect.h"
#include "include/core/SkScalar.h"
#include "include/core/SkTypes.h"
#include "include/private/base/SkDebug.h"
#include "src/core/SkPointPriv.h"
#include "tests/Test.h"
#include <cfloat>
#include <cstdint>
#include <cstring>
#include <string>

Go to the source code of this file.

Functions
static void	test_casts (skiatest::Reporter *reporter)
static void	test_Normalize (skiatest::Reporter *reporter, SkScalar x, SkScalar y)
static void	test_normalize_cannormalize_consistent (skiatest::Reporter *reporter)
static void	test_length (skiatest::Reporter *reporter, SkScalar x, SkScalar y, SkScalar expectedLength)
template<typename T >
T	get_value (skiatest::Reporter *reporter, T value)
static float	force_as_float (skiatest::Reporter *reporter, float value)
static void	test_overflow (skiatest::Reporter *reporter)
	DEF_TEST (Point, reporter)
	DEF_TEST (Point_setLengthFast, reporter)

Function Documentation

DEF_TEST() [1/2]

DEF_TEST	(	Point	,
		reporter
	)

Definition at line 132 of file PointTest.cpp.

                          {
    test_casts(reporter);
 
    static const struct {
        SkScalar fX;
        SkScalar fY;
        SkScalar fLength;
    } gRec[] = {
        { SkIntToScalar(3), SkIntToScalar(4), SkIntToScalar(5) },
        { 0.6f, 0.8f, SK_Scalar1 },
    };
 
    for (size_t i = 0; i < std::size(gRec); ++i) {
        test_length(reporter, gRec[i].fX, gRec[i].fY, gRec[i].fLength);
    }
 
    test_overflow(reporter);
    test_normalize_cannormalize_consistent(reporter);
}

DEF_TEST() [2/2]

DEF_TEST	(	Point_setLengthFast	,
		reporter
	)

Definition at line 152 of file PointTest.cpp.

                                        {
    // Scale a (1,1) point to a bunch of different lengths,
    // making sure the slow and fast paths are within 0.1%.
    const float tests[] = { 1.0f, 0.0f, 1.0e-37f, 3.4e38f, 42.0f, 0.00012f };
 
    const SkPoint kOne = {1.0f, 1.0f};
    for (unsigned i = 0; i < std::size(tests); i++) {
        SkPoint slow = kOne, fast = kOne;
 
        slow.setLength(tests[i]);
        SkPointPriv::SetLengthFast(&fast, tests[i]);
 
        if (slow.length() < FLT_MIN && fast.length() < FLT_MIN) continue;
 
        SkScalar ratio = slow.length() / fast.length();
        REPORTER_ASSERT(reporter, ratio > 0.999f);
        REPORTER_ASSERT(reporter, ratio < 1.001f);
    }
}

force_as_float()

static float force_as_float ( skiatest::Reporter *  reporter, float  value  )

static

Definition at line 96 of file PointTest.cpp.

                                                                     {
    uint32_t storage;
    memcpy(&storage, &value, 4);
    // even the pair of memcpy calls are not sufficient, since those seem to
    // be no-op'd, so we add a runtime tests (just like get_value) to force
    // the compiler to give us an actual float.
    if (nullptr == reporter) {
        storage = ~storage;
    }
    memcpy(&value, &storage, 4);
    return value;
}

get_value()

template<typename T >

T get_value	(	skiatest::Reporter *	reporter,
		T	value
	)

Definition at line 85 of file PointTest.cpp.

                                                                       {
    return reporter ? value : 0;
}

test_casts()

static void test_casts ( skiatest::Reporter *  reporter )

static

Definition at line 21 of file PointTest.cpp.

                                                   {
    SkPoint p = { 0, 0 };
    SkRect  r = { 0, 0, 0, 0 };
 
    const SkScalar* pPtr = reinterpret_cast<const SkScalar*>(&p);
    const SkScalar* rPtr = reinterpret_cast<const SkScalar*>(&r);
 
    REPORTER_ASSERT(reporter, SkPointPriv::AsScalars(p) == pPtr);
    REPORTER_ASSERT(reporter, r.asScalars() == rPtr);
}

test_length()

static void test_length ( skiatest::Reporter *  reporter, SkScalar  x, SkScalar  y, SkScalar  expectedLength  )

static

Definition at line 64 of file PointTest.cpp.

                                                 {
    SkPoint point;
    point.set(x, y);
    SkScalar s1 = point.length();
    SkScalar s2 = SkPoint::Length(x, y);
    //The following should be exactly the same, but need not be.
    //See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=323
    REPORTER_ASSERT(reporter, SkScalarNearlyEqual(s1, s2));
    REPORTER_ASSERT(reporter, SkScalarNearlyEqual(s1, expectedLength));
 
    test_Normalize(reporter, x, y);
}

test_Normalize()

static void test_Normalize ( skiatest::Reporter *  reporter, SkScalar  x, SkScalar  y  )

static

Definition at line 33 of file PointTest.cpp.

                                                   {
    SkPoint point;
    point.set(x, y);
    SkScalar oldLength = point.length();
    SkScalar returned = SkPoint::Normalize(&point);
    SkScalar newLength = point.length();
    REPORTER_ASSERT(reporter, SkScalarNearlyEqual(returned, oldLength));
    REPORTER_ASSERT(reporter, SkScalarNearlyEqual(newLength, SK_Scalar1));
}

test_normalize_cannormalize_consistent()

static void test_normalize_cannormalize_consistent ( skiatest::Reporter *  reporter )

static

Definition at line 44 of file PointTest.cpp.

                                                                               {
    const SkScalar values[] = { 1, 1e18f, 1e20f, 1e38f, SK_ScalarInfinity, SK_ScalarNaN };
 
    for (SkScalar val : values) {
        const SkScalar variants[] = { val, -val, SkScalarInvert(val), -SkScalarInvert(val) };
 
        for (SkScalar v : variants) {
            const SkPoint pts[] = { { 0, v }, { v, 0 }, { 1, v }, { v, 1 }, { v, v } };
 
            for (SkPoint p : pts) {
                bool can = SkPointPriv::CanNormalize(p.fX, p.fY);
                bool nor = p.normalize();
                REPORTER_ASSERT(reporter, can == nor);
            }
        }
    }
}

test_overflow()

static void test_overflow ( skiatest::Reporter *  reporter )

static

Definition at line 111 of file PointTest.cpp.

                                                      {
    SkScalar bigFloat = get_value(reporter, 3.4e38f);
    SkPoint pt = { bigFloat, bigFloat };
 
    SkScalar length = pt.length();
    length = force_as_float(reporter, length);
 
    // expect this to be non-finite, but dump the results if not.
    if (SkIsFinite(length)) {
        SkDebugf("length(%g, %g) == %g\n", pt.fX, pt.fY, length);
        REPORTER_ASSERT(reporter, !SkIsFinite(length));
    }
 
    // this should succeed, even though we can't represent length
    REPORTER_ASSERT(reporter, pt.setLength(SK_Scalar1));
 
    // now that pt is normalized, we check its length
    length = pt.length();
    REPORTER_ASSERT(reporter, SkScalarNearlyEqual(length, SK_Scalar1));
}