Merge branch '4.5' into 4.6

Conflicts:
	bin/syncqt
	configure
	demos/boxes/glshaders.cpp
	demos/boxes/vector.h
	demos/embedded/fluidlauncher/pictureflow.cpp
	demos/embedded/fluidlauncher/pictureflow.h
	dist/README
	dist/changes-3.0.0
	dist/changes-3.0.0-beta1
	dist/changes-4.3.0
	doc/src/desktop-integration.qdoc
	doc/src/development/designer-manual.qdoc
	doc/src/distributingqt.qdoc
	doc/src/examples-overview.qdoc
	doc/src/examples.qdoc
	doc/src/frameworks-technologies/dbus-adaptors.qdoc
	doc/src/geometry.qdoc
	doc/src/groups.qdoc
	doc/src/index.qdoc
	doc/src/objecttrees.qdoc
	doc/src/platform-notes.qdoc
	doc/src/plugins-howto.qdoc
	doc/src/porting/porting4.qdoc
	doc/src/porting4-obsoletedmechanism.qdocinc
	doc/src/qt-webpages.qdoc
	doc/src/qt3support.qdoc
	doc/src/qtdbus.qdoc
	doc/src/qtdesigner.qdoc
	doc/src/qtgui.qdoc
	doc/src/qtmain.qdoc
	doc/src/qtopengl.qdoc
	doc/src/qtsvg.qdoc
	doc/src/qtuiloader.qdoc
	doc/src/qundo.qdoc
	doc/src/richtext.qdoc
	doc/src/snippets/code/src_corelib_tools_qregexp.cpp
	doc/src/snippets/code/src_qt3support_network_q3ftp.cpp
	doc/src/snippets/qstring/main.cpp
	doc/src/snippets/textdocument-blocks/xmlwriter.cpp
	doc/src/snippets/textdocument-frames/xmlwriter.cpp
	doc/src/snippets/textdocument-tables/xmlwriter.cpp
	doc/src/tech-preview/known-issues.html
	doc/src/topics.qdoc
	doc/src/xml-processing/xml-processing.qdoc
	examples/xml/saxbookmarks/jennifer.xbel
	src/3rdparty/phonon/ds9/mediaobject.cpp
	src/3rdparty/phonon/ds9/mediaobject.h
	src/corelib/io/qurl.cpp
	src/corelib/tools/qdumper.cpp
	src/corelib/xml/qxmlstream.h
	src/gui/embedded/qkbdpc101_qws.cpp
	src/gui/embedded/qkbdsl5000_qws.cpp
	src/gui/embedded/qkbdusb_qws.cpp
	src/gui/embedded/qkbdvr41xx_qws.cpp
	src/gui/embedded/qkbdyopy_qws.cpp
	src/gui/embedded/qmousebus_qws.cpp
	src/gui/embedded/qmousevr41xx_qws.cpp
	src/gui/embedded/qmouseyopy_qws.cpp
	src/gui/image/qpixmapcache.cpp
	src/gui/kernel/qmotifdnd_x11.cpp
	src/gui/painting/qpaintengine_d3d.cpp
	src/gui/painting/qpaintengine_raster.cpp
	src/gui/painting/qwindowsurface_d3d.cpp
	src/gui/styles/qmacstyle_mac.mm
	src/gui/text/qtextformat.cpp
	src/gui/text/qtextobject_p.h
	src/network/access/qhttp.cpp
	src/opengl/gl2paintengineex/glgc_shader_source.h
	src/opengl/gl2paintengineex/qglpexshadermanager.cpp
	src/opengl/gl2paintengineex/qglpexshadermanager_p.h
	src/opengl/gl2paintengineex/qglshader.cpp
	src/opengl/gl2paintengineex/qglshader_p.h
	src/plugins/codecs/kr/qeuckrcodec.cpp
	src/plugins/kbddrivers/linuxis/linuxiskbdhandler.cpp
	src/plugins/mousedrivers/linuxis/linuxismousehandler.cpp
	src/qt3support/network/q3http.cpp
	src/script/qscriptarray_p.h
	src/script/qscriptasm_p.h
	src/script/qscriptbuffer_p.h
	src/script/qscriptclass.cpp
	src/script/qscriptcompiler.cpp
	src/script/qscriptcompiler_p.h
	src/script/qscriptcontext.cpp
	src/script/qscriptcontext_p.cpp
	src/script/qscriptcontext_p.h
	src/script/qscriptcontextfwd_p.h
	src/script/qscriptecmaarray.cpp
	src/script/qscriptecmaarray_p.h
	src/script/qscriptecmaboolean.cpp
	src/script/qscriptecmacore.cpp
	src/script/qscriptecmadate.cpp
	src/script/qscriptecmadate_p.h
	src/script/qscriptecmaerror.cpp
	src/script/qscriptecmaerror_p.h
	src/script/qscriptecmafunction.cpp
	src/script/qscriptecmafunction_p.h
	src/script/qscriptecmaglobal.cpp
	src/script/qscriptecmaglobal_p.h
	src/script/qscriptecmamath.cpp
	src/script/qscriptecmamath_p.h
	src/script/qscriptecmanumber.cpp
	src/script/qscriptecmanumber_p.h
	src/script/qscriptecmaobject.cpp
	src/script/qscriptecmaobject_p.h
	src/script/qscriptecmaregexp.cpp
	src/script/qscriptecmaregexp_p.h
	src/script/qscriptecmastring.cpp
	src/script/qscriptecmastring_p.h
	src/script/qscriptengine.cpp
	src/script/qscriptengine_p.cpp
	src/script/qscriptengine_p.h
	src/script/qscriptenginefwd_p.h
	src/script/qscriptextenumeration.cpp
	src/script/qscriptextenumeration_p.h
	src/script/qscriptextqobject.cpp
	src/script/qscriptextqobject_p.h
	src/script/qscriptextvariant.cpp
	src/script/qscriptfunction.cpp
	src/script/qscriptfunction_p.h
	src/script/qscriptgc_p.h
	src/script/qscriptmember_p.h
	src/script/qscriptobject_p.h
	src/script/qscriptprettypretty.cpp
	src/script/qscriptprettypretty_p.h
	src/script/qscriptvalue.cpp
	src/script/qscriptvalueimpl.cpp
	src/script/qscriptvalueimpl_p.h
	src/script/qscriptvalueimplfwd_p.h
	src/script/qscriptvalueiteratorimpl.cpp
	src/script/qscriptxmlgenerator.cpp
	src/script/qscriptxmlgenerator_p.h
	src/sql/drivers/sqlite/qsql_sqlite.cpp
	src/svg/qsvghandler.cpp
	src/svg/qsvgstyle.cpp
	src/xmlpatterns/expr/qcastingplatform_p.h
	src/xmlpatterns/iterators/qcachingiterator_p.h
	src/xmlpatterns/parser/qquerytransformparser_p.h
	tests/auto/q3uridrag/tst_q3uridrag.cpp
	tests/auto/qcombobox/tst_qcombobox.cpp
	tests/auto/qgraphicswidget/tst_qgraphicswidget.cpp
	tests/auto/qkeyevent/tst_qkeyevent.cpp
	tests/auto/qmainwindow/tst_qmainwindow.cpp
	tests/auto/qnetworkcookiejar/tst_qnetworkcookiejar.cpp
	tests/auto/qsqltablemodel/tst_qsqltablemodel.cpp
	tests/auto/qsslsocket/tst_qsslsocket.cpp
	tests/auto/qurl/tst_qurl.cpp
	tests/auto/qvariant/tst_qvariant.cpp
	tests/auto/qwidget/tst_qwidget.cpp
	tests/auto/uic/baseline/batchtranslation.ui
	tests/auto/uic/baseline/batchtranslation.ui.h
	tests/auto/uic/baseline/config.ui
	tests/auto/uic/baseline/config.ui.h
	tests/auto/uic/baseline/finddialog.ui
	tests/auto/uic/baseline/finddialog.ui.h
	tests/auto/uic/baseline/formwindowsettings.ui
	tests/auto/uic/baseline/formwindowsettings.ui.h
	tests/auto/uic/baseline/helpdialog.ui
	tests/auto/uic/baseline/helpdialog.ui.h
	tests/auto/uic/baseline/listwidgeteditor.ui
	tests/auto/uic/baseline/listwidgeteditor.ui.h
	tests/auto/uic/baseline/mainwindowbase.ui
	tests/auto/uic/baseline/mainwindowbase.ui.h
	tests/auto/uic/baseline/newactiondialog.ui
	tests/auto/uic/baseline/newactiondialog.ui.h
	tests/auto/uic/baseline/newform.ui
	tests/auto/uic/baseline/newform.ui.h
	tests/auto/uic/baseline/orderdialog.ui
	tests/auto/uic/baseline/orderdialog.ui.h
	tests/auto/uic/baseline/paletteeditor.ui
	tests/auto/uic/baseline/paletteeditor.ui.h
	tests/auto/uic/baseline/paletteeditoradvancedbase.ui
	tests/auto/uic/baseline/paletteeditoradvancedbase.ui.h
	tests/auto/uic/baseline/phrasebookbox.ui
	tests/auto/uic/baseline/phrasebookbox.ui.h
	tests/auto/uic/baseline/plugindialog.ui
	tests/auto/uic/baseline/plugindialog.ui.h
	tests/auto/uic/baseline/previewwidget.ui
	tests/auto/uic/baseline/previewwidget.ui.h
	tests/auto/uic/baseline/previewwidgetbase.ui
	tests/auto/uic/baseline/previewwidgetbase.ui.h
	tests/auto/uic/baseline/qfiledialog.ui
	tests/auto/uic/baseline/qfiledialog.ui.h
	tests/auto/uic/baseline/qtgradientdialog.ui
	tests/auto/uic/baseline/qtgradientdialog.ui.h
	tests/auto/uic/baseline/qtgradientviewdialog.ui
	tests/auto/uic/baseline/qtgradientviewdialog.ui.h
	tests/auto/uic/baseline/saveformastemplate.ui
	tests/auto/uic/baseline/saveformastemplate.ui.h
	tests/auto/uic/baseline/statistics.ui
	tests/auto/uic/baseline/statistics.ui.h
	tests/auto/uic/baseline/stringlisteditor.ui
	tests/auto/uic/baseline/stringlisteditor.ui.h
	tests/auto/uic/baseline/tabbedbrowser.ui
	tests/auto/uic/baseline/tabbedbrowser.ui.h
	tests/auto/uic/baseline/tablewidgeteditor.ui
	tests/auto/uic/baseline/tablewidgeteditor.ui.h
	tests/auto/uic/baseline/translatedialog.ui
	tests/auto/uic/baseline/translatedialog.ui.h
	tests/auto/uic/baseline/treewidgeteditor.ui
	tests/auto/uic/baseline/treewidgeteditor.ui.h
	tests/auto/uic/baseline/trpreviewtool.ui
	tests/auto/uic/baseline/trpreviewtool.ui.h
	tests/auto/uic3/baseline/previewwidget.ui
	tests/auto/uic3/baseline/previewwidget.ui.4
	tests/auto/uic3/baseline/previewwidgetbase.ui
	tests/auto/uic3/baseline/previewwidgetbase.ui.4
	tests/auto/uic3/baseline/qactivexselect.ui
	tests/auto/uic3/baseline/qactivexselect.ui.4
	tests/auto/uiloader/baseline/batchtranslation.ui
	tests/auto/uiloader/baseline/config.ui
	tests/auto/uiloader/baseline/finddialog.ui
	tests/auto/uiloader/baseline/formwindowsettings.ui
	tests/auto/uiloader/baseline/helpdialog.ui
	tests/auto/uiloader/baseline/listwidgeteditor.ui
	tests/auto/uiloader/baseline/mainwindowbase.ui
	tests/auto/uiloader/baseline/newactiondialog.ui
	tests/auto/uiloader/baseline/newform.ui
	tests/auto/uiloader/baseline/orderdialog.ui
	tests/auto/uiloader/baseline/paletteeditor.ui
	tests/auto/uiloader/baseline/paletteeditoradvancedbase.ui
	tests/auto/uiloader/baseline/phrasebookbox.ui
	tests/auto/uiloader/baseline/plugindialog.ui
	tests/auto/uiloader/baseline/previewwidget.ui
	tests/auto/uiloader/baseline/previewwidgetbase.ui
	tests/auto/uiloader/baseline/qfiledialog.ui
	tests/auto/uiloader/baseline/qtgradientdialog.ui
	tests/auto/uiloader/baseline/qtgradienteditor.ui
	tests/auto/uiloader/baseline/qtgradientviewdialog.ui
	tests/auto/uiloader/baseline/saveformastemplate.ui
	tests/auto/uiloader/baseline/statistics.ui
	tests/auto/uiloader/baseline/stringlisteditor.ui
	tests/auto/uiloader/baseline/tabbedbrowser.ui
	tests/auto/uiloader/baseline/tablewidgeteditor.ui
	tests/auto/uiloader/baseline/translatedialog.ui
	tests/auto/uiloader/baseline/treewidgeteditor.ui
	tests/auto/uiloader/baseline/trpreviewtool.ui
	tests/auto/windowsmobile/test/test.pro
	tests/auto/xmlpatternsdiagnosticsts/test/tst_xmlpatternsdiagnosticsts.cpp
	tools/doxygen/config/header.html
	tools/doxygen/config/phonon.doxyfile
	tools/installer/nsis/opensource.ini
	tools/linguist/phrasebooks/polish.qph
	tools/linguist/shared/cpp.cpp
	tools/linguist/shared/ts.dtd
	tools/qdoc3/test/assistant.qdocconf
	tools/qdoc3/test/designer.qdocconf
	tools/qdoc3/test/linguist.qdocconf
	tools/qdoc3/test/qmake.qdocconf
	tools/qdoc3/test/qt-build-docs.qdocconf
	tools/qdoc3/test/qt-inc.qdocconf
	tools/qdoc3/test/qt.qdocconf
	tools/qvfb/qtopiakeysym.h
	tools/qvfb/qvfbx11view.cpp
	tools/qvfb/qvfbx11view.h
	tools/qvfb/x11keyfaker.cpp
	tools/xmlpatterns/main.cpp
	tools/xmlpatterns/main.h
	tools/xmlpatterns/qcoloringmessagehandler_p.h
	tools/xmlpatterns/qcoloroutput.cpp
	tools/xmlpatterns/qcoloroutput_p.h
	translations/assistant_de.ts
	translations/qt_ar.ts
	translations/qt_da.ts
	translations/qt_de.ts
	translations/qt_fr.ts
	translations/qt_ja_JP.ts
	translations/qt_ru.ts
	translations/qt_uk.ts
	translations/qt_zh_CN.ts
	util/qlalr/compress.cpp
	util/qlalr/cppgenerator.cpp
	util/qlalr/dotgraph.cpp
	util/qlalr/grammar.cpp
	util/qlalr/lalr.cpp
	util/qlalr/main.cpp
	util/qlalr/parsetable.cpp
	util/qlalr/recognizer.cpp

