TestUnit TestScript Math TRIG.lsl

///////////////////////////////////////////////////////////////////////////////////
///////
///////
///////
///////            TestUnit_TestScript
///////             
///////            Math_TRIG
///////
///////  This is the test script for the trigonometry math functions.  
///////      
///////              
//////////////////////////////////////////////////////////////////////////////////////    

//TestUnit_TestScript    .1 -> initial framework  6.23.2007
//TestUnit_TestScript    .2 -> tested with minor bug fixes  7.2.2007

//Math_TRIG              .1 -> modified from TestUnit_TestScript base to test trig math functions  7.3.2007


//////////////////////////////////////////////////////////////////////////////////////
//
//                  Command Protocol
//
//////////////////////////////////////////////////////////////////////////////////////
//
//////////////////////////////////////////////
//        CHAT commands
//////////////////////////////////////////////
//
//  Chat commands will be on the specified broadcastChannel
//
//////// OUTPUT ///////////
//
// AddUnitReport - send Report update to Coordinator on the chat broadcastChannel
// format example -> AddUnitReport::unitKey::00000-0000-0000-00000::Report::Successful Completion of Test
//
//////////////////////////////////////////////
//        LINK MESSAGE commands
//////////////////////////////////////////////
//
//  link message commands will be sent out on the toAllChannel, and recieved on the passFailChannel
//
//////// INPUT ///////////
//
//  RunTest - activation command to start test
//  format example -> RunTest
//
//  Report - channel and report type
//  format example -> Report::controlChannel::0::reportType::NORMAL
//
//  Reset - rest the scripts 
//  format example -> Reset
//
//////// OUTPUT ///////////
//
//  passFail - status of test sent on passFailChannel
//  format example -> PASS
//
//////////////////////////////////////////////////////////////////////////////////////////


// Global Variables

integer toAllChannel = -255;           // general channel - linked message
integer passFailChannel = -355;        // test scripts channel for cummunicating pass/fail - linked message

integer debug = 0;                     // level of debug message
integer debugChannel = DEBUG_CHANNEL;  // output channel for debug messages


integer llAcosPASS;                    // These are global pass/fail
integer llAsinPASS;                    // indicators for the various
integer llAtan2PASS;                   // Math trig functions that are 
integer llCosPASS;                     // being tested. These variables 
integer llSinPASS;                     // are used in the Run Test and
integer llTanPASS;                     // Report Functions of this script. 


//////////////////////////////////////////////////////////////////////////////////////////////////
//////////
//////////      Function:   ParseCommand
//////////
//////////      Input:      string message - command to be parsed
//////////                    
//////////      Output:     no return value
//////////                    
//////////      Purpose:    This function calls various other functions or sets globals
//////////                    depending on message string. Allows external command calls.
//////////                    
//////////      Issues:        no known issues 
//////////                    
//////////                    
/////////////////////////////////////////////////////////////////////////////////////////////////
ParseCommand(string message)
{
    if(debug > 1)llSay(debugChannel, llGetScriptName()+ "->ParseCommand: " + message);
        
    //reset all scripts 
    if(message == "Reset")
    {
        //reset this script 
        llResetScript();                   
    }
    
    //RunTest()
    else if(message == "RunTest")
    {
        RunTest();
    }

    //Report()
    //Example format -> Report::broadcastChannel::0::reportType::NORMAL
    else if( llSubStringIndex(message, "Report") != -1 )
    {
        //parse the string command into a list
        list reportParameters = llParseString2List( message, ["::"], [""] );
        
        //find the broadcastChannel label and increment by one
        integer tempIndex = llListFindList( reportParameters, ["controlChannel"] ) + 1;
        //pull the broadcastChannel from the list with the index just calculated
        integer controlChannel = llList2Integer( reportParameters , tempIndex);
        
        //find the reportType label and increment by one
        tempIndex = llListFindList( reportParameters, ["reportType"] ) + 1;
        //pull the reportType from the list with the index just calculated
        string reportType = llList2String( reportParameters , tempIndex);
                
        //call the Report function with new parameters
        Report( controlChannel, reportType );
    }
    
    
    
} //end ParseCommand

