Long live Qt!

4 files changed, 2338 insertions, 0 deletions

diff --git a/tests/auto/qbytearray/.gitignore b/tests/auto/qbytearray/.gitignore
new file mode 100644
index 0000000..3de7c3f
--- /dev/null
+++ b/tests/auto/qbytearray/.gitignore
@@ -0,0 +1 @@
+tst_qbytearray
diff --git a/tests/auto/qbytearray/qbytearray.pro b/tests/auto/qbytearray/qbytearray.pro
new file mode 100644
index 0000000..f41c7ae
--- /dev/null
+++ b/tests/auto/qbytearray/qbytearray.pro
@@ -0,0 +1,14 @@
+load(qttest_p4)
+SOURCES  += tst_qbytearray.cpp
+
+
+QT = core
+
+wince*: {
+   addFile.sources = rfc3252.txt
+   addFile.path = .
+   DEPLOYMENT += addFile
+   DEFINES += SRCDIR=\\\"\\\"
+} else {
+   DEFINES += SRCDIR=\\\"$$PWD/\\\"
+}
diff --git a/tests/auto/qbytearray/rfc3252.txt b/tests/auto/qbytearray/rfc3252.txt
new file mode 100644
index 0000000..b80c61b
--- /dev/null
+++ b/tests/auto/qbytearray/rfc3252.txt
@@ -0,0 +1,899 @@
+
+
+
+
+
+
+Network Working Group                                         H. Kennedy
+Request for Comments: 3252                                      Mimezine
+Category: Informational                                     1 April 2002
+
+
+                 Binary Lexical Octet Ad-hoc Transport
+
+Status of this Memo
+
+   This memo provides information for the Internet community.  It does
+   not specify an Internet standard of any kind.  Distribution of this
+   memo is unlimited.
+
+Copyright Notice
+
+   Copyright (C) The Internet Society (2002).  All Rights Reserved.
+
+Abstract
+
+   This document defines a reformulation of IP and two transport layer
+   protocols (TCP and UDP) as XML applications.
+
+1.   Introduction
+
+1.1. Overview
+
+   This document describes the Binary Lexical Octet Ad-hoc Transport
+   (BLOAT): a reformulation of a widely-deployed network-layer protocol
+   (IP [RFC791]), and two associated transport layer protocols (TCP
+   [RFC793] and UDP [RFC768]) as XML [XML] applications.  It also
+   describes methods for transporting BLOAT over Ethernet and IEEE 802
+   networks as well as encapsulating BLOAT in IP for gatewaying BLOAT
+   across the public Internet.
+
+1.2. Motivation
+
+   The wild popularity of XML as a basis for application-level protocols
+   such as the Blocks Extensible Exchange Protocol [RFC3080], the Simple
+   Object Access Protocol [SOAP], and Jabber [JABBER] prompted
+   investigation into the possibility of extending the use of XML in the
+   protocol stack.  Using XML at both the transport and network layer in
+   addition to the application layer would provide for an amazing amount
+   of power and flexibility while removing dependencies on proprietary
+   and hard-to-understand binary protocols.  This protocol unification
+   would also allow applications to use a single XML parser for all
+   aspects of their operation, eliminating developer time spent figuring
+   out the intricacies of each new protocol, and moving the hard work of
+
+
+
+
+Kennedy                      Informational                      [Page 1]
+
+RFC 3252         Binary Lexical Octet Ad-hoc Transport      1 April 2002
+
+
+   parsing to the XML toolset.  The use of XML also mitigates concerns
+   over "network vs. host" byte ordering which is at the root of many
+   network application bugs.
+
+1.3. Relation to Existing Protocols
+
+   The reformulations specified in this RFC follow as closely as
+   possible the spirit of the RFCs on which they are based, and so MAY
+   contain elements or attributes that would not be needed in a pure
+   reworking (e.g. length attributes, which are implicit in XML.)
+
+   The layering of network and transport protocols are maintained in
+   this RFC despite the optimizations that could be made if the line
+   were somewhat blurred (i.e. merging TCP and IP into a single, larger
+   element in the DTD) in order to foster future use of this protocol as
+   a basis for reformulating other protocols (such as ICMP.)
+
+   Other than the encoding, the behavioral aspects of each of the
+   existing protocols remain unchanged.  Routing, address spaces, TCP
+   congestion control, etc. behave as specified in the extant standards.
+   Adapting to new standards and experimental algorithm heuristics for
+   improving performance will become much easier once the move to BLOAT
+   has been completed.
+
+1.4. Requirement Levels
+
+   The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT",
+   "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this
+   document are to be interpreted as described in BCP 14, RFC 2119
+   [RFC2119].
+
+2.   IPoXML
+
+   This protocol MUST be implemented to be compliant with this RFC.
+   IPoXML is the root protocol REQUIRED for effective use of TCPoXML
+   (section 3.) and higher-level application protocols.
+
+   The DTD for this document type can be found in section 7.1.
+
+   The routing of IPoXML can be easily implemented on hosts with an XML
+   parser, as the regular structure lends itself handily to parsing and
+   validation of the document/datagram and then processing the
+   destination address, TTL, and checksum before sending it on to its
+   next-hop.
+
+   The reformulation of IPv4 was chosen over IPv6 [RFC2460] due to the
+   wider deployment of IPv4 and the fact that implementing IPv6 as XML
+   would have exceeded the 1500 byte Ethernet MTU.
+
+
+
+Kennedy                      Informational                      [Page 2]
+
+RFC 3252         Binary Lexical Octet Ad-hoc Transport      1 April 2002
+
+
+   All BLOAT implementations MUST use - and specify - the UTF-8 encoding
+   of RFC 2279 [RFC2279].  All BLOAT document/datagrams MUST be well-
+   formed and include the XMLDecl.
+
+2.1. IP Description
+
+   A number of items have changed (for the better) from the original IP
+   specification.  Bit-masks, where present have been converted into
+   human-readable values.  IP addresses are listed in their dotted-
+   decimal notation [RFC1123].  Length and checksum values are present
+   as decimal integers.
+
+   To calculate the length and checksum fields of the IP element, a
+   canonicalized form of the element MUST be used.  The canonical form
+   SHALL have no whitespace (including newline characters) between
+   elements and only one space character between attributes.  There
+   SHALL NOT be a space following the last attribute in an element.
+
+   An iterative method SHOULD be used to calculate checksums, as the
+   length field will vary based on the size of the checksum.
+
+   The payload element bears special attention.  Due to the character
+   set restrictions of XML, the payload of IP datagrams (which MAY
+   contain arbitrary data) MUST be encoded for transport. This RFC
+   REQUIRES the contents of the payload to be encoded in the base-64
+   encoding of RFC 2045 [RFC2045], but removes the requirement that the
+   encoded output MUST be wrapped on 76-character lines.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Kennedy                      Informational                      [Page 3]
+
+RFC 3252         Binary Lexical Octet Ad-hoc Transport      1 April 2002
+
+
+2.2. Example Datagram
+
+   The following is an example IPoXML datagram with an empty payload:
+
+   <?xml version="1.0" encoding="UTF-8"?>
+   <!DOCTYPE ip PUBLIC "-//IETF//DTD BLOAT 1.0 IP//EN" "bloat.dtd">
+   <ip>
+   <header length="474">
+   <version value="4"/>
+   <tos precedence="Routine" delay="Normal" throughput="Normal"
+        relibility="Normal" reserved="0"/>
+   <total.length value="461"/>
+   <id value="1"/>
+   <flags reserved="0" df="dont" mf="last"/>
+   <offset value="0"/>
+   <ttl value="255"/>
+   <protocol value="6"/>
+   <checksum value="8707"/>
+   <source address="10.0.0.22"/>
+   <destination address="10.0.0.1"/>
+   <options>
+   <end copied="0" class="0" number="0"/>
+   </options>
+   <padding pad="0"/>
+   </header>
+   <payload>
+   </payload>
+   </ip>
+
+3.   TCPoXML
+
+   This protocol MUST be implemented to be compliant with this RFC.  The
+   DTD for this document type can be found in section 7.2.
+
+3.1. TCP Description
+
+   A number of items have changed from the original TCP specification.
+   Bit-masks, where present have been converted into human-readable
+   values.  Length and checksum and port values are present as decimal
+   integers.
+
+   To calculate the length and checksum fields of the TCP element, a
+   canonicalized form of the element MUST be used as in section 2.1.
+
+   An iterative method SHOULD be used to calculate checksums as in
+   section 2.1.
+
+   The payload element MUST be encoded as in section 2.1.
+
+
+
+Kennedy                      Informational                      [Page 4]
+
+RFC 3252         Binary Lexical Octet Ad-hoc Transport      1 April 2002
+
+
+   The TCP offset element was expanded to a maximum of 255 from 16 to
+   allow for the increased size of the header in XML.
+
+   TCPoXML datagrams encapsulated by IPoXML MAY omit the <?xml?> header
+   as well as the <!DOCTYPE> declaration.
+
+3.2. Example Datagram
+
+   The following is an example TCPoXML datagram with an empty payload:
+
+   <?xml version="1.0" encoding="UTF-8"?>
+   <!DOCTYPE tcp PUBLIC "-//IETF//DTD BLOAT 1.0 TCP//EN" "bloat.dtd">
+   <tcp>
+   <tcp.header>
+   <src port="31415"/>
+   <dest port="42424"/>
+   <sequence number="322622954"/>
+   <acknowledgement number="689715995"/>
+   <offset number=""/>
+   <reserved value="0"/>
+   <control syn="1" ack="1"/>
+   <window size="1"/>
+   <urgent pointer="0"/>
+   <checksum value="2988"/>
+   <tcp.options>
+   <tcp.end kind="0"/>
+   </tcp.options>
+   <padding pad="0"/>
+   </tcp.header>
+   <payload>
+   </payload>
+   </tcp>
+
+4.   UDPoXML
+
+   This protocol MUST be implemented to be compliant with this RFC.  The
+   DTD for this document type can be found in section 7.3.
+
+4.1. UDP Description
+
+   A number of items have changed from the original UDP specification.
+   Bit-masks, where present have been converted into human-readable
+   values.  Length and checksum and port values are present as decimal
+   integers.
+
+
+
+
+
+
+
+Kennedy                      Informational                      [Page 5]
+
+RFC 3252         Binary Lexical Octet Ad-hoc Transport      1 April 2002
+
+
+   To calculate the length and checksum fields of the UDP element, a
+   canonicalized form of the element MUST be used as in section 2.1.  An
+   iterative method SHOULD be used to calculate checksums as in section
+   2.1.
+
+   The payload element MUST be encoded as in section 2.1.
+
+   UDPoXML datagrams encapsulated by IPoXML MAY omit the <?xml?> header
+   as well as the <!DOCTYPE> declaration.
+
+4.2. Example Datagram
+
+   The following is an example UDPoXML datagram with an empty payload:
+
+   <?xml version="1.0" encoding="UTF-8"?>
+   <!DOCTYPE udp PUBLIC "-//IETF//DTD BLOAT 1.0 UDP//EN" "bloat.dtd">
+   <udp>
+   <udp.header>
+   <src port="31415"/>
+   <dest port="42424"/>
+   <udp.length value="143"/>
+   <checksum value="2988"/>
+   </udp.header>
+   <payload>
+   </payload>
+   </udp>
+
+5.   Network Transport
+
+   This document provides for the transmission of BLOAT datagrams over
+   two common families of physical layer transport.  Future RFCs will
+   address additional transports as routing vendors catch up to the
+   specification, and we begin to see BLOAT routed across the Internet
+   backbone.
+
+5.1. Ethernet
+
+   BLOAT is encapsulated in Ethernet datagrams as in [RFC894] with the
+   exception that the type field of the Ethernet frame MUST contain the
+   value 0xBEEF.  The first 5 octets of the Ethernet frame payload will
+   be 0x3c 3f 78 6d 6c ("<?xml".)
+
+5.2. IEEE 802
+
+   BLOAT is encapsulated in IEEE 802 Networks as in [RFC1042] except
+   that the protocol type code for IPoXML is 0xBEEF.
+
+
+
+
+
+Kennedy                      Informational                      [Page 6]
+
+RFC 3252         Binary Lexical Octet Ad-hoc Transport      1 April 2002
+
+
+6. Gatewaying over IP
+
+   In order to facilitate the gradual introduction of BLOAT into the
+   public Internet, BLOAT MAY be encapsulated in IP as in [RFC2003] to
+   gateway between networks that run BLOAT natively on their LANs.
+
+7. DTDs
+
+   The Transport DTDs (7.2. and 7.3.) build on the definitions in the
+   Network DTD (7.1.)
+
+   The DTDs are referenced by their PubidLiteral and SystemLiteral (from
+   [XML]) although it is understood that most IPoXML implementations
+   will not need to pull down the DTD, as it will normally be embedded
+   in the implementation, and presents something of a catch-22 if you
+   need to load part of your network protocol over the network.
+
+7.1.  IPoXML DTD
+
+   <!--
+    DTD for IP over XML.
+    Refer to this DTD as:
+
+    <!DOCTYPE ip PUBLIC "-//IETF//DTD BLOAT 1.0 IP//EN" "bloat.dtd">
+   -->
+   <!--
+    DTD data types:
+
+      Digits      [0..9]+
+
+      Precedence  "NetworkControl | InternetworkControl |
+                   CRITIC | FlashOverride | Flash | Immediate |
+                   Priority | Routine"
+
+      IP4Addr     "dotted-decimal" notation of [RFC1123]
+
+      Class       [0..3]
+
+      Sec          "Unclassified | Confidential | EFTO | MMMM | PROG |
+                    Restricted | Secret | Top Secret | Reserved"
+
+      Compartments [0..65535]
+
+      Handling     [0..65535]
+
+      TCC          [0..16777216]
+
+   -->
+
+
+
+Kennedy                      Informational                      [Page 7]
+
+RFC 3252         Binary Lexical Octet Ad-hoc Transport      1 April 2002
+
+
+   <!ENTITY % Digits "CDATA">
+   <!ENTITY % Precedence "CDATA">
+   <!ENTITY % IP4Addr "CDATA">
+   <!ENTITY % Class "CDATA">
+   <!ENTITY % Sec "CDATA">
+   <!ENTITY % Compartments "CDATA">
+   <!ENTITY % Handling "CDATA">
+   <!ENTITY % TCC "CDATA">
+
+   <!ELEMENT ip (header, payload)>
+
+   <!ELEMENT header (version, tos, total.length, id, flags, offset, ttl,
+                    protocol, checksum, source, destination, options,
+                    padding)>
+   <!-- length of header in 32-bit words -->
+   <!ATTLIST header
+             length %Digits; #REQUIRED>
+
+   <!ELEMENT version EMPTY>
+   <!-- ip version. SHOULD be "4" -->
+   <!ATTLIST version
+             value   %Digits;  #REQUIRED>
+
+   <!ELEMENT tos EMPTY>
+   <!ATTLIST tos
+             precedence   %Precedence;    #REQUIRED
+             delay    (normal | low)  #REQUIRED
+             throughput   (normal | high) #REQUIRED
+             relibility   (normal | high) #REQUIRED
+             reserved     CDATA #FIXED "0">
+
+   <!ELEMENT total.length EMPTY>
+   <!--
+    total length of datagram (header and payload) in octets, MUST be
+    less than 65,535 (and SHOULD be less than 1024 for IPoXML on local
+    ethernets).
+   -->
+   <!ATTLIST total.length
+             value %Digits; #REQUIRED>
+
+   <!ELEMENT id EMPTY>
+   <!-- 0 <= id <= 65,535  -->
+   <!ATTLIST id
+             value %Digits; #REQUIRED>
+
+   <!ELEMENT flags EMPTY>
+   <!-- df = don't fragment, mf = more fragments  -->
+   <!ATTLIST flags
+
+
+
+Kennedy                      Informational                      [Page 8]
+
+RFC 3252         Binary Lexical Octet Ad-hoc Transport      1 April 2002
+
+
+          reserved CDATA  #FIXED "0"
+          df (may|dont)   #REQUIRED
+          mf (last|more)  #REQUIRED>
+
+   <!ELEMENT offset EMPTY>
+   <!-- 0 <= offset <= 8192 measured in 8 octet (64-bit) chunks -->
+   <!ATTLIST offset
+             value %Digits; #REQUIRED>
+
+   <!ELEMENT ttl EMPTY>
+   <!-- 0 <= ttl <= 255 -->
+   <!ATTLIST ttl
+             value %Digits; #REQUIRED>
+
+   <!ELEMENT protocol EMPTY>
+   <!-- 0 <= protocol <= 255 (per IANA) -->
+   <!ATTLIST protocol
+             value %Digits; #REQUIRED>
+
+   <!ELEMENT checksum EMPTY>
+   <!-- 0 <= checksum <= 65535 (over header only) -->
+   <!ATTLIST checksum
+             value %Digits; #REQUIRED>
+
+   <!ELEMENT source EMPTY>
+   <!ATTLIST source
+             address %IP4Addr; #REQUIRED>
+
+   <!ELEMENT destination EMPTY>
+   <!ATTLIST destination
+             address %IP4Addr; #REQUIRED>
+
+   <!ELEMENT options ( end | noop | security | loose | strict | record
+                     | stream | timestamp )*>
+
+   <!ELEMENT end EMPTY>
+   <!ATTLIST end
+             copied (0|1) #REQUIRED
+             class  CDATA #FIXED "0"
+             number CDATA #FIXED "0">
+
+   <!ELEMENT noop EMPTY>
+   <!ATTLIST noop
+             copied (0|1) #REQUIRED
+             class  CDATA #FIXED "0"
+             number CDATA #FIXED "1">
+
+   <!ELEMENT security EMPTY>
+
+
+
+Kennedy                      Informational                      [Page 9]
+
+RFC 3252         Binary Lexical Octet Ad-hoc Transport      1 April 2002
+
+
+   <!ATTLIST security
+             copied CDATA #FIXED "1"
+             class  CDATA #FIXED "0"
+             number CDATA #FIXED "2"
+             length CDATA #FIXED "11"
+             security %Sec; #REQUIRED
+             compartments %Compartments; #REQUIRED
+             handling %Handling; #REQUIRED
+             tcc %TCC; #REQUIRED>
+   <!ELEMENT loose (hop)+>
+   <!ATTLIST loose
+             copied CDATA #FIXED "1"
+             class  CDATA #FIXED "0"
+             number CDATA #FIXED "3"
+             length %Digits; #REQUIRED
+             pointer %Digits; #REQUIRED>
+
+   <!ELEMENT hop EMPTY>
+   <!ATTLIST hop
+             address %IP4Addr; #REQUIRED>
+
+   <!ELEMENT strict (hop)+>
+   <!ATTLIST strict
+             copied CDATA #FIXED "1"
+             class  CDATA #FIXED "0"
+             number CDATA #FIXED "9"
+             length %Digits; #REQUIRED
+             pointer %Digits; #REQUIRED>
+
+   <!ELEMENT record (hop)+>
+   <!ATTLIST record
+             copied CDATA #FIXED "0"
+             class  CDATA #FIXED "0"
+             number CDATA #FIXED "7"
+             length %Digits; #REQUIRED
+             pointer %Digits; #REQUIRED>
+
+   <!ELEMENT stream EMPTY>
+   <!-- 0 <= id <= 65,535 -->
+   <!ATTLIST stream
+             copied CDATA #FIXED "1"
+             class  CDATA #FIXED "0"
+             number CDATA #FIXED "8"
+             length CDATA #FIXED "4"
+             id %Digits; #REQUIRED>
+
+   <!ELEMENT timestamp (tstamp)+>
+   <!-- 0 <= oflw <=15 -->
+
+
+
+Kennedy                      Informational                     [Page 10]
+
+RFC 3252         Binary Lexical Octet Ad-hoc Transport      1 April 2002
+
+
+   <!ATTLIST timestamp
+             copied CDATA #FIXED "0"
+             class  CDATA #FIXED "2"
+             number CDATA #FIXED "4"
+             length %Digits;  #REQUIRED
+             pointer %Digits; #REQUIRED
+             oflw %Digits;    #REQUIRED
+             flag (0 | 1 | 3)  #REQUIRED>
+
+   <!ELEMENT tstamp EMPTY>
+   <!ATTLIST tstamp
+             time %Digits;   #REQUIRED
+             address %IP4Addr; #IMPLIED>
+   <!--
+       padding to bring header to 32-bit boundary.
+       pad MUST be "0"*
+    -->
+   <!ELEMENT padding EMPTY>
+   <!ATTLIST padding
+             pad CDATA #REQUIRED>
+
+   <!-- payload MUST be encoded as base-64 [RFC2045], as modified
+        by section 2.1 of this RFC -->
+   <!ELEMENT payload (CDATA)>
+
+7.2.  TCPoXML DTD
+
+   <!--
+      DTD for TCP over XML.
+      Refer to this DTD as:
+
+      <!DOCTYPE tcp PUBLIC "-//IETF//DTD BLOAT 1.0 TCP//EN" "bloat.dtd">
+   -->
+
+   <!-- the pseudoheader is only included for checksum calculations -->
+   <!ELEMENT tcp (tcp.pseudoheader?, tcp.header, payload)>
+
+   <!ELEMENT tcp.header (src, dest, sequence, acknowledgement, offset,
+                         reserved, control, window, checksum, urgent,
+                         tcp.options, padding)>
+
+   <!ELEMENT src EMPTY>
+   <!-- 0 <= port <= 65,535 -->
+   <!ATTLIST src
+             port %Digits; #REQUIRED>
+
+   <!ELEMENT dest EMPTY>
+   <!-- 0 <= port <= 65,535 -->
+
+
+
+Kennedy                      Informational                     [Page 11]
+
+RFC 3252         Binary Lexical Octet Ad-hoc Transport      1 April 2002
+
+
+   <!ATTLIST dest
+             port %Digits; #REQUIRED>
+
+   <!ELEMENT sequence EMPTY>
+   <!-- 0 <= number <= 4294967295 -->
+   <!ATTLIST sequence
+             number %Digits; #REQUIRED>
+
+   <!ELEMENT acknowledgement EMPTY>
+   <!-- 0 <= number <= 4294967295 -->
+   <!ATTLIST acknowledgement
+             number %Digits; #REQUIRED>
+
+   <!ELEMENT offset EMPTY>
+   <!-- 0 <= number <= 255 -->
+   <!ATTLIST offset
+             number %Digits; #REQUIRED>
+
+   <!ELEMENT reserved EMPTY>
+   <!ATTLIST reserved
+             value CDATA #FIXED "0">
+
+   <!ELEMENT control EMPTY>
+   <!ATTLIST control
+             urg (0|1) #IMPLIED
+             ack (0|1) #IMPLIED
+             psh (0|1) #IMPLIED
+             rst (0|1) #IMPLIED
+             syn (0|1) #IMPLIED
+             fin (0|1) #IMPLIED>
+
+   <!ELEMENT window EMPTY>
+   <!-- 0 <= size <= 65,535 -->
+   <!ATTLIST window
+             size %Digits; #REQUIRED>
+
+   <!--
+      checksum as in ip, but with
+      the following pseudo-header added into the tcp element:
+     -->
+   <!ELEMENT tcp.pseudoheader (source, destination, protocol,
+                               tcp.length)>
+
+   <!--
+      tcp header + data length in octets. does not include the size of
+
+      the pseudoheader.
+    -->
+
+
+
+Kennedy                      Informational                     [Page 12]
+
+RFC 3252         Binary Lexical Octet Ad-hoc Transport      1 April 2002
+
+
+   <!ELEMENT tcp.length EMPTY>
+   <!ATTLIST tcp.length
+             value %Digits; #REQUIRED>
+
+   <!ELEMENT urgent EMPTY>
+   <!-- 0 <= pointer <= 65,535 -->
+   <!ATTLIST urgent
+             pointer %Digits; #REQUIRED>
+
+   <!ELEMENT tcp.options (tcp.end | tcp.noop | tcp.mss)+>
+
+   <!ELEMENT tcp.end EMPTY>
+   <!ATTLIST tcp.end
+             kind CDATA #FIXED "0">
+
+   <!ELEMENT tcp.noop EMPTY>
+   <!ATTLIST tcp.noop
+             kind CDATA #FIXED "1">
+
+   <!ELEMENT tcp.mss EMPTY>
+   <!ATTLIST tcp.mss
+             kind CDATA #FIXED "2"
+             length CDATA #FIXED "4"
+             size %Digits; #REQUIRED>
+
+7.3.  UDPoXML DTD
+
+   <!--
+      DTD for UDP over XML.
+      Refer to this DTD as:
+
+      <!DOCTYPE udp PUBLIC "-//IETF//DTD BLOAT 1.0 UDP//EN" "bloat.dtd">
+   -->
+
+   <!ELEMENT udp (udp.pseudoheader?, udp.header, payload)>
+
+   <!ELEMENT udp.header (src, dest, udp.length, checksum)>
+
+   <!ELEMENT udp.pseudoheader (source, destination, protocol,
+                               udp.length)>
+
+   <!--
+      udp header + data length in octets. does not include the size of
+      the pseudoheader.
+    -->
+   <!ELEMENT udp.length EMPTY>
+   <!ATTLIST udp.length
+             value %Digits; #REQUIRED>
+
+
+
+Kennedy                      Informational                     [Page 13]
+
+RFC 3252         Binary Lexical Octet Ad-hoc Transport      1 April 2002
+
+
+8. Security Considerations
+
+   XML, as a subset of SGML, has the same security considerations as
+   specified in SGML Media Types [RFC1874].  Security considerations
+   that apply to IP, TCP and UDP also likely apply to BLOAT as it does
+   not attempt to correct for issues not related to message format.
+
+9.   References
+
+   [JABBER]    Miller, J., "Jabber", draft-miller-jabber-00.txt,
+               February 2002. (Work in Progress)
+
+   [RFC768]    Postel, J., "User Datagram Protocol", STD 6, RFC 768,
+               August 1980.
+
+   [RFC791]    Postel, J., "Internet Protocol", STD 5, RFC 791,
+               September 1981.
+
+   [RFC793]    Postel, J., "Transmission Control Protocol", STD 7, RFC
+               793, September 1981.
+
+   [RFC894]    Hornig, C., "Standard for the Transmission of IP
+               Datagrams over Ethernet Networks.", RFC 894, April 1984.
+
+   [RFC1042]   Postel, J. and J. Reynolds, "Standard for the
+               Transmission of IP Datagrams Over IEEE 802 Networks", STD
+               43, RFC 1042, February 1988.
+
+   [RFC1123]   Braden, R., "Requirements for Internet Hosts -
+               Application and Support", RFC 1123, October 1989.
+
+   [RFC1874]   Levinson, E., "SGML Media Types", RFC 1874, December
+               1995.
+
+   [RFC2003]   Perkins, C., "IP Encapsulation within IP", RFC 2003,
+               October 1996.
+
+   [RFC2045]   Freed, N. and N. Borenstein, "Multipurpose Internet Mail
+               Extensions (MIME) Part One: Format of Internet Message
+               Bodies", RFC 2045, November 1996.
+
+   [RFC2119]   Bradner, S., "Key words for use in RFCs to Indicate
+               Requirement Levels", BCP 14, RFC 2119, March 1997.
+
+   [RFC2279]   Yergeau, F., "UTF-8, a transformation format of ISO
+               10646", RFC 2279, January 1998.
+
+
+
+
+
+Kennedy                      Informational                     [Page 14]
+
+RFC 3252         Binary Lexical Octet Ad-hoc Transport      1 April 2002
+
+
+   [RFC2460]   Deering, S. and R. Hinden, "Internet Protocol, Version 6
+               (IPv6) Specification", RFC 2460, December 1998.
+
+   [RFC3080]   Rose, M., "The Blocks Extensible Exchange Protocol Core",
+               RFC 3080, March 2001.
+
+   [SOAP]      Box, D., Ehnebuske, D., Kakivaya, G., Layman, A.,
+               Mendelsohn, N., Nielsen, H. F., Thatte, S. Winer, D.,
+               "Simple Object Access Protocol (SOAP) 1.1" World Wide Web
+               Consortium Note, May 2000 http://www.w3.org/TR/SOAP/
+
+   [XML]       Bray, T., Paoli, J., Sperberg-McQueen, C. M., "Extensible
+               Markup Language (XML)" World Wide Web Consortium
+               Recommendation REC- xml-19980210.
+               http://www.w3.org/TR/1998/REC-xml-19980210
+
+10.  Author's Address
+
+   Hugh Kennedy
+   Mimezine
+   1060 West Addison
+   Chicago, IL 60613
+   USA
+
+   EMail: kennedyh@engin.umich.edu
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Kennedy                      Informational                     [Page 15]
+
+RFC 3252         Binary Lexical Octet Ad-hoc Transport      1 April 2002
+
+
+11.  Full Copyright Statement
+
+   Copyright (C) The Internet Society (2002).  All Rights Reserved.
+
+   This document and translations of it may be copied and furnished to
+   others, and derivative works that comment on or otherwise explain it
+   or assist in its implementation may be prepared, copied, published
+   and distributed, in whole or in part, without restriction of any
+   kind, provided that the above copyright notice and this paragraph are
+   included on all such copies and derivative works.  However, this
+   document itself may not be modified in any way, such as by removing
+   the copyright notice or references to the Internet Society or other
+   Internet organizations, except as needed for the purpose of
+   developing Internet standards in which case the procedures for
+   copyrights defined in the Internet Standards process must be
+   followed, or as required to translate it into languages other than
+   English.
+
+   The limited permissions granted above are perpetual and will not be
+   revoked by the Internet Society or its successors or assigns.
+
+   This document and the information contained herein is provided on an
+   "AS IS" basis and THE INTERNET SOCIETY AND THE INTERNET ENGINEERING
+   TASK FORCE DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING
+   BUT NOT LIMITED TO ANY WARRANTY THAT THE USE OF THE INFORMATION
+   HEREIN WILL NOT INFRINGE ANY RIGHTS OR ANY IMPLIED WARRANTIES OF
+   MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
+
+Acknowledgement
+
+   Funding for the RFC Editor function is currently provided by the
+   Internet Society.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Kennedy                      Informational                     [Page 16]
+
diff --git a/tests/auto/qbytearray/tst_qbytearray.cpp b/tests/auto/qbytearray/tst_qbytearray.cpp
new file mode 100644
index 0000000..4da8c5c
--- /dev/null
+++ b/tests/auto/qbytearray/tst_qbytearray.cpp
@@ -0,0 +1,1424 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#include <QtTest/QtTest>
+
+#include <qbytearray.h>
+#include <qfile.h>
+#include <limits.h>
+#include <private/qtools_p.h>
+#if defined(Q_OS_WINCE)
+#include <qcoreapplication.h>
+#endif
+
+//TESTED_CLASS=
+//TESTED_FILES=
+
+class tst_QByteArray : public QObject
+{
+    Q_OBJECT
+
+public:
+    tst_QByteArray();
+    virtual ~tst_QByteArray();
+
+public slots:
+    void initTestCase();
+    void cleanupTestCase();
+    void init();
+    void cleanup();
+private slots:
+    void qCompress_data();
+#ifndef QT_NO_COMPRESS
+    void qCompress();
+    void qUncompress_data();
+    void qUncompress();
+#endif
+    void constByteArray();
+    void leftJustified();
+    void rightJustified();
+    void startsWith_data();
+    void startsWith();
+    void startsWith_char();
+    void endsWith_data();
+    void endsWith();
+    void endsWith_char();
+    void split_data();
+    void split();
+    void base64_data();
+    void base64();
+    void qvsnprintf();
+    void qstrlen();
+    void qstrnlen();
+    void qstrcpy();
+    void qstrncpy();
+    void qstricmp_data();
+    void qstricmp();
+    void qstricmp_singularities();
+    void qstrnicmp_singularities();
+    void chop_data();
+    void chop();
+    void prepend();
+    void append();
+    void insert();
+    void remove_data();
+    void remove();
+    void replace_data();
+    void replace();
+    void indexOf_data();
+    void indexOf();
+    void lastIndexOf_data();
+    void lastIndexOf();
+    void toULong_data();
+    void toULong();
+    void toULongLong_data();
+    void toULongLong();
+
+    void number();
+    void toInt_data();
+    void toInt();
+    void qAllocMore();
+
+    void resizeAfterFromRawData();
+    void appendAfterFromRawData();
+    void toFromHex_data();
+    void toFromHex();
+    void toFromPercentEncoding();
+
+    void compare_data();
+    void compare();
+    void compareCharStar_data();
+    void compareCharStar();
+
+    void repeatedSignature() const;
+    void repeated() const;
+    void repeated_data() const;
+
+    void byteRefDetaching() const;
+};
+
+tst_QByteArray::tst_QByteArray()
+{
+    qRegisterMetaType<qulonglong>("qulonglong");
+}
+
+tst_QByteArray::~tst_QByteArray()
+{
+}
+
+void tst_QByteArray::initTestCase()
+{
+}
+
+void tst_QByteArray::cleanupTestCase()
+{
+}
+
+void tst_QByteArray::init()
+{
+}
+
+void tst_QByteArray::cleanup()
+{
+}
+
+void tst_QByteArray::qCompress_data()
+{
+    QTest::addColumn<QByteArray>("ba");
+
+#ifndef Q_OS_WINCE
+    const int size1 = 1024*1024;
+#else
+    const int size1 = 1024;
+#endif
+    QByteArray ba1( size1, 0 );
+
+    QTest::newRow( "00" ) << QByteArray();
+
+    int i;
+    for ( i=0; i<size1; i++ )
+	ba1[i] = (char)( i / 1024 );
+    QTest::newRow( "01" ) << ba1;
+
+    for ( i=0; i<size1; i++ )
+	ba1[i] = (char)( i % 256 );
+    QTest::newRow( "02" ) << ba1;
+
+    ba1.fill( 'A' );
+    QTest::newRow( "03" ) << ba1;
+
+#if defined(Q_OS_WINCE)
+    int tmpArgc = 0;
+    char** tmpArgv = 0;
+    QCoreApplication app(tmpArgc, tmpArgv);
+#endif
+    QFile file( SRCDIR "rfc3252.txt" );
+    QVERIFY( file.open(QIODevice::ReadOnly) );
+    QTest::newRow( "04" ) << file.readAll();
+}
+
+#ifndef QT_NO_COMPRESS
+void tst_QByteArray::qCompress()
+{
+    QFETCH( QByteArray, ba );
+    QByteArray compressed = ::qCompress( ba );
+    //qDebug( "size uncompressed: %d    size compressed: %d", ba.size(), compressed.size() );
+    QTEST( ::qUncompress( compressed ), "ba" );
+}
+
+/*
+    Just making sure it doesn't crash on invalid data.
+*/
+void tst_QByteArray::qUncompress_data()
+{
+    QTest::addColumn<QByteArray>("in");
+    QTest::addColumn<QByteArray>("out");
+
+    QTest::newRow("0x00000000") << QByteArray("\x00\x00\x00\x00") << QByteArray();
+    QTest::newRow("0x000000ff") << QByteArray("\x00\x00\x00\xff") << QByteArray();
+    QTest::newRow("0x3f000000") << QByteArray("\x3f\x00\x00\x00") << QByteArray();
+    QTest::newRow("0x3fffffff") << QByteArray("\x3f\xff\xff\xff") << QByteArray();
+    QTest::newRow("0x7fffff00") << QByteArray("\x7f\xff\xff\x00") << QByteArray();
+    QTest::newRow("0x7fffffff") << QByteArray("\x7f\xff\xff\xff") << QByteArray();
+    QTest::newRow("0x80000000") << QByteArray("\x80\x00\x00\x00") << QByteArray();
+    QTest::newRow("0x800000ff") << QByteArray("\x80\x00\x00\xff") << QByteArray();
+    QTest::newRow("0xcf000000") << QByteArray("\xcf\x00\x00\x00") << QByteArray();
+    QTest::newRow("0xcfffffff") << QByteArray("\xcf\xff\xff\xff") << QByteArray();
+    QTest::newRow("0xffffff00") << QByteArray("\xff\xff\xff\x00") << QByteArray();
+    QTest::newRow("0xffffffff") << QByteArray("\xff\xff\xff\xff") << QByteArray();
+}
+
+void tst_QByteArray::qUncompress()
+{
+    QFETCH(QByteArray, in);
+
+#if defined Q_OS_HPUX && !defined __ia64 && defined Q_CC_GNU
+    QSKIP("Corrupt data causes this tests to lock up on HP-UX / PA-RISC with gcc", SkipAll);
+#elif defined Q_OS_SOLARIS
+    QSKIP("Corrupt data causes this tests to lock up on Solaris", SkipAll);
+#endif
+
+    QTEST(::qUncompress(in), "out");
+
+#if defined Q_WS_MAC && (MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_4)
+    QSKIP("Corrupt data causes this test to lock up on Mac OS X Panther", SkipSingle);
+#endif
+
+    QTEST(::qUncompress(in + "blah"), "out");
+}
+#endif
+
+void tst_QByteArray::constByteArray()
+{
+    const char *ptr = "abc";
+    QByteArray cba = QByteArray::fromRawData(ptr, 3);
+    QVERIFY(cba.constData() == ptr);
+    cba.squeeze();
+    QVERIFY(cba.constData() == ptr);
+    cba.detach();
+    QVERIFY(cba.size() == 3);
+    QVERIFY(cba.capacity() == 3);
+    QVERIFY(cba.constData() != ptr);
+    QVERIFY(cba.constData()[0] == 'a');
+    QVERIFY(cba.constData()[1] == 'b');
+    QVERIFY(cba.constData()[2] == 'c');
+    QVERIFY(cba.constData()[3] == '\0');
+}
+
+void tst_QByteArray::leftJustified()
+{
+    QByteArray a;
+    a = "ABC";
+    QCOMPARE(a.leftJustified(5,'-'), QByteArray("ABC--"));
+    QCOMPARE(a.leftJustified(4,'-'), QByteArray("ABC-"));
+    QCOMPARE(a.leftJustified(4), QByteArray("ABC "));
+    QCOMPARE(a.leftJustified(3), QByteArray("ABC"));
+    QCOMPARE(a.leftJustified(2), QByteArray("ABC"));
+    QCOMPARE(a.leftJustified(1), QByteArray("ABC"));
+    QCOMPARE(a.leftJustified(0), QByteArray("ABC"));
+
+    QByteArray n;
+    QVERIFY(!n.leftJustified(3).isNull());    // I expected true
+    QCOMPARE(a.leftJustified(4,' ',true), QByteArray("ABC "));
+    QCOMPARE(a.leftJustified(3,' ',true), QByteArray("ABC"));
+    QCOMPARE(a.leftJustified(2,' ',true), QByteArray("AB"));
+    QCOMPARE(a.leftJustified(1,' ',true), QByteArray("A"));
+    QCOMPARE(a.leftJustified(0,' ',true), QByteArray(""));
+}
+
+void tst_QByteArray::rightJustified()
+{
+    QByteArray a;
+    a="ABC";
+    QCOMPARE(a.rightJustified(5,'-'),QByteArray("--ABC"));
+    QCOMPARE(a.rightJustified(4,'-'),QByteArray("-ABC"));
+    QCOMPARE(a.rightJustified(4),QByteArray(" ABC"));
+    QCOMPARE(a.rightJustified(3),QByteArray("ABC"));
+    QCOMPARE(a.rightJustified(2),QByteArray("ABC"));
+    QCOMPARE(a.rightJustified(1),QByteArray("ABC"));
+    QCOMPARE(a.rightJustified(0),QByteArray("ABC"));
+
+    QByteArray n;
+    QVERIFY(!n.rightJustified(3).isNull());  // I expected true
+    QCOMPARE(a.rightJustified(4,'-',true),QByteArray("-ABC"));
+    QCOMPARE(a.rightJustified(4,' ',true),QByteArray(" ABC"));
+    QCOMPARE(a.rightJustified(3,' ',true),QByteArray("ABC"));
+    QCOMPARE(a.rightJustified(2,' ',true),QByteArray("AB"));
+    QCOMPARE(a.rightJustified(1,' ',true),QByteArray("A"));
+    QCOMPARE(a.rightJustified(0,' ',true),QByteArray(""));
+    QCOMPARE(a,QByteArray("ABC"));
+}
+
+void tst_QByteArray::startsWith_data()
+{
+    QTest::addColumn<QByteArray>("ba");
+    QTest::addColumn<QByteArray>("sw");
+    QTest::addColumn<bool>("result");
+
+    QTest::newRow("01") << QByteArray() << QByteArray() << true;
+    QTest::newRow("02") << QByteArray() << QByteArray("") << true;
+    QTest::newRow("03") << QByteArray() << QByteArray("hallo") << false;
+
+    QTest::newRow("04") << QByteArray("") << QByteArray() << true;
+    QTest::newRow("05") << QByteArray("") << QByteArray("") << true;
+    QTest::newRow("06") << QByteArray("") << QByteArray("h") << false;
+
+    QTest::newRow("07") << QByteArray("hallo") << QByteArray("h") << true;
+    QTest::newRow("08") << QByteArray("hallo") << QByteArray("hallo") << true;
+    QTest::newRow("09") << QByteArray("hallo") << QByteArray("") << true;
+    QTest::newRow("10") << QByteArray("hallo") << QByteArray("hallohallo") << false;
+    QTest::newRow("11") << QByteArray("hallo") << QByteArray() << true;
+}
+
+void tst_QByteArray::startsWith()
+{
+    QFETCH(QByteArray, ba);
+    QFETCH(QByteArray, sw);
+    QFETCH(bool, result);
+
+    QVERIFY(ba.startsWith(sw) == result);
+
+    if (sw.isNull()) {
+        QVERIFY(ba.startsWith((char*)0) == result);
+    } else {
+        QVERIFY(ba.startsWith(sw.data()) == result);
+    }
+}
+
+void tst_QByteArray::startsWith_char()
+{
+    QVERIFY(QByteArray("hallo").startsWith('h'));
+    QVERIFY(!QByteArray("hallo").startsWith('\0'));
+    QVERIFY(!QByteArray("hallo").startsWith('o'));
+    QVERIFY(QByteArray("h").startsWith('h'));
+    QVERIFY(!QByteArray("h").startsWith('\0'));
+    QVERIFY(!QByteArray("h").startsWith('o'));
+    QVERIFY(!QByteArray("hallo").startsWith('l'));
+    QVERIFY(!QByteArray("").startsWith('\0'));
+    QVERIFY(!QByteArray("").startsWith('a'));
+    QVERIFY(!QByteArray().startsWith('a'));
+    QVERIFY(!QByteArray().startsWith('\0'));
+}
+
+void tst_QByteArray::endsWith_data()
+{
+    QTest::addColumn<QByteArray>("ba");
+    QTest::addColumn<QByteArray>("sw");
+    QTest::addColumn<bool>("result");
+
+    QTest::newRow("01") << QByteArray() << QByteArray() << true;
+    QTest::newRow("02") << QByteArray() << QByteArray("") << true;
+    QTest::newRow("03") << QByteArray() << QByteArray("hallo") << false;
+
+    QTest::newRow("04") << QByteArray("") << QByteArray() << true;
+    QTest::newRow("05") << QByteArray("") << QByteArray("") << true;
+    QTest::newRow("06") << QByteArray("") << QByteArray("h") << false;
+
+    QTest::newRow("07") << QByteArray("hallo") << QByteArray("o") << true;
+    QTest::newRow("08") << QByteArray("hallo") << QByteArray("hallo") << true;
+    QTest::newRow("09") << QByteArray("hallo") << QByteArray("") << true;
+    QTest::newRow("10") << QByteArray("hallo") << QByteArray("hallohallo") << false;
+    QTest::newRow("11") << QByteArray("hallo") << QByteArray() << true;
+}
+
+void tst_QByteArray::endsWith()
+{
+    QFETCH(QByteArray, ba);
+    QFETCH(QByteArray, sw);
+    QFETCH(bool, result);
+
+    QVERIFY(ba.endsWith(sw) == result);
+
+    if (sw.isNull()) {
+        QVERIFY(ba.endsWith((char*)0) == result);
+    } else {
+        QVERIFY(ba.endsWith(sw.data()) == result);
+    }
+}
+
+void tst_QByteArray::endsWith_char()
+{
+    QVERIFY(QByteArray("hallo").endsWith('o'));
+    QVERIFY(!QByteArray("hallo").endsWith('\0'));
+    QVERIFY(!QByteArray("hallo").endsWith('h'));
+    QVERIFY(QByteArray("h").endsWith('h'));
+    QVERIFY(!QByteArray("h").endsWith('\0'));
+    QVERIFY(!QByteArray("h").endsWith('o'));
+    QVERIFY(!QByteArray("hallo").endsWith('l'));
+    QVERIFY(!QByteArray("").endsWith('\0'));
+    QVERIFY(!QByteArray("").endsWith('a'));
+    QVERIFY(!QByteArray().endsWith('a'));
+    QVERIFY(!QByteArray().endsWith('\0'));
+}
+
+void tst_QByteArray::split_data()
+{
+    QTest::addColumn<QByteArray>("sample");
+    QTest::addColumn<int>("size");
+
+    QTest::newRow("1") << QByteArray("-rw-r--r--  1 0  0  519240 Jul  9  2002 bigfile")
+		    << 14;
+    QTest::newRow("2") << QByteArray("abcde") << 1;
+    QTest::newRow("one empty") << QByteArray("") << 1;
+    QTest::newRow("two empty") << QByteArray(" ") << 2;
+    QTest::newRow("three empty") << QByteArray("  ") << 3;
+
+}
+
+void tst_QByteArray::split()
+{
+    QFETCH(QByteArray, sample);
+    QFETCH(int, size);
+
+    QList<QByteArray> list = sample.split(' ');
+    QCOMPARE(list.count(), size);
+}
+
+void tst_QByteArray::base64_data()
+{
+    QTest::addColumn<QByteArray>("rawdata");
+    QTest::addColumn<QByteArray>("base64");
+
+    QTest::newRow("1") << QByteArray("") << QByteArray("");
+    QTest::newRow("2") << QByteArray("1") << QByteArray("MQ==");
+    QTest::newRow("3") << QByteArray("12") << QByteArray("MTI=");
+    QTest::newRow("4") << QByteArray("123") << QByteArray("MTIz");
+    QTest::newRow("5") << QByteArray("1234") << QByteArray("MTIzNA==");
+    QTest::newRow("6") << QByteArray("\n") << QByteArray("Cg==");
+    QTest::newRow("7") << QByteArray("a\n") << QByteArray("YQo=");
+    QTest::newRow("8") << QByteArray("ab\n") << QByteArray("YWIK");
+    QTest::newRow("9") << QByteArray("abc\n") << QByteArray("YWJjCg==");
+    QTest::newRow("a") << QByteArray("abcd\n") << QByteArray("YWJjZAo=");
+    QTest::newRow("b") << QByteArray("abcde\n") << QByteArray("YWJjZGUK");
+    QTest::newRow("c") << QByteArray("abcdef\n") << QByteArray("YWJjZGVmCg==");
+    QTest::newRow("d") << QByteArray("abcdefg\n") << QByteArray("YWJjZGVmZwo=");
+    QTest::newRow("e") << QByteArray("abcdefgh\n") << QByteArray("YWJjZGVmZ2gK");
+
+    QByteArray ba;
+    ba.resize(256);
+    for (int i = 0; i < 256; ++i)
+        ba[i] = i;
+    QTest::newRow("f") << ba << QByteArray("AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6e3x9fn+AgYKDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmqq6ytrq+wsbKztLW2t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna29zd3t/g4eLj5OXm5+jp6uvs7e7v8PHy8/T19vf4+fr7/P3+/w==");
+}
+
+
+void tst_QByteArray::base64()
+{
+    QFETCH(QByteArray, rawdata);
+    QFETCH(QByteArray, base64);
+
+    QByteArray arr = QByteArray::fromBase64(base64);
+    QCOMPARE(arr, rawdata);
+
+    QByteArray arr64 = rawdata.toBase64();
+    QCOMPARE(arr64, base64);
+}
+
+void tst_QByteArray::qvsnprintf()
+{
+    char buf[20];
+    qMemSet(buf, 42, sizeof(buf));
+
+    QCOMPARE(::qsnprintf(buf, 10, "%s", "bubu"), 4);
+    QCOMPARE(static_cast<const char *>(buf), "bubu");
+    QCOMPARE(buf[5], char(42));
+
+    qMemSet(buf, 42, sizeof(buf));
+    QCOMPARE(::qsnprintf(buf, 5, "%s", "bubu"), 4);
+    QCOMPARE(static_cast<const char *>(buf), "bubu");
+    QCOMPARE(buf[5], char(42));
+
+    qMemSet(buf, 42, sizeof(buf));
+#ifdef Q_OS_WIN
+    // VS 2005 uses the Qt implementation of vsnprintf.
+# if defined(_MSC_VER) && _MSC_VER >= 1400 && !defined(Q_OS_WINCE)
+    QCOMPARE(::qsnprintf(buf, 3, "%s", "bubu"), -1);
+    QCOMPARE(static_cast<const char*>(buf), "bu");
+# else
+    // windows has to do everything different, of course.
+    QCOMPARE(::qsnprintf(buf, 3, "%s", "bubu"), -1);
+    buf[19] = '\0';
+    QCOMPARE(static_cast<const char *>(buf), "bub****************");
+# endif
+#else
+#ifdef Q_OS_IRIX
+    // Irix reports back the amount of characters written without the \0
+    QCOMPARE(::qsnprintf(buf, 3, "%s", "bubu"), 2);
+#else
+    // Every other system in this world reports the amount of data that could have been written
+    QCOMPARE(::qsnprintf(buf, 3, "%s", "bubu"), 4);
+#endif
+    QCOMPARE(static_cast<const char*>(buf), "bu");
+#endif
+    QCOMPARE(buf[4], char(42));
+
+#ifndef Q_OS_WIN
+    qMemSet(buf, 42, sizeof(buf));
+    QCOMPARE(::qsnprintf(buf, 10, ""), 0);
+#endif
+}
+
+
+void tst_QByteArray::qstrlen()
+{
+    const char *src = "Something about ... \0 a string.";
+    QCOMPARE(::qstrlen((char*)0), (uint)0);
+    QCOMPARE(::qstrlen(src), (uint)20);
+}
+
+void tst_QByteArray::qstrnlen()
+{
+    const char *src = "Something about ... \0 a string.";
+    QCOMPARE(::qstrnlen((char*)0, 1), (uint)0);
+    QCOMPARE(::qstrnlen(src, 31), (uint)20);
+    QCOMPARE(::qstrnlen(src, 19), (uint)19);
+    QCOMPARE(::qstrnlen(src, 21), (uint)20);
+    QCOMPARE(::qstrnlen(src, 20), (uint)20);
+}
+
+void tst_QByteArray::qstrcpy()
+{
+    const char *src = "Something about ... \0 a string.";
+    const char *expected = "Something about ... ";
+    char dst[128];
+
+    QCOMPARE(::qstrcpy(0, 0), (char*)0);
+    QCOMPARE(::qstrcpy(dst, 0), (char*)0);
+
+    QCOMPARE(::qstrcpy(dst ,src), (char *)dst);
+    QCOMPARE((char *)dst, const_cast<char *>(expected));
+}
+
+void tst_QByteArray::qstrncpy()
+{
+    QByteArray src(1024, 'a'), dst(1024, 'b');
+
+    // singularities
+    QCOMPARE(::qstrncpy(0, 0,0), (char*)0);
+    QCOMPARE(::qstrncpy(dst.data(), 0, 0), (char*)0);
+
+    // normal copy
+    QCOMPARE(::qstrncpy(dst.data(), src.data(), src.size()), dst.data());
+
+    src = QByteArray( "Tumdelidum" );
+    QCOMPARE(QByteArray(::qstrncpy(dst.data(), src.data(), src.size())),
+            QByteArray("Tumdelidu"));
+
+    // normal copy with length is longer than neccessary
+    src = QByteArray( "Tumdelidum\0foo" );
+    dst.resize(128*1024);
+    QCOMPARE(QByteArray(::qstrncpy(dst.data(), src.data(), dst.size())),
+            QByteArray("Tumdelidum"));
+}
+
+void tst_QByteArray::qstricmp_data()
+{
+    QTest::addColumn<QString>("str1");
+    QTest::addColumn<QString>("str2");
+
+    QTest::newRow("equal   1") << "abcEdb"  << "abcEdb";
+    QTest::newRow("equal   2") << "abcEdb"  << "ABCeDB";
+    QTest::newRow("equal   3") << "ABCEDB"  << "abcedb";
+    QTest::newRow("less    1") << "abcdef"  << "abcdefg";
+    QTest::newRow("less    2") << "abcdeF"  << "abcdef";
+    QTest::newRow("greater 1") << "abcdef"  << "abcdeF";
+    QTest::newRow("greater 2") << "abcdefg" << "abcdef";
+}
+
+void tst_QByteArray::qstricmp()
+{
+    QFETCH(QString, str1);
+    QFETCH(QString, str2);
+
+    int expected = strcmp(str1.toUpper().toLatin1(),
+                          str2.toUpper().toLatin1());
+    if ( expected != 0 ) {
+        expected = (expected < 0 ? -1 : 1);
+    }
+    int actual = ::qstricmp(str1.toLatin1(), str2.toLatin1());
+    if ( actual != 0 ) {
+        actual = (actual < 0 ? -1 : 1);
+    }
+    QCOMPARE(expected, actual);
+}
+
+void tst_QByteArray::qstricmp_singularities()
+{
+    QCOMPARE(::qstricmp(0, 0), 0);
+    QVERIFY(::qstricmp(0, "a") != 0);
+    QVERIFY(::qstricmp("a", 0) != 0);
+    QCOMPARE(::qstricmp("", ""), 0);
+}
+
+void tst_QByteArray::qstrnicmp_singularities()
+{
+    QCOMPARE(::qstrnicmp(0, 0, 123), 0);
+    QVERIFY(::qstrnicmp(0, "a", 123) != 0);
+    QVERIFY(::qstrnicmp("a", 0, 123) != 0);
+    QCOMPARE(::qstrnicmp("", "", 123), 0);
+    QCOMPARE(::qstrnicmp("a", "B", 0), 0);
+}
+
+void tst_QByteArray::chop_data()
+{
+    QTest::addColumn<QByteArray>("src");
+    QTest::addColumn<int>("choplength");
+    QTest::addColumn<QByteArray>("expected");
+
+    QTest::newRow("1") << QByteArray("short1") << 128 << QByteArray();
+    QTest::newRow("2") << QByteArray("short2") << int(strlen("short2"))
+                    << QByteArray();
+    QTest::newRow("3") << QByteArray("abcdef\0foo", 10) << 2
+                    << QByteArray("abcdef\0f", 8);
+    QTest::newRow("4") << QByteArray("STARTTLS\r\n") << 2
+                    << QByteArray("STARTTLS");
+    QTest::newRow("5") << QByteArray("") << 1 << QByteArray();
+    QTest::newRow("6") << QByteArray("foo") << 0 << QByteArray("foo");
+    QTest::newRow("7") << QByteArray(0) << 28 << QByteArray();
+}
+
+void tst_QByteArray::chop()
+{
+    QFETCH(QByteArray, src);
+    QFETCH(int, choplength);
+    QFETCH(QByteArray, expected);
+
+    src.chop(choplength);
+    QCOMPARE(src, expected);
+}
+
+void tst_QByteArray::prepend()
+{
+    QByteArray ba("foo");
+    QCOMPARE(ba.prepend((char*)0), QByteArray("foo"));
+    QCOMPARE(ba.prepend(QByteArray()), QByteArray("foo"));
+    QCOMPARE(ba.prepend("1"), QByteArray("1foo"));
+    QCOMPARE(ba.prepend(QByteArray("2")), QByteArray("21foo"));
+    QCOMPARE(ba.prepend('3'), QByteArray("321foo"));
+}
+
+void tst_QByteArray::append()
+{
+    QByteArray ba("foo");
+    QCOMPARE(ba.append((char*)0), QByteArray("foo"));
+    QCOMPARE(ba.append(QByteArray()), QByteArray("foo"));
+    QCOMPARE(ba.append("1"), QByteArray("foo1"));
+    QCOMPARE(ba.append(QByteArray("2")), QByteArray("foo12"));
+    QCOMPARE(ba.append('3'), QByteArray("foo123"));
+}
+
+void tst_QByteArray::insert()
+{
+    QByteArray ba("Meal");
+    QCOMPARE(ba.insert(1, QByteArray("ontr")), QByteArray("Montreal"));
+    QCOMPARE(ba.insert(ba.size(), "foo"), QByteArray("Montrealfoo"));
+
+    ba = QByteArray("13");
+    QCOMPARE(ba.insert(1, QByteArray("2")), QByteArray("123"));
+
+    ba = "ac";
+    QCOMPARE(ba.insert(1, 'b'), QByteArray("abc"));
+    QCOMPARE(ba.size(), 3);
+
+    ba = "ikl";
+    QCOMPARE(ba.insert(1, "j"), QByteArray("ijkl"));
+    QCOMPARE(ba.size(), 4);
+}
+
+void tst_QByteArray::remove_data()
+{
+    QTest::addColumn<QByteArray>("src");
+    QTest::addColumn<int>("position");
+    QTest::addColumn<int>("length");
+    QTest::addColumn<QByteArray>("expected");
+
+    QTest::newRow("1") << QByteArray("Montreal") << 1 << 4
+                    << QByteArray("Meal");
+    QTest::newRow("2") << QByteArray() << 10 << 10 << QByteArray();
+    QTest::newRow("3") << QByteArray("hi") << 0 << 10 << QByteArray();
+    QTest::newRow("4") << QByteArray("Montreal") << 4 << 100
+                    << QByteArray("Mont");
+
+    // index out of range
+    QTest::newRow("5") << QByteArray("Montreal") << 8 << 1
+                    << QByteArray("Montreal");
+    QTest::newRow("6") << QByteArray("Montreal") << 18 << 4
+                    << QByteArray("Montreal");
+}
+
+void tst_QByteArray::remove()
+{
+    QFETCH(QByteArray, src);
+    QFETCH(int, position);
+    QFETCH(int, length);
+    QFETCH(QByteArray, expected);
+    QCOMPARE(src.remove(position, length), expected);
+}
+
+void tst_QByteArray::replace_data()
+{
+    QTest::addColumn<QByteArray>("src");
+    QTest::addColumn<int>("pos");
+    QTest::addColumn<int>("len");
+    QTest::addColumn<QByteArray>("after");
+    QTest::addColumn<QByteArray>("expected");
+
+    QTest::newRow("1") << QByteArray("Say yes!") << 4 << 3
+                    << QByteArray("no") << QByteArray("Say no!");
+    QTest::newRow("2") << QByteArray("rock and roll") << 5 << 3
+                    << QByteArray("&") << QByteArray("rock & roll");
+    QTest::newRow("3") << QByteArray("foo") << 3 << 0 << QByteArray("bar")
+                    << QByteArray("foobar");
+    QTest::newRow("4") << QByteArray() << 0 << 0 << QByteArray() << QByteArray();
+    // index out of range
+    QTest::newRow("5") << QByteArray() << 3 << 0 << QByteArray("hi")
+                    << QByteArray("   hi");
+    // Optimized path
+    QTest::newRow("6") << QByteArray("abcdef") << 3 << 12 << QByteArray("abcdefghijkl") << QByteArray("abcabcdefghijkl");
+    QTest::newRow("7") << QByteArray("abcdef") << 3 << 4  << QByteArray("abcdefghijkl") << QByteArray("abcabcdefghijkl");
+    QTest::newRow("8") << QByteArray("abcdef") << 3 << 3  << QByteArray("abcdefghijkl") << QByteArray("abcabcdefghijkl");
+    QTest::newRow("9") << QByteArray("abcdef") << 3 << 2  << QByteArray("abcdefghijkl") << QByteArray("abcabcdefghijklf");
+    QTest::newRow("10") << QByteArray("abcdef") << 2 << 2  << QByteArray("xx") << QByteArray("abxxef");
+}
+
+void tst_QByteArray::replace()
+{
+    QFETCH(QByteArray, src);
+    QFETCH(int, pos);
+    QFETCH(int, len);
+    QFETCH(QByteArray, after);
+    QFETCH(QByteArray, expected);
+
+    QByteArray str1 = src;
+    QByteArray str2 = src;
+
+    QCOMPARE(str1.replace(pos, len, after).constData(), expected.constData());
+    QCOMPARE(str2.replace(pos, len, after.data()), expected);
+}
+
+void tst_QByteArray::indexOf_data()
+{
+    QTest::addColumn<QByteArray>("haystack");
+    QTest::addColumn<QByteArray>("needle");
+    QTest::addColumn<int>("startpos");
+    QTest::addColumn<int>("expected");
+
+    QTest::newRow( "1" ) << QByteArray("abc") << QByteArray("a") << 0 << 0;
+    QTest::newRow( "2" ) << QByteArray("abc") << QByteArray("A") << 0 << -1;
+    QTest::newRow( "3" ) << QByteArray("abc") << QByteArray("a") << 1 << -1;
+    QTest::newRow( "4" ) << QByteArray("abc") << QByteArray("A") << 1 << -1;
+    QTest::newRow( "5" ) << QByteArray("abc") << QByteArray("b") << 0 << 1;
+    QTest::newRow( "6" ) << QByteArray("abc") << QByteArray("B") << 0 << -1;
+    QTest::newRow( "7" ) << QByteArray("abc") << QByteArray("b") << 1 << 1;
+    QTest::newRow( "8" ) << QByteArray("abc") << QByteArray("B") << 1 << -1;
+    QTest::newRow( "9" ) << QByteArray("abc") << QByteArray("b") << 2 << -1;
+    QTest::newRow( "10" ) << QByteArray("abc") << QByteArray("c") << 0 << 2;
+    QTest::newRow( "11" ) << QByteArray("abc") << QByteArray("C") << 0 << -1;
+    QTest::newRow( "12" ) << QByteArray("abc") << QByteArray("c") << 1 << 2;
+    QTest::newRow( "13" ) << QByteArray("abc") << QByteArray("C") << 1 << -1;
+    QTest::newRow( "14" ) << QByteArray("abc") << QByteArray("c") << 2 << 2;
+    QTest::newRow( "15" ) << QByteArray("aBc") << QByteArray("bc") << 0 << -1;
+    QTest::newRow( "16" ) << QByteArray("aBc") << QByteArray("Bc") << 0 << 1;
+    QTest::newRow( "17" ) << QByteArray("aBc") << QByteArray("bC") << 0 << -1;
+    QTest::newRow( "18" ) << QByteArray("aBc") << QByteArray("BC") << 0 << -1;
+
+    // task 203692
+    static const char h19[] = {'x', 0x00, 0xe7, 0x25, 0x1c, 0x0a};
+    static const char n19[] = {0x00, 0x00, 0x01, 0x00};
+    QTest::newRow( "19" ) << QByteArray(h19, sizeof(h19))
+                          << QByteArray(n19, sizeof(n19)) << 0 << -1;
+
+    QTest::newRow( "empty" ) << QByteArray("") << QByteArray("x") << 0 << -1;
+    QTest::newRow( "null" ) << QByteArray() << QByteArray("x") << 0 << -1;
+    QTest::newRow( "null-in-null") << QByteArray() << QByteArray() << 0 << 0;
+    QTest::newRow( "empty-in-null") << QByteArray() << QByteArray("") << 0 << 0;
+    QTest::newRow( "null-in-empty") << QByteArray("") << QByteArray() << 0 << 0;
+    QTest::newRow( "empty-in-empty") << QByteArray("") << QByteArray("") << 0 << 0;
+
+    QByteArray veryBigHaystack(500, 'a');
+    veryBigHaystack += 'B';
+    QTest::newRow("BoyerMooreStressTest") << veryBigHaystack << veryBigHaystack << 0 << 0;
+    QTest::newRow("BoyerMooreStressTest2") << veryBigHaystack + 'c' << veryBigHaystack << 0 << 0;
+    QTest::newRow("BoyerMooreStressTest3") << 'c' + veryBigHaystack << veryBigHaystack << 0 << 1;
+    QTest::newRow("BoyerMooreStressTest4") << veryBigHaystack << veryBigHaystack + 'c' << 0 << -1;
+    QTest::newRow("BoyerMooreStressTest5") << veryBigHaystack << 'c' + veryBigHaystack << 0 << -1;
+    QTest::newRow("BoyerMooreStressTest6") << 'd' + veryBigHaystack << 'c' + veryBigHaystack << 0 << -1;
+    QTest::newRow("BoyerMooreStressTest6") << veryBigHaystack + 'c' << 'c' + veryBigHaystack << 0 << -1;
+}
+
+void tst_QByteArray::indexOf()
+{
+    QFETCH( QByteArray, haystack );
+    QFETCH( QByteArray, needle );
+    QFETCH( int, startpos );
+    QFETCH( int, expected );
+
+    bool hasNull = needle.contains('\0');
+
+    QCOMPARE( haystack.indexOf(needle, startpos), expected );
+    if (!hasNull)
+        QCOMPARE( haystack.indexOf(needle.data(), startpos), expected );
+    if (needle.size() == 1)
+        QCOMPARE( haystack.indexOf(needle.at(0), startpos), expected );
+
+    if (startpos == 0) {
+        QCOMPARE( haystack.indexOf(needle), expected );
+        if (!hasNull)
+            QCOMPARE( haystack.indexOf(needle.data()), expected );
+        if (needle.size() == 1)
+            QCOMPARE( haystack.indexOf(needle.at(0)), expected );
+    }
+}
+
+void tst_QByteArray::lastIndexOf_data()
+{
+    QTest::addColumn<QByteArray>("haystack");
+    QTest::addColumn<QByteArray>("needle");
+    QTest::addColumn<int>("startpos");
+    QTest::addColumn<int>("expected");
+
+    QTest::newRow( "1" ) << QByteArray("abc") << QByteArray("a") << 0 << 0;
+    QTest::newRow( "2" ) << QByteArray("abc") << QByteArray("A") << 0 << -1;
+    QTest::newRow( "3" ) << QByteArray("abc") << QByteArray("a") << 1 << 0;
+    QTest::newRow( "4" ) << QByteArray("abc") << QByteArray("A") << 1 << -1;
+    QTest::newRow( "5" ) << QByteArray("abc") << QByteArray("a") << -1 << 0;
+    QTest::newRow( "6" ) << QByteArray("abc") << QByteArray("b") << 0 << -1;
+    QTest::newRow( "7" ) << QByteArray("abc") << QByteArray("B") << 0 << -1;
+    QTest::newRow( "8" ) << QByteArray("abc") << QByteArray("b") << 1 << 1;
+    QTest::newRow( "9" ) << QByteArray("abc") << QByteArray("B") << 1 << -1;
+    QTest::newRow( "10" ) << QByteArray("abc") << QByteArray("b") << 2 << 1;
+    QTest::newRow( "11" ) << QByteArray("abc") << QByteArray("b") << -1 << 1;
+    QTest::newRow( "12" ) << QByteArray("abc") << QByteArray("c") << 0 << -1;
+    QTest::newRow( "13" ) << QByteArray("abc") << QByteArray("C") << 0 << -1;
+    QTest::newRow( "14" ) << QByteArray("abc") << QByteArray("c") << 1 << -1;
+    QTest::newRow( "15" ) << QByteArray("abc") << QByteArray("C") << 1 << -1;
+    QTest::newRow( "16" ) << QByteArray("abc") << QByteArray("c") << 2 << 2;
+    QTest::newRow( "17" ) << QByteArray("abc") << QByteArray("c") << -1 << 2;
+    QTest::newRow( "18" ) << QByteArray("aBc") << QByteArray("bc") << 0 << -1;
+    QTest::newRow( "19" ) << QByteArray("aBc") << QByteArray("Bc") << 0 << -1;
+    QTest::newRow( "20" ) << QByteArray("aBc") << QByteArray("Bc") << 2 << 1;
+    QTest::newRow( "21" ) << QByteArray("aBc") << QByteArray("Bc") << 1 << 1;
+    QTest::newRow( "22" ) << QByteArray("aBc") << QByteArray("Bc") << -1 << 1;
+    QTest::newRow( "23" ) << QByteArray("aBc") << QByteArray("bC") << 0 << -1;
+    QTest::newRow( "24" ) << QByteArray("aBc") << QByteArray("BC") << 0 << -1;
+
+    // task 203692
+    static const char h25[] = {0x00, 0xbc, 0x03, 0x10, 0x0a };
+    static const char n25[] = {0x00, 0x00, 0x01, 0x00};
+    QTest::newRow( "25" ) << QByteArray(h25, sizeof(h25))
+                          << QByteArray(n25, sizeof(n25)) << 0 << -1;
+
+    QTest::newRow( "empty" ) << QByteArray("") << QByteArray("x") << -1 << -1;
+    QTest::newRow( "null" ) << QByteArray() << QByteArray("x") << -1 << -1;
+    QTest::newRow( "null-in-null") << QByteArray() << QByteArray() << -1 << 0;
+    QTest::newRow( "empty-in-null") << QByteArray() << QByteArray("") << -1 << 0;
+    QTest::newRow( "null-in-empty") << QByteArray("") << QByteArray() << -1 << 0;
+    QTest::newRow( "empty-in-empty") << QByteArray("") << QByteArray("") << -1 << 0;
+}
+
+void tst_QByteArray::lastIndexOf()
+{
+    QFETCH( QByteArray, haystack );
+    QFETCH( QByteArray, needle );
+    QFETCH( int, startpos );
+    QFETCH( int, expected );
+
+    bool hasNull = needle.contains('\0');
+
+    QCOMPARE( haystack.lastIndexOf(needle, startpos), expected );
+    if (!hasNull)
+        QCOMPARE( haystack.lastIndexOf(needle.data(), startpos), expected );
+    if (needle.size() == 1)
+	QCOMPARE( haystack.lastIndexOf(needle.at(0), startpos), expected );
+
+    if (startpos == -1) {
+	QCOMPARE( haystack.lastIndexOf(needle), expected );
+        if (!hasNull)
+            QCOMPARE( haystack.lastIndexOf(needle.data()), expected );
+	if (needle.size() == 1)
+	    QCOMPARE( haystack.lastIndexOf(needle.at(0)), expected );
+    }
+}
+
+void tst_QByteArray::number()
+{
+    QCOMPARE(QString(QByteArray::number((quint64) 0)),
+	    QString(QByteArray("0")));
+    QCOMPARE(QString(QByteArray::number(Q_UINT64_C(0xFFFFFFFFFFFFFFFF))),
+	    QString(QByteArray("18446744073709551615")));
+    QCOMPARE(QString(QByteArray::number(Q_INT64_C(0xFFFFFFFFFFFFFFFF))),
+	    QString(QByteArray("-1")));
+    QCOMPARE(QString(QByteArray::number(qint64(0))),
+	    QString(QByteArray("0")));
+    QCOMPARE(QString(QByteArray::number(Q_INT64_C(0x7FFFFFFFFFFFFFFF))),
+	    QString(QByteArray("9223372036854775807")));
+    QCOMPARE(QString(QByteArray::number(Q_INT64_C(0x8000000000000000))),
+	    QString(QByteArray("-9223372036854775808")));
+}
+
+// defined later
+extern const char globalChar;
+
+void tst_QByteArray::toInt_data()
+{
+    QTest::addColumn<QByteArray>("string");
+    QTest::addColumn<int>("base");
+    QTest::addColumn<int>("expectednumber");
+    QTest::addColumn<bool>("expectedok");
+
+    QTest::newRow("base 10") << QByteArray("100") << 10 << int(100) << true;
+    QTest::newRow("base 16") << QByteArray("100") << 16 << int(256) << true;
+    QTest::newRow("base 16") << QByteArray("0400") << 16 << int(1024) << true;
+    QTest::newRow("base 2") << QByteArray("1111") << 2 << int(15) << true;
+    QTest::newRow("base 8") << QByteArray("100") << 8 << int(64) << true;
+    QTest::newRow("base 0") << QByteArray("0x10") << 0 << int(16) << true;
+    QTest::newRow("base 0") << QByteArray("10") << 0 << int(10) << true;
+    QTest::newRow("base 0") << QByteArray("010") << 0 << int(8) << true;
+    QTest::newRow("empty") << QByteArray() << 0 << int(0) << false;
+
+    // using fromRawData
+    QTest::newRow("raw1") << QByteArray::fromRawData("1", 1) << 10 << 1 << true;
+    QTest::newRow("raw2") << QByteArray::fromRawData("1foo", 1) << 10 << 1 << true;
+    QTest::newRow("raw3") << QByteArray::fromRawData("12", 1) << 10 << 1 << true;
+    QTest::newRow("raw4") << QByteArray::fromRawData("123456789", 1) << 10 << 1 << true;
+    QTest::newRow("raw4") << QByteArray::fromRawData("123456789", 2) << 10 << 12 << true;
+
+    QTest::newRow("raw-static") << QByteArray::fromRawData(&globalChar, 1) << 10 << 1 << true;
+}
+
+void tst_QByteArray::toInt()
+{
+    QFETCH( QByteArray, string );
+    QFETCH( int, base );
+    QFETCH( int, expectednumber );
+    QFETCH( bool, expectedok );
+
+    bool ok;
+    int number = string.toInt(&ok, base);
+
+    QCOMPARE( ok, expectedok );
+    QCOMPARE( number, expectednumber );
+}
+
+Q_DECLARE_METATYPE(qulonglong);
+void tst_QByteArray::toULong_data()
+{
+    QTest::addColumn<QByteArray>("str");
+    QTest::addColumn<int>("base");
+    QTest::addColumn<ulong>("result");
+    QTest::addColumn<bool>("ok");
+
+    ulong LongMaxPlusOne = (ulong)LONG_MAX + 1;
+    QTest::newRow("LONG_MAX+1") << QString::number(LongMaxPlusOne).toLatin1() << 10 << LongMaxPlusOne << true;
+    QTest::newRow("default") << QByteArray() << 10 << 0UL << FALSE;
+    QTest::newRow("empty") << QByteArray("") << 10 << 0UL << FALSE;
+    QTest::newRow("ulong1") << QByteArray("3234567890") << 10 << 3234567890UL << true;
+    QTest::newRow("ulong2") << QByteArray("fFFfFfFf") << 16 << 0xFFFFFFFFUL << true;
+}
+
+void tst_QByteArray::toULong()
+{
+    QFETCH(QByteArray, str);
+    QFETCH(int, base);
+    QFETCH(ulong, result);
+    QFETCH(bool, ok);
+
+    bool b;
+    QCOMPARE(str.toULong(0, base), result);
+    QCOMPARE(str.toULong(&b, base), result);
+    QCOMPARE(b, ok);
+}
+
+void tst_QByteArray::toULongLong_data()
+{
+    QTest::addColumn<QByteArray>("str");
+    QTest::addColumn<int>("base");
+    QTest::addColumn<qulonglong>("result");
+    QTest::addColumn<bool>("ok");
+
+    QTest::newRow("default") << QByteArray() << 10 << (qulonglong)0 << FALSE;
+    QTest::newRow("out of base bound") << QByteArray("c") << 10 << (qulonglong)0 << FALSE;
+
+}
+
+void tst_QByteArray::toULongLong()
+{
+    QFETCH(QByteArray, str);
+    QFETCH(int, base);
+    QFETCH(qulonglong, result);
+    QFETCH(bool, ok);
+
+    bool b;
+    QCOMPARE(str.toULongLong(0, base), result);
+    QCOMPARE(str.toULongLong(&b, base), result);
+    QCOMPARE(b, ok);
+}
+
+// global function defined in qbytearray.cpp
+void tst_QByteArray::qAllocMore()
+{
+    static const int t[] = {
+        INT_MIN, INT_MIN + 1, -1234567, -66000, -1025,
+        -3, -1, 0, +1, +3, +1025, +66000, +1234567, INT_MAX - 1, INT_MAX,
+        INT_MAX/3
+    };
+    static const int N = sizeof(t)/sizeof(t[0]);
+
+    // make sure qAllocMore() doesn't loop infinitely on any input
+    for (int i = 0; i < N; ++i) {
+        for (int j = 0; j < N; ++j) {
+            ::qAllocMore(t[i], t[j]);
+        }
+    }
+}
+
+void tst_QByteArray::resizeAfterFromRawData()
+{
+    QByteArray buffer("hello world");
+
+    QByteArray array = QByteArray::fromRawData(buffer.constData(), buffer.size());
+    QVERIFY(array.constData() == buffer.constData());
+    array.resize(5);
+    QVERIFY(array.constData() == buffer.constData());
+}
+
+void tst_QByteArray::appendAfterFromRawData()
+{
+    QByteArray arr;
+    {
+        char data[] = "X";
+        arr += QByteArray::fromRawData(data, sizeof(data));
+        data[0] = 'Y';
+    }
+    QVERIFY(arr.at(0) == 'X');
+}
+
+void tst_QByteArray::toFromHex_data()
+{
+    QTest::addColumn<QByteArray>("str");
+    QTest::addColumn<QByteArray>("hex");
+    QTest::addColumn<QByteArray>("hex_alt1");
+
+    QTest::newRow("Qt is great!")
+        << QByteArray("Qt is great!")
+        << QByteArray("517420697320677265617421")
+        << QByteArray("51 74 20 69 73 20 67 72 65 61 74 21");
+
+    QTest::newRow("Qt is so great!")
+        << QByteArray("Qt is so great!")
+        << QByteArray("517420697320736f20677265617421")
+        << QByteArray("51 74 20 69 73 20 73 6f 20 67 72 65 61 74 21");
+
+    QTest::newRow("default-constructed")
+        << QByteArray()
+        << QByteArray()
+        << QByteArray();
+
+    QTest::newRow("empty")
+        << QByteArray("")
+        << QByteArray("")
+        << QByteArray("");
+
+    QTest::newRow("array-of-null")
+        << QByteArray("\0", 1)
+        << QByteArray("00")
+        << QByteArray("0");
+
+    QTest::newRow("no-leading-zero")
+        << QByteArray("\xf")
+        << QByteArray("0f")
+        << QByteArray("f");
+
+    QTest::newRow("single-byte")
+        << QByteArray("\xaf")
+        << QByteArray("af")
+        << QByteArray("xaf");
+
+    QTest::newRow("no-leading-zero")
+        << QByteArray("\xd\xde\xad\xc0\xde")
+        << QByteArray("0ddeadc0de")
+        << QByteArray("ddeadc0de");
+
+    QTest::newRow("garbage")
+        << QByteArray("\xC\xde\xeC\xea\xee\xDe\xee\xee")
+        << QByteArray("0cdeeceaeedeeeee")
+        << QByteArray("Code less. Create more. Deploy everywhere.");
+
+    QTest::newRow("under-defined-1")
+        << QByteArray("\x1\x23")
+        << QByteArray("0123")
+        << QByteArray("x123");
+
+    QTest::newRow("under-defined-2")
+        << QByteArray("\x12\x34")
+        << QByteArray("1234")
+        << QByteArray("x1234");
+}
+
+void tst_QByteArray::toFromHex()
+{
+    QFETCH(QByteArray, str);
+    QFETCH(QByteArray, hex);
+    QFETCH(QByteArray, hex_alt1);
+
+    {
+        const QByteArray th = str.toHex();
+        QCOMPARE(th.size(), hex.size());
+        QCOMPARE(th, hex);
+    }
+
+    {
+        const QByteArray fh = QByteArray::fromHex(hex);
+        QCOMPARE(fh.size(), str.size());
+        QCOMPARE(fh, str);
+    }
+
+    QCOMPARE(QByteArray::fromHex(hex_alt1), str);
+}
+
+void tst_QByteArray::toFromPercentEncoding()
+{
+    QByteArray arr("Qt is great!");
+
+    QByteArray data = arr.toPercentEncoding();
+    QCOMPARE(QString(data), QString("Qt%20is%20great%21"));
+    QCOMPARE(QByteArray::fromPercentEncoding(data), arr);
+
+    data = arr.toPercentEncoding("! ", "Qt");
+    QCOMPARE(QString(data), QString("%51%74 is grea%74!"));
+    QCOMPARE(QByteArray::fromPercentEncoding(data), arr);
+
+    data = arr.toPercentEncoding(QByteArray(), "abcdefghijklmnopqrstuvwxyz", 'Q');
+    QCOMPARE(QString(data), QString("Q51Q74Q20Q69Q73Q20Q67Q72Q65Q61Q74Q21"));
+    QCOMPARE(QByteArray::fromPercentEncoding(data, 'Q'), arr);
+
+    // verify that to/from percent encoding preserves nullity
+    arr = "";
+    QVERIFY(arr.isEmpty());
+    QVERIFY(!arr.isNull());
+    QVERIFY(arr.toPercentEncoding().isEmpty());
+    QVERIFY(!arr.toPercentEncoding().isNull());
+    QVERIFY(QByteArray::fromPercentEncoding("").isEmpty());
+    QVERIFY(!QByteArray::fromPercentEncoding("").isNull());
+
+    arr = QByteArray();
+    QVERIFY(arr.isEmpty());
+    QVERIFY(arr.isNull());
+    QVERIFY(arr.toPercentEncoding().isEmpty());
+    QVERIFY(arr.toPercentEncoding().isNull());
+    QVERIFY(QByteArray::fromPercentEncoding(QByteArray()).isEmpty());
+    QVERIFY(QByteArray::fromPercentEncoding(QByteArray()).isNull());
+}
+
+void tst_QByteArray::compare_data()
+{
+    QTest::addColumn<QByteArray>("str1");
+    QTest::addColumn<QByteArray>("str2");
+    QTest::addColumn<int>("result");
+
+    QTest::newRow("null")      << QByteArray() << QByteArray() << 0;
+    QTest::newRow("null-empty")<< QByteArray() << QByteArray("") << 0;
+    QTest::newRow("empty-null")<< QByteArray("") << QByteArray() << 0;
+    QTest::newRow("null-full") << QByteArray() << QByteArray("abc") << -1;
+    QTest::newRow("full-null") << QByteArray("abc") << QByteArray() << +1;
+    QTest::newRow("empty-full")<< QByteArray("") << QByteArray("abc") << -1;
+    QTest::newRow("full-empty")<< QByteArray("abc") << QByteArray("") << +1;
+    QTest::newRow("rawempty-full") << QByteArray::fromRawData("abc", 0) << QByteArray("abc") << -1;
+    QTest::newRow("full-rawempty") << QByteArray("abc") << QByteArray::fromRawData("abc", 0) << +1;
+
+    QTest::newRow("equal   1") << QByteArray("abc") << QByteArray("abc") << 0;
+    QTest::newRow("equal   2") << QByteArray::fromRawData("abc", 3) << QByteArray("abc") << 0;
+    QTest::newRow("equal   3") << QByteArray::fromRawData("abcdef", 3) << QByteArray("abc") << 0;
+    QTest::newRow("equal   4") << QByteArray("abc") << QByteArray::fromRawData("abc", 3) << 0;
+    QTest::newRow("equal   5") << QByteArray("abc") << QByteArray::fromRawData("abcdef", 3) << 0;
+    QTest::newRow("equal   6") << QByteArray("a\0bc", 4) << QByteArray("a\0bc", 4) << 0;
+    QTest::newRow("equal   7") << QByteArray::fromRawData("a\0bcdef", 4) << QByteArray("a\0bc", 4) << 0;
+    QTest::newRow("equal   8") << QByteArray("a\0bc", 4) << QByteArray::fromRawData("a\0bcdef", 4) << 0;
+
+    QTest::newRow("less    1") << QByteArray("000") << QByteArray("abc") << -1;
+    QTest::newRow("less    2") << QByteArray::fromRawData("00", 3) << QByteArray("abc") << -1;
+    QTest::newRow("less    3") << QByteArray("000") << QByteArray::fromRawData("abc", 3) << -1;
+    QTest::newRow("less    4") << QByteArray("abc", 3) << QByteArray("abc", 4) << -1;
+    QTest::newRow("less    5") << QByteArray::fromRawData("abc\0", 3) << QByteArray("abc\0", 4) << -1;
+    QTest::newRow("less    6") << QByteArray("a\0bc", 4) << QByteArray("a\0bd", 4) << -1;
+
+    QTest::newRow("greater 1") << QByteArray("abc") << QByteArray("000") << +1;
+    QTest::newRow("greater 2") << QByteArray("abc") << QByteArray::fromRawData("00", 3) << +1;
+    QTest::newRow("greater 3") << QByteArray("abcd") << QByteArray::fromRawData("abcd", 3) << +1;
+    QTest::newRow("greater 4") << QByteArray("a\0bc", 4) << QByteArray("a\0bb", 4) << +1;
+}
+
+void tst_QByteArray::compare()
+{
+    QFETCH(QByteArray, str1);
+    QFETCH(QByteArray, str2);
+    QFETCH(int, result);
+
+    const bool isEqual   = result == 0;
+    const bool isLess    = result < 0;
+    const bool isGreater = result > 0;
+
+    // basic tests:
+    QCOMPARE(str1 == str2, isEqual);
+    QCOMPARE(str1 < str2, isLess);
+    QCOMPARE(str1 > str2, isGreater);
+
+    // composed tests:
+    QCOMPARE(str1 <= str2, isLess || isEqual);
+    QCOMPARE(str1 >= str2, isGreater || isEqual);
+    QCOMPARE(str1 != str2, !isEqual);
+
+    // inverted tests:
+    QCOMPARE(str2 == str1, isEqual);
+    QCOMPARE(str2 < str1, isGreater);
+    QCOMPARE(str2 > str1, isLess);
+
+    // composed, inverted tests:
+    QCOMPARE(str2 <= str1, isGreater || isEqual);
+    QCOMPARE(str2 >= str1, isLess || isEqual);
+    QCOMPARE(str2 != str1, !isEqual);
+}
+
+void tst_QByteArray::compareCharStar_data()
+{
+    QTest::addColumn<QByteArray>("str1");
+    QTest::addColumn<QString>("string2");
+    QTest::addColumn<int>("result");
+
+    QTest::newRow("null-null") << QByteArray() << QString() << 0;
+    QTest::newRow("null-empty") << QByteArray() << "" << 0;
+    QTest::newRow("null-full") << QByteArray() << "abc" << -1;
+    QTest::newRow("empty-null") << QByteArray("") << QString() << 0;
+    QTest::newRow("empty-empty") << QByteArray("") << "" << 0;
+    QTest::newRow("empty-full") << QByteArray("") << "abc" << -1;
+    QTest::newRow("raw-null") << QByteArray::fromRawData("abc", 0) << QString() << 0;
+    QTest::newRow("raw-empty") << QByteArray::fromRawData("abc", 0) << QString("") << 0;
+    QTest::newRow("raw-full") << QByteArray::fromRawData("abc", 0) << "abc" << -1;
+
+    QTest::newRow("full-null") << QByteArray("abc") << QString() << +1;
+    QTest::newRow("full-empty") << QByteArray("abc") << "" << +1;
+
+    QTest::newRow("equal1") << QByteArray("abc") << "abc" << 0;
+    QTest::newRow("equal2") << QByteArray("abcd", 3) << "abc" << 0;
+    QTest::newRow("equal3") << QByteArray::fromRawData("abcd", 3) << "abc" << 0;
+
+    QTest::newRow("less1") << QByteArray("ab") << "abc" << -1;
+    QTest::newRow("less2") << QByteArray("abb") << "abc" << -1;
+    QTest::newRow("less3") << QByteArray::fromRawData("abc", 2) << "abc" << -1;
+    QTest::newRow("less4") << QByteArray("", 1) << "abc" << -1;
+    QTest::newRow("less5") << QByteArray::fromRawData("", 1) << "abc" << -1;
+    QTest::newRow("less6") << QByteArray("a\0bc", 4) << "a.bc" << -1;
+
+    QTest::newRow("greater1") << QByteArray("ac") << "abc" << +1;
+    QTest::newRow("greater2") << QByteArray("abd") << "abc" << +1;
+    QTest::newRow("greater3") << QByteArray("abcd") << "abc" << +1;
+    QTest::newRow("greater4") << QByteArray::fromRawData("abcd", 4) << "abc" << +1;
+}
+
+void tst_QByteArray::compareCharStar()
+{
+    QFETCH(QByteArray, str1);
+    QFETCH(QString, string2);
+    QFETCH(int, result);
+
+    const bool isEqual   = result == 0;
+    const bool isLess    = result < 0;
+    const bool isGreater = result > 0;
+    QByteArray qba = string2.toLatin1();
+    const char *str2 = qba.constData();
+    if (string2.isNull())
+        str2 = 0;
+
+    // basic tests:
+    QCOMPARE(str1 == str2, isEqual);
+    QCOMPARE(str1 < str2, isLess);
+    QCOMPARE(str1 > str2, isGreater);
+
+    // composed tests:
+    QCOMPARE(str1 <= str2, isLess || isEqual);
+    QCOMPARE(str1 >= str2, isGreater || isEqual);
+    QCOMPARE(str1 != str2, !isEqual);
+
+    // inverted tests:
+    QCOMPARE(str2 == str1, isEqual);
+    QCOMPARE(str2 < str1, isGreater);
+    QCOMPARE(str2 > str1, isLess);
+
+    // composed, inverted tests:
+    QCOMPARE(str2 <= str1, isGreater || isEqual);
+    QCOMPARE(str2 >= str1, isLess || isEqual);
+    QCOMPARE(str2 != str1, !isEqual);
+}
+
+void tst_QByteArray::repeatedSignature() const
+{
+    /* repated() should be a const member. */
+    const QByteArray string;
+    string.repeated(3);
+}
+
+void tst_QByteArray::repeated() const
+{
+    QFETCH(QByteArray, string);
+    QFETCH(QByteArray, expected);
+    QFETCH(int, count);
+
+    QCOMPARE(string.repeated(count), expected);
+}
+
+void tst_QByteArray::repeated_data() const
+{
+    QTest::addColumn<QByteArray>("string" );
+    QTest::addColumn<QByteArray>("expected" );
+    QTest::addColumn<int>("count" );
+
+    /* Empty strings. */
+    QTest::newRow("")
+        << QByteArray()
+        << QByteArray()
+        << 0;
+
+    QTest::newRow("")
+        << QByteArray()
+        << QByteArray()
+        << -1004;
+
+    QTest::newRow("")
+        << QByteArray()
+        << QByteArray()
+        << 1;
+
+    QTest::newRow("")
+        << QByteArray()
+        << QByteArray()
+        << 5;
+
+    /* On simple string. */
+    QTest::newRow("")
+        << QByteArray("abc")
+        << QByteArray()
+        << -1004;
+
+    QTest::newRow("")
+        << QByteArray("abc")
+        << QByteArray()
+        << -1;
+
+    QTest::newRow("")
+        << QByteArray("abc")
+        << QByteArray()
+        << 0;
+
+    QTest::newRow("")
+        << QByteArray("abc")
+        << QByteArray("abc")
+        << 1;
+
+    QTest::newRow("")
+        << QByteArray(("abc"))
+        << QByteArray(("abcabc"))
+        << 2;
+
+    QTest::newRow("")
+        << QByteArray(("abc"))
+        << QByteArray(("abcabcabc"))
+        << 3;
+
+    QTest::newRow("")
+        << QByteArray(("abc"))
+        << QByteArray(("abcabcabcabc"))
+        << 4;
+}
+
+void tst_QByteArray::byteRefDetaching() const
+{
+    {
+        QByteArray str = "str";
+        QByteArray copy;
+        copy[0] = 'S';
+
+        QCOMPARE(str, QByteArray("str"));
+    }
+
+    {
+        char buf[] = { 's', 't', 'r' };
+        QByteArray str = QByteArray::fromRawData(buf, 3);
+        str[0] = 'S';
+
+        QCOMPARE(buf[0], char('s'));
+    }
+
+    {
+        static const char buf[] = { 's', 't', 'r' };
+        QByteArray str = QByteArray::fromRawData(buf, 3);
+
+        // this causes a crash in most systems if the detaching doesn't work
+        str[0] = 'S';
+
+        QCOMPARE(buf[0], char('s'));
+    }
+}
+
+const char globalChar = '1';
+
+QTEST_APPLESS_MAIN(tst_QByteArray)
+#include "tst_qbytearray.moc"