def testPickling(self):
        v = {
            'long': NSNumber.numberWithUnsignedLongLong_(2 ** 63 + 5000),
            'int':  NSNumber.numberWithInt_(42),
            'float': NSNumber.numberWithDouble_(2.0),
        }
        import pickle
        data = pickle.dumps(v)

        w = pickle.loads(data)
        if os_release() <= '10.5' and os_release() != '10.10':
            self.assertEqual(w, {
                'long': -2**63 + 5000,
                'int': 42,
                'float': 2.0,
            })
        else:
            self.assertEqual(w, {
                'long': 2**63 + 5000,
                'int': 42,
                'float': 2.0,
            })

        for o in v.values():
            self.assertTrue(hasattr(o, '__pyobjc_object__'))

        for o in w.values():
            self.assertFalse(hasattr(o, '__pyobjc_object__'))
Beispiel #2
0
    def testPickling(self):
        v = {
            "long": NSNumber.numberWithUnsignedLongLong_(2**63 + 5000),
            "int": NSNumber.numberWithInt_(42),
            "float": NSNumber.numberWithDouble_(2.0),
        }
        import pickle

        data = pickle.dumps(v)

        w = pickle.loads(data)
        if os_level_key(os_release()) < os_level_key("10.5"):
            self.assertEqual(w, {
                "long": -(2**63) + 5000,
                "int": 42,
                "float": 2.0
            })
        else:
            self.assertEqual(w, {
                "long": 2**63 + 5000,
                "int": 42,
                "float": 2.0
            })

        for o in v.values():
            self.assertTrue(hasattr(o, "__pyobjc_object__"))

        for o in w.values():
            self.assertFalse(hasattr(o, "__pyobjc_object__"))
Beispiel #3
0
    def testPickling(self):
        v = {
            'long': NSNumber.numberWithUnsignedLongLong_(2**63 + 5000),
            'int': NSNumber.numberWithInt_(42),
            'float': NSNumber.numberWithDouble_(2.0),
        }
        import pickle
        data = pickle.dumps(v)

        w = pickle.loads(data)
        if os_level_key(os_release()) < os_level_key('10.5'):
            self.assertEqual(w, {
                'long': -2**63 + 5000,
                'int': 42,
                'float': 2.0,
            })
        else:
            self.assertEqual(w, {
                'long': 2**63 + 5000,
                'int': 42,
                'float': 2.0,
            })

        for o in v.values():
            self.assertTrue(hasattr(o, '__pyobjc_object__'))

        for o in w.values():
            self.assertFalse(hasattr(o, '__pyobjc_object__'))