//////////////////////////////////////////////////////////////////////////////////////////////////
//////////
//////////      Function:   RunTest
//////////
//////////      Input:      no input paramaters
//////////                    
//////////      Output:     link message on passFailChannel test status
//////////                    
//////////      Purpose:    This function is where you put the scripts that you want to test
//////////                  with this unit.
//////////                    
//////////      Issues:        no known issues 
//////////                    
//////////                    
/////////////////////////////////////////////////////////////////////////////////////////////////
RunTest()
{

     ///////////////////////////////////////////////////////////////////////////////////////////
     // Function: float llAcos( float val );
     // Returns a float that is the arccosine in radians of val
     // • float     val     –     val must fall in the range [-1.0, 1.0]. (-1.0 <= val <= 1.0)     
     ///////////////////////////////////////////////////////////////////////////////////////////

     //initialize a pass variable to TRUE 
     llAcosPASS = 0;
          
     //compare known cosine of some angles
     if( (string)3.141593 == (string)llAcos( -1.0 ) &
     		(string)1.570796 == (string)llAcos( 0.0 ) &
     		(string)0.0 == (string)llAcos( 1.0 ) )
     {
         llAcosPASS = 1;    
     }
     
     ///////////////////////////////////////////////////////////////////////////////////////
     // Function: float llAsin( float val );
     // Returns a float that is the arcsine in radians of val
     // • float     val     –     must fall in the range [-1.0, 1.0]. (-1.0 <= val <= 1.0)     
     ////////////////////////////////////////////////////////////////////////////////////////
     
    //initialize a pass variable to TRUE 
    llAsinPASS = 0;
     
     //test four sets of vector configurations to hardcoded values
     if( (string)-1.570796 == (string)llAsin( -1.0) &
     		(string)0.0 == (string)llAsin( 0.0 ) &
     		(string)1.570796 == (string)llAsin( 1.0 ) )
     {
         llAsinPASS = 1; 
     }


     /////////////////////////////////////////////////////////////////////////
     // Function: float llAtan2( float y, float x );
     // Returns a float that is the arctangent2 of y, x.
     // • float     y             
     // • float     x             
     // Similar to the arctangent(y/x) except it utilizes the signs of x & y to 
     // determine the quadrant. Returns zero if x and y are zero. 
     ////////////////////////////////////////////////////////////////////////////////
     
    //initialize a pass variable to TRUE 
    llAtan2PASS = 0;
         
     //test four sets of configurations to hardcoded values
     if( (string)0.0 == (string)llAtan2( 0.0, 0.0) &
     		(string)0.0 ==  (string)llAtan2( 0.0, 1.0 ) &
     		(string)0.785398 == (string)llAtan2( 1.0, 1.0 ) )
     {
         llAtan2PASS = 1; 
     }

     //////////////////////////////////////////////////////////////////////////////
     // Function: float llCos( float theta );
     // Returns a float that is the cosine of theta.
     // • float     theta     –     angle expressed in radians.     
     /////////////////////////////////////////////////////////////////////////////
     
    //initialize a pass variable to TRUE 
    llCosPASS = 0;
       
     //test four sets of configurations to hardcoded values
     if( (string)1.0 == (string)llCos( 0.0 ) &
     		(string)0.540302 ==  (string)llCos( 1.0 ) &
     		(string)0.540302 == (string)llCos( -1.0 ) )
     {
         llCosPASS = 1; 
     }

       ///////////////////////////////////////////////////////////////////////////////////    
       // Function: float llSin( float theta );
       // Returns a float that is the sine of theta.
       // • float     theta     –     angle expressed in radians.     
       //////////////////////////////////////////////////////////////////////////////////   
     
    //initialize a pass variable to TRUE 
    llSinPASS = 0;
       
     //test four sets of configurations to hardcoded values
     if( (string)0.0 == (string)llSin( 0.0 ) &
     		(string)0.841471 ==  (string)llSin( 1.0 ) &
     		(string)-0.841471 == (string)llSin( -1.0 ) )
     {
         llSinPASS = 1; 
     }   
     

     /////////////////////////////////////////////////////////////////////////////////
     // Function: float llTan( float theta );
     // Returns a float that is the tangent of theta.
     // • float     theta     –     angle expressed in radians.
     /////////////////////////////////////////////////////////////////////////////////
     
    //initialize a pass variable to TRUE 
    llTanPASS = 0;
       
     //test four sets of configurations to hardcoded values
     if( (string)0.0 == (string)llTan( 0.0 ) &
     		(string)1.557408 ==  (string)llTan( 1.0 ) &
     		(string)-1.557408 == (string)llTan( -1.0 ) )
     {
         llTanPASS = 1; 
     }

     //check to see if any failures occured. 
     integer pass = llAcosPASS &
                    llAsinPASS &
                    llAtan2PASS &
                    llCosPASS &
                    llSinPASS &
                    llTanPASS;

     // if all of the individual 
     if( pass )
     {
       llMessageLinked(LINK_SET, passFailChannel, "PASS", NULL_KEY);
     }
     else
     {
       llMessageLinked(LINK_SET, passFailChannel, "FAIL", NULL_KEY);
     }
}

