[wxWidgets.git] / tests / longlong / longlongtest.cpp

///////////////////////////////////////////////////////////////////////////////
// Name:        tests/longlong/longlong.cpp
// Purpose:     wxLongLong unit test
// Author:      Vadim Zeitlin, Wlodzimierz ABX Skiba
// Created:     2004-04-01
// Copyright:   (c) 2004 Vadim Zeitlin, Wlodzimierz Skiba
///////////////////////////////////////////////////////////////////////////////

// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------

#include "testprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#ifndef WX_PRECOMP
    #include "wx/wx.h"
#endif // WX_PRECOMP

#include "wx/longlong.h"
#include "wx/timer.h"

#if wxUSE_LONGLONG

// ----------------------------------------------------------------------------
// helpers for testing
// ----------------------------------------------------------------------------

// number of iterations in loops
#define ITEMS 1000

// make a 64 bit number from 4 16 bit ones
#define MAKE_LL(x1, x2, x3, x4) wxLongLong((x1 << 16) | x2, (x3 << 16) | x3)

// get a random 64 bit number
#define RAND_LL()   MAKE_LL(rand(), rand(), rand(), rand())

static const long testLongs[] =
{
    0,
    1,
    -1,
    LONG_MAX,
    LONG_MIN,
    0x1234,
    -0x1234
};

// ----------------------------------------------------------------------------
// test class
// ----------------------------------------------------------------------------

class LongLongTestCase : public CppUnit::TestCase
{
public:
    LongLongTestCase();

private:
    CPPUNIT_TEST_SUITE( LongLongTestCase );
        CPPUNIT_TEST( Conversion );
        CPPUNIT_TEST( Comparison );
        CPPUNIT_TEST( Addition );
        CPPUNIT_TEST( Multiplication );
        CPPUNIT_TEST( Division );
        CPPUNIT_TEST( BitOperations );
        CPPUNIT_TEST( ToString );
        CPPUNIT_TEST( LoHi );
        CPPUNIT_TEST( Limits );
    CPPUNIT_TEST_SUITE_END();

    void Conversion();
    void Comparison();
    void Addition();
    void Multiplication();
    void Division();
    void BitOperations();
    void ToString();
    void LoHi();
    void Limits();

    DECLARE_NO_COPY_CLASS(LongLongTestCase)
};

// register in the unnamed registry so that these tests are run by default
CPPUNIT_TEST_SUITE_REGISTRATION( LongLongTestCase );

// also include in its own registry so that these tests can be run alone
CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( LongLongTestCase, "LongLongTestCase" );

LongLongTestCase::LongLongTestCase()
{
    srand((unsigned)time(NULL));
}

void LongLongTestCase::Conversion()
{
    for ( size_t n = 0; n < ITEMS; n++ )
    {
        wxLongLong a = RAND_LL();

        wxLongLong b(a.GetHi(), a.GetLo());
        CPPUNIT_ASSERT( a == b );

#if wxUSE_LONGLONG_WX
        wxLongLongWx c(a.GetHi(), a.GetLo());
        CPPUNIT_ASSERT( a == c );
#endif

#if wxUSE_LONGLONG_NATIVE
        wxLongLongNative d(a.GetHi(), a.GetLo());
        CPPUNIT_ASSERT( a == d );
#endif
    }
}

void LongLongTestCase::Comparison()
{
    static const long ls[2] =
    {
        0x1234,
       -0x1234,
    };

    wxLongLong lls[2];
    lls[0] = ls[0];
    lls[1] = ls[1];

    for ( size_t n = 0; n < WXSIZEOF(testLongs); n++ )
    {
        for ( size_t m = 0; m < WXSIZEOF(lls); m++ )
        {
            CPPUNIT_ASSERT( (lls[m] < testLongs[n]) == (ls[m] < testLongs[n]) );
            CPPUNIT_ASSERT( (lls[m] > testLongs[n]) == (ls[m] > testLongs[n]) );
            CPPUNIT_ASSERT( (lls[m] <= testLongs[n]) == (ls[m] <= testLongs[n]) );
            CPPUNIT_ASSERT( (lls[m] >= testLongs[n]) == (ls[m] >= testLongs[n]) );
            CPPUNIT_ASSERT( (lls[m] != testLongs[n]) == (ls[m] != testLongs[n]) );
            CPPUNIT_ASSERT( (lls[m] == testLongs[n]) == (ls[m] == testLongs[n]) );
        }
    }
}

