summaryrefslogtreecommitdiffstats
path: root/tests/auto/corelib/tools/qbytearray
diff options
context:
space:
mode:
authorHolger Ihrig <holger.ihrig@nokia.com>2011-08-26 15:03:33 +0200
committerHolger Ihrig <holger.ihrig@nokia.com>2011-09-01 13:07:23 +0200
commit5c27f0a2fb772279fb3e4d60f7c879f5cecb3352 (patch)
tree12ef0e9acc79be2fd32b01703ee83a45fb068df1 /tests/auto/corelib/tools/qbytearray
parentceed409b40fd5b8fe5c62ac33144e66f50b28ede (diff)
Moving relevant tests to corelib/tools
Task-number: QTBUG-21066 Change-Id: I650f8f7826b9feea7c1484f06e03e10c68ec2b65 Reviewed-on: http://codereview.qt.nokia.com/3712 Reviewed-by: Qt Sanity Bot <qt_sanity_bot@ovi.com> Reviewed-by: Sergio Ahumada <sergio.ahumada@nokia.com>
Diffstat (limited to 'tests/auto/corelib/tools/qbytearray')
-rw-r--r--tests/auto/corelib/tools/qbytearray/.gitattributes1
-rw-r--r--tests/auto/corelib/tools/qbytearray/.gitignore1
-rw-r--r--tests/auto/corelib/tools/qbytearray/qbytearray.pro21
-rw-r--r--tests/auto/corelib/tools/qbytearray/rfc3252.txt899
-rw-r--r--tests/auto/corelib/tools/qbytearray/tst_qbytearray.cpp1569
5 files changed, 2491 insertions, 0 deletions
diff --git a/tests/auto/corelib/tools/qbytearray/.gitattributes b/tests/auto/corelib/tools/qbytearray/.gitattributes
new file mode 100644
index 0000000000..e04709aa2e
--- /dev/null
+++ b/tests/auto/corelib/tools/qbytearray/.gitattributes
@@ -0,0 +1 @@
+rfc3252.txt -crlf
diff --git a/tests/auto/corelib/tools/qbytearray/.gitignore b/tests/auto/corelib/tools/qbytearray/.gitignore
new file mode 100644
index 0000000000..3de7c3fab5
--- /dev/null
+++ b/tests/auto/corelib/tools/qbytearray/.gitignore
@@ -0,0 +1 @@
+tst_qbytearray
diff --git a/tests/auto/corelib/tools/qbytearray/qbytearray.pro b/tests/auto/corelib/tools/qbytearray/qbytearray.pro
new file mode 100644
index 0000000000..2c58db6b84
--- /dev/null
+++ b/tests/auto/corelib/tools/qbytearray/qbytearray.pro
@@ -0,0 +1,21 @@
+load(qttest_p4)
+SOURCES += tst_qbytearray.cpp
+
+
+QT = core core-private
+
+wince*|symbian {
+ addFile.files = rfc3252.txt
+ addFile.path = .
+ DEPLOYMENT += addFile
+}
+
+wince* {
+ DEFINES += SRCDIR=\\\"./\\\"
+} else:symbian {
+ TARGET.EPOCHEAPSIZE="0x100 0x800000"
+} else {
+ DEFINES += SRCDIR=\\\"$$PWD/\\\"
+}
+
+CONFIG += parallel_test
diff --git a/tests/auto/corelib/tools/qbytearray/rfc3252.txt b/tests/auto/corelib/tools/qbytearray/rfc3252.txt
new file mode 100644
index 0000000000..b80c61bf0a
--- /dev/null
+++ b/tests/auto/corelib/tools/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/corelib/tools/qbytearray/tst_qbytearray.cpp b/tests/auto/corelib/tools/qbytearray/tst_qbytearray.cpp
new file mode 100644
index 0000000000..5f036f37fe
--- /dev/null
+++ b/tests/auto/corelib/tools/qbytearray/tst_qbytearray.cpp
@@ -0,0 +1,1569 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** GNU Lesser General Public License Usage
+** 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.1, 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.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms and
+** conditions contained in a signed written agreement between you and Nokia.
+**
+**
+**
+**
+**
+** $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=
+
+#if defined(Q_OS_SYMBIAN)
+#define SRCDIR ""
+#endif
+
+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 swap();
+ void qCompress_data();
+#ifndef QT_NO_COMPRESS
+ void qCompress();
+ void qUncompress_data();
+ void qUncompress();
+ void qCompressionZeroTermination();
+#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 fromBase64_data();
+ void fromBase64();
+ 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 replaceWithSpecifiedLength();
+ 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;
+
+ void reserve();
+
+ void literals();
+};
+
+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", 4) << QByteArray();
+ QTest::newRow("0x000000ff") << QByteArray("\x00\x00\x00\xff", 4) << QByteArray();
+ QTest::newRow("0x3f000000") << QByteArray("\x3f\x00\x00\x00", 4) << QByteArray();
+ QTest::newRow("0x3fffffff") << QByteArray("\x3f\xff\xff\xff", 4) << QByteArray();
+ QTest::newRow("0x7fffff00") << QByteArray("\x7f\xff\xff\x00", 4) << QByteArray();
+ QTest::newRow("0x7fffffff") << QByteArray("\x7f\xff\xff\xff", 4) << QByteArray();
+ QTest::newRow("0x80000000") << QByteArray("\x80\x00\x00\x00", 4) << QByteArray();
+ QTest::newRow("0x800000ff") << QByteArray("\x80\x00\x00\xff", 4) << QByteArray();
+ QTest::newRow("0xcf000000") << QByteArray("\xcf\x00\x00\x00", 4) << QByteArray();
+ QTest::newRow("0xcfffffff") << QByteArray("\xcf\xff\xff\xff", 4) << QByteArray();
+ QTest::newRow("0xffffff00") << QByteArray("\xff\xff\xff\x00", 4) << QByteArray();
+ QTest::newRow("0xffffffff") << QByteArray("\xff\xff\xff\xff", 4) << QByteArray();
+}
+
+void tst_QByteArray::qUncompress()
+{
+ QFETCH(QByteArray, in);
+ QFETCH(QByteArray, out);
+
+#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);
+#elif defined Q_OS_QNX
+ QSKIP("Corrupt data causes this test to lock up on QNX", SkipAll);
+#elif defined Q_OS_WIN
+ QSKIP("Corrupt data causes this test to lock up on Windows", SkipAll);
+#endif
+
+ QByteArray res;
+ res = ::qUncompress(in);
+ QCOMPARE(res, out);
+
+ res = ::qUncompress(in + "blah");
+ QCOMPARE(res, out);
+}
+
+void tst_QByteArray::qCompressionZeroTermination()
+{
+ QString s = "Hello, I'm a string.";
+ QByteArray ba = ::qUncompress(::qCompress(s.toLocal8Bit()));
+ QVERIFY((int) *(ba.data() + ba.size()) == 0);
+}
+
+#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::swap()
+{
+ QByteArray b1 = "b1", b2 = "b2";
+ b1.swap(b2);
+ QCOMPARE(b1, QByteArray("b2"));
+ QCOMPARE(b2, QByteArray("b1"));
+}
+
+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==");
+
+ QTest::newRow("g") << QByteArray("foo\0bar", 7) << QByteArray("Zm9vAGJhcg==");
+ QTest::newRow("h") << QByteArray("f\xd1oo\x9ctar") << QByteArray("ZtFvb5x0YXI=");
+ QTest::newRow("i") << QByteArray("\"\0\0\0\0\0\0\"", 8) << QByteArray("IgAAAAAAACI=");
+}
+
+
+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);
+}
+
+//different from the previous test as the input are invalid
+void tst_QByteArray::fromBase64_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("M=TIz");
+ QTest::newRow("5") << QByteArray("1234") << QByteArray("MTI zN A ");
+ QTest::newRow("6") << QByteArray("\n") << QByteArray("Cg");
+ QTest::newRow("7") << QByteArray("a\n") << QByteArray("======YQo=");
+ QTest::newRow("8") << QByteArray("ab\n") << QByteArray("Y\nWIK");
+ QTest::newRow("9") << QByteArray("abc\n") << QByteArray("YWJjCg==");
+ QTest::newRow("a") << QByteArray("abcd\n") << QByteArray("YWJ\1j\x9cZAo=");
+ QTest::newRow("b") << QByteArray("abcde\n") << QByteArray("YW JjZ\n G\tUK");
+ QTest::newRow("c") << QByteArray("abcdef\n") << QByteArray("YWJjZGVmCg=");
+ QTest::newRow("d") << QByteArray("abcdefg\n") << QByteArray("YWJ\rjZGVmZwo");
+ 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("AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Nj\n"
+ "c4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWprbG1u\n"
+ "b3BxcnN0dXZ3eHl6e3x9fn+AgYKDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpa\n"
+ "anqKmqq6ytrq+wsbKztLW2t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna29zd\n"
+ "3t/g4eLj5OXm5+jp6uvs7e7v8PHy8/T19vf4+fr7/P3+/w== ");
+
+
+ QTest::newRow("g") << QByteArray("foo\0bar", 7) << QByteArray("Zm9vAGJhcg");
+ QTest::newRow("h") << QByteArray("f\xd1oo\x9ctar") << QByteArray("ZtFvb5x0YXI=");
+ QTest::newRow("i") << QByteArray("\"\0\0\0\0\0\0\"", 8) << QByteArray("IgAAAAAAACI");
+
+}
+
+
+void tst_QByteArray::fromBase64()
+{
+ QFETCH(QByteArray, rawdata);
+ QFETCH(QByteArray, base64);
+
+ QByteArray arr = QByteArray::fromBase64(base64);
+ QCOMPARE(arr, rawdata);
+}
+
+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 necessary
+ 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"));
+ QCOMPARE(ba.prepend("\0 ", 2), QByteArray::fromRawData("\0 321foo", 8));
+}
+
+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"));
+ QCOMPARE(ba.append("\0"), QByteArray("foo123"));
+ QCOMPARE(ba.append("\0", 1), QByteArray::fromRawData("foo123\0", 7));
+ QCOMPARE(ba.size(), 7);
+}
+
+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);
+
+ ba = "ab";
+ QCOMPARE(ba.insert(1, "\0X\0", 3), QByteArray::fromRawData("a\0X\0b", 5));
+ QCOMPARE(ba.size(), 5);
+}
+
+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::replaceWithSpecifiedLength()
+{
+ const char after[] = "zxc\0vbnmqwert";
+ int lenAfter = 6;
+ QByteArray ba("abcdefghjk");
+ ba.replace(0,2,after,lenAfter);
+
+ const char _expected[] = "zxc\0vbcdefghjk";
+ QByteArray expected(_expected,sizeof(_expected)-1);
+ QCOMPARE(ba,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, (char)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") << QByteArray(veryBigHaystack + 'c') << QByteArray(veryBigHaystack) << 0 << 0;
+ QTest::newRow("BoyerMooreStressTest3") << QByteArray('c' + veryBigHaystack) << QByteArray(veryBigHaystack) << 0 << 1;
+ QTest::newRow("BoyerMooreStressTest4") << QByteArray(veryBigHaystack) << QByteArray(veryBigHaystack + 'c') << 0 << -1;
+ QTest::newRow("BoyerMooreStressTest5") << QByteArray(veryBigHaystack) << QByteArray('c' + veryBigHaystack) << 0 << -1;
+ QTest::newRow("BoyerMooreStressTest6") << QByteArray('d' + veryBigHaystack) << QByteArray('c' + veryBigHaystack) << 0 << -1;
+ QTest::newRow("BoyerMooreStressTest6") << QByteArray(veryBigHaystack + 'c') << QByteArray('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, (char)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);
+*/
+ QByteArray 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'));
+ }
+}
+
+void tst_QByteArray::reserve()
+{
+ int capacity = 100;
+ QByteArray qba;
+ qba.reserve(capacity);
+ QVERIFY(qba.capacity() == capacity);
+ char *data = qba.data();
+
+ for (int i = 0; i < capacity; i++) {
+ qba.resize(i);
+ QVERIFY(capacity == qba.capacity());
+ QVERIFY(data == qba.data());
+ }
+}
+
+void tst_QByteArray::literals()
+{
+#if defined(Q_COMPILER_LAMBDA) || defined(Q_CC_GNU)
+ QByteArray str(QByteArrayLiteral("abcd"));
+
+ QVERIFY(str.length() == 4);
+ QVERIFY(str == "abcd");
+ QVERIFY(str.data_ptr()->ref == -1);
+ QVERIFY(str.data_ptr()->offset == 0);
+
+ const char *s = str.constData();
+ QByteArray str2 = str;
+ QVERIFY(str2.constData() == s);
+
+ // detach on non const access
+ QVERIFY(str.data() != s);
+
+ QVERIFY(str2.constData() == s);
+ QVERIFY(str2.data() != s);
+
+#else
+ QSKIP("Only tested on c++0x compliant compiler or gcc", SkipAll);
+#endif
+}
+
+const char globalChar = '1';
+
+QTEST_APPLESS_MAIN(tst_QByteArray)
+#include "tst_qbytearray.moc"
generated by cgit v1.2.3 (git 2.25.1) at 2024-05-02 20:54:52 +0000