basic_log_test.cpp

这是广泛使用的通信开源项目,对于大容量,高并发的通讯要求完全能够胜任,他广泛可用于网络游戏医学图像网关的高qos要求.更详细的内容可阅读相应的材料

    }
  ACE_CATCH(DsLogAdmin::LogLocked, xLocked)
    {
      ACE_DEBUG ((LM_DEBUG,"Setting administrative state to lock faild.  DsLogAdmin::LogLocked was caught.\n"));
    }
  ACE_ENDTRY;
  ACE_RETURN(0);
}


int
BasicLog_Test::test_logSize (void)
{
  ACE_DECLARE_NEW_CORBA_ENV;

  ACE_TRY
    {
      basicLog_->set_max_size (1);
      ACE_TRY_CHECK;

      ACE_ERROR_RETURN ((LM_ERROR,
                         "Setting max size less than current size failed.\n"
                         "DsLogAdmin::InvalidParam not thrown.\n"),
                       -1);
    }
  ACE_CATCH(DsLogAdmin::InvalidParam, xParam)
    {
      ACE_DEBUG ((LM_DEBUG,
                  "Setting max size less than current size succeeded.\n"
                  "DsLogAdmin::InvalidParam caught.\n"));
    }
  ACE_ENDTRY;

  ACE_TRY_EX(SECOND)
    {
      basicLog_->set_max_size (10000);

      CORBA::ULongLong nrecords = basicLog_->get_n_records ();
      int i = this->write_records (0 ACE_ENV_ARG_PARAMETER);

      ACE_TRY_CHECK_EX (SECOND);
      ACE_DEBUG ((LM_DEBUG,
                  "Increasing max size succeeded. Old record count, %d."
                  "New record count, %d\n",
                  ACE_U64_TO_U32(nrecords),
                  i));
    }
  ACE_CATCHANY
    {
      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, "test_logSize");
      ACE_ERROR_RETURN ((LM_ERROR,
                         "Increasing max size failed. Exception thrown.\n"),
                        -1);
    }
  ACE_ENDTRY;
  ACE_RETURN(0);
}

int
BasicLog_Test::test_logCompaction(CORBA::ULong lifeExpectancy)
{
  ACE_DECLARE_NEW_CORBA_ENV;

  CORBA::ULongLong old_n_records = basicLog_->get_n_records ();
  if (old_n_records <= 0)
    {
      ACE_TRY
        {
          this->write_records (0 ACE_ENV_ARG_PARAMETER);
          ACE_TRY_CHECK;
        }
      ACE_CATCHANY
        {
          ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, "test_logCompaction");
          ACE_ERROR_RETURN ((LM_ERROR,
                             "Caught exception trying to write records "
                             "for test_logCompaction.\n"),
                            -1);
        }
      ACE_ENDTRY;
    }

  CORBA::ULong old_max_life = basicLog_->get_max_record_life ();

  ACE_TRY_EX(SECOND)
    {
      basicLog_->set_max_record_life (lifeExpectancy);
      // @@: need to modify set_max_record_life
      ACE_TRY_CHECK_EX (SECOND);
    }
  ACE_CATCHANY
    {
      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, "test_logCompaction");
      ACE_ERROR_RETURN ((LM_ERROR,
                         "Caught exception setting max record life "
                         "test_logCompaction.\n"),
                        -1);
    }
  ACE_ENDTRY;

  ACE_OS::sleep (lifeExpectancy + 1); // make sure the records have aged.
  CORBA::ULongLong new_n_records = basicLog_->get_n_records ();
  basicLog_->set_max_record_life (old_max_life);

  ACE_DEBUG ((LM_ERROR,
              "The number of records in log is %d\n",
              ACE_U64_TO_U32 (new_n_records)));

  if (new_n_records != 0)
    {
      ACE_ERROR_RETURN((LM_ERROR,
                        "Log compaction failed, because %d records remain.\n",
                        ACE_U64_TO_U32 (new_n_records)),
                       -1 );
    }

  return 0;
}