//////////////////////////////////////////////////////////////////////////////////////////////////
//////////
//////////      Function:   Report
//////////
//////////      Input:      broadcastChannel - chat channel to send report
//////////                  reportType - determines length and content of report type
//////////                                         -> NORMAL - failures and summary information
//////////                                         -> QUITE - summary information only
//////////                                         -> VERBOSE - everything
//////////                    
//////////      Output:     llSay on broadcastChannel 
//////////                    
//////////      Purpose:    This function is where you design the three level of reports
//////////                  avaliable upon request by the Coordinator
//////////                    
//////////      Issues:        no known issues 
//////////                    
//////////                    
/////////////////////////////////////////////////////////////////////////////////////////////////
Report( integer controlChannel, string reportType )
{
    //this string will be sent out reguardless of reporting mode
    string reportString;
 
    // PASS or FAIL wording for the report
    string llAcosPASSstring = "FAIL";
    string llAsinPASSstring = "FAIL";
    string llAtan2PASSstring = "FAIL";
    string llCosPASSstring = "FAIL";
    string llSinPASSstring = "FAIL";
    string llTanPASSstring = "FAIL";


    
    //translate integer conditional into text string for the report. 
    if ( llAcosPASS )
    {
          llAcosPASSstring = "PASS";
    }
    if ( llAsinPASS )
    {
          llAsinPASSstring = "PASS";
    }
    if ( llAtan2PASS )
    {
          llAtan2PASSstring = "PASS";
    }
    if ( llCosPASS  )
    {
          llCosPASSstring = "PASS";
    }
    if ( llSinPASS )
    {
          llSinPASSstring = "PASS";
    }
    if ( llTanPASS )
    {
          llTanPASSstring = "PASS";
    }
   
    //Normal - moderate level of reporting
    if( reportType == "NORMAL" )
    {
      reportString = "Function: float llAcos( float val ) -> " 
                                                + llAcosPASSstring + "\n"
                   + "Function: float llAsin( float val ) ->" 
                                                + llAsinPASSstring + "\n"
                   + "Function: float llAtan2( float y, float x ) -> " 
                                                + llAtan2PASSstring + "\n"
                   + "Function: float llCos( float theta ) -> " 
                                                + llCosPASSstring + "\n"
                   + "Function: float llSin( float theta ) -> " 
                                                + llSinPASSstring + "\n"
                   + "Function: float llTan( float theta ) -> "
                                                + llTanPASSstring + "\n";
       
    } // end normal   
    
    //VERBOSE - highest level of reporting
    if( reportType == "VERBOSE" )
    {
             reportString = "///////////////////////////////////////////////////////////////////////////////////////////" + "\n"+
             	"// Function: float llAcos( float val );" + "\n" +
				"// Returns a float that is the arccosine in radians of val" + "\n" +
				"// • float     val     –     val must fall in the range [-1.0, 1.0]. (-1.0 <= val <= 1.0)     " + "\n" +
				"///////////////////////////////////////////////////////////////////////////////////////////" + "\n" +
				"PASS/FAIL -> " + llAcosPASSstring + "\n\n" +
     
				"///////////////////////////////////////////////////////////////////////////////////////" + "\n" +
				"// Function: float llAsin( float val );" + "\n" +
				"// Returns a float that is the arcsine in radians of val" + "\n" +
				"// • float     val     –     must fall in the range [-1.0, 1.0]. (-1.0 <= val <= 1.0)     " + "\n" +
				"////////////////////////////////////////////////////////////////////////////////////////" + "\n" +
				"PASS/FAIL -> " + llAsinPASSstring + "\n\n" +
				
				"/////////////////////////////////////////////////////////////////////////" + "\n" +
				"// Function: float llAtan2( float y, float x );" + "\n" +
				"// Returns a float that is the arctangent2 of y, x." + "\n" +
				"// • float     y             " + "\n" +
				"// • float     x             " + "\n" +
				"// Similar to the arctangent(y/x) except it utilizes the signs of x & y to " + "\n" +
				"// determine the quadrant. Returns zero if x and y are zero. " + "\n" +
				"////////////////////////////////////////////////////////////////////////////////" + "\n" +
				"PASS/FAIL -> " + llAtan2PASSstring + "\n\n" +
				     
				"//////////////////////////////////////////////////////////////////////////////" + "\n" +
				"// Function: float llCos( float theta );" + "\n" +
				"// Returns a float that is the cosine of theta." + "\n" +
				"// • float     theta     –     angle expressed in radians.     " + "\n" +
				"/////////////////////////////////////////////////////////////////////////////" + "\n" +
				"PASS/FAIL -> " + llCosPASSstring + "\n\n" +
				
				     
				"///////////////////////////////////////////////////////////////////////////////////" + "\n" +    
				"// Function: float llSin( float theta );" + "\n" +
				"// Returns a float that is the sine of theta." + "\n" +
				"// • float     theta     –     angle expressed in radians.     " + "\n" +
				"//////////////////////////////////////////////////////////////////////////////////" + "\n" +   
				"PASS/FAIL -> " + llSinPASSstring + "\n\n" +
				
				"/////////////////////////////////////////////////////////////////////////////////" + "\n" +
				"// Function: float llTan( float theta );" + "\n" +
				"// Returns a float that is the tangent of theta." + "\n" +
				"// • float     theta     –     angle expressed in radians." + "\n" +
				"/////////////////////////////////////////////////////////////////////////////////" + "\n" +
				"PASS/FAIL -> " + llTanPASSstring + "\n\n";
    
    } // end verbose
        
    //AddUnitReport()
    //send to Coordinator on the broadcastChannel the selected report
    //format example -> AddUnitReport::unitKey::00000-0000-0000-00000::Report::Successful Completion of Test
    llSay( controlChannel, "AddUnitReport::unitKey::" + (string)llGetKey() + "::Report::" + reportString);

}