void LongLongTestCase::Addition()
{
    for ( size_t n = 0; n < ITEMS; n++ )
    {
        wxLongLong a = RAND_LL();
        wxLongLong b = RAND_LL();
        wxLongLong c = a + b;

#if wxUSE_LONGLONG_NATIVE
        wxLongLongNative a1 = a;
        wxLongLongNative b1 = b;
        wxLongLongNative c1 = a1 + b1;
        CPPUNIT_ASSERT( c == c1 );
#endif

#if wxUSE_LONGLONG_WX
        wxLongLongWx a2 = a;
        wxLongLongWx b2 = b;
        wxLongLongWx c2 = a2 + b2;
        CPPUNIT_ASSERT( c == c2 );
#endif
    }
}

void LongLongTestCase::Multiplication()
{
    for ( size_t n = 0; n < ITEMS; n++ )
    {
        wxLongLong a = RAND_LL();
        wxLongLong b = RAND_LL();
        wxLongLong c = a*b;

        wxLongLong a1(a.GetHi(), a.GetLo());
        wxLongLong b1(b.GetHi(), b.GetLo());
        wxLongLong c1 = a1*b1;
        CPPUNIT_ASSERT( c1 == c );

#if wxUSE_LONGLONG_WX
        wxLongLongWx a2(a.GetHi(), a.GetLo());
        wxLongLongWx b2(b.GetHi(), b.GetLo());
        wxLongLongWx c2 = a2*b2;
        CPPUNIT_ASSERT( c2 == c );
#endif

#if wxUSE_LONGLONG_NATIVE
        wxLongLongNative a3(a.GetHi(), a.GetLo());
        wxLongLongNative b3(b.GetHi(), b.GetLo());
        wxLongLongNative c3 = a3*b3;
        CPPUNIT_ASSERT( c3 == c );
#endif
    }
}

void LongLongTestCase::Division()
{
    for ( size_t n = 0; n < ITEMS; n++ )
    {
        // get a random wxLongLong (shifting by 12 the MSB ensures that the
        // multiplication will not overflow)
        wxLongLong a = MAKE_LL((rand() >> 12), rand(), rand(), rand());

        // get a random (but non null) long (not wxLongLong for now) divider
        long l;
        do
        {
           l = rand();
        }
        while ( !l );

        wxLongLong q = a / l;
        wxLongLong r = a % l;

        CPPUNIT_ASSERT( a == ( q * l + r ) );

#if wxUSE_LONGLONG_WX
        wxLongLongWx a1(a.GetHi(), a.GetLo());
        wxLongLongWx q1 = a1 / l;
        wxLongLongWx r1 = a1 % l;
        CPPUNIT_ASSERT( q == q1 );
        CPPUNIT_ASSERT( r == r1 );
        CPPUNIT_ASSERT( a1 == ( q1 * l + r1 ) );
#endif

#if wxUSE_LONGLONG_NATIVE
        wxLongLongNative a2(a.GetHi(), a.GetLo());
        wxLongLongNative q2 = a2 / l;
        wxLongLongNative r2 = a2 % l;
        CPPUNIT_ASSERT( q == q2 );
        CPPUNIT_ASSERT( r == r2 );
        CPPUNIT_ASSERT( a2 == ( q2 * l + r2 ) );
#endif
    }
}

