---

test-colocated.cc

/*
*  Name:      test-colocated.cc
*  Author:    Rafael Jesus Alcantara Perez
*  Summary:   Test for CORBA (colocated)
*  Date:      $Date: 2003/10/06 12:45:11 $
*  Revision:  $Revision: 1.2 $
*
*  Copyright (C) 2001-2002  Rafael Jesus Alcantara Perez <rafa@dedalo-ing.com>
*
*  This program is free software; you can redistribute it and/or modify
*  it under the terms of the GNU General Public License as published by
*  the Free Software Foundation; either version 2 of the License, or
*  (at your option) any later version.
*
*  This program is distributed in the hope that it will be useful,
*  but WITHOUT ANY WARRANTY; without even the implied warranty of
*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
*  GNU General Public License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with this program; if not, write to the Free Software
*  Foundation, Inc., 59 Temple Place, Suite 330, Boston,
*  MA 02111-1307, USA.
*/

#include <cstdlib>
#include <fstream>
#include <iostream>
#include <mpcl/net/corba/orb.hh>
#include <mpcl/net/corba/server_application.hh>
#include <mpcl/system/system.hh>
#include <mpcl/test.h>
#include "test-sample_producer.hh"


using mpcl::net::corba::TOrb;
using mpcl::net::corba::TServerApplication;


//
//  L O C A L   V A R I A B L E S
//

template <typename TOrb>
class TSampleProducer                        :
  public POA_mpcl::TSampleProducer           ,
  public PortableServer::RefCountServantBase
{

  private:

    long int   liValue;

    TOrb&   rtOrb;


  public:

    TSampleProducer (TOrb& rtORB)                 :
      POA_mpcl::TSampleProducer           ()      ,
      PortableServer::RefCountServantBase ()      ,
      liValue                             (0)     ,
      rtOrb                               (rtORB) {}

    CORBA::Long get (void)
    {
      return liValue++;
    }

    void finish (void)
    {
      rtOrb.finish();
    }

};  // class TSampleProducer


class TColocatedApplication :
  public TServerApplication<TOrb>
{

  private:

    typedef
      TSampleProducer<TOrb>
      TCorbaSampleProducer;

    typedef
      mpcl::TSampleProducer_var
      QTCorbaSampleProducer;

    QTCorbaSampleProducer   qtSampleProducer;


  public:

    TColocatedApplication ( const char* pkcNAME    ,
                            const char* pkcRELEASE ,
                            TOrb&       rtORB      )        :
      TServerApplication<TOrb> (pkcNAME, pkcRELEASE, rtORB) {}

    void initialize (void)
    {
      TCorbaSampleProducer*   ptSampleProducer;

      ptSampleProducer = new TCorbaSampleProducer (rtOrb);
      qtSampleProducer =
        rtOrb.enrol<TCorbaSampleProducer, QTCorbaSampleProducer> (ptSampleProducer);
    }

    int start (void)
    {
      TEST_INIT ("tests for class 'TClientApplication'");

      TServerApplication<TOrb>::start();
      TEST_NUMBERS (0, qtSampleProducer->get());
      TEST_NUMBERS (1, qtSampleProducer->get());
      TEST_NUMBERS (2, qtSampleProducer->get());
      TEST_NUMBERS (3, qtSampleProducer->get());

      TEST_MEMORY_STATUS;
      TEST_RETURN_CODE;
    }
    

  public:

    mpcl::TString programFileName (void) const
    {
      return "test-colocated";
    }

};  // class TColocatedApplication


int main (int argc, const char** argv)
{

  TEST_INIT ("tests for CORBA (colocated)");

  try
  {
    TOrb                    tOrb (argc, argv);
    TColocatedApplication   tApplication ("test-colocated", "0.0.0", tOrb);

    tOrb.setColocated (true);
    tApplication.initialize();
    TEST_FUNCTION (tApplication.start());
  }
  catch (CORBA::SystemException&)
  {
    std::cerr << "ORB; caught CORBA::SystemException" << std::endl;
    TEST_FAIL;
  }
  catch (CORBA::Exception&)
  {
    std::cerr << "ORB; caught CORBA::Exception" << std::endl;
    TEST_FAIL;
  }
  catch (const mpcl::TException& rktEXCEPTION)
  {
    std::cerr << rktEXCEPTION;
    TEST_FAIL;
  }
  catch (std::exception& rktEXCEPTION)
  {
    std::cerr << rktEXCEPTION.what();
    TEST_FAIL;
  }
  catch (...)
  {
    std::cerr << "caught unknown exception" << std::endl;
    TEST_FAIL;
  }
  TEST_MEMORY_STATUS;
  TEST_RETURN_CODE;

}  // main()

---