Don't like ads? PRO users don't see any ads ;-)
Public Pastes
Guest

ManagedArchivingTest

By: a guest on Jun 18th, 2010  |  syntax: C++  |  size: 6.78 KB  |  hits: 193  |  expires: Never
download  |  raw  |  embed  |  report abuse  |  print
Text below is selected. Please press Ctrl+C to copy to your clipboard. (⌘+C on Mac)
  1.  
  2. using namespace std;
  3.  
  4. #include <cppunit/Test.h>
  5. #include <cppunit/TestCaller.h>
  6. #include <cppunit/TestSuite.h>
  7. #include <cppunit/extensions/HelperMacros.h>
  8. #include <cppunit/ui/text/TestRunner.h>
  9.  
  10. #include <Archivable.h>
  11. #include <Message.h>
  12. #include <MessagePrivate.h>
  13.  
  14. const char* kSelfField = "cr:self";
  15. const char* kAField = "cr:A";
  16. const char* kACopyField = "cr:Acopy";
  17. const char* kChildField = "cr:child";
  18. const char* kParentField = "cr:parent";
  19. const char* kNullField = "cr:null";
  20.  
  21. class CrossReferencer: public BArchivable {
  22. public:
  23.         CrossReferencer();
  24.         CrossReferencer(BMessage* archive);
  25.         ~CrossReferencer();
  26.  
  27.         void                            SetAPointer(CrossReferencer* aPointer);
  28.         CrossReferencer*        APointer();
  29.  
  30.         CrossReferencer*        Child();
  31.         CrossReferencer*        Parent();
  32.         void                            SetChild(CrossReferencer* child);
  33.  
  34.         void    Validate();
  35.  
  36.         virtual status_t        Archive(BMessage* into, bool deep = true) const;
  37.         static BArchivable*     Instantiate(BMessage* from);
  38.  
  39. private:
  40.         CrossReferencer*        fSelfPointer;
  41.         CrossReferencer*        fAPointer;
  42.         CrossReferencer*        fAPointerCopy;
  43.         CrossReferencer*        fChildPointer;
  44.         CrossReferencer*        fParentPointer;
  45.         CrossReferencer*        fNullPointer;
  46. };
  47.  
  48.  
  49. CrossReferencer::CrossReferencer()
  50.         :
  51.         fSelfPointer(this),
  52.         fAPointer(NULL),
  53.         fAPointerCopy(NULL),
  54.         fChildPointer(NULL),
  55.         fParentPointer(NULL),
  56.         fNullPointer(NULL)
  57. {
  58. }
  59.  
  60.  
  61. CrossReferencer::~CrossReferencer()
  62. {
  63. }
  64.  
  65.  
  66. status_t
  67. CrossReferencer::Archive(BMessage* into, bool deep) const
  68. {
  69.         BArchivable::Archive(BArchiver::PrepareArchive(into));
  70.         BArchiver archiver(into);
  71.  
  72.         archiver.AddArchivable(kSelfField, fSelfPointer);              
  73.         archiver.AddArchivable(kAField, fAPointer);
  74.         archiver.AddArchivable(kACopyField, fAPointerCopy);
  75.         archiver.AddArchivable(kChildField, fChildPointer);
  76.         archiver.AddArchivable(kParentField, fParentPointer);
  77.         archiver.AddArchivable(kNullField, fNullPointer);
  78.  
  79.         return B_OK;
  80. }
  81.  
  82.  
  83. CrossReferencer::CrossReferencer(BMessage* archive)
  84.         :
  85.         BArchivable(BUnarchiver::PrepareArchive(archive))
  86. {
  87.         BUnarchiver unarchiver(archive);
  88.  
  89.         BArchivable* retriever;
  90.  
  91.         unarchiver.FindArchivable(kSelfField, &retriever);
  92.         fSelfPointer = static_cast<CrossReferencer*>(retriever);
  93.  
  94.         unarchiver.FindArchivable(kAField, &retriever);
  95.         fAPointer = static_cast<CrossReferencer*>(retriever);
  96.  
  97.         unarchiver.FindArchivable(kACopyField, &retriever);
  98.         fAPointerCopy = static_cast<CrossReferencer*>(retriever);
  99.  
  100.         unarchiver.FindArchivable(kChildField, &retriever);
  101.         fChildPointer = static_cast<CrossReferencer*>(retriever);
  102.  
  103.         unarchiver.FindArchivable(kParentField, &retriever);
  104.         fParentPointer = static_cast<CrossReferencer*>(retriever);
  105.  
  106.         unarchiver.FindArchivable(kNullField, &retriever);
  107.         fNullPointer = static_cast<CrossReferencer*>(retriever);
  108. }
  109.  
  110.  
  111. BArchivable*
  112. CrossReferencer::Instantiate(BMessage* from)
  113. {
  114.         if (validate_instantiation(from, "CrossReferencer"))
  115.                 return new CrossReferencer(from);
  116.         return NULL;
  117. }
  118.  
  119.  
  120. void
  121. CrossReferencer::Validate()
  122. {
  123.         CPPUNIT_ASSERT(fSelfPointer == this);
  124.  
  125.         CPPUNIT_ASSERT(fAPointer);
  126.         CPPUNIT_ASSERT(fAPointer == fAPointerCopy);
  127.  
  128.         CPPUNIT_ASSERT(fChildPointer->fParentPointer == this);
  129.         CPPUNIT_ASSERT(fParentPointer->fChildPointer == this);
  130.  
  131.         CPPUNIT_ASSERT(fNullPointer == NULL);
  132. }
  133.  
  134.  
  135. void
  136. CrossReferencer::SetAPointer(CrossReferencer* aPointer)
  137. {
  138.         fAPointer = aPointer;
  139.         fAPointerCopy = fAPointer;
  140. }
  141.  
  142.  
  143. CrossReferencer*
  144. CrossReferencer::APointer()
  145. {
  146.         return fAPointer;
  147. }
  148.  
  149.  
  150. void
  151. CrossReferencer::SetChild(CrossReferencer* child)
  152. {
  153.         fChildPointer = child;
  154.         if (child)
  155.                 child->fParentPointer = this;
  156. }
  157.  
  158.  
  159. CrossReferencer*
  160. CrossReferencer::Child()
  161. {
  162.         return fChildPointer;
  163. }
  164.  
  165.  
  166. CrossReferencer*
  167. CrossReferencer::Parent()
  168. {
  169.         return fParentPointer;
  170. }
  171.  
  172.  
  173. class CrossReferencerTest: public CppUnit::TestFixture {
  174.  
  175.         CPPUNIT_TEST_SUITE(CrossReferencerTest);
  176.                 CPPUNIT_TEST(TestArchiveTopInstantiateTop);
  177.                 CPPUNIT_TEST(TestArchiveTwoInstantiateChildTwo);
  178.                 CPPUNIT_TEST(TestArchiveOneInsantiateChildOne);
  179.                 CPPUNIT_TEST(TestManagerSetsItselfToNULL);
  180.                 CPPUNIT_TEST(TestArchiveIsManagedMethod);
  181.         CPPUNIT_TEST_SUITE_END();
  182.  
  183. private:
  184.         CrossReferencer* top;
  185.         CrossReferencer* childOne;
  186.         CrossReferencer* childTwo;
  187.  
  188.         CrossReferencer* topCopy;
  189.         CrossReferencer* childOneCopy;
  190.         CrossReferencer* childTwoCopy;
  191.  
  192. public:
  193.  
  194.         void
  195.         setUp() {
  196.                 top = new CrossReferencer();
  197.                 childOne = new CrossReferencer();
  198.                 childTwo = new CrossReferencer();
  199.  
  200.                 top->SetChild(childOne);
  201.                 top->SetAPointer(childTwo);
  202.  
  203.                 childOne->SetChild(childTwo);
  204.                 childOne->SetAPointer(childOne);
  205.  
  206.                 childTwo->SetAPointer(top);
  207.                 childTwo->SetChild(top);
  208.  
  209.                 topCopy = NULL;
  210.                 childOneCopy = NULL;
  211.                 childTwoCopy = NULL;
  212.         }
  213.  
  214.         void
  215.         tearDown() {
  216.                 delete top;
  217.                 delete childOne;
  218.                 delete childTwo;
  219.  
  220.                 delete topCopy;
  221.                 delete childOneCopy;
  222.                 delete childTwoCopy;
  223.         }
  224.  
  225.  
  226.         void
  227.         ValidateCopies() {
  228.                 topCopy->Validate();
  229.                 childOneCopy->Validate();
  230.                 childTwoCopy->Validate();
  231.  
  232.                 CPPUNIT_ASSERT(childOneCopy->APointer() == childOneCopy);
  233.                 CPPUNIT_ASSERT(childTwoCopy->APointer() == topCopy);
  234.                 CPPUNIT_ASSERT(topCopy->APointer() == childTwoCopy);
  235.         }
  236.  
  237.  
  238.         void
  239.         FillCopyFields() {
  240.                 if (topCopy) {
  241.                         childOneCopy = topCopy->Child();
  242.                         childTwoCopy = childOneCopy->Child();
  243.                 } else if (childOneCopy) {
  244.                         childTwoCopy = childOneCopy->Child();
  245.                         topCopy = childTwoCopy->Child();
  246.                 } else if (childTwoCopy) {
  247.                         topCopy = childTwoCopy->Child();
  248.                         childOneCopy = topCopy->Child();
  249.                 }
  250.         }
  251.  
  252.  
  253.         void
  254.         CompleteTest()
  255.         {
  256.                 FillCopyFields();
  257.                 ValidateCopies();
  258.         }
  259.  
  260.  
  261.         void
  262.         ArchiveInstantiateAndTest(CrossReferencer* archiveFrom,
  263.                 CrossReferencer** instantiateTo) {
  264.                 BMessage archive;
  265.                 CPPUNIT_ASSERT(archiveFrom->Archive(&archive) == B_OK);
  266.                 CPPUNIT_ASSERT(*instantiateTo =
  267.                         dynamic_cast<CrossReferencer*>(instantiate_object(&archive)));
  268.  
  269.                 CompleteTest();
  270.         }
  271.  
  272.  
  273.         void
  274.         TestArchiveTopInstantiateTop() {
  275.                 ArchiveInstantiateAndTest(top, &topCopy);
  276.         }
  277.  
  278.  
  279.         void
  280.         TestArchiveTwoInstantiateChildTwo() {
  281.                 ArchiveInstantiateAndTest(childTwo, &childTwoCopy);
  282.         }
  283.  
  284.  
  285.         void
  286.         TestArchiveOneInsantiateChildOne() {
  287.                 ArchiveInstantiateAndTest(childOne, &childOneCopy);
  288.         }
  289.  
  290.  
  291.         void
  292.         TestManagerSetsItselfToNULL() {
  293.                 BMessage archive;
  294.                 top->Archive(&archive);
  295.  
  296.                 BMessage::Private messagePrivate(archive);
  297.                 CPPUNIT_ASSERT(!messagePrivate.ArchiveManager());
  298.  
  299.                 topCopy = (CrossReferencer*)instantiate_object(&archive);
  300.                 CPPUNIT_ASSERT(!messagePrivate.UnarchiveManager());
  301.                 CompleteTest();
  302.         }
  303.  
  304.  
  305.         void
  306.         TestArchiveIsManagedMethod() {
  307.                 BMessage archive;
  308.                 CPPUNIT_ASSERT(!BUnarchiver::ArchiveIsManaged(&archive));
  309.  
  310.                 top->Archive(&archive);
  311.                 CPPUNIT_ASSERT(BUnarchiver::ArchiveIsManaged(&archive));
  312.         }
  313. };
  314.  
  315.        
  316. int main() {
  317.         CppUnit::TextUi::TestRunner runner;
  318.         runner.addTest(CrossReferencerTest::suite());
  319.         runner.run();
  320.         return 0;
  321. }
create a new version of this paste RAW Paste Data