test/RandomNArray/EPTF_RNA_Test.ttcn

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// Copyright (c) 2000-2019 Ericsson Telecom AB                               //
//                                                                           //
// All rights reserved. This program and the accompanying materials          //
// are made available under the terms of the Eclipse Public License v2.0     //
// which accompanies this distribution, and is available at                  //
// https://www.eclipse.org/org/documents/epl-2.0/EPL-2.0.html                                 //
///////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////
// Module: EPTF_RNA_Test
//
// Purpose:
//   This module contains the tests of Random N Array
//
//  Module depends on:
//    <EPTF_CLL_RNA_Functions>
//    <EPTF_CLL_RNA_Definitions>
//
// Current Owner:
//   Bence Molnar (EBENMOL)
//
// Last Review Date:
//   2009-02-20
//
///////////////////////////////////////////////////////////

module EPTF_RNA_Test
{

import from EPTF_CLL_RNA_Functions all;
import from EPTF_CLL_RNA_Definitions all

type component PCOComp {}

////////////////////////////////////////////////////////////
// tc_getlist_RNA()
////////////////////////////////////////////////////////////
testcase tc_getlist_RNA() runs on PCOComp system PCOComp {

  var integer vl_idx; 
  var EPTF_RNA_RandomNArray pl_RNA := c_EPTF_RNA_emptyRandomNArray;

  f_EPTF_RNA_initRNA(10,2,pl_RNA);
  log("The RNA: ",pl_RNA);

  vl_idx := f_EPTF_RNA_getList(5,pl_RNA); // good elementIdx
  log("ElementIdx 5 is in list Nr:",vl_idx)
  if(vl_idx==0) { 
    setverdict(pass); 
  } else {
    setverdict(fail);   
  }
  vl_idx := f_EPTF_RNA_getList(11,pl_RNA);  // bad elementIdx
  log("ElementIdx 11 is not in list. Returned:", vl_idx);
  if(vl_idx==-1) { 
    setverdict(pass); 
  } else {
    setverdict(fail);   
  }  
}

////////////////////////////////////////////////////////////
// tc_itemIsFree_RFBA()
////////////////////////////////////////////////////////////
testcase tc_itemIsFree_RFBA() runs on PCOComp system PCOComp {

  var boolean vl_result;
  var integer vl_length;
  var EPTF_RNA_RandomNArray pl_RFBA := c_EPTF_RNA_emptyRandomNArray;
  
  f_EPTF_RNA_initRFBA(10,pl_RFBA);
  log("The RFBA: ",pl_RFBA);

  vl_result := f_EPTF_RNA_itemIsFree(5,pl_RFBA); //good elementIdx
  if(not(vl_result)) {
    setverdict(fail);   
  } else {
    setverdict(pass); 
  }
  
  vl_result := f_EPTF_RNA_moveFromFreeToBusySlot(5,pl_RFBA);// creating 1 busy slot
  if(not(vl_result)) {setverdict(fail);} 

  vl_result := f_EPTF_RNA_itemIsFree(5,pl_RFBA); //bad elementIdx
  if(vl_result) {
    setverdict(fail);  
  } else {
    setverdict(pass); 
  }

  vl_result := f_EPTF_RNA_itemIsFree(10,pl_RFBA); //elementIdx not in list
  if(vl_result) {
    setverdict(fail);  
  } else {
    setverdict(pass); 
  }  
    
}

////////////////////////////////////////////////////////////
// tc_itemIsBusy_RFBA()
////////////////////////////////////////////////////////////
testcase tc_itemIsBusy_RFBA() runs on PCOComp system PCOComp {

  var boolean vl_result;
  var integer vl_length;
  var EPTF_RNA_RandomNArray pl_RFBA := c_EPTF_RNA_emptyRandomNArray;
  
  f_EPTF_RNA_initRFBA(10,pl_RFBA);
  log("The RFBA: ",pl_RFBA);

  vl_result := f_EPTF_RNA_itemIsBusy(5,pl_RFBA); //bad elementIdx
  if(vl_result) {
    setverdict(fail);   
  } else {
    setverdict(pass); 
  }

  vl_result := f_EPTF_RNA_moveFromFreeToBusySlot(5,pl_RFBA);// creating 1 busy slot
  if(not(vl_result)) {setverdict(fail);} 

  vl_result := f_EPTF_RNA_itemIsBusy(5,pl_RFBA); //good elementIdx
  if(not(vl_result)) {
    setverdict(fail);  
  } else {
    setverdict(pass); 
  }
  
  vl_result := f_EPTF_RNA_itemIsBusy(10,pl_RFBA); //elementIdx not in list
  if(vl_result) {
    setverdict(fail);   
  } else {
    setverdict(pass); 
  }    
}


////////////////////////////////////////////////////////////
// tc_getLengthOfList_RNA()
////////////////////////////////////////////////////////////
testcase tc_getLengthOfList_RNA() runs on PCOComp system PCOComp {

  var integer vl_length;
  var EPTF_RNA_RandomNArray pl_RNA := c_EPTF_RNA_emptyRandomNArray;  
  
  f_EPTF_RNA_initRNA(10,2,pl_RNA);
  log("The RNA: ",pl_RNA);

  vl_length := f_EPTF_RNA_getLengthOfList(0,pl_RNA); // good list
  log("Length of list Nr 0 is:",vl_length);  
  if(vl_length==10) { 
    setverdict(pass); 
  } else {
    setverdict(fail);   
  }
  vl_length := f_EPTF_RNA_getLengthOfList(2,pl_RNA); // bad list
  log("List Nr 2 not exists. Returned:", vl_length);
  if(vl_length==-1) { 
    setverdict(pass); 
  } else {
    setverdict(fail);   
  }  
}

////////////////////////////////////////////////////////////
// tc_getLengthOfFreeList_RFBA()
////////////////////////////////////////////////////////////
testcase tc_getLengthOfFreeList_RFBA() runs on PCOComp system PCOComp {

  var integer vl_length;
  var EPTF_RNA_RandomNArray pl_RFBA := c_EPTF_RNA_emptyRandomNArray;
  
  f_EPTF_RNA_initRFBA(0,pl_RFBA);
  log("The RFBA: ",pl_RFBA);

  vl_length := f_EPTF_RNA_getLengthOfFreeList(pl_RFBA); // list with 0 element
  log("Length of free list is:",vl_length);  
  if(vl_length==0) { 
    setverdict(pass); 
  } else {
    setverdict(fail);   
  }
  f_EPTF_RNA_createFreeSlots(10,pl_RFBA);  // creating 10 slots  
  vl_length := f_EPTF_RNA_getLengthOfFreeList(pl_RFBA); // list with 10 element
  log("Length of free list is:", vl_length);
  if(vl_length==10) { 
    setverdict(pass); 
  } else {
    setverdict(fail);   
  }  
}

////////////////////////////////////////////////////////////
// tc_getLengthOfBusyList_RFBA()
////////////////////////////////////////////////////////////
testcase tc_getLengthOfBusyList_RFBA() runs on PCOComp system PCOComp {

  var boolean vl_result;
  var integer vl_length;
  var EPTF_RNA_RandomNArray pl_RFBA := c_EPTF_RNA_emptyRandomNArray;
  
  f_EPTF_RNA_initRFBA(10,pl_RFBA);
  log("The RFBA: ",pl_RFBA);

  vl_length := f_EPTF_RNA_getLengthOfBusyList(pl_RFBA); // list with 0 element
  log("Length of busy list is:",vl_length);   
  if(vl_length==0) { 
    setverdict(pass); 
  } else {
    setverdict(fail);   
  }

  for ( var integer vl_i := 0; vl_i < 10 ; vl_i := vl_i+1 )
  {   
    vl_result := f_EPTF_RNA_moveFromFreeToBusySlot(vl_i,pl_RFBA);// creating 10 slots 
    if(not(vl_result)) {setverdict(fail);}  
  } 

  vl_length := f_EPTF_RNA_getLengthOfBusyList(pl_RFBA); // list with 10 element
  log("Length of busy list is:",vl_length);
  if(vl_length==10) { 
    setverdict(pass); 
  } else {
    setverdict(fail);   
  }  
}

////////////////////////////////////////////////////////////
// tc_moveSlot_RNA()
////////////////////////////////////////////////////////////
testcase tc_moveSlot_RNA() runs on PCOComp system PCOComp {

  var boolean vl_result;
  var integer vl_length;    
  var EPTF_RNA_RandomNArray pl_RNA := c_EPTF_RNA_emptyRandomNArray;

  f_EPTF_RNA_initRNA(10,2,pl_RNA);
  log("The RNA before the modifications: ",pl_RNA);

  vl_result := f_EPTF_RNA_moveSlot(5,1,pl_RNA);
  if(not(vl_result)) {setverdict(fail);}  
  vl_result := f_EPTF_RNA_moveSlot(6,1,pl_RNA);
  if(not(vl_result)) {setverdict(fail);} 
  vl_result := f_EPTF_RNA_moveSlot(5,0,pl_RNA);  
  if(not(vl_result)) {setverdict(fail);}
  
  vl_result := f_EPTF_RNA_moveSlot(5,0,pl_RNA); // move the same again 
  if(vl_result) {setverdict(fail);}
  
  vl_result := f_EPTF_RNA_moveSlot(5,4,pl_RNA);  // move to a non existent list  
  if(vl_result) {setverdict(fail);}  

  vl_length := f_EPTF_RNA_getLengthOfList(0,pl_RNA); // checking length of list 0  
  if(vl_length==9) { 
    setverdict(pass); 
  } else {
    setverdict(fail);   
  }
  vl_length := f_EPTF_RNA_getLengthOfList(1,pl_RNA); // checking length of list 1  
  if(vl_length==1) { 
    setverdict(pass); 
  } else {
    setverdict(fail);   
  }  
      
  log("The RNA after the modifications: ",pl_RNA);  
  setverdict(pass);
}


////////////////////////////////////////////////////////////
// tc_moveSlot_RFBA()
////////////////////////////////////////////////////////////
testcase tc_moveSlot_RFBA() runs on PCOComp system PCOComp {

  var boolean vl_result;
  var integer vl_length;     
  var EPTF_RNA_RandomNArray pl_RFBA := c_EPTF_RNA_emptyRandomNArray;

  f_EPTF_RNA_initRFBA(10,pl_RFBA);
  log("The RFBA before the modifications: ",pl_RFBA);

  vl_result := f_EPTF_RNA_moveFromFreeToBusySlot(5,pl_RFBA);
  if(not(vl_result)) {setverdict(fail);}  
  vl_result := f_EPTF_RNA_moveFromFreeToBusySlot(6,pl_RFBA);
  if(not(vl_result)) {setverdict(fail);}  
  vl_result := f_EPTF_RNA_moveFromBusyToFreeSlot(5,pl_RFBA);  
  if(not(vl_result)) {setverdict(fail);}
  vl_result := f_EPTF_RNA_moveFromFreeToBusySlot(9,pl_RFBA);
  if(not(vl_result)) {setverdict(fail);}
  
  vl_result := f_EPTF_RNA_moveFromFreeToBusySlot(9,pl_RFBA) // move the same again 
  if(vl_result) {setverdict(fail);} 

  vl_length := f_EPTF_RNA_getLengthOfList(0,pl_RFBA); // checking length of free list 
  if(vl_length==8) { 
    setverdict(pass); 
  } else {
    setverdict(fail);   
  }
  vl_length := f_EPTF_RNA_getLengthOfList(1,pl_RFBA); // checking length of busy list 
  if(vl_length==2) { 
    setverdict(pass); 
  } else {
    setverdict(fail);   
  }  
     
  log("The RFBA after the modifications: ",pl_RFBA);  
  setverdict(pass);
}

////////////////////////////////////////////////////////////
// tc_getRndSlot_RNA()
////////////////////////////////////////////////////////////
testcase tc_getRndSlot_RNA() runs on PCOComp system PCOComp {

  var integer vl_elementIdx;    
  var EPTF_RNA_RandomNArray pl_RNA := c_EPTF_RNA_emptyRandomNArray;

  f_EPTF_RNA_initRNA(10,2,pl_RNA);
  log("The RNA before the modifications: ",pl_RNA);

  vl_elementIdx := f_EPTF_RNA_getRndSlot(1,pl_RNA); // get slot from list with no elements
  if(vl_elementIdx==-1) { 
    setverdict(pass); 
  } else {
    setverdict(fail);   
  }  

  vl_elementIdx := f_EPTF_RNA_getRndSlot(2,pl_RNA); // get slot from a non existent list
  if(vl_elementIdx==-1) { 
    setverdict(pass); 
  } else {
    setverdict(fail);   
  }  

  for ( var integer vl_i := 0; vl_i < 100 ; vl_i := vl_i+1 )
  { 
    vl_elementIdx := f_EPTF_RNA_getRndSlot(0,pl_RNA);  // get slot 100 times
  }
 
  setverdict(pass);
}

////////////////////////////////////////////////////////////
// tc_getRndSlot_RFBA()
////////////////////////////////////////////////////////////
testcase tc_getRndSlot_RFBA() runs on PCOComp system PCOComp {

  var integer vl_elementIdx;    
  var EPTF_RNA_RandomNArray pl_RFBA := c_EPTF_RNA_emptyRandomNArray;

  f_EPTF_RNA_initRFBA(10,pl_RFBA);
  log("The RFBA before the modifications: ",pl_RFBA); 

  for ( var integer vl_i := 0; vl_i < 100 ; vl_i := vl_i+1 )
  { 
    vl_elementIdx := f_EPTF_RNA_getRndFreeSlot(pl_RFBA);  // get slot 100 times
  }
 
  setverdict(pass);
}

////////////////////////////////////////////////////////////
// tc_createSlots_RNA()
////////////////////////////////////////////////////////////
testcase tc_createSlots_RNA() runs on PCOComp system PCOComp {

  var boolean vl_result;
  var integer vl_length;        
  var EPTF_RNA_RandomNArray pl_RNA := c_EPTF_RNA_emptyRandomNArray;

  f_EPTF_RNA_initRNA(10,2,pl_RNA);
  log("The RNA before the modifications: ",pl_RNA);

  vl_result := f_EPTF_RNA_createSlots(0,0,pl_RNA);  // creating 0 slots
  if(vl_result) {setverdict(fail);}

  vl_result := f_EPTF_RNA_createSlots(10,2,pl_RNA);  // creating slots to a non existent list
  if(vl_result) {setverdict(fail);}


  vl_result := f_EPTF_RNA_createSlots(10,0,pl_RNA);  // creating 10 slots to list 0
  if(not(vl_result)) {setverdict(fail);}
  vl_result := f_EPTF_RNA_createSlots(10,1,pl_RNA);  // creating 10 slots to list 1
  if(not(vl_result)) {setverdict(fail);}

  vl_length := f_EPTF_RNA_getLengthOfList(0,pl_RNA); // checking length of list 0  
  if(vl_length==20) { 
    setverdict(pass); 
  } else {
    setverdict(fail);   
  }
  vl_length := f_EPTF_RNA_getLengthOfList(1,pl_RNA); // checking length of list 1  
  if(vl_length==10) { 
    setverdict(pass); 
  } else {
    setverdict(fail);   
  }  
      
  log("The RNA after the modifications: ",pl_RNA); 
  setverdict(pass);
}

////////////////////////////////////////////////////////////
// tc_createSlots_RFBA()
////////////////////////////////////////////////////////////
testcase tc_createSlots_RFBA() runs on PCOComp system PCOComp {

  var boolean vl_result;
  var integer vl_length;        
  var EPTF_RNA_RandomNArray pl_RFBA := c_EPTF_RNA_emptyRandomNArray;

  f_EPTF_RNA_initRFBA(10,pl_RFBA);
  log("The RFBA before the modifications: ",pl_RFBA);

  vl_result := f_EPTF_RNA_createFreeSlots(0,pl_RFBA);  // creating 0 slots
  if(vl_result) {setverdict(fail);}


  vl_result := f_EPTF_RNA_createFreeSlots(10,pl_RFBA);  // creating 10 slots
  if(not(vl_result)) {setverdict(fail);}

  vl_length := f_EPTF_RNA_getLengthOfList(0,pl_RFBA); // checking length of free list 
  if(vl_length==20) { 
    setverdict(pass); 
  } else {
    setverdict(fail);   
  }
      
  log("The RFBA after the modifications: ",pl_RFBA); 
  setverdict(pass);
}

////////////////////////////////////////////////////////////
// tc_getRndOrCreateSlot_RNA()
////////////////////////////////////////////////////////////
testcase tc_getRndOrCreateSlot_RNA() runs on PCOComp system PCOComp {

  var integer vl_elementIdx;
  var integer vl_length;      
  var EPTF_RNA_RandomNArray pl_RNA := c_EPTF_RNA_emptyRandomNArray;

  f_EPTF_RNA_initRNA(10,2,pl_RNA);
  log("The RNA before the modifications: ",pl_RNA);

  vl_elementIdx := f_EPTF_RNA_getRndOrCreateSlot(2,pl_RNA); // get slot from a non existent list
  if(vl_elementIdx==-1) { 
    setverdict(pass); 
  } else {
    setverdict(fail);   
  }

  vl_elementIdx := f_EPTF_RNA_getRndOrCreateSlot(0,pl_RNA); // get slot from list with 10 elements
  if(vl_elementIdx>-1) { 
    setverdict(pass); 
  } else {
    setverdict(fail);   
  }  

  vl_elementIdx := f_EPTF_RNA_getRndOrCreateSlot(1,pl_RNA); // get slot from list with 0 elements
  if(vl_elementIdx>-1) { 
    setverdict(pass); 
  } else {
    setverdict(fail);   
  }
  vl_length := f_EPTF_RNA_getLengthOfList(1,pl_RNA); // checking length of list 1  
  if(vl_length==1) { 
    setverdict(pass); 
  } else {
    setverdict(fail);   
  }
 
  setverdict(pass);
}

////////////////////////////////////////////////////////////
// tc_getRndOrCreateSlot_RFBA()
////////////////////////////////////////////////////////////
testcase tc_getRndOrCreateSlot_RFBA() runs on PCOComp system PCOComp {

  var integer vl_elementIdx;
  var integer vl_length;      
  var EPTF_RNA_RandomNArray pl_RFBA := c_EPTF_RNA_emptyRandomNArray;

  f_EPTF_RNA_initRFBA(0,pl_RFBA);
  log("The RFBA before the modifications: ",pl_RFBA); 

  vl_elementIdx := f_EPTF_RNA_getRndOrCreateFreeSlot(pl_RFBA); // get slot from free list
  if(vl_elementIdx>-1) { 
    setverdict(pass); 
  } else {
    setverdict(fail);   
  }
  vl_length := f_EPTF_RNA_getLengthOfList(0,pl_RFBA); // checking length of free list  
  if(vl_length==1) { 
    setverdict(pass); 
  } else {
    setverdict(fail);   
  }

  vl_elementIdx := f_EPTF_RNA_getRndOrCreateFreeSlot(pl_RFBA); // get slot from free list
  if(vl_elementIdx>-1) { 
    setverdict(pass); 
  } else {
    setverdict(fail);   
  }
 
  setverdict(pass);
}

////////////////////////////////////////////////////////////
// control section
////////////////////////////////////////////////////////////

control{
  execute(tc_getlist_RNA());
  execute(tc_itemIsFree_RFBA());  
  execute(tc_itemIsBusy_RFBA());
 
  execute(tc_getLengthOfList_RNA());
  execute(tc_getLengthOfFreeList_RFBA());
  execute(tc_getLengthOfBusyList_RFBA());  
    
  execute(tc_moveSlot_RNA());
  execute(tc_moveSlot_RFBA());  

  execute(tc_getRndSlot_RNA());
  execute(tc_getRndSlot_RFBA()); 

  execute(tc_createSlots_RNA());
  execute(tc_createSlots_RFBA());

  execute(tc_getRndOrCreateSlot_RNA());
  execute(tc_getRndOrCreateSlot_RFBA());
 
} 

}  // end of module