//////////////////////////////////////////////////////////////////////////////////////////////////
//////////
//////////      Function:   Initialize
//////////
//////////      Input:      no input paramaters
//////////                    
//////////      Output:     no return value
//////////                    
//////////      Purpose:    This function initializes any variables or functions necessary
//////////                  to get us started
//////////                    
//////////      Issues:        no known issues 
//////////                    
//////////                    
/////////////////////////////////////////////////////////////////////////////////////////////////
Initialize()
{
    llSetText( "Math Trig", <255,255,255>, 1);
}


///////////////////////////////////////////////////////////////////////////////////////
//STATE STATE STATE STATE STATE STATE STATE STATE STATE STATE STATE STATE STATE STATE//
///////////////////////////////////////////////////////////////////////////////////////
//                                                                                   //
//                                                                                   //
//                          DEFAULT STATE                                            //
//                                                                                   //
//                                                                                   //
///////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////
default
{
///////////////////////////////////////////////////////
//  State Entry of default state                     //
///////////////////////////////////////////////////////
   state_entry()
    {
        Initialize();
    }
////////////////////////////////////////////////////////
//  On Rez of default state                           //
////////////////////////////////////////////////////////    
    on_rez(integer start_param)
    {
        Initialize();
    }


    
///////////////////////////////////////////////////////
//  Link Message of default state                    //
///////////////////////////////////////////////////////   
    link_message(integer sender_number, integer number, string message, key id)
    {
        //if link message is on the correct channel
        if(number == toAllChannel)
        {
            //treat as command input
            ParseCommand(message);
        }
        
    } //end of link message
    

} // end default