Ejemplo n.º 1
0
        public void EqualityMembers_ShouldEqualComponentId_WhenStringValueIsEqual(string id1, string id2, bool expectedIsEqual)
        {
            // Arrange
            var componentId1 = new ComponentId(id1);
            var componentId2 = new ComponentId(id2);

            // Act
            // Assert
            AssertEqualityMembers
            .ForValues(componentId1, componentId2)
            .UsingEqualityOperator((x, y) => x == y)
            .UsingInequalityOperator((x, y) => x != y)
            .EqualityIsExpectedToBe(expectedIsEqual);
        }
Ejemplo n.º 2
0
        public void EqualityMembers_ShouldEqualGameTime_WhenDeltaTimeIsEqual(int hours1, int hours2, bool expectedIsEqual)
        {
            // Arrange
            var gameTime1 = new GameTime(TimeSpan.FromHours(hours1));
            var gameTime2 = new GameTime(TimeSpan.FromHours(hours2));

            // Act
            // Assert
            AssertEqualityMembers
            .ForValues(gameTime1, gameTime2)
            .UsingEqualityOperator((x, y) => x == y)
            .UsingInequalityOperator((x, y) => x != y)
            .EqualityIsExpectedToBe(expectedIsEqual);
        }
Ejemplo n.º 3
0
        public void EqualityMembers_ShouldEqualFontSize_WhenPointsAreEqual(double points1, double points2, bool expectedIsEqual)
        {
            // Arrange
            var fontSize1 = FontSize.FromPoints(points1);
            var fontSize2 = FontSize.FromPoints(points2);

            // Act
            // Assert
            AssertEqualityMembers
            .ForValues(fontSize1, fontSize2)
            .UsingEqualityOperator((x, y) => x == y)
            .UsingInequalityOperator((x, y) => x != y)
            .EqualityIsExpectedToBe(expectedIsEqual);
        }
        public void EqualityMembers_Test(EqualityMembersTestCase testCase)
        {
            // Arrange
            var variant1 = testCase.HardwareInputVariant1;
            var variant2 = testCase.HardwareInputVariant2;

            // Act
            // Assert
            AssertEqualityMembers
            .ForValues(variant1, variant2)
            .UsingEqualityOperator((x, y) => x == y)
            .UsingInequalityOperator((x, y) => x != y)
            .EqualityIsExpectedToBe(testCase.ExpectedIsEqual);
        }
Ejemplo n.º 5
0
        public void EqualityMembers_ShouldEqualAssetType_WhenStringValueIsEqual(string type1, string type2, bool expectedIsEqual)
        {
            // Arrange
            var assetType1 = new AssetType(type1);
            var assetType2 = new AssetType(type2);

            // Act
            // Assert
            AssertEqualityMembers
            .ForValues(assetType1, assetType2)
            .UsingEqualityOperator((x, y) => x == y)
            .UsingInequalityOperator((x, y) => x != y)
            .EqualityIsExpectedToBe(expectedIsEqual);
        }
Ejemplo n.º 6
0
        public void EqualityMembers_ShouldEqualColor_WhenArgbIsEqual(uint argb1, uint argb2, bool expectedIsEqual)
        {
            // Arrange
            var color1 = Color.FromArgb((int)argb1);
            var color2 = Color.FromArgb((int)argb2);

            // Act
            // Assert
            AssertEqualityMembers
            .ForValues(color1, color2)
            .UsingEqualityOperator((x, y) => x == y)
            .UsingInequalityOperator((x, y) => x != y)
            .EqualityIsExpectedToBe(expectedIsEqual);
        }
Ejemplo n.º 7
0
        public void EqualityMembers_ShouldEqualAssetId_WhenGuidIsEqual(string guid1, string guid2, bool expectedIsEqual)
        {
            // Arrange
            var assetId1 = new AssetId(new Guid(guid1));
            var assetId2 = new AssetId(new Guid(guid2));

            // Act
            // Assert
            AssertEqualityMembers
            .ForValues(assetId1, assetId2)
            .UsingEqualityOperator((x, y) => x == y)
            .UsingInequalityOperator((x, y) => x != y)
            .EqualityIsExpectedToBe(expectedIsEqual);
        }