Beispiel #4
0
    def testIntConversions(self):
        v = NSNumber.numberWithInt_(42)

        self.assertEqual(v.stringValue(), "42")

        self.assertEqual(OC_TestNumber.numberAsBOOL_(v), 1)
        self.assertEqual(OC_TestNumber.numberAsChar_(v), 42)
        self.assertEqual(OC_TestNumber.numberAsShort_(v), 42)
        self.assertEqual(OC_TestNumber.numberAsInt_(v), 42)
        self.assertEqual(OC_TestNumber.numberAsLong_(v), 42)
        self.assertEqual(OC_TestNumber.numberAsLongLong_(v), 42)
        self.assertEqual(OC_TestNumber.numberAsUnsignedChar_(v), 42)
        self.assertEqual(OC_TestNumber.numberAsUnsignedShort_(v), 42)
        self.assertEqual(OC_TestNumber.numberAsUnsignedInt_(v), 42)
        self.assertEqual(OC_TestNumber.numberAsUnsignedLong_(v), 42)
        self.assertEqual(OC_TestNumber.numberAsUnsignedLongLong_(v), 42)
        self.assertEqual(OC_TestNumber.numberAsFloat_(v), 42.0)
        self.assertEqual(OC_TestNumber.numberAsDouble_(v), 42.0)

        # Negative values
        v = NSNumber.numberWithInt_(-42)

        self.assertEqual(v.stringValue(), "-42")

        self.assertEqual(OC_TestNumber.numberAsBOOL_(v), 1)
        self.assertEqual(OC_TestNumber.numberAsChar_(v), -42)
        self.assertEqual(OC_TestNumber.numberAsShort_(v), -42)
        self.assertEqual(OC_TestNumber.numberAsInt_(v), -42)
        self.assertEqual(OC_TestNumber.numberAsLong_(v), -42)
        self.assertEqual(OC_TestNumber.numberAsLongLong_(v), -42)
        self.assertEqual(OC_TestNumber.numberAsUnsignedChar_(v), 214)
        self.assertEqual(OC_TestNumber.numberAsUnsignedShort_(v), 65494)
        self.assertEqual(OC_TestNumber.numberAsUnsignedInt_(v), 4_294_967_254)

        if sys.maxsize == (2 ** 31) - 1:
            self.assertEqual(OC_TestNumber.numberAsUnsignedLong_(v), 4_294_967_254)
        else:
            self.assertEqual(
                OC_TestNumber.numberAsUnsignedLong_(v), 18_446_744_073_709_551_574
            )

        self.assertEqual(
            OC_TestNumber.numberAsUnsignedLongLong_(v), 18_446_744_073_709_551_574
        )
        self.assertEqual(OC_TestNumber.numberAsFloat_(v), -42.0)
        self.assertEqual(OC_TestNumber.numberAsDouble_(v), -42.0)

        # Overflow
        v = NSNumber.numberWithInt_(892_455)

        self.assertEqual(OC_TestNumber.numberAsBOOL_(v), 1)
        self.assertEqual(OC_TestNumber.numberAsChar_(v), 39)
        self.assertEqual(OC_TestNumber.numberAsShort_(v), -25049)
        self.assertEqual(OC_TestNumber.numberAsUnsignedChar_(v), 39)
        self.assertEqual(OC_TestNumber.numberAsUnsignedShort_(v), 40487)
    def testIntConversions(self):
        v = NSNumber.numberWithInt_(42)

        self.assertEqual(v.stringValue(), '42')

        self.assertEqual(OC_TestNumber.numberAsBOOL_(v), 1)
        self.assertEqual(OC_TestNumber.numberAsChar_(v), 42)
        self.assertEqual(OC_TestNumber.numberAsShort_(v), 42)
        self.assertEqual(OC_TestNumber.numberAsInt_(v), 42)
        self.assertEqual(OC_TestNumber.numberAsLong_(v), 42)
        self.assertEqual(OC_TestNumber.numberAsLongLong_(v), 42)
        self.assertEqual(OC_TestNumber.numberAsUnsignedChar_(v), 42)
        self.assertEqual(OC_TestNumber.numberAsUnsignedShort_(v), 42)
        self.assertEqual(OC_TestNumber.numberAsUnsignedInt_(v), 42)
        self.assertEqual(OC_TestNumber.numberAsUnsignedLong_(v), 42)
        self.assertEqual(OC_TestNumber.numberAsUnsignedLongLong_(v), 42)
        self.assertEqual(OC_TestNumber.numberAsFloat_(v), 42.0)
        self.assertEqual(OC_TestNumber.numberAsDouble_(v), 42.0)

        # Negative values
        v = NSNumber.numberWithInt_(-42)

        self.assertEqual(v.stringValue(), '-42')

        self.assertEqual(OC_TestNumber.numberAsBOOL_(v), 1)
        self.assertEqual(OC_TestNumber.numberAsChar_(v), -42)
        self.assertEqual(OC_TestNumber.numberAsShort_(v), -42)
        self.assertEqual(OC_TestNumber.numberAsInt_(v), -42)
        self.assertEqual(OC_TestNumber.numberAsLong_(v), -42)
        self.assertEqual(OC_TestNumber.numberAsLongLong_(v), -42)
        self.assertEqual(OC_TestNumber.numberAsUnsignedChar_(v), 214)
        self.assertEqual(OC_TestNumber.numberAsUnsignedShort_(v), 65494)
        self.assertEqual(OC_TestNumber.numberAsUnsignedInt_(v), 4294967254)

        if sys.maxsize == (2 ** 31) -1:
            self.assertEqual(OC_TestNumber.numberAsUnsignedLong_(v), 4294967254)
        else:
            self.assertEqual(OC_TestNumber.numberAsUnsignedLong_(v), 18446744073709551574)

        self.assertEqual(OC_TestNumber.numberAsUnsignedLongLong_(v), 18446744073709551574)
        self.assertEqual(OC_TestNumber.numberAsFloat_(v), -42.0)
        self.assertEqual(OC_TestNumber.numberAsDouble_(v), -42.0)

        # Overflow
        v = NSNumber.numberWithInt_(892455)

        self.assertEqual(OC_TestNumber.numberAsBOOL_(v), 1)
        self.assertEqual(OC_TestNumber.numberAsChar_(v), 39)
        self.assertEqual(OC_TestNumber.numberAsShort_(v), -25049)
        self.assertEqual(OC_TestNumber.numberAsUnsignedChar_(v), 39)
        self.assertEqual(OC_TestNumber.numberAsUnsignedShort_(v), 40487)
