def testSetFloatValue(): """ The fraction scalar should accept a float-convertible value. Since the fraction is a subclass from scalar, it should be able to respect the same interface. """ f = units.FractionScalar("length", value=FractionValue(0), unit="in") f = f.CreateCopy(value=0.75) assert f.GetValue("in") == FractionValue(0.75)
def testStr(): f = FractionValue(3, Fraction(5, 3)) assert str(f) == "3 5/3" assert repr(f) == "FractionValue(3, 5/3)" f = FractionValue(3) assert str(f) == "3" assert repr(f) == "FractionValue(3, 0/1)"
def testCopy(): f = FractionValue(3, (5, 3)) cf = copy.copy(f) assert f == cf assert f is not cf cf.fraction.numerator = 10 cf.fraction.denominator = 4 assert f == FractionValue(3, (5, 3))
def testFractionScalarConversion(): db = units.UnitDatabase() db.AddUnit("length", "milimeters", "mm", "%f * 1000.0", "%f / 1000.0") db.AddUnitBase("length", "meters", "m") f = units.FractionScalar("length", value=FractionValue(3, (1, 2)), unit="m") converted = db.Convert("length", "m", "mm", f.value) assert converted == FractionValue(3500)
def testComparison(): f1 = units.FractionScalar("length", value=FractionValue(10), unit="in") f3 = units.FractionScalar("volume", value=FractionValue(4), unit="m3") with pytest.raises(TypeError): f1 < f3 f2 = units.FractionScalar("length", unit="in") f1 = f1.CreateCopy(value=FractionValue(250, (1, 2)), unit="m") f2 = f2.CreateCopy(value=FractionValue(220, (3, 4)), unit="m") assert f1 > f2 assert f2 < f1
def testFractionScalarWithDefaultValueOnCategory(unit_database_len): """ FractionScalar is not considering the default value from category on initialization """ db = unit_database_len db.AddCategory("my length", "length", default_value=FractionValue(5, (1, 2))) scalar = units.FractionScalar("my length", unit="m") assert scalar.GetValue("m") == FractionValue(5, (1, 2)) assert scalar.GetUnit() == "m" assert scalar.GetFormatted() == "5 1/2 [m]"
def ConvertFractionValue(cls, fraction_value, quantity, from_unit, to_unit): """ Converts the given fraction value to the given unit. :type fraction_value: L{FractionValue} :param fraction_value: the fraction value to convert :type quantity: IQuantity or str :param quantity: the IQuantity object to use in the conversion, or the quantity type itself :type from_unit: L{FractionValue} :param from_unit: current unit of the given fraction value :type to_unit: L{FractionValue} :param to_unit: the unit to convert the fraction value to :rtype: L{FractionValue} :returns: the converted fraction value """ # check if a quantity type str was passed if quantity.__class__ == str: # Note: actually ignoring the initial quantity type in this case because we # do the operation just using the from unit which may have any category (i.e. # the important thing is the quantity type, so, it can be created with the # default category). quantity = ObtainQuantity(from_unit) convert_to_quantity = ObtainQuantity(from_unit, quantity.GetComposingCategories()) converted_number = convert_to_quantity.ConvertScalarValue( fraction_value.GetNumber(), to_unit ) # convert the number result = FractionValue(number=converted_number) # convert fraction's numerator if fraction_value.GetFraction() is not None: converted_numerator = convert_to_quantity.ConvertScalarValue( fraction_value.GetFraction().numerator, to_unit ) converted_fraction = copy.copy(fraction_value.GetFraction()) converted_fraction.numerator = converted_numerator result.SetFraction(converted_fraction) return result
def _InternalCreateWithQuantity(self, quantity, value, unit_database=None): """ For internal use only. Is used to initialize the actual quantity. :type quantity: str or IQuantity :param quantity: The quantity of this scalar. :param FractionValue value: The initial value """ # Considering fraction values values are easily coerced from float values (though it is # important to note the opposite is not true) if the input value is not a fraction already # try to convert value to float. This also makes this subclass SetValue interface compatible # with superclass interface. try: if type(value) != FractionValue: value = FractionValue(number=float(value)) except Exception: # If not a fraction and coercion to float fails, use CheckType to provide a better error # message. CheckType(value, (FractionValue, float)) self._value = value self._quantity = quantity self._unit_database = unit_database or UnitDatabase.GetSingleton()
def ConvertFractionScalar(db_unit, quantity_type, from_unit, to_unit, value): """ Converts the given Fraction Scalar by applying the converts method of this class. """ converted = cls.ConvertFractionValue(value, quantity_type, from_unit, to_unit) return FractionValue(number=float(converted))
def testConvertFractionValues(unit_database_custom_conversion) -> None: """ Test unit database handling fraction values. """ db = unit_database_custom_conversion # Converting half meter to cm value = FractionValue(0, (1, 2)) value = db.Convert("length", "m", "cm", value) assert float(value) == 50
def testRegisterTwoFunctionsForTheSameClass(unit_database_custom_conversion): """ Test the behavior when we attempt to register two convert functions for the same class """ def ConvertFunction1(*args, **kwargs): return 0 db = unit_database_custom_conversion # There is a function specialized in convert fraction values. Attempting to register another # function should raise an error value = FractionValue(0, (1, 2)) db.Convert("length", "m", "cm", value) with pytest.raises(AssertionError): db.RegisterAdditionalConversionType(FractionValue, ConvertFunction1)
def testBasicUsage(): f = FractionValue(3, Fraction(5, 3)) assert f.number == 3 assert f.fraction == Fraction(5, 3) f.number = 5.5 f.fraction = Fraction(6, 5) assert f.number == 5.5 assert f.fraction == Fraction(6, 5) with pytest.raises(TypeError): f.SetNumber("hello") with pytest.raises(TypeError): f.SetFraction("hello") with pytest.raises(ValueError): f.SetFraction((1, 2, 3)) assert FractionValue(3).GetFraction() == Fraction(0, 1)
def testPartsArentNone(): """ FractionValue can't be initialized nor modified to have None as number or fraction part. """ with pytest.raises(TypeError): FractionValue(1, None) with pytest.raises(TypeError): FractionValue(None, (0 / 1)) with pytest.raises(TypeError): FractionValue(None, None) f = FractionValue(1, Fraction(0, 1)) with pytest.raises(TypeError): f.SetNumber(None) with pytest.raises(TypeError): f.SetFraction(None)
def testFractionScalarInvalidValue(unit_database_len): db = unit_database_len db.AddCategory("another-length", "length", min_value=5, max_value=15) scalar = units.FractionScalar("another-length", value=FractionValue(1, (1, 5)), unit="m") assert not scalar.IsValid() with pytest.raises(ValueError): scalar.CheckValidity() # By default the validation will be performed, 10 is a valid value scalar = scalar.CreateCopy(value=FractionValue(10)) assert scalar.IsValid() # Even invalid ,the scalar returns the value, unit and a formatted text. another = units.FractionScalar("another-length", value=FractionValue(3000), unit="m") assert not another.IsValid() assert another.GetValue("m") == FractionValue(3000) assert another.GetUnit() == "m" assert another.GetFormatted() == "3000 [m]" # By default the validation will be performed, and in this cases will raise ValueError. another_2 = scalar.CreateCopy(value=FractionValue(5000)) assert not another_2.IsValid() another_3 = units.FractionScalar("another-length", unit="m", value=FractionValue(5000)) assert not another_3.IsValid() # Performing copy between invalid fraction scalars. The validation is not performed on copy. copied = another.Copy() assert not copied.IsValid() assert copied.GetValue("m") == FractionValue(3000) assert copied.GetUnit() == "m" assert copied.GetFormatted() == "3000 [m]"
def AssertCreateFromString(text, whole, fraction=None): assert (FractionValue.CreateFromString(text) == FractionValue( whole, fraction) if fraction is not None else FractionValue(whole))
def testDefault(): f = FractionValue() assert f.number == 0.0 assert f.fraction == Fraction(0, 1)
def testEquality(): assert FractionValue(3, Fraction(5, 3)) == FractionValue(3, Fraction(5, 3)) assert not FractionValue(3, Fraction(5, 3)) != FractionValue( 3, Fraction(5, 3)) assert FractionValue(3) == FractionValue(3) assert not FractionValue(3) != FractionValue(3) assert FractionValue(10, Fraction(5, 3)) != FractionValue( 3, Fraction(5, 3)) assert not FractionValue(10, Fraction(5, 3)) == FractionValue( 3, Fraction(5, 3)) assert FractionValue(10, (5, 3)) == FractionValue(10, Fraction(5, 3))
def testFormatValue(): f = units.FractionScalar("length", value=FractionValue(250.0, (3, 4)), unit="m") assert f.GetFormattedValue() == "250 3/4"
def testFractionScalar(): # create our scalar f = units.FractionScalar("length", value=FractionValue(250, (3, 4)), unit="m") # check formatting assert f.GetFormatted() == "250 3/4 [m]" # check conversion # f.unit = 'km' assert f.GetValue("km") == FractionValue(0.25, (3 / 1000.0, 4)) assert f.GetValue("m") == FractionValue(250.0, (3, 4)) # test no fraction part f = f.CreateCopy(value=FractionValue(0.25), unit="km") assert f.value == FractionValue(0.25) assert f.GetFormatted() == "0.25 [km]" # set fraction again f = f.CreateCopy(value=FractionValue(250, (3, 4)), unit="m") assert f.GetValue("km") == FractionValue(0.25, (3 / 1000.0, 4)) assert f.GetFormatted() == "250 3/4 [m]" assert f.GetValue("m") == FractionValue(250, (3, 4)) f = f.CreateCopy(value=FractionValue(0.25, (3, 4)), unit="km") assert f.value == FractionValue(0.25, (3, 4)) assert f.GetFormatted() == "0.25 3/4 [km]" assert f.GetValue("m") == FractionValue(250.0, (3000, 4)) with pytest.raises(AttributeError): setattr(f, "value", 10)
def testRepr(): assert repr(FractionValue(250, (3, 4))) == "FractionValue(250, 3/4)"
def Create(number, fraction): return units.FractionScalar("length", value=FractionValue(number, fraction), unit="m")
def testCopy(): f = units.FractionScalar("length", value=FractionValue(250.0, (3, 4)), unit="m") c = copy.copy(f) assert c.value == FractionValue(250.0, (3, 4))
def testComparison(): assert FractionValue(3) < FractionValue(3, (3, 4)) assert FractionValue(3) <= FractionValue(3, (3, 4)) assert FractionValue(3, (3, 4)) > FractionValue(3) assert FractionValue(3, (3, 4)) >= FractionValue(3)
def testMatchFractionPart(): # Text Ok, should not raise error FractionValue.MatchFractionPart("3/4") with pytest.raises(ValueError): FractionValue.MatchFractionPart("2 3/4")
def testCreateFromFloat(): """ Allow the user enter only the fraction value """ assert FractionValue.CreateFromFloat(1.375) == FractionValue(1, (3, 8)) assert FractionValue.CreateFromFloat(2.5) == FractionValue(2, (1, 2))
def testFloat(): assert float(FractionValue(3, Fraction(5, 3))) == 3 + 5 / 3.0 assert float(FractionValue(3)) == 3.0