//use ACE_U64_TO_U32 to convert ULongLong to ULong in call to this function
//Writes and retrieves numberOfrecordsToWrite records.
int
BasicLog_Test::test_retrieval (CORBA::ULong /* numberOfRecordsToWrite */)
{
  int rc = 0;

  if (!rc)
    {
      ACE_DEBUG ((LM_ERROR,"Test of retrieval: succeeded.\n"));
    }

  return rc;
}



int
BasicLog_Test::test_query(CORBA::ULong numberOfRecordsToWrite)
{
    // save for compares
    DsLogAdmin::Anys infos(numberOfRecordsToWrite);
    return -1;
}


int
BasicLog_Test::parse_args (void)
{
  ACE_Get_Opt get_opts (argc_, argv_, "di");
  int c;

  while ((c = get_opts ()) != -1)
    switch (c)
      {
      case 'd':  // debug flag
        TAO_debug_level++;
        break;
      case '?':
      default:
        ACE_ERROR_RETURN ((LM_ERROR,
                           "usage:  %s"
                           " [-d]"
                           "\n"
                           "    -d: increase debug level\n",
                           this->argv_ [0]),
                          -1);
      }

  // Indicates successful parsing of command line.
  return 0;
}

void
BasicLog_Test::resolve_naming_service (ACE_ENV_SINGLE_ARG_DECL)
{
  CORBA::Object_var naming_obj =
    this->orb_->resolve_initial_references (naming_sevice_name_
                                            ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;

  // Need to check return value for errors.
  if (CORBA::is_nil (naming_obj.in ()))
    ACE_THROW (CORBA::UNKNOWN ());

  this->naming_context_ =
    CosNaming::NamingContext::_narrow (naming_obj.in () ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
}

void
BasicLog_Test::resolve_basic_factory (ACE_ENV_SINGLE_ARG_DECL)
{
  CosNaming::Name name (1);
  name.length (1);
  name[0].id = CORBA::string_dup (basic_log_factory_name_);

  CORBA::Object_var obj =
    this->naming_context_->resolve (name ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;

  this->factory_ =
    DsLogAdmin::BasicLogFactory::_narrow (obj.in () ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
}

void
BasicLog_Test::destroy_log()
{
  ACE_TRY_NEW_ENV
    {
      if (!CORBA::is_nil(basicLog_.in ()))
        {
          basicLog_->destroy (ACE_ENV_SINGLE_ARG_PARAMETER);
          ACE_TRY_CHECK;

          basicLog_ = DsLogAdmin::BasicLog::_nil ();
        }
    }
  ACE_CATCHANY
    {
      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, "Destroying log");
    }
  ACE_ENDTRY;
}

int BasicLog_Test::test_log_destroy (void)
{

  ACE_DEBUG ((LM_ERROR, "Testing destroy log\n"));
  this->basicLog_->destroy ();

  ACE_TRY_NEW_ENV
    {
      this->write_records (1 ACE_ENV_ARG_PARAMETER);
      ACE_TRY_CHECK;
      ACE_DEBUG ((LM_INFO, "Wrote to log\n"));
    }
  ACE_CATCHANY
    {
      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, "Destroying log");
      ACE_DEBUG ((LM_ERROR,
                  "Test of destroy log succeeded and caught exception.\n"));
      return 0;
    }
  ACE_ENDTRY;
  ACE_ERROR_RETURN ((LM_ERROR,
                     "Test of destroy log failed and no exception thrown.\n"),
                    -1);
}

int
BasicLog_Test::test_week_mask (void)
{
  DsLogAdmin::WeekMask masks;
  masks.length (1);

  masks[0].days =
    DsLogAdmin::Monday
    | DsLogAdmin::Tuesday
    | DsLogAdmin::Wednesday
    | DsLogAdmin::Friday
    | DsLogAdmin::Saturday;

  masks[0].intervals.length(1);

  masks[0].intervals[0].start.hour = (CORBA::Short) 13;

  masks[0].intervals[0].start.minute = (CORBA::Short) 30;
  masks[0].intervals[0].stop.hour = (CORBA::Short) 14;
  masks[0].intervals[0].stop.minute = (CORBA::Short) 30;

  this->basicLog_->set_week_mask (masks);

  return 0;
}


int BasicLog_Test::delete_records (CORBA::ULongLong /* numberOfRecords */)
{
  ACE_DECLARE_NEW_CORBA_ENV;

#ifndef ACE_LACKS_LONGLONG_T
  ACE_DEBUG ((LM_INFO,
              " before delete -- curr size %Q, max %Q\n",
              basicLog_->get_current_size (),
              basicLog_->get_max_size()));
#else
  ACE_DEBUG ((LM_DEBUG,
              "2ndThe current size %u , max size %u\n",
              basicLog_->get_current_size().lo(),
              basicLog_->get_max_size().lo()));
#endif

  CORBA::ULongLong nrecords = basicLog_->get_n_records ();

  ACE_DEBUG ((LM_ERROR,
              "The number of records was %d\n",
              ACE_U64_TO_U32 (nrecords)));

  CORBA::Long retVal =
    basicLog_->delete_records ("TCL", "id >= 0" ACE_ENV_ARG_PARAMETER);

  ACE_DEBUG ((LM_DEBUG,
              "Number of records in Log after delete = %d\n",
              retVal));

#ifndef ACE_LACKS_LONGLONG_T
  ACE_DEBUG ((LM_INFO,
              " after delete -- curr size %Q, max %Q\n",
              basicLog_->get_current_size (),
              basicLog_->get_max_size ()));
#else
  ACE_DEBUG ((LM_DEBUG,
              "2ndThe current size %u , max size %u\n",
              basicLog_->get_current_size ().lo (),
              basicLog_->get_max_size ().lo ()));
#endif

  nrecords = basicLog_->get_n_records ();

  ACE_DEBUG ((LM_ERROR,
              "The number of records is %d\n",
              ACE_U64_TO_U32 (nrecords)));

return 0;
}

int
BasicLog_Test::test_capacity_alarm_threshold (void)
{

  //basicLog_->set_log_full_action(DsLogAdmin::halt);

  DsLogAdmin::CapacityAlarmThresholdList list;
  list.length(0);

  basicLog_->set_capacity_alarm_thresholds (list);

  ACE_DECLARE_NEW_CORBA_ENV;

  list.length (1);
  list[0] = 200;

  ACE_TRY
    {
      basicLog_->set_capacity_alarm_thresholds (list);
      ACE_TRY_CHECK;
      ACE_ERROR_RETURN ((LM_ERROR,
                         "Setting an invalid alarm threshold failed.  "
                         "DsLogAdmin::InvalidThreshold not thrown.\n"),
                        -1);
    }
  ACE_CATCH(DsLogAdmin::InvalidThreshold, xParam)
    {
      ACE_DEBUG ((LM_DEBUG,
                  "Setting an invalid alarm threshold succeeded.  "
                  "DsLogAdmin::InvalidThreshold caught.\n"));
    }
  ACE_ENDTRY;

  list.length (2);
  list[0] = 70;
  list[1] = 20;

  ACE_TRY_EX(SECOND)
    {
      basicLog_->set_capacity_alarm_thresholds (list);
      ACE_TRY_CHECK_EX (SECOND);
      ACE_ERROR_RETURN ((LM_ERROR,
                         "Setting an invalid alarm threshold failed.  "
                         "DsLogAdmin::InvalidThreshold not thrown.\n"),
                       -1);
    }
  ACE_CATCH(DsLogAdmin::InvalidThreshold, xParam)
    {
      ACE_DEBUG ((LM_DEBUG,
                  "Setting an invalid alarm threshold succeeded.  "
                  "DsLogAdmin::InvalidThreshold caught.\n"));
    }
  ACE_ENDTRY;

  list.length (2);
  list[0] = 20;
  list[1] = 70;

  basicLog_->set_capacity_alarm_thresholds (list);

  CORBA::ULongLong nrecords = basicLog_->get_n_records();

  ACE_DEBUG ((LM_ERROR,
              "The number of records is %d\n",
              ACE_U64_TO_U32(nrecords)));

  this->write_records (0 ACE_ENV_ARG_PARAMETER);

  return 0;

}