Beispiel #6
0
    def testIntConversions(self):
        v = NSNumber.numberWithInt_(42)

        self.assertEquals(OC_TestNumber.numberAsBOOL_(v), 1)
        self.assertEquals(OC_TestNumber.numberAsChar_(v), 42)
        self.assertEquals(OC_TestNumber.numberAsShort_(v), 42)
        self.assertEquals(OC_TestNumber.numberAsInt_(v), 42)
        self.assertEquals(OC_TestNumber.numberAsLong_(v), 42)
        self.assertEquals(OC_TestNumber.numberAsLongLong_(v), 42)
        self.assertEquals(OC_TestNumber.numberAsUnsignedChar_(v), 42)
        self.assertEquals(OC_TestNumber.numberAsUnsignedShort_(v), 42)
        self.assertEquals(OC_TestNumber.numberAsUnsignedInt_(v), 42)
        self.assertEquals(OC_TestNumber.numberAsUnsignedLong_(v), 42)
        self.assertEquals(OC_TestNumber.numberAsUnsignedLongLong_(v), 42)
        self.assertEquals(OC_TestNumber.numberAsFloat_(v), 42.0)
        self.assertEquals(OC_TestNumber.numberAsDouble_(v), 42.0)

        # Negative values
        v = NSNumber.numberWithInt_(-42)

        self.assertEquals(OC_TestNumber.numberAsBOOL_(v), 1)
        self.assertEquals(OC_TestNumber.numberAsChar_(v), -42)
        self.assertEquals(OC_TestNumber.numberAsShort_(v), -42)
        self.assertEquals(OC_TestNumber.numberAsInt_(v), -42)
        self.assertEquals(OC_TestNumber.numberAsLong_(v), -42)
        self.assertEquals(OC_TestNumber.numberAsLongLong_(v), -42)
        self.assertEquals(OC_TestNumber.numberAsUnsignedChar_(v), 214)
        self.assertEquals(OC_TestNumber.numberAsUnsignedShort_(v), 65494)
        self.assertEquals(OC_TestNumber.numberAsUnsignedInt_(v), 4294967254)

        if sys.maxint == (2**31) - 1:
            self.assertEquals(OC_TestNumber.numberAsUnsignedLong_(v),
                              4294967254)
        else:
            self.assertEquals(OC_TestNumber.numberAsUnsignedLong_(v),
                              18446744073709551574)

        self.assertEquals(OC_TestNumber.numberAsUnsignedLongLong_(v),
                          18446744073709551574)
        self.assertEquals(OC_TestNumber.numberAsFloat_(v), -42.0)
        self.assertEquals(OC_TestNumber.numberAsDouble_(v), -42.0)

        # Overflow
        v = NSNumber.numberWithInt_(892455)

        self.assertEquals(OC_TestNumber.numberAsBOOL_(v), 1)
        self.assertEquals(OC_TestNumber.numberAsChar_(v), 39)
        self.assertEquals(OC_TestNumber.numberAsShort_(v), -25049)
        self.assertEquals(OC_TestNumber.numberAsUnsignedChar_(v), 39)
        self.assertEquals(OC_TestNumber.numberAsUnsignedShort_(v), 40487)
    def testFormatting(self):
        formatter = NSNumberFormatter.alloc().init()

        n = NSNumber.numberWithInt_(42)
        p = 42
        self.assertEqual(formatter.stringForObjectValue_(n), formatter.stringForObjectValue_(p))

        n = NSNumber.numberWithInt_(-42)
        p = -42
        self.assertEqual(formatter.stringForObjectValue_(n), formatter.stringForObjectValue_(p))


        n = NSNumber.numberWithDouble_(10.42)
        p = 10.42
        self.assertEqual(formatter.stringForObjectValue_(n), formatter.stringForObjectValue_(p))
    def testFormatting(self):
        formatter = NSNumberFormatter.alloc().init()

        n = NSNumber.numberWithInt_(42)
        p = 42
        self.assertEqual(formatter.stringForObjectValue_(n), formatter.stringForObjectValue_(p))

        n = NSNumber.numberWithInt_(-42)
        p = -42
        self.assertEqual(formatter.stringForObjectValue_(n), formatter.stringForObjectValue_(p))


        n = NSNumber.numberWithDouble_(10.42)
        p = 10.42
        self.assertEqual(formatter.stringForObjectValue_(n), formatter.stringForObjectValue_(p))
    def testDescription(self):
        v = OC_TestNumber.numberDescription_(NSNumber.numberWithInt_(0))
        self.assertIsInstance(v, unicode)
        self.assertEqual(v, "0")

        v = OC_TestNumber.numberDescription_(NSNumber.numberWithLongLong_(2**60))
        self.assertIsInstance(v, unicode)
        self.assertEqual(v, unicode(str(2**60)))

        v = OC_TestNumber.numberDescription_(NSNumber.numberWithLongLong_(-2**60))
        self.assertIsInstance(v, unicode)
        self.assertEqual(v, unicode(str(-2**60)))

        v = OC_TestNumber.numberDescription_(NSNumber.numberWithDouble_(264.0))
        self.assertIsInstance(v, unicode)
        self.assertEqual(v, "264")
    def testDescription(self):
        v = OC_TestNumber.numberDescription_(NSNumber.numberWithInt_(0))
        self.assertIsInstance(v, unicode)
        self.assertEqual(v, "0")

        v = OC_TestNumber.numberDescription_(NSNumber.numberWithLongLong_(2**60))
        self.assertIsInstance(v, unicode)
        self.assertEqual(v, unicode(str(2**60)))

        v = OC_TestNumber.numberDescription_(NSNumber.numberWithLongLong_(-2**60))
        self.assertIsInstance(v, unicode)
        self.assertEqual(v, unicode(str(-2**60)))

        v = OC_TestNumber.numberDescription_(NSNumber.numberWithDouble_(264.0))
        self.assertIsInstance(v, unicode)
        self.assertEqual(v, "264")
Beispiel #11
0
    def testPickleFloat(self):
        v = NSNumber.numberWithFloat_(42)
        self.assertIsInstance(v, OC_PythonFloat)

        # First python pickle
        s = pickle.dumps(v)
        v2 = pickle.loads(s)
        self.assertEqual(v2, v)
        self.assertIsNotInstance(v2, OC_PythonFloat)
        self.assertIsInstance(v2, float)
Beispiel #12
0
    def testPickleLongLong(self):
        v = NSNumber.numberWithLongLong_(sys.maxsize + 3)
        self.assertIsInstance(v, OC_PythonLong)

        # First python pickle
        s = pickle.dumps(v)
        v2 = pickle.loads(s)
        self.assertEqual(v2, v)
        self.assertIsNotInstance(v2, OC_PythonLong)
        self.assertIsInstance(v2, int)
