FreeCAD / tests /src /Mod /Part /App /FeatureExtrusion.cpp

Upload folder using huggingface_hub

985c397 verified 9 months ago

11.9 kB

// SPDX-License-Identifier: LGPL-2.1-or-later

#include <cmath>
#include <Base/Tools.h>
#include "Mod/Part/App/FeatureExtrusion.h"
#include <src/App/InitApplication.h>

#include "BRepBuilderAPI_MakeEdge.hxx"

#include "PartTestHelpers.h"

class FeatureExtrusionTest: public ::testing::Test, public PartTestHelpers::PartTestHelperClass
{
protected:
    static void SetUpTestSuite()
    {
        tests::initApplication();
    }


    void SetUp() override
    {
        createTestDoc();
        _extrusion = _doc->addObject<Part::Extrusion>();
        PartTestHelpers::rectangle(len, wid, "Rect1");
        _extrusion->Base.setValue(_doc->getObjects().back());
        _extrusion->LengthFwd.setValue(ext1);
    }

    void TearDown() override
    {}

    // NOLINTBEGIN(cppcoreguidelines-non-private-member-variables-in-classes)
    Part::Extrusion* _extrusion = nullptr;
    // Arbtitrary constants for testing.  Named here for clarity.
    const double len = 3.0;
    const double wid = 4.0;
    const double ext1 = 10.0;
    // NOLINTEND(cppcoreguidelines-non-private-member-variables-in-classes)
};

TEST_F(FeatureExtrusionTest, testMustExecute)
{
    // Assert
    EXPECT_TRUE(_extrusion->mustExecute());
    // Act
    _doc->recompute();
    // Assert
    EXPECT_FALSE(_extrusion->mustExecute());
    // Act
    _extrusion->Base.setValue(_extrusion->Base.getValue());
    // Assert
    EXPECT_TRUE(_extrusion->mustExecute());
    // Act
    _doc->recompute();
    // Assert
    EXPECT_FALSE(_extrusion->mustExecute());
    // Act
    _extrusion->Solid.setValue(Standard_True);
    // Assert
    EXPECT_TRUE(_extrusion->mustExecute());
    // Act
    _doc->recompute();
    // Assert
    EXPECT_FALSE(_extrusion->mustExecute());
}

TEST_F(FeatureExtrusionTest, testGetProviderName)
{
    // Act
    _extrusion->execute();
    const char* name = _extrusion->getViewProviderName();
    // Assert
    EXPECT_STREQ(name, "PartGui::ViewProviderExtrusion");
}

// Not clear if there is test value in this one.

TEST_F(FeatureExtrusionTest, testFetchAxisLink)
{
    // static bool fetchAxisLink(const App::PropertyLinkSub& axisLink,
    //                           Base::Vector3d& basepoint,
    //                           Base::Vector3d& dir);
}

// Filling in these next two tests seems very redundant, since they are used in execute()
// and thus tested by the results there.  In the event that ever went funny, then maybe
// implementation here would make sense.

TEST_F(FeatureExtrusionTest, testExtrudeShape)
{
    // static TopoShape extrudeShape(const TopoShape& source, const ExtrusionParameters& params);
}

TEST_F(FeatureExtrusionTest, testComputeFinalParameters)
{
    // ExtrusionParameters computeFinalParameters();
}

TEST_F(FeatureExtrusionTest, testExecuteSimple)
{
    // Arrange
    // Act
    _extrusion->execute();
    Part::TopoShape ts = _extrusion->Shape.getValue();
    double volume = PartTestHelpers::getVolume(ts.getShape());
    Base::BoundBox3d bb = ts.getBoundBox();
    // Assert
    EXPECT_FLOAT_EQ(volume, len * wid * ext1);
    EXPECT_TRUE(PartTestHelpers::boxesMatch(bb, Base::BoundBox3d(0, 0, 0, len, wid, ext1)));
}

