tests/archive/archivetest.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        tests/archive/archive.cpp
   3 // Purpose:     Test the archive classes
   4 // Author:      Mike Wetherell
   5 // RCS-ID:      $Id$
   6 // Copyright:   (c) 2004 Mike Wetherell
   7 // Licence:     wxWindows licence
   8 ///////////////////////////////////////////////////////////////////////////////
   9
  10 #include "testprec.h"
  11
  12 #ifdef __BORLANDC__
  13 #   pragma hdrstop
  14 #endif
  15
  16 #ifndef WX_PRECOMP
  17 #   include "wx/wx.h"
  18 #endif
  19
  20 #if wxUSE_STREAMS
  21
  22 #define WX_TEST_ARCHIVE_ITERATOR
  23
  24 // This sample uses some advanced typedef syntax that messes
  25 // up MSVC 6 - turn off its warning about it
  26 #if defined _MSC_VER
  27 #pragma warning (disable:4284)
  28 #endif
  29
  30 #include "wx/zipstrm.h"
  31 #include "wx/mstream.h"
  32 #include "wx/wfstream.h"
  33 #include "wx/dir.h"
  34 #include <string>
  35 #include <list>
  36 #include <map>
  37 #include <sys/stat.h>
  38
  39 using std::string;
  40 using std::auto_ptr;
  41
  42
  43 // Check whether member templates can be used
  44 //
  45 #if defined __GNUC__ && \
  46     (__GNUC__ >= 3 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95))
  47 #   define WXARC_MEMBER_TEMPLATES
  48 #endif
  49 #if defined _MSC_VER && _MSC_VER >= 1310
  50 #   define WXARC_MEMBER_TEMPLATES
  51 #endif
  52 #if defined __BORLANDC__ && __BORLANDC__ >= 0x530
  53 #   define WXARC_MEMBER_TEMPLATES
  54 #endif
  55 #if defined __DMC__ && __DMC__ >= 0x832
  56 #   define WXARC_MEMBER_TEMPLATES
  57 #endif
  58 #if defined __MWERKS__ && __MWERKS__ >= 0x2200
  59 #   define WXARC_MEMBER_TEMPLATES
  60 #endif
  61 #if defined __HP_aCC && __HP_aCC > 33300
  62 #   define WXARC_MEMBER_TEMPLATES
  63 #endif
  64 #if defined __SUNPRO_CC && __SUNPRO_CC > 0x500
  65 #   define WXARC_MEMBER_TEMPLATES
  66 #endif
  67
  68
  69 ///////////////////////////////////////////////////////////////////////////////
  70 // Bit flags for options for the tests
  71
  72 enum Options
  73 {
  74     PipeIn      = 0x01,     // input streams are non-seekable
  75     PipeOut     = 0x02,     // output streams are non-seekable
  76     Stub        = 0x04,     // the archive should be appended to a stub
  77     AllOptions  = 0x07
  78 };
  79
  80
  81 ///////////////////////////////////////////////////////////////////////////////
  82 // These structs are passed as the template parameter of the test case to
  83 // specify a set of classes to use in the test. This allows either the generic
  84 // wxArchiveXXX interface to be exercised or the specific interface for a
  85 // particular archive format e.g. wxZipXXX.
  86
  87 struct ArchiveClasses
  88 {
  89     typedef wxArchiveEntry EntryT;
  90     typedef wxArchiveInputStream InputStreamT;
  91     typedef wxArchiveOutputStream OutputStreamT;
  92     typedef wxArchiveClassFactory ClassFactoryT;
  93     typedef wxArchiveNotifier NotifierT;
  94     typedef wxArchiveIter IterT;
  95     typedef wxArchivePairIter PairIterT;
  96 };
  97
  98 struct ZipClasses
  99 {
 100     typedef wxZipEntry EntryT;
 101     typedef wxZipInputStream InputStreamT;
 102     typedef wxZipOutputStream OutputStreamT;
 103     typedef wxZipClassFactory ClassFactoryT;
 104     typedef wxZipNotifier NotifierT;
 105     typedef wxZipIter IterT;
 106     typedef wxZipPairIter PairIterT;
 107 };
 108
 109
 110 ///////////////////////////////////////////////////////////////////////////////
 111 // A class to hold a test entry
 112
 113 class TestEntry
 114 {
 115 public:
 116     TestEntry(const wxDateTime& dt, int len, const char *data);
 117     ~TestEntry() { delete [] (char*) m_data; }
 118
 119     wxDateTime GetDateTime() const  { return m_dt; }
 120     wxFileOffset GetLength() const  { return m_len; }
 121     size_t GetSize() const          { return m_len; }
 122     const char *GetData() const     { return m_data; }
 123     wxString GetComment() const     { return m_comment; }
 124     bool IsText() const             { return m_isText; }
 125
 126     void SetComment(const wxString& comment) { m_comment = comment; }
 127     void SetDateTime(const wxDateTime& dt)   { m_dt = dt; }
 128
 129 private:
 130     wxDateTime m_dt;
 131     size_t m_len;
 132     const char *m_data;
 133     wxString m_comment;
 134     bool m_isText;
 135 };
 136
 137 TestEntry::TestEntry(const wxDateTime& dt, int len, const char *data)
 138   : m_dt(dt),
 139     m_len(len),
 140     m_isText(len > 0)
 141 {
 142     char *d = new char[len];
 143     memcpy(d, data, len);
 144     m_data = d;
 145
 146     for (int i = 0; i < len && m_isText; i++)
 147         m_isText = (signed char)m_data[i] > 0;
 148 }
 149
 150
 151 ///////////////////////////////////////////////////////////////////////////////
 152 // TestOutputStream and TestInputStream are memory streams which can be
 153 // seekable or non-seekable.
 154
 155 class TestOutputStream : public wxOutputStream
 156 {
 157 public:
 158     TestOutputStream(int options);
 159
 160     ~TestOutputStream() { delete [] m_data; }
 161
 162     int GetOptions() const { return m_options; }
 163     wxFileOffset GetLength() const { return m_size; }
 164
 165     // gives away the data, this stream is then empty, and can be reused
 166     void GetData(const char*& data, size_t& size);
 167
 168     enum { STUB_SIZE = 2048, INITIAL_SIZE = 0x18000, SEEK_LIMIT = 0x100000 };
 169
 170 private:
 171     void Init();
 172
 173     wxFileOffset OnSysSeek(wxFileOffset pos, wxSeekMode mode);
 174     wxFileOffset OnSysTell() const;
 175     size_t OnSysWrite(const void *buffer, size_t size);
 176
 177     int m_options;
 178     size_t m_pos;
 179     size_t m_capacity;
 180     size_t m_size;
 181     char *m_data;
 182 };
 183
 184 TestOutputStream::TestOutputStream(int options)
 185   : m_options(options)
 186 {
 187     Init();
 188 }
 189
 190 void TestOutputStream::Init()
 191 {
 192     m_data = NULL;
 193     m_size = 0;
 194     m_capacity = 0;
 195     m_pos = 0;
 196
 197     if (m_options & Stub) {
 198         wxCharBuffer buf(STUB_SIZE);
 199         memset(buf.data(), 0, STUB_SIZE);
 200         Write(buf, STUB_SIZE);
 201     }
 202 }
 203
 204 wxFileOffset TestOutputStream::OnSysSeek(wxFileOffset pos, wxSeekMode mode)
 205 {
 206     if ((m_options & PipeOut) == 0) {
 207         switch (mode) {
 208             case wxFromStart:   break;
 209             case wxFromCurrent: pos += m_pos; break;
 210             case wxFromEnd:     pos += m_size; break;
 211         }
 212         if (pos < 0 || pos > SEEK_LIMIT)
 213             return wxInvalidOffset;
 214         m_pos = (size_t)pos;
 215         return m_pos;
 216     }
 217     return wxInvalidOffset;
 218 }
 219
 220 wxFileOffset TestOutputStream::OnSysTell() const
 221 {
 222     return (m_options & PipeOut) == 0 ? (wxFileOffset)m_pos : wxInvalidOffset;
 223 }
 224
 225 size_t TestOutputStream::OnSysWrite(const void *buffer, size_t size)
 226 {
 227     if (!IsOk() || !size)
 228         return 0;
 229     m_lasterror = wxSTREAM_WRITE_ERROR;
 230
 231     size_t newsize = m_pos + size;
 232     wxCHECK(newsize > m_pos, 0);
 233
 234     if (m_capacity < newsize) {
 235         size_t capacity = m_capacity ? m_capacity : INITIAL_SIZE;
 236
 237         while (capacity < newsize) {
 238             capacity <<= 1;
 239             wxCHECK(capacity > m_capacity, 0);
 240         }
 241
 242         char *buf = new char[capacity];
 243         if (m_data)
 244             memcpy(buf, m_data, m_capacity);
 245         delete [] m_data;
 246         m_data = buf;
 247         m_capacity = capacity;
 248     }
 249
 250     memcpy(m_data + m_pos, buffer, size);
 251     m_pos += size;
 252     if (m_pos > m_size)
 253         m_size = m_pos;
 254     m_lasterror = wxSTREAM_NO_ERROR;
 255
 256     return size;
 257 }
 258
 259 void TestOutputStream::GetData(const char*& data, size_t& size)
 260 {
 261     data = m_data;
 262     size = m_size;
 263
 264     if (m_options & Stub) {
 265         char *d = m_data;
 266         size += STUB_SIZE;
 267
 268         if (size > m_capacity) {
 269             d = new char[size];
 270             memcpy(d + STUB_SIZE, m_data, m_size);
 271             delete [] m_data;
 272         }
 273         else {
 274             memmove(d + STUB_SIZE, d, m_size);
 275         }
 276
 277         memset(d, 0, STUB_SIZE);
 278         data = d;
 279     }
 280
 281     Init();
 282     Reset();
 283 }
 284
 285 class TestInputStream : public wxInputStream
 286 {
 287 public:
 288     // ctor takes the data from the output stream, which is then empty
 289     TestInputStream(TestOutputStream& out) : m_data(NULL) { SetData(out); }
 290     // this ctor 'dups'
 291     TestInputStream(const TestInputStream& in);
 292     ~TestInputStream() { delete [] (char*) m_data; }
 293
 294     void Rewind();
 295     wxFileOffset GetLength() const { return m_size; }
 296     void SetData(TestOutputStream& out);
 297
 298 private:
 299     wxFileOffset OnSysSeek(wxFileOffset pos, wxSeekMode mode);
 300     wxFileOffset OnSysTell() const;
 301     size_t OnSysRead(void *buffer, size_t size);
 302
 303     int m_options;
 304     size_t m_pos;
 305     size_t m_size;
 306     const char *m_data;
 307 };
 308
 309 TestInputStream::TestInputStream(const TestInputStream& in)
 310   : m_options(in.m_options),
 311     m_pos(in.m_pos),
 312     m_size(in.m_size)
 313 {
 314     char *p = new char[m_size];
 315     memcpy(p, in.m_data, m_size);
 316     m_data = p;
 317 }
 318
 319 void TestInputStream::Rewind()
 320 {
 321     if ((m_options & Stub) && (m_options & PipeIn))
 322         m_pos = TestOutputStream::STUB_SIZE * 2;
 323     else
 324         m_pos = 0;
 325
 326     if (m_wbacksize) {
 327         free(m_wback);
 328         m_wback = NULL;
 329         m_wbacksize = 0;
 330         m_wbackcur = 0;
 331     }
 332 }
 333
 334 void TestInputStream::SetData(TestOutputStream& out)
 335 {
 336     delete [] (char*) m_data;
 337     m_options = out.GetOptions();
 338     out.GetData(m_data, m_size);
 339     Rewind();
 340     Reset();
 341 }
 342
 343 wxFileOffset TestInputStream::OnSysSeek(wxFileOffset pos, wxSeekMode mode)
 344 {
 345     if ((m_options & PipeIn) == 0) {
 346         switch (mode) {
 347             case wxFromStart:   break;
 348             case wxFromCurrent: pos += m_pos; break;
 349             case wxFromEnd:     pos += m_size; break;
 350         }
 351         if (pos < 0 || pos > TestOutputStream::SEEK_LIMIT)
 352             return wxInvalidOffset;
 353         m_pos = (size_t)pos;
 354         return m_pos;
 355     }
 356     return wxInvalidOffset;
 357 }
 358
 359 wxFileOffset TestInputStream::OnSysTell() const
 360 {
 361     return (m_options & PipeIn) == 0 ? (wxFileOffset)m_pos : wxInvalidOffset;
 362 }
 363
 364 size_t TestInputStream::OnSysRead(void *buffer, size_t size)
 365 {
 366     if (!IsOk() || !size)
 367         return 0;
 368     if (m_size <= m_pos) {
 369         m_lasterror = wxSTREAM_EOF;
 370         return 0;
 371     }
 372
 373     if (m_size - m_pos < size)
 374         size = m_size - m_pos;
 375     memcpy(buffer, m_data + m_pos, size);
 376     m_pos += size;
 377     return size;
 378 }
 379
 380
 381 ///////////////////////////////////////////////////////////////////////////////
 382 // minimal non-intrusive reference counting pointer for testing the iterators
 383
 384 template <class T> class Ptr
 385 {
 386 public:
 387     explicit Ptr(T* p = NULL) : m_p(p), m_count(new int) { *m_count = 1; }
 388     Ptr(const Ptr& sp) : m_p(sp.m_p), m_count(sp.m_count) { ++*m_count; }
 389     ~Ptr() { Free(); }
 390
 391     Ptr& operator =(const Ptr& sp) {
 392         if (&sp != this) {
 393             Free();
 394             m_p = sp.m_p;
 395             m_count = sp.m_count;
 396             ++*m_count;
 397         }
 398         return *this;
 399     }
 400
 401     T* get() const { return m_p; }
 402     T* operator->() const { return m_p; }
 403     T& operator*() const { return *m_p; }
 404
 405 private:
 406     void Free() {
 407         if (--*m_count == 0) {
 408             delete m_p;
 409             delete m_count;
 410         }
 411     }
 412
 413     T *m_p;
 414     int *m_count;
 415 };
 416
 417
 418 ///////////////////////////////////////////////////////////////////////////////
 419 // Clean-up for temp directory
 420
 421 class TempDir
 422 {
 423 public:
 424     TempDir();
 425     ~TempDir();
 426     wxString GetName() const { return m_tmp; }
 427
 428 private:
 429     void RemoveDir(wxString& path);
 430     wxString m_tmp;
 431     wxString m_original;
 432 };
 433
 434 TempDir::TempDir()
 435 {
 436     wxString tmp = wxFileName::CreateTempFileName(_T("arctest-"));
 437     if (tmp != wxEmptyString) {
 438         wxRemoveFile(tmp);
 439         m_original = wxGetCwd();
 440         CPPUNIT_ASSERT(wxMkdir(tmp, 0700));
 441         m_tmp = tmp;
 442         CPPUNIT_ASSERT(wxSetWorkingDirectory(tmp));
 443     }
 444 }
 445
 446 TempDir::~TempDir()
 447 {
 448     if (m_tmp != wxEmptyString) {
 449         wxSetWorkingDirectory(m_original);
 450         RemoveDir(m_tmp);
 451     }
 452 }
 453
 454 void TempDir::RemoveDir(wxString& path)
 455 {
 456     wxCHECK_RET(!m_tmp.empty() && path.substr(0, m_tmp.length()) == m_tmp,
 457                 _T("remove '") + path + _T("' fails safety check"));
 458
 459     const wxChar *files[] = {
 460         _T("text/empty"),
 461         _T("text/small"),
 462         _T("bin/bin1000"),
 463         _T("bin/bin4095"),
 464         _T("bin/bin4096"),
 465         _T("bin/bin4097"),
 466         _T("bin/bin16384"),
 467         _T("zero/zero5"),
 468         _T("zero/zero1024"),
 469         _T("zero/zero32768"),
 470         _T("zero/zero16385"),
 471         _T("zero/newname"),
 472         _T("newfile"),
 473     };
 474
 475     const wxChar *dirs[] = {
 476         _T("text/"), _T("bin/"), _T("zero/"), _T("empty/")
 477     };
 478
 479     wxString tmp = m_tmp + wxFileName::GetPathSeparator();
 480     size_t i;
 481
 482     for (i = 0; i < WXSIZEOF(files); i++)
 483         wxRemoveFile(tmp + wxFileName(files[i], wxPATH_UNIX).GetFullPath());
 484
 485     for (i = 0; i < WXSIZEOF(dirs); i++)
 486         wxRmdir(tmp + wxFileName(dirs[i], wxPATH_UNIX).GetFullPath());
 487
 488     if (!wxRmdir(m_tmp))
 489         wxLogSysError(_T("can't remove temporary dir '%s'"), m_tmp.c_str());
 490 }
 491
 492
 493 ///////////////////////////////////////////////////////////////////////////////
 494 // wxFFile streams for piping to/from an external program
 495
 496 #if defined __UNIX__ || defined __MINGW32__
 497 #   define WXARC_popen popen
 498 #   define WXARC_pclose pclose
 499 #elif defined _MSC_VER || defined __BORLANDC__
 500 #   define WXARC_popen _popen
 501 #   define WXARC_pclose _pclose
 502 #else
 503 #   define WXARC_NO_POPEN
 504 #   define WXARC_popen(cmd, type) NULL
 505 #   define WXARC_pclose(fp)
 506 #endif
 507
 508 #ifdef __WXMSW__
 509 #   define WXARC_b "b"
 510 #else
 511 #   define WXARC_b
 512 #endif
 513
 514 class PFileInputStream : public wxFFileInputStream
 515 {
 516 public:
 517     PFileInputStream(const wxString& cmd) :
 518         wxFFileInputStream(WXARC_popen(cmd.mb_str(), "r" WXARC_b)) { }
 519     ~PFileInputStream()
 520         { WXARC_pclose(m_file->fp()); m_file->Detach(); }
 521 };
 522
 523 class PFileOutputStream : public wxFFileOutputStream
 524 {
 525 public:
 526     PFileOutputStream(const wxString& cmd) :
 527         wxFFileOutputStream(WXARC_popen(cmd.mb_str(), "w" WXARC_b)) { }
 528     ~PFileOutputStream()
 529         { WXARC_pclose(m_file->fp()); m_file->Detach(); }
 530 };
 531
 532
 533 ///////////////////////////////////////////////////////////////////////////////
 534 // The test case
 535
 536 template <class Classes>
 537 class ArchiveTestCase : public CppUnit::TestCase
 538 {
 539 public:
 540     ArchiveTestCase(string name,
 541                     int id,
 542                     wxArchiveClassFactory *factory,
 543                     int options,
 544                     const wxString& archiver = wxEmptyString,
 545                     const wxString& unarchiver = wxEmptyString);
 546
 547     ~ArchiveTestCase();
 548
 549 protected:
 550     // the classes to test
 551     typedef typename Classes::EntryT EntryT;
 552     typedef typename Classes::InputStreamT InputStreamT;
 553     typedef typename Classes::OutputStreamT OutputStreamT;
 554     typedef typename Classes::ClassFactoryT ClassFactoryT;
 555     typedef typename Classes::NotifierT NotifierT;
 556     typedef typename Classes::IterT IterT;
 557     typedef typename Classes::PairIterT PairIterT;
 558
 559     // the entry point for the test
 560     void runTest();
 561
 562     // create the test data
 563     void CreateTestData();
 564     TestEntry& Add(const char *name, const char *data, int len = -1);
 565     TestEntry& Add(const char *name, int len = 0, int value = EOF);
 566
 567     // 'archive up' the test data
 568     void CreateArchive(wxOutputStream& out);
 569     void CreateArchive(wxOutputStream& out, const wxString& archiver);
 570
 571     // perform various modifications on the archive
 572     void ModifyArchive(wxInputStream& in, wxOutputStream& out);
 573
 574     // extract the archive and verify its contents
 575     void ExtractArchive(wxInputStream& in);
 576     void ExtractArchive(wxInputStream& in, const wxString& unarchiver);
 577     void VerifyDir(wxString& path, size_t rootlen = 0);
 578
 579     // tests for the iterators
 580     void TestIterator(wxInputStream& in);
 581     void TestPairIterator(wxInputStream& in);
 582     void TestSmartIterator(wxInputStream& in);
 583     void TestSmartPairIterator(wxInputStream& in);
 584
 585     // try reading two entries at the same time
 586     void ReadSimultaneous(TestInputStream& in);
 587
 588     // overridables
 589     virtual void OnCreateArchive(OutputStreamT& WXUNUSED(arc)) { }
 590     virtual void OnSetNotifier(EntryT& entry);
 591
 592     virtual void OnArchiveExtracted(InputStreamT& WXUNUSED(arc),
 593                                     int WXUNUSED(expectedTotal)) { }
 594
 595     virtual void OnCreateEntry(     OutputStreamT& WXUNUSED(arc),
 596                                     TestEntry& WXUNUSED(testEntry),
 597                                     EntryT *entry = NULL) { (void)entry; }
 598
 599     virtual void OnEntryExtracted(  EntryT& WXUNUSED(entry),
 600                                     const TestEntry& WXUNUSED(testEntry),
 601                                     InputStreamT *arc = NULL) { (void)arc; }
 602
 603     typedef std::map<wxString, TestEntry*> TestEntries;
 604     TestEntries m_testEntries;              // test data
 605     auto_ptr<ClassFactoryT> m_factory;      // factory to make classes
 606     int m_options;                          // test options
 607     wxDateTime m_timeStamp;                 // timestamp to give test entries
 608     int m_id;                               // select between the possibilites
 609     wxString m_archiver;                    // external archiver
 610     wxString m_unarchiver;                  // external unarchiver
 611 };
 612
 613 // Constructor
 614 // The only way I could get this to compile on VC++ 5.0 was to pass 'factory'
 615 // as a wxArchiveFactory* then cast it, even then only with some ifdefing.
 616 //
 617 template <class Classes>
 618 ArchiveTestCase<Classes>::ArchiveTestCase(
 619     string name,
 620     int id,
 621     wxArchiveClassFactory *factory,
 622     int options,
 623     const wxString& archiver,
 624     const wxString& unarchiver)
 625   :
 626     CppUnit::TestCase(name),
 627 #if defined _MSC_VER && _MSC_VER < 1300
 628     m_factory(dynamic_cast<Classes::ClassFactoryT*>(factory)),
 629 #else
 630     m_factory(dynamic_cast<typename Classes::ClassFactoryT*>(factory)),
 631 #endif
 632     m_options(options),
 633     m_timeStamp(1, wxDateTime::Mar, 2005, 12, 0),
 634     m_id(id),
 635     m_archiver(archiver),
 636     m_unarchiver(unarchiver)
 637 {
 638     wxASSERT(m_factory.get() != NULL);
 639 }
 640
 641 template <class Classes>
 642 ArchiveTestCase<Classes>::~ArchiveTestCase()
 643 {
 644     TestEntries::iterator it;
 645     for (it = m_testEntries.begin(); it != m_testEntries.end(); ++it)
 646         delete it->second;
 647 }
 648
 649 template <class Classes>
 650 void ArchiveTestCase<Classes>::runTest()
 651 {
 652     TestOutputStream out(m_options);
 653
 654     CreateTestData();
 655
 656     if (m_archiver.empty())
 657         CreateArchive(out);
 658     else
 659         CreateArchive(out, m_archiver);
 660
 661     // check archive could be created
 662     CPPUNIT_ASSERT(out.GetLength() > 0);
 663
 664     TestInputStream in(out);
 665
 666     TestIterator(in);
 667     in.Rewind();
 668     TestPairIterator(in);
 669     in.Rewind();
 670     TestSmartIterator(in);
 671     in.Rewind();
 672     TestSmartPairIterator(in);
 673     in.Rewind();
 674
 675     if ((m_options & PipeIn) == 0) {
 676         ReadSimultaneous(in);
 677         in.Rewind();
 678     }
 679
 680     ModifyArchive(in, out);
 681     in.SetData(out);
 682
 683     if (m_unarchiver.empty())
 684         ExtractArchive(in);
 685     else
 686         ExtractArchive(in, m_unarchiver);
 687
 688     // check that all the test entries were found in the archive
 689     CPPUNIT_ASSERT(m_testEntries.empty());
 690 }
 691
 692 template <class Classes>
 693 void ArchiveTestCase<Classes>::CreateTestData()
 694 {
 695     Add("text/");
 696     Add("text/empty", "");
 697     Add("text/small", "Small text file for testing\n"
 698                       "archive streams in wxWidgets\n");
 699
 700     Add("bin/");
 701     Add("bin/bin1000", 1000);
 702     Add("bin/bin4095", 4095);
 703     Add("bin/bin4096", 4096);
 704     Add("bin/bin4097", 4097);
 705     Add("bin/bin16384", 16384);
 706
 707     Add("zero/");
 708     Add("zero/zero5", 5, 0);
 709     Add("zero/zero1024", 1024, 109);
 710     Add("zero/zero32768", 32768, 106);
 711     Add("zero/zero16385", 16385, 119);
 712
 713     Add("empty/");
 714 }
 715
 716 template <class Classes>
 717 TestEntry& ArchiveTestCase<Classes>::Add(const char *name,
 718                                          const char *data,
 719                                          int len /*=-1*/)
 720 {
 721     if (len == -1)
 722         len = strlen(data);
 723     TestEntry*& entry = m_testEntries[wxString(name, *wxConvCurrent)];
 724     wxASSERT(entry == NULL);
 725     entry = new TestEntry(m_timeStamp, len, data);
 726     m_timeStamp += wxTimeSpan(0, 1, 30);
 727     return *entry;
 728 }
 729
 730 template <class Classes>
 731 TestEntry& ArchiveTestCase<Classes>::Add(const char *name,
 732                                          int len /*=0*/,
 733                                          int value /*=EOF*/)
 734 {
 735     wxCharBuffer buf(len);
 736     for (int i = 0; i < len; i++)
 737         buf.data()[i] = value == EOF ? rand() : value;
 738     return Add(name, buf, len);
 739 }
 740
 741 // Create an archive using the wx archive classes, write it to 'out'
 742 //
 743 template <class Classes>
 744 void ArchiveTestCase<Classes>::CreateArchive(wxOutputStream& out)
 745 {
 746     auto_ptr<OutputStreamT> arc(m_factory->NewStream(out));
 747     TestEntries::iterator it;
 748
 749     OnCreateArchive(*arc);
 750
 751     // We want to try creating entries in various different ways, 'choices'
 752     // is just a number used to select between all the various possibilities.
 753     int choices = m_id;
 754
 755     for (it = m_testEntries.begin(); it != m_testEntries.end(); ++it) {
 756         choices += 5;
 757         TestEntry& testEntry = *it->second;
 758         wxString name = it->first;
 759
 760         // It should be possible to create a directory entry just by supplying
 761         // a name that looks like a directory, or alternatively any old name
 762         // can be identified as a directory using SetIsDir or PutNextDirEntry
 763         bool setIsDir = name.Last() == _T('/') && (choices & 1);
 764         if (setIsDir)
 765             name.erase(name.length() - 1);
 766
 767         // provide some context for the error message so that we know which
 768         // iteration of the loop we were on
 769         string error_entry((_T(" '") + name + _T("'")).mb_str());
 770         string error_context(" failed for entry" + error_entry);
 771
 772         if ((choices & 2) || testEntry.IsText()) {
 773             // try PutNextEntry(EntryT *pEntry)
 774             auto_ptr<EntryT> entry(m_factory->NewEntry());
 775             entry->SetName(name, wxPATH_UNIX);
 776             if (setIsDir)
 777                 entry->SetIsDir();
 778             entry->SetDateTime(testEntry.GetDateTime());
 779             entry->SetSize(testEntry.GetLength());
 780             OnCreateEntry(*arc, testEntry, entry.get());
 781             CPPUNIT_ASSERT_MESSAGE("PutNextEntry" + error_context,
 782                                    arc->PutNextEntry(entry.release()));
 783         }
 784         else {
 785             // try the convenience methods
 786             OnCreateEntry(*arc, testEntry);
 787             if (setIsDir)
 788                 CPPUNIT_ASSERT_MESSAGE("PutNextDirEntry" + error_context,
 789                     arc->PutNextDirEntry(name, testEntry.GetDateTime()));
 790             else
 791                 CPPUNIT_ASSERT_MESSAGE("PutNextEntry" + error_context,
 792                     arc->PutNextEntry(name, testEntry.GetDateTime(),
 793                                       testEntry.GetLength()));
 794         }
 795
 796         if (name.Last() != _T('/')) {
 797             // for non-dirs write the data
 798             arc->Write(testEntry.GetData(), testEntry.GetSize());
 799             CPPUNIT_ASSERT_MESSAGE("LastWrite check" + error_context,
 800                 arc->LastWrite() == testEntry.GetSize());
 801             // should work with or without explicit CloseEntry
 802             if (choices & 3)
 803                 CPPUNIT_ASSERT_MESSAGE("CloseEntry" + error_context,
 804                     arc->CloseEntry());
 805         }
 806
 807         CPPUNIT_ASSERT_MESSAGE("IsOk" + error_context, arc->IsOk());
 808     }
 809
 810     // should work with or without explicit Close
 811     if (m_id % 2)
 812         CPPUNIT_ASSERT(arc->Close());
 813 }
 814
 815 // Create an archive using an external archive program
 816 //
 817 template <class Classes>
 818 void ArchiveTestCase<Classes>::CreateArchive(wxOutputStream& out,
 819                                              const wxString& archiver)
 820 {
 821     // for an external archiver the test data need to be written to
 822     // temp files
 823     TempDir tmpdir;
 824
 825     // write the files
 826     TestEntries::iterator i;
 827     for (i = m_testEntries.begin(); i != m_testEntries.end(); ++i) {
 828         wxFileName fn(i->first, wxPATH_UNIX);
 829         TestEntry& entry = *i->second;
 830
 831         if (fn.IsDir()) {
 832             fn.Mkdir(0777, wxPATH_MKDIR_FULL);
 833         } else {
 834             wxFileName::Mkdir(fn.GetPath(), 0777, wxPATH_MKDIR_FULL);
 835             wxFFileOutputStream fileout(fn.GetFullPath());
 836             fileout.Write(entry.GetData(), entry.GetSize());
 837         }
 838     }
 839
 840     for (i = m_testEntries.begin(); i != m_testEntries.end(); ++i) {
 841         wxFileName fn(i->first, wxPATH_UNIX);
 842         TestEntry& entry = *i->second;
 843         wxDateTime dt = entry.GetDateTime();
 844 #ifdef __WXMSW__
 845         if (fn.IsDir())
 846             entry.SetDateTime(wxDateTime());
 847         else
 848 #endif
 849             fn.SetTimes(NULL, &dt, NULL);
 850     }
 851
 852     if ((m_options & PipeOut) == 0) {
 853         wxFileName fn(tmpdir.GetName());
 854         fn.SetExt(_T("arc"));
 855         wxString tmparc = fn.GetFullPath();
 856
 857         // call the archiver to create an archive file
 858         system(wxString::Format(archiver, tmparc.c_str()).mb_str());
 859
 860         // then load the archive file
 861         {
 862             wxFFileInputStream in(tmparc);
 863             if (in.Ok())
 864                 out.Write(in);
 865         }
 866
 867         wxRemoveFile(tmparc);
 868     }
 869     else {
 870         // for the non-seekable test, have the archiver output to "-"
 871         // and read the archive via a pipe
 872         PFileInputStream in(wxString::Format(archiver, _T("-")));
 873         if (in.Ok())
 874             out.Write(in);
 875     }
 876 }
 877
 878 // Do a standard set of modification on an archive, delete an entry,
 879 // rename an entry and add an entry
 880 //
 881 template <class Classes>
 882 void ArchiveTestCase<Classes>::ModifyArchive(wxInputStream& in,
 883                                              wxOutputStream& out)
 884 {
 885     auto_ptr<InputStreamT> arcIn(m_factory->NewStream(in));
 886     auto_ptr<OutputStreamT> arcOut(m_factory->NewStream(out));
 887     ;
 888
 889     const wxString deleteName = _T("bin/bin1000");
 890     const wxString renameFrom = _T("zero/zero1024");
 891     const wxString renameTo   = _T("zero/newname");
 892     const wxString newName    = _T("newfile");
 893     const char *newData       = "New file added as a test\n";
 894
 895     arcOut->CopyArchiveMetaData(*arcIn);
 896
 897     auto_ptr<EntryT>* pEntry;
 898
 899     for (pEntry = new auto_ptr<EntryT>(arcIn->GetNextEntry()) ;
 900          pEntry->get() != NULL ;
 901          delete pEntry, pEntry = new auto_ptr<EntryT>(arcIn->GetNextEntry()))
 902     {
 903         OnSetNotifier(**pEntry);
 904         wxString name = (*pEntry)->GetName(wxPATH_UNIX);
 905
 906         // provide some context for the error message so that we know which
 907         // iteration of the loop we were on
 908         string error_entry((_T(" '") + name + _T("'")).mb_str());
 909         string error_context(" failed for entry" + error_entry);
 910
 911         if (name == deleteName) {
 912             TestEntries::iterator it = m_testEntries.find(name);
 913             CPPUNIT_ASSERT_MESSAGE(
 914                 "deletion failed (already deleted?) for" + error_entry,
 915                 it != m_testEntries.end());
 916             TestEntry *p = it->second;
 917             m_testEntries.erase(it);
 918             delete p;
 919         }
 920         else {
 921             if (name == renameFrom) {
 922                 (*pEntry)->SetName(renameTo);
 923                 TestEntries::iterator it = m_testEntries.find(renameFrom);
 924                 CPPUNIT_ASSERT_MESSAGE(
 925                     "rename failed (already renamed?) for" + error_entry,
 926                     it != m_testEntries.end());
 927                 TestEntry *p = it->second;
 928                 m_testEntries.erase(it);
 929                 m_testEntries[renameTo] = p;
 930             }
 931
 932             CPPUNIT_ASSERT_MESSAGE("CopyEntry" + error_context,
 933                 arcOut->CopyEntry(pEntry->release(), *arcIn));
 934         }
 935     }
 936
 937     delete pEntry;
 938
 939     // check that the deletion and rename were done
 940     CPPUNIT_ASSERT(m_testEntries.count(deleteName) == 0);
 941     CPPUNIT_ASSERT(m_testEntries.count(renameFrom) == 0);
 942     CPPUNIT_ASSERT(m_testEntries.count(renameTo) == 1);
 943
 944     // check that the end of the input archive was reached without error
 945     CPPUNIT_ASSERT(arcIn->Eof());
 946
 947     // try adding a new entry
 948     TestEntry& testEntry = Add(newName.mb_str(), newData);
 949     auto_ptr<EntryT> newentry(m_factory->NewEntry());
 950     newentry->SetName(newName);
 951     newentry->SetDateTime(testEntry.GetDateTime());
 952     newentry->SetSize(testEntry.GetLength());
 953     OnCreateEntry(*arcOut, testEntry, newentry.get());
 954     OnSetNotifier(*newentry);
 955     CPPUNIT_ASSERT(arcOut->PutNextEntry(newentry.release()));
 956     CPPUNIT_ASSERT(arcOut->Write(newData, strlen(newData)).IsOk());
 957
 958     // should work with or without explicit Close
 959     if (m_id % 2)
 960         CPPUNIT_ASSERT(arcOut->Close());
 961 }
 962
 963 // Extract an archive using the wx archive classes
 964 //
 965 template <class Classes>
 966 void ArchiveTestCase<Classes>::ExtractArchive(wxInputStream& in)
 967 {
 968     typedef Ptr<EntryT> EntryPtr;
 969     typedef std::list<EntryPtr> Entries;
 970     typedef typename Entries::iterator EntryIter;
 971
 972     auto_ptr<InputStreamT> arc(m_factory->NewStream(in));
 973     int expectedTotal = m_testEntries.size();
 974     EntryPtr entry;
 975     Entries entries;
 976
 977     if ((m_options & PipeIn) == 0)
 978         OnArchiveExtracted(*arc, expectedTotal);
 979
 980     while (entry = EntryPtr(arc->GetNextEntry()), entry.get() != NULL) {
 981         wxString name = entry->GetName(wxPATH_UNIX);
 982
 983         // provide some context for the error message so that we know which
 984         // iteration of the loop we were on
 985         string error_entry((_T(" '") + name + _T("'")).mb_str());
 986         string error_context(" failed for entry" + error_entry);
 987
 988         TestEntries::iterator it = m_testEntries.find(name);
 989         CPPUNIT_ASSERT_MESSAGE(
 990             "archive contains an entry that shouldn't be there" + error_entry,
 991             it != m_testEntries.end());
 992
 993         const TestEntry& testEntry = *it->second;
 994
 995         wxDateTime dt = testEntry.GetDateTime();
 996         if (dt.IsValid())
 997             CPPUNIT_ASSERT_MESSAGE("timestamp check" + error_context,
 998                                    dt == entry->GetDateTime());
 999
1000         // non-seekable entries are allowed to have GetSize == wxInvalidOffset
1001         // until the end of the entry's data has been read past
1002         CPPUNIT_ASSERT_MESSAGE("entry size check" + error_context,
1003             testEntry.GetLength() == entry->GetSize() ||
1004             ((m_options & PipeIn) != 0 && entry->GetSize() == wxInvalidOffset));
1005         CPPUNIT_ASSERT_MESSAGE(
1006             "arc->GetLength() == entry->GetSize()" + error_context,
1007             arc->GetLength() == entry->GetSize());
1008
1009         if (name.Last() != _T('/'))
1010         {
1011             CPPUNIT_ASSERT_MESSAGE("!IsDir" + error_context,
1012                 !entry->IsDir());
1013             wxCharBuffer buf(testEntry.GetSize() + 1);
1014             CPPUNIT_ASSERT_MESSAGE("Read until Eof" + error_context,
1015                 arc->Read(buf.data(), testEntry.GetSize() + 1).Eof());
1016             CPPUNIT_ASSERT_MESSAGE("LastRead check" + error_context,
1017                 arc->LastRead() == testEntry.GetSize());
1018             CPPUNIT_ASSERT_MESSAGE("data compare" + error_context,
1019                 !memcmp(buf.data(), testEntry.GetData(), testEntry.GetSize()));
1020         } else {
1021             CPPUNIT_ASSERT_MESSAGE("IsDir" + error_context, entry->IsDir());
1022         }
1023
1024         // GetSize() must return the right result in all cases after all the
1025         // data has been read
1026         CPPUNIT_ASSERT_MESSAGE("entry size check" + error_context,
1027             testEntry.GetLength() == entry->GetSize());
1028         CPPUNIT_ASSERT_MESSAGE(
1029             "arc->GetLength() == entry->GetSize()" + error_context,
1030             arc->GetLength() == entry->GetSize());
1031
1032         if ((m_options & PipeIn) == 0) {
1033             OnEntryExtracted(*entry, testEntry, arc.get());
1034             delete it->second;
1035             m_testEntries.erase(it);
1036         } else {
1037             entries.push_back(entry);
1038         }
1039     }
1040
1041     // check that the end of the input archive was reached without error
1042     CPPUNIT_ASSERT(arc->Eof());
1043
1044     // for non-seekable streams these data are only guaranteed to be
1045     // available once the end of the archive has been reached
1046     if (m_options & PipeIn) {
1047         for (EntryIter i = entries.begin(); i != entries.end(); ++i) {
1048             wxString name = (*i)->GetName(wxPATH_UNIX);
1049             TestEntries::iterator j = m_testEntries.find(name);
1050             OnEntryExtracted(**i, *j->second);
1051             delete j->second;
1052             m_testEntries.erase(j);
1053         }
1054         OnArchiveExtracted(*arc, expectedTotal);
1055     }
1056 }
1057
1058 // Extract an archive using an external unarchive program
1059 //
1060 template <class Classes>
1061 void ArchiveTestCase<Classes>::ExtractArchive(wxInputStream& in,
1062                                               const wxString& unarchiver)
1063 {
1064     // for an external unarchiver, unarchive to a tempdir
1065     TempDir tmpdir;
1066
1067     if ((m_options & PipeIn) == 0) {
1068         wxFileName fn(tmpdir.GetName());
1069         fn.SetExt(_T("arc"));
1070         wxString tmparc = fn.GetFullPath();
1071
1072         if (m_options & Stub)
1073             in.SeekI(TestOutputStream::STUB_SIZE * 2);
1074
1075         // write the archive to a temporary file
1076         {
1077             wxFFileOutputStream out(tmparc);
1078             if (out.Ok())
1079                 out.Write(in);
1080         }
1081
1082         // call unarchiver
1083         system(wxString::Format(unarchiver, tmparc.c_str()).mb_str());
1084         wxRemoveFile(tmparc);
1085     }
1086     else {
1087         // for the non-seekable test, have the archiver extract "-" and
1088         // feed it the archive via a pipe
1089         PFileOutputStream out(wxString::Format(unarchiver, _T("-")));
1090         if (out.Ok())
1091             out.Write(in);
1092     }
1093
1094     wxString dir = tmpdir.GetName();
1095     VerifyDir(dir);
1096 }
1097
1098 // Verifies the files produced by an external unarchiver are as expected
1099 //
1100 template <class Classes>
1101 void ArchiveTestCase<Classes>::VerifyDir(wxString& path, size_t rootlen /*=0*/)
1102 {
1103     wxDir dir;
1104     path += wxFileName::GetPathSeparator();
1105     int pos = path.length();
1106     wxString name;
1107
1108     if (!rootlen)
1109         rootlen = pos;
1110
1111     if (dir.Open(path) && dir.GetFirst(&name)) {
1112         do {
1113             path.replace(pos, wxString::npos, name);
1114             name = m_factory->GetInternalName(
1115                     path.substr(rootlen, wxString::npos));
1116
1117             bool isDir = wxDirExists(path);
1118             if (isDir)
1119                 name += _T("/");
1120
1121             // provide some context for the error message so that we know which
1122             // iteration of the loop we were on
1123             string error_entry((_T(" '") + name + _T("'")).mb_str());
1124             string error_context(" failed for entry" + error_entry);
1125
1126             TestEntries::iterator it = m_testEntries.find(name);
1127             CPPUNIT_ASSERT_MESSAGE(
1128                 "archive contains an entry that shouldn't be there"
1129                     + error_entry,
1130                 it != m_testEntries.end());
1131
1132             const TestEntry& testEntry = *it->second;
1133
1134 #ifndef __WXMSW__
1135             CPPUNIT_ASSERT_MESSAGE("timestamp check" + error_context,
1136                                    testEntry.GetDateTime() ==
1137                                    wxFileName(path).GetModificationTime());
1138 #endif
1139             if (!isDir) {
1140                 wxFFileInputStream in(path);
1141                 CPPUNIT_ASSERT_MESSAGE(
1142                     "entry not found in archive" + error_entry, in.Ok());
1143
1144                 size_t size = in.GetLength();
1145                 wxCharBuffer buf(size);
1146                 CPPUNIT_ASSERT_MESSAGE("Read" + error_context,
1147                     in.Read(buf.data(), size).LastRead() == size);
1148                 CPPUNIT_ASSERT_MESSAGE("size check" + error_context,
1149                     testEntry.GetSize() == size);
1150                 CPPUNIT_ASSERT_MESSAGE("data compare" + error_context,
1151                     memcmp(buf.data(), testEntry.GetData(), size) == 0);
1152             }
1153             else {
1154                 VerifyDir(path, rootlen);
1155             }
1156
1157             delete it->second;
1158             m_testEntries.erase(it);
1159         }
1160         while (dir.GetNext(&name));
1161     }
1162 }
1163
1164 // test the simple iterators that give away ownership of an entry
1165 //
1166 template <class Classes>
1167 void ArchiveTestCase<Classes>::TestIterator(wxInputStream& in)
1168 {
1169     typedef std::list<EntryT*> ArchiveCatalog;
1170     typedef typename ArchiveCatalog::iterator CatalogIter;
1171
1172     auto_ptr<InputStreamT> arc(m_factory->NewStream(in));
1173     size_t count = 0;
1174
1175 #ifdef WXARC_MEMBER_TEMPLATES
1176     ArchiveCatalog cat((IterT)*arc, IterT());
1177 #else
1178     ArchiveCatalog cat;
1179     for (IterT i(*arc); i != IterT(); ++i)
1180         cat.push_back(*i);
1181 #endif
1182
1183     for (CatalogIter it = cat.begin(); it != cat.end(); ++it) {
1184         auto_ptr<EntryT> entry(*it);
1185         count += m_testEntries.count(entry->GetName(wxPATH_UNIX));
1186     }
1187
1188     CPPUNIT_ASSERT(m_testEntries.size() == cat.size());
1189     CPPUNIT_ASSERT(count == cat.size());
1190 }
1191
1192 // test the pair iterators that can be used to load a std::map or wxHashMap
1193 // these also give away ownership of entries
1194 //
1195 template <class Classes>
1196 void ArchiveTestCase<Classes>::TestPairIterator(wxInputStream& in)
1197 {
1198     typedef std::map<wxString, EntryT*> ArchiveCatalog;
1199     typedef typename ArchiveCatalog::iterator CatalogIter;
1200
1201     auto_ptr<InputStreamT> arc(m_factory->NewStream(in));
1202     size_t count = 0;
1203
1204 #ifdef WXARC_MEMBER_TEMPLATES
1205     ArchiveCatalog cat((PairIterT)*arc, PairIterT());
1206 #else
1207     ArchiveCatalog cat;
1208     for (PairIterT i(*arc); i != PairIterT(); ++i)
1209         cat.insert(*i);
1210 #endif
1211
1212     for (CatalogIter it = cat.begin(); it != cat.end(); ++it) {
1213         auto_ptr<EntryT> entry(it->second);
1214         count += m_testEntries.count(entry->GetName(wxPATH_UNIX));
1215     }
1216
1217     CPPUNIT_ASSERT(m_testEntries.size() == cat.size());
1218     CPPUNIT_ASSERT(count == cat.size());
1219 }
1220
1221 // simple iterators using smart pointers, no need to worry about ownership
1222 //
1223 template <class Classes>
1224 void ArchiveTestCase<Classes>::TestSmartIterator(wxInputStream& in)
1225 {
1226     typedef std::list<Ptr<EntryT> > ArchiveCatalog;
1227     typedef typename ArchiveCatalog::iterator CatalogIter;
1228     typedef wxArchiveIterator<InputStreamT, Ptr<EntryT> > Iter;
1229
1230     auto_ptr<InputStreamT> arc(m_factory->NewStream(in));
1231
1232 #ifdef WXARC_MEMBER_TEMPLATES
1233     ArchiveCatalog cat((Iter)*arc, Iter());
1234 #else
1235     ArchiveCatalog cat;
1236     for (Iter i(*arc); i != Iter(); ++i)
1237         cat.push_back(*i);
1238 #endif
1239
1240     CPPUNIT_ASSERT(m_testEntries.size() == cat.size());
1241
1242     for (CatalogIter it = cat.begin(); it != cat.end(); ++it)
1243         CPPUNIT_ASSERT(m_testEntries.count((*it)->GetName(wxPATH_UNIX)));
1244 }
1245
1246 // pair iterator using smart pointers
1247 //
1248 template <class Classes>
1249 void ArchiveTestCase<Classes>::TestSmartPairIterator(wxInputStream& in)
1250 {
1251     typedef std::map<wxString, Ptr<EntryT> > ArchiveCatalog;
1252     typedef typename ArchiveCatalog::iterator CatalogIter;
1253     typedef wxArchiveIterator<InputStreamT,
1254                 std::pair<wxString, Ptr<EntryT> > > PairIter;
1255
1256     auto_ptr<InputStreamT> arc(m_factory->NewStream(in));
1257
1258 #ifdef WXARC_MEMBER_TEMPLATES
1259     ArchiveCatalog cat((PairIter)*arc, PairIter());
1260 #else
1261     ArchiveCatalog cat;
1262     for (PairIter i(*arc); i != PairIter(); ++i)
1263         cat.insert(*i);
1264 #endif
1265
1266     CPPUNIT_ASSERT(m_testEntries.size() == cat.size());
1267
1268     for (CatalogIter it = cat.begin(); it != cat.end(); ++it)
1269         CPPUNIT_ASSERT(m_testEntries.count(it->second->GetName(wxPATH_UNIX)));
1270 }
1271
1272 // try reading two entries at the same time
1273 //
1274 template <class Classes>
1275 void ArchiveTestCase<Classes>::ReadSimultaneous(TestInputStream& in)
1276 {
1277     typedef std::map<wxString, Ptr<EntryT> > ArchiveCatalog;
1278     typedef wxArchiveIterator<InputStreamT,
1279                 std::pair<wxString, Ptr<EntryT> > > PairIter;
1280
1281     // create two archive input streams
1282     TestInputStream in2(in);
1283     auto_ptr<InputStreamT> arc(m_factory->NewStream(in));
1284     auto_ptr<InputStreamT> arc2(m_factory->NewStream(in2));
1285
1286     // load the catalog
1287 #ifdef WXARC_MEMBER_TEMPLATES
1288     ArchiveCatalog cat((PairIter)*arc, PairIter());
1289 #else
1290     ArchiveCatalog cat;
1291     for (PairIter i(*arc); i != PairIter(); ++i)
1292         cat.insert(*i);
1293 #endif
1294
1295     // the names of two entries to read
1296     const wxChar *name = _T("text/small");
1297     const wxChar *name2 = _T("bin/bin1000");
1298
1299     // open them
1300     typename ArchiveCatalog::iterator j;
1301     CPPUNIT_ASSERT((j = cat.find(name)) != cat.end());
1302     CPPUNIT_ASSERT(arc->OpenEntry(*j->second));
1303     CPPUNIT_ASSERT((j = cat.find(name2)) != cat.end());
1304     CPPUNIT_ASSERT(arc2->OpenEntry(*j->second));
1305
1306     // get pointers to the expected data
1307     TestEntries::iterator k;
1308     CPPUNIT_ASSERT((k = m_testEntries.find(name)) != m_testEntries.end());
1309     TestEntry *entry = k->second;
1310     CPPUNIT_ASSERT((k = m_testEntries.find(name2)) != m_testEntries.end());
1311     TestEntry *entry2 = k->second;
1312
1313     size_t count = 0, count2 = 0;
1314     size_t size = entry->GetSize(), size2 = entry2->GetSize();
1315     const char *data = entry->GetData(), *data2 = entry2->GetData();
1316
1317     // read and check the two entries in parallel, character by character
1318     while (arc->IsOk() || arc2->IsOk()) {
1319         char ch = arc->GetC();
1320         if (arc->LastRead() == 1) {
1321             CPPUNIT_ASSERT(count < size);
1322             CPPUNIT_ASSERT(ch == data[count++]);
1323         }
1324         char ch2 = arc2->GetC();
1325         if (arc2->LastRead() == 1) {
1326             CPPUNIT_ASSERT(count2 < size2);
1327             CPPUNIT_ASSERT(ch2 == data2[count2++]);
1328         }
1329     }
1330
1331     CPPUNIT_ASSERT(arc->Eof());
1332     CPPUNIT_ASSERT(arc2->Eof());
1333     CPPUNIT_ASSERT(count == size);
1334     CPPUNIT_ASSERT(count2 == size2);
1335 }
1336
1337 // Nothing useful can be done with a generic notifier yet, so just test one
1338 // can be set
1339 //
1340 template <class NotifierT, class EntryT>
1341 class ArchiveNotifier : public NotifierT
1342 {
1343 public:
1344     void OnEntryUpdated(EntryT& WXUNUSED(entry)) { }
1345 };
1346
1347 template <class Classes>
1348 void ArchiveTestCase<Classes>::OnSetNotifier(EntryT& entry)
1349 {
1350     static ArchiveNotifier<NotifierT, EntryT> notifier;
1351     entry.SetNotifier(notifier);
1352 }
1353
1354
1355 ///////////////////////////////////////////////////////////////////////////////
1356 // ArchiveTestCase<ZipClasses> could be used directly, but instead this
1357 // derived class is used so that zip specific features can be tested.
1358
1359 class ZipTestCase : public ArchiveTestCase<ZipClasses>
1360 {
1361 public:
1362     ZipTestCase(string name,
1363                 int id,
1364                 int options,
1365                 const wxString& archiver = wxEmptyString,
1366                 const wxString& unarchiver = wxEmptyString)
1367     :
1368         ArchiveTestCase<ZipClasses>(name, id, new wxZipClassFactory,
1369                                     options, archiver, unarchiver),
1370         m_count(0)
1371     { }
1372
1373 protected:
1374     void OnCreateArchive(wxZipOutputStream& zip);
1375
1376     void OnArchiveExtracted(wxZipInputStream& zip, int expectedTotal);
1377
1378     void OnCreateEntry(wxZipOutputStream& zip,
1379                        TestEntry& testEntry,
1380                        wxZipEntry *entry);
1381
1382     void OnEntryExtracted(wxZipEntry& entry,
1383                           const TestEntry& testEntry,
1384                           wxZipInputStream *arc);
1385
1386     void OnSetNotifier(EntryT& entry);
1387
1388     int m_count;
1389     wxString m_comment;
1390 };
1391
1392 void ZipTestCase::OnCreateArchive(wxZipOutputStream& zip)
1393 {
1394     m_comment << _T("Comment for test ") << m_id;
1395     zip.SetComment(m_comment);
1396 }
1397
1398 void ZipTestCase::OnArchiveExtracted(wxZipInputStream& zip, int expectedTotal)
1399 {
1400     CPPUNIT_ASSERT(zip.GetComment() == m_comment);
1401     CPPUNIT_ASSERT(zip.GetTotalEntries() == expectedTotal);
1402 }
1403
1404 void ZipTestCase::OnCreateEntry(wxZipOutputStream& zip,
1405                                 TestEntry& testEntry,
1406                                 wxZipEntry *entry)
1407 {
1408     zip.SetLevel((m_id + m_count) % 10);
1409
1410     if (entry) {
1411         switch ((m_id + m_count) % 5) {
1412             case 0:
1413             {
1414                 wxString comment = _T("Comment for ") + entry->GetName();
1415                 entry->SetComment(comment);
1416                 // lowercase the expected result, and the notifier should do
1417                 // the same for the zip entries when ModifyArchive() runs
1418                 testEntry.SetComment(comment.Lower());
1419                 break;
1420             }
1421             case 2:
1422                 entry->SetMethod(wxZIP_METHOD_STORE);
1423                 break;
1424             case 4:
1425                 entry->SetMethod(wxZIP_METHOD_DEFLATE);
1426                 break;
1427         }
1428         entry->SetIsText(testEntry.IsText());
1429     }
1430
1431     m_count++;
1432 }
1433
1434 void ZipTestCase::OnEntryExtracted(wxZipEntry& entry,
1435                                    const TestEntry& testEntry,
1436                                    wxZipInputStream *arc)
1437 {
1438     // provide some context for the error message so that we know which
1439     // iteration of the loop we were on
1440     wxString name = _T(" '") + entry.GetName() + _T("'");
1441     string error_entry(name.mb_str());
1442     string error_context(" failed for entry" + error_entry);
1443
1444     CPPUNIT_ASSERT_MESSAGE("GetComment" + error_context,
1445         entry.GetComment() == testEntry.GetComment());
1446
1447     // for seekable streams, GetNextEntry() doesn't read the local header so
1448     // call OpenEntry() to do it
1449     if (arc && (m_options & PipeIn) == 0 && entry.IsDir())
1450         arc->OpenEntry(entry);
1451
1452     CPPUNIT_ASSERT_MESSAGE("IsText" + error_context,
1453                            entry.IsText() == testEntry.IsText());
1454
1455     CPPUNIT_ASSERT_MESSAGE("Extra/LocalExtra mismatch for entry" + error_entry,
1456         (entry.GetExtraLen() != 0 && entry.GetLocalExtraLen() != 0) ||
1457         (entry.GetExtraLen() == 0 && entry.GetLocalExtraLen() == 0));
1458 }
1459
1460 // check the notifier mechanism by using it to fold the entry comments to
1461 // lowercase
1462 //
1463 class ZipNotifier : public wxZipNotifier
1464 {
1465 public:
1466     void OnEntryUpdated(wxZipEntry& entry);
1467 };
1468
1469 void ZipNotifier::OnEntryUpdated(wxZipEntry& entry)
1470 {
1471     entry.SetComment(entry.GetComment().Lower());
1472 }
1473
1474 void ZipTestCase::OnSetNotifier(EntryT& entry)
1475 {
1476     static ZipNotifier notifier;
1477     entry.SetNotifier(notifier);
1478 }
1479
1480
1481 ///////////////////////////////////////////////////////////////////////////////
1482 // 'zip - -' produces local headers without the size field set. This is a
1483 // case not covered by all the other tests, so this class tests it as a
1484 // special case
1485
1486 class ZipPipeTestCase : public CppUnit::TestCase
1487 {
1488 public:
1489     ZipPipeTestCase(string name, int options) :
1490         CppUnit::TestCase(name), m_options(options) { }
1491
1492 protected:
1493     void runTest();
1494     int m_options;
1495 };
1496
1497 void ZipPipeTestCase::runTest()
1498 {
1499     TestOutputStream out(m_options);
1500
1501     wxString testdata = _T("test data to pipe through zip");
1502     wxString cmd = _T("echo ") + testdata + _T(" | zip -q - -");
1503
1504     {
1505         PFileInputStream in(cmd);
1506         if (in.Ok())
1507             out.Write(in);
1508     }
1509
1510     TestInputStream in(out);
1511     wxZipInputStream zip(in);
1512
1513     auto_ptr<wxZipEntry> entry(zip.GetNextEntry());
1514     CPPUNIT_ASSERT(entry.get() != NULL);
1515
1516     if ((m_options & PipeIn) == 0)
1517         CPPUNIT_ASSERT(entry->GetSize() != wxInvalidOffset);
1518
1519     char buf[64];
1520     size_t len = zip.Read(buf, sizeof(buf) - 1).LastRead();
1521
1522     while (len > 0 && buf[len - 1] <= 32)
1523         --len;
1524     buf[len] = 0;
1525
1526     CPPUNIT_ASSERT(zip.Eof());
1527     CPPUNIT_ASSERT(wxString(buf, *wxConvCurrent) == testdata);
1528 }
1529
1530
1531 ///////////////////////////////////////////////////////////////////////////////
1532 // The suite
1533
1534 class ArchiveTestSuite : public CppUnit::TestSuite
1535 {
1536 public:
1537     ArchiveTestSuite();
1538     static CppUnit::Test *suite()
1539         { return (new ArchiveTestSuite)->makeSuite(); }
1540
1541 private:
1542     int m_id;
1543     wxPathList m_path;
1544
1545     ArchiveTestSuite *makeSuite();
1546     void AddCmd(wxArrayString& cmdlist, const wxString& cmd);
1547     bool IsInPath(const wxString& cmd);
1548
1549     string Description(const wxString& type,
1550                        int options,
1551                        bool genericInterface = false,
1552                        const wxString& archiver = wxEmptyString,
1553                        const wxString& unarchiver = wxEmptyString);
1554 };
1555
1556 ArchiveTestSuite::ArchiveTestSuite()
1557   : CppUnit::TestSuite("ArchiveTestSuite"),
1558     m_id(0)
1559 {
1560     m_path.AddEnvList(_T("PATH"));
1561 }
1562
1563 // add the command for an external archiver to the list, testing for it in
1564 // the path first
1565 //
1566 void ArchiveTestSuite::AddCmd(wxArrayString& cmdlist, const wxString& cmd)
1567 {
1568     if (cmdlist.empty())
1569         cmdlist.push_back(_T(""));
1570     if (IsInPath(cmd))
1571         cmdlist.push_back(cmd);
1572 }
1573
1574 bool ArchiveTestSuite::IsInPath(const wxString& cmd)
1575 {
1576     wxString c = cmd.BeforeFirst(_T(' '));
1577 #ifdef __WXMSW__
1578     c += _T(".exe");
1579 #endif
1580     return !m_path.FindValidPath(c).empty();
1581 }
1582
1583 // make the test suite
1584 //
1585 ArchiveTestSuite *ArchiveTestSuite::makeSuite()
1586 {
1587     typedef wxArrayString::iterator Iter;
1588     wxArrayString zippers;
1589     wxArrayString unzippers;
1590
1591     AddCmd(zippers, _T("zip -qr %s *"));
1592     AddCmd(unzippers, _T("unzip -q %s"));
1593
1594     for (int genInterface = 0; genInterface < 2; genInterface++)
1595         for (Iter i = unzippers.begin(); i != unzippers.end(); ++i)
1596             for (Iter j = zippers.begin(); j != zippers.end(); ++j)
1597                 for (int options = 0; options <= AllOptions; options++)
1598                 {
1599                     // unzip doesn't support piping in the zip
1600                     if ((options & PipeIn) && !i->empty())
1601                         continue;
1602 #ifdef WXARC_NO_POPEN
1603                     // if no popen then can use piped output of zip
1604                     if ((options & PipeOut) && !j->empty())
1605                         continue;
1606 #endif
1607                     string name = Description(_T("wxZip"), options,
1608                                               genInterface != 0, *j, *i);
1609
1610                     if (genInterface)
1611                         addTest(new ArchiveTestCase<ArchiveClasses>(
1612                                     name, m_id,
1613                                     new wxZipClassFactory,
1614                                     options, *j, *i));
1615                     else
1616                         addTest(new ZipTestCase(name, m_id, options, *j, *i));
1617
1618                     m_id++;
1619                 }
1620
1621 #ifndef WXARC_NO_POPEN
1622     // if have popen then can check the piped output of 'zip - -'
1623     if (IsInPath(_T("zip")))
1624         for (int options = 0; options <= PipeIn; options += PipeIn) {
1625             string name = Description(_T("ZipPipeTestCase"), options);
1626             addTest(new ZipPipeTestCase(name, options));
1627             m_id++;
1628         }
1629 #endif
1630
1631     return this;
1632 }
1633
1634 // make a display string for the option bits
1635 //
1636 string ArchiveTestSuite::Description(const wxString& type,
1637                                      int options,
1638                                      bool genericInterface,
1639                                      const wxString& archiver,
1640                                      const wxString& unarchiver)
1641 {
1642     wxString descr;
1643     descr << m_id << _T(" ");
1644
1645     if (genericInterface)
1646         descr << _T("wxArchive (") << type << _T(")");
1647     else
1648         descr << type;
1649
1650     if (!archiver.empty())
1651         descr << _T(" ") << archiver.BeforeFirst(_T(' '));
1652     if (!unarchiver.empty())
1653         descr << _T(" ") << unarchiver.BeforeFirst(_T(' '));
1654
1655     wxString optstr;
1656
1657     if ((options & PipeIn) != 0)
1658         optstr += _T("|PipeIn");
1659     if ((options & PipeOut) != 0)
1660         optstr += _T("|PipeOut");
1661     if ((options & Stub) != 0)
1662         optstr += _T("|Stub");
1663     if (!optstr.empty())
1664         optstr = _T(" (") + optstr.substr(1) + _T(")");
1665
1666     descr << optstr;
1667
1668     return (const char*)descr.mb_str();
1669 }
1670
1671 // register in the unnamed registry so that these tests are run by default
1672 CPPUNIT_TEST_SUITE_REGISTRATION(ArchiveTestSuite);
1673
1674 // also include in it's own registry so that these tests can be run alone
1675 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(ArchiveTestSuite, "ArchiveTestSuite");
1676
1677 #endif // wxUSE_STREAMS