test_field.py

# -*- coding: utf-8 -*-

"""Test CLR field support."""

import System
import pytest
from Python.Test import FieldTest


def test_public_instance_field():
    """Test public instance fields."""
    ob = FieldTest()
    assert ob.PublicField == 0

    ob.PublicField = 1
    assert ob.PublicField == 1

    with pytest.raises(TypeError):
        del FieldTest().PublicField


def test_public_static_field():
    """Test public static fields."""
    ob = FieldTest()
    assert FieldTest.PublicStaticField == 0

    FieldTest.PublicStaticField = 1
    assert FieldTest.PublicStaticField == 1

    assert ob.PublicStaticField == 1
    ob.PublicStaticField = 0
    assert ob.PublicStaticField == 0

    with pytest.raises(TypeError):
        del FieldTest.PublicStaticField

    with pytest.raises(TypeError):
        del FieldTest().PublicStaticField


def test_protected_instance_field():
    """Test protected instance fields."""
    ob = FieldTest()
    assert ob.ProtectedField == 0

    ob.ProtectedField = 1
    assert ob.ProtectedField == 1

    with pytest.raises(TypeError):
        del FieldTest().ProtectedField


def test_protected_static_field():
    """Test protected static fields."""
    ob = FieldTest()
    assert FieldTest.ProtectedStaticField == 0

    FieldTest.ProtectedStaticField = 1
    assert FieldTest.ProtectedStaticField == 1

    assert ob.ProtectedStaticField == 1
    ob.ProtectedStaticField = 0
    assert ob.ProtectedStaticField == 0

    with pytest.raises(TypeError):
        del FieldTest.ProtectedStaticField

    with pytest.raises(TypeError):
        del FieldTest().ProtectedStaticField


def test_read_only_instance_field():
    """Test readonly instance fields."""
    assert FieldTest().ReadOnlyField == 0

    with pytest.raises(TypeError):
        FieldTest().ReadOnlyField = 1

    with pytest.raises(TypeError):
        del FieldTest().ReadOnlyField


def test_read_only_static_field():
    """Test readonly static fields."""
    ob = FieldTest()

    assert FieldTest.ReadOnlyStaticField == 0
    assert ob.ReadOnlyStaticField == 0

    with pytest.raises(TypeError):
        FieldTest.ReadOnlyStaticField = 1

    with pytest.raises(TypeError):
        FieldTest().ReadOnlyStaticField = 1

    with pytest.raises(TypeError):
        del FieldTest.ReadOnlyStaticField

    with pytest.raises(TypeError):
        del FieldTest().ReadOnlyStaticField


def test_constant_field():
    """Test const fields."""
    ob = FieldTest()

    assert FieldTest.ConstField == 0
    assert ob.ConstField == 0

    with pytest.raises(TypeError):
        FieldTest().ConstField = 1

    with pytest.raises(TypeError):
        FieldTest.ConstField = 1

    with pytest.raises(TypeError):
        del FieldTest().ConstField

    with pytest.raises(TypeError):
        del FieldTest.ConstField


def test_internal_field():
    """Test internal fields."""

    with pytest.raises(AttributeError):
        _ = FieldTest().InternalField

    with pytest.raises(AttributeError):
        _ = FieldTest().InternalStaticField

    with pytest.raises(AttributeError):
        _ = FieldTest.InternalStaticField


def test_private_field():
    """Test private fields."""

    with pytest.raises(AttributeError):
        _ = FieldTest().PrivateField

    with pytest.raises(AttributeError):
        _ = FieldTest().PrivateStaticField

    with pytest.raises(AttributeError):
        _ = FieldTest.PrivateStaticField


def test_field_descriptor_get_set():
    """Test field descriptor get / set."""

    # This test ensures that setting an attribute implemented with
    # a descriptor actually goes through the descriptor (rather than
    # silently replacing the descriptor in the instance or type dict.

    ob = FieldTest()

    assert FieldTest.PublicStaticField == 0
    assert ob.PublicStaticField == 0

    descriptor = FieldTest.__dict__['PublicStaticField']
    assert type(descriptor) != int

    ob.PublicStaticField = 0
    descriptor = FieldTest.__dict__['PublicStaticField']
    assert type(descriptor) != int

    FieldTest.PublicStaticField = 0
    descriptor = FieldTest.__dict__['PublicStaticField']
    assert type(descriptor) != int


def test_field_descriptor_wrong_type():
    """Test setting a field using a value of the wrong type."""

    with pytest.raises(TypeError):
        FieldTest().PublicField = "spam"


def test_field_descriptor_abuse():
    """Test field descriptor abuse."""
    desc = FieldTest.__dict__['PublicField']

    with pytest.raises(TypeError):
        desc.__get__(0, 0)

    with pytest.raises(TypeError):
        desc.__set__(0, 0)


