Difference between revisions of "TestUnit MATH Binary Operators.lsl"
Jump to navigation
Jump to search
(Created page with 'Category:Conformance Test <lsl> /////////////////////////////////////////////////////////////////////////////////// /////// /////// /////// /////// TestUnit_TestS...') |
m (<lsl> tag to <source>) |
||
| (One intermediate revision by one other user not shown) | |||
| Line 1: | Line 1: | ||
[[Category:Conformance Test]] | [[Category:Conformance Test]] | ||
< | <source lang="lsl2"> | ||
/////////////////////////////////////////////////////////////////////////////////// | /////////////////////////////////////////////////////////////////////////////////// | ||
/////// | /////// | ||
| Line 11: | Line 11: | ||
/////// | /////// | ||
/////// This is the test script for the data types. | /////// This is the test script for the data types. | ||
/////// | |||
/////// Created by Vektor Linden | /////// Created by Vektor Linden | ||
/////// | /////// | ||
| Line 18: | Line 19: | ||
//TestUnit_TestScript .2 -> tested with minor bug fixes 7.2.2007 | //TestUnit_TestScript .2 -> tested with minor bug fixes 7.2.2007 | ||
//BinaryOperators | //BinaryOperators .3 -> Formal creation of script 2/18/10 | ||
| Line 725: | Line 726: | ||
} // end default | } // end default | ||
</ | </source> | ||
Latest revision as of 12:44, 25 January 2015
///////////////////////////////////////////////////////////////////////////////////
///////
///////
///////
/////// TestUnit_TestScript
///////
/////// MATH_BinaryOperators
///////
/////// This is the test script for the data types.
///////
/////// Created by Vektor Linden
///////
//////////////////////////////////////////////////////////////////////////////////////
//TestUnit_TestScript .1 -> initial framework 6.23.2007
//TestUnit_TestScript .2 -> tested with minor bug fixes 7.2.2007
//BinaryOperators .3 -> Formal creation of script 2/18/10
//////////////////////////////////////////////////////////////////////////////////////
//
// 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 ArithmeticAddition_PASS; // These are global pass/fail
integer ArithmeticSubtraction_PASS; // indicators for the various
integer ArithmeticMultiplication_PASS; // Data Types that are
integer ArithmeticDivision_PASS; // being tested. These variables
integer ArithmeticModulo_PASS; // are used in the Run Test and
integer ArithmeticGreaterThan_PASS; // Report Functions of this script.
integer ArithmeticLessThan_PASS;
integer ArithmeticGreaterThanOrEqualTo_PASS;
integer ArithmeticLessThanOrEqualTo_PASS;
integer LogicalInequality_PASS;
integer LogicalEquality_PASS;
integer LogicalAND_PASS;
integer LogicalOR_PASS;
integer BitwiseAND_PASS;
integer BitwiseOR_PASS;
integer BitwiseLeftShift_PASS;
integer BitwiseRightShift_PASS;
integer BitwiseExclusiveOR_PASS;
//////////////////////////////////////////////////////////////////////////////////////////////////
//////////
////////// 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()
{
// initialize PASS variable
ArithmeticAddition_PASS = 0;
// Compare data against criteria in GetType function, which returns an integer corresponding to the type.
if (1 + 1 == 2)
{
ArithmeticAddition_PASS = 1;
}
// initialize PASS variable
ArithmeticSubtraction_PASS = 0;
// Compare data against criteria in GetType function, which returns an integer corresponding to the type.
if (1 - 1 == 0)
{
ArithmeticSubtraction_PASS = 1;
}
// initialize PASS variable
ArithmeticMultiplication_PASS = 0;
// Compare data against criteria in GetType function, which returns an integer corresponding to the type.
if (2 * 2 == 4)
{
ArithmeticMultiplication_PASS = 1;
}
// initialize PASS variable
ArithmeticDivision_PASS = 0;
// Compare data against criteria in GetType function, which returns an integer corresponding to the type.
if (4 / 2 == 2)
{
ArithmeticDivision_PASS = 1;
}
// initialize PASS variable
ArithmeticModulo_PASS = 0;
// Compare data against criteria in GetType function, which returns an integer corresponding to the type.
if (5 % 2 == 1)
{
ArithmeticModulo_PASS = 1;
}
// initialize PASS variable
ArithmeticGreaterThan_PASS = 0;
// Compare data against criteria in GetType function, which returns an integer corresponding to the type.
if (2 > 1)
{
ArithmeticGreaterThan_PASS = 1;
}
// initialize PASS variable
ArithmeticLessThan_PASS = 0;
// Compare data against criteria in GetType function, which returns an integer corresponding to the type.
if (1 < 2)
{
ArithmeticLessThan_PASS = 1;
}
// initialize PASS variable
ArithmeticGreaterThanOrEqualTo_PASS = 0;
// Compare data against criteria in GetType function, which returns an integer corresponding to the type.
if (2 >= 1)
{
if (1 >= 1)
{
ArithmeticGreaterThanOrEqualTo_PASS = 1;
}
}
// initialize PASS variable
ArithmeticLessThanOrEqualTo_PASS = 0;
// Compare data against criteria in GetType function, which returns an integer corresponding to the type.
if (1 <= 2)
{
if (1 <= 1)
{
ArithmeticLessThanOrEqualTo_PASS = 1;
}
}
// initialize PASS variable
LogicalInequality_PASS = 0;
// Compare data against criteria in GetType function, which returns an integer corresponding to the type.
if (1 != 2)
{
LogicalInequality_PASS = 1;
}
// initialize PASS variable
LogicalEquality_PASS = 0;
// Compare data against criteria in GetType function, which returns an integer corresponding to the type.
if (1 == 1)
{
LogicalEquality_PASS = 1;
}
// initialize PASS variable
LogicalAND_PASS = 0;
// Compare data against criteria in GetType function, which returns an integer corresponding to the type.
if (TRUE && TRUE == TRUE)
{
LogicalAND_PASS = 1;
}
// initialize PASS variable
LogicalOR_PASS = 0;
// Compare data against criteria in GetType function, which returns an integer corresponding to the type.
if (TRUE || TRUE == TRUE)
{
LogicalOR_PASS = 1;
}
// initialize PASS variable
BitwiseAND_PASS = 0;
// Compare data against criteria in GetType function, which returns an integer corresponding to the type.
if (TRUE & TRUE == TRUE)
{
BitwiseAND_PASS = 1;
}
// initialize PASS variable
BitwiseOR_PASS = 0;
// Compare data against criteria in GetType function, which returns an integer corresponding to the type.
if (TRUE | TRUE == TRUE)
{
BitwiseOR_PASS = 1;
}
// initialize PASS variable
BitwiseLeftShift_PASS = 0;
// Compare data against criteria in GetType function, which returns an integer corresponding to the type.
if (2 << 1 == 4)
{
BitwiseLeftShift_PASS = 1;
}
// initialize PASS variable
BitwiseRightShift_PASS = 0;
// Compare data against criteria in GetType function, which returns an integer corresponding to the type.
if (2 >> 1 == 1)
{
BitwiseRightShift_PASS = 1;
}
// initialize PASS variable
BitwiseExclusiveOR_PASS = 0;
// Compare data against criteria in GetType function, which returns an integer corresponding to the type.
if (0 ^ 0 == 0)
{
if (0 ^ 1 == 1)
{
if (1 ^ 0 == 1)
{
if (1 ^ 1 == 0)
{
BitwiseExclusiveOR_PASS = 1;
}
}
}
}
//check to see if any failures occured.
integer pass = ArithmeticAddition_PASS &
ArithmeticSubtraction_PASS &
ArithmeticMultiplication_PASS &
ArithmeticModulo_PASS &
ArithmeticDivision_PASS &
ArithmeticGreaterThan_PASS &
ArithmeticLessThan_PASS &
ArithmeticGreaterThanOrEqualTo_PASS &
ArithmeticLessThanOrEqualTo_PASS &
LogicalInequality_PASS &
LogicalEquality_PASS &
LogicalAND_PASS &
LogicalOR_PASS &
BitwiseAND_PASS &
BitwiseOR_PASS &
BitwiseLeftShift_PASS &
BitwiseRightShift_PASS &
BitwiseExclusiveOR_PASS;
// if all of the individual cases pass, test passes.
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
////////// -> QUIET - 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 ArithmeticAddition_PASSstring = "FAIL";
string ArithmeticSubtraction_PASSstring = "FAIL";
string ArithmeticMultiplication_PASSstring = "FAIL";
string ArithmeticDivision_PASSstring = "FAIL";
string ArithmeticModulo_PASSstring = "FAIL";
string ArithmeticGreaterThan_PASSstring = "FAIL";
string ArithmeticLessThan_PASSstring = "FAIL";
string ArithmeticGreaterThanOrEqualTo_PASSstring = "FAIL";
string ArithmeticLessThanOrEqualTo_PASSstring = "FAIL";
string LogicalInequality_PASSstring = "FAIL";
string LogicalEquality_PASSstring = "FAIL";
string LogicalAND_PASSstring = "FAIL";
string LogicalOR_PASSstring = "FAIL";
string BitwiseAND_PASSstring = "FAIL";
string BitwiseOR_PASSstring = "FAIL";
string BitwiseLeftShift_PASSstring = "FAIL";
string BitwiseRightShift_PASSstring = "FAIL";
string BitwiseExclusiveOR_PASSstring = "FAIL";
//translate integer conditional into text string for the report.
if ( ArithmeticAddition_PASS )
{
ArithmeticAddition_PASSstring = "PASS";
}
if ( ArithmeticSubtraction_PASS )
{
ArithmeticSubtraction_PASSstring = "PASS";
}
if ( ArithmeticMultiplication_PASS )
{
ArithmeticMultiplication_PASSstring = "PASS";
}
if ( ArithmeticDivision_PASS )
{
ArithmeticDivision_PASSstring = "PASS";
}
if ( ArithmeticModulo_PASS )
{
ArithmeticModulo_PASSstring = "PASS";
}
if ( ArithmeticGreaterThan_PASS )
{
ArithmeticGreaterThan_PASSstring = "PASS";
}
if ( ArithmeticLessThan_PASS )
{
ArithmeticLessThan_PASSstring = "PASS";
}
if ( ArithmeticGreaterThanOrEqualTo_PASS )
{
ArithmeticGreaterThanOrEqualTo_PASSstring = "PASS";
}
if ( ArithmeticLessThanOrEqualTo_PASS )
{
ArithmeticLessThanOrEqualTo_PASSstring = "PASS";
}
if ( LogicalInequality_PASS )
{
LogicalInequality_PASSstring = "PASS";
}
if ( LogicalEquality_PASS )
{
LogicalEquality_PASSstring = "PASS";
}
if ( LogicalAND_PASS )
{
LogicalAND_PASSstring = "PASS";
}
if ( LogicalOR_PASS )
{
LogicalOR_PASSstring = "PASS";
}
if ( BitwiseAND_PASS )
{
BitwiseAND_PASSstring = "PASS";
}
if ( BitwiseOR_PASS )
{
BitwiseOR_PASSstring = "PASS";
}
if ( BitwiseLeftShift_PASS )
{
BitwiseLeftShift_PASSstring = "PASS";
}
if ( BitwiseRightShift_PASS )
{
BitwiseRightShift_PASSstring = "PASS";
}
if ( BitwiseExclusiveOR_PASS )
{
BitwiseExclusiveOR_PASSstring = "PASS";
}
//Normal - moderate level of reporting
if( reportType == "NORMAL" )
{
reportString = "Type: ArithmeticAddition -> "
+ ArithmeticAddition_PASSstring + "\n"
+ "Type: ArithmeticSubtraction -> "
+ ArithmeticSubtraction_PASSstring + "\n"
+ "Type: ArithmeticMultiplication -> "
+ ArithmeticMultiplication_PASSstring + "\n"
+ "Type: ArithmeticDivision -> "
+ ArithmeticDivision_PASSstring + "\n"
+ "Type: ArithmeticModulo -> "
+ ArithmeticModulo_PASSstring + "\n"
+ "Type: ArithmeticGreaterThan ->"
+ ArithmeticGreaterThan_PASSstring + "\n"
+ "Type: ArithmeticLessThan -> "
+ ArithmeticLessThan_PASSstring + "\n"
+ "Type: ArithmeticGreaterThanOrEqualTo -> "
+ ArithmeticGreaterThanOrEqualTo_PASSstring + "\n"
+ "Type: ArithmeticLessThanOrEqualTo -> "
+ ArithmeticLessThanOrEqualTo_PASSstring + "\n"
+ "Type: LogicalInequality -> "
+ LogicalInequality_PASSstring + "\n"
+ "Type: LogicalEquality ->"
+ LogicalEquality_PASSstring + "\n"
+ "Type: LogicalAND -> "
+ LogicalAND_PASSstring + "\n"
+ "Type: LogicalOR -> "
+ LogicalOR_PASSstring + "\n"
+ "Type: BitwiseAND -> "
+ BitwiseAND_PASSstring + "\n"
+ "Type: BitwiseOR -> "
+ BitwiseOR_PASSstring + "\n" + "Type: BitwiseLeftShift -> "
+ BitwiseLeftShift_PASSstring + "\n"
+ "Type: BitwiseRightShift -> "
+ BitwiseRightShift_PASSstring + "\n"
+ "Type: BitwiseExclusiveOR ->"
+ BitwiseExclusiveOR_PASSstring + "\n";
} // end normal
//VERBOSE - highest level of reporting
if( reportType == "VERBOSE" )
{
reportString = "///////////////////////////////////////////////////////////////////////////////////////////" + "\n"+
"// Type: ArithmeticAddition" + "\n" +
"// Returns an integer representing the integer type constant" + "\n" +
"// • ArithmeticAddition = 1" + "\n" +
"///////////////////////////////////////////////////////////////////////////////////////////" + "\n" +
"PASS/FAIL -> " + ArithmeticAddition_PASSstring + "\n\n" +
"///////////////////////////////////////////////////////////////////////////////////////" + "\n" +
"// Type: ArithmeticSubtraction" + "\n" +
"// Returns an integer representing the float type constant" + "\n" +
"// • ArithmeticSubtraction = 2" + "\n" +
"////////////////////////////////////////////////////////////////////////////////////////" + "\n" +
"PASS/FAIL -> " + ArithmeticSubtraction_PASSstring + "\n\n" +
"/////////////////////////////////////////////////////////////////////////" + "\n" +
"// Type: ArithmeticMultiplication" + "\n" +
"// Returns an integer representing the string data type constant" + "\n" +
"// • ArithmeticMultiplication = 3" + "\n" +
"////////////////////////////////////////////////////////////////////////////////" + "\n" +
"PASS/FAIL -> " + ArithmeticMultiplication_PASSstring + "\n\n" +
"//////////////////////////////////////////////////////////////////////////////" + "\n" +
"// Type: ArithmeticDivision" + "\n" +
"// Returns an integer representing the key data type constant" + "\n" +
"// • ArithmeticDivision = 4" + "\n" +
"/////////////////////////////////////////////////////////////////////////////" + "\n" +
"PASS/FAIL -> " + ArithmeticDivision_PASSstring + "\n\n" +
"///////////////////////////////////////////////////////////////////////////////////" + "\n" +
"// Type: ArithmeticModulo" + "\n" +
"// Returns an integer representing the vector data type constant" + "\n" +
"// • ArithmeticModulo = 5" + "\n" +
"//////////////////////////////////////////////////////////////////////////////////" + "\n" +
"PASS/FAIL -> " + ArithmeticModulo_PASSstring + "\n\n" +
"// Type: ArithmeticGreaterThan" + "\n" +
"// Returns an integer representing the integer type constant" + "\n" +
"// • ArithmeticGreaterThan = 1" + "\n" +
"///////////////////////////////////////////////////////////////////////////////////////////" + "\n" +
"PASS/FAIL -> " + ArithmeticGreaterThan_PASSstring + "\n\n" +
"///////////////////////////////////////////////////////////////////////////////////////" + "\n" +
"// Type: ArithmeticLessThan" + "\n" +
"// Returns an integer representing the float type constant" + "\n" +
"// • ArithmeticLessThan = 2" + "\n" +
"////////////////////////////////////////////////////////////////////////////////////////" + "\n" +
"PASS/FAIL -> " + ArithmeticLessThan_PASSstring + "\n\n" +
"/////////////////////////////////////////////////////////////////////////" + "\n" +
"// Type: ArithmeticGreaterThanOrEqualTo" + "\n" +
"// Returns an integer representing the string data type constant" + "\n" +
"// • ArithmeticGreaterThanOrEqualTo = 3" + "\n" +
"////////////////////////////////////////////////////////////////////////////////" + "\n" +
"PASS/FAIL -> " + ArithmeticGreaterThanOrEqualTo_PASSstring + "\n\n" +
"//////////////////////////////////////////////////////////////////////////////" + "\n" +
"// Type: ArithmeticLessThanOrEqualTo" + "\n" +
"// Returns an integer representing the key data type constant" + "\n" +
"// • ArithmeticLessThanOrEqualTo = 4" + "\n" +
"/////////////////////////////////////////////////////////////////////////////" + "\n" +
"PASS/FAIL -> " + ArithmeticLessThanOrEqualTo_PASSstring + "\n\n" +
"///////////////////////////////////////////////////////////////////////////////////////////" + "\n" +
"// Type: LogicalInequality" + "\n" +
"// Returns an integer representing the integer type constant" + "\n" +
"// • LogicalInequality = 1" + "\n" +
"///////////////////////////////////////////////////////////////////////////////////////////" + "\n" +
"PASS/FAIL -> " + LogicalInequality_PASSstring + "\n\n" +
"///////////////////////////////////////////////////////////////////////////////////////" + "\n" +
"// Type: LogicalEquality" + "\n" +
"// Returns an integer representing the float type constant" + "\n" +
"// • LogicalEquality = 2" + "\n" +
"////////////////////////////////////////////////////////////////////////////////////////" + "\n" +
"PASS/FAIL -> " + LogicalEquality_PASSstring + "\n\n" +
"/////////////////////////////////////////////////////////////////////////" + "\n" +
"// Type: LogicalAND" + "\n" +
"// Returns an integer representing the string data type constant" + "\n" +
"// • LogicalAND = 3" + "\n" +
"////////////////////////////////////////////////////////////////////////////////" + "\n" +
"PASS/FAIL -> " + LogicalAND_PASSstring + "\n\n" +
"//////////////////////////////////////////////////////////////////////////////" + "\n" +
"// Type: LogicalOR" + "\n" +
"// Returns an integer representing the key data type constant" + "\n" +
"// • LogicalOR = 4" + "\n" +
"/////////////////////////////////////////////////////////////////////////////" + "\n" +
"PASS/FAIL -> " + LogicalOR_PASSstring + "\n\n" +
"/////////////////////////////////////////////////////////////////////////////////" + "\n" +
"// Type: BitwiseAND" + "\n" +
"// Returns an integer representing the invalid data type constant" + "\n" +
"// • BitwiseAND = 0" + "\n" +
"/////////////////////////////////////////////////////////////////////////////////" + "\n" +
"PASS/FAIL -> " + BitwiseAND_PASSstring + "\n\n" +
"///////////////////////////////////////////////////////////////////////////////////////" + "\n" +
"// Type: BitwiseOR" + "\n" +
"// Returns an integer representing the float type constant" + "\n" +
"// • BitwiseOR = 2" + "\n" +
"////////////////////////////////////////////////////////////////////////////////////////" + "\n" +
"PASS/FAIL -> " + BitwiseOR_PASSstring + "\n\n" +
"/////////////////////////////////////////////////////////////////////////" + "\n" +
"// Type: BitwiseLeftShift" + "\n" +
"// Returns an integer representing the string data type constant" + "\n" +
"// • BitwiseLeftShift = 3" + "\n" +
"////////////////////////////////////////////////////////////////////////////////" + "\n" +
"PASS/FAIL -> " + BitwiseLeftShift_PASSstring + "\n\n" +
"//////////////////////////////////////////////////////////////////////////////" + "\n" +
"// Type: BitwiseRightShift" + "\n" +
"// Returns an integer representing the key data type constant" + "\n" +
"// • BitwiseRightShift = 4" + "\n" +
"/////////////////////////////////////////////////////////////////////////////" + "\n" +
"PASS/FAIL -> " + BitwiseRightShift_PASSstring + "\n\n" +
"/////////////////////////////////////////////////////////////////////////////////" + "\n" +
"// Type: BitwiseExclusiveOR" + "\n" +
"// Returns an integer representing the invalid data type constant" + "\n" +
"// • BitwiseExclusiveOR = 0" + "\n" +
"/////////////////////////////////////////////////////////////////////////////////" + "\n" +
"PASS/FAIL -> " + BitwiseExclusiveOR_PASSstring + "\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_BinaryOperators", <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