void LongLongTestCase::BitOperations()
{
    for ( size_t m = 0; m < ITEMS; m++ )
    {
        wxLongLong a = RAND_LL();

        for ( size_t n = 0; n < 33; n++ )
        {
            wxLongLong b(a.GetHi(), a.GetLo()), c, d = b, e;
            d >>= n;
            c = b >> n;
            CPPUNIT_ASSERT( c == d );
            d <<= n;
            e = c << n;
            CPPUNIT_ASSERT( d == e );

#if wxUSE_LONGLONG_WX
            wxLongLongWx b1(a.GetHi(), a.GetLo()), c1, d1 = b1, e1;
            d1 >>= n;
            c1 = b1 >> n;
            CPPUNIT_ASSERT( c1 == d1 );
            d1 <<= n;
            e1 = c1 << n;
            CPPUNIT_ASSERT( d1 == e1 );
#endif

#if wxUSE_LONGLONG_NATIVE
            wxLongLongNative b2(a.GetHi(), a.GetLo()), c2, d2 = b2, e2;
            d2 >>= n;
            c2 = b2 >> n;
            CPPUNIT_ASSERT( c2 == d2 );
            d2 <<= n;
            e2 = c2 << n;
            CPPUNIT_ASSERT( d2 == e2 );
#endif
        }
    }
}

void LongLongTestCase::ToString()
{
    wxString s1, s2;

    for ( size_t n = 0; n < WXSIZEOF(testLongs); n++ )
    {
        wxLongLong a = testLongs[n];
        s1 = wxString::Format(wxT("%ld"), testLongs[n]);
        s2 = a.ToString();
        CPPUNIT_ASSERT( s1 == s2 );

        s2 = wxEmptyString;
        s2 << a;
        CPPUNIT_ASSERT( s1 == s2 );

#if wxUSE_LONGLONG_WX
        wxLongLongWx a1 = testLongs[n];
        s2 = a1.ToString();
        CPPUNIT_ASSERT( s1 == s2 );
#endif

#if wxUSE_LONGLONG_NATIVE
        wxLongLongNative a2 = testLongs[n];
        s2 = a2.ToString();
        CPPUNIT_ASSERT( s1 == s2 );
#endif
    }

    wxLongLong a(0x12345678, 0x87654321);
    CPPUNIT_ASSERT( a.ToString() == wxT("1311768467139281697") );
    a.Negate();
    CPPUNIT_ASSERT( a.ToString() == wxT("-1311768467139281697") );

    wxLongLong llMin(-2147483647L - 1L, 0);
    CPPUNIT_ASSERT( llMin.ToString() == wxT("-9223372036854775808") );

#if wxUSE_LONGLONG_WX
    wxLongLongWx a1(a.GetHi(), a.GetLo());
    CPPUNIT_ASSERT( a1.ToString() == wxT("-1311768467139281697") );
    a1.Negate();
    CPPUNIT_ASSERT( a1.ToString() == wxT("1311768467139281697") );
#endif

#if wxUSE_LONGLONG_NATIVE
    wxLongLongNative a2(a.GetHi(), a.GetLo());
    CPPUNIT_ASSERT( a2.ToString() == wxT("-1311768467139281697") );
    a2.Negate();
    CPPUNIT_ASSERT( a2.ToString() == wxT("1311768467139281697") );
#endif

}

void LongLongTestCase::LoHi()
{
    wxLongLong ll(123, 456);
    CPPUNIT_ASSERT_EQUAL( 456u, ll.GetLo() );
    CPPUNIT_ASSERT_EQUAL( 123, ll.GetHi() );

    wxULongLong ull(987, 654);
    CPPUNIT_ASSERT_EQUAL( 654u, ull.GetLo() );
    CPPUNIT_ASSERT_EQUAL( 987u, ull.GetHi() );
}

void LongLongTestCase::Limits()
{
    // VC6 doesn't specialize numeric_limits<> for __int64 so skip this test
    // for it.
#ifndef __VISUALC6__
#if wxUSE_LONGLONG_NATIVE
    CPPUNIT_ASSERT( std::numeric_limits<wxLongLong>::is_specialized );
    CPPUNIT_ASSERT( std::numeric_limits<wxULongLong>::is_specialized );

    wxULongLong maxval = std::numeric_limits<wxULongLong>::max();
    CPPUNIT_ASSERT( maxval.ToDouble() > 0 );
#endif // wxUSE_LONGLONG_NATIVE
#endif // !__VISUALC6__
}