Beispiel #13
0
    def testPickleInt(self):
        number_type = OC_PythonLong
        v = NSNumber.numberWithInt_(42)
        self.assertIsInstance(v, number_type)

        # First python pickle
        s = pickle.dumps(v)
        v2 = pickle.loads(s)
        self.assertEqual(v2, v)
        self.assertIsNotInstance(v2, number_type)
        self.assertIsInstance(v2, int)
Beispiel #14
0
    def testLongValue(self):
        v = NSNumber.numberWithUnsignedLongLong_(2**63 + 5000)
        self.assertIsInstance(v, long)

        if os_level_key(os_release()) < os_level_key('10.5'):
            self.assertEqual(v.description(), str(-2**63 + 5000))
        else:
            self.assertEqual(v.description(), str(2**63 + 5000))

        self.assertIsNot(type(v), long)

        self.assertRaises(AttributeError, setattr, v, 'x', 42)
    def testLongValue(self):
        v = NSNumber.numberWithUnsignedLongLong_(2 ** 63 + 5000)
        self.assertIsInstance(v, long)

        if os_release() <= '10.5' and os_release() != '10.10':
            self.assertEqual(v.description(), str(-2**63+5000))
        else:
            self.assertEqual(v.description(), str(2**63+5000))

        self.assertIsNot(type(v), long)

        self.assertRaises(AttributeError, setattr, v, 'x', 42)
Beispiel #16
0
    def testShortConversions(self):
        v = NSNumber.numberWithShort_(42)

        self.assertEquals(OC_TestNumber.numberAsBOOL_(v), 1)
        self.assertEquals(OC_TestNumber.numberAsChar_(v), 42)
        self.assertEquals(OC_TestNumber.numberAsShort_(v), 42)
        self.assertEquals(OC_TestNumber.numberAsInt_(v), 42)
        self.assertEquals(OC_TestNumber.numberAsLong_(v), 42)
        self.assertEquals(OC_TestNumber.numberAsLongLong_(v), 42)
        self.assertEquals(OC_TestNumber.numberAsUnsignedChar_(v), 42)
        self.assertEquals(OC_TestNumber.numberAsUnsignedShort_(v), 42)
        self.assertEquals(OC_TestNumber.numberAsUnsignedInt_(v), 42)
        self.assertEquals(OC_TestNumber.numberAsUnsignedLong_(v), 42)
        self.assertEquals(OC_TestNumber.numberAsUnsignedLongLong_(v), 42)
        self.assertEquals(OC_TestNumber.numberAsFloat_(v), 42.0)
        self.assertEquals(OC_TestNumber.numberAsDouble_(v), 42.0)
Beispiel #17
0
    def testShortConversions(self):
        v = NSNumber.numberWithShort_(42)

        self.assertEquals(OC_TestNumber.numberAsBOOL_(v), 1)
        self.assertEquals(OC_TestNumber.numberAsChar_(v), 42)
        self.assertEquals(OC_TestNumber.numberAsShort_(v), 42)
        self.assertEquals(OC_TestNumber.numberAsInt_(v), 42)
        self.assertEquals(OC_TestNumber.numberAsLong_(v), 42)
        self.assertEquals(OC_TestNumber.numberAsLongLong_(v), 42)
        self.assertEquals(OC_TestNumber.numberAsUnsignedChar_(v), 42)
        self.assertEquals(OC_TestNumber.numberAsUnsignedShort_(v), 42)
        self.assertEquals(OC_TestNumber.numberAsUnsignedInt_(v), 42)
        self.assertEquals(OC_TestNumber.numberAsUnsignedLong_(v), 42)
        self.assertEquals(OC_TestNumber.numberAsUnsignedLongLong_(v), 42)
        self.assertEquals(OC_TestNumber.numberAsFloat_(v), 42.0)
        self.assertEquals(OC_TestNumber.numberAsDouble_(v), 42.0)
Beispiel #18
0
    def testPickleInt(self):
        v = NSNumber.numberWithInt_(42)
        self.assert_(isinstance(v, OC_PythonInt))

        # First python pickle
        s = pickle.dumps(v)
        v2 = pickle.loads(s)
        self.assertEquals(v2, v)
        self.assert_(not isinstance(v2, OC_PythonInt))
        self.assert_(isinstance(v2, int))

        # Then C pickle
        s = cPickle.dumps(v)
        v2 = cPickle.loads(s)
        self.assertEquals(v2, v)
        self.assert_(not isinstance(v2, OC_PythonInt))
        self.assert_(isinstance(v2, int))
Beispiel #19
0
    def testPickleLongLong(self):
        v = NSNumber.numberWithLongLong_(sys.maxint + 3)
        self.assertIsInstance(v, OC_PythonLong)

        # First python pickle
        s = pickle.dumps(v)
        v2 = pickle.loads(s)
        self.assertEquals(v2, v)
        self.assertIsNotInstance(v2, OC_PythonLong)
        self.assertIsInstance(v2, long)

        # Then C pickle
        s = cPickle.dumps(v)
        v2 = cPickle.loads(s)
        self.assertEquals(v2, v)
        self.assertIsNotInstance(v2, OC_PythonLong)
        self.assertIsInstance(v2, long)