TEST_F(FeatureExtrusionTest, testExecuteSimpleRev)
{
    const double ext2 = 9;
    // Arrange
    _extrusion->LengthFwd.setValue(0);
    _extrusion->LengthRev.setValue(ext2);
    // Act
    _extrusion->execute();
    Part::TopoShape ts = _extrusion->Shape.getValue();
    double volume = PartTestHelpers::getVolume(ts.getShape());
    Base::BoundBox3d bb = ts.getBoundBox();
    // Assert
    EXPECT_FLOAT_EQ(volume, len * wid * ext2);
    EXPECT_TRUE(PartTestHelpers::boxesMatch(bb, Base::BoundBox3d(0, 0, -ext2, len, wid, 0)));
}

TEST_F(FeatureExtrusionTest, testExecuteSolid)
{
    // Arrange
    _extrusion->Solid.setValue(true);
    // Act
    _extrusion->execute();
    Part::TopoShape ts = _extrusion->Shape.getValue();
    double volume = PartTestHelpers::getVolume(ts.getShape());
    Base::BoundBox3d bb = ts.getBoundBox();
    // Assert
    EXPECT_FLOAT_EQ(volume, len * wid * ext1);
    EXPECT_TRUE(PartTestHelpers::boxesMatch(bb, Base::BoundBox3d(0, 0, 0, len, wid, ext1)));
}

TEST_F(FeatureExtrusionTest, testExecuteReverse)
{
    // Arrange
    _extrusion->Reversed.setValue(true);
    // Act
    _extrusion->execute();
    Part::TopoShape ts = _extrusion->Shape.getValue();
    double volume = PartTestHelpers::getVolume(ts.getShape());
    Base::BoundBox3d bb = ts.getBoundBox();
    // Assert
    EXPECT_FLOAT_EQ(volume, len * wid * ext1);
    EXPECT_TRUE(PartTestHelpers::boxesMatch(bb, Base::BoundBox3d(0, 0, -ext1, len, wid, 0)));
}

TEST_F(FeatureExtrusionTest, testExecuteSymmetric)
{
    // Arrange
    _extrusion->Symmetric.setValue(true);
    // Act
    _extrusion->execute();
    Part::TopoShape ts = _extrusion->Shape.getValue();
    double volume = PartTestHelpers::getVolume(ts.getShape());
    Base::BoundBox3d bb = ts.getBoundBox();
    // Assert
    EXPECT_FLOAT_EQ(volume, len * wid * ext1);
    EXPECT_TRUE(PartTestHelpers::boxesMatch(bb, Base::BoundBox3d(0, 0, -ext1 / 2, len, wid, ext1 / 2)));
}

TEST_F(FeatureExtrusionTest, testExecuteAngled)
{
    // Arrange
    const double ang = 30;
    const double tangent = tan(Base::toRadians(ang));

    // The shape is a truncated pyramid elongated by a truncated triangular prism in the middle.
    // Calc the volume of full size pyramid and prism, and subtract top volumes to truncate.
    const double shorterSide = len > wid ? wid : len;
    const double longerSide = len < wid ? wid : len;
    const double centerWidth = longerSide - shorterSide;  // Width of the triang prism.
    const double topHeight = shorterSide / tangent / 2;   // Height of the truncation
    const double fullHeight = ext1 + topHeight;
    const double fullPrismVol = fullHeight * (shorterSide + ext1 * tangent * 2.0) / 2.0 * centerWidth;
    const double fullPyrVol = pow(shorterSide + ext1 * tangent * 2.0, 2.0) / 3.0 * fullHeight;
    const double topPrismVol = topHeight * shorterSide / 2.0 * centerWidth;
    const double topPyrVol = pow(shorterSide, 2.0) / 3.0 * topHeight;
    const double targetVol = (fullPyrVol + fullPrismVol) - (topPyrVol + topPrismVol);
    _extrusion->Solid.setValue(true);
    _extrusion->TaperAngle.setValue(ang);
    // Act
    _extrusion->execute();
    Part::TopoShape ts = _extrusion->Shape.getValue();
    double volume = PartTestHelpers::getVolume(ts.getShape());
    Base::BoundBox3d bb = ts.getBoundBox();
    // Assert
    EXPECT_FLOAT_EQ(volume, targetVol);
    EXPECT_TRUE(
        PartTestHelpers::boxesMatch(
            bb,
            Base::BoundBox3d(-ext1 * tangent, -ext1 * tangent, 0, len + ext1 * tangent, wid + ext1 * tangent, ext1)
        )
    );
}