#endif // wxUSE_LONGLONG
Commit	Line	Data
1b035b8c VS	1	///////////////////////////////////////////////////////////////////////////////
	2	// Name: tests/longlong/longlong.cpp
	3	// Purpose: wxLongLong unit test
	4	// Author: Vadim Zeitlin, Wlodzimierz ABX Skiba
	5	// Created: 2004-04-01
1b035b8c VS	6	// Copyright: (c) 2004 Vadim Zeitlin, Wlodzimierz Skiba
	7	///////////////////////////////////////////////////////////////////////////////
	8
	9	// ----------------------------------------------------------------------------
	10	// headers
	11	// ----------------------------------------------------------------------------
	12
8899b155	13	#include "testprec.h"
1b035b8c VS	14
	15	#ifdef __BORLANDC__
	16	#pragma hdrstop
	17	#endif
	18
	19	#ifndef WX_PRECOMP
	20	#include "wx/wx.h"
	21	#endif // WX_PRECOMP
	22
	23	#include "wx/longlong.h"
	24	#include "wx/timer.h"
	25
216a72f3 VZ	26	#if wxUSE_LONGLONG
216a72f3 VZ	27
1b035b8c VS	28	// ----------------------------------------------------------------------------
	29	// helpers for testing
	30	// ----------------------------------------------------------------------------
	31
	32	// number of iterations in loops
95762eaf	33	#define ITEMS 1000
1b035b8c VS	34
	35	// make a 64 bit number from 4 16 bit ones
	36	#define MAKE_LL(x1, x2, x3, x4) wxLongLong((x1 << 16) \| x2, (x3 << 16) \| x3)
	37
	38	// get a random 64 bit number
	39	#define RAND_LL() MAKE_LL(rand(), rand(), rand(), rand())
	40
	41	static const long testLongs[] =
	42	{
	43	0,
	44	1,
	45	-1,
	46	LONG_MAX,
	47	LONG_MIN,
	48	0x1234,
	49	-0x1234
	50	};
	51
	52	// ----------------------------------------------------------------------------
	53	// test class
	54	// ----------------------------------------------------------------------------
	55
	56	class LongLongTestCase : public CppUnit::TestCase
	57	{
	58	public:
	59	LongLongTestCase();
	60
	61	private:
	62	CPPUNIT_TEST_SUITE( LongLongTestCase );
	63	CPPUNIT_TEST( Conversion );
	64	CPPUNIT_TEST( Comparison );
	65	CPPUNIT_TEST( Addition );
	66	CPPUNIT_TEST( Multiplication );
	67	CPPUNIT_TEST( Division );
	68	CPPUNIT_TEST( BitOperations );
	69	CPPUNIT_TEST( ToString );
bec76e18	70	CPPUNIT_TEST( LoHi );
3dd4d0ec	71	CPPUNIT_TEST( Limits );
1b035b8c VS	72	CPPUNIT_TEST_SUITE_END();
	73
	74	void Conversion();
	75	void Comparison();
	76	void Addition();
	77	void Multiplication();
	78	void Division();
	79	void BitOperations();
	80	void ToString();
bec76e18	81	void LoHi();
3dd4d0ec	82	void Limits();
1b035b8c VS	83
	84	DECLARE_NO_COPY_CLASS(LongLongTestCase)
	85	};
	86
	87	// register in the unnamed registry so that these tests are run by default
	88	CPPUNIT_TEST_SUITE_REGISTRATION( LongLongTestCase );
	89
