[wxWidgets.git] / tests / streams / largefile.cpp

///////////////////////////////////////////////////////////////////////////////
// Name:        tests/streams/largefile.cpp
// Purpose:     Tests for large file support
// Author:      Mike Wetherell
// RCS-ID:      $Id$
// Copyright:   (c) 2004 Mike Wetherell
// Licence:     wxWidgets licence
///////////////////////////////////////////////////////////////////////////////

//
// We're interested in what happens around offsets 0x7fffffff and 0xffffffff
// so the test writes a small chunk of test data just before and just after
// these offsets, then reads them back.
//
// The tests can be run with:
//
//  test --verbose largeFile
//
// On systems supporting sparse files they may also be registered in the
// Streams subsuite.
//

// For compilers that support precompilation, includes "wx/wx.h".
#include "testprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

// for all others, include the necessary headers
#ifndef WX_PRECOMP
    #include "wx/wx.h"
#endif

#include "wx/filename.h"
#include "wx/wfstream.h"

#ifdef __WXMSW__
#include "wx/msw/wrapwin.h"
#include <winioctl.h>
#endif

using std::auto_ptr;


///////////////////////////////////////////////////////////////////////////////
// Helpers

bool IsFAT(const wxString& path);
void MakeSparse(const wxString& path, int fd);


///////////////////////////////////////////////////////////////////////////////
// Base class for the test cases - common code

class LargeFileTest : public CppUnit::TestCase
{
public:
    LargeFileTest(std::string name) : CppUnit::TestCase(name) { }
    virtual ~LargeFileTest() { }

protected:
    void runTest();

    virtual wxInputStream *MakeInStream(const wxString& name) const = 0;
    virtual wxOutputStream *MakeOutStream(const wxString& name) const = 0;
    virtual bool HasLFS() const = 0;
};

