Ejemplo n.º 1
0
def test_decimal_conversion():
    """Test decimal conversion."""
    from System import Decimal

    max_d = Decimal.Parse("79228162514264337593543950335")
    min_d = Decimal.Parse("-79228162514264337593543950335")

    assert Decimal.ToInt64(Decimal(10)) == 10

    ob = ConversionTest()
    assert ob.DecimalField == Decimal(0)

    ob.DecimalField = Decimal(10)
    assert ob.DecimalField == Decimal(10)

    ob.DecimalField = Decimal.One
    assert ob.DecimalField == Decimal.One

    ob.DecimalField = Decimal.Zero
    assert ob.DecimalField == Decimal.Zero

    ob.DecimalField = max_d
    assert ob.DecimalField == max_d

    ob.DecimalField = min_d
    assert ob.DecimalField == min_d

    with pytest.raises(TypeError):
        ConversionTest().DecimalField = None

    with pytest.raises(TypeError):
        ConversionTest().DecimalField = "spam"

    with pytest.raises(TypeError):
        ConversionTest().DecimalField = 1
Ejemplo n.º 2
0
def test_decimal_array():
    """Test Decimal arrays."""
    ob = Test.DecimalArrayTest()
    items = ob.items

    from System import Decimal
    max_d = Decimal.Parse("79228162514264337593543950335")
    min_d = Decimal.Parse("-79228162514264337593543950335")

    assert len(items) == 5

    assert items[0] == Decimal(0)
    assert items[4] == Decimal(4)

    items[0] = max_d
    assert items[0] == max_d

    items[0] = min_d
    assert items[0] == min_d

    items[-4] = max_d
    assert items[-4] == max_d

    items[-1] = min_d
    assert items[-1] == min_d

    with pytest.raises(TypeError):
        ob = Test.DecimalArrayTest()
        _ = ob.items["wrong"]

    with pytest.raises(TypeError):
        ob = Test.DecimalArrayTest()
        ob[0] = "wrong"
Ejemplo n.º 3
0
    def testDecimalIndexer(self):
        """Test Decimal indexers."""
        object = Test.DecimalIndexerTest()

        from System import Decimal
        max_d = Decimal.Parse("79228162514264337593543950335")
        min_d = Decimal.Parse("-79228162514264337593543950335")

        self.assertTrue(object[max_d] == None)

        object[max_d] = "max"
        self.assertTrue(object[max_d] == "max")

        object[min_d] = "min"
        self.assertTrue(object[min_d] == "min")

        def test():
            object = Test.DecimalIndexerTest()
            object["wrong"]

        self.assertRaises(TypeError, test)

        def test():
            object = Test.DecimalIndexerTest()
            object["wrong"] = "wrong"

        self.assertRaises(TypeError, test)
Ejemplo n.º 4
0
def get_std_dev_channels(history, lookbackPeriod, standardDeviations):
    _list = Indicator.GetStdDevChannels[Qoute](
        _convert_df_to_csharp_list(history), lookbackPeriod,
        CsDecimal.Parse(str(standardDeviations)))
    _dict = {
        _convert_csharp_datetime(i.Date):
        (float(str(i.Centerline)) if i.Centerline else None)
        for i in _list
    }

    return _dict
Ejemplo n.º 5
0
def get_bollinger_bands_lower(history, lookbackPeriod, standardDeviations):
    _list = Indicator.GetBollingerBands[Qoute](
        _convert_df_to_csharp_list(history), lookbackPeriod,
        CsDecimal.Parse(str(standardDeviations)))
    _dict = {
        _convert_csharp_datetime(i.Date):
        (float(str(i.LowerBand)) if i.LowerBand else None)
        for i in _list
    }

    return _dict
Ejemplo n.º 6
0
def get_super_trend(history, lookbackPeriod, multiplier):
    _list = Indicator.GetSuperTrend[Qoute](_convert_df_to_csharp_list(history),
                                           lookbackPeriod,
                                           CsDecimal.Parse(str(multiplier)))
    _dict = {
        _convert_csharp_datetime(i.Date):
        (float(str(i.SuperTrend)) if i.SuperTrend else None)
        for i in _list
    }

    return _dict
Ejemplo n.º 7
0
    def testDecimalConversion(self):
        """Test decimal conversion."""
        from System import Decimal

        max_d = Decimal.Parse("79228162514264337593543950335")
        min_d = Decimal.Parse("-79228162514264337593543950335")
        
        self.failUnless(Decimal.ToInt64(Decimal(10)) == 10L)

        object = ConversionTest()
        self.failUnless(object.DecimalField == Decimal(0))

        object.DecimalField = Decimal(10)
        self.failUnless(object.DecimalField == Decimal(10))

        object.DecimalField = Decimal.One
        self.failUnless(object.DecimalField == Decimal.One)

        object.DecimalField = Decimal.Zero
        self.failUnless(object.DecimalField == Decimal.Zero)

        object.DecimalField = max_d
        self.failUnless(object.DecimalField == max_d)

        object.DecimalField = min_d
        self.failUnless(object.DecimalField == min_d)

        def test():
            ConversionTest().DecimalField = None
            
        self.failUnlessRaises(TypeError, test)

        def test():
            ConversionTest().DecimalField = "spam"
            
        self.failUnlessRaises(TypeError, test)

        def test():
            ConversionTest().DecimalField = 1
            
        self.failUnlessRaises(TypeError, test)
Ejemplo n.º 8
0
def test_decimal_indexer():
    """Test Decimal indexers."""
    ob = Test.DecimalIndexerTest()

    from System import Decimal
    max_d = Decimal.Parse("79228162514264337593543950335")
    min_d = Decimal.Parse("-79228162514264337593543950335")

    assert ob[max_d] is None

    ob[max_d] = "max_"
    assert ob[max_d] == "max_"

    ob[min_d] = "min_"
    assert ob[min_d] == "min_"

    with pytest.raises(TypeError):
        ob = Test.DecimalIndexerTest()
        ob["wrong"]

    with pytest.raises(TypeError):
        ob = Test.DecimalIndexerTest()
        ob["wrong"] = "wrong"
Ejemplo n.º 9
0
    def testDecimalArray(self):
        """Test Decimal arrays."""
        object = Test.DecimalArrayTest()
        items = object.items

        from System import Decimal
        max_d = Decimal.Parse("79228162514264337593543950335")
        min_d = Decimal.Parse("-79228162514264337593543950335")

        self.assertTrue(len(items) == 5)

        self.assertTrue(items[0] == Decimal(0))
        self.assertTrue(items[4] == Decimal(4))

        items[0] = max_d
        self.assertTrue(items[0] == max_d)

        items[0] = min_d
        self.assertTrue(items[0] == min_d)

        items[-4] = max_d
        self.assertTrue(items[-4] == max_d)

        items[-1] = min_d
        self.assertTrue(items[-1] == min_d)

        def test():
            object = Test.DecimalArrayTest()
            v = object.items["wrong"]

        self.assertRaises(TypeError, test)

        def test():
            object = Test.DecimalArrayTest()
            object[0] = "wrong"

        self.assertRaises(TypeError, test)