TEST_F(FeatureExtrusionTest, testExecuteAngledRev)
{
    // Arrange
    const double ang = 30;
    const double tangent = tan(Base::toRadians(ang));
    // The shape is a truncated pyramid elongated by a truncated triangular prism in the middle,
    // plus a rectangular prism.
    // Calc the volume of full size pyramid and prism, and subtract top volumes to truncate.
    const double shorterSide = len > wid ? wid : len;
    const double longerSide = len < wid ? wid : len;
    const double centerWidth = longerSide - shorterSide;  // Width of the triang prism.
    const double topHeight = shorterSide / tangent / 2;   // Height of the truncation
    const double fullHeight = ext1 / 2 + topHeight;
    const double fullPrismVol = fullHeight * (shorterSide + ext1 / 2 * tangent * 2.0) / 2.0
        * centerWidth;
    const double fullPyrVol = pow(shorterSide + ext1 / 2 * tangent * 2.0, 2.0) / 3.0 * fullHeight;
    const double topPrismVol = topHeight * shorterSide / 2.0 * centerWidth;
    const double topPyrVol = pow(shorterSide, 2.0) / 3.0 * topHeight;
    const double targetVol = (fullPyrVol + fullPrismVol) - (topPyrVol + topPrismVol)
        + len * wid * ext1 / 2;

    _extrusion->Solid.setValue(true);
    _extrusion->Symmetric.setValue(true);
    _extrusion->TaperAngleRev.setValue(ang);
    // Act
    _extrusion->execute();
    Part::TopoShape ts = _extrusion->Shape.getValue();
    double volume = PartTestHelpers::getVolume(ts.getShape());
    Base::BoundBox3d bb = ts.getBoundBox();
    // Assert
    EXPECT_FLOAT_EQ(volume, targetVol);
    EXPECT_TRUE(
        PartTestHelpers::boxesMatch(
            bb,
            Base::BoundBox3d(
                -ext1 * tangent / 2,
                -ext1 * tangent / 2,
                -ext1 / 2,
                len + ext1 * tangent / 2,
                wid + ext1 * tangent / 2,
                ext1 / 2
            )
        )
    );
}

TEST_F(FeatureExtrusionTest, testExecuteEdge)
{
    // Arrange
    const double ang = 30;
    const double tangent = tan(Base::toRadians(ang));
    BRepBuilderAPI_MakeEdge e1(gp_Pnt(0, 0, 0), gp_Pnt(ext1, ext1, ext1));
    auto edge = _doc->addObject<Part::Feature>("Edge");
    edge->Shape.setValue(e1);
    _extrusion->DirLink.setValue(edge);
    _extrusion->DirMode.setValue(1);
    // Act
    _extrusion->execute();
    Part::TopoShape ts = _extrusion->Shape.getValue();
    double volume = PartTestHelpers::getVolume(ts.getShape());
    Base::BoundBox3d bb = ts.getBoundBox();
    // Assert
    EXPECT_FLOAT_EQ(volume, len * wid * ext1 * tangent);
    EXPECT_TRUE(
        PartTestHelpers::boxesMatch(
            bb,
            Base::BoundBox3d(0, 0, 0, len + ext1 * tangent, wid + ext1 * tangent, ext1 * tangent)
        )
    );
}

TEST_F(FeatureExtrusionTest, testExecuteDir)
{
    // Arrange
    const double sin45 = sin(Base::toRadians(45.0));
    _extrusion->Dir.setValue(Base::Vector3d(0, 1, 1));
    _extrusion->DirMode.setValue((long)0);
    // Act
    _extrusion->execute();
    Part::TopoShape ts = _extrusion->Shape.getValue();
    double volume = PartTestHelpers::getVolume(ts.getShape());
    Base::BoundBox3d bb = ts.getBoundBox();
    // Assert
    EXPECT_FLOAT_EQ(volume, len * wid * ext1 * sin45);
    EXPECT_TRUE(
        PartTestHelpers::boxesMatch(bb, Base::BoundBox3d(0, 0, 0, len, wid + ext1 * sin45, ext1 * sin45))
    );
}

