def pack(self, obj):
		data = getattr(obj, "_" + self.name)
		size = len(data)
		string = pack('I', size)
		for i in data:
			for structure in self.structures:
				string += structure.pack(i)
		return string
    def test_integer(self):
        for size in (8, 16, 32, 64):
            for sign in ('signed', 'unsigned', 'semisigned'):
                if size == 8 and sign == 'semisigned':
                    #only combination that dosent exist
                    continue
                if sign == 'signed':
                    min = -2**(size - 1)
                    max = 2**(size - 1) - 1
                if sign == 'unsigned':
                    min = 0
                    max = 2**(size) - 1
                if sign == 'semisigned':
                    min = -1
                    max = 2**(size) - 2

                #good values
                structure = IntegerStructure('int', size=size, type=sign)

                self.assertEqual(structure.length(min), size / 8)
                self.assertTrue(structure.check(min))
                self.assertTrue(structure.check(max))

                format = structure.xstruct
                self.assertEqual(unpack(format, pack(format, min))[0][0], min)
                self.assertEqual(unpack(format, pack(format, max))[0][0], max)

                #bad values
                self.assertRaises(ValueError, structure.check, min - 1)
                self.assertRaises(ValueError, structure.check, max + 1)
                self.assertRaises(ValueError, structure.check, 0.)
                self.assertRaises(ValueError, structure.check, '')
                self.assertRaises(ValueError, structure.check, None)

        self.assertRaises(ValueError, lambda: IntegerStructure('int', size=7))
        self.assertRaises(ValueError,
                          lambda: IntegerStructure('int', type='supersigned'))
	def test_integer(self):
		for size in (8, 16, 32, 64):
			for sign in ('signed', 'unsigned', 'semisigned'):
				if size == 8 and sign == 'semisigned':
					#only combination that dosent exist
					continue
				if sign == 'signed':
					min = -2**(size-1)
					max = 2**(size-1)-1
				if sign == 'unsigned':
					min = 0
					max = 2**(size)-1
				if sign == 'semisigned':
					min = -1
					max = 2**(size)-2
				
				#good values
				structure = IntegerStructure('int', size=size, type=sign)
				
				self.assertEqual(structure.length(min), size/8)
				self.assertTrue(structure.check(min))
				self.assertTrue(structure.check(max))
				
				format = structure.xstruct
				self.assertEqual(unpack(format, pack(format, min))[0][0], min)
				self.assertEqual(unpack(format, pack(format, max))[0][0], max)
				
				#bad values
				self.assertRaises(ValueError, structure.check, min-1)
				self.assertRaises(ValueError, structure.check, max+1)
				self.assertRaises(ValueError, structure.check, 0.)
				self.assertRaises(ValueError, structure.check, '')
				self.assertRaises(ValueError, structure.check, None)
		
		self.assertRaises(ValueError, lambda: IntegerStructure('int', size=7))
		self.assertRaises(ValueError, lambda: IntegerStructure('int', type='supersigned'))
	def test_string(self):
		strings = ['A', '\x00\x01', u'Ж', u'中', u'\U00010346']
		structure = StringStructure("string")
		self.assertEqual(structure.xstruct, 'S',
			"StringStructure's xstruct is %r instead of 'S'" % (structure.xstruct,))
		
		#good values
		for string in strings:
			try:
				structure.check(string)
			except:
				self.fail("StringStructure said %r is not valid" % (string,))
			self.assertEqual(structure.length(string), len(pack(structure.xstruct, string)))
		
		#bad values
		self.assertRaises(ValueError, structure.check, 0)
		self.assertRaises(ValueError, structure.check, 0.)
		self.assertRaises(ValueError, structure.check, None)
	def test_character(self):
		#good values
		CharacterStructure("character")
		strings = ['', 'a' '123']
		for string in strings:
			length = len(string)
			structure = CharacterStructure("character", size=length)
			self.assertTrue(structure.check(string))
			self.assertEqual(structure.length(string), length)
			self.assertEqual(pack(structure.xstruct, string), string,
				"CharacterStructure's xstruct is talking crazy for %r" % (string,))
		
		#bad values
		structure = CharacterStructure("character", size=1)
		self.assertRaises(ValueError, structure.check, 0)
		self.assertRaises(ValueError, structure.check, 0.)
		self.assertRaises(ValueError, structure.check, None)
		self.assertRaises(ValueError, structure.check, '')
		self.assertRaises(ValueError, structure.check, '12')
    def test_character(self):
        #good values
        CharacterStructure("character")
        strings = ['', 'a' '123']
        for string in strings:
            length = len(string)
            structure = CharacterStructure("character", size=length)
            self.assertTrue(structure.check(string))
            self.assertEqual(structure.length(string), length)
            self.assertEqual(
                pack(structure.xstruct, string), string,
                "CharacterStructure's xstruct is talking crazy for %r" %
                (string, ))

        #bad values
        structure = CharacterStructure("character", size=1)
        self.assertRaises(ValueError, structure.check, 0)
        self.assertRaises(ValueError, structure.check, 0.)
        self.assertRaises(ValueError, structure.check, None)
        self.assertRaises(ValueError, structure.check, '')
        self.assertRaises(ValueError, structure.check, '12')
    def test_string(self):
        strings = ['A', '\x00\x01', u'Ж', u'中', u'\U00010346']
        structure = StringStructure("string")
        self.assertEqual(
            structure.xstruct, 'S',
            "StringStructure's xstruct is %r instead of 'S'" %
            (structure.xstruct, ))

        #good values
        for string in strings:
            try:
                structure.check(string)
            except:
                self.fail("StringStructure said %r is not valid" % (string, ))
            self.assertEqual(structure.length(string),
                             len(pack(structure.xstruct, string)))

        #bad values
        self.assertRaises(ValueError, structure.check, 0)
        self.assertRaises(ValueError, structure.check, 0.)
        self.assertRaises(ValueError, structure.check, None)