e3778b4d	90	// also include in its own registry so that these tests can be run alone
1b035b8c VS	91	CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( LongLongTestCase, "LongLongTestCase" );
	92
	93	LongLongTestCase::LongLongTestCase()
	94	{
	95	srand((unsigned)time(NULL));
	96	}
	97
	98	void LongLongTestCase::Conversion()
	99	{
	100	for ( size_t n = 0; n < ITEMS; n++ )
	101	{
	102	wxLongLong a = RAND_LL();
	103
	104	wxLongLong b(a.GetHi(), a.GetLo());
	105	CPPUNIT_ASSERT( a == b );
	106
	107	#if wxUSE_LONGLONG_WX
	108	wxLongLongWx c(a.GetHi(), a.GetLo());
	109	CPPUNIT_ASSERT( a == c );
	110	#endif
	111
	112	#if wxUSE_LONGLONG_NATIVE
	113	wxLongLongNative d(a.GetHi(), a.GetLo());
	114	CPPUNIT_ASSERT( a == d );
	115	#endif
	116	}
	117	}
	118
	119	void LongLongTestCase::Comparison()
	120	{
	121	static const long ls[2] =
	122	{
	123	0x1234,
	124	-0x1234,
	125	};
	126
	127	wxLongLong lls[2];
	128	lls[0] = ls[0];
	129	lls[1] = ls[1];
	130
	131	for ( size_t n = 0; n < WXSIZEOF(testLongs); n++ )
	132	{
	133	for ( size_t m = 0; m < WXSIZEOF(lls); m++ )
	134	{
	135	CPPUNIT_ASSERT( (lls[m] < testLongs[n]) == (ls[m] < testLongs[n]) );
	136	CPPUNIT_ASSERT( (lls[m] > testLongs[n]) == (ls[m] > testLongs[n]) );
	137	CPPUNIT_ASSERT( (lls[m] <= testLongs[n]) == (ls[m] <= testLongs[n]) );
	138	CPPUNIT_ASSERT( (lls[m] >= testLongs[n]) == (ls[m] >= testLongs[n]) );
	139	CPPUNIT_ASSERT( (lls[m] != testLongs[n]) == (ls[m] != testLongs[n]) );
	140	CPPUNIT_ASSERT( (lls[m] == testLongs[n]) == (ls[m] == testLongs[n]) );
	141	}
	142	}
	143	}
	144
	145	void LongLongTestCase::Addition()
	146	{
	147	for ( size_t n = 0; n < ITEMS; n++ )
	148	{
	149	wxLongLong a = RAND_LL();
	150	wxLongLong b = RAND_LL();
	151	wxLongLong c = a + b;
	152
	153	#if wxUSE_LONGLONG_NATIVE
	154	wxLongLongNative a1 = a;
155	wxLongLongNative b1 = b;
156	wxLongLongNative c1 = a1 + b1;
157	CPPUNIT_ASSERT( c == c1 );
158	#endif
159
160	#if wxUSE_LONGLONG_WX
161	wxLongLongWx a2 = a;
162	wxLongLongWx b2 = b;
163	wxLongLongWx c2 = a2 + b2;
164	CPPUNIT_ASSERT( c == c2 );
165	#endif
166	}
167	}
168
169	void LongLongTestCase::Multiplication()
170	{
171	for ( size_t n = 0; n < ITEMS; n++ )
172	{
173	wxLongLong a = RAND_LL();
174	wxLongLong b = RAND_LL();
175	wxLongLong c = a*b;
176
177	wxLongLong a1(a.GetHi(), a.GetLo());
178	wxLongLong b1(b.GetHi(), b.GetLo());
179	wxLongLong c1 = a1*b1;
180	CPPUNIT_ASSERT( c1 == c );
181
182	#if wxUSE_LONGLONG_WX
183	wxLongLongWx a2(a.GetHi(), a.GetLo());
184	wxLongLongWx b2(b.GetHi(), b.GetLo());
185	wxLongLongWx c2 = a2*b2;
186	CPPUNIT_ASSERT( c2 == c );
187	#endif
188
189	#if wxUSE_LONGLONG_NATIVE
190	wxLongLongNative a3(a.GetHi(), a.GetLo());
191	wxLongLongNative b3(b.GetHi(), b.GetLo());
192	wxLongLongNative c3 = a3*b3;
193	CPPUNIT_ASSERT( c3 == c );
194	#endif
195	}
196	}
197
198	void LongLongTestCase::Division()
199	{
200	for ( size_t n = 0; n < ITEMS; n++ )
201	{
202	// get a random wxLongLong (shifting by 12 the MSB ensures that the
203	// multiplication will not overflow)
204	wxLongLong a = MAKE_LL((rand() >> 12), rand(), rand(), rand());
205
206	// get a random (but non null) long (not wxLongLong for now) divider
207	long l;
208	do
209	{
210	l = rand();
211	}
212	while ( !l );
213
214	wxLongLong q = a / l;
215	wxLongLong r = a % l;
216
217	CPPUNIT_ASSERT( a == ( q * l + r ) );
218
219	#if wxUSE_LONGLONG_WX
220	wxLongLongWx a1(a.GetHi(), a.GetLo());
221	wxLongLongWx q1 = a1 / l;
222	wxLongLongWx r1 = a1 % l;
223	CPPUNIT_ASSERT( q == q1 );
224	CPPUNIT_ASSERT( r == r1 );
225	CPPUNIT_ASSERT( a1 == ( q1 * l + r1 ) );
226	#endif
227
228	#if wxUSE_LONGLONG_NATIVE
229	wxLongLongNative a2(a.GetHi(), a.GetLo());
230	wxLongLongNative q2 = a2 / l;
231	wxLongLongNative r2 = a2 % l;
232	CPPUNIT_ASSERT( q == q2 );
233	CPPUNIT_ASSERT( r == r2 );
234	CPPUNIT_ASSERT( a2 == ( q2 * l + r2 ) );
235	#endif
236	}
237	}
238
239	void LongLongTestCase::BitOperations()
240	{
93a800a9	241	for ( size_t m = 0; m < ITEMS; m++ )
1b035b8c VS	242	{
	243	wxLongLong a = RAND_LL();
	244
	245	for ( size_t n = 0; n < 33; n++ )
	246	{
	247	wxLongLong b(a.GetHi(), a.GetLo()), c, d = b, e;
51496782 WS	248	d >>= n;
51496782 WS	249	c = b >> n;
1b035b8c	250	CPPUNIT_ASSERT( c == d );
51496782 WS	251	d <<= n;
51496782 WS	252	e = c << n;
1b035b8c VS	253	CPPUNIT_ASSERT( d == e );
	254
	255	#if wxUSE_LONGLONG_WX
	256	wxLongLongWx b1(a.GetHi(), a.GetLo()), c1, d1 = b1, e1;
51496782 WS	257	d1 >>= n;
51496782 WS	258	c1 = b1 >> n;
1b035b8c	259	CPPUNIT_ASSERT( c1 == d1 );
51496782 WS	260	d1 <<= n;
51496782 WS	261	e1 = c1 << n;
1b035b8c VS	262	CPPUNIT_ASSERT( d1 == e1 );
	263	#endif
	264
	265	#if wxUSE_LONGLONG_NATIVE
	266	wxLongLongNative b2(a.GetHi(), a.GetLo()), c2, d2 = b2, e2;
51496782 WS	267	d2 >>= n;
51496782 WS	268	c2 = b2 >> n;
1b035b8c	269	CPPUNIT_ASSERT( c2 == d2 );
51496782 WS	270	d2 <<= n;
51496782 WS	271	e2 = c2 << n;
1b035b8c VS	272	CPPUNIT_ASSERT( d2 == e2 );
	273	#endif
	274	}
	275	}
	276	}
	277
	278	void LongLongTestCase::ToString()
	279	{
	280	wxString s1, s2;
	281
	282	for ( size_t n = 0; n < WXSIZEOF(testLongs); n++ )
	283	{
	284	wxLongLong a = testLongs[n];
9a83f860	285	s1 = wxString::Format(wxT("%ld"), testLongs[n]);
1b035b8c VS	286	s2 = a.ToString();
	287	CPPUNIT_ASSERT( s1 == s2 );
	288
51496782 WS	289	s2 = wxEmptyString;
	290	s2 << a;
	291	CPPUNIT_ASSERT( s1 == s2 );
	292
1b035b8c VS	293	#if wxUSE_LONGLONG_WX
	294	wxLongLongWx a1 = testLongs[n];
	295	s2 = a1.ToString();
	296	CPPUNIT_ASSERT( s1 == s2 );
	297	#endif
	298
	299	#if wxUSE_LONGLONG_NATIVE
	300	wxLongLongNative a2 = testLongs[n];
	301	s2 = a2.ToString();
	302	CPPUNIT_ASSERT( s1 == s2 );
	303	#endif
	304	}
	305
	306	wxLongLong a(0x12345678, 0x87654321);
9a83f860	307	CPPUNIT_ASSERT( a.ToString() == wxT("1311768467139281697") );
1b035b8c	308	a.Negate();
9a83f860	309	CPPUNIT_ASSERT( a.ToString() == wxT("-1311768467139281697") );
1b035b8c	310
1d805c14	311	wxLongLong llMin(-2147483647L - 1L, 0);
9a83f860	312	CPPUNIT_ASSERT( llMin.ToString() == wxT("-9223372036854775808") );
1d4037aa	313
1b035b8c VS	314	#if wxUSE_LONGLONG_WX
1b035b8c VS	315	wxLongLongWx a1(a.GetHi(), a.GetLo());
9a83f860	316	CPPUNIT_ASSERT( a1.ToString() == wxT("-1311768467139281697") );
1b035b8c	317	a1.Negate();
9a83f860	318	CPPUNIT_ASSERT( a1.ToString() == wxT("1311768467139281697") );
1b035b8c VS	319	#endif
	320
	321	#if wxUSE_LONGLONG_NATIVE
	322	wxLongLongNative a2(a.GetHi(), a.GetLo());
9a83f860	323	CPPUNIT_ASSERT( a2.ToString() == wxT("-1311768467139281697") );
1b035b8c	324	a2.Negate();
9a83f860	325	CPPUNIT_ASSERT( a2.ToString() == wxT("1311768467139281697") );
1b035b8c VS	326	#endif
	327
	328	}
	329