void LargeFileTest::runTest()
{
    // self deleting temp file
    struct TmpFile {
        TmpFile() : m_name(wxFileName::CreateTempFileName(_T("wxlfs-"))) { }
        ~TmpFile() { if (!m_name.empty()) wxRemoveFile(m_name); }
        wxString m_name;
    } tmpfile;

    CPPUNIT_ASSERT(!tmpfile.m_name.empty());

    bool haveLFS = true;
    bool fourGigLimit = false;

    if (!HasLFS()) {
        haveLFS = false;
        wxString n(getName().c_str(), *wxConvCurrent);
        wxLogInfo(n + _T(": No large file support, testing up to 2GB only"));
    }
    else if (IsFAT(tmpfile.m_name)) {
        fourGigLimit = true;
        wxString n(getName().c_str(), *wxConvCurrent);
        wxLogInfo(n + _T(": FAT volumes are limited to 4GB files"));
    }

    // size of the test blocks
    const size_t size = 0x40;

    // the test blocks
    char upto2Gig[size];
    char past2Gig[size];
    char upto4Gig[size];
    char past4Gig[size];
    memset(upto2Gig, 'A', size);
    memset(past2Gig, 'B', size);
    memset(upto4Gig, 'X', size);
    memset(past4Gig, 'Y', size);

    wxFileOffset pos;

    // write a large file
    {
        auto_ptr<wxOutputStream> out(MakeOutStream(tmpfile.m_name));
        
        // write 'A's at [ 0x7fffffbf, 0x7fffffff [
        pos = 0x7fffffff - size;
        CPPUNIT_ASSERT(out->SeekO(pos) == pos);
        CPPUNIT_ASSERT(out->Write(upto2Gig, size).LastWrite() == size);
        pos += size;

        if (haveLFS) {
            // write 'B's at [ 0x7fffffff, 0x8000003f [
            CPPUNIT_ASSERT(out->Write(past2Gig, size).LastWrite() == size);
            pos += size;
            CPPUNIT_ASSERT(out->TellO() == pos);

            // write 'X's at [ 0xffffffbf, 0xffffffff [
            pos = 0xffffffff - size;
            CPPUNIT_ASSERT(out->SeekO(pos) == pos);
            CPPUNIT_ASSERT(out->Write(upto4Gig, size).LastWrite() == size);
            pos += size;

            if (!fourGigLimit) {
                // write 'Y's at [ 0xffffffff, 0x10000003f [
                CPPUNIT_ASSERT(out->Write(past4Gig, size).LastWrite() == size);
                pos += size;
            }
        }

        // check the file seems to be the right length
        CPPUNIT_ASSERT(out->TellO() == pos);
        CPPUNIT_ASSERT(out->GetLength() == pos);
    }

    // read the large file back
    {
        auto_ptr<wxInputStream> in(MakeInStream(tmpfile.m_name));
        char buf[size];

        if (haveLFS) {
            CPPUNIT_ASSERT(in->GetLength() == pos);
            pos = 0xffffffff;

            if (!fourGigLimit) {
                CPPUNIT_ASSERT(in->GetLength() > pos);

                // read back the 'Y's at [ 0xffffffff, 0x10000003f [
                CPPUNIT_ASSERT(in->SeekI(pos) == pos);
                CPPUNIT_ASSERT(in->Read(buf, size).LastRead() == size);
                CPPUNIT_ASSERT(memcmp(buf, past4Gig, size) == 0);

                CPPUNIT_ASSERT(in->TellI() == in->GetLength());
            }

            // read back the 'X's at [ 0xffffffbf, 0xffffffff [
            pos -= size;
            CPPUNIT_ASSERT(in->SeekI(pos) == pos);
            CPPUNIT_ASSERT(in->Read(buf, size).LastRead() == size);
            CPPUNIT_ASSERT(memcmp(buf, upto4Gig, size) == 0);
            pos += size;
            CPPUNIT_ASSERT(in->TellI() == pos);

            // read back the 'B's at [ 0x7fffffff, 0x8000003f [
            pos = 0x7fffffff;
            CPPUNIT_ASSERT(in->SeekI(pos) == pos);
            CPPUNIT_ASSERT(in->Read(buf, size).LastRead() == size);
            CPPUNIT_ASSERT(memcmp(buf, past2Gig, size) == 0);
        }
        else {
            CPPUNIT_ASSERT(in->GetLength() == 0x7fffffff);
            pos = 0x7fffffff;
        }

        // read back the 'A's at [ 0x7fffffbf, 0x7fffffff [
        pos -= size;
        CPPUNIT_ASSERT(in->SeekI(pos) == pos);
        CPPUNIT_ASSERT(in->Read(buf, size).LastRead() == size);
        CPPUNIT_ASSERT(memcmp(buf, upto2Gig, size) == 0);
        pos += size;
        CPPUNIT_ASSERT(in->TellI() == pos);
    }
}


///////////////////////////////////////////////////////////////////////////////
// wxFile test case

class LargeFileTest_wxFile : public LargeFileTest
{
public:
    LargeFileTest_wxFile() : LargeFileTest("wxFile streams") { }

protected:
    wxInputStream *MakeInStream(const wxString& name) const;
    wxOutputStream *MakeOutStream(const wxString& name) const;
    bool HasLFS() const { return (wxFileOffset)0xffffffff > 0; }
};

wxInputStream *LargeFileTest_wxFile::MakeInStream(const wxString& name) const
{
    auto_ptr<wxFileInputStream> in(new wxFileInputStream(name));
    CPPUNIT_ASSERT(in->Ok());
    return in.release();
}

wxOutputStream *LargeFileTest_wxFile::MakeOutStream(const wxString& name) const
{
    wxFile file(name, wxFile::write);
    CPPUNIT_ASSERT(file.IsOpened());
    int fd = file.fd();
    file.Detach();
    MakeSparse(name, fd);
    return new wxFileOutputStream(fd);
}


///////////////////////////////////////////////////////////////////////////////
// wxFFile test case

class LargeFileTest_wxFFile : public LargeFileTest
{
public:
    LargeFileTest_wxFFile() : LargeFileTest("wxFFile streams") { }

protected:
    wxInputStream *MakeInStream(const wxString& name) const;
    wxOutputStream *MakeOutStream(const wxString& name) const;
    bool HasLFS() const;
};

