---

test-server.cc

/*
*  Name:      test-server.cc
*  Author:    Rafael Jesus Alcantara Perez
*  Summary:   Test for CORBA (server)
*  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/all.hh>
#include <mpcl/test.h>
// <FIXME comment="this must abstracted using mpcl::system">
#include <unistd.h>
// </FIXME>
#include "test-sample_producer.hh"


using mpcl::net::corba::TOrb;
using mpcl::net::corba::TServerApplication;
using mpcl::system::GetErrorMessage;
using mpcl::system::tSystem;
using mpcl::text::TString;


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

static const char*   _pkcIorFileName = "test-server.ior.txt";


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

  private:

    long int   liValue;

    TOrb&   rtOrb;


  public:

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

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

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

};  // class TSampleProducer


class TProducerApplication :
  public TServerApplication<TOrb>
{

  private:

    typedef
      TSampleProducer<TOrb>
      TCorbaSampleProducer;

    typedef
      mpcl::TSampleProducer_var
      QTCorbaSampleProducer;


  public:

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

    void initialize (void)
    {
      TCorbaSampleProducer*   ptNamedSampleProducer1;
      TCorbaSampleProducer*   ptNamedSampleProducer2;
      TCorbaSampleProducer*   ptSampleProducer;
      QTCorbaSampleProducer   qtNamedSampleProducer1;
      QTCorbaSampleProducer   qtNamedSampleProducer2;
      QTCorbaSampleProducer   qtSampleProducer;
      std::ofstream           tOfstream (_pkcIorFileName);

      ptNamedSampleProducer1 = new TCorbaSampleProducer (rtOrb, 10);
      ptNamedSampleProducer2 = new TCorbaSampleProducer (rtOrb, 20);
      ptSampleProducer       = new TCorbaSampleProducer (rtOrb);
      qtNamedSampleProducer1 =
        rtOrb.enrol<TCorbaSampleProducer, QTCorbaSampleProducer> (ptNamedSampleProducer1, "/mpcl/test-server/sample_producer_1.object");
      qtNamedSampleProducer2 =
        rtOrb.enrol<TCorbaSampleProducer, QTCorbaSampleProducer> (ptNamedSampleProducer2, "/mpcl/test-server/sample_producer_2.object");
      qtSampleProducer =
        rtOrb.enrol<TCorbaSampleProducer, QTCorbaSampleProducer> (ptSampleProducer);
      tOfstream << rtOrb.name (qtSampleProducer) << std::endl;
    }


  public:

    TString programFileName (void) const
    {
      return "test-server";
    }

};  // class TProducerApplication


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

  using std::basic_ifstream;

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

  try
  {
    switch (fork())
    {
      case 0:
      {
        //
        //  Child process running as a daemon.
        //
        TOrb                   tOrb (argc, argv);
        TProducerApplication   tApplication ("test-server", "0.0.0", tOrb);
    
        tApplication.initialize();
        TEST_FUNCTION (tApplication.start());
        break;
      }
      case -1:
      {
        throw mpcl::TException ("test-server", GetErrorMessage(), __FILE__, __LINE__);
        break;
      }
      default:
      {
        basic_ifstream<char>   tIfstream;
        int                    I = 0;

        //
        //  Parent process. Returns code 77  to  force  AUTOMAKE to  ignore the
        //  result of this test.
        //
        TEST_FAIL_WITH_CODE (77);
        do
        {
          //
          //  Tests IOR file readiness from [2, (2 * 10)] seconds.
          //
          tSystem.sleep (2);
          tIfstream.clear();
          tIfstream.open (_pkcIorFileName);
        } while ( !tIfstream.is_open() && ( I++ < 10 ) );
        break;
      }
    }
  }
  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()

---