Beispiel #20
0
    def testPickleFloat(self):
        v = NSNumber.numberWithFloat_(42)
        self.assertIsInstance(v, OC_PythonFloat)

        # First python pickle
        s = pickle.dumps(v)
        v2 = pickle.loads(s)
        self.assertEquals(v2, v)
        self.assertIsNotInstance(v2, OC_PythonFloat)
        self.assertIsInstance(v2, float)

        # Then C pickle
        s = cPickle.dumps(v)
        v2 = cPickle.loads(s)
        self.assertEquals(v2, v)
        self.assertIsNotInstance(v2, OC_PythonFloat)
        self.assertIsInstance(v2, float)
Beispiel #21
0
    def testPickleLongLong(self):
        if sys.maxint > 2**32:
            return

        v = NSNumber.numberWithLongLong_(sys.maxint + 3)
        self.assert_(isinstance(v, OC_PythonLong))

        # First python pickle
        s = pickle.dumps(v)
        v2 = pickle.loads(s)
        self.assertEquals(v2, v)
        self.assert_(not isinstance(v2, OC_PythonLong))
        self.assert_(isinstance(v2, long))

        # Then C pickle
        s = cPickle.dumps(v)
        v2 = cPickle.loads(s)
        self.assertEquals(v2, v)
        self.assert_(not isinstance(v2, OC_PythonLong))
        self.assert_(isinstance(v2, long))
Beispiel #22
0
    def testPickleInt(self):
        if sys.version_info[0] == 2:
            number_type = OC_PythonInt
        else:
            number_type = OC_PythonLong
        v = NSNumber.numberWithInt_(42)
        self.assertIsInstance(v, number_type)

        # First python pickle
        s = pickle.dumps(v)
        v2 = pickle.loads(s)
        self.assertEquals(v2, v)
        self.assertIsNotInstance(v2, number_type)
        self.assertIsInstance(v2, int)

        # Then C pickle
        s = cPickle.dumps(v)
        v2 = cPickle.loads(s)
        self.assertEquals(v2, v)
        self.assertIsNotInstance(v2, number_type)
        self.assertIsInstance(v2, int)
Beispiel #23
0
    def testPickleInt(self):
        if sys.version_info[0] == 2:
            number_type = OC_PythonInt
        else:
            number_type = OC_PythonLong
        v = NSNumber.numberWithInt_(42)
        self.assertIsInstance(v, number_type)

        # First python pickle
        s = pickle.dumps(v)
        v2 = pickle.loads(s)
        self.assertEquals(v2, v)
        self.assertIsNotInstance(v2, number_type)
        self.assertIsInstance(v2, int)

        # Then C pickle
        s = cPickle.dumps(v)
        v2 = cPickle.loads(s)
        self.assertEquals(v2, v)
        self.assertIsNotInstance(v2, number_type)
        self.assertIsInstance(v2, int)