wxInputStream *LargeFileTest_wxFFile::MakeInStream(const wxString& name) const
{
    auto_ptr<wxFFileInputStream> in(new wxFFileInputStream(name));
    CPPUNIT_ASSERT(in->Ok());
    return in.release();
}

wxOutputStream *LargeFileTest_wxFFile::MakeOutStream(const wxString& name) const
{
    wxFFile file(name, _T("w"));
    CPPUNIT_ASSERT(file.IsOpened());
    FILE *fp = file.fp();
    file.Detach();
    MakeSparse(name, fileno(fp));
    return new wxFFileOutputStream(fp);
}

bool LargeFileTest_wxFFile::HasLFS() const
{
#ifdef HAVE_FSEEKO
    return (wxFileOffset)0xffffffff > 0;
#else
    return false;
#endif
}


///////////////////////////////////////////////////////////////////////////////
// The suite

class largeFile : public CppUnit::TestSuite
{
public:
    largeFile() : CppUnit::TestSuite("largeFile") { }

    static CppUnit::Test *suite();
};

CppUnit::Test *largeFile::suite()
{
    largeFile *suite = new largeFile;

    suite->addTest(new LargeFileTest_wxFile);
    suite->addTest(new LargeFileTest_wxFFile);

    return suite;
}


///////////////////////////////////////////////////////////////////////////////
// Implement the helpers
//
// Ideally these tests will be part of the default suite so that regressions
// are picked up. However this is only possible when sparse files are
// supported otherwise the tests require too much disk space.
//
// On unix, most filesystems support sparse files, though not all. So for now
// I'm not assuming sparse file support on unix. On Windows it's possible to
// test, and sparse files should be available on Win 5+ with NTFS.

#ifdef __WXMSW__

#ifndef FILE_SUPPORTS_SPARSE_FILES
#define FILE_SUPPORTS_SPARSE_FILES 0x00000040
#endif

#ifndef FSCTL_SET_SPARSE

#   ifndef FILE_SPECIAL_ACCESS 
#       define FILE_SPECIAL_ACCESS FILE_ANY_ACCESS
#   endif
#   define FSCTL_SET_SPARSE CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 49, \
                                     METHOD_BUFFERED, FILE_SPECIAL_ACCESS)
#endif

static DWORD  volumeFlags;
static wxChar volumeType[64];
static bool   volumeInfoInit;

void GetVolumeInfo(const wxString& path)
{
    // extract the volume 'C:\' or '\\tooter\share\' from the path
    wxString vol;
    
    if (path.substr(1, 2) == _T(":\\")) {
        vol = path.substr(0, 3);
    } else {
        if (path.substr(0, 2) == _T("\\\\")) {
            size_t i = path.find(_T('\\'), 2);

            if (i != wxString::npos && i > 2) {
                size_t j = path.find(_T('\\'), ++i);

                if (j != i)
                    vol = path.substr(0, j) + _T("\\");
            }
        }
    }

    // NULL means the current volume
    const wxChar *pVol = vol.empty() ? (wxChar *)NULL
                                     : vol.c_str();

    if (!::GetVolumeInformation(pVol, NULL, 0, NULL, NULL,
                                &volumeFlags, 
                                volumeType,
                                WXSIZEOF(volumeType)))
        wxLogSysError(_T("GetVolumeInformation() failed"));

    volumeInfoInit = true;
}

bool IsFAT(const wxString& path)
{
    if (!volumeInfoInit)
        GetVolumeInfo(path);
    return wxString(volumeType).Upper().find(_T("FAT")) != wxString::npos;
}

void MakeSparse(const wxString& path, int fd)
{
    DWORD cb;

    if (!volumeInfoInit)
        GetVolumeInfo(path);
   
    if ((volumeFlags & FILE_SUPPORTS_SPARSE_FILES) != 0)
        if (!::DeviceIoControl((HANDLE)_get_osfhandle(fd),
                               FSCTL_SET_SPARSE,
                               NULL, 0, NULL, 0, &cb, NULL))
            volumeFlags &= ~FILE_SUPPORTS_SPARSE_FILES;
}

