void VerifyCommonBrushProperties()

in winrt/test.internal/graphics/CanvasImageBrushUnitTests.cpp [128:245]
116 lines of code
1 McCabe index (conditional complexity)

    void VerifyCommonBrushProperties(
        ComPtr<CanvasImageBrush> const& brush,
        ComPtr<BackingBrushType> const& backingBrush,
        ICanvasDevice* expectedDevice)
    {
        {
            bool getExtendXCalled = false;
            backingBrush->MockGetExtendModeX =
                [&]
                {
                    Assert::IsFalse(getExtendXCalled);
                    getExtendXCalled = true;
                    return D2D1_EXTEND_MODE_MIRROR;
                };
            CanvasEdgeBehavior edgeBehavior;
            ThrowIfFailed(brush->get_ExtendX(&edgeBehavior));
            Assert::IsTrue(getExtendXCalled);
            Assert::AreEqual(CanvasEdgeBehavior::Mirror, edgeBehavior);
        }
        {
            bool setExtendXCalled = false;
            backingBrush->MockSetExtendModeX =
                [&](D2D1_EXTEND_MODE extendMode)
                {
                    Assert::IsFalse(setExtendXCalled);
                    setExtendXCalled = true;
                    Assert::AreEqual(D2D1_EXTEND_MODE_MIRROR, extendMode);
                };
            ThrowIfFailed(brush->put_ExtendX(CanvasEdgeBehavior::Mirror));
            Assert::IsTrue(setExtendXCalled);
        }
        {
            bool getExtendYCalled = false;
            backingBrush->MockGetExtendModeY =
                [&]
                {
                    Assert::IsFalse(getExtendYCalled);
                    getExtendYCalled = true;
                    return D2D1_EXTEND_MODE_WRAP;
                };
            CanvasEdgeBehavior edgeBehavior;
            ThrowIfFailed(brush->get_ExtendY(&edgeBehavior));
            Assert::IsTrue(getExtendYCalled);
            Assert::AreEqual(CanvasEdgeBehavior::Wrap, edgeBehavior);
        }
        {
            bool setExtendYCalled = false;
            backingBrush->MockSetExtendModeY =
                [&](D2D1_EXTEND_MODE extendMode)
                {
                    Assert::IsFalse(setExtendYCalled);
                    setExtendYCalled = true;
                    Assert::AreEqual(D2D1_EXTEND_MODE_WRAP, extendMode);
                };
            ThrowIfFailed(brush->put_ExtendY(CanvasEdgeBehavior::Wrap));
            Assert::IsTrue(setExtendYCalled);
        }
        {
            bool getOpacityCalled = false;
            backingBrush->MockGetOpacity =
                [&]
                {
                    Assert::IsFalse(getOpacityCalled);
                    getOpacityCalled = true;
                    return 0.6f;
                };
            float opacity;
            ThrowIfFailed(brush->get_Opacity(&opacity));
            Assert::IsTrue(getOpacityCalled);
            Assert::AreEqual(0.6f, opacity);
        }
        {
            bool setOpacityCalled = false;
            backingBrush->MockSetOpacity =
                [&](float opacity)
                {
                    Assert::IsFalse(setOpacityCalled);
                    setOpacityCalled = true;
                    // No sanitization done is supposed to occur.
                    Assert::AreEqual(500.0f, opacity);
                };
            ThrowIfFailed(brush->put_Opacity(500));
            Assert::IsTrue(setOpacityCalled);
        }
        {
            bool getTransformCalled = false;
            D2D1_MATRIX_3X2_F d2dTransform = D2D1::Matrix3x2F(1, 2, 3, 4, 5, 6);
            backingBrush->MockGetTransform =
                [&](D2D1_MATRIX_3X2_F* transform)
                {
                    Assert::IsFalse(getTransformCalled);
                    getTransformCalled = true;
                    *transform = d2dTransform;
                };
            Numerics::Matrix3x2 transform;
            ThrowIfFailed(brush->get_Transform(&transform));
            Assert::IsTrue(getTransformCalled);
            Assert::AreEqual(*(reinterpret_cast<Numerics::Matrix3x2*>(&d2dTransform)), transform);
        }
        {
            bool setTransformCalled = false;
            D2D1_MATRIX_3X2_F d2dTransform = D2D1::Matrix3x2F(1, 2, 3, 4, 5, 6);
            backingBrush->MockSetTransform =
                [&](const D2D1_MATRIX_3X2_F* transform)
                {
                    Assert::IsFalse(setTransformCalled);
                    setTransformCalled = true;
                    Assert::AreEqual(d2dTransform, *transform);
                };
            Numerics::Matrix3x2 transform = *(reinterpret_cast<Numerics::Matrix3x2*>(&d2dTransform));
            ThrowIfFailed(brush->put_Transform(transform));
            Assert::IsTrue(setTransformCalled);
        }

        ComPtr<ICanvasDevice> actualDevice;
        brush->get_Device(&actualDevice);
        Assert::AreEqual(expectedDevice, actualDevice.Get());
    }