Beispiel #24
0
    def testMixedEquals(self):
        # isEqualToNumber for:
        #   - python number to nsnumber
        #   - nsnumber to python number
        # For: (bool, int, long, float) vs (char, short, ...)
        self.assertTrue(
            OC_TestNumber.number_isEqualTo_(0, NSNumber.numberWithInt_(0)))
        self.assertTrue(
            OC_TestNumber.number_isEqualTo_(0, NSNumber.numberWithLong_(0)))
        self.assertTrue(
            OC_TestNumber.number_isEqualTo_(0, NSNumber.numberWithFloat_(0)))
        self.assertTrue(
            OC_TestNumber.number_isEqualTo_(NSNumber.numberWithInt_(0), 0))
        self.assertTrue(
            OC_TestNumber.number_isEqualTo_(NSNumber.numberWithLong_(0), 0))
        self.assertTrue(
            OC_TestNumber.number_isEqualTo_(NSNumber.numberWithFloat_(0), 0))

        self.assertFalse(
            OC_TestNumber.number_isEqualTo_(42, NSNumber.numberWithInt_(0)))
        self.assertFalse(
            OC_TestNumber.number_isEqualTo_(42, NSNumber.numberWithLong_(0)))
        self.assertFalse(
            OC_TestNumber.number_isEqualTo_(42, NSNumber.numberWithFloat_(0)))
        self.assertFalse(
            OC_TestNumber.number_isEqualTo_(NSNumber.numberWithInt_(0), 42))
        self.assertFalse(
            OC_TestNumber.number_isEqualTo_(NSNumber.numberWithLong_(0), 42))
        self.assertFalse(
            OC_TestNumber.number_isEqualTo_(NSNumber.numberWithFloat_(0), 42))
    def testDoubleConversions(self):
        v = NSNumber.numberWithDouble_(75.5)
        self.assertEqual(v.stringValue(), "75.5")
        self.assertEqual(OC_TestNumber.numberAsBOOL_(v), 1)
        self.assertEqual(OC_TestNumber.numberAsChar_(v), 75)
        self.assertEqual(OC_TestNumber.numberAsShort_(v), 75)
        self.assertEqual(OC_TestNumber.numberAsInt_(v), 75)
        self.assertEqual(OC_TestNumber.numberAsLong_(v), 75)
        self.assertEqual(OC_TestNumber.numberAsLongLong_(v), 75)
        self.assertEqual(OC_TestNumber.numberAsUnsignedChar_(v), 75)
        self.assertEqual(OC_TestNumber.numberAsUnsignedShort_(v), 75)
        self.assertEqual(OC_TestNumber.numberAsUnsignedInt_(v), 75)
        self.assertEqual(OC_TestNumber.numberAsUnsignedLong_(v), 75)
        self.assertEqual(OC_TestNumber.numberAsUnsignedLongLong_(v), 75)
        self.assertEqual(OC_TestNumber.numberAsFloat_(v), 75.5)
        self.assertEqual(OC_TestNumber.numberAsDouble_(v), 75.5)

        # Negative values
        v = NSNumber.numberWithDouble_(-127.6)
        self.assertEqual(v.stringValue(), "-127.6")

        self.assertEqual(OC_TestNumber.numberAsBOOL_(v), 1)
        self.assertEqual(OC_TestNumber.numberAsChar_(v), -127)
        self.assertEqual(OC_TestNumber.numberAsShort_(v), -127)
        self.assertEqual(OC_TestNumber.numberAsInt_(v), -127)
        self.assertEqual(OC_TestNumber.numberAsLong_(v), -127)
        self.assertEqual(OC_TestNumber.numberAsLongLong_(v), -127)
        self.assertEqual(OC_TestNumber.numberAsUnsignedChar_(v), 129)
        self.assertEqual(OC_TestNumber.numberAsUnsignedShort_(v), 65409)
        self.assertEqual(OC_TestNumber.numberAsUnsignedInt_(v), 4_294_967_169)

        # NOTE: The expected values in the test below were determined by running
        #       the equivalent ObjC code.
        if objc.arch == "arm64":
            self.assertEqual(OC_TestNumber.numberAsUnsignedLong_(v),
                             18_446_744_073_709_551_615)
        else:
            self.assertEqual(OC_TestNumber.numberAsUnsignedLong_(v),
                             18_446_744_073_709_551_488)

        # The first entry in the tuple below is incorrect, that happens to be what
        # is returned by NSNumber on some platforms (in particular, any Python where
        # the python framework itself is linked against the 10.4 SDK)
        #
        #   double v = -127.6;
        #   unsigned long long lv = v;
        #   printf("%llu\n", lv);
        #

        self.assertIn(
            OC_TestNumber.numberAsUnsignedLongLong_(v),
            (
                18_446_744_073_709_551_489,
                18_446_744_073_709_551_488,
                18_446_744_073_709_551_615,
            ),
        )

        self.assertEqual(OC_TestNumber.numberAsDouble_(v), -127.6)

        # Overflow
        v = NSNumber.numberWithDouble_(float(2**64 + 99))

        self.assertEqual(OC_TestNumber.numberAsBOOL_(v), 1)

        if objc.arch == "arm64":
            self.assertEqual(OC_TestNumber.numberAsChar_(v), -1)
            self.assertEqual(OC_TestNumber.numberAsShort_(v), -1)
            self.assertEqual(OC_TestNumber.numberAsUnsignedChar_(v), 255)
            self.assertEqual(OC_TestNumber.numberAsUnsignedShort_(v), 65535)
        else:
            self.assertEqual(OC_TestNumber.numberAsChar_(v), 0)
            self.assertEqual(OC_TestNumber.numberAsShort_(v), 0)
            self.assertEqual(OC_TestNumber.numberAsUnsignedChar_(v), 0)
            self.assertEqual(OC_TestNumber.numberAsUnsignedShort_(v), 0)
    def testMixedEquals(self):
        # isEqualToNumber for:
        #   - python number to nsnumber
        #   - nsnumber to python number
        # For: (bool, int, long, float) vs (char, short, ...)
        self.assertTrue(OC_TestNumber.number_isEqualTo_(0, NSNumber.numberWithInt_(0)))
        self.assertTrue(OC_TestNumber.number_isEqualTo_(0, NSNumber.numberWithLong_(0)))
        self.assertTrue(OC_TestNumber.number_isEqualTo_(0, NSNumber.numberWithFloat_(0)))
        self.assertTrue(OC_TestNumber.number_isEqualTo_(NSNumber.numberWithInt_(0), 0))
        self.assertTrue(OC_TestNumber.number_isEqualTo_(NSNumber.numberWithLong_(0), 0))
        self.assertTrue(OC_TestNumber.number_isEqualTo_(NSNumber.numberWithFloat_(0), 0))

        self.assertFalse(OC_TestNumber.number_isEqualTo_(42, NSNumber.numberWithInt_(0)))
        self.assertFalse(OC_TestNumber.number_isEqualTo_(42, NSNumber.numberWithLong_(0)))
        self.assertFalse(OC_TestNumber.number_isEqualTo_(42, NSNumber.numberWithFloat_(0)))
        self.assertFalse(OC_TestNumber.number_isEqualTo_(NSNumber.numberWithInt_(0), 42))
        self.assertFalse(OC_TestNumber.number_isEqualTo_(NSNumber.numberWithLong_(0), 42))
        self.assertFalse(OC_TestNumber.number_isEqualTo_(NSNumber.numberWithFloat_(0), 42))
