mirror of https://github.com/python/cpython
Merged revisions 61750,61752,61754,61756,61760,61763,61768,61772,61775,61805,61809,61812,61819,61917,61920,61930,61933-61934 via svnmerge from
svn+ssh://pythondev@svn.python.org/python/branches/trunk-bytearray
........
r61750 | christian.heimes | 2008-03-22 20:47:44 +0100 (Sat, 22 Mar 2008) | 1 line
Copied files from py3k w/o modifications
........
r61752 | christian.heimes | 2008-03-22 20:53:20 +0100 (Sat, 22 Mar 2008) | 7 lines
Take One
* Added initialization code, warnings, flags etc. to the appropriate places
* Added new buffer interface to string type
* Modified tests
* Modified Makefile.pre.in to compile the new files
* Added bytesobject.c to Python.h
........
r61754 | christian.heimes | 2008-03-22 21:22:19 +0100 (Sat, 22 Mar 2008) | 2 lines
Disabled bytearray.extend for now since it causes an infinite recursion
Fixed serveral unit tests
........
r61756 | christian.heimes | 2008-03-22 21:43:38 +0100 (Sat, 22 Mar 2008) | 5 lines
Added PyBytes support to several places:
str + bytearray
ord(bytearray)
bytearray(str, encoding)
........
r61760 | christian.heimes | 2008-03-22 21:56:32 +0100 (Sat, 22 Mar 2008) | 1 line
Fixed more unit tests related to type('') is not unicode
........
r61763 | christian.heimes | 2008-03-22 22:20:28 +0100 (Sat, 22 Mar 2008) | 2 lines
Fixed more unit tests
Fixed bytearray.extend
........
r61768 | christian.heimes | 2008-03-22 22:40:50 +0100 (Sat, 22 Mar 2008) | 1 line
Implemented old buffer interface for bytearray
........
r61772 | christian.heimes | 2008-03-22 23:24:52 +0100 (Sat, 22 Mar 2008) | 1 line
Added backport of the io module
........
r61775 | christian.heimes | 2008-03-23 03:50:49 +0100 (Sun, 23 Mar 2008) | 1 line
Fix str assignement to bytearray. Assignment of a str of size 1 is interpreted as a single byte
........
r61805 | christian.heimes | 2008-03-23 19:33:48 +0100 (Sun, 23 Mar 2008) | 3 lines
Fixed more tests
Fixed bytearray() comparsion with unicode()
Fixed iterator assignment of bytearray
........
r61809 | christian.heimes | 2008-03-23 21:02:21 +0100 (Sun, 23 Mar 2008) | 2 lines
str(bytesarray()) now returns the bytes and not the representation of the bytearray object
Enabled and fixed more unit tests
........
r61812 | christian.heimes | 2008-03-23 21:53:08 +0100 (Sun, 23 Mar 2008) | 3 lines
Clear error PyNumber_AsSsize_t() fails
Use CHARMASK for ob_svall access
disabled a test with memoryview again
........
r61819 | christian.heimes | 2008-03-23 23:05:57 +0100 (Sun, 23 Mar 2008) | 1 line
Untested updates to the PCBuild directory
........
r61917 | christian.heimes | 2008-03-26 00:57:06 +0100 (Wed, 26 Mar 2008) | 1 line
The type system of Python 2.6 has subtle differences to 3.0's. I've removed the Py_TPFLAGS_BASETYPE flags from bytearray for now. bytearray can't be subclasses until the issues with bytearray subclasses are fixed.
........
r61920 | christian.heimes | 2008-03-26 01:44:08 +0100 (Wed, 26 Mar 2008) | 2 lines
Disabled last failing test
I don't understand what the test is testing and how it suppose to work. Ka-Ping, please check it out.
........
r61930 | christian.heimes | 2008-03-26 12:46:18 +0100 (Wed, 26 Mar 2008) | 1 line
Re-enabled bytes warning code
........
r61933 | christian.heimes | 2008-03-26 13:20:46 +0100 (Wed, 26 Mar 2008) | 1 line
Fixed a bug in the new buffer protocol. The buffer slots weren't copied into a subclass.
........
r61934 | christian.heimes | 2008-03-26 13:25:09 +0100 (Wed, 26 Mar 2008) | 1 line
Re-enabled bytearray subclassing - all tests are passing.
........
This commit is contained in:
Christian Heimes
parent
630b57a0a1
commit
1a6387e683
|
|
@ -92,6 +92,7 @@
|
|||
#include "stringobject.h"
|
||||
/* #include "memoryobject.h" */
|
||||
#include "bufferobject.h"
|
||||
#include "bytesobject.h"
|
||||
#include "tupleobject.h"
|
||||
#include "listobject.h"
|
||||
#include "dictobject.h"
|
||||
|
|
|
|||
|
|
@ -0,0 +1,84 @@
|
|||
#ifndef Py_BYTES_CTYPE_H
|
||||
#define Py_BYTES_CTYPE_H
|
||||
|
||||
/*
|
||||
* The internal implementation behind PyString (bytes) and PyBytes (buffer)
|
||||
* methods of the given names, they operate on ASCII byte strings.
|
||||
*/
|
||||
extern PyObject* _Py_bytes_isspace(const char *cptr, Py_ssize_t len);
|
||||
extern PyObject* _Py_bytes_isalpha(const char *cptr, Py_ssize_t len);
|
||||
extern PyObject* _Py_bytes_isalnum(const char *cptr, Py_ssize_t len);
|
||||
extern PyObject* _Py_bytes_isdigit(const char *cptr, Py_ssize_t len);
|
||||
extern PyObject* _Py_bytes_islower(const char *cptr, Py_ssize_t len);
|
||||
extern PyObject* _Py_bytes_isupper(const char *cptr, Py_ssize_t len);
|
||||
extern PyObject* _Py_bytes_istitle(const char *cptr, Py_ssize_t len);
|
||||
|
||||
/* These store their len sized answer in the given preallocated *result arg. */
|
||||
extern void _Py_bytes_lower(char *result, const char *cptr, Py_ssize_t len);
|
||||
extern void _Py_bytes_upper(char *result, const char *cptr, Py_ssize_t len);
|
||||
extern void _Py_bytes_title(char *result, char *s, Py_ssize_t len);
|
||||
extern void _Py_bytes_capitalize(char *result, char *s, Py_ssize_t len);
|
||||
extern void _Py_bytes_swapcase(char *result, char *s, Py_ssize_t len);
|
||||
|
||||
/* Shared __doc__ strings. */
|
||||
extern const char _Py_isspace__doc__[];
|
||||
extern const char _Py_isalpha__doc__[];
|
||||
extern const char _Py_isalnum__doc__[];
|
||||
extern const char _Py_isdigit__doc__[];
|
||||
extern const char _Py_islower__doc__[];
|
||||
extern const char _Py_isupper__doc__[];
|
||||
extern const char _Py_istitle__doc__[];
|
||||
extern const char _Py_lower__doc__[];
|
||||
extern const char _Py_upper__doc__[];
|
||||
extern const char _Py_title__doc__[];
|
||||
extern const char _Py_capitalize__doc__[];
|
||||
extern const char _Py_swapcase__doc__[];
|
||||
|
||||
#define FLAG_LOWER 0x01
|
||||
#define FLAG_UPPER 0x02
|
||||
#define FLAG_ALPHA (FLAG_LOWER|FLAG_UPPER)
|
||||
#define FLAG_DIGIT 0x04
|
||||
#define FLAG_ALNUM (FLAG_ALPHA|FLAG_DIGIT)
|
||||
#define FLAG_SPACE 0x08
|
||||
#define FLAG_XDIGIT 0x10
|
||||
|
||||
extern const unsigned int _Py_ctype_table[256];
|
||||
|
||||
#define ISLOWER(c) (_Py_ctype_table[Py_CHARMASK(c)] & FLAG_LOWER)
|
||||
#define ISUPPER(c) (_Py_ctype_table[Py_CHARMASK(c)] & FLAG_UPPER)
|
||||
#define ISALPHA(c) (_Py_ctype_table[Py_CHARMASK(c)] & FLAG_ALPHA)
|
||||
#define ISDIGIT(c) (_Py_ctype_table[Py_CHARMASK(c)] & FLAG_DIGIT)
|
||||
#define ISXDIGIT(c) (_Py_ctype_table[Py_CHARMASK(c)] & FLAG_XDIGIT)
|
||||
#define ISALNUM(c) (_Py_ctype_table[Py_CHARMASK(c)] & FLAG_ALNUM)
|
||||
#define ISSPACE(c) (_Py_ctype_table[Py_CHARMASK(c)] & FLAG_SPACE)
|
||||
|
||||
#undef islower
|
||||
#define islower(c) undefined_islower(c)
|
||||
#undef isupper
|
||||
#define isupper(c) undefined_isupper(c)
|
||||
#undef isalpha
|
||||
#define isalpha(c) undefined_isalpha(c)
|
||||
#undef isdigit
|
||||
#define isdigit(c) undefined_isdigit(c)
|
||||
#undef isxdigit
|
||||
#define isxdigit(c) undefined_isxdigit(c)
|
||||
#undef isalnum
|
||||
#define isalnum(c) undefined_isalnum(c)
|
||||
#undef isspace
|
||||
#define isspace(c) undefined_isspace(c)
|
||||
|
||||
extern const unsigned char _Py_ctype_tolower[256];
|
||||
extern const unsigned char _Py_ctype_toupper[256];
|
||||
|
||||
#define TOLOWER(c) (_Py_ctype_tolower[Py_CHARMASK(c)])
|
||||
#define TOUPPER(c) (_Py_ctype_toupper[Py_CHARMASK(c)])
|
||||
|
||||
#undef tolower
|
||||
#define tolower(c) undefined_tolower(c)
|
||||
#undef toupper
|
||||
#define toupper(c) undefined_toupper(c)
|
||||
|
||||
/* this is needed because some docs are shared from the .o, not static */
|
||||
#define PyDoc_STRVAR_shared(name,str) const char name[] = PyDoc_STR(str)
|
||||
|
||||
#endif /* !Py_BYTES_CTYPE_H */
|
||||
|
|
@ -0,0 +1,53 @@
|
|||
/* Bytes object interface */
|
||||
|
||||
#ifndef Py_BYTESOBJECT_H
|
||||
#define Py_BYTESOBJECT_H
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
/* Type PyBytesObject represents a mutable array of bytes.
|
||||
* The Python API is that of a sequence;
|
||||
* the bytes are mapped to ints in [0, 256).
|
||||
* Bytes are not characters; they may be used to encode characters.
|
||||
* The only way to go between bytes and str/unicode is via encoding
|
||||
* and decoding.
|
||||
* For the convenience of C programmers, the bytes type is considered
|
||||
* to contain a char pointer, not an unsigned char pointer.
|
||||
*/
|
||||
|
||||
/* Object layout */
|
||||
typedef struct {
|
||||
PyObject_VAR_HEAD
|
||||
/* XXX(nnorwitz): should ob_exports be Py_ssize_t? */
|
||||
int ob_exports; /* how many buffer exports */
|
||||
Py_ssize_t ob_alloc; /* How many bytes allocated */
|
||||
char *ob_bytes;
|
||||
} PyBytesObject;
|
||||
|
||||
/* Type object */
|
||||
PyAPI_DATA(PyTypeObject) PyBytes_Type;
|
||||
PyAPI_DATA(PyTypeObject) PyBytesIter_Type;
|
||||
|
||||
/* Type check macros */
|
||||
#define PyBytes_Check(self) PyObject_TypeCheck(self, &PyBytes_Type)
|
||||
#define PyBytes_CheckExact(self) (Py_TYPE(self) == &PyBytes_Type)
|
||||
|
||||
/* Direct API functions */
|
||||
PyAPI_FUNC(PyObject *) PyBytes_FromObject(PyObject *);
|
||||
PyAPI_FUNC(PyObject *) PyBytes_Concat(PyObject *, PyObject *);
|
||||
PyAPI_FUNC(PyObject *) PyBytes_FromStringAndSize(const char *, Py_ssize_t);
|
||||
PyAPI_FUNC(Py_ssize_t) PyBytes_Size(PyObject *);
|
||||
PyAPI_FUNC(char *) PyBytes_AsString(PyObject *);
|
||||
PyAPI_FUNC(int) PyBytes_Resize(PyObject *, Py_ssize_t);
|
||||
|
||||
/* Macros, trading safety for speed */
|
||||
#define PyBytes_AS_STRING(self) (assert(PyBytes_Check(self)),((PyBytesObject *)(self))->ob_bytes)
|
||||
#define PyBytes_GET_SIZE(self) (assert(PyBytes_Check(self)),Py_SIZE(self))
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
#endif /* !Py_BYTESOBJECT_H */
|
||||
|
|
@ -11,6 +11,7 @@ PyAPI_DATA(int) Py_InteractiveFlag;
|
|||
PyAPI_DATA(int) Py_InspectFlag;
|
||||
PyAPI_DATA(int) Py_OptimizeFlag;
|
||||
PyAPI_DATA(int) Py_NoSiteFlag;
|
||||
PyAPI_DATA(int) Py_BytesWarningFlag;
|
||||
PyAPI_DATA(int) Py_UseClassExceptionsFlag;
|
||||
PyAPI_DATA(int) Py_FrozenFlag;
|
||||
PyAPI_DATA(int) Py_TabcheckFlag;
|
||||
|
|
|
|||
|
|
@ -175,6 +175,7 @@ PyAPI_DATA(PyObject *) PyExc_RuntimeWarning;
|
|||
PyAPI_DATA(PyObject *) PyExc_FutureWarning;
|
||||
PyAPI_DATA(PyObject *) PyExc_ImportWarning;
|
||||
PyAPI_DATA(PyObject *) PyExc_UnicodeWarning;
|
||||
PyAPI_DATA(PyObject *) PyExc_BytesWarning;
|
||||
|
||||
|
||||
/* Convenience functions */
|
||||
|
|
|
|||
|
|
@ -123,6 +123,7 @@ PyAPI_FUNC(void) _PyImportHooks_Init(void);
|
|||
PyAPI_FUNC(int) _PyFrame_Init(void);
|
||||
PyAPI_FUNC(int) _PyInt_Init(void);
|
||||
PyAPI_FUNC(void) _PyFloat_Init(void);
|
||||
PyAPI_FUNC(int) PyBytes_Init(void);
|
||||
|
||||
/* Various internal finalizers */
|
||||
PyAPI_FUNC(void) _PyExc_Fini(void);
|
||||
|
|
@ -138,6 +139,7 @@ PyAPI_FUNC(void) PyString_Fini(void);
|
|||
PyAPI_FUNC(void) PyInt_Fini(void);
|
||||
PyAPI_FUNC(void) PyFloat_Fini(void);
|
||||
PyAPI_FUNC(void) PyOS_FiniInterrupts(void);
|
||||
PyAPI_FUNC(void) PyBytes_Fini(void);
|
||||
|
||||
/* Stuff with no proper home (yet) */
|
||||
PyAPI_FUNC(char *) PyOS_Readline(FILE *, FILE *, char *);
|
||||
|
|
|
|||
|
|
@ -181,6 +181,18 @@ class IncrementalEncoder(object):
|
|||
Resets the encoder to the initial state.
|
||||
"""
|
||||
|
||||
def getstate(self):
|
||||
"""
|
||||
Return the current state of the encoder.
|
||||
"""
|
||||
return 0
|
||||
|
||||
def setstate(self, state):
|
||||
"""
|
||||
Set the current state of the encoder. state must have been
|
||||
returned by getstate().
|
||||
"""
|
||||
|
||||
class BufferedIncrementalEncoder(IncrementalEncoder):
|
||||
"""
|
||||
This subclass of IncrementalEncoder can be used as the baseclass for an
|
||||
|
|
@ -208,6 +220,12 @@ class BufferedIncrementalEncoder(IncrementalEncoder):
|
|||
IncrementalEncoder.reset(self)
|
||||
self.buffer = ""
|
||||
|
||||
def getstate(self):
|
||||
return self.buffer or 0
|
||||
|
||||
def setstate(self, state):
|
||||
self.buffer = state or ""
|
||||
|
||||
class IncrementalDecoder(object):
|
||||
"""
|
||||
An IncrementalDecoder decodes an input in multiple steps. The input can be
|
||||
|
|
@ -235,6 +253,28 @@ class IncrementalDecoder(object):
|
|||
Resets the decoder to the initial state.
|
||||
"""
|
||||
|
||||
def getstate(self):
|
||||
"""
|
||||
Return the current state of the decoder.
|
||||
|
||||
This must be a (buffered_input, additional_state_info) tuple.
|
||||
buffered_input must be a bytes object containing bytes that
|
||||
were passed to decode() that have not yet been converted.
|
||||
additional_state_info must be a non-negative integer
|
||||
representing the state of the decoder WITHOUT yet having
|
||||
processed the contents of buffered_input. In the initial state
|
||||
and after reset(), getstate() must return (b"", 0).
|
||||
"""
|
||||
return (b"", 0)
|
||||
|
||||
def setstate(self, state):
|
||||
"""
|
||||
Set the current state of the decoder.
|
||||
|
||||
state must have been returned by getstate(). The effect of
|
||||
setstate((b"", 0)) must be equivalent to reset().
|
||||
"""
|
||||
|
||||
class BufferedIncrementalDecoder(IncrementalDecoder):
|
||||
"""
|
||||
This subclass of IncrementalDecoder can be used as the baseclass for an
|
||||
|
|
@ -262,6 +302,14 @@ class BufferedIncrementalDecoder(IncrementalDecoder):
|
|||
IncrementalDecoder.reset(self)
|
||||
self.buffer = ""
|
||||
|
||||
def getstate(self):
|
||||
# additional state info is always 0
|
||||
return (self.buffer, 0)
|
||||
|
||||
def setstate(self, state):
|
||||
# ignore additional state info
|
||||
self.buffer = state[0]
|
||||
|
||||
#
|
||||
# The StreamWriter and StreamReader class provide generic working
|
||||
# interfaces which can be used to implement new encoding submodules
|
||||
|
|
|
|||
|
|
@ -0,0 +1,206 @@
|
|||
# Tests that work for both bytes and buffer objects.
|
||||
# See PEP 3137.
|
||||
|
||||
import struct
|
||||
import sys
|
||||
|
||||
class MixinBytesBufferCommonTests(object):
|
||||
"""Tests that work for both bytes and buffer objects.
|
||||
See PEP 3137.
|
||||
"""
|
||||
|
||||
def marshal(self, x):
|
||||
"""Convert x into the appropriate type for these tests."""
|
||||
raise RuntimeError('test class must provide a marshal method')
|
||||
|
||||
def test_islower(self):
|
||||
self.assertFalse(self.marshal(b'').islower())
|
||||
self.assert_(self.marshal(b'a').islower())
|
||||
self.assertFalse(self.marshal(b'A').islower())
|
||||
self.assertFalse(self.marshal(b'\n').islower())
|
||||
self.assert_(self.marshal(b'abc').islower())
|
||||
self.assertFalse(self.marshal(b'aBc').islower())
|
||||
self.assert_(self.marshal(b'abc\n').islower())
|
||||
self.assertRaises(TypeError, self.marshal(b'abc').islower, 42)
|
||||
|
||||
def test_isupper(self):
|
||||
self.assertFalse(self.marshal(b'').isupper())
|
||||
self.assertFalse(self.marshal(b'a').isupper())
|
||||
self.assert_(self.marshal(b'A').isupper())
|
||||
self.assertFalse(self.marshal(b'\n').isupper())
|
||||
self.assert_(self.marshal(b'ABC').isupper())
|
||||
self.assertFalse(self.marshal(b'AbC').isupper())
|
||||
self.assert_(self.marshal(b'ABC\n').isupper())
|
||||
self.assertRaises(TypeError, self.marshal(b'abc').isupper, 42)
|
||||
|
||||
def test_istitle(self):
|
||||
self.assertFalse(self.marshal(b'').istitle())
|
||||
self.assertFalse(self.marshal(b'a').istitle())
|
||||
self.assert_(self.marshal(b'A').istitle())
|
||||
self.assertFalse(self.marshal(b'\n').istitle())
|
||||
self.assert_(self.marshal(b'A Titlecased Line').istitle())
|
||||
self.assert_(self.marshal(b'A\nTitlecased Line').istitle())
|
||||
self.assert_(self.marshal(b'A Titlecased, Line').istitle())
|
||||
self.assertFalse(self.marshal(b'Not a capitalized String').istitle())
|
||||
self.assertFalse(self.marshal(b'Not\ta Titlecase String').istitle())
|
||||
self.assertFalse(self.marshal(b'Not--a Titlecase String').istitle())
|
||||
self.assertFalse(self.marshal(b'NOT').istitle())
|
||||
self.assertRaises(TypeError, self.marshal(b'abc').istitle, 42)
|
||||
|
||||
def test_isspace(self):
|
||||
self.assertFalse(self.marshal(b'').isspace())
|
||||
self.assertFalse(self.marshal(b'a').isspace())
|
||||
self.assert_(self.marshal(b' ').isspace())
|
||||
self.assert_(self.marshal(b'\t').isspace())
|
||||
self.assert_(self.marshal(b'\r').isspace())
|
||||
self.assert_(self.marshal(b'\n').isspace())
|
||||
self.assert_(self.marshal(b' \t\r\n').isspace())
|
||||
self.assertFalse(self.marshal(b' \t\r\na').isspace())
|
||||
self.assertRaises(TypeError, self.marshal(b'abc').isspace, 42)
|
||||
|
||||
def test_isalpha(self):
|
||||
self.assertFalse(self.marshal(b'').isalpha())
|
||||
self.assert_(self.marshal(b'a').isalpha())
|
||||
self.assert_(self.marshal(b'A').isalpha())
|
||||
self.assertFalse(self.marshal(b'\n').isalpha())
|
||||
self.assert_(self.marshal(b'abc').isalpha())
|
||||
self.assertFalse(self.marshal(b'aBc123').isalpha())
|
||||
self.assertFalse(self.marshal(b'abc\n').isalpha())
|
||||
self.assertRaises(TypeError, self.marshal(b'abc').isalpha, 42)
|
||||
|
||||
def test_isalnum(self):
|
||||
self.assertFalse(self.marshal(b'').isalnum())
|
||||
self.assert_(self.marshal(b'a').isalnum())
|
||||
self.assert_(self.marshal(b'A').isalnum())
|
||||
self.assertFalse(self.marshal(b'\n').isalnum())
|
||||
self.assert_(self.marshal(b'123abc456').isalnum())
|
||||
self.assert_(self.marshal(b'a1b3c').isalnum())
|
||||
self.assertFalse(self.marshal(b'aBc000 ').isalnum())
|
||||
self.assertFalse(self.marshal(b'abc\n').isalnum())
|
||||
self.assertRaises(TypeError, self.marshal(b'abc').isalnum, 42)
|
||||
|
||||
def test_isdigit(self):
|
||||
self.assertFalse(self.marshal(b'').isdigit())
|
||||
self.assertFalse(self.marshal(b'a').isdigit())
|
||||
self.assert_(self.marshal(b'0').isdigit())
|
||||
self.assert_(self.marshal(b'0123456789').isdigit())
|
||||
self.assertFalse(self.marshal(b'0123456789a').isdigit())
|
||||
|
||||
self.assertRaises(TypeError, self.marshal(b'abc').isdigit, 42)
|
||||
|
||||
def test_lower(self):
|
||||
self.assertEqual(b'hello', self.marshal(b'HeLLo').lower())
|
||||
self.assertEqual(b'hello', self.marshal(b'hello').lower())
|
||||
self.assertRaises(TypeError, self.marshal(b'hello').lower, 42)
|
||||
|
||||
def test_upper(self):
|
||||
self.assertEqual(b'HELLO', self.marshal(b'HeLLo').upper())
|
||||
self.assertEqual(b'HELLO', self.marshal(b'HELLO').upper())
|
||||
self.assertRaises(TypeError, self.marshal(b'hello').upper, 42)
|
||||
|
||||
def test_capitalize(self):
|
||||
self.assertEqual(b' hello ', self.marshal(b' hello ').capitalize())
|
||||
self.assertEqual(b'Hello ', self.marshal(b'Hello ').capitalize())
|
||||
self.assertEqual(b'Hello ', self.marshal(b'hello ').capitalize())
|
||||
self.assertEqual(b'Aaaa', self.marshal(b'aaaa').capitalize())
|
||||
self.assertEqual(b'Aaaa', self.marshal(b'AaAa').capitalize())
|
||||
|
||||
self.assertRaises(TypeError, self.marshal(b'hello').capitalize, 42)
|
||||
|
||||
def test_ljust(self):
|
||||
self.assertEqual(b'abc ', self.marshal(b'abc').ljust(10))
|
||||
self.assertEqual(b'abc ', self.marshal(b'abc').ljust(6))
|
||||
self.assertEqual(b'abc', self.marshal(b'abc').ljust(3))
|
||||
self.assertEqual(b'abc', self.marshal(b'abc').ljust(2))
|
||||
self.assertEqual(b'abc*******', self.marshal(b'abc').ljust(10, '*'))
|
||||
self.assertRaises(TypeError, self.marshal(b'abc').ljust)
|
||||
|
||||
def test_rjust(self):
|
||||
self.assertEqual(b' abc', self.marshal(b'abc').rjust(10))
|
||||
self.assertEqual(b' abc', self.marshal(b'abc').rjust(6))
|
||||
self.assertEqual(b'abc', self.marshal(b'abc').rjust(3))
|
||||
self.assertEqual(b'abc', self.marshal(b'abc').rjust(2))
|
||||
self.assertEqual(b'*******abc', self.marshal(b'abc').rjust(10, '*'))
|
||||
self.assertRaises(TypeError, self.marshal(b'abc').rjust)
|
||||
|
||||
def test_center(self):
|
||||
self.assertEqual(b' abc ', self.marshal(b'abc').center(10))
|
||||
self.assertEqual(b' abc ', self.marshal(b'abc').center(6))
|
||||
self.assertEqual(b'abc', self.marshal(b'abc').center(3))
|
||||
self.assertEqual(b'abc', self.marshal(b'abc').center(2))
|
||||
self.assertEqual(b'***abc****', self.marshal(b'abc').center(10, '*'))
|
||||
self.assertRaises(TypeError, self.marshal(b'abc').center)
|
||||
|
||||
def test_swapcase(self):
|
||||
self.assertEqual(b'hEllO CoMPuTErS',
|
||||
self.marshal(b'HeLLo cOmpUteRs').swapcase())
|
||||
|
||||
self.assertRaises(TypeError, self.marshal(b'hello').swapcase, 42)
|
||||
|
||||
def test_zfill(self):
|
||||
self.assertEqual(b'123', self.marshal(b'123').zfill(2))
|
||||
self.assertEqual(b'123', self.marshal(b'123').zfill(3))
|
||||
self.assertEqual(b'0123', self.marshal(b'123').zfill(4))
|
||||
self.assertEqual(b'+123', self.marshal(b'+123').zfill(3))
|
||||
self.assertEqual(b'+123', self.marshal(b'+123').zfill(4))
|
||||
self.assertEqual(b'+0123', self.marshal(b'+123').zfill(5))
|
||||
self.assertEqual(b'-123', self.marshal(b'-123').zfill(3))
|
||||
self.assertEqual(b'-123', self.marshal(b'-123').zfill(4))
|
||||
self.assertEqual(b'-0123', self.marshal(b'-123').zfill(5))
|
||||
self.assertEqual(b'000', self.marshal(b'').zfill(3))
|
||||
self.assertEqual(b'34', self.marshal(b'34').zfill(1))
|
||||
self.assertEqual(b'0034', self.marshal(b'34').zfill(4))
|
||||
|
||||
self.assertRaises(TypeError, self.marshal(b'123').zfill)
|
||||
|
||||
def test_expandtabs(self):
|
||||
self.assertEqual(b'abc\rab def\ng hi',
|
||||
self.marshal(b'abc\rab\tdef\ng\thi').expandtabs())
|
||||
self.assertEqual(b'abc\rab def\ng hi',
|
||||
self.marshal(b'abc\rab\tdef\ng\thi').expandtabs(8))
|
||||
self.assertEqual(b'abc\rab def\ng hi',
|
||||
self.marshal(b'abc\rab\tdef\ng\thi').expandtabs(4))
|
||||
self.assertEqual(b'abc\r\nab def\ng hi',
|
||||
self.marshal(b'abc\r\nab\tdef\ng\thi').expandtabs(4))
|
||||
self.assertEqual(b'abc\rab def\ng hi',
|
||||
self.marshal(b'abc\rab\tdef\ng\thi').expandtabs())
|
||||
self.assertEqual(b'abc\rab def\ng hi',
|
||||
self.marshal(b'abc\rab\tdef\ng\thi').expandtabs(8))
|
||||
self.assertEqual(b'abc\r\nab\r\ndef\ng\r\nhi',
|
||||
self.marshal(b'abc\r\nab\r\ndef\ng\r\nhi').expandtabs(4))
|
||||
self.assertEqual(b' a\n b', self.marshal(b' \ta\n\tb').expandtabs(1))
|
||||
|
||||
self.assertRaises(TypeError, self.marshal(b'hello').expandtabs, 42, 42)
|
||||
# This test is only valid when sizeof(int) == sizeof(void*) == 4.
|
||||
if sys.maxint < (1 << 32) and struct.calcsize('P') == 4:
|
||||
self.assertRaises(OverflowError,
|
||||
self.marshal(b'\ta\n\tb').expandtabs, sys.maxint)
|
||||
|
||||
def test_title(self):
|
||||
self.assertEqual(b' Hello ', self.marshal(b' hello ').title())
|
||||
self.assertEqual(b'Hello ', self.marshal(b'hello ').title())
|
||||
self.assertEqual(b'Hello ', self.marshal(b'Hello ').title())
|
||||
self.assertEqual(b'Format This As Title String',
|
||||
self.marshal(b'fOrMaT thIs aS titLe String').title())
|
||||
self.assertEqual(b'Format,This-As*Title;String',
|
||||
self.marshal(b'fOrMaT,thIs-aS*titLe;String').title())
|
||||
self.assertEqual(b'Getint', self.marshal(b'getInt').title())
|
||||
self.assertRaises(TypeError, self.marshal(b'hello').title, 42)
|
||||
|
||||
def test_splitlines(self):
|
||||
self.assertEqual([b'abc', b'def', b'', b'ghi'],
|
||||
self.marshal(b'abc\ndef\n\rghi').splitlines())
|
||||
self.assertEqual([b'abc', b'def', b'', b'ghi'],
|
||||
self.marshal(b'abc\ndef\n\r\nghi').splitlines())
|
||||
self.assertEqual([b'abc', b'def', b'ghi'],
|
||||
self.marshal(b'abc\ndef\r\nghi').splitlines())
|
||||
self.assertEqual([b'abc', b'def', b'ghi'],
|
||||
self.marshal(b'abc\ndef\r\nghi\n').splitlines())
|
||||
self.assertEqual([b'abc', b'def', b'ghi', b''],
|
||||
self.marshal(b'abc\ndef\r\nghi\n\r').splitlines())
|
||||
self.assertEqual([b'', b'abc', b'def', b'ghi', b''],
|
||||
self.marshal(b'\nabc\ndef\r\nghi\n\r').splitlines())
|
||||
self.assertEqual([b'\n', b'abc\n', b'def\r\n', b'ghi\n', b'\r'],
|
||||
self.marshal(b'\nabc\ndef\r\nghi\n\r').splitlines(1))
|
||||
|
||||
self.assertRaises(TypeError, self.marshal(b'abc').splitlines, 42, 42)
|
||||
|
|
@ -46,3 +46,4 @@ BaseException
|
|||
+-- FutureWarning
|
||||
+-- ImportWarning
|
||||
+-- UnicodeWarning
|
||||
+-- BytesWarning
|
||||
|
|
|
|||
|
|
@ -486,8 +486,9 @@ class CommonTest(unittest.TestCase):
|
|||
'lstrip', unicode('xyz', 'ascii'))
|
||||
self.checkequal(unicode('xyzzyhello', 'ascii'), 'xyzzyhelloxyzzy',
|
||||
'rstrip', unicode('xyz', 'ascii'))
|
||||
self.checkequal(unicode('hello', 'ascii'), 'hello',
|
||||
'strip', unicode('xyz', 'ascii'))
|
||||
# XXX
|
||||
#self.checkequal(unicode('hello', 'ascii'), 'hello',
|
||||
# 'strip', unicode('xyz', 'ascii'))
|
||||
|
||||
self.checkraises(TypeError, 'hello', 'strip', 42, 42)
|
||||
self.checkraises(TypeError, 'hello', 'lstrip', 42, 42)
|
||||
|
|
@ -727,6 +728,9 @@ class CommonTest(unittest.TestCase):
|
|||
|
||||
self.checkraises(TypeError, '123', 'zfill')
|
||||
|
||||
# XXX alias for py3k forward compatibility
|
||||
BaseTest = CommonTest
|
||||
|
||||
class MixinStrUnicodeUserStringTest:
|
||||
# additional tests that only work for
|
||||
# stringlike objects, i.e. str, unicode, UserString
|
||||
|
|
|
|||
|
|
@ -0,0 +1,982 @@
|
|||
"""Unit tests for the bytes and bytearray types.
|
||||
|
||||
XXX This is a mess. Common tests should be moved to buffer_tests.py,
|
||||
which itself ought to be unified with string_tests.py (and the latter
|
||||
should be modernized).
|
||||
"""
|
||||
|
||||
import os
|
||||
import re
|
||||
import sys
|
||||
import copy
|
||||
import pickle
|
||||
import tempfile
|
||||
import unittest
|
||||
import warnings
|
||||
import test.test_support
|
||||
import test.string_tests
|
||||
import test.buffer_tests
|
||||
|
||||
|
||||
class BaseBytesTest(unittest.TestCase):
|
||||
|
||||
def setUp(self):
|
||||
self.warning_filters = warnings.filters[:]
|
||||
|
||||
def tearDown(self):
|
||||
warnings.filters = self.warning_filters
|
||||
|
||||
def test_basics(self):
|
||||
b = self.type2test()
|
||||
self.assertEqual(type(b), self.type2test)
|
||||
self.assertEqual(b.__class__, self.type2test)
|
||||
|
||||
def test_empty_sequence(self):
|
||||
b = self.type2test()
|
||||
self.assertEqual(len(b), 0)
|
||||
self.assertRaises(IndexError, lambda: b[0])
|
||||
self.assertRaises(IndexError, lambda: b[1])
|
||||
self.assertRaises(IndexError, lambda: b[sys.maxint])
|
||||
self.assertRaises(IndexError, lambda: b[sys.maxint+1])
|
||||
self.assertRaises(IndexError, lambda: b[10**100])
|
||||
self.assertRaises(IndexError, lambda: b[-1])
|
||||
self.assertRaises(IndexError, lambda: b[-2])
|
||||
self.assertRaises(IndexError, lambda: b[-sys.maxint])
|
||||
self.assertRaises(IndexError, lambda: b[-sys.maxint-1])
|
||||
self.assertRaises(IndexError, lambda: b[-sys.maxint-2])
|
||||
self.assertRaises(IndexError, lambda: b[-10**100])
|
||||
|
||||
def test_from_list(self):
|
||||
ints = list(range(256))
|
||||
b = self.type2test(i for i in ints)
|
||||
self.assertEqual(len(b), 256)
|
||||
self.assertEqual(list(b), ints)
|
||||
|
||||
def test_from_index(self):
|
||||
class C:
|
||||
def __init__(self, i=0):
|
||||
self.i = i
|
||||
def __index__(self):
|
||||
return self.i
|
||||
b = self.type2test([C(), C(1), C(254), C(255)])
|
||||
self.assertEqual(list(b), [0, 1, 254, 255])
|
||||
self.assertRaises(ValueError, bytearray, [C(-1)])
|
||||
self.assertRaises(ValueError, bytearray, [C(256)])
|
||||
|
||||
def test_from_ssize(self):
|
||||
self.assertEqual(bytearray(0), b'')
|
||||
self.assertEqual(bytearray(1), b'\x00')
|
||||
self.assertEqual(bytearray(5), b'\x00\x00\x00\x00\x00')
|
||||
self.assertRaises(ValueError, bytearray, -1)
|
||||
|
||||
self.assertEqual(bytearray('0', 'ascii'), b'0')
|
||||
self.assertEqual(bytearray(b'0'), b'0')
|
||||
|
||||
def test_constructor_type_errors(self):
|
||||
self.assertRaises(TypeError, self.type2test, 0.0)
|
||||
class C:
|
||||
pass
|
||||
self.assertRaises(TypeError, self.type2test, ["0"])
|
||||
self.assertRaises(TypeError, self.type2test, [0.0])
|
||||
self.assertRaises(TypeError, self.type2test, [None])
|
||||
self.assertRaises(TypeError, self.type2test, [C()])
|
||||
|
||||
def test_constructor_value_errors(self):
|
||||
self.assertRaises(ValueError, self.type2test, [-1])
|
||||
self.assertRaises(ValueError, self.type2test, [-sys.maxint])
|
||||
self.assertRaises(ValueError, self.type2test, [-sys.maxint-1])
|
||||
self.assertRaises(ValueError, self.type2test, [-sys.maxint-2])
|
||||
self.assertRaises(ValueError, self.type2test, [-10**100])
|
||||
self.assertRaises(ValueError, self.type2test, [256])
|
||||
self.assertRaises(ValueError, self.type2test, [257])
|
||||
self.assertRaises(ValueError, self.type2test, [sys.maxint])
|
||||
self.assertRaises(ValueError, self.type2test, [sys.maxint+1])
|
||||
self.assertRaises(ValueError, self.type2test, [10**100])
|
||||
|
||||
def test_compare(self):
|
||||
b1 = self.type2test([1, 2, 3])
|
||||
b2 = self.type2test([1, 2, 3])
|
||||
b3 = self.type2test([1, 3])
|
||||
|
||||
self.assertEqual(b1, b2)
|
||||
self.failUnless(b2 != b3)
|
||||
self.failUnless(b1 <= b2)
|
||||
self.failUnless(b1 <= b3)
|
||||
self.failUnless(b1 < b3)
|
||||
self.failUnless(b1 >= b2)
|
||||
self.failUnless(b3 >= b2)
|
||||
self.failUnless(b3 > b2)
|
||||
|
||||
self.failIf(b1 != b2)
|
||||
self.failIf(b2 == b3)
|
||||
self.failIf(b1 > b2)
|
||||
self.failIf(b1 > b3)
|
||||
self.failIf(b1 >= b3)
|
||||
self.failIf(b1 < b2)
|
||||
self.failIf(b3 < b2)
|
||||
self.failIf(b3 <= b2)
|
||||
|
||||
def test_compare_to_str(self):
|
||||
warnings.simplefilter('ignore', BytesWarning)
|
||||
# Byte comparisons with unicode should always fail!
|
||||
# Test this for all expected byte orders and Unicode character sizes
|
||||
self.assertEqual(self.type2test(b"\0a\0b\0c") == u"abc", False)
|
||||
self.assertEqual(self.type2test(b"\0\0\0a\0\0\0b\0\0\0c") == u"abc", False)
|
||||
self.assertEqual(self.type2test(b"a\0b\0c\0") == u"abc", False)
|
||||
self.assertEqual(self.type2test(b"a\0\0\0b\0\0\0c\0\0\0") == u"abc", False)
|
||||
self.assertEqual(self.type2test() == unicode(), False)
|
||||
self.assertEqual(self.type2test() != unicode(), True)
|
||||
|
||||
def test_reversed(self):
|
||||
input = list(map(ord, "Hello"))
|
||||
b = self.type2test(input)
|
||||
output = list(reversed(b))
|
||||
input.reverse()
|
||||
self.assertEqual(output, input)
|
||||
|
||||
def test_getslice(self):
|
||||
def by(s):
|
||||
return self.type2test(map(ord, s))
|
||||
b = by("Hello, world")
|
||||
|
||||
self.assertEqual(b[:5], by("Hello"))
|
||||
self.assertEqual(b[1:5], by("ello"))
|
||||
self.assertEqual(b[5:7], by(", "))
|
||||
self.assertEqual(b[7:], by("world"))
|
||||
self.assertEqual(b[7:12], by("world"))
|
||||
self.assertEqual(b[7:100], by("world"))
|
||||
|
||||
self.assertEqual(b[:-7], by("Hello"))
|
||||
self.assertEqual(b[-11:-7], by("ello"))
|
||||
self.assertEqual(b[-7:-5], by(", "))
|
||||
self.assertEqual(b[-5:], by("world"))
|
||||
self.assertEqual(b[-5:12], by("world"))
|
||||
self.assertEqual(b[-5:100], by("world"))
|
||||
self.assertEqual(b[-100:5], by("Hello"))
|
||||
|
||||
def test_extended_getslice(self):
|
||||
# Test extended slicing by comparing with list slicing.
|
||||
L = list(range(255))
|
||||
b = self.type2test(L)
|
||||
indices = (0, None, 1, 3, 19, 100, -1, -2, -31, -100)
|
||||
for start in indices:
|
||||
for stop in indices:
|
||||
# Skip step 0 (invalid)
|
||||
for step in indices[1:]:
|
||||
self.assertEqual(b[start:stop:step], self.type2test(L[start:stop:step]))
|
||||
|
||||
def test_encoding(self):
|
||||
sample = u"Hello world\n\u1234\u5678\u9abc\udef0"
|
||||
for enc in ("utf8", "utf16"):
|
||||
b = self.type2test(sample, enc)
|
||||
self.assertEqual(b, self.type2test(sample.encode(enc)))
|
||||
self.assertRaises(UnicodeEncodeError, self.type2test, sample, "latin1")
|
||||
b = self.type2test(sample, "latin1", "ignore")
|
||||
self.assertEqual(b, self.type2test(sample[:-4], "utf-8"))
|
||||
|
||||
def test_decode(self):
|
||||
sample = u"Hello world\n\u1234\u5678\u9abc\def0\def0"
|
||||
for enc in ("utf8", "utf16"):
|
||||
b = self.type2test(sample, enc)
|
||||
self.assertEqual(b.decode(enc), sample)
|
||||
sample = u"Hello world\n\x80\x81\xfe\xff"
|
||||
b = self.type2test(sample, "latin1")
|
||||
self.assertRaises(UnicodeDecodeError, b.decode, "utf8")
|
||||
self.assertEqual(b.decode("utf8", "ignore"), "Hello world\n")
|
||||
|
||||
def test_from_int(self):
|
||||
b = self.type2test(0)
|
||||
self.assertEqual(b, self.type2test())
|
||||
b = self.type2test(10)
|
||||
self.assertEqual(b, self.type2test([0]*10))
|
||||
b = self.type2test(10000)
|
||||
self.assertEqual(b, self.type2test([0]*10000))
|
||||
|
||||
def test_concat(self):
|
||||
b1 = self.type2test(b"abc")
|
||||
b2 = self.type2test(b"def")
|
||||
self.assertEqual(b1 + b2, b"abcdef")
|
||||
self.assertEqual(b1 + bytes(b"def"), b"abcdef")
|
||||
self.assertEqual(bytes(b"def") + b1, b"defabc")
|
||||
self.assertRaises(TypeError, lambda: b1 + u"def")
|
||||
self.assertRaises(TypeError, lambda: u"abc" + b2)
|
||||
|
||||
def test_repeat(self):
|
||||
for b in b"abc", self.type2test(b"abc"):
|
||||
self.assertEqual(b * 3, b"abcabcabc")
|
||||
self.assertEqual(b * 0, b"")
|
||||
self.assertEqual(b * -1, b"")
|
||||
self.assertRaises(TypeError, lambda: b * 3.14)
|
||||
self.assertRaises(TypeError, lambda: 3.14 * b)
|
||||
# XXX Shouldn't bytes and bytearray agree on what to raise?
|
||||
self.assertRaises((OverflowError, MemoryError),
|
||||
lambda: b * sys.maxint)
|
||||
|
||||
def test_repeat_1char(self):
|
||||
self.assertEqual(self.type2test(b'x')*100, self.type2test([ord('x')]*100))
|
||||
|
||||
def test_contains(self):
|
||||
b = self.type2test(b"abc")
|
||||
self.failUnless(ord('a') in b)
|
||||
self.failUnless(int(ord('a')) in b)
|
||||
self.failIf(200 in b)
|
||||
self.failIf(200 in b)
|
||||
self.assertRaises(ValueError, lambda: 300 in b)
|
||||
self.assertRaises(ValueError, lambda: -1 in b)
|
||||
self.assertRaises(TypeError, lambda: None in b)
|
||||
self.assertRaises(TypeError, lambda: float(ord('a')) in b)
|
||||
self.assertRaises(TypeError, lambda: u"a" in b)
|
||||
for f in bytes, bytearray:
|
||||
self.failUnless(f(b"") in b)
|
||||
self.failUnless(f(b"a") in b)
|
||||
self.failUnless(f(b"b") in b)
|
||||
self.failUnless(f(b"c") in b)
|
||||
self.failUnless(f(b"ab") in b)
|
||||
self.failUnless(f(b"bc") in b)
|
||||
self.failUnless(f(b"abc") in b)
|
||||
self.failIf(f(b"ac") in b)
|
||||
self.failIf(f(b"d") in b)
|
||||
self.failIf(f(b"dab") in b)
|
||||
self.failIf(f(b"abd") in b)
|
||||
|
||||
def test_fromhex(self):
|
||||
self.assertRaises(TypeError, self.type2test.fromhex)
|
||||
self.assertRaises(TypeError, self.type2test.fromhex, 1)
|
||||
self.assertEquals(self.type2test.fromhex(u''), self.type2test())
|
||||
b = bytearray([0x1a, 0x2b, 0x30])
|
||||
self.assertEquals(self.type2test.fromhex(u'1a2B30'), b)
|
||||
self.assertEquals(self.type2test.fromhex(u' 1A 2B 30 '), b)
|
||||
self.assertEquals(self.type2test.fromhex(u'0000'), b'\0\0')
|
||||
self.assertRaises(TypeError, self.type2test.fromhex, b'1B')
|
||||
self.assertRaises(ValueError, self.type2test.fromhex, u'a')
|
||||
self.assertRaises(ValueError, self.type2test.fromhex, u'rt')
|
||||
self.assertRaises(ValueError, self.type2test.fromhex, u'1a b cd')
|
||||
self.assertRaises(ValueError, self.type2test.fromhex, u'\x00')
|
||||
self.assertRaises(ValueError, self.type2test.fromhex, u'12 \x00 34')
|
||||
|
||||
def test_join(self):
|
||||
self.assertEqual(self.type2test(b"").join([]), b"")
|
||||
self.assertEqual(self.type2test(b"").join([b""]), b"")
|
||||
for lst in [[b"abc"], [b"a", b"bc"], [b"ab", b"c"], [b"a", b"b", b"c"]]:
|
||||
lst = list(map(self.type2test, lst))
|
||||
self.assertEqual(self.type2test(b"").join(lst), b"abc")
|
||||
self.assertEqual(self.type2test(b"").join(tuple(lst)), b"abc")
|
||||
self.assertEqual(self.type2test(b"").join(iter(lst)), b"abc")
|
||||
self.assertEqual(self.type2test(b".").join([b"ab", b"cd"]), b"ab.cd")
|
||||
# XXX more...
|
||||
|
||||
def test_index(self):
|
||||
b = self.type2test(b'parrot')
|
||||
self.assertEqual(b.index('p'), 0)
|
||||
self.assertEqual(b.index('rr'), 2)
|
||||
self.assertEqual(b.index('t'), 5)
|
||||
self.assertRaises(ValueError, lambda: b.index('w'))
|
||||
|
||||
def test_count(self):
|
||||
b = self.type2test(b'mississippi')
|
||||
self.assertEqual(b.count(b'i'), 4)
|
||||
self.assertEqual(b.count(b'ss'), 2)
|
||||
self.assertEqual(b.count(b'w'), 0)
|
||||
|
||||
def test_startswith(self):
|
||||
b = self.type2test(b'hello')
|
||||
self.assertFalse(self.type2test().startswith(b"anything"))
|
||||
self.assertTrue(b.startswith(b"hello"))
|
||||
self.assertTrue(b.startswith(b"hel"))
|
||||
self.assertTrue(b.startswith(b"h"))
|
||||
self.assertFalse(b.startswith(b"hellow"))
|
||||
self.assertFalse(b.startswith(b"ha"))
|
||||
|
||||
def test_endswith(self):
|
||||
b = self.type2test(b'hello')
|
||||
self.assertFalse(bytearray().endswith(b"anything"))
|
||||
self.assertTrue(b.endswith(b"hello"))
|
||||
self.assertTrue(b.endswith(b"llo"))
|
||||
self.assertTrue(b.endswith(b"o"))
|
||||
self.assertFalse(b.endswith(b"whello"))
|
||||
self.assertFalse(b.endswith(b"no"))
|
||||
|
||||
def test_find(self):
|
||||
b = self.type2test(b'mississippi')
|
||||
self.assertEqual(b.find(b'ss'), 2)
|
||||
self.assertEqual(b.find(b'ss', 3), 5)
|
||||
self.assertEqual(b.find(b'ss', 1, 7), 2)
|
||||
self.assertEqual(b.find(b'ss', 1, 3), -1)
|
||||
self.assertEqual(b.find(b'w'), -1)
|
||||
self.assertEqual(b.find(b'mississippian'), -1)
|
||||
|
||||
def test_rfind(self):
|
||||
b = self.type2test(b'mississippi')
|
||||
self.assertEqual(b.rfind(b'ss'), 5)
|
||||
self.assertEqual(b.rfind(b'ss', 3), 5)
|
||||
self.assertEqual(b.rfind(b'ss', 0, 6), 2)
|
||||
self.assertEqual(b.rfind(b'w'), -1)
|
||||
self.assertEqual(b.rfind(b'mississippian'), -1)
|
||||
|
||||
def test_index(self):
|
||||
b = self.type2test(b'world')
|
||||
self.assertEqual(b.index(b'w'), 0)
|
||||
self.assertEqual(b.index(b'orl'), 1)
|
||||
self.assertRaises(ValueError, b.index, b'worm')
|
||||
self.assertRaises(ValueError, b.index, b'ldo')
|
||||
|
||||
def test_rindex(self):
|
||||
# XXX could be more rigorous
|
||||
b = self.type2test(b'world')
|
||||
self.assertEqual(b.rindex(b'w'), 0)
|
||||
self.assertEqual(b.rindex(b'orl'), 1)
|
||||
self.assertRaises(ValueError, b.rindex, b'worm')
|
||||
self.assertRaises(ValueError, b.rindex, b'ldo')
|
||||
|
||||
def test_replace(self):
|
||||
b = self.type2test(b'mississippi')
|
||||
self.assertEqual(b.replace(b'i', b'a'), b'massassappa')
|
||||
self.assertEqual(b.replace(b'ss', b'x'), b'mixixippi')
|
||||
|
||||
def test_split(self):
|
||||
b = self.type2test(b'mississippi')
|
||||
self.assertEqual(b.split(b'i'), [b'm', b'ss', b'ss', b'pp', b''])
|
||||
self.assertEqual(b.split(b'ss'), [b'mi', b'i', b'ippi'])
|
||||
self.assertEqual(b.split(b'w'), [b])
|
||||
|
||||
def test_split_whitespace(self):
|
||||
for b in (b' arf barf ', b'arf\tbarf', b'arf\nbarf', b'arf\rbarf',
|
||||
b'arf\fbarf', b'arf\vbarf'):
|
||||
b = self.type2test(b)
|
||||
self.assertEqual(b.split(), [b'arf', b'barf'])
|
||||
self.assertEqual(b.split(None), [b'arf', b'barf'])
|
||||
self.assertEqual(b.split(None, 2), [b'arf', b'barf'])
|
||||
for b in (b'a\x1Cb', b'a\x1Db', b'a\x1Eb', b'a\x1Fb'):
|
||||
b = self.type2test(b)
|
||||
self.assertEqual(b.split(), [b])
|
||||
self.assertEqual(self.type2test(b' a bb c ').split(None, 0), [b'a bb c '])
|
||||
self.assertEqual(self.type2test(b' a bb c ').split(None, 1), [b'a', b'bb c '])
|
||||
self.assertEqual(self.type2test(b' a bb c ').split(None, 2), [b'a', b'bb', b'c '])
|
||||
self.assertEqual(self.type2test(b' a bb c ').split(None, 3), [b'a', b'bb', b'c'])
|
||||
|
||||
def test_split_string_error(self):
|
||||
self.assertRaises(TypeError, self.type2test(b'a b').split, u' ')
|
||||
|
||||
def test_rsplit(self):
|
||||
b = self.type2test(b'mississippi')
|
||||
self.assertEqual(b.rsplit(b'i'), [b'm', b'ss', b'ss', b'pp', b''])
|
||||
self.assertEqual(b.rsplit(b'ss'), [b'mi', b'i', b'ippi'])
|
||||
self.assertEqual(b.rsplit(b'w'), [b])
|
||||
|
||||
def test_rsplit_whitespace(self):
|
||||
for b in (b' arf barf ', b'arf\tbarf', b'arf\nbarf', b'arf\rbarf',
|
||||
b'arf\fbarf', b'arf\vbarf'):
|
||||
b = self.type2test(b)
|
||||
self.assertEqual(b.rsplit(), [b'arf', b'barf'])
|
||||
self.assertEqual(b.rsplit(None), [b'arf', b'barf'])
|
||||
self.assertEqual(b.rsplit(None, 2), [b'arf', b'barf'])
|
||||
self.assertEqual(self.type2test(b' a bb c ').rsplit(None, 0), [b' a bb c'])
|
||||
self.assertEqual(self.type2test(b' a bb c ').rsplit(None, 1), [b' a bb', b'c'])
|
||||
self.assertEqual(self.type2test(b' a bb c ').rsplit(None, 2), [b' a', b'bb', b'c'])
|
||||
self.assertEqual(self.type2test(b' a bb c ').rsplit(None, 3), [b'a', b'bb', b'c'])
|
||||
|
||||
def test_rsplit_string_error(self):
|
||||
self.assertRaises(TypeError, self.type2test(b'a b').rsplit, u' ')
|
||||
|
||||
def test_rsplit_unicodewhitespace(self):
|
||||
b = self.type2test(b"\x09\x0A\x0B\x0C\x0D\x1C\x1D\x1E\x1F")
|
||||
self.assertEqual(b.split(), [b'\x1c\x1d\x1e\x1f'])
|
||||
self.assertEqual(b.rsplit(), [b'\x1c\x1d\x1e\x1f'])
|
||||
|
||||
def test_partition(self):
|
||||
b = self.type2test(b'mississippi')
|
||||
self.assertEqual(b.partition(b'ss'), (b'mi', b'ss', b'issippi'))
|
||||
self.assertEqual(b.rpartition(b'w'), (b'', b'', b'mississippi'))
|
||||
|
||||
def test_rpartition(self):
|
||||
b = self.type2test(b'mississippi')
|
||||
self.assertEqual(b.rpartition(b'ss'), (b'missi', b'ss', b'ippi'))
|
||||
self.assertEqual(b.rpartition(b'i'), (b'mississipp', b'i', b''))
|
||||
|
||||
def test_pickling(self):
|
||||
for proto in range(pickle.HIGHEST_PROTOCOL):
|
||||
for b in b"", b"a", b"abc", b"\xffab\x80", b"\0\0\377\0\0":
|
||||
b = self.type2test(b)
|
||||
ps = pickle.dumps(b, proto)
|
||||
q = pickle.loads(ps)
|
||||
self.assertEqual(b, q)
|
||||
|
||||
def test_strip(self):
|
||||
b = self.type2test(b'mississippi')
|
||||
self.assertEqual(b.strip(b'i'), b'mississipp')
|
||||
self.assertEqual(b.strip(b'm'), b'ississippi')
|
||||
self.assertEqual(b.strip(b'pi'), b'mississ')
|
||||
self.assertEqual(b.strip(b'im'), b'ssissipp')
|
||||
self.assertEqual(b.strip(b'pim'), b'ssiss')
|
||||
self.assertEqual(b.strip(b), b'')
|
||||
|
||||
def test_lstrip(self):
|
||||
b = self.type2test(b'mississippi')
|
||||
self.assertEqual(b.lstrip(b'i'), b'mississippi')
|
||||
self.assertEqual(b.lstrip(b'm'), b'ississippi')
|
||||
self.assertEqual(b.lstrip(b'pi'), b'mississippi')
|
||||
self.assertEqual(b.lstrip(b'im'), b'ssissippi')
|
||||
self.assertEqual(b.lstrip(b'pim'), b'ssissippi')
|
||||
|
||||
def test_rstrip(self):
|
||||
b = self.type2test(b'mississippi')
|
||||
self.assertEqual(b.rstrip(b'i'), b'mississipp')
|
||||
self.assertEqual(b.rstrip(b'm'), b'mississippi')
|
||||
self.assertEqual(b.rstrip(b'pi'), b'mississ')
|
||||
self.assertEqual(b.rstrip(b'im'), b'mississipp')
|
||||
self.assertEqual(b.rstrip(b'pim'), b'mississ')
|
||||
|
||||
def test_strip_whitespace(self):
|
||||
b = self.type2test(b' \t\n\r\f\vabc \t\n\r\f\v')
|
||||
self.assertEqual(b.strip(), b'abc')
|
||||
self.assertEqual(b.lstrip(), b'abc \t\n\r\f\v')
|
||||
self.assertEqual(b.rstrip(), b' \t\n\r\f\vabc')
|
||||
|
||||
def XXXtest_strip_bytearray(self):
|
||||
# XXX memoryview not available
|
||||
self.assertEqual(self.type2test(b'abc').strip(memoryview(b'ac')), b'b')
|
||||
self.assertEqual(self.type2test(b'abc').lstrip(memoryview(b'ac')), b'bc')
|
||||
self.assertEqual(self.type2test(b'abc').rstrip(memoryview(b'ac')), b'ab')
|
||||
|
||||
def test_strip_string_error(self):
|
||||
self.assertRaises(TypeError, self.type2test(b'abc').strip, u'b')
|
||||
self.assertRaises(TypeError, self.type2test(b'abc').lstrip, u'b')
|
||||
self.assertRaises(TypeError, self.type2test(b'abc').rstrip, u'b')
|
||||
|
||||
def test_ord(self):
|
||||
b = self.type2test(b'\0A\x7f\x80\xff')
|
||||
self.assertEqual([ord(b[i:i+1]) for i in range(len(b))],
|
||||
[0, 65, 127, 128, 255])
|
||||
|
||||
|
||||
class ByteArrayTest(BaseBytesTest):
|
||||
type2test = bytearray
|
||||
|
||||
def test_nohash(self):
|
||||
self.assertRaises(TypeError, hash, bytearray())
|
||||
|
||||
def test_bytearray_api(self):
|
||||
short_sample = b"Hello world\n"
|
||||
sample = short_sample + b"\0"*(20 - len(short_sample))
|
||||
tfn = tempfile.mktemp()
|
||||
try:
|
||||
# Prepare
|
||||
with open(tfn, "wb") as f:
|
||||
f.write(short_sample)
|
||||
# Test readinto
|
||||
with open(tfn, "rb") as f:
|
||||
b = bytearray(20)
|
||||
n = f.readinto(b)
|
||||
self.assertEqual(n, len(short_sample))
|
||||
# Python 2.x
|
||||
b_sample = (ord(s) for s in sample)
|
||||
self.assertEqual(list(b), list(b_sample))
|
||||
# Test writing in binary mode
|
||||
with open(tfn, "wb") as f:
|
||||
f.write(b)
|
||||
with open(tfn, "rb") as f:
|
||||
self.assertEqual(f.read(), sample)
|
||||
# Text mode is ambiguous; don't test
|
||||
finally:
|
||||
try:
|
||||
os.remove(tfn)
|
||||
except os.error:
|
||||
pass
|
||||
|
||||
def test_reverse(self):
|
||||
b = bytearray(b'hello')
|
||||
self.assertEqual(b.reverse(), None)
|
||||
self.assertEqual(b, b'olleh')
|
||||
b = bytearray(b'hello1') # test even number of items
|
||||
b.reverse()
|
||||
self.assertEqual(b, b'1olleh')
|
||||
b = bytearray()
|
||||
b.reverse()
|
||||
self.assertFalse(b)
|
||||
|
||||
def test_regexps(self):
|
||||
def by(s):
|
||||
return bytearray(map(ord, s))
|
||||
b = by("Hello, world")
|
||||
self.assertEqual(re.findall(r"\w+", b), [by("Hello"), by("world")])
|
||||
|
||||
def test_setitem(self):
|
||||
b = bytearray([1, 2, 3])
|
||||
b[1] = 100
|
||||
self.assertEqual(b, bytearray([1, 100, 3]))
|
||||
b[-1] = 200
|
||||
self.assertEqual(b, bytearray([1, 100, 200]))
|
||||
class C:
|
||||
def __init__(self, i=0):
|
||||
self.i = i
|
||||
def __index__(self):
|
||||
return self.i
|
||||
b[0] = C(10)
|
||||
self.assertEqual(b, bytearray([10, 100, 200]))
|
||||
try:
|
||||
b[3] = 0
|
||||
self.fail("Didn't raise IndexError")
|
||||
except IndexError:
|
||||
pass
|
||||
try:
|
||||
b[-10] = 0
|
||||
self.fail("Didn't raise IndexError")
|
||||
except IndexError:
|
||||
pass
|
||||
try:
|
||||
b[0] = 256
|
||||
self.fail("Didn't raise ValueError")
|
||||
except ValueError:
|
||||
pass
|
||||
try:
|
||||
b[0] = C(-1)
|
||||
self.fail("Didn't raise ValueError")
|
||||
except ValueError:
|
||||
pass
|
||||
try:
|
||||
b[0] = None
|
||||
self.fail("Didn't raise TypeError")
|
||||
except TypeError:
|
||||
pass
|
||||
|
||||
def test_delitem(self):
|
||||
b = bytearray(range(10))
|
||||
del b[0]
|
||||
self.assertEqual(b, bytearray(range(1, 10)))
|
||||
del b[-1]
|
||||
self.assertEqual(b, bytearray(range(1, 9)))
|
||||
del b[4]
|
||||
self.assertEqual(b, bytearray([1, 2, 3, 4, 6, 7, 8]))
|
||||
|
||||
def test_setslice(self):
|
||||
b = bytearray(range(10))
|
||||
self.assertEqual(list(b), list(range(10)))
|
||||
|
||||
b[0:5] = bytearray([1, 1, 1, 1, 1])
|
||||
self.assertEqual(b, bytearray([1, 1, 1, 1, 1, 5, 6, 7, 8, 9]))
|
||||
|
||||
del b[0:-5]
|
||||
self.assertEqual(b, bytearray([5, 6, 7, 8, 9]))
|
||||
|
||||
b[0:0] = bytearray([0, 1, 2, 3, 4])
|
||||
self.assertEqual(b, bytearray(range(10)))
|
||||
|
||||
b[-7:-3] = bytearray([100, 101])
|
||||
self.assertEqual(b, bytearray([0, 1, 2, 100, 101, 7, 8, 9]))
|
||||
|
||||
b[3:5] = [3, 4, 5, 6]
|
||||
self.assertEqual(b, bytearray(range(10)))
|
||||
|
||||
b[3:0] = [42, 42, 42]
|
||||
self.assertEqual(b, bytearray([0, 1, 2, 42, 42, 42, 3, 4, 5, 6, 7, 8, 9]))
|
||||
|
||||
def test_extended_set_del_slice(self):
|
||||
indices = (0, None, 1, 3, 19, 300, -1, -2, -31, -300)
|
||||
for start in indices:
|
||||
for stop in indices:
|
||||
# Skip invalid step 0
|
||||
for step in indices[1:]:
|
||||
L = list(range(255))
|
||||
b = bytearray(L)
|
||||
# Make sure we have a slice of exactly the right length,
|
||||
# but with different data.
|
||||
data = L[start:stop:step]
|
||||
data.reverse()
|
||||
L[start:stop:step] = data
|
||||
b[start:stop:step] = data
|
||||
self.assertEquals(b, bytearray(L))
|
||||
|
||||
del L[start:stop:step]
|
||||
del b[start:stop:step]
|
||||
self.assertEquals(b, bytearray(L))
|
||||
|
||||
def test_setslice_trap(self):
|
||||
# This test verifies that we correctly handle assigning self
|
||||
# to a slice of self (the old Lambert Meertens trap).
|
||||
b = bytearray(range(256))
|
||||
b[8:] = b
|
||||
self.assertEqual(b, bytearray(list(range(8)) + list(range(256))))
|
||||
|
||||
def test_iconcat(self):
|
||||
b = bytearray(b"abc")
|
||||
b1 = b
|
||||
b += b"def"
|
||||
self.assertEqual(b, b"abcdef")
|
||||
self.assertEqual(b, b1)
|
||||
self.failUnless(b is b1)
|
||||
b += b"xyz"
|
||||
self.assertEqual(b, b"abcdefxyz")
|
||||
try:
|
||||
b += u""
|
||||
except TypeError:
|
||||
pass
|
||||
else:
|
||||
self.fail("bytes += unicode didn't raise TypeError")
|
||||
|
||||
def test_irepeat(self):
|
||||
b = bytearray(b"abc")
|
||||
b1 = b
|
||||
b *= 3
|
||||
self.assertEqual(b, b"abcabcabc")
|
||||
self.assertEqual(b, b1)
|
||||
self.failUnless(b is b1)
|
||||
|
||||
def test_irepeat_1char(self):
|
||||
b = bytearray(b"x")
|
||||
b1 = b
|
||||
b *= 100
|
||||
self.assertEqual(b, b"x"*100)
|
||||
self.assertEqual(b, b1)
|
||||
self.failUnless(b is b1)
|
||||
|
||||
def test_alloc(self):
|
||||
b = bytearray()
|
||||
alloc = b.__alloc__()
|
||||
self.assert_(alloc >= 0)
|
||||
seq = [alloc]
|
||||
for i in range(100):
|
||||
b += b"x"
|
||||
alloc = b.__alloc__()
|
||||
self.assert_(alloc >= len(b))
|
||||
if alloc not in seq:
|
||||
seq.append(alloc)
|
||||
|
||||
def test_extend(self):
|
||||
orig = b'hello'
|
||||
a = bytearray(orig)
|
||||
a.extend(a)
|
||||
self.assertEqual(a, orig + orig)
|
||||
self.assertEqual(a[5:], orig)
|
||||
a = bytearray(b'')
|
||||
# Test iterators that don't have a __length_hint__
|
||||
a.extend(map(ord, orig * 25))
|
||||
a.extend(ord(x) for x in orig * 25)
|
||||
self.assertEqual(a, orig * 50)
|
||||
self.assertEqual(a[-5:], orig)
|
||||
a = bytearray(b'')
|
||||
a.extend(iter(map(ord, orig * 50)))
|
||||
self.assertEqual(a, orig * 50)
|
||||
self.assertEqual(a[-5:], orig)
|
||||
a = bytearray(b'')
|
||||
a.extend(list(map(ord, orig * 50)))
|
||||
self.assertEqual(a, orig * 50)
|
||||
self.assertEqual(a[-5:], orig)
|
||||
a = bytearray(b'')
|
||||
self.assertRaises(ValueError, a.extend, [0, 1, 2, 256])
|
||||
self.assertRaises(ValueError, a.extend, [0, 1, 2, -1])
|
||||
self.assertEqual(len(a), 0)
|
||||
|
||||
def test_remove(self):
|
||||
b = bytearray(b'hello')
|
||||
b.remove(ord('l'))
|
||||
self.assertEqual(b, b'helo')
|
||||
b.remove(ord('l'))
|
||||
self.assertEqual(b, b'heo')
|
||||
self.assertRaises(ValueError, lambda: b.remove(ord('l')))
|
||||
self.assertRaises(ValueError, lambda: b.remove(400))
|
||||
self.assertRaises(TypeError, lambda: b.remove(u'e'))
|
||||
# remove first and last
|
||||
b.remove(ord('o'))
|
||||
b.remove(ord('h'))
|
||||
self.assertEqual(b, b'e')
|
||||
self.assertRaises(TypeError, lambda: b.remove(u'e'))
|
||||
|
||||
def test_pop(self):
|
||||
b = bytearray(b'world')
|
||||
self.assertEqual(b.pop(), ord('d'))
|
||||
self.assertEqual(b.pop(0), ord('w'))
|
||||
self.assertEqual(b.pop(-2), ord('r'))
|
||||
self.assertRaises(IndexError, lambda: b.pop(10))
|
||||
self.assertRaises(OverflowError, lambda: bytearray().pop())
|
||||
|
||||
def test_nosort(self):
|
||||
self.assertRaises(AttributeError, lambda: bytearray().sort())
|
||||
|
||||
def test_append(self):
|
||||
b = bytearray(b'hell')
|
||||
b.append(ord('o'))
|
||||
self.assertEqual(b, b'hello')
|
||||
self.assertEqual(b.append(100), None)
|
||||
b = bytearray()
|
||||
b.append(ord('A'))
|
||||
self.assertEqual(len(b), 1)
|
||||
self.assertRaises(TypeError, lambda: b.append(u'o'))
|
||||
|
||||
def test_insert(self):
|
||||
b = bytearray(b'msssspp')
|
||||
b.insert(1, ord('i'))
|
||||
b.insert(4, ord('i'))
|
||||
b.insert(-2, ord('i'))
|
||||
b.insert(1000, ord('i'))
|
||||
self.assertEqual(b, b'mississippi')
|
||||
self.assertRaises(TypeError, lambda: b.insert(0, b'1'))
|
||||
|
||||
def test_partition_bytearray_doesnt_share_nullstring(self):
|
||||
a, b, c = bytearray(b"x").partition(b"y")
|
||||
self.assertEqual(b, b"")
|
||||
self.assertEqual(c, b"")
|
||||
self.assert_(b is not c)
|
||||
b += b"!"
|
||||
self.assertEqual(c, b"")
|
||||
a, b, c = bytearray(b"x").partition(b"y")
|
||||
self.assertEqual(b, b"")
|
||||
self.assertEqual(c, b"")
|
||||
# Same for rpartition
|
||||
b, c, a = bytearray(b"x").rpartition(b"y")
|
||||
self.assertEqual(b, b"")
|
||||
self.assertEqual(c, b"")
|
||||
self.assert_(b is not c)
|
||||
b += b"!"
|
||||
self.assertEqual(c, b"")
|
||||
c, b, a = bytearray(b"x").rpartition(b"y")
|
||||
self.assertEqual(b, b"")
|
||||
self.assertEqual(c, b"")
|
||||
|
||||
|
||||
class AssortedBytesTest(unittest.TestCase):
|
||||
#
|
||||
# Test various combinations of bytes and bytearray
|
||||
#
|
||||
|
||||
def setUp(self):
|
||||
self.warning_filters = warnings.filters[:]
|
||||
|
||||
def tearDown(self):
|
||||
warnings.filters = self.warning_filters
|
||||
|
||||
def test_repr_str(self):
|
||||
warnings.simplefilter('ignore', BytesWarning)
|
||||
for f in str, repr:
|
||||
self.assertEqual(f(bytearray()), "bytearray(b'')")
|
||||
self.assertEqual(f(bytearray([0])), "bytearray(b'\\x00')")
|
||||
self.assertEqual(f(bytearray([0, 1, 254, 255])),
|
||||
"bytearray(b'\\x00\\x01\\xfe\\xff')")
|
||||
self.assertEqual(f(b"abc"), "b'abc'")
|
||||
self.assertEqual(f(b"'"), '''b"'"''') # '''
|
||||
self.assertEqual(f(b"'\""), r"""b'\'"'""") # '
|
||||
|
||||
def test_compare_bytes_to_bytearray(self):
|
||||
self.assertEqual(b"abc" == bytes(b"abc"), True)
|
||||
self.assertEqual(b"ab" != bytes(b"abc"), True)
|
||||
self.assertEqual(b"ab" <= bytes(b"abc"), True)
|
||||
self.assertEqual(b"ab" < bytes(b"abc"), True)
|
||||
self.assertEqual(b"abc" >= bytes(b"ab"), True)
|
||||
self.assertEqual(b"abc" > bytes(b"ab"), True)
|
||||
|
||||
self.assertEqual(b"abc" != bytes(b"abc"), False)
|
||||
self.assertEqual(b"ab" == bytes(b"abc"), False)
|
||||
self.assertEqual(b"ab" > bytes(b"abc"), False)
|
||||
self.assertEqual(b"ab" >= bytes(b"abc"), False)
|
||||
self.assertEqual(b"abc" < bytes(b"ab"), False)
|
||||
self.assertEqual(b"abc" <= bytes(b"ab"), False)
|
||||
|
||||
self.assertEqual(bytes(b"abc") == b"abc", True)
|
||||
self.assertEqual(bytes(b"ab") != b"abc", True)
|
||||
self.assertEqual(bytes(b"ab") <= b"abc", True)
|
||||
self.assertEqual(bytes(b"ab") < b"abc", True)
|
||||
self.assertEqual(bytes(b"abc") >= b"ab", True)
|
||||
self.assertEqual(bytes(b"abc") > b"ab", True)
|
||||
|
||||
self.assertEqual(bytes(b"abc") != b"abc", False)
|
||||
self.assertEqual(bytes(b"ab") == b"abc", False)
|
||||
self.assertEqual(bytes(b"ab") > b"abc", False)
|
||||
self.assertEqual(bytes(b"ab") >= b"abc", False)
|
||||
self.assertEqual(bytes(b"abc") < b"ab", False)
|
||||
self.assertEqual(bytes(b"abc") <= b"ab", False)
|
||||
|
||||
def test_doc(self):
|
||||
self.failUnless(bytearray.__doc__ != None)
|
||||
self.failUnless(bytearray.__doc__.startswith("bytearray("), bytearray.__doc__)
|
||||
self.failUnless(bytes.__doc__ != None)
|
||||
self.failUnless(bytes.__doc__.startswith("bytes("), bytes.__doc__)
|
||||
|
||||
def test_from_bytearray(self):
|
||||
sample = bytes(b"Hello world\n\x80\x81\xfe\xff")
|
||||
buf = memoryview(sample)
|
||||
b = bytearray(buf)
|
||||
self.assertEqual(b, bytearray(sample))
|
||||
|
||||
def test_to_str(self):
|
||||
warnings.simplefilter('ignore', BytesWarning)
|
||||
self.assertEqual(str(b''), "b''")
|
||||
self.assertEqual(str(b'x'), "b'x'")
|
||||
self.assertEqual(str(b'\x80'), "b'\\x80'")
|
||||
self.assertEqual(str(bytearray(b'')), "bytearray(b'')")
|
||||
self.assertEqual(str(bytearray(b'x')), "bytearray(b'x')")
|
||||
self.assertEqual(str(bytearray(b'\x80')), "bytearray(b'\\x80')")
|
||||
|
||||
def test_literal(self):
|
||||
tests = [
|
||||
(b"Wonderful spam", "Wonderful spam"),
|
||||
(br"Wonderful spam too", "Wonderful spam too"),
|
||||
(b"\xaa\x00\000\200", "\xaa\x00\000\200"),
|
||||
(br"\xaa\x00\000\200", r"\xaa\x00\000\200"),
|
||||
]
|
||||
for b, s in tests:
|
||||
self.assertEqual(b, bytearray(s, 'latin-1'))
|
||||
for c in range(128, 256):
|
||||
self.assertRaises(SyntaxError, eval,
|
||||
'b"%s"' % chr(c))
|
||||
|
||||
def test_translate(self):
|
||||
b = b'hello'
|
||||
rosetta = bytearray(range(0, 256))
|
||||
rosetta[ord('o')] = ord('e')
|
||||
c = b.translate(rosetta, b'l')
|
||||
self.assertEqual(b, b'hello')
|
||||
self.assertEqual(c, b'hee')
|
||||
|
||||
def test_split_bytearray(self):
|
||||
self.assertEqual(b'a b'.split(memoryview(b' ')), [b'a', b'b'])
|
||||
|
||||
def test_rsplit_bytearray(self):
|
||||
self.assertEqual(b'a b'.rsplit(memoryview(b' ')), [b'a', b'b'])
|
||||
|
||||
# Optimizations:
|
||||
# __iter__? (optimization)
|
||||
# __reversed__? (optimization)
|
||||
|
||||
# XXX More string methods? (Those that don't use character properties)
|
||||
|
||||
# There are tests in string_tests.py that are more
|
||||
# comprehensive for things like split, partition, etc.
|
||||
# Unfortunately they are all bundled with tests that
|
||||
# are not appropriate for bytes
|
||||
|
||||
# I've started porting some of those into bytearray_tests.py, we should port
|
||||
# the rest that make sense (the code can be cleaned up to use modern
|
||||
# unittest methods at the same time).
|
||||
|
||||
class BytearrayPEP3137Test(unittest.TestCase,
|
||||
test.buffer_tests.MixinBytesBufferCommonTests):
|
||||
def marshal(self, x):
|
||||
return bytearray(x)
|
||||
|
||||
def test_returns_new_copy(self):
|
||||
val = self.marshal(b'1234')
|
||||
# On immutable types these MAY return a reference to themselves
|
||||
# but on mutable types like bytearray they MUST return a new copy.
|
||||
for methname in ('zfill', 'rjust', 'ljust', 'center'):
|
||||
method = getattr(val, methname)
|
||||
newval = method(3)
|
||||
self.assertEqual(val, newval)
|
||||
self.assertTrue(val is not newval,
|
||||
methname+' returned self on a mutable object')
|
||||
|
||||
|
||||
class FixedStringTest(test.string_tests.BaseTest):
|
||||
|
||||
def fixtype(self, obj):
|
||||
if isinstance(obj, str):
|
||||
return obj.encode("utf-8")
|
||||
return super(FixedStringTest, self).fixtype(obj)
|
||||
|
||||
# Currently the bytes containment testing uses a single integer
|
||||
# value. This may not be the final design, but until then the
|
||||
# bytes section with in a bytes containment not valid
|
||||
def test_contains(self):
|
||||
pass
|
||||
def test_expandtabs(self):
|
||||
pass
|
||||
def test_upper(self):
|
||||
pass
|
||||
def test_lower(self):
|
||||
pass
|
||||
def test_hash(self):
|
||||
# XXX check this out
|
||||
pass
|
||||
|
||||
|
||||
class ByteArrayAsStringTest(FixedStringTest):
|
||||
type2test = bytearray
|
||||
|
||||
|
||||
class ByteArraySubclass(bytearray):
|
||||
pass
|
||||
|
||||
class ByteArraySubclassTest(unittest.TestCase):
|
||||
|
||||
def test_basic(self):
|
||||
self.assert_(issubclass(ByteArraySubclass, bytearray))
|
||||
self.assert_(isinstance(ByteArraySubclass(), bytearray))
|
||||
|
||||
a, b = b"abcd", b"efgh"
|
||||
_a, _b = ByteArraySubclass(a), ByteArraySubclass(b)
|
||||
|
||||
# test comparison operators with subclass instances
|
||||
self.assert_(_a == _a)
|
||||
self.assert_(_a != _b)
|
||||
self.assert_(_a < _b)
|
||||
self.assert_(_a <= _b)
|
||||
self.assert_(_b >= _a)
|
||||
self.assert_(_b > _a)
|
||||
self.assert_(_a is not a)
|
||||
|
||||
# test concat of subclass instances
|
||||
self.assertEqual(a + b, _a + _b)
|
||||
self.assertEqual(a + b, a + _b)
|
||||
self.assertEqual(a + b, _a + b)
|
||||
|
||||
# test repeat
|
||||
self.assert_(a*5 == _a*5)
|
||||
|
||||
def test_join(self):
|
||||
# Make sure join returns a NEW object for single item sequences
|
||||
# involving a subclass.
|
||||
# Make sure that it is of the appropriate type.
|
||||
s1 = ByteArraySubclass(b"abcd")
|
||||
s2 = bytearray().join([s1])
|
||||
self.assert_(s1 is not s2)
|
||||
self.assert_(type(s2) is bytearray, type(s2))
|
||||
|
||||
# Test reverse, calling join on subclass
|
||||
s3 = s1.join([b"abcd"])
|
||||
self.assert_(type(s3) is bytearray)
|
||||
|
||||
def test_pickle(self):
|
||||
a = ByteArraySubclass(b"abcd")
|
||||
a.x = 10
|
||||
a.y = ByteArraySubclass(b"efgh")
|
||||
for proto in range(pickle.HIGHEST_PROTOCOL):
|
||||
b = pickle.loads(pickle.dumps(a, proto))
|
||||
self.assertNotEqual(id(a), id(b))
|
||||
self.assertEqual(a, b)
|
||||
self.assertEqual(a.x, b.x)
|
||||
self.assertEqual(a.y, b.y)
|
||||
self.assertEqual(type(a), type(b))
|
||||
self.assertEqual(type(a.y), type(b.y))
|
||||
|
||||
def test_copy(self):
|
||||
a = ByteArraySubclass(b"abcd")
|
||||
a.x = 10
|
||||
a.y = ByteArraySubclass(b"efgh")
|
||||
for copy_method in (copy.copy, copy.deepcopy):
|
||||
b = copy_method(a)
|
||||
self.assertNotEqual(id(a), id(b))
|
||||
self.assertEqual(a, b)
|
||||
self.assertEqual(a.x, b.x)
|
||||
self.assertEqual(a.y, b.y)
|
||||
self.assertEqual(type(a), type(b))
|
||||
self.assertEqual(type(a.y), type(b.y))
|
||||
|
||||
def test_init_override(self):
|
||||
class subclass(bytearray):
|
||||
def __init__(self, newarg=1, *args, **kwargs):
|
||||
bytearray.__init__(self, *args, **kwargs)
|
||||
x = subclass(4, source=b"abcd")
|
||||
self.assertEqual(x, b"abcd")
|
||||
x = subclass(newarg=4, source=b"abcd")
|
||||
self.assertEqual(x, b"abcd")
|
||||
|
||||
def test_main():
|
||||
#test.test_support.run_unittest(BytesTest)
|
||||
#test.test_support.run_unittest(AssortedBytesTest)
|
||||
#test.test_support.run_unittest(BytesAsStringTest)
|
||||
test.test_support.run_unittest(
|
||||
ByteArrayTest,
|
||||
ByteArrayAsStringTest,
|
||||
ByteArraySubclassTest,
|
||||
BytearrayPEP3137Test)
|
||||
|
||||
if __name__ == "__main__":
|
||||
test_main()
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -9,10 +9,10 @@ import unittest
|
|||
from test import test_support
|
||||
|
||||
import sys
|
||||
try:
|
||||
if sys.version_info[0] == 3:
|
||||
# 3.x
|
||||
from io import StringIO
|
||||
except ImportError:
|
||||
else:
|
||||
# 2.x
|
||||
from StringIO import StringIO
|
||||
|
||||
|
|
|
|||
|
|
@ -295,6 +295,8 @@ OBJECT_OBJS= \
|
|||
Objects/abstract.o \
|
||||
Objects/boolobject.o \
|
||||
Objects/bufferobject.o \
|
||||
Objects/bytes_methods.o \
|
||||
Objects/bytesobject.o \
|
||||
Objects/cellobject.o \
|
||||
Objects/classobject.o \
|
||||
Objects/cobject.o \
|
||||
|
|
@ -518,13 +520,16 @@ Objects/unicodectype.o: $(srcdir)/Objects/unicodectype.c \
|
|||
$(srcdir)/Objects/unicodetype_db.h
|
||||
|
||||
STRINGLIB_HEADERS= \
|
||||
$(srcdir)/Include/bytes_methods.h \
|
||||
$(srcdir)/Objects/stringlib/count.h \
|
||||
$(srcdir)/Objects/stringlib/ctype.h \
|
||||
$(srcdir)/Objects/stringlib/fastsearch.h \
|
||||
$(srcdir)/Objects/stringlib/find.h \
|
||||
$(srcdir)/Objects/stringlib/formatter.h \
|
||||
$(srcdir)/Objects/stringlib/partition.h \
|
||||
$(srcdir)/Objects/stringlib/stringdefs.h \
|
||||
$(srcdir)/Objects/stringlib/string_format.h \
|
||||
$(srcdir)/Objects/stringlib/transmogrify.h \
|
||||
$(srcdir)/Objects/stringlib/unicodedefs.h
|
||||
|
||||
Objects/unicodeobject.o: $(srcdir)/Objects/unicodeobject.c \
|
||||
|
|
@ -532,6 +537,8 @@ Objects/unicodeobject.o: $(srcdir)/Objects/unicodeobject.c \
|
|||
|
||||
Objects/stringobject.o: $(srcdir)/Objects/stringobject.c \
|
||||
$(STRINGLIB_HEADERS)
|
||||
Objects/bytesobject.o: $(srcdir)/Objects/bytesobject.c \
|
||||
$(STRINGLIB_HEADERS)
|
||||
|
||||
Python/formatter_unicode.o: $(srcdir)/Python/formatter_unicode.c \
|
||||
$(STRINGLIB_HEADERS)
|
||||
|
|
@ -550,6 +557,8 @@ PYTHON_HEADERS= \
|
|||
Include/ast.h \
|
||||
Include/bitset.h \
|
||||
Include/boolobject.h \
|
||||
Include/bytes_methods.h \
|
||||
Include/bytesobject.h \
|
||||
Include/bufferobject.h \
|
||||
Include/cellobject.h \
|
||||
Include/ceval.h \
|
||||
|
|
|
|||
|
|
@ -40,7 +40,7 @@ static char **orig_argv;
|
|||
static int orig_argc;
|
||||
|
||||
/* command line options */
|
||||
#define BASE_OPTS "3Bc:dEhim:OQ:StuUvVW:xX?"
|
||||
#define BASE_OPTS "3bBc:dEhim:OQ:StuUvVW:xX?"
|
||||
|
||||
#ifndef RISCOS
|
||||
#define PROGRAM_OPTS BASE_OPTS
|
||||
|
|
@ -296,6 +296,9 @@ Py_Main(int argc, char **argv)
|
|||
}
|
||||
|
||||
switch (c) {
|
||||
case 'b':
|
||||
Py_BytesWarningFlag++;
|
||||
break;
|
||||
|
||||
case 'd':
|
||||
Py_DebugFlag++;
|
||||
|
|
|
|||
|
|
@ -0,0 +1,610 @@
|
|||
#include "Python.h"
|
||||
#include "bytes_methods.h"
|
||||
|
||||
/* Our own locale-independent ctype.h-like macros */
|
||||
|
||||
const unsigned int _Py_ctype_table[256] = {
|
||||
0, /* 0x0 '\x00' */
|
||||
0, /* 0x1 '\x01' */
|
||||
0, /* 0x2 '\x02' */
|
||||
0, /* 0x3 '\x03' */
|
||||
0, /* 0x4 '\x04' */
|
||||
0, /* 0x5 '\x05' */
|
||||
0, /* 0x6 '\x06' */
|
||||
0, /* 0x7 '\x07' */
|
||||
0, /* 0x8 '\x08' */
|
||||
FLAG_SPACE, /* 0x9 '\t' */
|
||||
FLAG_SPACE, /* 0xa '\n' */
|
||||
FLAG_SPACE, /* 0xb '\v' */
|
||||
FLAG_SPACE, /* 0xc '\f' */
|
||||
FLAG_SPACE, /* 0xd '\r' */
|
||||
0, /* 0xe '\x0e' */
|
||||
0, /* 0xf '\x0f' */
|
||||
0, /* 0x10 '\x10' */
|
||||
0, /* 0x11 '\x11' */
|
||||
0, /* 0x12 '\x12' */
|
||||
0, /* 0x13 '\x13' */
|
||||
0, /* 0x14 '\x14' */
|
||||
0, /* 0x15 '\x15' */
|
||||
0, /* 0x16 '\x16' */
|
||||
0, /* 0x17 '\x17' */
|
||||
0, /* 0x18 '\x18' */
|
||||
0, /* 0x19 '\x19' */
|
||||
0, /* 0x1a '\x1a' */
|
||||
0, /* 0x1b '\x1b' */
|
||||
0, /* 0x1c '\x1c' */
|
||||
0, /* 0x1d '\x1d' */
|
||||
0, /* 0x1e '\x1e' */
|
||||
0, /* 0x1f '\x1f' */
|
||||
FLAG_SPACE, /* 0x20 ' ' */
|
||||
0, /* 0x21 '!' */
|
||||
0, /* 0x22 '"' */
|
||||
0, /* 0x23 '#' */
|
||||
0, /* 0x24 '$' */
|
||||
0, /* 0x25 '%' */
|
||||
0, /* 0x26 '&' */
|
||||
0, /* 0x27 "'" */
|
||||
0, /* 0x28 '(' */
|
||||
0, /* 0x29 ')' */
|
||||
0, /* 0x2a '*' */
|
||||
0, /* 0x2b '+' */
|
||||
0, /* 0x2c ',' */
|
||||
0, /* 0x2d '-' */
|
||||
0, /* 0x2e '.' */
|
||||
0, /* 0x2f '/' */
|
||||
FLAG_DIGIT|FLAG_XDIGIT, /* 0x30 '0' */
|
||||
FLAG_DIGIT|FLAG_XDIGIT, /* 0x31 '1' */
|
||||
FLAG_DIGIT|FLAG_XDIGIT, /* 0x32 '2' */
|
||||
FLAG_DIGIT|FLAG_XDIGIT, /* 0x33 '3' */
|
||||
FLAG_DIGIT|FLAG_XDIGIT, /* 0x34 '4' */
|
||||
FLAG_DIGIT|FLAG_XDIGIT, /* 0x35 '5' */
|
||||
FLAG_DIGIT|FLAG_XDIGIT, /* 0x36 '6' */
|
||||
FLAG_DIGIT|FLAG_XDIGIT, /* 0x37 '7' */
|
||||
FLAG_DIGIT|FLAG_XDIGIT, /* 0x38 '8' */
|
||||
FLAG_DIGIT|FLAG_XDIGIT, /* 0x39 '9' */
|
||||
0, /* 0x3a ':' */
|
||||
0, /* 0x3b ';' */
|
||||
0, /* 0x3c '<' */
|
||||
0, /* 0x3d '=' */
|
||||
0, /* 0x3e '>' */
|
||||
0, /* 0x3f '?' */
|
||||
0, /* 0x40 '@' */
|
||||
FLAG_UPPER|FLAG_XDIGIT, /* 0x41 'A' */
|
||||
FLAG_UPPER|FLAG_XDIGIT, /* 0x42 'B' */
|
||||
FLAG_UPPER|FLAG_XDIGIT, /* 0x43 'C' */
|
||||
FLAG_UPPER|FLAG_XDIGIT, /* 0x44 'D' */
|
||||
FLAG_UPPER|FLAG_XDIGIT, /* 0x45 'E' */
|
||||
FLAG_UPPER|FLAG_XDIGIT, /* 0x46 'F' */
|
||||
FLAG_UPPER, /* 0x47 'G' */
|
||||
FLAG_UPPER, /* 0x48 'H' */
|
||||
FLAG_UPPER, /* 0x49 'I' */
|
||||
FLAG_UPPER, /* 0x4a 'J' */
|
||||
FLAG_UPPER, /* 0x4b 'K' */
|
||||
FLAG_UPPER, /* 0x4c 'L' */
|
||||
FLAG_UPPER, /* 0x4d 'M' */
|
||||
FLAG_UPPER, /* 0x4e 'N' */
|
||||
FLAG_UPPER, /* 0x4f 'O' */
|
||||
FLAG_UPPER, /* 0x50 'P' */
|
||||
FLAG_UPPER, /* 0x51 'Q' */
|
||||
FLAG_UPPER, /* 0x52 'R' */
|
||||
FLAG_UPPER, /* 0x53 'S' */
|
||||
FLAG_UPPER, /* 0x54 'T' */
|
||||
FLAG_UPPER, /* 0x55 'U' */
|
||||
FLAG_UPPER, /* 0x56 'V' */
|
||||
FLAG_UPPER, /* 0x57 'W' */
|
||||
FLAG_UPPER, /* 0x58 'X' */
|
||||
FLAG_UPPER, /* 0x59 'Y' */
|
||||
FLAG_UPPER, /* 0x5a 'Z' */
|
||||
0, /* 0x5b '[' */
|
||||
0, /* 0x5c '\\' */
|
||||
0, /* 0x5d ']' */
|
||||
0, /* 0x5e '^' */
|
||||
0, /* 0x5f '_' */
|
||||
0, /* 0x60 '`' */
|
||||
FLAG_LOWER|FLAG_XDIGIT, /* 0x61 'a' */
|
||||
FLAG_LOWER|FLAG_XDIGIT, /* 0x62 'b' */
|
||||
FLAG_LOWER|FLAG_XDIGIT, /* 0x63 'c' */
|
||||
FLAG_LOWER|FLAG_XDIGIT, /* 0x64 'd' */
|
||||
FLAG_LOWER|FLAG_XDIGIT, /* 0x65 'e' */
|
||||
FLAG_LOWER|FLAG_XDIGIT, /* 0x66 'f' */
|
||||
FLAG_LOWER, /* 0x67 'g' */
|
||||
FLAG_LOWER, /* 0x68 'h' */
|
||||
FLAG_LOWER, /* 0x69 'i' */
|
||||
FLAG_LOWER, /* 0x6a 'j' */
|
||||
FLAG_LOWER, /* 0x6b 'k' */
|
||||
FLAG_LOWER, /* 0x6c 'l' */
|
||||
FLAG_LOWER, /* 0x6d 'm' */
|
||||
FLAG_LOWER, /* 0x6e 'n' */
|
||||
FLAG_LOWER, /* 0x6f 'o' */
|
||||
FLAG_LOWER, /* 0x70 'p' */
|
||||
FLAG_LOWER, /* 0x71 'q' */
|
||||
FLAG_LOWER, /* 0x72 'r' */
|
||||
FLAG_LOWER, /* 0x73 's' */
|
||||
FLAG_LOWER, /* 0x74 't' */
|
||||
FLAG_LOWER, /* 0x75 'u' */
|
||||
FLAG_LOWER, /* 0x76 'v' */
|
||||
FLAG_LOWER, /* 0x77 'w' */
|
||||
FLAG_LOWER, /* 0x78 'x' */
|
||||
FLAG_LOWER, /* 0x79 'y' */
|
||||
FLAG_LOWER, /* 0x7a 'z' */
|
||||
0, /* 0x7b '{' */
|
||||
0, /* 0x7c '|' */
|
||||
0, /* 0x7d '}' */
|
||||
0, /* 0x7e '~' */
|
||||
0, /* 0x7f '\x7f' */
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
};
|
||||
|
||||
|
||||
const unsigned char _Py_ctype_tolower[256] = {
|
||||
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
|
||||
0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
|
||||
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
|
||||
0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
|
||||
0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
|
||||
0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
|
||||
0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
|
||||
0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
|
||||
0x40, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
|
||||
0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
|
||||
0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
|
||||
0x78, 0x79, 0x7a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
|
||||
0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
|
||||
0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
|
||||
0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
|
||||
0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
|
||||
0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
|
||||
0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
|
||||
0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
|
||||
0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
|
||||
0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
|
||||
0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
|
||||
0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
|
||||
0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
|
||||
0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
|
||||
0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
|
||||
0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
|
||||
0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
|
||||
0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
|
||||
0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
|
||||
0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
|
||||
0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
|
||||
};
|
||||
|
||||
const unsigned char _Py_ctype_toupper[256] = {
|
||||
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
|
||||
0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
|
||||
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
|
||||
0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
|
||||
0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
|
||||
0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
|
||||
0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
|
||||
0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
|
||||
0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
|
||||
0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
|
||||
0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
|
||||
0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
|
||||
0x60, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
|
||||
0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
|
||||
0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
|
||||
0x58, 0x59, 0x5a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
|
||||
0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
|
||||
0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
|
||||
0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
|
||||
0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
|
||||
0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
|
||||
0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
|
||||
0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
|
||||
0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
|
||||
0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
|
||||
0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
|
||||
0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
|
||||
0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
|
||||
0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
|
||||
0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
|
||||
0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
|
||||
0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
|
||||
};
|
||||
|
||||
|
||||
PyDoc_STRVAR_shared(_Py_isspace__doc__,
|
||||
"B.isspace() -> bool\n\
|
||||
\n\
|
||||
Return True if all characters in B are whitespace\n\
|
||||
and there is at least one character in B, False otherwise.");
|
||||
|
||||
PyObject*
|
||||
_Py_bytes_isspace(const char *cptr, Py_ssize_t len)
|
||||
{
|
||||
register const unsigned char *p
|
||||
= (unsigned char *) cptr;
|
||||
register const unsigned char *e;
|
||||
|
||||
/* Shortcut for single character strings */
|
||||
if (len == 1 && ISSPACE(*p))
|
||||
Py_RETURN_TRUE;
|
||||
|
||||
/* Special case for empty strings */
|
||||
if (len == 0)
|
||||
Py_RETURN_FALSE;
|
||||
|
||||
e = p + len;
|
||||
for (; p < e; p++) {
|
||||
if (!ISSPACE(*p))
|
||||
Py_RETURN_FALSE;
|
||||
}
|
||||
Py_RETURN_TRUE;
|
||||
}
|
||||
|
||||
|
||||
PyDoc_STRVAR_shared(_Py_isalpha__doc__,
|
||||
"B.isalpha() -> bool\n\
|
||||
\n\
|
||||
Return True if all characters in B are alphabetic\n\
|
||||
and there is at least one character in B, False otherwise.");
|
||||
|
||||
PyObject*
|
||||
_Py_bytes_isalpha(const char *cptr, Py_ssize_t len)
|
||||
{
|
||||
register const unsigned char *p
|
||||
= (unsigned char *) cptr;
|
||||
register const unsigned char *e;
|
||||
|
||||
/* Shortcut for single character strings */
|
||||
if (len == 1 && ISALPHA(*p))
|
||||
Py_RETURN_TRUE;
|
||||
|
||||
/* Special case for empty strings */
|
||||
if (len == 0)
|
||||
Py_RETURN_FALSE;
|
||||
|
||||
e = p + len;
|
||||
for (; p < e; p++) {
|
||||
if (!ISALPHA(*p))
|
||||
Py_RETURN_FALSE;
|
||||
}
|
||||
Py_RETURN_TRUE;
|
||||
}
|
||||
|
||||
|
||||
PyDoc_STRVAR_shared(_Py_isalnum__doc__,
|
||||
"B.isalnum() -> bool\n\
|
||||
\n\
|
||||
Return True if all characters in B are alphanumeric\n\
|
||||
and there is at least one character in B, False otherwise.");
|
||||
|
||||
PyObject*
|
||||
_Py_bytes_isalnum(const char *cptr, Py_ssize_t len)
|
||||
{
|
||||
register const unsigned char *p
|
||||
= (unsigned char *) cptr;
|
||||
register const unsigned char *e;
|
||||
|
||||
/* Shortcut for single character strings */
|
||||
if (len == 1 && ISALNUM(*p))
|
||||
Py_RETURN_TRUE;
|
||||
|
||||
/* Special case for empty strings */
|
||||
if (len == 0)
|
||||
Py_RETURN_FALSE;
|
||||
|
||||
e = p + len;
|
||||
for (; p < e; p++) {
|
||||
if (!ISALNUM(*p))
|
||||
Py_RETURN_FALSE;
|
||||
}
|
||||
Py_RETURN_TRUE;
|
||||
}
|
||||
|
||||
|
||||
PyDoc_STRVAR_shared(_Py_isdigit__doc__,
|
||||
"B.isdigit() -> bool\n\
|
||||
\n\
|
||||
Return True if all characters in B are digits\n\
|
||||
and there is at least one character in B, False otherwise.");
|
||||
|
||||
PyObject*
|
||||
_Py_bytes_isdigit(const char *cptr, Py_ssize_t len)
|
||||
{
|
||||
register const unsigned char *p
|
||||
= (unsigned char *) cptr;
|
||||
register const unsigned char *e;
|
||||
|
||||
/* Shortcut for single character strings */
|
||||
if (len == 1 && ISDIGIT(*p))
|
||||
Py_RETURN_TRUE;
|
||||
|
||||
/* Special case for empty strings */
|
||||
if (len == 0)
|
||||
Py_RETURN_FALSE;
|
||||
|
||||
e = p + len;
|
||||
for (; p < e; p++) {
|
||||
if (!ISDIGIT(*p))
|
||||
Py_RETURN_FALSE;
|
||||
}
|
||||
Py_RETURN_TRUE;
|
||||
}
|
||||
|
||||
|
||||
PyDoc_STRVAR_shared(_Py_islower__doc__,
|
||||
"B.islower() -> bool\n\
|
||||
\n\
|
||||
Return True if all cased characters in B are lowercase and there is\n\
|
||||
at least one cased character in B, False otherwise.");
|
||||
|
||||
PyObject*
|
||||
_Py_bytes_islower(const char *cptr, Py_ssize_t len)
|
||||
{
|
||||
register const unsigned char *p
|
||||
= (unsigned char *) cptr;
|
||||
register const unsigned char *e;
|
||||
int cased;
|
||||
|
||||
/* Shortcut for single character strings */
|
||||
if (len == 1)
|
||||
return PyBool_FromLong(ISLOWER(*p));
|
||||
|
||||
/* Special case for empty strings */
|
||||
if (len == 0)
|
||||
Py_RETURN_FALSE;
|
||||
|
||||
e = p + len;
|
||||
cased = 0;
|
||||
for (; p < e; p++) {
|
||||
if (ISUPPER(*p))
|
||||
Py_RETURN_FALSE;
|
||||
else if (!cased && ISLOWER(*p))
|
||||
cased = 1;
|
||||
}
|
||||
return PyBool_FromLong(cased);
|
||||
}
|
||||
|
||||
|
||||
PyDoc_STRVAR_shared(_Py_isupper__doc__,
|
||||
"B.isupper() -> bool\n\
|
||||
\n\
|
||||
Return True if all cased characters in B are uppercase and there is\n\
|
||||
at least one cased character in B, False otherwise.");
|
||||
|
||||
PyObject*
|
||||
_Py_bytes_isupper(const char *cptr, Py_ssize_t len)
|
||||
{
|
||||
register const unsigned char *p
|
||||
= (unsigned char *) cptr;
|
||||
register const unsigned char *e;
|
||||
int cased;
|
||||
|
||||
/* Shortcut for single character strings */
|
||||
if (len == 1)
|
||||
return PyBool_FromLong(ISUPPER(*p));
|
||||
|
||||
/* Special case for empty strings */
|
||||
if (len == 0)
|
||||
Py_RETURN_FALSE;
|
||||
|
||||
e = p + len;
|
||||
cased = 0;
|
||||
for (; p < e; p++) {
|
||||
if (ISLOWER(*p))
|
||||
Py_RETURN_FALSE;
|
||||
else if (!cased && ISUPPER(*p))
|
||||
cased = 1;
|
||||
}
|
||||
return PyBool_FromLong(cased);
|
||||
}
|
||||
|
||||
|
||||
PyDoc_STRVAR_shared(_Py_istitle__doc__,
|
||||
"B.istitle() -> bool\n\
|
||||
\n\
|
||||
Return True if B is a titlecased string and there is at least one\n\
|
||||
character in B, i.e. uppercase characters may only follow uncased\n\
|
||||
characters and lowercase characters only cased ones. Return False\n\
|
||||
otherwise.");
|
||||
|
||||
PyObject*
|
||||
_Py_bytes_istitle(const char *cptr, Py_ssize_t len)
|
||||
{
|
||||
register const unsigned char *p
|
||||
= (unsigned char *) cptr;
|
||||
register const unsigned char *e;
|
||||
int cased, previous_is_cased;
|
||||
|
||||
/* Shortcut for single character strings */
|
||||
if (len == 1)
|
||||
return PyBool_FromLong(ISUPPER(*p));
|
||||
|
||||
/* Special case for empty strings */
|
||||
if (len == 0)
|
||||
Py_RETURN_FALSE;
|
||||
|
||||
e = p + len;
|
||||
cased = 0;
|
||||
previous_is_cased = 0;
|
||||
for (; p < e; p++) {
|
||||
register const unsigned char ch = *p;
|
||||
|
||||
if (ISUPPER(ch)) {
|
||||
if (previous_is_cased)
|
||||
Py_RETURN_FALSE;
|
||||
previous_is_cased = 1;
|
||||
cased = 1;
|
||||
}
|
||||
else if (ISLOWER(ch)) {
|
||||
if (!previous_is_cased)
|
||||
Py_RETURN_FALSE;
|
||||
previous_is_cased = 1;
|
||||
cased = 1;
|
||||
}
|
||||
else
|
||||
previous_is_cased = 0;
|
||||
}
|
||||
return PyBool_FromLong(cased);
|
||||
}
|
||||
|
||||
|
||||
PyDoc_STRVAR_shared(_Py_lower__doc__,
|
||||
"B.lower() -> copy of B\n\
|
||||
\n\
|
||||
Return a copy of B with all ASCII characters converted to lowercase.");
|
||||
|
||||
void
|
||||
_Py_bytes_lower(char *result, const char *cptr, Py_ssize_t len)
|
||||
{
|
||||
Py_ssize_t i;
|
||||
|
||||
/*
|
||||
newobj = PyString_FromStringAndSize(NULL, len);
|
||||
if (!newobj)
|
||||
return NULL;
|
||||
|
||||
s = PyString_AS_STRING(newobj);
|
||||
*/
|
||||
|
||||
Py_MEMCPY(result, cptr, len);
|
||||
|
||||
for (i = 0; i < len; i++) {
|
||||
int c = Py_CHARMASK(result[i]);
|
||||
if (ISUPPER(c))
|
||||
result[i] = TOLOWER(c);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
PyDoc_STRVAR_shared(_Py_upper__doc__,
|
||||
"B.upper() -> copy of B\n\
|
||||
\n\
|
||||
Return a copy of B with all ASCII characters converted to uppercase.");
|
||||
|
||||
void
|
||||
_Py_bytes_upper(char *result, const char *cptr, Py_ssize_t len)
|
||||
{
|
||||
Py_ssize_t i;
|
||||
|
||||
/*
|
||||
newobj = PyString_FromStringAndSize(NULL, len);
|
||||
if (!newobj)
|
||||
return NULL;
|
||||
|
||||
s = PyString_AS_STRING(newobj);
|
||||
*/
|
||||
|
||||
Py_MEMCPY(result, cptr, len);
|
||||
|
||||
for (i = 0; i < len; i++) {
|
||||
int c = Py_CHARMASK(result[i]);
|
||||
if (ISLOWER(c))
|
||||
result[i] = TOUPPER(c);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
PyDoc_STRVAR_shared(_Py_title__doc__,
|
||||
"B.title() -> copy of B\n\
|
||||
\n\
|
||||
Return a titlecased version of B, i.e. ASCII words start with uppercase\n\
|
||||
characters, all remaining cased characters have lowercase.");
|
||||
|
||||
void
|
||||
_Py_bytes_title(char *result, char *s, Py_ssize_t len)
|
||||
{
|
||||
Py_ssize_t i;
|
||||
int previous_is_cased = 0;
|
||||
|
||||
/*
|
||||
newobj = PyString_FromStringAndSize(NULL, len);
|
||||
if (newobj == NULL)
|
||||
return NULL;
|
||||
s_new = PyString_AsString(newobj);
|
||||
*/
|
||||
for (i = 0; i < len; i++) {
|
||||
int c = Py_CHARMASK(*s++);
|
||||
if (ISLOWER(c)) {
|
||||
if (!previous_is_cased)
|
||||
c = TOUPPER(c);
|
||||
previous_is_cased = 1;
|
||||
} else if (ISUPPER(c)) {
|
||||
if (previous_is_cased)
|
||||
c = TOLOWER(c);
|
||||
previous_is_cased = 1;
|
||||
} else
|
||||
previous_is_cased = 0;
|
||||
*result++ = c;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
PyDoc_STRVAR_shared(_Py_capitalize__doc__,
|
||||
"B.capitalize() -> copy of B\n\
|
||||
\n\
|
||||
Return a copy of B with only its first character capitalized (ASCII).");
|
||||
|
||||
void
|
||||
_Py_bytes_capitalize(char *result, char *s, Py_ssize_t len)
|
||||
{
|
||||
Py_ssize_t i;
|
||||
|
||||
/*
|
||||
newobj = PyString_FromStringAndSize(NULL, len);
|
||||
if (newobj == NULL)
|
||||
return NULL;
|
||||
s_new = PyString_AsString(newobj);
|
||||
*/
|
||||
if (0 < len) {
|
||||
int c = Py_CHARMASK(*s++);
|
||||
if (ISLOWER(c))
|
||||
*result = TOUPPER(c);
|
||||
else
|
||||
*result = c;
|
||||
result++;
|
||||
}
|
||||
for (i = 1; i < len; i++) {
|
||||
int c = Py_CHARMASK(*s++);
|
||||
if (ISUPPER(c))
|
||||
*result = TOLOWER(c);
|
||||
else
|
||||
*result = c;
|
||||
result++;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
PyDoc_STRVAR_shared(_Py_swapcase__doc__,
|
||||
"B.swapcase() -> copy of B\n\
|
||||
\n\
|
||||
Return a copy of B with uppercase ASCII characters converted\n\
|
||||
to lowercase ASCII and vice versa.");
|
||||
|
||||
void
|
||||
_Py_bytes_swapcase(char *result, char *s, Py_ssize_t len)
|
||||
{
|
||||
Py_ssize_t i;
|
||||
|
||||
/*
|
||||
newobj = PyString_FromStringAndSize(NULL, len);
|
||||
if (newobj == NULL)
|
||||
return NULL;
|
||||
s_new = PyString_AsString(newobj);
|
||||
*/
|
||||
for (i = 0; i < len; i++) {
|
||||
int c = Py_CHARMASK(*s++);
|
||||
if (ISLOWER(c)) {
|
||||
*result = TOUPPER(c);
|
||||
}
|
||||
else if (ISUPPER(c)) {
|
||||
*result = TOLOWER(c);
|
||||
}
|
||||
else
|
||||
*result = c;
|
||||
result++;
|
||||
}
|
||||
}
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -1923,6 +1923,12 @@ SimpleExtendsException(PyExc_Warning, UnicodeWarning,
|
|||
"Base class for warnings about Unicode related problems, mostly\n"
|
||||
"related to conversion problems.");
|
||||
|
||||
/*
|
||||
* BytesWarning extends Warning
|
||||
*/
|
||||
SimpleExtendsException(PyExc_Warning, BytesWarning,
|
||||
"Base class for warnings about bytes and buffer related problems, mostly\n"
|
||||
"related to conversion from str or comparing to str.");
|
||||
|
||||
/* Pre-computed MemoryError instance. Best to create this as early as
|
||||
* possible and not wait until a MemoryError is actually raised!
|
||||
|
|
@ -2031,6 +2037,7 @@ _PyExc_Init(void)
|
|||
PRE_INIT(FutureWarning)
|
||||
PRE_INIT(ImportWarning)
|
||||
PRE_INIT(UnicodeWarning)
|
||||
PRE_INIT(BytesWarning)
|
||||
|
||||
m = Py_InitModule4("exceptions", functions, exceptions_doc,
|
||||
(PyObject *)NULL, PYTHON_API_VERSION);
|
||||
|
|
@ -2097,6 +2104,7 @@ _PyExc_Init(void)
|
|||
POST_INIT(FutureWarning)
|
||||
POST_INIT(ImportWarning)
|
||||
POST_INIT(UnicodeWarning)
|
||||
POST_INIT(BytesWarning)
|
||||
|
||||
PyExc_MemoryErrorInst = BaseException_new(&_PyExc_MemoryError, NULL, NULL);
|
||||
if (!PyExc_MemoryErrorInst)
|
||||
|
|
|
|||
|
|
@ -1986,6 +1986,9 @@ _Py_ReadyTypes(void)
|
|||
if (PyType_Ready(&PyString_Type) < 0)
|
||||
Py_FatalError("Can't initialize 'str'");
|
||||
|
||||
if (PyType_Ready(&PyBytes_Type) < 0)
|
||||
Py_FatalError("Can't initialize 'bytes'");
|
||||
|
||||
if (PyType_Ready(&PyList_Type) < 0)
|
||||
Py_FatalError("Can't initialize 'list'");
|
||||
|
||||
|
|
|
|||
|
|
@ -0,0 +1,110 @@
|
|||
/* NOTE: this API is -ONLY- for use with single byte character strings. */
|
||||
/* Do not use it with Unicode. */
|
||||
|
||||
#include "bytes_methods.h"
|
||||
|
||||
static PyObject*
|
||||
stringlib_isspace(PyObject *self)
|
||||
{
|
||||
return _Py_bytes_isspace(STRINGLIB_STR(self), STRINGLIB_LEN(self));
|
||||
}
|
||||
|
||||
static PyObject*
|
||||
stringlib_isalpha(PyObject *self)
|
||||
{
|
||||
return _Py_bytes_isalpha(STRINGLIB_STR(self), STRINGLIB_LEN(self));
|
||||
}
|
||||
|
||||
static PyObject*
|
||||
stringlib_isalnum(PyObject *self)
|
||||
{
|
||||
return _Py_bytes_isalnum(STRINGLIB_STR(self), STRINGLIB_LEN(self));
|
||||
}
|
||||
|
||||
static PyObject*
|
||||
stringlib_isdigit(PyObject *self)
|
||||
{
|
||||
return _Py_bytes_isdigit(STRINGLIB_STR(self), STRINGLIB_LEN(self));
|
||||
}
|
||||
|
||||
static PyObject*
|
||||
stringlib_islower(PyObject *self)
|
||||
{
|
||||
return _Py_bytes_islower(STRINGLIB_STR(self), STRINGLIB_LEN(self));
|
||||
}
|
||||
|
||||
static PyObject*
|
||||
stringlib_isupper(PyObject *self)
|
||||
{
|
||||
return _Py_bytes_isupper(STRINGLIB_STR(self), STRINGLIB_LEN(self));
|
||||
}
|
||||
|
||||
static PyObject*
|
||||
stringlib_istitle(PyObject *self)
|
||||
{
|
||||
return _Py_bytes_istitle(STRINGLIB_STR(self), STRINGLIB_LEN(self));
|
||||
}
|
||||
|
||||
|
||||
/* functions that return a new object partially translated by ctype funcs: */
|
||||
|
||||
static PyObject*
|
||||
stringlib_lower(PyObject *self)
|
||||
{
|
||||
PyObject* newobj;
|
||||
newobj = STRINGLIB_NEW(NULL, STRINGLIB_LEN(self));
|
||||
if (!newobj)
|
||||
return NULL;
|
||||
_Py_bytes_lower(STRINGLIB_STR(newobj), STRINGLIB_STR(self),
|
||||
STRINGLIB_LEN(self));
|
||||
return newobj;
|
||||
}
|
||||
|
||||
static PyObject*
|
||||
stringlib_upper(PyObject *self)
|
||||
{
|
||||
PyObject* newobj;
|
||||
newobj = STRINGLIB_NEW(NULL, STRINGLIB_LEN(self));
|
||||
if (!newobj)
|
||||
return NULL;
|
||||
_Py_bytes_upper(STRINGLIB_STR(newobj), STRINGLIB_STR(self),
|
||||
STRINGLIB_LEN(self));
|
||||
return newobj;
|
||||
}
|
||||
|
||||
static PyObject*
|
||||
stringlib_title(PyObject *self)
|
||||
{
|
||||
PyObject* newobj;
|
||||
newobj = STRINGLIB_NEW(NULL, STRINGLIB_LEN(self));
|
||||
if (!newobj)
|
||||
return NULL;
|
||||
_Py_bytes_title(STRINGLIB_STR(newobj), STRINGLIB_STR(self),
|
||||
STRINGLIB_LEN(self));
|
||||
return newobj;
|
||||
}
|
||||
|
||||
static PyObject*
|
||||
stringlib_capitalize(PyObject *self)
|
||||
{
|
||||
PyObject* newobj;
|
||||
newobj = STRINGLIB_NEW(NULL, STRINGLIB_LEN(self));
|
||||
if (!newobj)
|
||||
return NULL;
|
||||
_Py_bytes_capitalize(STRINGLIB_STR(newobj), STRINGLIB_STR(self),
|
||||
STRINGLIB_LEN(self));
|
||||
return newobj;
|
||||
}
|
||||
|
||||
static PyObject*
|
||||
stringlib_swapcase(PyObject *self)
|
||||
{
|
||||
PyObject* newobj;
|
||||
newobj = STRINGLIB_NEW(NULL, STRINGLIB_LEN(self));
|
||||
if (!newobj)
|
||||
return NULL;
|
||||
_Py_bytes_swapcase(STRINGLIB_STR(newobj), STRINGLIB_STR(self),
|
||||
STRINGLIB_LEN(self));
|
||||
return newobj;
|
||||
}
|
||||
|
||||
|
|
@ -0,0 +1,362 @@
|
|||
/* NOTE: this API is -ONLY- for use with single byte character strings. */
|
||||
/* Do not use it with Unicode. */
|
||||
|
||||
#include "bytes_methods.h"
|
||||
|
||||
#ifndef STRINGLIB_MUTABLE
|
||||
#warning "STRINGLIB_MUTABLE not defined before #include, assuming 0"
|
||||
#define STRINGLIB_MUTABLE 0
|
||||
#endif
|
||||
|
||||
/* the more complicated methods. parts of these should be pulled out into the
|
||||
shared code in bytes_methods.c to cut down on duplicate code bloat. */
|
||||
|
||||
PyDoc_STRVAR(expandtabs__doc__,
|
||||
"B.expandtabs([tabsize]) -> copy of B\n\
|
||||
\n\
|
||||
Return a copy of B where all tab characters are expanded using spaces.\n\
|
||||
If tabsize is not given, a tab size of 8 characters is assumed.");
|
||||
|
||||
static PyObject*
|
||||
stringlib_expandtabs(PyObject *self, PyObject *args)
|
||||
{
|
||||
const char *e, *p;
|
||||
char *q;
|
||||
Py_ssize_t i, j, old_j;
|
||||
PyObject *u;
|
||||
int tabsize = 8;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "|i:expandtabs", &tabsize))
|
||||
return NULL;
|
||||
|
||||
/* First pass: determine size of output string */
|
||||
i = j = old_j = 0;
|
||||
e = STRINGLIB_STR(self) + STRINGLIB_LEN(self);
|
||||
for (p = STRINGLIB_STR(self); p < e; p++)
|
||||
if (*p == '\t') {
|
||||
if (tabsize > 0) {
|
||||
j += tabsize - (j % tabsize);
|
||||
/* XXX: this depends on a signed integer overflow to < 0 */
|
||||
/* C compilers, including gcc, do -NOT- guarantee this. */
|
||||
if (old_j > j) {
|
||||
PyErr_SetString(PyExc_OverflowError,
|
||||
"result is too long");
|
||||
return NULL;
|
||||
}
|
||||
old_j = j;
|
||||
}
|
||||
}
|
||||
else {
|
||||
j++;
|
||||
if (*p == '\n' || *p == '\r') {
|
||||
i += j;
|
||||
old_j = j = 0;
|
||||
/* XXX: this depends on a signed integer overflow to < 0 */
|
||||
/* C compilers, including gcc, do -NOT- guarantee this. */
|
||||
if (i < 0) {
|
||||
PyErr_SetString(PyExc_OverflowError,
|
||||
"result is too long");
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if ((i + j) < 0) {
|
||||
/* XXX: this depends on a signed integer overflow to < 0 */
|
||||
/* C compilers, including gcc, do -NOT- guarantee this. */
|
||||
PyErr_SetString(PyExc_OverflowError, "result is too long");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* Second pass: create output string and fill it */
|
||||
u = STRINGLIB_NEW(NULL, i + j);
|
||||
if (!u)
|
||||
return NULL;
|
||||
|
||||
j = 0;
|
||||
q = STRINGLIB_STR(u);
|
||||
|
||||
for (p = STRINGLIB_STR(self); p < e; p++)
|
||||
if (*p == '\t') {
|
||||
if (tabsize > 0) {
|
||||
i = tabsize - (j % tabsize);
|
||||
j += i;
|
||||
while (i--)
|
||||
*q++ = ' ';
|
||||
}
|
||||
}
|
||||
else {
|
||||
j++;
|
||||
*q++ = *p;
|
||||
if (*p == '\n' || *p == '\r')
|
||||
j = 0;
|
||||
}
|
||||
|
||||
return u;
|
||||
}
|
||||
|
||||
Py_LOCAL_INLINE(PyObject *)
|
||||
pad(PyObject *self, Py_ssize_t left, Py_ssize_t right, char fill)
|
||||
{
|
||||
PyObject *u;
|
||||
|
||||
if (left < 0)
|
||||
left = 0;
|
||||
if (right < 0)
|
||||
right = 0;
|
||||
|
||||
if (left == 0 && right == 0 && STRINGLIB_CHECK_EXACT(self)) {
|
||||
#if STRINGLIB_MUTABLE
|
||||
/* We're defined as returning a copy; If the object is mutable
|
||||
* that means we must make an identical copy. */
|
||||
return STRINGLIB_NEW(STRINGLIB_STR(self), STRINGLIB_LEN(self));
|
||||
#else
|
||||
Py_INCREF(self);
|
||||
return (PyObject *)self;
|
||||
#endif /* STRINGLIB_MUTABLE */
|
||||
}
|
||||
|
||||
u = STRINGLIB_NEW(NULL,
|
||||
left + STRINGLIB_LEN(self) + right);
|
||||
if (u) {
|
||||
if (left)
|
||||
memset(STRINGLIB_STR(u), fill, left);
|
||||
Py_MEMCPY(STRINGLIB_STR(u) + left,
|
||||
STRINGLIB_STR(self),
|
||||
STRINGLIB_LEN(self));
|
||||
if (right)
|
||||
memset(STRINGLIB_STR(u) + left + STRINGLIB_LEN(self),
|
||||
fill, right);
|
||||
}
|
||||
|
||||
return u;
|
||||
}
|
||||
|
||||
PyDoc_STRVAR(ljust__doc__,
|
||||
"B.ljust(width[, fillchar]) -> copy of B\n"
|
||||
"\n"
|
||||
"Return B left justified in a string of length width. Padding is\n"
|
||||
"done using the specified fill character (default is a space).");
|
||||
|
||||
static PyObject *
|
||||
stringlib_ljust(PyObject *self, PyObject *args)
|
||||
{
|
||||
Py_ssize_t width;
|
||||
char fillchar = ' ';
|
||||
|
||||
if (!PyArg_ParseTuple(args, "n|c:ljust", &width, &fillchar))
|
||||
return NULL;
|
||||
|
||||
if (STRINGLIB_LEN(self) >= width && STRINGLIB_CHECK_EXACT(self)) {
|
||||
#if STRINGLIB_MUTABLE
|
||||
/* We're defined as returning a copy; If the object is mutable
|
||||
* that means we must make an identical copy. */
|
||||
return STRINGLIB_NEW(STRINGLIB_STR(self), STRINGLIB_LEN(self));
|
||||
#else
|
||||
Py_INCREF(self);
|
||||
return (PyObject*) self;
|
||||
#endif
|
||||
}
|
||||
|
||||
return pad(self, 0, width - STRINGLIB_LEN(self), fillchar);
|
||||
}
|
||||
|
||||
|
||||
PyDoc_STRVAR(rjust__doc__,
|
||||
"B.rjust(width[, fillchar]) -> copy of B\n"
|
||||
"\n"
|
||||
"Return B right justified in a string of length width. Padding is\n"
|
||||
"done using the specified fill character (default is a space)");
|
||||
|
||||
static PyObject *
|
||||
stringlib_rjust(PyObject *self, PyObject *args)
|
||||
{
|
||||
Py_ssize_t width;
|
||||
char fillchar = ' ';
|
||||
|
||||
if (!PyArg_ParseTuple(args, "n|c:rjust", &width, &fillchar))
|
||||
return NULL;
|
||||
|
||||
if (STRINGLIB_LEN(self) >= width && STRINGLIB_CHECK_EXACT(self)) {
|
||||
#if STRINGLIB_MUTABLE
|
||||
/* We're defined as returning a copy; If the object is mutable
|
||||
* that means we must make an identical copy. */
|
||||
return STRINGLIB_NEW(STRINGLIB_STR(self), STRINGLIB_LEN(self));
|
||||
#else
|
||||
Py_INCREF(self);
|
||||
return (PyObject*) self;
|
||||
#endif
|
||||
}
|
||||
|
||||
return pad(self, width - STRINGLIB_LEN(self), 0, fillchar);
|
||||
}
|
||||
|
||||
|
||||
PyDoc_STRVAR(center__doc__,
|
||||
"B.center(width[, fillchar]) -> copy of B\n"
|
||||
"\n"
|
||||
"Return B centered in a string of length width. Padding is\n"
|
||||
"done using the specified fill character (default is a space).");
|
||||
|
||||
static PyObject *
|
||||
stringlib_center(PyObject *self, PyObject *args)
|
||||
{
|
||||
Py_ssize_t marg, left;
|
||||
Py_ssize_t width;
|
||||
char fillchar = ' ';
|
||||
|
||||
if (!PyArg_ParseTuple(args, "n|c:center", &width, &fillchar))
|
||||
return NULL;
|
||||
|
||||
if (STRINGLIB_LEN(self) >= width && STRINGLIB_CHECK_EXACT(self)) {
|
||||
#if STRINGLIB_MUTABLE
|
||||
/* We're defined as returning a copy; If the object is mutable
|
||||
* that means we must make an identical copy. */
|
||||
return STRINGLIB_NEW(STRINGLIB_STR(self), STRINGLIB_LEN(self));
|
||||
#else
|
||||
Py_INCREF(self);
|
||||
return (PyObject*) self;
|
||||
#endif
|
||||
}
|
||||
|
||||
marg = width - STRINGLIB_LEN(self);
|
||||
left = marg / 2 + (marg & width & 1);
|
||||
|
||||
return pad(self, left, marg - left, fillchar);
|
||||
}
|
||||
|
||||
PyDoc_STRVAR(zfill__doc__,
|
||||
"B.zfill(width) -> copy of B\n"
|
||||
"\n"
|
||||
"Pad a numeric string B with zeros on the left, to fill a field\n"
|
||||
"of the specified width. B is never truncated.");
|
||||
|
||||
static PyObject *
|
||||
stringlib_zfill(PyObject *self, PyObject *args)
|
||||
{
|
||||
Py_ssize_t fill;
|
||||
PyObject *s;
|
||||
char *p;
|
||||
Py_ssize_t width;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "n:zfill", &width))
|
||||
return NULL;
|
||||
|
||||
if (STRINGLIB_LEN(self) >= width) {
|
||||
if (STRINGLIB_CHECK_EXACT(self)) {
|
||||
#if STRINGLIB_MUTABLE
|
||||
/* We're defined as returning a copy; If the object is mutable
|
||||
* that means we must make an identical copy. */
|
||||
return STRINGLIB_NEW(STRINGLIB_STR(self), STRINGLIB_LEN(self));
|
||||
#else
|
||||
Py_INCREF(self);
|
||||
return (PyObject*) self;
|
||||
#endif
|
||||
}
|
||||
else
|
||||
return STRINGLIB_NEW(
|
||||
STRINGLIB_STR(self),
|
||||
STRINGLIB_LEN(self)
|
||||
);
|
||||
}
|
||||
|
||||
fill = width - STRINGLIB_LEN(self);
|
||||
|
||||
s = pad(self, fill, 0, '0');
|
||||
|
||||
if (s == NULL)
|
||||
return NULL;
|
||||
|
||||
p = STRINGLIB_STR(s);
|
||||
if (p[fill] == '+' || p[fill] == '-') {
|
||||
/* move sign to beginning of string */
|
||||
p[0] = p[fill];
|
||||
p[fill] = '0';
|
||||
}
|
||||
|
||||
return (PyObject*) s;
|
||||
}
|
||||
|
||||
|
||||
#define _STRINGLIB_SPLIT_APPEND(data, left, right) \
|
||||
str = STRINGLIB_NEW((data) + (left), \
|
||||
(right) - (left)); \
|
||||
if (str == NULL) \
|
||||
goto onError; \
|
||||
if (PyList_Append(list, str)) { \
|
||||
Py_DECREF(str); \
|
||||
goto onError; \
|
||||
} \
|
||||
else \
|
||||
Py_DECREF(str);
|
||||
|
||||
PyDoc_STRVAR(splitlines__doc__,
|
||||
"B.splitlines([keepends]) -> list of lines\n\
|
||||
\n\
|
||||
Return a list of the lines in B, breaking at line boundaries.\n\
|
||||
Line breaks are not included in the resulting list unless keepends\n\
|
||||
is given and true.");
|
||||
|
||||
static PyObject*
|
||||
stringlib_splitlines(PyObject *self, PyObject *args)
|
||||
{
|
||||
register Py_ssize_t i;
|
||||
register Py_ssize_t j;
|
||||
Py_ssize_t len;
|
||||
int keepends = 0;
|
||||
PyObject *list;
|
||||
PyObject *str;
|
||||
char *data;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "|i:splitlines", &keepends))
|
||||
return NULL;
|
||||
|
||||
data = STRINGLIB_STR(self);
|
||||
len = STRINGLIB_LEN(self);
|
||||
|
||||
/* This does not use the preallocated list because splitlines is
|
||||
usually run with hundreds of newlines. The overhead of
|
||||
switching between PyList_SET_ITEM and append causes about a
|
||||
2-3% slowdown for that common case. A smarter implementation
|
||||
could move the if check out, so the SET_ITEMs are done first
|
||||
and the appends only done when the prealloc buffer is full.
|
||||
That's too much work for little gain.*/
|
||||
|
||||
list = PyList_New(0);
|
||||
if (!list)
|
||||
goto onError;
|
||||
|
||||
for (i = j = 0; i < len; ) {
|
||||
Py_ssize_t eol;
|
||||
|
||||
/* Find a line and append it */
|
||||
while (i < len && data[i] != '\n' && data[i] != '\r')
|
||||
i++;
|
||||
|
||||
/* Skip the line break reading CRLF as one line break */
|
||||
eol = i;
|
||||
if (i < len) {
|
||||
if (data[i] == '\r' && i + 1 < len &&
|
||||
data[i+1] == '\n')
|
||||
i += 2;
|
||||
else
|
||||
i++;
|
||||
if (keepends)
|
||||
eol = i;
|
||||
}
|
||||
_STRINGLIB_SPLIT_APPEND(data, j, eol);
|
||||
j = i;
|
||||
}
|
||||
if (j < len) {
|
||||
_STRINGLIB_SPLIT_APPEND(data, j, len);
|
||||
}
|
||||
|
||||
return list;
|
||||
|
||||
onError:
|
||||
Py_XDECREF(list);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
#undef _STRINGLIB_SPLIT_APPEND
|
||||
|
||||
|
|
@ -953,6 +953,8 @@ string_concat(register PyStringObject *a, register PyObject *bb)
|
|||
if (PyUnicode_Check(bb))
|
||||
return PyUnicode_Concat((PyObject *)a, bb);
|
||||
#endif
|
||||
if (PyBytes_Check(bb))
|
||||
return PyBytes_Concat((PyObject *)a, bb);
|
||||
PyErr_Format(PyExc_TypeError,
|
||||
"cannot concatenate 'str' and '%.200s' objects",
|
||||
Py_TYPE(bb)->tp_name);
|
||||
|
|
@ -1303,6 +1305,13 @@ string_buffer_getcharbuf(PyStringObject *self, Py_ssize_t index, const char **pt
|
|||
return Py_SIZE(self);
|
||||
}
|
||||
|
||||
static int
|
||||
string_buffer_getbuffer(PyStringObject *self, Py_buffer *view, int flags)
|
||||
{
|
||||
return PyBuffer_FillInfo(view, (void *)self->ob_sval, Py_SIZE(self),
|
||||
0, flags);
|
||||
}
|
||||
|
||||
static PySequenceMethods string_as_sequence = {
|
||||
(lenfunc)string_length, /*sq_length*/
|
||||
(binaryfunc)string_concat, /*sq_concat*/
|
||||
|
|
@ -1325,6 +1334,8 @@ static PyBufferProcs string_as_buffer = {
|
|||
(writebufferproc)string_buffer_getwritebuf,
|
||||
(segcountproc)string_buffer_getsegcount,
|
||||
(charbufferproc)string_buffer_getcharbuf,
|
||||
(getbufferproc)string_buffer_getbuffer,
|
||||
0, /* XXX */
|
||||
};
|
||||
|
||||
|
||||
|
|
@ -4122,7 +4133,8 @@ PyTypeObject PyString_Type = {
|
|||
0, /* tp_setattro */
|
||||
&string_as_buffer, /* tp_as_buffer */
|
||||
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_CHECKTYPES |
|
||||
Py_TPFLAGS_BASETYPE | Py_TPFLAGS_STRING_SUBCLASS, /* tp_flags */
|
||||
Py_TPFLAGS_BASETYPE | Py_TPFLAGS_STRING_SUBCLASS |
|
||||
Py_TPFLAGS_HAVE_NEWBUFFER, /* tp_flags */
|
||||
string_doc, /* tp_doc */
|
||||
0, /* tp_traverse */
|
||||
0, /* tp_clear */
|
||||
|
|
|
|||
|
|
@ -3763,6 +3763,8 @@ inherit_slots(PyTypeObject *type, PyTypeObject *base)
|
|||
COPYBUF(bf_getwritebuffer);
|
||||
COPYBUF(bf_getsegcount);
|
||||
COPYBUF(bf_getcharbuffer);
|
||||
COPYBUF(bf_getbuffer);
|
||||
COPYBUF(bf_releasebuffer);
|
||||
}
|
||||
|
||||
basebase = base->tp_base;
|
||||
|
|
|
|||
|
|
@ -1076,7 +1076,13 @@ PyObject *PyUnicode_FromEncodedObject(register PyObject *obj,
|
|||
if (PyString_Check(obj)) {
|
||||
s = PyString_AS_STRING(obj);
|
||||
len = PyString_GET_SIZE(obj);
|
||||
}
|
||||
}
|
||||
else if (PyBytes_Check(obj)) {
|
||||
/* Python 2.x specific */
|
||||
PyErr_Format(PyExc_TypeError,
|
||||
"decoding bytearray is not supported");
|
||||
return NULL;
|
||||
}
|
||||
else if (PyObject_AsCharBuffer(obj, &s, &len)) {
|
||||
/* Overwrite the error message with something more useful in
|
||||
case of a TypeError. */
|
||||
|
|
|
|||
|
|
@ -654,6 +654,14 @@
|
|||
RelativePath="..\Include\bufferobject.h"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath="..\Include\bytesobject.h"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath="..\Include\bytes_methods.h"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath="..\Include\cellobject.h"
|
||||
>
|
||||
|
|
@ -1346,6 +1354,14 @@
|
|||
RelativePath="..\Objects\bufferobject.c"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath="..\Objects\bytesobject.c"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath="..\Objects\bytes_methods.c"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath="..\Objects\cellobject.c"
|
||||
>
|
||||
|
|
|
|||
|
|
@ -1437,6 +1437,13 @@ builtin_ord(PyObject *self, PyObject* obj)
|
|||
ord = (long)((unsigned char)*PyString_AS_STRING(obj));
|
||||
return PyInt_FromLong(ord);
|
||||
}
|
||||
} else if (PyBytes_Check(obj)) {
|
||||
size = PyBytes_GET_SIZE(obj);
|
||||
if (size == 1) {
|
||||
ord = (long)((unsigned char)*PyBytes_AS_STRING(obj));
|
||||
return PyInt_FromLong(ord);
|
||||
}
|
||||
|
||||
#ifdef Py_USING_UNICODE
|
||||
} else if (PyUnicode_Check(obj)) {
|
||||
size = PyUnicode_GET_SIZE(obj);
|
||||
|
|
@ -2552,6 +2559,7 @@ _PyBuiltin_Init(void)
|
|||
SETBUILTIN("basestring", &PyBaseString_Type);
|
||||
SETBUILTIN("bool", &PyBool_Type);
|
||||
/* SETBUILTIN("memoryview", &PyMemoryView_Type); */
|
||||
SETBUILTIN("bytearray", &PyBytes_Type);
|
||||
SETBUILTIN("bytes", &PyString_Type);
|
||||
SETBUILTIN("buffer", &PyBuffer_Type);
|
||||
SETBUILTIN("classmethod", &PyClassMethod_Type);
|
||||
|
|
|
|||
|
|
@ -72,6 +72,7 @@ int Py_VerboseFlag; /* Needed by import.c */
|
|||
int Py_InteractiveFlag; /* Needed by Py_FdIsInteractive() below */
|
||||
int Py_InspectFlag; /* Needed to determine whether to exit at SystemError */
|
||||
int Py_NoSiteFlag; /* Suppress 'import site' */
|
||||
int Py_BytesWarningFlag; /* Warn on str(bytes) and str(buffer) */
|
||||
int Py_DontWriteBytecodeFlag; /* Suppress writing bytecode files (*.py[co]) */
|
||||
int Py_UseClassExceptionsFlag = 1; /* Needed by bltinmodule.c: deprecated */
|
||||
int Py_FrozenFlag; /* Needed by getpath.c */
|
||||
|
|
@ -193,6 +194,9 @@ Py_InitializeEx(int install_sigs)
|
|||
if (!_PyInt_Init())
|
||||
Py_FatalError("Py_Initialize: can't init ints");
|
||||
|
||||
if (!PyBytes_Init())
|
||||
Py_FatalError("Py_Initialize: can't init bytearray");
|
||||
|
||||
_PyFloat_Init();
|
||||
|
||||
interp->modules = PyDict_New();
|
||||
|
|
@ -251,8 +255,28 @@ Py_InitializeEx(int install_sigs)
|
|||
#endif /* WITH_THREAD */
|
||||
|
||||
warnings_module = PyImport_ImportModule("warnings");
|
||||
if (!warnings_module)
|
||||
if (!warnings_module) {
|
||||
PyErr_Clear();
|
||||
}
|
||||
else {
|
||||
PyObject *o;
|
||||
char *action[8];
|
||||
|
||||
if (Py_BytesWarningFlag > 1)
|
||||
*action = "error";
|
||||
else if (Py_BytesWarningFlag)
|
||||
*action = "default";
|
||||
else
|
||||
*action = "ignore";
|
||||
|
||||
o = PyObject_CallMethod(warnings_module,
|
||||
"simplefilter", "sO",
|
||||
*action, PyExc_BytesWarning);
|
||||
if (o == NULL)
|
||||
Py_FatalError("Py_Initialize: can't initialize"
|
||||
"warning filter for BytesWarning.");
|
||||
Py_DECREF(o);
|
||||
}
|
||||
|
||||
#if defined(Py_USING_UNICODE) && defined(HAVE_LANGINFO_H) && defined(CODESET)
|
||||
/* On Unix, set the file system encoding according to the
|
||||
|
|
@ -471,6 +495,7 @@ Py_Finalize(void)
|
|||
PyList_Fini();
|
||||
PySet_Fini();
|
||||
PyString_Fini();
|
||||
PyBytes_Fini();
|
||||
PyInt_Fini();
|
||||
PyFloat_Fini();
|
||||
PyDict_Fini();
|
||||
|
|
|
|||
Loading…
Reference in New Issue