TEST_F(FeatureExtrusionTest, testExecuteFaceMaker)
{
    // Arrange
    _extrusion->FaceMakerClass.setValue("Part::FaceMakerCheese");
    // Act
    _extrusion->execute();
    Part::TopoShape ts = _extrusion->Shape.getValue();
    double volume = PartTestHelpers::getVolume(ts.getShape());
    Base::BoundBox3d bb = ts.getBoundBox();
    // Assert
    EXPECT_FLOAT_EQ(volume, len * wid * ext1);
    EXPECT_TRUE(PartTestHelpers::boxesMatch(bb, Base::BoundBox3d(0, 0, 0, len, wid, ext1)));
}

TEST_F(FeatureExtrusionTest, testFaceWithHoles)
{
    // Arrange
    float radius = 0.75;
    auto [face1, wire1, wire2] = PartTestHelpers::CreateFaceWithRoundHole(len, wid, radius);
    // face1 is the sum of the outside (wire1) and the internal hole (wire2).
    Part::TopoShape newFace = Part::TopoShape(face1).makeElementFace(nullptr);
    // newFace cleans that up and is the outside minus the internal hole.
    auto face2 = newFace.getShape();

    auto partFeature = _doc->addObject<Part::Feature>();
    partFeature->Shape.setValue(face2);
    _extrusion->Base.setValue(_doc->getObjects().back());
    _extrusion->FaceMakerClass.setValue("Part::FaceMakerCheese");
    // Act
    _extrusion->execute();
    Part::TopoShape ts = _extrusion->Shape.getValue();
    double volume = PartTestHelpers::getVolume(ts.getShape());
    Base::BoundBox3d bb = ts.getBoundBox();
    // Assert
    EXPECT_FLOAT_EQ(volume, len * wid * ext1 - radius * radius * std::numbers::pi * ext1);
    EXPECT_TRUE(PartTestHelpers::boxesMatch(bb, Base::BoundBox3d(0, 0, 0, len, wid, ext1)));
    EXPECT_FLOAT_EQ(PartTestHelpers::getArea(face1), len * wid + radius * radius * std::numbers::pi);
    EXPECT_FLOAT_EQ(PartTestHelpers::getArea(face2), len * wid - radius * radius * std::numbers::pi);
}

	// SPDX-License-Identifier: LGPL-2.1-or-later

	#include <cmath>
	#include <Base/Tools.h>
	#include "Mod/Part/App/FeatureExtrusion.h"
	#include <src/App/InitApplication.h>

	#include "BRepBuilderAPI_MakeEdge.hxx"

	#include "PartTestHelpers.h"

	class FeatureExtrusionTest: public ::testing::Test, public PartTestHelpers::PartTestHelperClass
	{
	protected:
	static void SetUpTestSuite()
	{
	tests::initApplication();
	}


	void SetUp() override
	{
	createTestDoc();
	_extrusion = _doc->addObject<Part::Extrusion>();
	PartTestHelpers::rectangle(len, wid, "Rect1");
	_extrusion->Base.setValue(_doc->getObjects().back());
	_extrusion->LengthFwd.setValue(ext1);
	}

	void TearDown() override
	{}

	// NOLINTBEGIN(cppcoreguidelines-non-private-member-variables-in-classes)
	Part::Extrusion* _extrusion = nullptr;
	// Arbtitrary constants for testing. Named here for clarity.
	const double len = 3.0;
	const double wid = 4.0;
	const double ext1 = 10.0;
	// NOLINTEND(cppcoreguidelines-non-private-member-variables-in-classes)
	};

	TEST_F(FeatureExtrusionTest, testMustExecute)
	{
	// Assert
	EXPECT_TRUE(_extrusion->mustExecute());
	// Act
	_doc->recompute();
	// Assert
	EXPECT_FALSE(_extrusion->mustExecute());
	// Act
	_extrusion->Base.setValue(_extrusion->Base.getValue());
	// Assert
	EXPECT_TRUE(_extrusion->mustExecute());
	// Act
	_doc->recompute();
	// Assert
	EXPECT_FALSE(_extrusion->mustExecute());
	// Act
	_extrusion->Solid.setValue(Standard_True);
	// Assert
	EXPECT_TRUE(_extrusion->mustExecute());
	// Act
	_doc->recompute();
	// Assert
	EXPECT_FALSE(_extrusion->mustExecute());
	}

	TEST_F(FeatureExtrusionTest, testGetProviderName)
	{
	// Act
	_extrusion->execute();
	const char* name = _extrusion->getViewProviderName();
	// Assert
	EXPECT_STREQ(name, "PartGui::ViewProviderExtrusion");
	}

	// Not clear if there is test value in this one.

	TEST_F(FeatureExtrusionTest, testFetchAxisLink)
	{
	// static bool fetchAxisLink(const App::PropertyLinkSub& axisLink,
	// Base::Vector3d& basepoint,
	// Base::Vector3d& dir);
	}

	// Filling in these next two tests seems very redundant, since they are used in execute()
	// and thus tested by the results there. In the event that ever went funny, then maybe
	// implementation here would make sense.

	TEST_F(FeatureExtrusionTest, testExtrudeShape)
	{
	// static TopoShape extrudeShape(const TopoShape& source, const ExtrusionParameters& params);
	}

	TEST_F(FeatureExtrusionTest, testComputeFinalParameters)
	{
	// ExtrusionParameters computeFinalParameters();
	}

	TEST_F(FeatureExtrusionTest, testExecuteSimple)
	{
	// Arrange
	// Act
	_extrusion->execute();
	Part::TopoShape ts = _extrusion->Shape.getValue();
	double volume = PartTestHelpers::getVolume(ts.getShape());
	Base::BoundBox3d bb = ts.getBoundBox();
	// Assert
	EXPECT_FLOAT_EQ(volume, len * wid * ext1);
	EXPECT_TRUE(PartTestHelpers::boxesMatch(bb, Base::BoundBox3d(0, 0, 0, len, wid, ext1)));
	}

	TEST_F(FeatureExtrusionTest, testExecuteSimpleRev)
	{
	const double ext2 = 9;
	// Arrange
	_extrusion->LengthFwd.setValue(0);
	_extrusion->LengthRev.setValue(ext2);
	// Act
	_extrusion->execute();
	Part::TopoShape ts = _extrusion->Shape.getValue();
	double volume = PartTestHelpers::getVolume(ts.getShape());
	Base::BoundBox3d bb = ts.getBoundBox();
	// Assert
	EXPECT_FLOAT_EQ(volume, len * wid * ext2);
	EXPECT_TRUE(PartTestHelpers::boxesMatch(bb, Base::BoundBox3d(0, 0, -ext2, len, wid, 0)));
	}

	TEST_F(FeatureExtrusionTest, testExecuteSolid)
	{
	// Arrange
	_extrusion->Solid.setValue(true);
	// Act
	_extrusion->execute();
	Part::TopoShape ts = _extrusion->Shape.getValue();
	double volume = PartTestHelpers::getVolume(ts.getShape());
	Base::BoundBox3d bb = ts.getBoundBox();
	// Assert
	EXPECT_FLOAT_EQ(volume, len * wid * ext1);
	EXPECT_TRUE(PartTestHelpers::boxesMatch(bb, Base::BoundBox3d(0, 0, 0, len, wid, ext1)));
	}

	TEST_F(FeatureExtrusionTest, testExecuteReverse)
	{
	// Arrange
	_extrusion->Reversed.setValue(true);
	// Act
	_extrusion->execute();
	Part::TopoShape ts = _extrusion->Shape.getValue();
	double volume = PartTestHelpers::getVolume(ts.getShape());
	Base::BoundBox3d bb = ts.getBoundBox();
	// Assert
	EXPECT_FLOAT_EQ(volume, len * wid * ext1);
	EXPECT_TRUE(PartTestHelpers::boxesMatch(bb, Base::BoundBox3d(0, 0, -ext1, len, wid, 0)));
	}

	TEST_F(FeatureExtrusionTest, testExecuteSymmetric)
	{
	// Arrange
	_extrusion->Symmetric.setValue(true);
	// Act
	_extrusion->execute();
	Part::TopoShape ts = _extrusion->Shape.getValue();
	double volume = PartTestHelpers::getVolume(ts.getShape());
	Base::BoundBox3d bb = ts.getBoundBox();
	// Assert
	EXPECT_FLOAT_EQ(volume, len * wid * ext1);
	EXPECT_TRUE(PartTestHelpers::boxesMatch(bb, Base::BoundBox3d(0, 0, -ext1 / 2, len, wid, ext1 / 2)));
	}

	TEST_F(FeatureExtrusionTest, testExecuteAngled)
	{
	// Arrange
	const double ang = 30;
	const double tangent = tan(Base::toRadians(ang));

	// The shape is a truncated pyramid elongated by a truncated triangular prism in the middle.
	// Calc the volume of full size pyramid and prism, and subtract top volumes to truncate.
	const double shorterSide = len > wid ? wid : len;
	const double longerSide = len < wid ? wid : len;
	const double centerWidth = longerSide - shorterSide; // Width of the triang prism.
	const double topHeight = shorterSide / tangent / 2; // Height of the truncation
	const double fullHeight = ext1 + topHeight;
	const double fullPrismVol = fullHeight * (shorterSide + ext1 * tangent * 2.0) / 2.0 * centerWidth;
	const double fullPyrVol = pow(shorterSide + ext1 * tangent * 2.0, 2.0) / 3.0 * fullHeight;
	const double topPrismVol = topHeight * shorterSide / 2.0 * centerWidth;
	const double topPyrVol = pow(shorterSide, 2.0) / 3.0 * topHeight;
	const double targetVol = (fullPyrVol + fullPrismVol) - (topPyrVol + topPrismVol);
	_extrusion->Solid.setValue(true);
	_extrusion->TaperAngle.setValue(ang);
	// Act
	_extrusion->execute();
	Part::TopoShape ts = _extrusion->Shape.getValue();
	double volume = PartTestHelpers::getVolume(ts.getShape());
	Base::BoundBox3d bb = ts.getBoundBox();
	// Assert
	EXPECT_FLOAT_EQ(volume, targetVol);
	EXPECT_TRUE(
	PartTestHelpers::boxesMatch(
	bb,
	Base::BoundBox3d(-ext1 * tangent, -ext1 * tangent, 0, len + ext1 * tangent, wid + ext1 * tangent, ext1)
	)
	);
	}

	TEST_F(FeatureExtrusionTest, testExecuteAngledRev)
	{
	// Arrange
	const double ang = 30;
	const double tangent = tan(Base::toRadians(ang));
	// The shape is a truncated pyramid elongated by a truncated triangular prism in the middle,
	// plus a rectangular prism.
	// Calc the volume of full size pyramid and prism, and subtract top volumes to truncate.
	const double shorterSide = len > wid ? wid : len;
	const double longerSide = len < wid ? wid : len;
	const double centerWidth = longerSide - shorterSide; // Width of the triang prism.
	const double topHeight = shorterSide / tangent / 2; // Height of the truncation
	const double fullHeight = ext1 / 2 + topHeight;
	const double fullPrismVol = fullHeight * (shorterSide + ext1 / 2 * tangent * 2.0) / 2.0
	* centerWidth;
	const double fullPyrVol = pow(shorterSide + ext1 / 2 * tangent * 2.0, 2.0) / 3.0 * fullHeight;
	const double topPrismVol = topHeight * shorterSide / 2.0 * centerWidth;
	const double topPyrVol = pow(shorterSide, 2.0) / 3.0 * topHeight;
	const double targetVol = (fullPyrVol + fullPrismVol) - (topPyrVol + topPrismVol)
	+ len * wid * ext1 / 2;

	_extrusion->Solid.setValue(true);
	_extrusion->Symmetric.setValue(true);
	_extrusion->TaperAngleRev.setValue(ang);
	// Act
	_extrusion->execute();
	Part::TopoShape ts = _extrusion->Shape.getValue();
	double volume = PartTestHelpers::getVolume(ts.getShape());
	Base::BoundBox3d bb = ts.getBoundBox();
	// Assert
	EXPECT_FLOAT_EQ(volume, targetVol);
	EXPECT_TRUE(
	PartTestHelpers::boxesMatch(
	bb,
	Base::BoundBox3d(
	-ext1 * tangent / 2,
	-ext1 * tangent / 2,
	-ext1 / 2,
	len + ext1 * tangent / 2,
	wid + ext1 * tangent / 2,
	ext1 / 2
	)
	)
	);
	}

	TEST_F(FeatureExtrusionTest, testExecuteEdge)
	{
	// Arrange
	const double ang = 30;
	const double tangent = tan(Base::toRadians(ang));
	BRepBuilderAPI_MakeEdge e1(gp_Pnt(0, 0, 0), gp_Pnt(ext1, ext1, ext1));
	auto edge = _doc->addObject<Part::Feature>("Edge");
	edge->Shape.setValue(e1);
	_extrusion->DirLink.setValue(edge);
	_extrusion->DirMode.setValue(1);
	// Act
	_extrusion->execute();
	Part::TopoShape ts = _extrusion->Shape.getValue();
	double volume = PartTestHelpers::getVolume(ts.getShape());
	Base::BoundBox3d bb = ts.getBoundBox();
	// Assert
	EXPECT_FLOAT_EQ(volume, len * wid * ext1 * tangent);
	EXPECT_TRUE(
	PartTestHelpers::boxesMatch(
	bb,
	Base::BoundBox3d(0, 0, 0, len + ext1 * tangent, wid + ext1 * tangent, ext1 * tangent)
	)
	);
	}

	TEST_F(FeatureExtrusionTest, testExecuteDir)
	{
	// Arrange
	const double sin45 = sin(Base::toRadians(45.0));
	_extrusion->Dir.setValue(Base::Vector3d(0, 1, 1));
	_extrusion->DirMode.setValue((long)0);
	// Act
	_extrusion->execute();
	Part::TopoShape ts = _extrusion->Shape.getValue();
	double volume = PartTestHelpers::getVolume(ts.getShape());
	Base::BoundBox3d bb = ts.getBoundBox();
	// Assert
	EXPECT_FLOAT_EQ(volume, len * wid * ext1 * sin45);
	EXPECT_TRUE(
	PartTestHelpers::boxesMatch(bb, Base::BoundBox3d(0, 0, 0, len, wid + ext1 * sin45, ext1 * sin45))
	);
	}

	TEST_F(FeatureExtrusionTest, testExecuteFaceMaker)
	{
	// Arrange
	_extrusion->FaceMakerClass.setValue("Part::FaceMakerCheese");
	// Act
	_extrusion->execute();
	Part::TopoShape ts = _extrusion->Shape.getValue();
	double volume = PartTestHelpers::getVolume(ts.getShape());
	Base::BoundBox3d bb = ts.getBoundBox();
	// Assert
	EXPECT_FLOAT_EQ(volume, len * wid * ext1);
	EXPECT_TRUE(PartTestHelpers::boxesMatch(bb, Base::BoundBox3d(0, 0, 0, len, wid, ext1)));
	}

	TEST_F(FeatureExtrusionTest, testFaceWithHoles)
	{
	// Arrange
	float radius = 0.75;
	auto [face1, wire1, wire2] = PartTestHelpers::CreateFaceWithRoundHole(len, wid, radius);
	// face1 is the sum of the outside (wire1) and the internal hole (wire2).
	Part::TopoShape newFace = Part::TopoShape(face1).makeElementFace(nullptr);
	// newFace cleans that up and is the outside minus the internal hole.
	auto face2 = newFace.getShape();

	auto partFeature = _doc->addObject<Part::Feature>();
	partFeature->Shape.setValue(face2);
	_extrusion->Base.setValue(_doc->getObjects().back());
	_extrusion->FaceMakerClass.setValue("Part::FaceMakerCheese");
	// Act
	_extrusion->execute();
	Part::TopoShape ts = _extrusion->Shape.getValue();
	double volume = PartTestHelpers::getVolume(ts.getShape());
	Base::BoundBox3d bb = ts.getBoundBox();
	// Assert
	EXPECT_FLOAT_EQ(volume, len * wid * ext1 - radius * radius * std::numbers::pi * ext1);
	EXPECT_TRUE(PartTestHelpers::boxesMatch(bb, Base::BoundBox3d(0, 0, 0, len, wid, ext1)));
	EXPECT_FLOAT_EQ(PartTestHelpers::getArea(face1), len * wid + radius * radius * std::numbers::pi);
	EXPECT_FLOAT_EQ(PartTestHelpers::getArea(face2), len * wid - radius * radius * std::numbers::pi);
	}