Beispiel #27
0
    def testDoubleConversions(self):
        v = NSNumber.numberWithDouble_(75.5)
        self.assertEqual(v.stringValue(), '75.5')
        self.assertEqual(OC_TestNumber.numberAsBOOL_(v), 1)
        self.assertEqual(OC_TestNumber.numberAsChar_(v), 75)
        self.assertEqual(OC_TestNumber.numberAsShort_(v), 75)
        self.assertEqual(OC_TestNumber.numberAsInt_(v), 75)
        self.assertEqual(OC_TestNumber.numberAsLong_(v), 75)
        self.assertEqual(OC_TestNumber.numberAsLongLong_(v), 75)
        self.assertEqual(OC_TestNumber.numberAsUnsignedChar_(v), 75)
        self.assertEqual(OC_TestNumber.numberAsUnsignedShort_(v), 75)
        self.assertEqual(OC_TestNumber.numberAsUnsignedInt_(v), 75)
        self.assertEqual(OC_TestNumber.numberAsUnsignedLong_(v), 75)
        self.assertEqual(OC_TestNumber.numberAsUnsignedLongLong_(v), 75)
        self.assertEqual(OC_TestNumber.numberAsFloat_(v), 75.5)
        self.assertEqual(OC_TestNumber.numberAsDouble_(v), 75.5)

        # Negative values
        v = NSNumber.numberWithDouble_(-127.6)
        self.assertEqual(v.stringValue(), '-127.6')

        self.assertEqual(OC_TestNumber.numberAsBOOL_(v), 1)
        self.assertEqual(OC_TestNumber.numberAsChar_(v), -127)
        self.assertEqual(OC_TestNumber.numberAsShort_(v), -127)
        self.assertEqual(OC_TestNumber.numberAsInt_(v), -127)
        self.assertEqual(OC_TestNumber.numberAsLong_(v), -127)
        self.assertEqual(OC_TestNumber.numberAsLongLong_(v), -127)
        self.assertEqual(OC_TestNumber.numberAsUnsignedChar_(v), 129)
        self.assertEqual(OC_TestNumber.numberAsUnsignedShort_(v), 65409)
        self.assertEqual(OC_TestNumber.numberAsUnsignedInt_(v), 4294967169)

        if sys.maxsize == (2**31) - 1:
            self.assertEqual(OC_TestNumber.numberAsUnsignedLong_(v),
                             4294967169)
        else:
            self.assertEqual(OC_TestNumber.numberAsUnsignedLong_(v),
                             18446744073709551488)

        # The first entry in the tuple below is incorrect, that happens to be what
        # is returned by NSNumber on some platforms (in particular, any Python where
        # the python framework itself is linked against the 10.4 SDK)
        #
        #   double v = -127.6;
        #   unsigned long long lv = v;
        #   printf("%llu\n", lv);
        #

        self.assertIn(OC_TestNumber.numberAsUnsignedLongLong_(v),
                      (18446744073709551489, 18446744073709551488))

        self.assertEqual(OC_TestNumber.numberAsDouble_(v), -127.6)

        # Overflow
        v = NSNumber.numberWithDouble_(float(2**64 + 99))

        self.assertEqual(OC_TestNumber.numberAsBOOL_(v), 1)

        if sys.byteorder == 'big':
            self.assertEqual(OC_TestNumber.numberAsChar_(v), -1)
            self.assertEqual(OC_TestNumber.numberAsShort_(v), -1)
            self.assertEqual(OC_TestNumber.numberAsUnsignedChar_(v), 255)
            self.assertEqual(OC_TestNumber.numberAsUnsignedShort_(v), 65535)
        else:
            self.assertEqual(OC_TestNumber.numberAsChar_(v), 0)
            self.assertEqual(OC_TestNumber.numberAsShort_(v), 0)
            self.assertEqual(OC_TestNumber.numberAsUnsignedChar_(v), 0)
            self.assertEqual(OC_TestNumber.numberAsUnsignedShort_(v), 0)
