ObviousAltIsObvious Resident: language tags to

2015-01-25T20:44:01Z

language tags to <source>

← Older revision		Revision as of 13:44, 25 January 2015
Line 2:		Line 2:


	<~~lsl~~>		<source lang="lsl2">
	///////////////////////////////////////////////////////////////////////////////////		///////////////////////////////////////////////////////////////////////////////////
	///////		///////
Line 681:		Line 681:

	} // end default		} // end default
	</~~lsl~~>		</source>

Uzume Grigorovich: typos

2008-04-12T18:37:12Z

typos

← Older revision		Revision as of 11:37, 12 April 2008
Line 41:		Line 41:
	//////////////////////////////////////////////		//////////////////////////////////////////////
	//		//
	// link message commands will be sent out on the toAllChannel, and ~~recieved~~ on the passFailChannel		// link message commands will be sent out on the toAllChannel, and received on the passFailChannel
	//		//
	//////// INPUT ///////////		//////// INPUT ///////////
Line 65:		Line 65:

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

	integer debug = 0; // level of debug message		integer debug = 0; // level of debug message
Line 279:		Line 279:
	////////// Function: RunTest		////////// Function: RunTest
	//////////		//////////
	////////// Input: no input ~~paramaters~~		////////// Input: no input parameters
	//////////		//////////
	////////// Output: link message on passFailChannel test status		////////// Output: link message on passFailChannel test status
Line 577:		Line 577:
	//////////		//////////
	////////// Purpose: This function is where you design the three level of reports		////////// Purpose: This function is where you design the three level of reports
	////////// ~~avaliable~~ upon request by the Coordinator		////////// available upon request by the Coordinator
	//////////		//////////
	////////// Issues: no known issues		////////// Issues: no known issues
Line 618:		Line 618:
	////////// Function: Initialize		////////// Function: Initialize
	//////////		//////////
	////////// Input: no input ~~paramaters~~		////////// Input: no input parameters
	//////////		//////////
	////////// Output: no return value		////////// Output: no return value

Uzume Grigorovich: lsl code tagging

2008-04-12T18:34:30Z

lsl code tagging

← Older revision		Revision as of 11:34, 12 April 2008
Line 2:		Line 2:


	<~~pre~~>		<lsl>
	///////////////////////////////////////////////////////////////////////////////////		///////////////////////////////////////////////////////////////////////////////////
	///////		///////
Line 681:		Line 681:

	} // end default		} // end default
	</~~pre~~>		</lsl>

Phoenix Linden at 22:58, 4 February 2008

2008-02-04T22:58:46Z

← Older revision		Revision as of 15:58, 4 February 2008
Line 1:		Line 1:
			[[Category:Conformance Test]]


	<pre>		<pre>
	///////////////////////////////////////////////////////////////////////////////////		///////////////////////////////////////////////////////////////////////////////////

Periapse Linden: New page:

 /////////////////////////////////////////////////////////////////////////////////// /////// /////// /////// ///////            TestUnit_TestScript ///////              ///////       ...

2007-10-29T20:42:59Z

New page: <pre> /////////////////////////////////////////////////////////////////////////////////// /////// /////// /////// /////// TestUnit_TestScript /////// /////// ...

New page

<pre>
///////////////////////////////////////////////////////////////////////////////////
///////
///////
///////
/////// TestUnit_TestScript
///////
///////
///////
/////// This is the test script that should include the code you want to test.
///////
///////
//////////////////////////////////////////////////////////////////////////////////////

//TestUnit_TestScript .1 -> initial framework 6.23.2007
//TestUnit_TestScript .2 -> tested with minor bug fixes 7.2.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 gTestsPassed = 0;
integer gTestsFailed = 0;

//////////////////////////////////////////////////////////////////////////////////////////////////
//////////
////////// 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

///////////////////////////////////////////////////////////////////////////////////////////////////
// supporting functions
testPassed(string description, string actual, string expected)
{
++gTestsPassed;
//llSay(0, description);
}

testFailed(string description, string actual, string expected)
{
++gTestsFailed;
llSay(0, "FAILED!: " + description + " (" + actual + " expected " + expected + ")");
}

ensureTrue(string description, integer actual)
{
if(actual)
{
testPassed(description, (string) actual, (string) TRUE);
}
else
{
testFailed(description, (string) actual, (string) TRUE);
}
}