Ejemplo n.º 8
0
        public void EqualityMembers_ShouldEqualVector2_WhenComponentsAreEqual(double x1, double y1, double x2, double y2, bool expectedIsEqual)
        {
            // Arrange
            var v1 = new Vector2(x1, y1);
            var v2 = new Vector2(x2, y2);

            // Act
            // Assert
            AssertEqualityMembers
            .ForValues(v1, v2)
            .UsingEqualityOperator((x, y) => x == y)
            .UsingInequalityOperator((x, y) => x != y)
            .EqualityIsExpectedToBe(expectedIsEqual);
        }
        public void EqualityMembers_ShouldEqualAxisAlignedRectangle_WhenCenterAndWidthAndHeightAreEqual(double x1, double y1, double w1, double h1, double x2,
                                                                                                        double y2, double w2, double h2, bool expectedIsEqual)
        {
            // Arrange
            var rectangle1 = new AxisAlignedRectangle(x1, y1, w1, h1);
            var rectangle2 = new AxisAlignedRectangle(x2, y2, w2, h2);

            // Act
            // Assert
            AssertEqualityMembers
            .ForValues(rectangle1, rectangle2)
            .UsingEqualityOperator((x, y) => x == y)
            .UsingInequalityOperator((x, y) => x != y)
            .EqualityIsExpectedToBe(expectedIsEqual);
        }
Ejemplo n.º 10
0
        public void EqualityMembers_ShouldEqualEllipse_WhenCenterAndRadiusXAndRadiusYAreEqual(double x1, double y1, double rx1, double ry1, double x2,
                                                                                              double y2, double rx2, double ry2, bool expectedIsEqual)
        {
            // Arrange
            var ellipse1 = new Ellipse(new Vector2(x1, y1), rx1, ry1);
            var ellipse2 = new Ellipse(new Vector2(x2, y2), rx2, ry2);

            // Act
            // Assert
            AssertEqualityMembers
            .ForValues(ellipse1, ellipse2)
            .UsingEqualityOperator((x, y) => x == y)
            .UsingInequalityOperator((x, y) => x != y)
            .EqualityIsExpectedToBe(expectedIsEqual);
        }
Ejemplo n.º 11
0
        public void EqualityMembers_ShouldEqualCircle_WhenCenterAndRadiusAreEqual(double x1, double y1, double r1, double x2, double y2, double r2,
                                                                                  bool expectedIsEqual)
        {
            // Arrange
            var circle1 = new Circle(new Vector2(x1, y1), r1);
            var circle2 = new Circle(new Vector2(x2, y2), r2);

            // Act
            // Assert
            AssertEqualityMembers
            .ForValues(circle1, circle2)
            .UsingEqualityOperator((x, y) => x == y)
            .UsingInequalityOperator((x, y) => x != y)
            .EqualityIsExpectedToBe(expectedIsEqual);
        }
Ejemplo n.º 12
0
        public void EqualityMembers_ShouldEqualRectangle_WhenAllVerticesAreEqual(double x1, double y1, double w1, double h1, double x2, double y2, double w2,
                                                                                 double h2, bool expectedIsEqual)
        {
            // Arrange
            var rectangle1 = new Rectangle(new Vector2(x1, y1), new Vector2(w1, h1));
            var rectangle2 = new Rectangle(new Vector2(x2, y2), new Vector2(w2, h2));

            // Act
            // Assert
            AssertEqualityMembers
            .ForValues(rectangle1, rectangle2)
            .UsingEqualityOperator((x, y) => x == y)
            .UsingInequalityOperator((x, y) => x != y)
            .EqualityIsExpectedToBe(expectedIsEqual);
        }
Ejemplo n.º 13
0
        public void EqualityMembers_ShouldEqualMatrix3x3_WhenComponentsAreEqual(double m1_11, double m1_12, double m1_13, double m1_21, double m1_22,
                                                                                double m1_23, double m1_31, double m1_32, double m1_33, double m2_11, double m2_12, double m2_13, double m2_21, double m2_22, double m2_23,
                                                                                double m2_31, double m2_32, double m2_33, bool expectedIsEqual)
        {
            // Arrange
            var m1 = new Matrix3x3(m1_11, m1_12, m1_13, m1_21, m1_22, m1_23, m1_31, m1_32, m1_33);
            var m2 = new Matrix3x3(m2_11, m2_12, m2_13, m2_21, m2_22, m2_23, m2_31, m2_32, m2_33);

            // Act
            // Assert
            AssertEqualityMembers
            .ForValues(m1, m2)
            .UsingEqualityOperator((x, y) => x == y)
            .UsingInequalityOperator((x, y) => x != y)
            .EqualityIsExpectedToBe(expectedIsEqual);
        }