Beispiel #28
0
    def testCompare(self):
        self.assertEqual(
            OC_TestNumber.compareA_andB_(NSNumber.numberWithLong_(0),
                                         NSNumber.numberWithLong_(1)),
            NSOrderedAscending)
        self.assertEqual(
            OC_TestNumber.compareA_andB_(
                NSNumber.numberWithLong_(0),
                NSNumber.numberWithUnsignedLongLong_(2**40)),
            NSOrderedAscending)
        self.assertEqual(
            OC_TestNumber.compareA_andB_(NSNumber.numberWithLong_(0),
                                         NSNumber.numberWithDouble_(42.0)),
            NSOrderedAscending)

        self.assertEqual(
            OC_TestNumber.compareA_andB_(NSNumber.numberWithLong_(0),
                                         NSNumber.numberWithLong_(-1)),
            NSOrderedDescending)
        self.assertEqual(
            OC_TestNumber.compareA_andB_(NSNumber.numberWithLong_(0),
                                         NSNumber.numberWithLongLong_(-2**60)),
            NSOrderedDescending)
        self.assertEqual(
            OC_TestNumber.compareA_andB_(NSNumber.numberWithLong_(0),
                                         NSNumber.numberWithDouble_(-42.0)),
            NSOrderedDescending)

        self.assertEqual(
            OC_TestNumber.compareA_andB_(NSNumber.numberWithLong_(0),
                                         NSNumber.numberWithLong_(0)),
            NSOrderedSame)
        self.assertEqual(
            OC_TestNumber.compareA_andB_(NSNumber.numberWithLong_(0),
                                         NSNumber.numberWithDouble_(0.0)),
            NSOrderedSame)
        self.assertEqual(
            OC_TestNumber.compareA_andB_(NSNumber.numberWithLong_(0),
                                         NSNumber.numberWithLongLong_(0)),
            NSOrderedSame)
    def testCompare(self):
        self.assertEqual(OC_TestNumber.compareA_andB_(NSNumber.numberWithLong_(0), NSNumber.numberWithLong_(1)), NSOrderedAscending)
        self.assertEqual(OC_TestNumber.compareA_andB_(NSNumber.numberWithLong_(0), NSNumber.numberWithUnsignedLongLong_(2**40)), NSOrderedAscending)
        self.assertEqual(OC_TestNumber.compareA_andB_(NSNumber.numberWithLong_(0), NSNumber.numberWithDouble_(42.0)), NSOrderedAscending)

        self.assertEqual(OC_TestNumber.compareA_andB_(NSNumber.numberWithLong_(0), NSNumber.numberWithLong_(-1)), NSOrderedDescending)
        self.assertEqual(OC_TestNumber.compareA_andB_(NSNumber.numberWithLong_(0), NSNumber.numberWithLongLong_(-2**60)), NSOrderedDescending)
        self.assertEqual(OC_TestNumber.compareA_andB_(NSNumber.numberWithLong_(0), NSNumber.numberWithDouble_(-42.0)), NSOrderedDescending)

        self.assertEqual(OC_TestNumber.compareA_andB_(NSNumber.numberWithLong_(0), NSNumber.numberWithLong_(0)), NSOrderedSame)
        self.assertEqual(OC_TestNumber.compareA_andB_(NSNumber.numberWithLong_(0), NSNumber.numberWithDouble_(0.0)), NSOrderedSame)
        self.assertEqual(OC_TestNumber.compareA_andB_(NSNumber.numberWithLong_(0), NSNumber.numberWithLongLong_(0)), NSOrderedSame)
    def testDoubleConversions(self):
        v = NSNumber.numberWithDouble_(75.5)
        self.assertEqual(v.stringValue(), '75.5')

        self.assertEqual(OC_TestNumber.numberAsBOOL_(v), 1)
        self.assertEqual(OC_TestNumber.numberAsChar_(v), 75)
        self.assertEqual(OC_TestNumber.numberAsShort_(v), 75)
        self.assertEqual(OC_TestNumber.numberAsInt_(v), 75)
        self.assertEqual(OC_TestNumber.numberAsLong_(v), 75)
        self.assertEqual(OC_TestNumber.numberAsLongLong_(v), 75)
        self.assertEqual(OC_TestNumber.numberAsUnsignedChar_(v), 75)
        self.assertEqual(OC_TestNumber.numberAsUnsignedShort_(v), 75)
        self.assertEqual(OC_TestNumber.numberAsUnsignedInt_(v), 75)
        self.assertEqual(OC_TestNumber.numberAsUnsignedLong_(v), 75)
        self.assertEqual(OC_TestNumber.numberAsUnsignedLongLong_(v), 75)
        self.assertEqual(OC_TestNumber.numberAsFloat_(v), 75.5)
        self.assertEqual(OC_TestNumber.numberAsDouble_(v), 75.5)

        # Negative values
        v = NSNumber.numberWithDouble_(-127.6)
        self.assertEqual(v.stringValue(), '-127.6')

        self.assertEqual(OC_TestNumber.numberAsBOOL_(v), 1)
        self.assertEqual(OC_TestNumber.numberAsChar_(v), -127)
        self.assertEqual(OC_TestNumber.numberAsShort_(v), -127)
        self.assertEqual(OC_TestNumber.numberAsInt_(v), -127)
        self.assertEqual(OC_TestNumber.numberAsLong_(v), -127)
        self.assertEqual(OC_TestNumber.numberAsLongLong_(v), -127)
        self.assertEqual(OC_TestNumber.numberAsUnsignedChar_(v), 129)
        self.assertEqual(OC_TestNumber.numberAsUnsignedShort_(v), 65409)
        self.assertEqual(OC_TestNumber.numberAsUnsignedInt_(v), 4294967169)

        if sys.maxsize == (2 ** 31) -1:
            self.assertEqual(OC_TestNumber.numberAsUnsignedLong_(v), 4294967169)
        else:
            self.assertEqual(OC_TestNumber.numberAsUnsignedLong_(v), 18446744073709551488)

        # The first entry in the tuple below is incorrect, that happens to be what
        # is returned by NSNumber on some platforms (in particular, any Python where
        # the python framework itself is linked against the 10.4 SDK)
        #
        #   double v = -127.6;
        #   unsigned long long lv = v;
        #   printf("%llu\n", lv);
        #

        self.assertIn(
                OC_TestNumber.numberAsUnsignedLongLong_(v),
                    (18446744073709551489, 18446744073709551488))

        self.assertEqual(OC_TestNumber.numberAsDouble_(v), -127.6)

        # Overflow
        v = NSNumber.numberWithDouble_(float(2**64 + 99))

        self.assertEqual(OC_TestNumber.numberAsBOOL_(v), 1)

        if sys.byteorder == 'big':
            self.assertEqual(OC_TestNumber.numberAsChar_(v), -1)
            self.assertEqual(OC_TestNumber.numberAsShort_(v), -1)
            self.assertEqual(OC_TestNumber.numberAsUnsignedChar_(v), 255)
            self.assertEqual(OC_TestNumber.numberAsUnsignedShort_(v), 65535)
        else:
            self.assertEqual(OC_TestNumber.numberAsChar_(v), 0)
            self.assertEqual(OC_TestNumber.numberAsShort_(v), 0)
            self.assertEqual(OC_TestNumber.numberAsUnsignedChar_(v), 0)
            self.assertEqual(OC_TestNumber.numberAsUnsignedShort_(v), 0)