ensureFalse(string description, integer actual)
{
if(actual)
{
testFailed(description, (string) actual, (string) FALSE);
}
else
{
testPassed(description, (string) actual, (string) FALSE);
}
}

ensureIntegerEqual(string description, integer actual, integer expected)
{
if(actual == expected)
{
testPassed(description, (string) actual, (string) expected);
}
else
{
testFailed(description, (string) actual, (string) expected);
}
}

ensureFloatEqual(string description, float actual, float expected)
{
if(actual == expected)
{
testPassed(description, (string) actual, (string) expected);
}
else
{
testFailed(description, (string) actual, (string) expected);
}
}

ensureStringEqual(string description, string actual, string expected)
{
if(actual == expected)
{
testPassed(description, (string) actual, (string) expected);
}
else
{
testFailed(description, (string) actual, (string) expected);
}
}

ensureVectorEqual(string description, vector actual, vector expected)
{
if(actual == expected)
{
testPassed(description, (string) actual, (string) expected);
}
else
{
testFailed(description, (string) actual, (string) expected);
}
}

ensureRotationEqual(string description, rotation actual, rotation expected)
{
if(actual == expected)
{
testPassed(description, (string) actual, (string) expected);
}
else
{
testFailed(description, (string) actual, (string) expected);
}
}

ensureListEqual(string description, list actual, list expected)
{
if(actual == expected)
{
testPassed(description, (string) actual, (string) expected);
}
else
{
testFailed(description, (string) actual, (string) expected);
}
}

integer gInteger = 5;
float gFloat = 1.5;
string gString = "foo";
vector gVector = <1, 2, 3>;
rotation gRot = <1, 2, 3, 4>;

integer testReturn()
{
return 1;
}

integer testParameters(integer param)
{
param = param + 1;
return param;
}

integer testRecursion(integer param)
{
if(param <= 0)
{
return 0;
}
else
{
return testRecursion(param - 1);
}
}