CppUnit::Test* GetlargeFileSuite()
{
    if (!volumeInfoInit) {
        wxFile file;
        wxString path = wxFileName::CreateTempFileName(_T("wxlfs-"), &file);
        MakeSparse(path, file.fd());
        wxRemoveFile(path);
    }

    if ((volumeFlags & FILE_SUPPORTS_SPARSE_FILES) != 0)
        return largeFile::suite();
    else
        return NULL;
}

#else // __WXMSW__

bool IsFAT(const wxString& WXUNUSED(path)) { return false; }
void MakeSparse(const wxString& WXUNUSED(path), int WXUNUSED(fd)) { }

CppUnit::Test* GetlargeFileSuite() { return NULL; }

#endif // __WXMSW__

CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(largeFile, "largeFile");
CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(largeFile, "Streams.largeFile");
Commit	Line	Data
48714f74 RN	1	///////////////////////////////////////////////////////////////////////////////
	2	// Name: tests/streams/largefile.cpp
	3	// Purpose: Tests for large file support
	4	// Author: Mike Wetherell
	5	// RCS-ID: $Id$
	6	// Copyright: (c) 2004 Mike Wetherell
	7	// Licence: wxWidgets licence
	8	///////////////////////////////////////////////////////////////////////////////
	9
	10	//
086d7f31	11	// We're interested in what happens around offsets 0x7fffffff and 0xffffffff
48714f74 RN	12	// so the test writes a small chunk of test data just before and just after
	13	// these offsets, then reads them back.
	14	//
	15	// The tests can be run with:
	16	//
	17	// test --verbose largeFile
	18	//
	19	// On systems supporting sparse files they may also be registered in the
	20	// Streams subsuite.
	21	//
	22
	23	// For compilers that support precompilation, includes "wx/wx.h".
	24	#include "testprec.h"
	25
	26	#ifdef __BORLANDC__
	27	#pragma hdrstop
	28	#endif
	29
	30	// for all others, include the necessary headers
	31	#ifndef WX_PRECOMP
	32	#include "wx/wx.h"
	33	#endif
	34
	35	#include "wx/filename.h"
	36	#include "wx/wfstream.h"
	37
	38	#ifdef __WXMSW__
