Esempio n. 1
0
        public void SetVoltageScale_without_adjustment_should_update_only_VoltageScale()
        {
            // Assign
            const double R = 1730;

            const double S1 = 3.0,
                         S2 = 10.0;

            const double V1 = 3.1,
                         V2 = 3.2;

            var expectedReadings = new ElectricReadings(R, S1);

            expectedReadings.AddSample(new DataSample(T1, V1));
            expectedReadings.AddSample(new DataSample(T2, V2));

            var actualReadings = new ElectricReadings(R, S1);

            actualReadings.AddSample(new DataSample(T1, V1));
            actualReadings.AddSample(new DataSample(T2, V2));

            // Act
            actualReadings.SetVoltageScale(S2, adjustValues: false);

            // Assert
            actualReadings.ShouldBeEquivalentTo(expectedReadings, options => options
                                                .Excluding(r => r.VoltageScale));

            actualReadings.VoltageScale
            .Should().Be(S2);
        }
Esempio n. 2
0
        public void SetVoltageScale_readings_adjustment_cross_verification()
        {
            // Assign
            const double R = 1730;

            const double S1 = 2.0,
                         S2 = 10.0;

            const double U1 = 220,
                         U2 = 224;

            var electricReadings = new ElectricReadings(R, S1);

            electricReadings.AddSample(new DataSample(T1, U1 / S1));
            electricReadings.AddSample(new DataSample(T2, U2 / S1));

            var actualReadings = new ElectricReadings(R, S2);

            actualReadings.AddSample(new DataSample(T1, U1 / S1));
            actualReadings.AddSample(new DataSample(T2, U2 / S1));

            // Act
            actualReadings.SetVoltageScale(S1, adjustValues: true);

            // Assert
            actualReadings.ShouldBeEquivalentTo(electricReadings, options => options
                                                .Using(new DoubleAssertionRule(TOLERANCE)));
        }
Esempio n. 3
0
        public void SetVoltageScale_should_notify_property_change()
        {
            // Assign
            const double R = 4500, S = 2.1;

            var readings = new ElectricReadings(R, S);

            readings.MonitorEvents();

            // Act
            readings.SetVoltageScale(S * 1.1, adjustValues: false);

            // Assert
            readings.ShouldRaisePropertyChangeFor(m => m.VoltageScale);
        }
        public void SetVoltageScale_without_adjustment_should_update_only_VoltageScale()
        {
            // Assign
            const double R = 1730;

            const double S1 = 3.0,
                         S2 = 10.0;

            const double V1 = 3.1,
                         V2 = 3.2;

            var expectedReadings = new ElectricReadings(R, S1);
            expectedReadings.AddSample(new DataSample(T1, V1));
            expectedReadings.AddSample(new DataSample(T2, V2));

            var actualReadings = new ElectricReadings(R, S1);
            actualReadings.AddSample(new DataSample(T1, V1));
            actualReadings.AddSample(new DataSample(T2, V2));

            // Act
            actualReadings.SetVoltageScale(S2, adjustValues: false);

            // Assert
            actualReadings.ShouldBeEquivalentTo(expectedReadings, options => options
                .Excluding(r => r.VoltageScale));

            actualReadings.VoltageScale
                .Should().Be(S2);
        }
        public void SetVoltageScale_should_notify_property_change()
        {
            // Assign
            const double R = 4500, S = 2.1;

            var readings = new ElectricReadings(R, S);
            readings.MonitorEvents();

            // Act
            readings.SetVoltageScale(S * 1.1, adjustValues: false);

            // Assert
            readings.ShouldRaisePropertyChangeFor(m => m.VoltageScale);
        }
        public void SetVoltageScale_readings_adjustment_cross_verification()
        {
            // Assign
            const double R = 1730;

            const double S1 = 2.0,
                         S2 = 10.0;

            const double U1 = 220,
                         U2 = 224;

            var electricReadings = new ElectricReadings(R, S1);
            electricReadings.AddSample(new DataSample(T1, U1 / S1));
            electricReadings.AddSample(new DataSample(T2, U2 / S1));

            var actualReadings = new ElectricReadings(R, S2);
            actualReadings.AddSample(new DataSample(T1, U1 / S1));
            actualReadings.AddSample(new DataSample(T2, U2 / S1));

            // Act
            actualReadings.SetVoltageScale(S1, adjustValues: true);

            // Assert
            actualReadings.ShouldBeEquivalentTo(electricReadings, options => options
                .Using(new DoubleAssertionRule(TOLERANCE)));
        }