TestUnit DATA Supported Typecasts.lsl
<lsl>
///////////////////////////////////////////////////////////////////////////////////
///////
///////
///////
/////// TestUnit_TestScript
///////
/////// DATA_Supported Typecasts
///////
/////// This is the test script for the data types.
///////
///////
//////////////////////////////////////////////////////////////////////////////////////
//TestUnit_TestScript .1 -> initial framework 6.23.2007 //TestUnit_TestScript .2 -> tested with minor bug fixes 7.2.2007
//Supported Typecasts .1 -> Formal creation of script
//////////////////////////////////////////////////////////////////////////////////////
//
// 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 IntVar = 5; // These are global pass/fail
rotation RotVar = <90.0, 90.0, 90.0, 1.0>; // indicators for the various
float FloatVar = 2.0; // Data Types that are
vector VectorVar = <90.0, 90.0, 90.0>; // being tested. These variables
key KeyVar = "07be0b18-230b-81c4-51a7-f4a3be2aae0b"; // are used in the Run Test and
string StringVar = "This is the typecasting test string."; // Report Functions of this script.
// Variables for holding typecasts integer int2int; float int2float; string int2string;
rotation rot2rot; string rot2string;
integer float2int; float float2float; string float2string;
vector Vec2vec; string Vec2string;
key key2key; string key2string;
integer string2int; rotation string2rot; float string2float; vector string2vec; key string2key; string string2string;
// PASS BITS integer int2int_PASS; integer int2float_PASS; integer int2string_PASS;
integer rot2rot_PASS; integer rot2string_PASS;
integer float2int_PASS; integer float2float_PASS; integer float2string_PASS;
integer Vec2vec_PASS; integer Vec2string_PASS;
integer key2key_PASS; integer key2string_PASS;
integer string2int_PASS; integer string2rot_PASS; integer string2float_PASS; integer string2vec_PASS; integer string2key_PASS; integer string2string_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()
{
// INT IntVar int2int = (integer)IntVar; // initialize PASS variable int2int_PASS = 0; if ((string)int2int == "5") { int2int_PASS = 1; } int2float = (float)IntVar ; // initialize PASS variable int2float_PASS = 0; if ((string)int2float == "5.000000") { int2float_PASS = 1; } int2string = (string)IntVar; // initialize PASS variable int2string_PASS = 0; if ((string)int2string == "5") { int2string_PASS = 1; }
// rotation RotVar rot2rot = (rotation)RotVar; // initialize PASS variable rot2rot_PASS = 0; if ((string)rot2rot == "<90.00000, 90.00000, 90.00000, 1.00000>") { rot2rot_PASS = 1; } rot2string = (string)RotVar; // initialize PASS variable rot2string_PASS = 0; if ((string)rot2string == "<90.00000, 90.00000, 90.00000, 1.00000>") { rot2string_PASS = 1; } // float FloatVar float2int = (integer)FloatVar; // initialize PASS variable float2int_PASS = 0; if ((string)float2int == "2") { float2int_PASS = 1; } float2float = (float)FloatVar; // initialize PASS variable float2float_PASS = 0; if ((string)float2float == "2.000000") { float2float_PASS = 1; } float2string = (string)FloatVar; // initialize PASS variable float2string_PASS = 0; if ((string)float2string == "2.000000") { float2string_PASS = 1; } // vector VectorVar Vec2vec = (vector)VectorVar; // initialize PASS variable Vec2vec_PASS = 0; if ((string)Vec2vec == "<90.00000, 90.00000, 90.00000>") { Vec2vec_PASS = 1; } Vec2string = (string)VectorVar; // initialize PASS variable Vec2string_PASS = 0; if ((string)Vec2string == "<90.00000, 90.00000, 90.00000>") { Vec2string_PASS = 1; } // key KeyVar key2key = (key)KeyVar; // initialize PASS variable key2key_PASS = 0; if ((string)key2key == "07be0b18-230b-81c4-51a7-f4a3be2aae0b") { key2key_PASS = 1; } key2string = (string)KeyVar; // initialize PASS variable key2string_PASS = 0; if ((string)key2string == "07be0b18-230b-81c4-51a7-f4a3be2aae0b") { key2string_PASS = 1; } // string StringVar string2int = (integer)StringVar; // initialize PASS variable string2int_PASS = 0; if ((string)string2int == "0") { string2int_PASS = 1; } string2rot = (rotation)StringVar; // initialize PASS variable string2rot_PASS = 0; if ((string)string2rot == "<0.00000, 0.00000, 0.00000, 1.00000>") { string2rot_PASS = 1; } string2float = (float)StringVar; // initialize PASS variable string2float_PASS = 0; if ((string)string2float == "0.000000") { string2float_PASS = 1; } string2vec = (vector)StringVar; // initialize PASS variable string2vec_PASS = 0; if ((string)string2vec == "<0.00000, 0.00000, 0.00000>") { string2vec_PASS = 1; } string2key = (key)StringVar; // initialize PASS variable string2key_PASS = 0; if ((string)string2key == "This is the typecasting test string.") { string2key_PASS = 1; } string2string = (string)StringVar; // initialize PASS variable string2string_PASS = 0; if ((string)string2string == "This is the typecasting test string.") { string2string_PASS = 1; }
//check to see if any failures occured. integer pass = int2int_PASS & int2float_PASS & int2string_PASS & rot2rot_PASS & rot2string_PASS & float2int_PASS & float2float_PASS & float2string_PASS & Vec2vec_PASS & Vec2string_PASS & key2key_PASS & key2string_PASS & string2int_PASS & string2rot_PASS & string2float_PASS & string2vec_PASS & string2key_PASS & string2string_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 int2int_PASSstring = "FAIL"; string int2float_PASSstring = "FAIL"; string int2string_PASSstring = "FAIL"; string rot2rot_PASSstring = "FAIL"; string rot2string_PASSstring = "FAIL"; string float2int_PASSstring = "FAIL"; string float2float_PASSstring = "FAIL"; string float2string_PASSstring = "FAIL"; string Vec2vec_PASSstring = "FAIL"; string Vec2string_PASSstring = "FAIL"; string key2key_PASSstring = "FAIL"; string key2string_PASSstring = "FAIL"; string string2int_PASSstring = "FAIL"; string string2rot_PASSstring = "FAIL"; string string2float_PASSstring = "FAIL"; string string2vec_PASSstring = "FAIL"; string string2key_PASSstring = "FAIL"; string string2string_PASSstring = "FAIL"; //translate integer conditional into text string for the report. if ( int2int_PASS ) { int2int_PASSstring = "PASS"; } if ( int2float_PASS ) { int2float_PASSstring = "PASS"; } if ( int2string_PASS ) { int2string_PASSstring = "PASS"; } if ( rot2rot_PASS ) { rot2rot_PASSstring = "PASS"; } if ( rot2string_PASSstring ) { rot2string_PASSstring = "PASS"; } if ( float2int_PASS ) { float2int_PASSstring = "PASS"; } if ( float2float_PASS ) { float2float_PASSstring = "PASS"; } if ( float2string_PASS ) { float2string_PASSstring = "PASS"; } if ( Vec2vec_PASS ) { Vec2vec_PASSstring = "PASS"; } if ( Vec2string_PASS ) { Vec2string_PASSstring = "PASS"; } if ( key2key_PASS ) { key2key_PASSstring = "PASS"; } if ( key2string_PASS ) { key2string_PASSstring = "PASS"; } if ( string2int_PASS ) { string2int_PASSstring = "PASS"; } if ( string2rot_PASS ) { string2rot_PASSstring = "PASS"; } if ( string2float_PASS ) { string2float_PASSstring = "PASS"; } if ( string2vec_PASS ) { string2vec_PASSstring = "PASS"; } if ( string2key_PASS ) { string2key_PASSstring = "PASS"; } if ( string2string_PASS ) { string2string_PASSstring = "PASS"; }
//Normal - moderate level of reporting if( reportType == "NORMAL" ) { reportString = "Type: int2int -> " + int2int_PASSstring + "\n" + "Type: int2float -> " + int2float_PASSstring + "\n" + "Type: int2string -> " + int2string_PASSstring + "\n" + "Type: rot2rot -> " + rot2rot_PASSstring + "\n" + "Type: rot2string -> " + rot2string_PASSstring + "\n" + "Type: float2int ->" + float2int_PASSstring + "\n" + "Type: float2float -> " + float2float_PASSstring + "\n" + "Type: float2string -> " + float2string_PASSstring + "\n" + "Type: Vec2vec -> " + Vec2vec_PASSstring + "\n" + "Type: Vec2string -> " + Vec2string_PASSstring + "\n" + "Type: key2key ->" + key2key_PASSstring + "\n" + "Type: key2string -> " + key2string_PASSstring + "\n" + "Type: string2int -> " + string2int_PASSstring + "\n" + "Type: string2rot -> " + string2rot_PASSstring + "\n" + "Type: string2float -> " + string2float_PASSstring + "\n" + "Type: string2vec -> " + string2vec_PASSstring + "\n" + "Type: string2key -> " + string2key_PASSstring + "\n" + "Type: string2string ->" + string2string_PASSstring + "\n"; } // end normal
//VERBOSE - highest level of reporting if( reportType == "VERBOSE" ) { reportString = "///////////////////////////////////////////////////////////////////////////////////////////" + "\n"+ "// Type: int2int" + "\n" + "// Returns an integer representing the integer type constant" + "\n" + "// • int2int = 1" + "\n" + "///////////////////////////////////////////////////////////////////////////////////////////" + "\n" + "PASS/FAIL -> " + int2int_PASSstring + "\n\n" + "///////////////////////////////////////////////////////////////////////////////////////" + "\n" + "// Type: int2float" + "\n" + "// Returns an integer representing the float type constant" + "\n" + "// • int2float = 2" + "\n" + "////////////////////////////////////////////////////////////////////////////////////////" + "\n" + "PASS/FAIL -> " + int2float_PASSstring + "\n\n" + "/////////////////////////////////////////////////////////////////////////" + "\n" + "// Type: int2string" + "\n" + "// Returns an integer representing the string data type constant" + "\n" + "// • int2string = 3" + "\n" + "////////////////////////////////////////////////////////////////////////////////" + "\n" + "PASS/FAIL -> " + int2string_PASSstring + "\n\n" + "//////////////////////////////////////////////////////////////////////////////" + "\n" + "// Type: rot2rot" + "\n" + "// Returns an integer representing the key data type constant" + "\n" + "// • rot2rot = 4" + "\n" + "/////////////////////////////////////////////////////////////////////////////" + "\n" + "PASS/FAIL -> " + rot2rot_PASSstring + "\n\n" + "///////////////////////////////////////////////////////////////////////////////////" + "\n" + "// Type: rot2string" + "\n" + "// Returns an integer representing the vector data type constant" + "\n" + "// • rot2string = 5" + "\n" + "//////////////////////////////////////////////////////////////////////////////////" + "\n" + "PASS/FAIL -> " + rot2string_PASSstring + "\n\n" + "// Type: float2int" + "\n" + "// Returns an integer representing the integer type constant" + "\n" + "// • float2int = 1" + "\n" + "///////////////////////////////////////////////////////////////////////////////////////////" + "\n" + "PASS/FAIL -> " + float2int_PASSstring + "\n\n" + "///////////////////////////////////////////////////////////////////////////////////////" + "\n" + "// Type: float2float" + "\n" + "// Returns an integer representing the float type constant" + "\n" + "// • float2float = 2" + "\n" + "////////////////////////////////////////////////////////////////////////////////////////" + "\n" + "PASS/FAIL -> " + float2float_PASSstring + "\n\n" + "/////////////////////////////////////////////////////////////////////////" + "\n" + "// Type: float2string" + "\n" + "// Returns an integer representing the string data type constant" + "\n" + "// • float2string = 3" + "\n" + "////////////////////////////////////////////////////////////////////////////////" + "\n" + "PASS/FAIL -> " + float2string_PASSstring + "\n\n" + "//////////////////////////////////////////////////////////////////////////////" + "\n" + "// Type: Vec2vec" + "\n" + "// Returns an integer representing the key data type constant" + "\n" + "// • Vec2vec = 4" + "\n" + "/////////////////////////////////////////////////////////////////////////////" + "\n" + "PASS/FAIL -> " + Vec2vec_PASSstring + "\n\n" + "///////////////////////////////////////////////////////////////////////////////////////////" + "\n" + "// Type: Vec2string" + "\n" + "// Returns an integer representing the integer type constant" + "\n" + "// • Vec2string = 1" + "\n" + "///////////////////////////////////////////////////////////////////////////////////////////" + "\n" + "PASS/FAIL -> " + Vec2string_PASSstring + "\n\n" + "///////////////////////////////////////////////////////////////////////////////////////" + "\n" + "// Type: key2key" + "\n" + "// Returns an integer representing the float type constant" + "\n" + "// • key2key = 2" + "\n" + "////////////////////////////////////////////////////////////////////////////////////////" + "\n" + "PASS/FAIL -> " + key2key_PASSstring + "\n\n" + "/////////////////////////////////////////////////////////////////////////" + "\n" + "// Type: key2string" + "\n" + "// Returns an integer representing the string data type constant" + "\n" + "// • key2string = 3" + "\n" + "////////////////////////////////////////////////////////////////////////////////" + "\n" + "PASS/FAIL -> " + key2string_PASSstring + "\n\n" + "//////////////////////////////////////////////////////////////////////////////" + "\n" + "// Type: string2int" + "\n" + "// Returns an integer representing the key data type constant" + "\n" + "// • string2int = 4" + "\n" + "/////////////////////////////////////////////////////////////////////////////" + "\n" + "PASS/FAIL -> " + string2int_PASSstring + "\n\n" + "/////////////////////////////////////////////////////////////////////////////////" + "\n" + "// Type: string2rot" + "\n" + "// Returns an integer representing the invalid data type constant" + "\n" + "// • string2rot = 0" + "\n" + "/////////////////////////////////////////////////////////////////////////////////" + "\n" + "PASS/FAIL -> " + string2rot_PASSstring + "\n\n" + "///////////////////////////////////////////////////////////////////////////////////////" + "\n" + "// Type: string2float" + "\n" + "// Returns an integer representing the float type constant" + "\n" + "// • string2float = 2" + "\n" + "////////////////////////////////////////////////////////////////////////////////////////" + "\n" + "PASS/FAIL -> " + string2float_PASSstring + "\n\n" + "/////////////////////////////////////////////////////////////////////////" + "\n" + "// Type: string2vec" + "\n" + "// Returns an integer representing the string data type constant" + "\n" + "// • string2vec = 3" + "\n" + "////////////////////////////////////////////////////////////////////////////////" + "\n" + "PASS/FAIL -> " + string2vec_PASSstring + "\n\n" + "//////////////////////////////////////////////////////////////////////////////" + "\n" + "// Type: string2key" + "\n" + "// Returns an integer representing the key data type constant" + "\n" + "// • string2key = 4" + "\n" + "/////////////////////////////////////////////////////////////////////////////" + "\n" + "PASS/FAIL -> " + string2key_PASSstring + "\n\n" + "/////////////////////////////////////////////////////////////////////////////////" + "\n" + "// Type: string2string" + "\n" + "// Returns an integer representing the invalid data type constant" + "\n" + "// • string2string = 0" + "\n" + "/////////////////////////////////////////////////////////////////////////////////" + "\n" + "PASS/FAIL -> " + string2string_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( "DATA_Supported Typecasts", <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 </lsl>