8b686715 MW	39	#include "wx/msw/wrapwin.h"
8b686715 MW	40	#include <winioctl.h>
48714f74 RN	41	#endif
	42
	43	using std::auto_ptr;
	44
	45
	46	///////////////////////////////////////////////////////////////////////////////
	47	// Helpers
	48
	49	bool IsFAT(const wxString& path);
	50	void MakeSparse(const wxString& path, int fd);
	51
	52
	53	///////////////////////////////////////////////////////////////////////////////
	54	// Base class for the test cases - common code
	55
	56	class LargeFileTest : public CppUnit::TestCase
	57	{
	58	public:
	59	LargeFileTest(std::string name) : CppUnit::TestCase(name) { }
	60	virtual ~LargeFileTest() { }
	61
	62	protected:
	63	void runTest();
	64
	65	virtual wxInputStream *MakeInStream(const wxString& name) const = 0;
	66	virtual wxOutputStream *MakeOutStream(const wxString& name) const = 0;
	67	virtual bool HasLFS() const = 0;
	68	};
	69
	70	void LargeFileTest::runTest()
	71	{
	72	// self deleting temp file
	73	struct TmpFile {
	74	TmpFile() : m_name(wxFileName::CreateTempFileName(_T("wxlfs-"))) { }
	75	~TmpFile() { if (!m_name.empty()) wxRemoveFile(m_name); }
	76	wxString m_name;
	77	} tmpfile;
	78
	79	CPPUNIT_ASSERT(!tmpfile.m_name.empty());
	80
	81	bool haveLFS = true;
	82	bool fourGigLimit = false;
	83
	84	if (!HasLFS()) {
	85	haveLFS = false;
	86	wxString n(getName().c_str(), *wxConvCurrent);
	87	wxLogInfo(n + _T(": No large file support, testing up to 2GB only"));
	88	}
	89	else if (IsFAT(tmpfile.m_name)) {
	90	fourGigLimit = true;
	91	wxString n(getName().c_str(), *wxConvCurrent);
	92	wxLogInfo(n + _T(": FAT volumes are limited to 4GB files"));
	93	}
	94
	95	// size of the test blocks
	96	const size_t size = 0x40;
	97
	98	// the test blocks
	99	char upto2Gig[size];
	100	char past2Gig[size];
	101	char upto4Gig[size];
	102	char past4Gig[size];
	103	memset(upto2Gig, 'A', size);
	104	memset(past2Gig, 'B', size);
105	memset(upto4Gig, 'X', size);
106	memset(past4Gig, 'Y', size);
107
108	wxFileOffset pos;
109
110	// write a large file
111	{
112	auto_ptr<wxOutputStream> out(MakeOutStream(tmpfile.m_name));
113
114	// write 'A's at [ 0x7fffffbf, 0x7fffffff [
115	pos = 0x7fffffff - size;
116	CPPUNIT_ASSERT(out->SeekO(pos) == pos);
117	CPPUNIT_ASSERT(out->Write(upto2Gig, size).LastWrite() == size);
118	pos += size;
119
120	if (haveLFS) {
121	// write 'B's at [ 0x7fffffff, 0x8000003f [
122	CPPUNIT_ASSERT(out->Write(past2Gig, size).LastWrite() == size);
123	pos += size;
124	CPPUNIT_ASSERT(out->TellO() == pos);
125
126	// write 'X's at [ 0xffffffbf, 0xffffffff [
127	pos = 0xffffffff - size;
128	CPPUNIT_ASSERT(out->SeekO(pos) == pos);
129	CPPUNIT_ASSERT(out->Write(upto4Gig, size).LastWrite() == size);
130	pos += size;
131
132	if (!fourGigLimit) {
133	// write 'Y's at [ 0xffffffff, 0x10000003f [
134	CPPUNIT_ASSERT(out->Write(past4Gig, size).LastWrite() == size);
135	pos += size;
136	}
137	}
138
139	// check the file seems to be the right length
140	CPPUNIT_ASSERT(out->TellO() == pos);
141	CPPUNIT_ASSERT(out->GetLength() == pos);
142	}
143
144	// read the large file back
145	{
146	auto_ptr<wxInputStream> in(MakeInStream(tmpfile.m_name));
147	char buf[size];
148
149	if (haveLFS) {
150	CPPUNIT_ASSERT(in->GetLength() == pos);
151	pos = 0xffffffff;
152
153	if (!fourGigLimit) {
154	CPPUNIT_ASSERT(in->GetLength() > pos);
155
156	// read back the 'Y's at [ 0xffffffff, 0x10000003f [
157	CPPUNIT_ASSERT(in->SeekI(pos) == pos);
158	CPPUNIT_ASSERT(in->Read(buf, size).LastRead() == size);
159	CPPUNIT_ASSERT(memcmp(buf, past4Gig, size) == 0);
160
161	CPPUNIT_ASSERT(in->TellI() == in->GetLength());
162	}
163
164	// read back the 'X's at [ 0xffffffbf, 0xffffffff [
165	pos -= size;
166	CPPUNIT_ASSERT(in->SeekI(pos) == pos);
167	CPPUNIT_ASSERT(in->Read(buf, size).LastRead() == size);
168	CPPUNIT_ASSERT(memcmp(buf, upto4Gig, size) == 0);
169	pos += size;
170	CPPUNIT_ASSERT(in->TellI() == pos);
171
172	// read back the 'B's at [ 0x7fffffff, 0x8000003f [
173	pos = 0x7fffffff;
174	CPPUNIT_ASSERT(in->SeekI(pos) == pos);
175	CPPUNIT_ASSERT(in->Read(buf, size).LastRead() == size);
176	CPPUNIT_ASSERT(memcmp(buf, past2Gig, size) == 0);
177	}
178	else {
179	CPPUNIT_ASSERT(in->GetLength() == 0x7fffffff);
180	pos = 0x7fffffff;
181	}
182
183	// read back the 'A's at [ 0x7fffffbf, 0x7fffffff [
184	pos -= size;
185	CPPUNIT_ASSERT(in->SeekI(pos) == pos);
186	CPPUNIT_ASSERT(in->Read(buf, size).LastRead() == size);
187	CPPUNIT_ASSERT(memcmp(buf, upto2Gig, size) == 0);
188	pos += size;
189	CPPUNIT_ASSERT(in->TellI() == pos);
190	}
191	}
192
193
194	///////////////////////////////////////////////////////////////////////////////
195	// wxFile test case
196
197	class LargeFileTest_wxFile : public LargeFileTest
198	{
199	public:
200	LargeFileTest_wxFile() : LargeFileTest("wxFile streams") { }
201
202	protected:
203	wxInputStream *MakeInStream(const wxString& name) const;
204	wxOutputStream *MakeOutStream(const wxString& name) const;
205	bool HasLFS() const { return (wxFileOffset)0xffffffff > 0; }
206	};
207
208	wxInputStream *LargeFileTest_wxFile::MakeInStream(const wxString& name) const
209	{
210	auto_ptr<wxFileInputStream> in(new wxFileInputStream(name));
211	CPPUNIT_ASSERT(in->Ok());
212	return in.release();
213	}
214
215	wxOutputStream *LargeFileTest_wxFile::MakeOutStream(const wxString& name) const
216	{
217	wxFile file(name, wxFile::write);
218	CPPUNIT_ASSERT(file.IsOpened());
219	int fd = file.fd();
220	file.Detach();
221	MakeSparse(name, fd);
222	return new wxFileOutputStream(fd);
223	}
224
225
226	///////////////////////////////////////////////////////////////////////////////
227	// wxFFile test case
228
229	class LargeFileTest_wxFFile : public LargeFileTest
230	{
231	public:
232	LargeFileTest_wxFFile() : LargeFileTest("wxFFile streams") { }
233
234	protected:
235	wxInputStream *MakeInStream(const wxString& name) const;
236	wxOutputStream *MakeOutStream(const wxString& name) const;
237	bool HasLFS() const;
238	};
239
240	wxInputStream *LargeFileTest_wxFFile::MakeInStream(const wxString& name) const
241	{
242	auto_ptr<wxFFileInputStream> in(new wxFFileInputStream(name));
243	CPPUNIT_ASSERT(in->Ok());
244	return in.release();
245	}
246
247	wxOutputStream *LargeFileTest_wxFFile::MakeOutStream(const wxString& name) const
248	{
249	wxFFile file(name, _T("w"));
250	CPPUNIT_ASSERT(file.IsOpened());
251	FILE *fp = file.fp();
252	file.Detach();
253	MakeSparse(name, fileno(fp));
254	return new wxFFileOutputStream(fp);
255	}
256
257	bool LargeFileTest_wxFFile::HasLFS() const
258	{
0c094518	259	#ifdef HAVE_FSEEKO
48714f74 RN	260	return (wxFileOffset)0xffffffff > 0;
	261	#else
	262	return false;
	263	#endif
	264	}
	265
	266
	267	///////////////////////////////////////////////////////////////////////////////
	268	// The suite
	269
	270	class largeFile : public CppUnit::TestSuite
	271	{
	272	public:
	273	largeFile() : CppUnit::TestSuite("largeFile") { }
	274
	275	static CppUnit::Test *suite();
	276	};
	277
	278	CppUnit::Test *largeFile::suite()
	279	{
	280	largeFile *suite = new largeFile;
	281
	282	suite->addTest(new LargeFileTest_wxFile);
	283	suite->addTest(new LargeFileTest_wxFFile);
	284
	285	return suite;
	286	}
	287
	288
	289	///////////////////////////////////////////////////////////////////////////////
	290	// Implement the helpers
	291	//
	292	// Ideally these tests will be part of the default suite so that regressions
	293	// are picked up. However this is only possible when sparse files are
	294	// supported otherwise the tests require too much disk space.
	295	//
