def testEnumWithItems(self):
    class EnumWithItems(messages.Enum):
      A = 3
      B = 1
      C = 2

    expected = descriptor.EnumDescriptor()
    expected.name = 'EnumWithItems'

    a = descriptor.EnumValueDescriptor()
    a.name = 'A'
    a.number = 3

    b = descriptor.EnumValueDescriptor()
    b.name = 'B'
    b.number = 1

    c = descriptor.EnumValueDescriptor()
    c.name = 'C'
    c.number = 2

    expected.values = [b, c, a]

    described = descriptor.describe_enum(EnumWithItems)
    described.check_initialized()
    self.assertEquals(expected, described)
Example #2
0
    def testEnumWithItems(self):
        class EnumWithItems(messages.Enum):
            A = 3
            B = 1
            C = 2

        expected = descriptor.EnumDescriptor()
        expected.name = 'EnumWithItems'

        a = descriptor.EnumValueDescriptor()
        a.name = 'A'
        a.number = 3

        b = descriptor.EnumValueDescriptor()
        b.name = 'B'
        b.number = 1

        c = descriptor.EnumValueDescriptor()
        c.name = 'C'
        c.number = 2

        expected.values = [b, c, a]

        described = descriptor.describe_enum(EnumWithItems)
        described.check_initialized()
        self.assertEquals(expected, described)
  def testEmptyEnum(self):
    class EmptyEnum(messages.Enum):
      pass

    expected = descriptor.EnumDescriptor()
    expected.name = 'EmptyEnum'

    described = descriptor.describe_enum(EmptyEnum)
    described.check_initialized()
    self.assertEquals(expected, described)
Example #4
0
    def testEmptyEnum(self):
        class EmptyEnum(messages.Enum):
            pass

        expected = descriptor.EnumDescriptor()
        expected.name = 'EmptyEnum'

        described = descriptor.describe_enum(EmptyEnum)
        described.check_initialized()
        self.assertEquals(expected, described)
Example #5
0
  def testDefineEnum_Empty(self):
    """Test defining an empty enum."""
    enum_descriptor = descriptor.EnumDescriptor()
    enum_descriptor.name = 'Empty'

    enum_class = definition.define_enum(enum_descriptor, 'whatever')

    self.assertEquals('Empty', enum_class.__name__)
    self.assertEquals('whatever', enum_class.__module__)

    self.assertEquals(enum_descriptor, descriptor.describe_enum(enum_class))
  def testNestedEnum(self):
    class MyScope(messages.Message):
      class NestedEnum(messages.Enum):
        pass

    expected = descriptor.EnumDescriptor()
    expected.name = 'NestedEnum'

    described = descriptor.describe_enum(MyScope.NestedEnum)
    described.check_initialized()
    self.assertEquals(expected, described)
Example #7
0
    def testNestedEnum(self):
        class MyScope(messages.Message):
            class NestedEnum(messages.Enum):
                pass

        expected = descriptor.EnumDescriptor()
        expected.name = 'NestedEnum'

        described = descriptor.describe_enum(MyScope.NestedEnum)
        described.check_initialized()
        self.assertEquals(expected, described)
Example #8
0
    def testDefineEnum_Empty(self):
        """Test defining an empty enum."""
        enum_descriptor = descriptor.EnumDescriptor()
        enum_descriptor.name = 'Empty'

        enum_class = definition.define_enum(enum_descriptor, 'whatever')

        self.assertEquals('Empty', enum_class.__name__)
        self.assertEquals('whatever', enum_class.__module__)

        self.assertEquals(enum_descriptor,
                          descriptor.describe_enum(enum_class))
  def testNestedEnum(self):
    class MessageWithEnum(messages.Message):
      class Mood(messages.Enum):
        GOOD = 1
        BAD = 2
        UGLY = 3

      class Music(messages.Enum):
        CLASSIC = 1
        JAZZ = 2
        BLUES = 3

    expected = descriptor.MessageDescriptor()
    expected.name = 'MessageWithEnum'

    expected.enum_types = [descriptor.describe_enum(MessageWithEnum.Mood),
                           descriptor.describe_enum(MessageWithEnum.Music)]

    described = descriptor.describe_message(MessageWithEnum)
    described.check_initialized()
    self.assertEquals(expected, described)
Example #10
0
    def testNestedEnum(self):
        class MessageWithEnum(messages.Message):
            class Mood(messages.Enum):
                GOOD = 1
                BAD = 2
                UGLY = 3

            class Music(messages.Enum):
                CLASSIC = 1
                JAZZ = 2
                BLUES = 3

        expected = descriptor.MessageDescriptor()
        expected.name = 'MessageWithEnum'

        expected.enum_types = [
            descriptor.describe_enum(MessageWithEnum.Mood),
            descriptor.describe_enum(MessageWithEnum.Music)
        ]

        described = descriptor.describe_message(MessageWithEnum)
        described.check_initialized()
        self.assertEquals(expected, described)
Example #11
0
  def testDefineEnum(self):
    """Test defining an enum."""
    red = descriptor.EnumValueDescriptor()
    green = descriptor.EnumValueDescriptor()
    blue = descriptor.EnumValueDescriptor()

    red.name = 'RED'
    red.number = 1
    green.name = 'GREEN'
    green.number = 2
    blue.name = 'BLUE'
    blue.number = 3

    enum_descriptor = descriptor.EnumDescriptor()
    enum_descriptor.name = 'Colors'
    enum_descriptor.values = [red, green, blue]

    enum_class = definition.define_enum(enum_descriptor, 'whatever')

    self.assertEquals('Colors', enum_class.__name__)
    self.assertEquals('whatever', enum_class.__module__)

    self.assertEquals(enum_descriptor, descriptor.describe_enum(enum_class))
Example #12
0
    def testDefineEnum(self):
        """Test defining an enum."""
        red = descriptor.EnumValueDescriptor()
        green = descriptor.EnumValueDescriptor()
        blue = descriptor.EnumValueDescriptor()

        red.name = 'RED'
        red.number = 1
        green.name = 'GREEN'
        green.number = 2
        blue.name = 'BLUE'
        blue.number = 3

        enum_descriptor = descriptor.EnumDescriptor()
        enum_descriptor.name = 'Colors'
        enum_descriptor.values = [red, green, blue]

        enum_class = definition.define_enum(enum_descriptor, 'whatever')

        self.assertEquals('Colors', enum_class.__name__)
        self.assertEquals('whatever', enum_class.__module__)

        self.assertEquals(enum_descriptor,
                          descriptor.describe_enum(enum_class))
 def testEnum(self):
   self.assertEquals(
     descriptor.describe_enum(test_util.OptionalMessage.SimpleEnum),
     descriptor.describe(test_util.OptionalMessage.SimpleEnum))
Example #14
0
 def testEnum(self):
     self.assertEquals(
         descriptor.describe_enum(test_util.OptionalMessage.SimpleEnum),
         descriptor.describe(test_util.OptionalMessage.SimpleEnum))