--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/genericopenlibs/cppstdlib/stl/test/unit/uninitialized_test.cpp Fri Jun 04 16:20:51 2010 +0100
@@ -0,0 +1,258 @@
+/*
+* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:
+*
+*/
+#include <memory>
+#include <vector>
+#include <list>
+
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class UninitializedTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(UninitializedTest);
+ CPPUNIT_TEST(copy_test);
+ //CPPUNIT_TEST(fill_test);
+ //CPPUNIT_TEST(fill_n_test);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void copy_test();
+ void fill_test();
+ void fill_n_test();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(UninitializedTest);
+
+struct NotTrivialCopyStruct {
+ NotTrivialCopyStruct() : member(0) {}
+ NotTrivialCopyStruct(NotTrivialCopyStruct const&) : member(1) {}
+
+ int member;
+};
+
+struct TrivialCopyStruct {
+ TrivialCopyStruct() : member(0) {}
+ TrivialCopyStruct(TrivialCopyStruct const&) : member(1) {}
+
+ int member;
+};
+
+struct TrivialInitStruct {
+ TrivialInitStruct()
+ { ++nbConstructorCalls; }
+
+ static size_t nbConstructorCalls;
+};
+
+size_t TrivialInitStruct::nbConstructorCalls = 0;
+
+#if defined (STLPORT)
+namespace std
+{
+ _STLP_TEMPLATE_NULL
+ struct __type_traits<TrivialCopyStruct> {
+ typedef __false_type has_trivial_default_constructor;
+ //This is a wrong declaration just to check that internaly a simple memcpy is called:
+ typedef __true_type has_trivial_copy_constructor;
+ typedef __true_type has_trivial_assignment_operator;
+ typedef __true_type has_trivial_destructor;
+ typedef __false_type is_POD_type;
+ };
+
+ _STLP_TEMPLATE_NULL
+ struct __type_traits<TrivialInitStruct> {
+ //This is a wrong declaration just to check that internaly no initialization is done:
+ typedef __true_type has_trivial_default_constructor;
+ typedef __true_type has_trivial_copy_constructor;
+ typedef __true_type has_trivial_assignment_operator;
+ typedef __true_type has_trivial_destructor;
+ typedef __false_type is_POD_type;
+ };
+}
+#endif
+
+struct base {};
+struct derived : public base {};
+
+//
+// tests implementation
+//
+void UninitializedTest::copy_test()
+{
+ {
+ //Random iterators
+ {
+ vector<NotTrivialCopyStruct> src(10);
+ vector<NotTrivialCopyStruct> dst(10);
+ uninitialized_copy(src.begin(), src.end(), dst.begin());
+ vector<NotTrivialCopyStruct>::const_iterator it(dst.begin()), end(dst.end());
+ for (; it != end; ++it) {
+ CPPUNIT_ASSERT( (*it).member == 1 );
+ }
+ }
+ {
+ /** Note: we use static arrays here so the iterators are always
+ pointers, even in debug mode. */
+ size_t const count = 10;
+ TrivialCopyStruct src[count];
+ TrivialCopyStruct dst[count];
+
+ TrivialCopyStruct* it = src + 0;
+ TrivialCopyStruct* end = src + count;
+ for (; it != end; ++it) {
+ (*it).member = 0;
+ }
+
+ uninitialized_copy(src+0, src+count, dst+0);
+ for (it = dst+0, end = dst+count; it != end; ++it) {
+#if defined (STLPORT)
+ /* If the member is 1, it means that library has not found any
+ optimization oportunity and called the regular copy-ctor instead. */
+ CPPUNIT_ASSERT( (*it).member == 0 );
+#else
+ CPPUNIT_ASSERT( (*it).member == 1 );
+#endif
+ }
+ }
+ }
+
+ {
+ //Bidirectional iterator
+ {
+ vector<NotTrivialCopyStruct> src(10);
+ list<NotTrivialCopyStruct> dst(10);
+
+ list<NotTrivialCopyStruct>::iterator it(dst.begin()), end(dst.end());
+ for (; it != end; ++it) {
+ (*it).member = -1;
+ }
+
+ uninitialized_copy(src.begin(), src.end(), dst.begin());
+
+ for (it = dst.begin(); it != end; ++it) {
+ CPPUNIT_ASSERT( (*it).member == 1 );
+ }
+ }
+
+ {
+ list<NotTrivialCopyStruct> src(10);
+ vector<NotTrivialCopyStruct> dst(10);
+
+ vector<NotTrivialCopyStruct>::iterator it(dst.begin()), end(dst.end());
+ for (; it != end; ++it) {
+ (*it).member = -1;
+ }
+
+ uninitialized_copy(src.begin(), src.end(), dst.begin());
+
+ for (it = dst.begin(); it != end; ++it) {
+ CPPUNIT_ASSERT( (*it).member == 1 );
+ }
+ }
+ }
+
+ {
+ //Using containers of native types:
+#if !defined (STLPORT) || !defined (_STLP_NO_MEMBER_TEMPLATES)
+ {
+ vector<int> src;
+ int i;
+ for (i = -5; i < 6; ++i) {
+ src.push_back(i);
+ }
+
+ //Building a vector result in a uninitialized_copy call internally
+ vector<unsigned int> dst(src.begin(), src.end());
+ vector<unsigned int>::const_iterator it(dst.begin());
+ for (i = -5; i < 6; ++i, ++it) {
+ CPPUNIT_ASSERT( *it == (unsigned int)i );
+ }
+ }
+
+ {
+ vector<char> src;
+ char i;
+ for (i = -5; i < 6; ++i) {
+ src.push_back(i);
+ }
+
+ //Building a vector result in a uninitialized_copy call internally
+ vector<unsigned int> dst(src.begin(), src.end());
+ vector<unsigned int>::const_iterator it(dst.begin());
+ for (i = -5; i < 6; ++i, ++it) {
+ CPPUNIT_ASSERT( *it == (unsigned int)i );
+ }
+ }
+
+ {
+ vector<int> src;
+ int i;
+ for (i = -5; i < 6; ++i) {
+ src.push_back(i);
+ }
+
+ //Building a vector result in a uninitialized_copy call internally
+ vector<float> dst(src.begin(), src.end());
+ vector<float>::const_iterator it(dst.begin());
+ for (i = -5; i < 6; ++i, ++it) {
+ CPPUNIT_ASSERT( *it == (float)i );
+ }
+ }
+
+ {
+ vector<vector<float>*> src(10);
+ vector<vector<float>*> dst(src.begin(), src.end());
+ }
+
+ {
+ derived d;
+ //base *pb = &d;
+ derived *pd = &d;
+ //base **ppb = &pd;
+ vector<derived*> src(10, pd);
+ vector<base*> dst(src.begin(), src.end());
+ vector<base*>::iterator it(dst.begin()), end(dst.end());
+ for (; it != end; ++it) {
+ CPPUNIT_ASSERT( (*it) == pd );
+ }
+ }
+#endif
+ }
+
+ {
+ //Vector initialization:
+ vector<TrivialInitStruct> vect(10);
+ //Just 1 constructor call for the default value:
+ CPPUNIT_ASSERT( TrivialInitStruct::nbConstructorCalls == 1 );
+ }
+}
+
+/*
+void UninitializedTest::fill_test()
+{
+}
+
+void UninitializedTest::fill_n_test()
+{
+}
+*/