bec76e18 VZ	330	void LongLongTestCase::LoHi()
	331	{
	332	wxLongLong ll(123, 456);
	333	CPPUNIT_ASSERT_EQUAL( 456u, ll.GetLo() );
	334	CPPUNIT_ASSERT_EQUAL( 123, ll.GetHi() );
	335
	336	wxULongLong ull(987, 654);
	337	CPPUNIT_ASSERT_EQUAL( 654u, ull.GetLo() );
	338	CPPUNIT_ASSERT_EQUAL( 987u, ull.GetHi() );
	339	}
	340
3dd4d0ec VZ	341	void LongLongTestCase::Limits()
3dd4d0ec VZ	342	{
dff485d0 VZ	343	// VC6 doesn't specialize numeric_limits<> for __int64 so skip this test
	344	// for it.
	345	#ifndef __VISUALC6__
3dd4d0ec VZ	346	#if wxUSE_LONGLONG_NATIVE
	347	CPPUNIT_ASSERT( std::numeric_limits<wxLongLong>::is_specialized );
	348	CPPUNIT_ASSERT( std::numeric_limits<wxULongLong>::is_specialized );
	349
	350	wxULongLong maxval = std::numeric_limits<wxULongLong>::max();
	351	CPPUNIT_ASSERT( maxval.ToDouble() > 0 );
	352	#endif // wxUSE_LONGLONG_NATIVE
dff485d0	353	#endif // !__VISUALC6__
3dd4d0ec VZ	354	}
3dd4d0ec VZ	355
216a72f3	356	#endif // wxUSE_LONGLONG