//////////////////////////////////////////////////////////////////////////////////////////////////
//////////
////////// 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()
{

// truth
ensureIntegerEqual("TRUE", TRUE, TRUE);
ensureIntegerEqual("FALSE", FALSE, FALSE);

// equality
ensureIntegerEqual("(TRUE == TRUE)", (TRUE == TRUE), TRUE);
ensureIntegerEqual("(TRUE == FALSE)", (TRUE == FALSE), FALSE);
ensureIntegerEqual("(TRUE == FALSE)", (TRUE == FALSE), FALSE);
ensureIntegerEqual("(FALSE == FALSE)", (FALSE == FALSE), TRUE);

// inequality
ensureIntegerEqual("(TRUE != TRUE)", (TRUE != TRUE), FALSE);
ensureIntegerEqual("(TRUE != FALSE)", (TRUE != FALSE), TRUE);
ensureIntegerEqual("(TRUE != FALSE)", (TRUE != FALSE), TRUE);
ensureIntegerEqual("(FALSE != FALSE)", (FALSE != FALSE), FALSE);

// and
ensureIntegerEqual("(TRUE && TRUE)", (TRUE && TRUE), TRUE);
ensureIntegerEqual("(TRUE && FALSE)", (TRUE && FALSE), FALSE);
ensureIntegerEqual("(FALSE && TRUE)", (FALSE && TRUE), FALSE);
ensureIntegerEqual("(FALSE && FALSE)", (FALSE && FALSE), FALSE);

// or
ensureIntegerEqual("(TRUE || TRUE)", (TRUE || TRUE), TRUE);
ensureIntegerEqual("(TRUE || FALSE)", (TRUE || FALSE), TRUE);
ensureIntegerEqual("(FALSE || TRUE)", (FALSE || TRUE), TRUE);
ensureIntegerEqual("(FALSE || FALSE)", (FALSE || FALSE), FALSE);

// not
ensureIntegerEqual("(! TRUE)", (! TRUE), FALSE);
ensureIntegerEqual("(! FALSE)", (! FALSE), TRUE);

// greater than
ensureIntegerEqual("(1 > 0)", (1 > 0), TRUE);
ensureIntegerEqual("(0 > 1)", (0 > 1), FALSE);
ensureIntegerEqual("(1 > 1)", (1 > 1), FALSE);

// less than
ensureIntegerEqual("(0 < 1)", (0 < 1), TRUE);
ensureIntegerEqual("(1 < 0)", (1 < 0), FALSE);
ensureIntegerEqual("(1 < 1)", (1 < 1), FALSE);

// greater than or equal
ensureIntegerEqual("(1 >= 0)", (1 >= 0), TRUE);
ensureIntegerEqual("(0 >= 1)", (0 >= 1), FALSE);
ensureIntegerEqual("(1 >= 1)", (1 >= 1), TRUE);

// tess than or equal
ensureIntegerEqual("(0 <= 1)", (0 <= 1), TRUE);
ensureIntegerEqual("(1 <= 0)", (1 <= 0), FALSE);
ensureIntegerEqual("(1 <= 1)", (1 <= 1), TRUE);

// bitwise and
ensureIntegerEqual("(10 & 25)", (10 & 25), 8);

// bitwise or
ensureIntegerEqual("(10 | 25)", (10 | 25), 27);

// bitwise not
ensureIntegerEqual("~10", ~10, -11);

// xor
ensureIntegerEqual("(10 ^ 25)", (10 ^ 25), 19);

// right shift
ensureIntegerEqual("(523 >> 2)", (523 >> 2), 130);

// left shift
ensureIntegerEqual("(523 << 2)", (523 << 2), 2092);

// addition
ensureIntegerEqual("(1 + 1)", (1 + 1), 2);
ensureFloatEqual("(1 + 1.1)", (1 + 1.1), 2.1);
ensureFloatEqual("(1.1 + 1)", (1.1 + 1), 2.1);
ensureFloatEqual("(1.1 + 1.1)", (1.1 + 1.1), 2.2);
ensureStringEqual("\"foo\" + \"bar\"", "foo" + "bar", "foobar");
ensureVectorEqual("(<1.1, 2.2, 3.3> + <4.4, 5.5, 6.6>)", (<1.1, 2.2, 3.3> + <4.4, 5.5, 6.6>), <5.5, 7.7, 9.9>);
ensureRotationEqual("(<1.1, 2.2, 3.3, 4.4> + <4.4, 5.5, 6.6, 3.3>)", (<1.1, 2.2, 3.3, 4.4> + <4.4, 5.5, 6.6, 3.3>), <5.5, 7.7, 9.9, 7.7>);
ensureListEqual("([1] + 2)", ([1] + 2), [1,2]);
ensureListEqual("([] + 1.5)", ([] + 1.5), [1.5]);
ensureListEqual("([\"foo\"] + \"bar\")", (["foo"] + "bar"), ["foo", "bar"]);
ensureListEqual("([] + <1,2,3>)", ([] + <1,2,3>), [<1,2,3>]);
ensureListEqual("([] + <1,2,3,4>)", ([] + <1,2,3,4>), [<1,2,3,4>]);

// subtraction
ensureIntegerEqual("(1 - 1)", (1 - 1), 0);
ensureFloatEqual("(1 - 0.5)", (1 - 0.5), 0.5);
ensureFloatEqual("(1.5 - 1)", (1.5 - 1), 0.5);
ensureFloatEqual("(2.2 - 1.1)", (2.2 - 1.1), 1.1);
ensureVectorEqual("(<1.5, 2.5, 3.5> - <4.5, 5.5, 6.5>)", (<1.5, 2.5, 3.5> - <4.5, 5.5, 6.5>), <-3.0, -3.0, -3.0>);
ensureRotationEqual("(<1.5, 2.5, 3.5, 4.5> - <4.5, 5.5, 6.5, 7.5>)", (<1.5, 2.5, 3.5, 4.5> - <4.5, 5.5, 6.5, 7.5>), <-3.0, -3.0, -3.0, -3.0>);

// multiplication
ensureIntegerEqual("(2 * 3)", (2 * 3), 6);
ensureFloatEqual("(2 * 3.5)", (2 * 3.5), 7.0);
ensureFloatEqual("(2.5 * 3)", (2.5 * 3), 7.5);
ensureFloatEqual("(2.5 * 3.5)", (2.5 * 3.5), 8.75);
ensureVectorEqual("(<1.1, 2.2, 3.3> * 2)", (<1.1, 2.2, 3.3> * 2), <2.2, 4.4, 6.6>);
ensureVectorEqual("(<2.2, 4.4, 6.6> * 2.0)", (<2.2, 4.4, 6.6> * 2.0), <4.4, 8.8, 13.2>);
ensureFloatEqual("(<1.0, 2.0, 3.0> * <4.0, 5.0, 6.0>)", (<1.0, 2.0, 3.0> * <4.0, 5.0, 6.0>), 32.0);

// division
ensureIntegerEqual("(2 / 2)", (2 / 2), 1);
ensureFloatEqual("(2.2 / 2)", (2.2 / 2), 1.1);
ensureFloatEqual("(3 / 1.5)", (3 / 1.5), 2.0);
ensureFloatEqual("(2.2 / 2.0)", (2.2 / 2.0), 1.1);
ensureVectorEqual("(<1.0, 2.0, 3.0> / 2)", (<1.0, 2.0, 3.0> / 2), <0.5, 1.0, 1.5>);
ensureVectorEqual("(<3.0, 6.0, 9.0> / 1.5)", (<3.0, 6.0, 9.0> / 1.5), <2.0, 4.0, 6.0>);

// modulo
ensureIntegerEqual("(3 % 1)", (3 % 1), 0);
ensureVectorEqual("(<1.0, 2.0, 3.0> % <4.0, 5.0, 6.0>)", (<1.0, 2.0, 3.0> % <4.0, 5.0, 6.0>), <-3.0, 6.0, -3.0>);

// assignment
integer i = 1;
ensureIntegerEqual("i = 1;", i, 1);

// addition assignment
i = 1;
i += 1;
ensureIntegerEqual("i = 1; i += 1;", i, 2);

// subtraction assignment
i = 1;
i -= 1;
ensureIntegerEqual("i = 1; i -= 1;", i, 0);

// multiplication assignment
i = 2;
i *= 2;
ensureIntegerEqual("i = 2; i *= 2;", i, 4);

// division assignment
i = 2;
i /= 2;
ensureIntegerEqual("i = 2; i /= 2;", i, 1);

// modulo assignment
i = 3;
i %= 1;
ensureIntegerEqual("i = 3; i %= 1;", i, 0);

// post increment.
i = 1;
ensureIntegerEqual("i = 1; (i == 2) && (i++ == 1)", (i == 2) && (i++ == 1), TRUE);

// pre increment.
i = 1;
ensureIntegerEqual("i = 1; (i == 2) && (++i == 2)", (i == 2) && (++i == 2), TRUE);

// post decrement.
i = 1;
ensureIntegerEqual("i = 1; (i == 0) && (i-- == 1)", (i == 0) && (i-- == 1), TRUE);

// pre decrement.
i = 1;
ensureIntegerEqual("i = 1; (i == 0) && (--i == 0)", (i == 0) && (--i == 0), TRUE);

// casting
ensureFloatEqual("((float)2)", ((float)2), 2.0);
ensureStringEqual("((string)2)", ((string)2), "2");
ensureIntegerEqual("((integer) 1.5)", ((integer) 1.5), 1);
ensureStringEqual("((string) 1.5)", ((string) 1.5), "1.500000");
ensureIntegerEqual("((integer) \"0xF\")", ((integer) "0xF"), 15);
ensureIntegerEqual("((integer) \"2\")", ((integer) "2"), 2);
ensureFloatEqual("((float) \"1.5\")", ((float) "1.5"), 1.5);
ensureVectorEqual("((vector) \"<1,2,3>\")", ((vector) "<1,2,3>"), <1,2,3>);
ensureRotationEqual("((quaternion) \"<1,2,3,4>\")", ((quaternion) "<1,2,3,4>"), <1,2,3,4>);
ensureStringEqual("((string) <1,2,3>)", ((string) <1,2,3>), "<1.00000, 2.00000, 3.00000>");
ensureStringEqual("((string) <1,2,3,4>)", ((string) <1,2,3,4>), "<1.00000, 2.00000, 3.00000, 4.00000>");
ensureStringEqual("((string) [1,2.5,<1,2,3>])", ((string) [1,2.5,<1,2,3>]), "12.500000<1.000000, 2.000000, 3.000000>");

// while
i = 0;
while(i < 10) ++i;
ensureIntegerEqual("i = 0; while(i < 10) ++i", i, 10);

// do while
i = 0;
do {++i;} while(i < 10);
ensureIntegerEqual("i = 0; do {++i;} while(i < 10);", i, 10);

// for
for(i = 0; i < 10; ++i);
ensureIntegerEqual("for(i = 0; i < 10; ++i);", i, 10);

// jump
i = 1;
jump SkipAssign;
i = 2;
@SkipAssign;
ensureIntegerEqual("i = 1; jump SkipAssign; i = 2; @SkipAssign;", i, 1);

// return
ensureIntegerEqual("testReturn()", testReturn(), 1);

// parameters
ensureIntegerEqual("testParameters(1)", testParameters(1), 2);

// variable parameters
i = 1;
ensureIntegerEqual("i = 1; testParameters(i)", testParameters(i), 2);

// recursion
ensureIntegerEqual("testRecursion(10)", testRecursion(10), 0);

// globals
ensureIntegerEqual("gInteger", gInteger, 5);
ensureFloatEqual("gFloat", gFloat, 1.5);
ensureStringEqual("gString", gString, "foo");
ensureVectorEqual("gVector", gVector, <1, 2, 3>);
ensureRotationEqual("gRot", gRot, <1, 2, 3, 4>);

// global assignment
gInteger = 1;
ensureIntegerEqual("gInteger = 1", gInteger, 1);

gFloat = 0.5;
ensureFloatEqual("gFloat = 0.5", gFloat, 0.5);

gString = "bar";
ensureStringEqual("gString = \"bar\"", gString, "bar");

gVector = <3,3,3>;
ensureVectorEqual("gVector = <3,3,3>", gVector, <3,3,3>);

gRot = <3,3,3,3>;
ensureRotationEqual("gRot = <3,3,3,3>", gRot, <3,3,3,3>);

// vector accessor
vector v;
v.x = 3;
ensureFloatEqual("v.x", v.x, 3);

// rotation accessor
rotation q;
q.s = 5;
ensureFloatEqual("q.s", q.s, 5);

// global vector accessor
gVector.y = 17.5;
ensureFloatEqual("gVector.y = 17.5", gVector.y, 17.5);

// global rotation accessor
gRot.z = 19.5;
ensureFloatEqual("gRot.z = 19.5", gRot.z, 19.5);

// list equality
list l = (list) 5;
list l2 = (list) 5;
ensureListEqual("list l = (list) 5; list l2 = (list) 5", l, l2);
ensureListEqual("list l = (list) 5", l, [5]);
ensureListEqual("[1.5, 6, <1,2,3>, <1,2,3,4>]", [1.5, 6, <1,2,3>, <1,2,3,4>], [1.5, 6, <1,2,3>, <1,2,3,4>]);

if (gTestsFailed > 0) {
llMessageLinked(LINK_SET, passFailChannel, "FAIL", NULL_KEY);
} else {
llMessageLinked(LINK_SET, passFailChannel, "PASS", NULL_KEY);
}

// reset globals
gInteger = 5;
gFloat = 1.5;
gString = "foo";
gVector = <1, 2, 3>;
gRot = <1, 2, 3, 4>;
gTestsPassed = 0;
gTestsFailed = 0;

}