1 files changed, 656 insertions, 0 deletions

diff --git a/tests/auto/compiler/tst_compiler.cpp b/tests/auto/compiler/tst_compiler.cpp
new file mode 100644
index 000000000..78c1a56fb
--- /dev/null
+++ b/tests/auto/compiler/tst_compiler.cpp
@@ -0,0 +1,656 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Nokia Corporation (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 http://qt.nokia.com/contact.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#include <QtCore/QtCore>
+#include <QtTest/QtTest>
+
+#include <algorithm>
+
+#define BASECLASS_NOT_ABSTRACT
+#include "baseclass.h"
+#include "derivedclass.h"
+
+QT_USE_NAMESPACE
+
+class tst_Compiler : public QObject
+{
+Q_OBJECT
+
+private slots:
+    void template_methods();
+    void template_constructors();
+    void template_subclasses();
+    void methodSpecialization();
+    void constructorSpecialization();
+    void staticTemplateMethods();
+    void staticTemplateMethodSpecialization();
+    void detectDataStream();
+    void detectEnums();
+    void overrideCFunction();
+    void stdSortQList();
+    void stdSortQVector();
+    void templateCallOrder();
+    void virtualFunctionNoLongerPureVirtual();
+    void charSignedness() const;
+    void privateStaticTemplateMember() const;
+    void staticConstUnionWithInitializerList() const;
+};
+
+#if defined(Q_CC_MSVC) && _MSC_VER < 1300
+#define MSVC6
+#endif
+
+#if defined(Q_CC_MSVC) && _MSC_VER == 1300
+#define MSVC2002
+#endif
+
+#if defined(MSVC6)
+# define DONT_TEST_TEMPLATE_METHODS
+# define DONT_TEST_TEMPLATE_CONSTRUCTORS
+# define DONT_TEST_METHOD_SPECIALIZATION
+# define DONT_TEST_CONSTRUCTOR_SPECIALIZATION
+# define DONT_TEST_STATIC_TEMPLATE_METHODS
+# define DONT_TEST_STATIC_TEMPLATE_METHOD_SPECIALIZATION
+# define DONT_TEST_STL_SORTING
+# define DONT_TEST_SIGNEDNESS
+#endif
+
+#if defined(MSVC2002)
+# define DONT_TEST_TEMPLATE_METHODS
+# define DONT_TEST_DETECT_ENUMS
+# define DONT_TEST_METHOD_SPECIALIZATION
+# define DONT_TEST_CONSTRUCTOR_SPECIALIZATION
+# define DONT_TEST_STATIC_TEMPLATE_METHOD_SPECIALIZATION
+# define DONT_TEST_STL_SORTING
+#endif
+
+#if defined(Q_CC_HPACC)
+# define DONT_TEST_TEMPLATE_CONSTRUCTORS
+# define DONT_TEST_CONSTRUCTOR_SPECIALIZATION
+# define DONT_TEST_DATASTREAM_DETECTION
+#endif
+
+#if defined(Q_CC_SUN)
+# define DONT_TEST_STL_SORTING
+#endif
+
+#ifndef DONT_TEST_TEMPLATE_METHODS
+class TemplateMethodClass
+{
+public:
+    template <class T>
+    T foo() { return 42; }
+};
+
+void tst_Compiler::template_methods()
+{
+    TemplateMethodClass t;
+
+    QCOMPARE(t.foo<int>(), 42);
+    QCOMPARE(t.foo<long>(), 42l);
+    QCOMPARE(t.foo<double>(), 42.0);
+}
+#else
+void tst_Compiler::template_methods()
+{ QSKIP("Compiler doesn't do template methods", SkipAll); }
+#endif
+
+#ifndef DONT_TEST_TEMPLATE_CONSTRUCTORS
+class TemplateConstructorClass
+{
+public:
+    template <class T>
+    TemplateConstructorClass(const T& t) { i = int(t); }
+
+    int i;
+};
+
+void tst_Compiler::template_constructors()
+{
+    TemplateConstructorClass t1(42);
+    TemplateConstructorClass t2(42l);
+    TemplateConstructorClass t3(42.0);
+
+    QCOMPARE(t1.i, 42);
+    QCOMPARE(t2.i, 42);
+    QCOMPARE(t3.i, 42);
+}
+#else
+void tst_Compiler::template_constructors()
+{ QSKIP("Compiler doesn't do template constructors", SkipAll); }
+#endif
+
+template <typename T>
+struct OuterClass
+{
+    template <typename U>
+    struct InnerClass
+    {
+        U convert(const T &t) { return static_cast<U>(t); }
+    };
+};
+
+void tst_Compiler::template_subclasses()
+{
+    OuterClass<char>::InnerClass<int> c1;
+    QCOMPARE(c1.convert('a'), int('a'));
+
+    OuterClass<QRect>::InnerClass<QRectF> c2;
+    QCOMPARE(c2.convert(QRect(1, 2, 3, 4)), QRectF(QRect(1, 2, 3, 4)));
+}
+
+#ifndef DONT_TEST_METHOD_SPECIALIZATION
+class TemplateMethodClass2
+{
+public:
+    template <class T>
+    T foo() { return 42; }
+};
+
+template<>
+int TemplateMethodClass2::foo<int>()
+{ return 43; }
+
+void tst_Compiler::methodSpecialization()
+{
+    TemplateMethodClass2 t;
+
+    QCOMPARE(t.foo<int>(), 43);
+    QCOMPARE(t.foo<long>(), 42l);
+    QCOMPARE(t.foo<double>(), 42.0);
+}
+#else
+void tst_Compiler::methodSpecialization()
+{ QSKIP("Compiler doesn't do template specialization", SkipAll); }
+#endif
+
+#ifndef DONT_TEST_CONSTRUCTOR_SPECIALIZATION
+class TemplateConstructorClass2
+{
+public:
+    template <class T>
+    TemplateConstructorClass2(const T &t) { i = int(t); }
+
+    int i;
+};
+
+template<>
+TemplateConstructorClass2::TemplateConstructorClass2(const int &t) { i = t + 1; }
+
+void tst_Compiler::constructorSpecialization()
+{
+    TemplateConstructorClass2 t1(42);
+    TemplateConstructorClass2 t2(42l);
+    TemplateConstructorClass2 t3(42.0);
+
+    QCOMPARE(t1.i, 43);
+    QCOMPARE(t2.i, 42);
+    QCOMPARE(t3.i, 42);
+}
+#else
+void tst_Compiler::constructorSpecialization()
+{ QSKIP("Compiler doesn't do constructor specialization", SkipAll); }
+#endif
+
+#ifndef DONT_TEST_STATIC_TEMPLATE_METHODS
+class StaticTemplateClass
+{
+public:
+    template <class T>
+    static T foo() { return 42; }
+};
+
+void tst_Compiler::staticTemplateMethods()
+{
+    QCOMPARE(StaticTemplateClass::foo<int>(), 42);
+    QCOMPARE(StaticTemplateClass::foo<uint>(), 42u);
+}
+#else
+void tst_Compiler::staticTemplateMethods()
+{ QSKIP("Compiler doesn't do static template methods", SkipAll); }
+#endif
+
+#ifndef DONT_TEST_STATIC_TEMPLATE_METHOD_SPECIALIZATION
+class StaticTemplateClass2
+{
+public:
+    template <class T>
+    static T foo() { return 42; }
+};
+
+template<>
+double StaticTemplateClass2::foo<double>() { return 18.5; }
+
+void tst_Compiler::staticTemplateMethodSpecialization()
+{
+    QCOMPARE(StaticTemplateClass2::foo<int>(), 42);
+    QCOMPARE(StaticTemplateClass2::foo<uint>(), 42u);
+    QCOMPARE(StaticTemplateClass2::foo<double>(), 18.5);
+}
+#else
+void tst_Compiler::staticTemplateMethodSpecialization()
+{ QSKIP("Compiler doesn't do static template method specialization", SkipAll); }
+#endif
+
+#ifndef DONT_TEST_DATASTREAM_DETECTION
+/******* DataStream tester *********/
+namespace QtTestInternal
+{
+    struct EmptyStruct {};
+    struct LowPreferenceStruct { LowPreferenceStruct(...); };
+
+    EmptyStruct operator<<(QDataStream &, const LowPreferenceStruct &);
+    EmptyStruct operator>>(QDataStream &, const LowPreferenceStruct &);
+
+    template<typename T>
+    struct DataStreamChecker
+    {
+        static EmptyStruct hasStreamHelper(const EmptyStruct &);
+        static QDataStream hasStreamHelper(const QDataStream &);
+        static QDataStream &dsDummy();
+        static T &dummy();
+
+#ifdef BROKEN_COMPILER
+        static const bool HasDataStream =
+            sizeof(hasStreamHelper(dsDummy() << dummy())) == sizeof(QDataStream)
+            && sizeof(hasStreamHelper(dsDummy() >> dummy())) == sizeof(QDataStream);
+#else
+        enum {
+            HasOutDataStream = sizeof(hasStreamHelper(dsDummy() >> dummy())) == sizeof(QDataStream),
+            HasInDataStream = sizeof(hasStreamHelper(dsDummy() << dummy())) == sizeof(QDataStream),
+            HasDataStream = HasOutDataStream & HasInDataStream
+        };
+#endif
+    };
+
+    template<bool>
+    struct DataStreamOpHelper
+    {
+        template <typename T>
+        struct Getter {
+            static QMetaType::SaveOperator saveOp() { return 0; }
+        };
+    };
+
+    template<>
+    struct DataStreamOpHelper<true>
+    {
+        template <typename T>
+        struct Getter {
+            static QMetaType::SaveOperator saveOp()
+            {
+                typedef void(*SavePtr)(QDataStream &, const T *);
+                SavePtr op = ::qMetaTypeSaveHelper<T>;
+                return reinterpret_cast<QMetaType::SaveOperator>(op);
+            }
+        };
+
+    };
+
+    template<typename T>
+    inline QMetaType::SaveOperator getSaveOperator(T * = 0)
+    {
+        typedef typename DataStreamOpHelper<DataStreamChecker<T>::HasDataStream>::template Getter<T> GetterHelper;
+        return GetterHelper::saveOp();
+    }
+};
+
+struct MyString: public QString {};
+struct Qxxx {};
+
+void tst_Compiler::detectDataStream()
+{
+    QVERIFY(QtTestInternal::DataStreamChecker<int>::HasDataStream == true);
+    QVERIFY(QtTestInternal::DataStreamChecker<uint>::HasDataStream == true);
+    QVERIFY(QtTestInternal::DataStreamChecker<char *>::HasDataStream == true);
+    QVERIFY(QtTestInternal::DataStreamChecker<const int>::HasInDataStream == true);
+    QVERIFY(QtTestInternal::DataStreamChecker<const int>::HasOutDataStream == false);
+    QVERIFY(QtTestInternal::DataStreamChecker<const int>::HasDataStream == false);
+    QVERIFY(QtTestInternal::DataStreamChecker<double>::HasDataStream == true);
+
+    QVERIFY(QtTestInternal::DataStreamChecker<QString>::HasDataStream == true);
+    QVERIFY(QtTestInternal::DataStreamChecker<MyString>::HasDataStream == true);
+    QVERIFY(QtTestInternal::DataStreamChecker<Qxxx>::HasDataStream == false);
+
+    QVERIFY(QtTestInternal::getSaveOperator<int>() != 0);
+    QVERIFY(QtTestInternal::getSaveOperator<uint>() != 0);
+    QVERIFY(QtTestInternal::getSaveOperator<char *>() != 0);
+    QVERIFY(QtTestInternal::getSaveOperator<double>() != 0);
+    QVERIFY(QtTestInternal::getSaveOperator<QString>() != 0);
+    QVERIFY(QtTestInternal::getSaveOperator<MyString>() != 0);
+    QVERIFY(QtTestInternal::getSaveOperator<Qxxx>() == 0);
+}
+#else
+void tst_Compiler::detectDataStream()
+{ QSKIP("Compiler doesn't evaluate templates correctly", SkipAll); }
+#endif
+
+#ifndef DONT_TEST_DETECT_ENUMS
+enum Enum1 { Foo = 0, Bar = 1 };
+enum Enum2 {};
+enum Enum3 { Something = 1 };
+
+template <typename T> char QTypeInfoEnumHelper(T);
+template <typename T> void *QTypeInfoEnumHelper(...);
+
+#if defined(MSVC6)
+
+template <int>
+struct QTestTypeInfoHelper
+{
+    enum { IsE = 0 };
+};
+
+template <>
+struct QTestTypeInfoHelper<sizeof(void *)>
+{
+    enum { IsE = 1 };
+};
+
+
+template <typename T>
+struct QTestTypeInfo
+{
+    typedef typename QTestTypeInfoHelper<sizeof(QTypeInfoEnumHelper<T>(0))> TIHelper;
+    enum { IsEnum = TIHelper::IsE };
+};
+#else
+template <typename T>
+struct QTestTypeInfo
+{
+    enum { IsEnum = sizeof(QTypeInfoEnumHelper<T>(0)) == sizeof(void*) };
+};
+#endif
+
+void tst_Compiler::detectEnums()
+{
+    QVERIFY(QTestTypeInfo<Enum1>::IsEnum);
+    QVERIFY(QTestTypeInfo<Enum2>::IsEnum);
+    QVERIFY(QTestTypeInfo<Enum3>::IsEnum);
+    QVERIFY(!QTestTypeInfo<int>::IsEnum);
+    QVERIFY(!QTestTypeInfo<char>::IsEnum);
+    QVERIFY(!QTestTypeInfo<uint>::IsEnum);
+    QVERIFY(!QTestTypeInfo<short>::IsEnum);
+    QVERIFY(!QTestTypeInfo<ushort>::IsEnum);
+    QVERIFY(!QTestTypeInfo<void*>::IsEnum);
+    QVERIFY(!QTestTypeInfo<QString>::IsEnum);
+    QVERIFY(QTestTypeInfo<Qt::Key>::IsEnum);
+    QVERIFY(QTestTypeInfo<Qt::ToolBarArea>::IsEnum);
+    QVERIFY(!QTestTypeInfo<Qt::ToolBarAreas>::IsEnum);
+    QVERIFY(QTestTypeInfo<Qt::MatchFlag>::IsEnum);
+    QVERIFY(!QTestTypeInfo<Qt::MatchFlags>::IsEnum);
+}
+#else
+void tst_Compiler::detectEnums()
+{ QSKIP("Compiler doesn't evaluate templates correctly", SkipAll); }
+#endif
+
+static int indicator = 0;
+
+
+// this is a silly C function
+extern "C" {
+    void someCFunc(void *) { indicator = 42; }
+}
+
+// this is the catch-template that will be called if the C function doesn't exist
+template <typename T>
+void someCFunc(T *) { indicator = 10; }
+
+void tst_Compiler::overrideCFunction()
+{
+    someCFunc((void*)0);
+    QCOMPARE(indicator, 42);
+}
+
+#ifndef DONT_TEST_STL_SORTING
+void tst_Compiler::stdSortQList()
+{
+    QList<int> list;
+    list << 4 << 2;
+    std::sort(list.begin(), list.end());
+    QCOMPARE(list.value(0), 2);
+    QCOMPARE(list.value(1), 4);
+
+    QList<QString> slist;
+    slist << "b" << "a";
+    std::sort(slist.begin(), slist.end());
+    QCOMPARE(slist.value(0), QString("a"));
+    QCOMPARE(slist.value(1), QString("b"));
+}
+
+void tst_Compiler::stdSortQVector()
+{
+    QVector<int> vector;
+    vector << 4 << 2;
+    std::sort(vector.begin(), vector.end());
+    QCOMPARE(vector.value(0), 2);
+    QCOMPARE(vector.value(1), 4);
+
+    QVector<QString> strvec;
+    strvec << "b" << "a";
+    std::sort(strvec.begin(), strvec.end());
+    QCOMPARE(strvec.value(0), QString("a"));
+    QCOMPARE(strvec.value(1), QString("b"));
+}
+#else
+void tst_Compiler::stdSortQList()
+{ QSKIP("Compiler's STL broken", SkipAll); }
+void tst_Compiler::stdSortQVector()
+{ QSKIP("Compiler's STL broken", SkipAll); }
+#endif
+
+// the C func will set it to 1, the template to 2
+static int whatWasCalled = 0;
+
+void callOrderFunc(void *)
+{
+    whatWasCalled = 1;
+}
+
+template <typename T>
+void callOrderFunc(T *)
+{
+    whatWasCalled = 2;
+}
+
+template <typename T>
+void callOrderNoCFunc(T *)
+{
+    whatWasCalled = 3;
+}
+
+/*
+   This test will check what will get precendence - the C function
+   or the template.
+
+   It also makes sure this template "override" will compile on all systems
+   and not result in ambiguities.
+*/
+void tst_Compiler::templateCallOrder()
+{
+    QCOMPARE(whatWasCalled, 0);
+
+    // call it with a void *
+    void *f = 0;
+    callOrderFunc(f);
+    QCOMPARE(whatWasCalled, 1);
+    whatWasCalled = 0;
+
+    char *c = 0;
+    /* call it with a char * - AMBIGOUS, fails on several compilers
+    callOrderFunc(c);
+    QCOMPARE(whatWasCalled, 1);
+    whatWasCalled = 0;
+    */
+
+    // now try the case when there is no C function
+    callOrderNoCFunc(f);
+    QCOMPARE(whatWasCalled, 3);
+    whatWasCalled = 0;
+
+    callOrderNoCFunc(c);
+    QCOMPARE(whatWasCalled, 3);
+    whatWasCalled = 0;
+}
+
+// test to see if removing =0 from a pure virtual function is BC
+void tst_Compiler::virtualFunctionNoLongerPureVirtual()
+{
+#ifdef BASECLASS_NOT_ABSTRACT
+    // has a single virtual function, not pure virtual, can call it
+    BaseClass baseClass;
+    QTest::ignoreMessage(QtDebugMsg, "BaseClass::wasAPureVirtualFunction()");
+    baseClass.wasAPureVirtualFunction();
+#endif
+
+    // DerivedClass inherits from BaseClass, and function is declared
+    // pure virtual, make sure we can still call it
+    DerivedClass derivedClass;
+    QTest::ignoreMessage(QtDebugMsg, "DerivedClass::wasAPureVirtualFunction()");
+    derivedClass.wasAPureVirtualFunction();
+}
+
+template<typename T> const char *resolveCharSignedness();
+
+template<>
+const char *resolveCharSignedness<char>()
+{
+    return "char";
+}
+
+template<>
+const char *resolveCharSignedness<unsigned char>()
+{
+    return "unsigned char";
+}
+
+template<>
+const char *resolveCharSignedness<signed char>()
+{
+    return "signed char";
+}
+
+void tst_Compiler::charSignedness() const
+{
+#ifdef DONT_TEST_SIGNEDNESS
+    QSKIP("MS VC 6.0 instantiates the char function for type unsigned char.", SkipSingle);
+#else
+    QCOMPARE("char",            resolveCharSignedness<char>());
+    QCOMPARE("unsigned char",   resolveCharSignedness<unsigned char>());
+    QCOMPARE("signed char",     resolveCharSignedness<signed char>());
+#endif
+}
+
+class PrivateStaticTemplateMember
+{
+public:
+    long regularMember()
+    {
+        return helper<long, int>(3);
+    }
+
+private:
+    template<typename A, typename B>
+    static A helper(const B b)
+    {
+        return A(b);
+    }
+};
+
+void tst_Compiler::privateStaticTemplateMember() const
+{
+    PrivateStaticTemplateMember v;
+
+    QCOMPARE(long(3), v.regularMember());
+}
+
+
+#if !defined(Q_CC_MIPS)
+
+// make sure we can use a static initializer with a union and then use
+// the second member of the union
+static const union { unsigned char c[8]; double d; } qt_be_inf_bytes = { { 0x7f, 0xf0, 0, 0, 0, 0, 0, 0 } };
+static const union { unsigned char c[8]; double d; } qt_le_inf_bytes = { { 0, 0, 0, 0, 0, 0, 0xf0, 0x7f } };
+static const union { unsigned char c[8]; double d; } qt_armfpa_inf_bytes = { { 0, 0, 0xf0, 0x7f, 0, 0, 0, 0 } };
+static inline double qt_inf()
+{
+#ifdef QT_ARMFPA
+    return qt_armfpa_inf_bytes.d;
+#else
+    return (QSysInfo::ByteOrder == QSysInfo::BigEndian
+            ? qt_be_inf_bytes.d
+            : qt_le_inf_bytes.d);
+#endif
+}
+
+#else
+
+static const unsigned char qt_be_inf_bytes[] = { 0x7f, 0xf0, 0, 0, 0, 0, 0, 0 };
+static const unsigned char qt_le_inf_bytes[] = { 0, 0, 0, 0, 0, 0, 0xf0, 0x7f };
+static const unsigned char qt_armfpa_inf_bytes[] = { 0, 0, 0xf0, 0x7f, 0, 0, 0, 0 };
+static inline double qt_inf()
+{
+    const uchar *bytes;
+#ifdef QT_ARMFPA
+    bytes = qt_armfpa_inf_bytes;
+#else
+    bytes = (QSysInfo::ByteOrder == QSysInfo::BigEndian
+             ? qt_be_inf_bytes
+             : qt_le_inf_bytes);
+#endif
+
+    union { uchar c[8]; double d; } returnValue;
+    qMemCopy(returnValue.c, bytes, sizeof(returnValue.c));
+    return returnValue.d;
+}
+
+#endif
+
+void tst_Compiler::staticConstUnionWithInitializerList() const
+{
+    double d = qt_inf();
+    QVERIFY(qIsInf(d));
+}
+
+QTEST_MAIN(tst_Compiler)
+#include "tst_compiler.moc"