Testing Performance Of Various Byte Array / Binary Value Generation Methods In ColdFusion

<cfscript>

	a = javaCast( "byte[]", [ 32, 32, 32, 32, 32 ] );

	b = charsetDecode( repeatString( chr( 32 ), 5 ), "utf8" );

	c = createObject( "java", "java.nio.ByteBuffer" )
		.allocate( javaCast( "int", 5 ) )
		.put( javaCast( "byte", 32 ) )
		.put( javaCast( "byte", 32 ) )
		.put( javaCast( "byte", 32 ) )
		.put( javaCast( "byte", 32 ) )
		.put( javaCast( "byte", 32 ) )
		.array()
	;

	dStream = createObject( "java", "java.io.ByteArrayOutputStream" )
		.init( javaCast( "int", 5 ) )
	;
	dStream.write( javaCast( "int", 32 ) );
	dStream.write( javaCast( "int", 32 ) );
	dStream.write( javaCast( "int", 32 ) );
	dStream.write( javaCast( "int", 32 ) );
	dStream.write( javaCast( "int", 32 ) );
	d = dStream.toByteArray();

	e = repeatString( chr( 32 ), 5 ).getBytes();


	// ------------------------------------------------------------------------------- //
	// ------------------------------------------------------------------------------- //


	// Convert the values to HEX so we can easily compare them.
	aHex = binaryEncode( a, "hex" );
	bHex = binaryEncode( b, "hex" );
	cHex = binaryEncode( c, "hex" );
	dHex = binaryEncode( d, "hex" );
	eHex = binaryEncode( e, "hex" );

	writeOutput( "a: #aHex#<br />" );
	writeOutput( "b: #bHex#<br />" );
	writeOutput( "c: #cHex#<br />" );
	writeOutput( "d: #cHex#<br />" );
	writeOutput( "e: #eHex#<br />" );

	// Test equality through substitution principle.
	if ( ( aHex == bHex ) && ( bHex == cHex ) && ( cHex == dHex ) && ( dHex == eHex ) ) {

		writeOutput( "All values are equal" );

	} else {

		writeOutput( "Something went wrong!" );

	}

</cfscript>

<cfscript>

	// NOTE: This is here as a global variable for one of the tests.
	ByteBuffer = createObject( "java", "java.nio.ByteBuffer" );


	// Test each method to see how many iterations can be run in the same duration.
	writeOutput( "ByteBuffer: #numberFormat( runTest( testByteBuffer, 2000 ) )#<br />" );
	writeOutput( "ByteBuffer2: #numberFormat( runTest( testByteBuffer2, 2000 ) )#<br />" );
	writeOutput( "Manual Build: #numberFormat( runTest( testManualBuild, 2000 ) )#<br />" );
	writeOutput( "Repeat String: #numberFormat( runTest( testRepeatString, 2000 ) )#<br />" );
	writeOutput( "Repeat String2: #numberFormat( runTest( testRepeatString2, 2000 ) )#<br />" );
	writeOutput( "Output Stream: #numberFormat( runTest( testByteArrayOutputStream, 2000 ) )#<br />" );


	// ------------------------------------------------------------------------------- //
	// ------------------------------------------------------------------------------- //


	// I test the ByteArrayOutputStream by writing individual bytes to the stream.
	public void function testByteArrayOutputStream() {

		var stream = createObject( "java", "java.io.ByteArrayOutputStream" )
			.init( javaCast( "int", 1024 ) )
		;

		for ( var i = 1 ; i <= 1024 ; i++ ) {

			stream.write( javaCast( "int", 0 ) );

		}

		var buffer = stream.toByteArray();

	}


	// I test the ByteBuffer by creating the ByteBuffer static class each time.
	public void function testByteBuffer() {

		var buffer = createObject( "java", "java.nio.ByteBuffer" )
			.allocate( javaCast( "int", 1024 ) )
			.array()
		;

	}


	// I test the ByteBuffer by using a cached instance of the ByteBuffer class.
	// --
	// NOTE: This is a more realistic test as the Java class would likely be cached
	// inside whichever ColdFusion component was generating the binary values.
	public void function testByteBuffer2() {

		var buffer = ByteBuffer
			.allocate( javaCast( "int", 1024 ) )
			.array()
		;

	}


	// I test the manual building of individual bytes.
	public void function testManualBuild() {

		var bytes = [];

		arrayResize( bytes, 1024 );
		arraySet( bytes, 1, 1024, 0 );

		var buffer = javaCast( "byte[]", bytes );

	}


	// I test the string-to-bytes approach.
	// --
	// CAUTION: We are not actually creating an equivalent buffer here since this one
	// will be filled with the byte 32 (space). That said, I'm including this as part
	// of the test because this is completely fine in cases where all you need is an
	// intermediary buffer into which you will write bytes and then read those bytes.
	// In those cases, the initial value of the bytes in the buffer don't matter.
	public void function testRepeatString() {

		var buffer = charsetDecode( repeatString( " ", 1024 ), "utf8" );

	}


	// I test the string-to-bytes approach using the hidden Java method, getBytes().
	// --
	// CAUTION: We are not actually creating an equivalent buffer here since this one
	// will be filled with the byte 32 (space). That said, I'm including this as part
	// of the test because this is completely fine in cases where all you need is an
	// intermediary buffer into which you will write bytes and then read those bytes.
	// In those cases, the initial value of the bytes in the buffer don't matter.
	public void function testRepeatString2() {

		var buffer = repeatString( " ", 1024 ).getBytes();

	}


	// ------------------------------------------------------------------------------- //
	// ------------------------------------------------------------------------------- //


	// I run the given callback as many times as I can in the given duration and return
	// the iteration count.
	public numeric function runTest(
		required any callback,
		required numeric duration
		) {

		var targetTick = ( getTickCount() + duration );
		var count = 0;

		while ( getTickCount() < targetTick ) {

			count++;
			callback();

		}

		return( count );

	}

</cfscript>