//////////////////////////////////////////////////////////////////////////////////////////////////
//////////
////////// 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 broadcastChannel, string reportType )
{
string reportString;

//Normal - moderate level of reporting
if( reportType == "NORMAL" )
{
reportString = ""; //add what you would like to report here !!!!!!
}

//QUITE - shortest level of reporting
if( reportType == "QUIET" )
{
reportString = ""; //add what you would like to report here !!!!!!
}

//VERBOSE - highest level of reporting
if( reportType == "VERBOSE" )
{
reportString = ""; //add what you would like to report here !!!!!!
}

//AddUnitReport()
//send to Coordinator on the broadcastChannel the selected report
//format example -> AddUnitReport::unitKey::00000-0000-0000-00000::Report::Successful Completion of Test
llSay( broadcastChannel, "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()
{

}

///////////////////////////////////////////////////////////////////////////////////////
//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
</pre>

TestUnit TestScript LSL Language.lsl - Revision history

ObviousAltIsObvious Resident: language tags to

Uzume Grigorovich: typos

Uzume Grigorovich: lsl code tagging

Phoenix Linden at 22:58, 4 February 2008

Periapse Linden: New page:
/////////////////////////////////////////////////////////////////////////////////// /////// /////// /////// /////// TestUnit_TestScript /////// /////// ...