086d7f31 RN	296	// On unix, most filesystems support sparse files, though not all. So for now
	297	// I'm not assuming sparse file support on unix. On Windows it's possible to
	298	// test, and sparse files should be available on Win 5+ with NTFS.
48714f74 RN	299
	300	#ifdef __WXMSW__
	301
	302	#ifndef FILE_SUPPORTS_SPARSE_FILES
	303	#define FILE_SUPPORTS_SPARSE_FILES 0x00000040
	304	#endif
	305
	306	#ifndef FSCTL_SET_SPARSE
	307
	308	# ifndef FILE_SPECIAL_ACCESS
	309	# define FILE_SPECIAL_ACCESS FILE_ANY_ACCESS
	310	# endif
	311	# define FSCTL_SET_SPARSE CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 49, \
	312	METHOD_BUFFERED, FILE_SPECIAL_ACCESS)
	313	#endif
	314
	315	static DWORD volumeFlags;
	316	static wxChar volumeType[64];
	317	static bool volumeInfoInit;
	318
	319	void GetVolumeInfo(const wxString& path)
	320	{
	321	// extract the volume 'C:\' or '\\tooter\share\' from the path
	322	wxString vol;
	323
	324	if (path.substr(1, 2) == _T(":\\")) {
	325	vol = path.substr(0, 3);
	326	} else {
	327	if (path.substr(0, 2) == _T("\\\\")) {
	328	size_t i = path.find(_T('\\'), 2);
	329
	330	if (i != wxString::npos && i > 2) {
	331	size_t j = path.find(_T('\\'), ++i);
	332
	333	if (j != i)
	334	vol = path.substr(0, j) + _T("\\");
	335	}
	336	}
	337	}
	338
	339	// NULL means the current volume
48eba629 VZ	340	const wxChar pVol = vol.empty() ? (wxChar )NULL
48eba629 VZ	341	: vol.c_str();
48714f74 RN	342
	343	if (!::GetVolumeInformation(pVol, NULL, 0, NULL, NULL,
	344	&volumeFlags,
	345	volumeType,
	346	WXSIZEOF(volumeType)))
	347	wxLogSysError(_T("GetVolumeInformation() failed"));
	348
	349	volumeInfoInit = true;
	350	}
	351
	352	bool IsFAT(const wxString& path)
	353	{
	354	if (!volumeInfoInit)
	355	GetVolumeInfo(path);
	356	return wxString(volumeType).Upper().find(_T("FAT")) != wxString::npos;
	357	}
	358
	359	void MakeSparse(const wxString& path, int fd)
	360	{
	361	DWORD cb;
	362
	363	if (!volumeInfoInit)
	364	GetVolumeInfo(path);
	365
	366	if ((volumeFlags & FILE_SUPPORTS_SPARSE_FILES) != 0)
	367	if (!::DeviceIoControl((HANDLE)_get_osfhandle(fd),
	368	FSCTL_SET_SPARSE,
	369	NULL, 0, NULL, 0, &cb, NULL))
086d7f31	370	volumeFlags &= ~FILE_SUPPORTS_SPARSE_FILES;
48714f74 RN	371	}
	372
	373	CppUnit::Test* GetlargeFileSuite()
	374	{
	375	if (!volumeInfoInit) {
	376	wxFile file;
	377	wxString path = wxFileName::CreateTempFileName(_T("wxlfs-"), &file);
	378	MakeSparse(path, file.fd());
	379	wxRemoveFile(path);
	380	}
	381
	382	if ((volumeFlags & FILE_SUPPORTS_SPARSE_FILES) != 0)
	383	return largeFile::suite();
	384	else
	385	return NULL;
	386	}
	387
	388	#else // __WXMSW__
	389
	390	bool IsFAT(const wxString& WXUNUSED(path)) { return false; }
	391	void MakeSparse(const wxString& WXUNUSED(path), int WXUNUSED(fd)) { }
	392
48714f74	393	CppUnit::Test* GetlargeFileSuite() { return NULL; }
48714f74 RN	394
	395	#endif // __WXMSW__
	396
	397	CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(largeFile, "largeFile");
	398	CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(largeFile, "Streams.largeFile");