simple-test.cc

MICO2.3.13 corba 环境平台

  assert (!CORBA::is_nil (text));
  assert (!CORBA::is_nil (obr1));
  assert (!CORBA::is_nil (obr2));
  assert (!CORBA::is_nil (obr3));
  assert (strcmp (text->file (), "thesis.tex") == 0);
  cout << "Checking NodeFactory::create_node () ..." << flush;
  CosCompoundExternalization::Node_var node_text = CosCompoundExternalization::Node::_narrow(node_factory->create_node (text));
  if (!CORBA::is_nil (node_text))
    cout << "ok.\n";
  else
    cout << "error.\n";

  cout << "Checking Node::related_object () ..." << flush;
  exception = FALSE;
  try {
    node_text->related_object ();
    node_text->related_object ();
    if (!CORBA::is_nil (node_text->related_object ()))
      if (Documents::Text::_narrow (node_text->related_object ()))
	if ((Documents::Text::_narrow (node_text->related_object ()))
	    ->name () != NULL)
	  cout << "ok.\n";
  } catch (CORBA::SystemException& e) {
    cout << "failed.\n";
  } catch (CORBA::UserException& e) {
    cout << "error.\n";
  }
  
  cout << "Checking Node::add_role () ..." << flush;
  CosCompoundExternalization::Node_var node_obr1;   
  CosCompoundExternalization::Node_var node_obr2;
  CosCompoundExternalization::Node_var node_obr3;
  CosCompoundExternalization::Node_var node_obr4;
  CosCompoundExternalization::Node_var node_obr5;

  try {
    node_obr1 = CosCompoundExternalization::Node::_narrow(node_factory->create_node (obr1));
    node_obr2 = CosCompoundExternalization::Node::_narrow(node_factory->create_node (obr2));
    node_obr3 = CosCompoundExternalization::Node::_narrow(node_factory->create_node (obr3));
    node_obr4 = CosCompoundExternalization::Node::_narrow(node_factory->create_node (obr4));
    node_obr5 = CosCompoundExternalization::Node::_narrow(node_factory->create_node (obr5));
  } catch (::CORBA::Exception& e) {
    cout << "can't create nodes!!! " << flush;
  }
  CosCompoundExternalization::Role_var contains;
  CosCompoundExternalization::Role_var containedin1;
  CosCompoundExternalization::Role_var containedin2;
  CosCompoundExternalization::Role_var containedin3;
  CosCompoundExternalization::Role_var contains_obr1;
  CosCompoundExternalization::Role_var containedin4;
  CosCompoundExternalization::Role_var containedin5;
  
  try {
    contains = CosCompoundExternalization::Role::_narrow 
      (contains_factory->create_role (node_text));
    containedin1 = CosCompoundExternalization::Role::_narrow
      (containedin_factory->create_role (node_obr1));
    containedin2 = CosCompoundExternalization::Role::_narrow
      (containedin_factory->create_role (node_obr2));
    containedin3 = CosCompoundExternalization::Role::_narrow
      (containedin_factory->create_role (node_obr3));
    contains_obr1 = CosCompoundExternalization::Role::_narrow 
      (contains_factory->create_role (node_obr1));
    containedin4 = CosCompoundExternalization::Role::_narrow
      (containedin_factory->create_role (node_obr4));
    containedin5 = CosCompoundExternalization::Role::_narrow
      (containedin_factory->create_role (node_obr5));


  } catch (CosRelationships::RoleFactory::NilRelatedObject& e) {
    cout << "can't create roles - nil related object\n";
  } catch (CosRelationships::RoleFactory::RelatedObjectTypeError& e) {
    cout << "can't create roles - related object type error\n";
  } catch (::CORBA::SystemException& e) {
    cout << "can't create roles!!! system exception\n" << flush;
  }
    

  assert (!CORBA::is_nil (contains));
  exception = FALSE;
  try {
    node_text->add_role (contains);
  } catch (::CORBA::SystemException& e) {
    exception = TRUE;
  }
  if (node_text->roles_of_node ()->length () == 1 && !exception)
    cout << "ok.\n";
  else
    cout << "error.\n";


  cout << "Checking Node::roles_of_node () ..." << flush;
  exception = FALSE;
  CosGraphs::Node::Roles_var node_roles;
  try {
    node_roles = node_text->roles_of_node ();
    node_roles = node_text->roles_of_node ();
    node_roles = node_text->roles_of_node ();
  } catch (CORBA::SystemException& e) {
    exception = TRUE;
  }
  if (node_roles->length () == 1 && !exception)
    cout << "ok.\n";
  else
    cout << "error.\n"; 


  cout << "Checking Node::remove_role () ..." << flush;
  try {
    ::CORBA::InterfaceDef_var type = contains->_get_interface ();
    node_text->remove_role (type);
  } catch (CORBA::SystemException& e) {
    cout << "system exception\n";
  } catch (CORBA::UserException& e) {
    exception = TRUE;
  }
  if (node_text->roles_of_node ()->length () == 0 && !exception)
    cout << "ok.\n";
  else
    cout << "error.\n";

  assert (!CORBA::is_nil (node_text));

  cout << "Checking Node::roles_of_type () ..." << flush;

  // in this time is role_of_types buggy

  exception = FALSE;
  Test::BaseRole_ptr base_role = Test::BaseRole::_narrow 
    (base_factory->create_role (node_text));
  CORBA::InterfaceDef_var base_role_type = base_role->_get_interface ();

  Test::DerivedRole1_ptr derived1_role = Test::DerivedRole1::_narrow 
    (derived_factory1->create_role (node_text));
  CORBA::InterfaceDef_var derived1_role_type 
    = derived1_role->_get_interface ();

  Test::DerivedRole2_ptr derived2_role = Test::DerivedRole2::_narrow 
    (derived_factory2->create_role (node_text));
  CORBA::InterfaceDef_var derived2_role_type 
    = derived2_role->_get_interface ();

  state_good = TRUE;
  exception = FALSE;
  exception2 = FALSE;
  try {
    node_text->add_role (derived1_role);
    node_text->add_role (derived2_role);
    node_roles = node_text->roles_of_type (derived1_role_type);
    if (node_roles->length () == 1 
	&& (!CORBA::is_nil (Test::DerivedRole1::_narrow ((*node_roles)[0]))))
      state_good = TRUE;
    else
      state_good = FALSE;
    
    if (state_good) {
      node_roles = node_text->roles_of_type (derived2_role_type);
      if (node_roles->length () == 1 
	  && (Test::DerivedRole2::_narrow ((*node_roles)[0])))
	state_good = TRUE;
      else
	state_good = FALSE;
    }
    if (state_good) {
      node_roles = node_text->roles_of_type (base_role_type);
      if (node_roles->length () == 2)
	state_good = TRUE;
      else
	state_good = FALSE;
    }
    // cleaning up
    node_text->remove_role (base_role_type);

  } catch (CORBA::SystemException& e) {
    exception = TRUE;
  } catch (CORBA::UserException& e) {
    exception2 = TRUE;
  }
  
  if (state_good && !exception2 && !exception)
    cout << "ok.\n";
  if (!state_good)
    cout << "failed.\n";
  if (exception)
    cout << "failed2.\n";
  if (exception2)
    cout << "error.\n";
  

  cout << "Checking Node::DuplicateRoleType exception ..." << flush;
  exception = FALSE;
  try {
    node_text->add_role (contains);
    node_text->add_role (contains);
  } catch (CosGraphs::Node::DuplicateRoleType& e) {
    exception = TRUE;
  }
  if (exception)
    cout << "ok.\n";
  else
    cout << "error.\n";

  
  cout << "Checking Node::NoSuchRole exception ..." << flush;
  exception = FALSE;
  exception2 = FALSE;
  exception3 = FALSE;
  try {
    CORBA::InterfaceDef_var type = containedin1->_get_interface ();
    node_text->remove_role (type);
  } catch (CORBA::SystemException& e) {
    cout << "system exception\n";
  } catch (CosGraphs::Node::NoSuchRole& e) {
    exception = TRUE;
  }
  try {
    CORBA::InterfaceDef_var type = contains->_get_interface ();
    node_text->remove_role (type);
  } catch (CORBA::SystemException& e) {
    cout << "system exception\n";
  } catch (CosGraphs::Node::NoSuchRole& e) {
    exception2 = TRUE;
  }
  try {
    CORBA::InterfaceDef_var type = contains->_get_interface ();
    node_text->remove_role (type);
  } catch (CORBA::SystemException& e) {
    cout << "system exception\n";
  } catch (CosGraphs::Node::NoSuchRole& e) {
    exception3 = TRUE;
  }
    
  if (exception && !exception2 && exception3) 
    cout << "ok.\n";
  else
    cout << "error.\n";


  cout << "Checking Role::get_edges () " << flush;
  assert (node_text->roles_of_node ()->length () == 0);
  node_text->add_role (contains);
  node_obr1->add_role (containedin1);
  node_obr1->add_role (contains_obr1);
  node_obr2->add_role (containedin2);
  node_obr3->add_role (containedin3);
  node_obr4->add_role (containedin4);
  node_obr5->add_role (containedin5);
  
  cout << "." << flush;
  nr.length (2);
  nr[0].name = CORBA::string_dup ("ExternalizationContainsRole");
  nr[1].name = CORBA::string_dup ("ExternalizationContainedInRole");

  nr[0].aRole = CosCompoundExternalization::Role::_duplicate (contains);
  nr[1].aRole = CosCompoundExternalization::Role::_duplicate (containedin3);
  CosExternalizationContainment::Relationship_ptr containment3 
    = CosExternalizationContainment::Relationship::_narrow (containment_factory->create (nr));
  cout << "." << flush;

  nr[0].aRole = CosCompoundExternalization::Role::_duplicate (contains);
  nr[1].aRole = CosCompoundExternalization::Role::_duplicate (containedin1);
  CosExternalizationContainment::Relationship_ptr containment1 
    = CosExternalizationContainment::Relationship::_narrow (containment_factory->create (nr));
  cout << "." << flush;

  nr[0].aRole = CosCompoundExternalization::Role::_duplicate (contains);
  nr[1].aRole = CosCompoundExternalization::Role::_duplicate (containedin2);
  CosExternalizationContainment::Relationship_ptr containment2 
    = CosExternalizationContainment::Relationship::_narrow (containment_factory->create (nr));
  cout << "." << flush;


  nr[0].aRole = CosCompoundExternalization::Role::_duplicate (contains_obr1);
  nr[1].aRole = CosCompoundExternalization::Role::_duplicate (containedin4);
  CosExternalizationContainment::Relationship_ptr containment4 
    = CosExternalizationContainment::Relationship::_narrow (containment_factory->create (nr));
  cout << "." << flush;

  nr[0].aRole = CosCompoundExternalization::Role::_duplicate (contains_obr1);
  nr[1].aRole = CosCompoundExternalization::Role::_duplicate (containedin5);
  CosExternalizationContainment::Relationship_ptr containment5 
    = CosExternalizationContainment::Relationship::_narrow (containment_factory->create (nr));
  cout << "." << flush;

  state_good = true;
  CosGraphs::Edges* edges;
  CosGraphs::EdgeIterator_ptr edge_iterator;
  contains->get_edges (1, edges, edge_iterator);

  Documents::Text_ptr tmp_text 
    = Documents::Text::_narrow 
    (CosCompoundExternalization::Node::_narrow ((*edges)[0].from.the_role.the_role
			       ->related_object ())->related_object ()); 
  if (strcmp (tmp_text->name (), text->name ()) != 0)
    state_good = false;
  Documents::Figure_ptr tmp_obr 
    = Documents::Figure::_narrow 
    (CosCompoundExternalization::Node::_narrow ((*edges)[0].relatives[0].the_role.the_role
			       ->related_object ())->related_object ()); 
  if (strcmp (tmp_obr->name (), obr3->name ()) != 0)
    state_good = false;

  if (CORBA::is_nil (edge_iterator))
    state_good = false;
  else 
    edge_iterator->destroy ();
  if (state_good)
    cout << "ok.\n";
  else
    cout <<"failed.\n";

  cout << "Checking EdgeIterator::next_one () ..." << flush;
  contains->get_edges (1, edges, edge_iterator);
  CosGraphs::Edge* edge;
  if (!CORBA::is_nil (edge_iterator)) {
    edge_iterator->next_one (edge);
    tmp_obr = Documents::Figure::_narrow 
      (CosCompoundExternalization::Node::_narrow (edge->relatives[0].the_role.the_role
				 ->related_object ())->related_object ()); 
    if (strcmp (tmp_obr->name (), obr1->name ()) != 0)
      state_good = false;
    edge_iterator->next_one (edge);
    if (edge_iterator->next_one (edge))
      state_good = false;
  }
  else
    state_good = false;

  edge_iterator->destroy ();

  // for get_edges (0, edges, edge_iterator);
  contains->get_edges (0, edges, edge_iterator);
  if (!CORBA::is_nil (edge_iterator)) {
    edge_iterator->next_one (edge);
    tmp_obr = Documents::Figure::_narrow 
      (CosCompoundExternalization::Node::_narrow (edge->relatives[0].the_role.the_role
			       ->related_object ())->related_object ()); 
    if (strcmp (tmp_obr->name (), obr3->name ()) != 0)
      state_good = false;
    edge_iterator->next_one (edge);
    tmp_obr = Documents::Figure::_narrow 
      (CosCompoundExternalization::Node::_narrow (edge->relatives[0].the_role.the_role
				 ->related_object ())->related_object ()); 
    if (strcmp (tmp_obr->name (), obr1->name ()) != 0)
      state_good = false;
    edge_iterator->next_one (edge);
    if (edge_iterator->next_one (edge))
      state_good = false;

    edge_iterator->destroy ();
  }
  else
    state_good = false;
  
  contains->get_edges (3, edges, edge_iterator);
  if (!CORBA::is_nil (edge_iterator)) {
    if (edge_iterator->next_one (edge))
      state_good = false;

    edge_iterator->destroy ();
  }
  else