def test_boolean_field():
    """Test boolean fields."""
    # change this to true / false later for Python 2.3?
    ob = FieldTest()
    assert ob.BooleanField is False

    ob.BooleanField = True
    assert ob.BooleanField is True

    ob.BooleanField = False
    assert ob.BooleanField is False

    with pytest.raises(TypeError):
        ob.BooleanField = 1

    with pytest.raises(TypeError):
        ob.BooleanField = 0


def test_sbyte_field():
    """Test sbyte fields."""
    ob = FieldTest()
    assert ob.SByteField == 0

    ob.SByteField = 1
    assert ob.SByteField == 1


def test_byte_field():
    """Test byte fields."""
    ob = FieldTest()
    assert ob.ByteField == 0

    ob.ByteField = 1
    assert ob.ByteField == 1


def test_char_field():
    """Test char fields."""
    ob = FieldTest()
    assert ob.CharField == u'A'
    assert ob.CharField == 'A'

    ob.CharField = 'B'
    assert ob.CharField == u'B'
    assert ob.CharField == 'B'

    ob.CharField = u'C'
    assert ob.CharField == u'C'
    assert ob.CharField == 'C'


def test_int16_field():
    """Test int16 fields."""
    ob = FieldTest()
    assert ob.Int16Field == 0

    ob.Int16Field = 1
    assert ob.Int16Field == 1


def test_int32_field():
    """Test int32 fields."""
    ob = FieldTest()
    assert ob.Int32Field == 0

    ob.Int32Field = 1
    assert ob.Int32Field == 1


def test_int64_field():
    """Test int64 fields."""
    ob = FieldTest()
    assert ob.Int64Field == 0

    ob.Int64Field = 1
    assert ob.Int64Field == 1


def test_uint16_field():
    """Test uint16 fields."""
    ob = FieldTest()
    assert ob.UInt16Field == 0

    ob.UInt16Field = 1
    assert ob.UInt16Field == 1


def test_uint32_field():
    """Test uint32 fields."""
    ob = FieldTest()
    assert ob.UInt32Field == 0

    ob.UInt32Field = 1
    assert ob.UInt32Field == 1


def test_uint64_field():
    """Test uint64 fields."""
    ob = FieldTest()
    assert ob.UInt64Field == 0

    ob.UInt64Field = 1
    assert ob.UInt64Field == 1


def test_single_field():
    """Test single fields."""
    ob = FieldTest()
    assert ob.SingleField == 0.0

    ob.SingleField = 1.1
    assert ob.SingleField == System.Single(1.1)


def test_double_field():
    """Test double fields."""
    ob = FieldTest()
    assert ob.DoubleField == 0.0

    ob.DoubleField = 1.1
    assert ob.DoubleField == 1.1


def test_decimal_field():
    """Test decimal fields."""
    ob = FieldTest()
    assert ob.DecimalField == System.Decimal(0)

    ob.DecimalField = System.Decimal(1)
    assert ob.DecimalField == System.Decimal(1)


def test_string_field():
    """Test string fields."""
    ob = FieldTest()
    assert ob.StringField == "spam"

    ob.StringField = "eggs"
    assert ob.StringField == "eggs"


def test_interface_field():
    """Test interface fields."""
    from Python.Test import Spam, ISpam

    ob = FieldTest()

    assert ISpam(ob.SpamField).GetValue() == "spam"
    assert ob.SpamField.GetValue() == "spam"

    ob.SpamField = Spam("eggs")
    assert ISpam(ob.SpamField).GetValue() == "eggs"
    assert ob.SpamField.GetValue() == "eggs"


def test_object_field():
    """Test ob fields."""
    ob = FieldTest()
    assert ob.ObjectField is None

    ob.ObjectField = System.String("spam")
    assert ob.ObjectField == "spam"

    ob.ObjectField = System.Int32(1)
    assert ob.ObjectField == 1

    ob.ObjectField = None
    assert ob.ObjectField is None


def test_enum_field():
    """Test enum fields."""
    from Python.Test import ShortEnum

    ob = FieldTest()
    assert ob.EnumField == ShortEnum.Zero

    ob.EnumField = ShortEnum.One
    assert ob.EnumField == ShortEnum.One


def test_nullable_field():
    """Test nullable fields."""
    ob = FieldTest()

    ob.StringField = None
    assert ob.StringField is None

    ob.ObjectField = None
    assert ob.ObjectField is None

    ob.SpamField = None
    assert ob.SpamField is None

    # Primitive types and enums should not be set to null.

    with pytest.raises(TypeError):
        FieldTest().Int32Field = None

    with pytest.raises(TypeError):
        FieldTest().EnumField = None