The basics of what I did were taken from a forum posting which ultimately yielded the information I was looking for, but which presented commands I wasn’t prepared to run unvetted, and presented several different possible actions to take without being obvious which ones ended up being “correct”.

For full disclosure, the steps below worked for me on a Win7 x86_64 machine.

If I were to distill the action I took into a single command, ala the ones presented in the forum, it would be this:

reg add "HKEY_LOCAL_MACHINE\SOFTWARE\Classes\*\shell\Open with Sublime Text 2" /t REG_EXPAND_SZ /v "Icon" /d "C:\Program Files\Sublime Text 2\sublime_text.exe,0"

In truth though I was too chicken to run that actual command without fully understanding what I was doing. So here are the actual steps I took to add the icon:

• run `regedit` (windows-R -> “regedit” -> enter)
• Find (ctrl-F) “Open with Sublime Text 2″.
  • On my machine there were two results, one in HKEY_CLASSES_ROOT and one in HKEY_LOCAL_MACHINE. Based on the discussion in the forum post above I chose to use the one in HKEY_LOCAL_MACHINE
• Find the path to the executable being referenced by clicking on the “command” key under HKEY_LOCAL_MACHINE. It’s the “Data” portion of the Default key, minus the %1.
  • On my machine it was “C:\Program Files\Sublime Text 2\sublime_text.exe”
• Add new key:
  • select “Open with Sublime Text 2″
  • Choose the Edit->New->Expandable String Value menu item
  • Change name of new entry to “Icon”
  • Right click new value, select modify
  • Enter the value you picked up from the command key into the “Value data” field, with “,0″ added to the end
    • Example: “C:\Program Files\Sublime Text 2\sublime_text.exe,0″
  • Click “OK”
• Exit regedit

After those steps, you should have an Icon next to the “Edit with Sublime Text 2″ contextual menu item, like so:

I Need Another Text Editor Like I Need a Hole In The Head

An important piece of context for this post: I went looking for a new editor specifically because I was annoyed at switching between BBEdit on Mac and Notepad++ on Windows (I also use vi/vim/gvim on all platforms, but am not annoyed in the least with it). If either BBEdit of Notepad++ were on both platforms, I would be using it and not considering ST2. But they aren’t, and I am, and so much of this post is “how do I replicate this feature in Notepad++” or “I wish this cool BBEdit thing would work”. There’s even the short term effect of turning off interesting features in ST2 because I found them distracting. Long term I will revisit these choices, but in the short term my goal was to make ST2 as usable as BBEdit or Notepad++ as quickly as possible, even if that mean losing possible ST2 functionality.

Pay The Man

Sublime Text 2 is commercial software. It’s free to use right now (it is in beta) but the author reserves the right to charge in the future. After I used it for a while I didn’t need to wait. This software is definitely worth the $59 I paid for it, and I hope it motivates the author to keep working on it.

Settings

I might as well start this by jumping straight into the user settings. ST2 uses very readable JSON files to control things like preferences and keybindings. Setting “preferences” is really just opening a JSON file in the editor itself and typing away. All of the defaults are in a well-commented file, available from the “Settings – Default” menu option. Here’s a snippet of the file contents:

    // Set to true to insert spaces when tab is pressed
    "translate_tabs_to_spaces": false,

    // If translate_tabs_to_spaces is true, use_tab_stops will make tab and
    // backspace insert/delete up to the next tabstop
    "use_tab_stops": true,

    // Set to false to disable detection of tabs vs. spaces on load
    "detect_indentation": true,

    // Calculates indentation automatically when pressing enter
    "auto_indent": true,

Two great side effect of using a commented text file for configuration: Finding an option is as easy as searching for a keyword, and the configuration is versionable. The awesomeness of neither of these should be underestimated.

Once you find a setting you want to tweak, open the user-specific settings file (“Settings – User”) and add them there. Here is my current user-specific settings file, followed by some brief discussion of why I set the option:

{
    "auto_match_enabled": false,
    "auto_complete": false,
    "color_scheme": "Packages/Color Scheme - Default/Mac Classic.tmTheme",
    "draw_white_space": "all",
    "font_face": "Courier New",
    "trim_automatic_white_space": false,
}

• auto_match_enabled – This is a great example of what is probably a powerful feature that my own habits made me turn off. This option controls whether or not ST2 auto-closes braces and brackets for you. I really liked the idea of this option, but in practice it was more trouble than it was worth. It would auto-add the closing brace, and then I would either have to arrow/mouse past the auto-added closing brace, or forget that it had been added already and re-add it, which would cause me to go back and remove the extra closing brace. If I were to reimplement this feature, I would make ST2 try to detect whether I had just added an extra closing brace. If I had, ST2 should remove the auto-added brace. In the short term, it’s just easier to turn this feature off entirely.
• auto_complete – While I had it turned on, auto_complete was pretty interesting. The auto-complete of functions, language keywords, etc, was great. The problem is that the little box that popped up for auto-completion options while you typed, even if you didn’t want to auto-complete, that I had to turn it off. I think there are more tunables around this (for instance, increasing delay before completion options are presented, or requiring a manual keystroke to get completion options) but in the short term this option was actually making me less productive so I just turned it off.
• color_scheme – I wanted to like all the dark color schemes that ST2 had to choose from, but in the end I had to have a white background. The “Mac Classic” theme was the best “white background” theme I could find (which probably means it’s the closest to what Notepad++ uses by default).
• draw_white_space – Visual white space was one of the first features on Notepad++ that I became completely addicted to and could not live without. This option actually has three settings – “none”, “selection”, and “all”, with “selection” being the default. “Selection” (in which whitespace is only made visual in selected text) is actually a really nice idea, but I had gotten addicted to having it turned on all the time.
• font_face – When I first began using ST2 I had a hard time engaging with it. One of the factors were the dark-by-default themes, which I changed fairly quickly, but there was a lingering discomfort too that took me a while to identify. I eventually realized that I wasn’t comfortable with the default font. ST2 ships with “Consolas” as the default font on Windows, and “Menlo Regular” as the default on Mac OS X. Changing these both to “Courier New” made a huge difference in my comfort in making ST2 my default editor.
• trim_automatic_white_space – Another feature I turned off. ST2 has a fantastic auto-indenter (better than Notepad++’s in my opinion) but this feature worked against me. Apparently I move the I-beam around a lot when I am working, and this feature caused the auto-added whitespace to be removed when I (very temporarily) moved the I-beam off the line, which was pretty awful. I think one reason this was left on was that, technically, it results in “trailing white space” when you don’t type anything on a line. I happen to see this as a feature when also using visual white space

Sane Tab-Switching

Another tweak I made was changing the default tab-switching behavior. The default, stack-like, MRU-ish behavior was unnatural to me. I changed it to the more standard “cycle in tab order” style. This is done in the “Preferences -> Key Bindings – User” file, by adding these two lines:

    { "keys": ["ctrl+tab"], "command": "next_view" },
    { "keys": ["ctrl+shift+tab"], "command": "prev_view" }

Indenting

I’m of mixed opinion on ST2′s indenting vs. Notepad++’s (they are both better than BBEdit). Out of the box, I think Notepad++’s is better, but with some tweaking I’m starting to think that ST2 has pulled ahead.

Understanding Alternate Indenting Styles

ST2 is definitely better at following the indent of the previous line, rather than sticking slavishly to the indents set for the file. Specifically, consider the case of a single “line” of code split across multiple lines. In that case I “tab” to the natural indent, and then indent with spaces after that. In Notepad++, on the second space-indented line, it will indent with tabs, because it “knows” that tabs are the indent character for that doc. Sublime Text 2, on the other hand, will recognize that I’ve altered my indenting and will use the same indenting for following lines:

Notepadd++ annoyingly ignores the previous line and uses tabs in lines 3

Sublime Text 2 awesomely recognizes my indent style in line 2 and mimics it in line 3

Reindenting

One area I’m really torn over is “re-indenting”. I suspect that Sublime Text 2 is technically better at it, but that it’s more effort to make it work. I maintain a lot of legacy code has often been maintained by copying tabbed code out of a teminal and then pasted into a new file, resulting in 8-space indents, instead of the 4-space-tab indents we’ve agreed to use. In Notepad++, reindenting that code is very easy – Change a tab to 8-spaces in the preferences, select the entire block you want to re-indent, then hit tab (which indents the entire block one additional level, but also changes the 8-spaces into tabs), then hit shift-tab (which removes the extra indent level you just added, but leaves you with tabs instead of spaces). Then change you tabs back to 4-spaces, and you’re done. (It sounds complex as I read that back to myself, but it’s a fairly fluid action.)

Sublime Text 2, on the other hand, doesn’t quite do this (by default). It will block-indent/unindent of course, but it won’t automatically convert spaces to tabs. I finally realized that there’s an actual menu option to do what I want (Edit -> Line -> Reindent), and it works reasonably well. I haven’t figured out all of the nuances yet, but it is not 100% rock-solid as Notepad++’s functionality. It is good enough to use though. It lacks a default key binding, and I use it enough that I added one (Preferences -> Key Bindings – User) to bind ctrl+shift+r to Reindent:

    { "keys": ["ctrl+shift+r"], "command": "reindent" }

Awesome stuff

While I first focused on getting ST2 modified to be as similar as possible to Notepad++ or BBEdit, there are (at least) a few things that have stood out as being awesome and unique to Sublime Text 2 (as far as I know).

Scrolling Past “End Of File”

The first one is really simple but amazingly useful. When you scroll a file in ST2, you can scroll “past” the end of the file. In other words, you can scroll all the way until the last line of the file is the only visible line in the document (contrasting with the standard practice of allowing you to scroll until the last line in the file is on the last (bottom) visbile line in the editor window). This is shockingly useful, and not even abstractly – I’ve spent the last 15 years adding 20 lines of whitespace to the bottom of files as a poor-man’s version of this. Having it as a native feature in the editor is wonderful, and a great example of something I never would have thought to ask for, because “that’s not how editors work”.

“minimap”

The text for this post - how meta!

The minimap is another area that is phenomenal. It’s like a visual scroll-bar, with sensitity set halfway between just scrolling the I-beam with the arrow keys and dragging the actual scrollbar. It’s so good that I only just realized that the standard scrollbar doesn’t have arrows on the top and bottom – I’ve never needed to use them!

Easy and Powerful Layout Switching

Another feature I didn’t know I needed was the fast layout switching. The ability to quickly change from one-up to two-up, vertical or horizontal layouts is really powerful. Since there’s no cognitive overhead to changing the layout (View -> Layout -> (option)) or moving documents to different frames, I’m much more likely to use it to compare docs, or use another doc as a ref, which I’ve found has a noticeable performance benefit.

Project and Folders

One feature I didn’t really think I would use was projects, or adding folders to an editor window. It turns out that I tried it an instantly benefitted from it. I haven’t developed an ecosystem of “projects”, but I have found that I add and remove folders from my editor fairly regularly as I work. Being able to have all my files quickly reachable from within the editor itself, even if I don’t have them open for editing, is another time saver.

Open Issues

I don’t have a ton of open issues, but there are a couple of areas I’m still trying to figure out.

Unfocused Clicks on Minimap

The first is an issue with clicking in the minimap. When Sublime Text 2 is in focus, clicking in the minimap, but outside of the “this is what you’re currently looking at” grey box, will jump you to where you clicked. This makes sense. However, it does the exact same thing if the ST2 window does NOT have focus. I’ve lost the link now but this was raised on the ST2 forums and the author flatly stated that it wass working as designed and he would not change it. In my opinion this is a really poor design choice. I often switch back and forth between an editor, a terminal, and an scp client, and I can do it quickly my keeping parts of the windows visible and clicking into them. This works great until I click into ST2 and suddenly I’m in a completely different part of the file because the part that was visible to click was the minimap. More than anything, it surprised me that the author was so completely against it, to the point of being unwilling to offer a switch for the behavior. I’ve learned to live with it but I’m still puzzled at the choice.

“Find All” Results

In general I’ve found searching in ST2 to be as good as searching in Notepad++, possibly a little better. However, one of the few areas I’ve found in which Notepad++ is inarguably better (to the point where I suspect maybe I just haven’t found the right interface in ST2) is in the “Find all in document”, “Find all in open files”, and “Find in files” interfaces. It’s not that ST2 doesn’t have these options, it’s that the results are unusable. In Notepad++, there is a tray that opens from the bottom of the window that show all the matches and (if applicable), which file they are from. These results can be copied, they can be collapsed by file name, and double clicking the line takes you that that line in the appropriate file.

When searching in files, you can almost recreate the Notepad++ experience. The results are presenting as in a new document. Using a 2-up, row-based layout, you can have the results and the documents visible at the same time, and it appears that you can collapse files and double-click lines to go to the files. However, this might be a case where flexibility actually hampers instead of helps. I still much prefer the Notepad++ interface for this vs. the ST2 interface. Additionally, that only really seems to be for “find in files”. When doing “Find All” in just the active document, you end up with each match selected, but I haven’t found a good view of each of those matches. I’m not sure if this it a shortcoming of ST2 or my ability to use it, but the area of finding multiple matches is one of the few areas I think Notepad++ is genuinely a better use experience than ST2.

Split Screen Editing Of A Single Document

One last item I would like to have is, surprisingly, a feature in BBEdit that I haven’t found in either Notepad++ or Sublime Text 2, and that’s split-editing a single document. It’s can be wonderful to use one part of document as reference while editing a a different location in the same document. I bet you could kludge something up for this in both NPP and ST2, but the ease of just grabbing the “splitter” on the scrollbar to make it happen is pretty wonderful, and something I would love to have in ST2.

And For My Next Trick

This post has existed as a draft for the last several weeks. I knew it was time to finish it when I stopped noting “how to make ST2 as good as Notepad++” and started jotting down features I’d found that were entirely new. So,I’ll let this post stand for now, a summary of changes I made to bring the features of Sublime Text 2 quickly up to par with those of Notepad++ and BBEdit that I was used to using daily.

After remembering it yet again last night, I decided enough was enough, filed the roughest edges off of it, and posted it:

Ippsy, The Experimental Javascript Application

There’s not a lot of use to the internet at large in this tool (no one needs yet another IP Calculator), but the core of this app is written such that other screens/functions/pages/tools can be added to it. At some point I’ll get a wild hair to add something new and this frame will be available to do it.

There are a couple of design rules that I think make this project interesting. The first is that I intend it to never grow beyond a single HTML page with Javascript and CSS embedded directly in it. This is not the greatest design choice for manageability, but my goal is that this tool is not a “website”, it’s an application that runs in a browser. By making it a single HTML page app distribution is as simple as “save as”.

The second design choice, which is really driven by the first, is that I won’t use any external frameworks. No jQuery, no ExtJS, etc. I want to build this in relatively pure HTML/Javascript/CSS, while still making the site as pretty as possible (which it is not right now, I admit).

One specific goal I have not set it legacy browser version support. There’s nothing in the tool right now that’s especially troublesome for older browsers, but I won’t much care if I introduce a problem in the future. The app is very specifically targeted at “the browser I am using right now”, and more loosely targeted at “the last version or two of the bigger browsers”.

There, I published it. Now I can forget about it again for another year and see if anyone finds it…

The code I’ve published modifying or extending TestLink is now available in a github repository to make it easier to download and play with. The patches at github are not as granular as the diffs in the individual blog posts, but they are true patches and can be applied cleanly using the patch command.

The TestLink 1.9.3 API documentation I extracted via PHP doc is available for live browsing or for downloading.

Here are the individual posts I’ve made that attempt to extend or enhance TestLink:

• Alternating Test Step Row Colors in TestLink – better visual separation for test steps
• Better Copy/Paste When Editing Test Steps in TestLink – stop TestLink’s awful habit of editing a step when you click on it
• Setting Default Font in TestLink – How to force steps’ action and result text areas to be a monospace font by default
• UI Improvements for TestLink’s Vertical Step Layout – again with the alternating background color, but this time for the vertical layout
• TestLink 1.9.3 API Documentation
• Missing TestLink API Function – getExecutionResults()
• Example TestLink XMLRPC Clients in Perl

Test Runner

The first script is an example test runner, run-testplan-simple.pl, which can be found at https://github.com/jetmore/TestLink-Misc/blob/master/scripts/run-testplan-simple.pl or inline and collapsed at the end of this post. In terms of a full-featured test runner this is still pretty sparse, but it has some string points as an example:

• A demonstration of several more API methods than the standard perl example script
• An attempt at a reusable error checking function for api responses
• A method for storing external test information in test cases
• Example of posting results back to TestLink via tl.reportTCResult

Based on the amount of Google hits I’ve seen on other TestLink posts I’ve made, it looks like the usage information for tl.reportTCResult will be useful for people.

In my opinion the most useful thing in this script is the generalized error checking. The TestLink API is a mess in terms of standardized responses. There’s no “this is an error response” flag, so you have to determine errors heuristically, which is less than ideal. The isResponseError() function is my attempt to identify as many failure conditions as possible in one function.

The variables $testServer, $APIKey, and $projectName at the top of the script need to be uncommented and populated with the appropriate values. An API Key for your TestLink install can be generated from your user page in the TestLink UI.

Test Reporter

The second script is a reporter. Because we are in very early stages of implementing automated testing, we have many tests that are blocking (we wrote tests for functionality that isn’t implemented yet, and I chose to register that as a blocked test case in TestLink). So, at the moment, individual test case status is not very interesting to me. What is interesting is changes in status. If a test passed two nights ago, but blocked last night, I want to know about it.

I wrote get-testplan-status.pl (https://github.com/jetmore/TestLink-Misc/blob/master/scripts/get-testplan-status.pl) to do this reporting for me. This script is largely similar to run-testplan-simple.pl above, but it is a read-only script, which might make it more interesting for initial exploring.

This script also makes use of the non-standard API call getExecutionResults(). I wrote this new interface to allow more than one result to be returned for a test case. See http://www.jetmore.org/john/blog/2012/03/missing-testlink-api-function-getexecutionresults/ for more details on the function, including the code itself.

As with run-testplan-simple.pl, the variables $testServer, $APIKey, and $projectName at the top of the script need to be uncommented and populated with the appropriate values.

Code

The code for these two scripts at the time I wrote this post is included inline below, hopefully minimized…

run-testplan-simple.pl

#!/usr/bin/perl

# This is a sanitized version of the "nightly test runner" I bashed up for my company.
# It is very unlikely to be usable verbatim, but it shows some fundamental concepts:
#	- how to interact w/ TestLink XMLRPC api with a perl client
#	- an attempt at an error checking function for api responses
#	- a method for storing external test information in test cases
#	- how to post results back to TestLink

# -- John Jetmore, 2012

# yum install perl-Crypt-SSLeay
# yum install perl-RPC-XML
# http://www.softwaretestingconcepts.com/test-automation-using-testlink-xmlrpc-api-steps-and-sample-python-client-program
# http://search.cpan.org/~rjray/RPC-XML-0.71/
# http://jetmore.org/john/misc/phpdoc-testlink193-api/TestlinkAPI/TestlinkXMLRPCServer.html

use strict;

use RPC::XML;
use RPC::XML::Client;
use Data::Dumper;

# !!! You have to change all three of these to valid local settings to get this to work:
#my $testServer  = 'https://localhost/testlink/lib/api/xmlrpc.php';
#my $APIKey      = 'PUT_YOUR_API_ACCESS_KEY_IN_HERE';
#my $projectName = 'PUT_THE_NAME_OF_YOUR_PROJECT_HERE';

my $resp;
my $method;
my $options;
my $log      = -t STDIN ? 1 : 0; # only log if we're being run via a term
my %statuses = ('passed' => 'p', 'failed' => 'f', 'blocked' => 'b');

my $planName    = shift || die "Need Test Plan name to continue\n";

my $client = RPC::XML::Client->new($testServer);

#############
# Confirm test plan exists, get planID
$resp = $client->send_request('tl.getTestPlanByName', {
	'devKey' => $APIKey, 'testprojectname' => $projectName, testplanname => $planName
});
if (isResponseError($resp)) {
	die "An error occurred in getTestPlanByName ($main::apiLastResponseCode): $main::apiLastResponseString\n";
}
#print Dumper($resp); # uncomment to see what the raw response looks like
my $projectID = $resp->value->[0]{testproject_id};
my $planID    = $resp->value->[0]{id};
print "Found planID = $planID, projectID = $projectID\n" if ($log);

############
# This just picks the first build returned and uses it.  Errors if no build available
# for test plan.
$resp = $client->send_request('tl.getBuildsForTestPlan', {
	'devKey' => $APIKey, 'testplanid' => $planID
});
if (isResponseError($resp)) {
	die "An error occurred in getBuildsForTestPlan ($main::apiLastResponseCode): $main::apiLastResponseString\n";
}
#print Dumper($resp); # uncomment to see what the raw response looks like
my $buildID = $resp->value->[0]{id};
print "Found buildID = $buildID\n" if ($log);

###############
# Get all available test plan platforms.  This is kind of simple right now.  For now, if test runner is on linux, we will run
# any test case assigned to a plan with "Linux" in it, and same with Windows.  In future we probably want to filter
# on specific os releases and architectures
$resp = $client->send_request('tl.getTestPlanPlatforms', {
	'devKey' => $APIKey, 'testplanid' => $planID
});
if (isResponseError($resp)) {
	die "An error occurred in getTestPlanPlatforms ($main::apiLastResponseCode): $main::apiLastResponseString\n";
}
#print Dumper($resp); # uncomment to see what the raw response looks like
my %platformInfo = ();
# This heuristic was specific to my company's use.  Tailor to taste.
foreach my $platform (@{$resp->value()}) {
	if ($^O eq 'linux' && ($platform->{name} =~ /\bCentOS\b/i || $platform->{name} =~ /\bLinux\b/i)) {
		%platformInfo = %$platform;
		last;
	}
	elsif ($^O eq 'windows' && $platform->{name} =~ /\bWindows\b/i) {
		%platformInfo = %$platform;
		last;
	}
}
if (!$platformInfo{id}) {
	die "No available platform matched current platform\n" .
	    "Current: $^O\n" .
	    "Available: \n" . Dumper($resp->value());
}
print "Found platform = $platformInfo{id}, $platformInfo{name}\n" if ($log);

#################
# Now get all test cases in the test plan.
$resp = $client->send_request('tl.getTestCasesForTestPlan', {
	'devKey' => $APIKey, 'testplanid' => $planID,
});
if (isResponseError($resp)) {
	die "An error occurred in getTestCasesForTestPlan ($main::apiLastResponseCode): $main::apiLastResponseString\n";
}
#print Dumper($resp); # uncomment to see what the raw response looks like
my $respData  = $resp->value();
my %testCases = ();
# manually filter the test cases in the test plan against our currently selected platform
foreach my $caseID (keys %$respData) {
	foreach my $platformID (keys %{$respData->{$caseID}}) {
		if ($platformID eq $platformInfo{id} && $respData->{$caseID}{$platformID}{active} == 1) {
			$testCases{$caseID}{$platformID} = $respData->{$caseID}{$platformID};
		}
	}
}
#print Dumper(\%testCases);
print "Found ", scalar(keys(%testCases)), " test cases to run\n" if ($log);

###########################
# Now we loop and execute
foreach my $caseID (keys %testCases) {

	# As far as I can tell there's no real standard for how external test information is stored
	# in a testlink testcase.  We chose to pursue:
	#	1) 1 external test script per test case
	#	2) external test "configs" are stored in the testcase's "summary" field
	#	3) configs are:
	#		- one config per line
	#		- line format is KEY: VALUE
	#	4) Specific keys:
	#		- TestScript - complete path, including executable, of external test script
	#		- TestScriptOptions - Any command line options for TestScript
	#		- TestType - free text right now, but allow us a way to tell the test executor to run
	#		             different tests
	foreach my $platformID (keys %{$testCases{$caseID}}) {
		my $notes       = "";
		my $status      = "";
		my $tc          = $testCases{$caseID}{$platformID};
		my $caseConfigs = getCaseConfigs($tc->{summary});

		if (!$caseConfigs->{TestScript}) {
			$notes  = "Can't execute test, no TestScript set on test case";
			$status = $statuses{blocked};
		}
		else {
			($status,$notes) = getTestStatus($caseConfigs->{TestScript}, $caseConfigs->{TestScriptOptions});
		}
		$resp = $client->send_request('tl.reportTCResult', {
			'devKey'     => $APIKey,
			'testcaseid' => $caseID,
			'testplanid' => $planID,
			'status'     => $status,
			'buildid'    => $buildID,
			'notes'      => $notes,
			'platformid' => $platformID,
		});
		if (isResponseError($resp)) {
			print STDERR "Unable to save result for TC:$caseID, platform:$platformID:\n",
			             "\t($main::apiLastResponseCode): $main::apiLastResponseString\n",
			             "\t\$notes = $notes\n",
			             "\t\$status = $status\n";
		}
		print "TC:$caseID, P:$platformID, $status", ($notes =~ m|\n|sm ? '' : ", $notes"), "\n" if ($log);
	}
}

exit;

sub getTestStatus {
	my $testScript  = shift;
	my $testOptions = shift;
	$testScript    = "/path/to/standard/test/repo/$testScript" if ($testScript !~ m|^/|);

	if (!-e $testScript) {
		return($statuses{blocked}, "$testScript does not exist");
	}
	elsif (!-x $testScript) {
		return($statuses{blocked}, "$testScript is not executable");
	}

	# this needs to be more flexible long term (path to perl and base needs to be flexible)
	my $cmd = "$testScript $testOptions 2>&1";
	if (!open(P, "$cmd |")) {
		return($statuses{blocked}, "Error opening pipe to $cmd: $!");
	}
	my $output = join('', <P>);
	close(P);

	if ($?) {
		return($statuses{failed}, $output);
	}
	elsif ($output =~ /TODO/) {
		# We're using perl test harnesses for our initial implementation, so we have a very specific
		# check here that, even if the external test script returned "0" (success), we still need
		# to mark the test case as blocked if there's any "TODO" individual tests

		# this might need to be changed, but for now if there's a TODO, set the status to block
		# to indicate that, while it's not a hard failure, it's still not "right" yet.
		return($statuses{blocked}, $output);
	}
	return($statuses{passed}, $output);
}

# take a case's summary field and return a ref to a hash containing key->value pairs.
# the summary field might look like this:
#<div>
#<div>TestScript: coreAAA-ui/Users.t</div>
#<div>TestType: Standard</div>
#</div>
sub getCaseConfigs {
	my $summary = shift;
	my $null    = chr(0);
	my %config  = ();

	$summary =~ s|</div>\n<div>|$null|smg;
	$summary =~ s|</?div>|$null|g;
	$summary =~ s|$null{2,}|$null|;
	$summary =~ s|^$null+||;
	$summary =~ s|$null+$||;

	foreach my $pair (split(/$null/, $summary)) {
		next if ($pair =~ m|^\s*$|); # silently skip blank lines
		$pair =~ s|<[^>]+>||g;
		$pair =~ s|\n||gsm;
		if ($pair !~ m|^\w+:\s|) {
			print STDERR "saw config line '$pair', can't normalize to 'key: value', skipping\n";
			next;
		}
		else {
			my($k,$v) = split(/:\s+/, $pair, 2);
			$config{$k} = $v;
		}
	}

	return(\%config);
}

# Hoo boy is the API for TestLink messed up when it comes to error checking.  This is my best attempt
# at a single function that checks for error states in the returned object.  It works for every function
# I've used it on, but it wouldn't surprise me a bit if it incorrectlt reported an error condition
# for interfaces I haven't tried yet.

# takes a response from an API call and tells you if it is an error or not.
# returns one of the following:
# 0 - no error, we have data in the object
# 1 - API error - we received an error in the API response itself
# 2 - unknown local error
# 3 - unknown local HTTP level error (bad URL, remote host offline, etc)
# 4 - XMLRPC fault (for instance, incorrect RPC method name)
# 5 - unknown API response type (no data in response, unsure if this error type exists)
# 6 - code error in this module - shouldn't happen
# Also sets:
#    $main::apiLastResponseCode  - return code as described above
#    $main::apiLastResponseString - a text string describing the last api response (typically
#                                   something like the description above, plus any error text
#                                   that might have been returned by the tools
sub isResponseError {
	my $apiResp = shift;

	my $code = \$main::apiLastResponseCode;
	my $text = \$main::apiLastResponseString;

	$$code = 6;
	$$text = "unknown subroutine error";

	if (!$apiResp) {
		$$code = 2;
		$$text = "Unknown local error";
		#print STDERR "Request failed, exiting\n";
		#exit 1;
	}
	elsif (!ref($apiResp)) {
		# can get this by using incorrect url (I added "2" to the end of the URL)
		$$code = 3;
		$$text = "Local request error: $apiResp";
	}
	elsif ($apiResp->is_fault) {
		# can get this by using an incorrect method (I changed method to "getTestPlanByName2")
		#print STDERR "XMLRPC Fault: ", $resp->value->{faultCode}, ": ", $resp->value->{faultString}, "\n";
		#exit 3;
		$$code = 4;
		$$text = 'XMLRPC Fault: ' . $resp->value->{faultCode} . ': ' . $resp->value->{faultString};
	}
	else {
		my $respData = $resp->value;

		#print Dumper($respData), "\n";

		# note every valid response returns an array ref for data (see getTestCasesForTestPlan), so
		# split our error checking
		if (ref($respData) eq 'ARRAY') {
			if (scalar(@$respData) == 0) {
				# not sure if this is a real condition or not
				#print STDERR "Unexpected response from server: No objects in response\n";
				#exit 4;
				$$code = 5;
				$$text = "Unexpected response from server: No objects in response";
			}
			# there's no single "API Error" flag, this is the best test I could come up with
			# It is an API error response if:
			#  - the data is an array ref
			#  - the first element in the array is a hash ref
			#  - that hash has exactly two keys
			#  - the two keys are {code} and {message}
			# One interesting thing to note is that you can have two error objects (for instance, if you make a
			# getTestPlanByName call with an invalid API Key, you will get two errors, the first will be "Invalid
			# API Key" and the second will be "Test Plan Not Found").  It appears that the first is the most relevant,
			# so I'll be using it as if it were the sole error
			#elsif (isError($respData)) {
			elsif (ref($respData->[0]) eq 'HASH' && scalar(keys(%{$respData->[0]})) == 2 &&
					exists($respData->[0]{code}) && exists($respData->[0]{message})) {
				# simulate by passing in a plan name that doesn't exist
				#print "Unable to find testplan '$planName': ($respData->[0]{code}) $respData->[0]{message}\n";
				#exit 5;
				$$code = 1;
				$$text = "($respData->[0]{code}) $respData->[0]{message}";
			}
			# turing off the checking for this state, I don't think it's a global error condition
			#elsif (scalar(@$respData) > 1) {
			#	# not sure if this is a real error state or not
			#	print STDERR "Something unexpected happened - received >1 items in response to getTestPlanByName:\n", Dumper($respData), "\n";
			#	exit 6;
			#}
			else {
				$$code = 0;
				$$text = "";
			}
		}
		# I haven't seen very many example of the data key being a hash, assume it's always ok for now
		elsif (ref($respData) eq 'HASH') {
			$$code = 0;
			$$text = "";
		}
	}
	return $$code;
}

get-testplan-status.pl

#!/usr/bin/perl

# yum install perl-Crypt-SSLeay
# yum install perl-RPC-XML
# http://www.softwaretestingconcepts.com/test-automation-using-testlink-xmlrpc-api-steps-and-sample-python-client-program
# http://search.cpan.org/~rjray/RPC-XML-0.71/
# http://jetmore.org/john/misc/phpdoc-testlink193-api/TestlinkAPI/TestlinkXMLRPCServer.html

use strict;

use RPC::XML;
use RPC::XML::Client;
use Data::Dumper;

my $dumpRaw    = 0;
# !!! You have to change all three of these to valid local settings to get this to work:
#my $testServer  = 'https://localhost/testlink/lib/api/xmlrpc.php';
#my $APIKey      = 'PUT_YOUR_API_ACCESS_KEY_IN_HERE';
#my $projectName = 'PUT_THE_NAME_OF_YOUR_PROJECT_HERE';

my $resp;
my $method;
my $options;
my $log      = -t STDIN ? 1 : 0; # only log if we're being run via a term
my %statuses = ('passed' => 'p', 'failed' => 'f', 'blocked' => 'b');

my $planName    = shift || die "Need Test Plan name to continue\n";

my $client = RPC::XML::Client->new($testServer);

#############
# Confirm test plan exists, get planID
$resp = $client->send_request('tl.getTestPlanByName', {
	'devKey' => $APIKey, 'testprojectname' => $projectName, testplanname => $planName
});
if (isResponseError($resp)) {
	die "An error occurred in getTestPlanByName ($main::apiLastResponseCode): $main::apiLastResponseString\n";
}
#print Dumper($resp);
my $projectID = $resp->value->[0]{testproject_id};
my $planID    = $resp->value->[0]{id};
print "Found planID = $planID, projectID = $projectID\n" if ($log);

############
# In the future, get all builds, pick the right one if it exists, or create new.
# For now though, just assign all tests to the 'HEAD' build
$resp = $client->send_request('tl.getBuildsForTestPlan', {
	'devKey' => $APIKey, 'testplanid' => $planID
});
if (isResponseError($resp)) {
	die "An error occurred in getBuildsForTestPlan ($main::apiLastResponseCode): $main::apiLastResponseString\n";
}
#print Dumper($resp);
my $buildID = $resp->value->[0]{id};
print "Found buildID = $buildID\n" if ($log);

###############
# Get all available test plan platforms.  This is kind of simple right now.  For now, if test runner is on linux, we will run
# any test case assigned to a plan with "Linux" in it, and same with Windows.  In future we probably want to filter
# on specific os releases and architectures
$resp = $client->send_request('tl.getTestPlanPlatforms', {
	'devKey' => $APIKey, 'testplanid' => $planID
});
if (isResponseError($resp)) {
	die "An error occurred in getTestPlanPlatforms ($main::apiLastResponseCode): $main::apiLastResponseString\n";
}
#print Dumper($resp);
my %platformInfo = ();
foreach my $platform (@{$resp->value()}) {
	$platformInfo{$platform->{id}} = $platform;
}

#################
# Now get all test cases in the test plan.
$resp = $client->send_request('tl.getTestCasesForTestPlan', {
	'devKey' => $APIKey, 'testplanid' => $planID,
});
if (isResponseError($resp)) {
	die "An error occurred in getTestCasesForTestPlan ($main::apiLastResponseCode): $main::apiLastResponseString\n";
}
#print Dumper($resp);
my $respData  = $resp->value();
my %testCases = ();
# manually filter the test cases in the test plan against our currently selected platform
foreach my $caseID (keys %$respData) {
	foreach my $platformID (keys %{$respData->{$caseID}}) {
	#	if ($platformID eq $platformInfo{id} && $respData->{$caseID}{$platformID}{active} == 1) {
			$testCases{$caseID}{$platformID} = $respData->{$caseID}{$platformID};
	#	}
	}
}
#print Dumper(\%testCases);
print "Found ", scalar(keys(%testCases)), " test cases to run\n" if ($log);

###########################
# Now we loop and execute
my %tcResults = ();
foreach my $caseID (keys %testCases) {
	$resp = $client->send_request('tl.getExecutionResults', {
		'devKey' => $APIKey, 'testplanid' => $planID, 'testcaseid' => $caseID, 'numexecs' => 2,
	});
	if (isResponseError($resp)) {
		die "An error occurred in getExecutionResult ($main::apiLastResponseCode): $main::apiLastResponseString\n";
	}
	$tcResults{$caseID}{results} = $resp->value();
	$tcResults{$caseID}{configs} = getCaseConfigs($testCases{$caseID}{(keys(%{$testCases{$caseID}}))[0]}{summary});
	#print Dumper($resp);
}

# this is super quick and dirty.  Long term I would like to see an email that has an attachment which is a CSV file
# with values like this:
# package,component,testScript,platform,ExecDate,Status
# CoreDevice,Categories,Categories.t,server - CentOS 5.5 x86_64,2012-03-27 15:31:03,failed
# and with an easily-readible body that includes HTML like the following (only include lines for case/platform
# pairs that have changed status:
# TCID,TestScript,Platform,prevExecTime,lastExecTime
# 1234,codeDevice-ui/Categories.t,server - CentOS 5.5 x86_64,2012-03-26 14:31:03,2012-03-27 15:31:03
# the key to the HTML in the body is that the BGcolor for the last two cells will indicate the status of
# that test run (green = passed, red = failed, blue = blocked, black = not run).  This allows an easily-scannable
# list of _changed_ test cases.

# For now though, just use text.  Also ignore platform for right now.
foreach my $caseID (keys %tcResults) {
	my $r = $tcResults{$caseID}{results};
	my $c = $tcResults{$caseID}{configs};
	# skip if it's never been run
	next if ($r->[0]{id} == -1);
	# skip if there's not a change in the results
	next if ($r->[0]{status} eq $r->[1]{status});

	#print "$caseID $tcResults{$caseID}{configs}{TestScript} $r->[1]{status} -> $r->[0]{status}\n";
	printf "%-8s %6s %s\n               %3s %20s -> %3s %20s\n",
		$caseID,
		"$r->[1]{status} -> $r->[0]{status}",
		$c->{TestScript},
		$r->[1]{platform_id}, $r->[1]{execution_ts},
		$r->[0]{platform_id}, $r->[0]{execution_ts};
}

exit;

# take a case's summary field and return a ref to a hash containing key->value pairs.
# the summary field might look like this:
#<div>
#<div>TestScript: coreAAA-ui/Users.t</div>
#<div>TestType: Standard</div>
#</div>
sub getCaseConfigs {
	my $summary = shift;
	my $null    = chr(0);
	my %config  = ();

	$summary =~ s|</div>\n<div>|$null|smg;
	$summary =~ s|</?div>|$null|g;
	$summary =~ s|$null{2,}|$null|;
	$summary =~ s|^$null+||;
	$summary =~ s|$null+$||;

	foreach my $pair (split(/$null/, $summary)) {
		next if ($pair =~ m|^\s*$|); # silently skip blank lines
		$pair =~ s|<[^>]+>||g;
		$pair =~ s|\n||gsm;
		if ($pair !~ m|^\w+:\s|) {
			print STDERR "saw config line '$pair', can normalize to 'key: value', skipping\n";
			next;
		}
		else {
			my($k,$v) = split(/:\s+/, $pair, 2);
			$config{$k} = $v;
		}
	}

	return(\%config);
}

# takes a response from an API call and tells you if it is an error or not.
# returns one of the following:
# 0 - no error, we have data in the object
# 1 - API error - we received an error in the API response itself
# 2 - unknown local error
# 3 - unknown local HTTP level error (bad URL, remote host offline, etc)
# 4 - XMLRPC fault (for instance, incorrect RPC method name)
# 5 - unknown API response type (no data in response, unsure if this error type exists)
# 6 - code error in this module - shouldn't happen
# Also sets:
#    $main::apiLastResponseCode  - return code as described above
#    $main::apiLastResponseString - a text string describing the last api response (typically
#                                   something like the description above, plus any error text
#                                   that might have been returned by the tools
sub isResponseError {
	my $apiResp = shift;

	my $code = \$main::apiLastResponseCode;
	my $text = \$main::apiLastResponseString;

	$$code = 6;
	$$text = "unknown subroutine error";

	if (!$apiResp) {
		$$code = 2;
		$$text = "Unknown local error";
		#print STDERR "Request failed, exiting\n";
		#exit 1;
	}
	elsif (!ref($apiResp)) {
		# can get this by using incorrect url (I added "2" to the end of the URL)
		$$code = 3;
		$$text = "Local request error: $apiResp";
	}
	elsif ($apiResp->is_fault) {
		# can get this by using an incorrect method (I changed method to "getTestPlanByName2")
		#print STDERR "XMLRPC Fault: ", $resp->value->{faultCode}, ": ", $resp->value->{faultString}, "\n";
		#exit 3;
		$$code = 4;
		$$text = 'XMLRPC Fault: ' . $resp->value->{faultCode} . ': ' . $resp->value->{faultString};
	}
	else {
		my $respData = $resp->value;

		#print Dumper($respData), "\n";

		# note every valid response returns an array ref for data (see getTestCasesForTestPlan), so
		# split our error checking
		if (ref($respData) eq 'ARRAY') {
			if (scalar(@$respData) == 0) {
				# not sure if this is a real condition or not
				#print STDERR "Unexpected response from server: No objects in response\n";
				#exit 4;
				$$code = 5;
				$$text = "Unexpected response from server: No objects in response";
			}
			# there's no single "API Error" flag, this is the best test I could come up with
			# It is an API error response if:
			#  - the data is an array ref
			#  - the first element in the array is a hash ref
			#  - that hash has exactly two keys
			#  - the two keys are {code} and {message}
			# One interesting thing to note is that you can have two error objects (for instance, if you make a
			# getTestPlanByName call with an invalid API Key, you will get two errors, the first will be "Invalid
			# API Key" and the second will be "Test Plan Not Found").  It appears that the first is the most relevant,
			# so I'll be using it as if it were the sole error
			#elsif (isError($respData)) {
			elsif (ref($respData->[0]) eq 'HASH' && scalar(keys(%{$respData->[0]})) == 2 &&
					exists($respData->[0]{code}) && exists($respData->[0]{message})) {
				# simulate by passing in a plan name that doesn't exist
				#print "Unable to find testplan '$planName': ($respData->[0]{code}) $respData->[0]{message}\n";
				#exit 5;
				$$code = 1;
				$$text = "($respData->[0]{code}) $respData->[0]{message}";
			}
			# turing off the checking for this state, I don't think it's a global error condition
			#elsif (scalar(@$respData) > 1) {
			#	# not sure if this is a real error state or not
			#	print STDERR "Something unexpected happened - received >1 items in response to getTestPlanByName:\n", Dumper($respData), "\n";
			#	exit 6;
			#}
			else {
				$$code = 0;
				$$text = "";
			}
		}
		# I haven't seen very many example of the data key being a hash, assume it's always ok for now
		elsif (ref($respData) eq 'HASH') {
			$$code = 0;
			$$text = "";
		}
	}
	return $$code;
}

Fear my drawing skills...

I finally got grumpy enough to try to find a solution for it today. The obvious “edit every old post to remove double-spaces” seemed inefficient, and frankly I’m not likely to retrain myself to use only one space for future posts.

I assumed this would be a well known issue and there would a tuneable or a plugin to address it, but it turned out to be really hard to Google the right terms. I have actually decided not to change anything on my system based on my findings, but I wanted to document what I learned.

First, I did find a few plugins, but nothing that looked especially well-made. I never even installed one, because they all looked so suspect that I assumed they would reformat all my code snippets also. I care much more about the formatting in those code snippets than I do the double-space issue.

Next, after looking at the page source and seeing that there were two spaces present and not, say ‘ ’ characters (*foreshadowing*), I tried to reproduce the problem outside of WP, mimicking the WP CSS. No luck.

I finally managed to Google up this WP support page where the reporter is describing the exact issue I am having. What’s interesting to me is that this is a relatively new ticket and he’s told that there’s no solution. It does point out what’s actually happening though:

What happens is that when you put two spaces in a row in the visual editor, wordpress converts it to “space + unicode_nbsp”

Ah. That’s right, always use tools that won’t lie to me. Of course view-source is just translating that unicode character (correctly) to a space. That’s what the character is supposed to look like. I can confirm that’s what’s happening though. I grabbed a copy of a post with wget and looked at the output with xxd:

"20" is the real space, "c2a0" is U+00A0, the Unicode non-breaking space.

While that page itself doesn’t offer a solution, it mentions WP bug 19936, and that bug actually contains the solution. Essentially, the root of the problem is the TinyMCE editor that is used to provide the WYSIWYG functionality of the WP “Visual” editor. TinyMCE was the component translating trailing spaces into non-breaking spaces. That ticket is actually closed because the 3.4 release will include a newer version of TinyMCE which employs slightly better logic about which space to make non-breaking.

Again, none of that really helps me right now, and I suspect that it won’t help old posts in the future either because, once it’s been saved that way in the DB, the trailing space has already been translated to a non-breaking space (it just looks like a regular space in the text editor). Also, 3.4 isn’t released yet, so that’s not a help on newer posts.

What does work, though, is just using the HTML editor instead of the Visual editor. Normally I would say that this is a poor solution, but I had already sworn off the Visual editor in the past week after getting too fed up with how it irreparably mangles code snippets.

I still don’t have a solution for old posts that I created in the visual editor. I toyed with the idea of creating some javascript to do it dynamically but I don’t really care enough to. I may go back and edit the articles that still show up on the main page, but in the end just knowing the cause of the problem and how to avoid/fix it in the future is enough for right now.

Update: I actually went back and edited the last 10 posts, replacing the unicode_nonbreak with a regular ASCII space character. I wasn’t going to, but I figured out a relatively easy way to do it. I had feared I wouldn’t be able to do a bulk find and replace for fear of harming other formatting. I found that a good text editor (I used Notepad++) can do a find and replace on the specific U+00A0 character very quickly. I couldn’t figure out how to type that character, but I could copy it from the post and paste it into the search box, then type a regular space into the replace box. Since the find/replace box stays open all the time, I could copy the text out of the post, paste it into n++, replace all, copy out of n++, and paste into WP very quickly. Once I figure out what I was doing it took about 3 minutes to fix those 10 posts. If I had a very large site I would probably write a tool to do a find/replace against the DB directly, but this solution worked fine for me.

After getting nightly automated testing running, I wanted a very simple script which would, for each test case in a given test plan, compare the last and the second to last result and print a warning if they were different. Long term I will have better automated reporting, but our test script library is still so new that it’s not really news that a lot of them are failing. What would be news is if a specific test case passed two nights ago but failed last night.

This seemed like a really easy thing to do, but I couldn’t find an API function to support it. The closest thing I could find was getLastExecutionResult(), but that only gave me the last execution, it didn’t give me the execution history I needed. I also could have leveraged the fact that getTestCasesForTestPlan() includes each case’s last execution status to have done in-place alarming if the new status didn’t match the old status, but I felt like that would limit my ability to expand reporting in the future. I toyed with the idea of getting the info out of the DB directly, but decided instead of just implement the API function I needed. It’s mostly a copy of getLastExecutionResult(), but it has an added parameter numexecs which allows you to specify how many executions to return.

I hope to wrap all of these TestLink patches up into a better place at some point in the future, but for now it feels better to just get the code out where Google can find it as fast as possible.

Here’s the patch for adding the getExecutionResults() function:

Update 2012-05-08: There’s a real, usable-with-patch-command patch file for this change available at the github repo I started for my TestLink changes.

--- xmlrpc.class.php	(revision 268)
+++ xmlrpc.class.php	(revision 270)
@@ -176,6 +176,7 @@
 	public static $testSuiteNameParamName = "testsuitename";
 	public static $timeStampParamName = "timestamp";
     public static $titleParamName = "title";
+    public static $numexecsParamName = "numexecs";

     public static $urgencyParamName = "urgency";
@@ -255,6 +256,7 @@
 	                            'tl.getBuildsForTestPlan' => 'this:getBuildsForTestPlan',
 	                            'tl.getLatestBuildForTestPlan' => 'this:getLatestBuildForTestPlan',
                                 'tl.getLastExecutionResult' => 'this:getLastExecutionResult',
+                                'tl.getExecutionResults' => 'this:getExecutionResults',
 	                            'tl.getTestSuitesForTestPlan' => 'this:getTestSuitesForTestPlan',
 	                            'tl.getTestSuitesForTestSuite' => 'this:getTestSuitesForTestSuite',
 	                            'tl.getTestCasesForTestSuite'	=> 'this:getTestCasesForTestSuite',
@@ -1220,8 +1222,78 @@

 		return $maxbuild;
 	}
-
+
 	/**
+	 * Gets the result of LAST EXECUTION for a particular testcase
+	 * on a test plan, but WITHOUT checking for a particular build
+	 *
+	 * @param struct $args
+	 * @param string $args["devKey"]
+	 * @param int $args["tplanid"]
+	 * @param int $args["testcaseid"]: optional, if does not is present
+	 *                                 testcaseexternalid must be present
+	 *
+	 * @param int $args["testcaseexternalid"]: optional, if does not is present
+	 *                                         testcaseid must be present
+	 * @param int $args["numexecs"]: optional.  If set, number of cases to
+	 *                               return.  If unset, all will be returned
+	 *
+	 * @return mixed $resultInfo
+	 *               if execution found, array with these keys:
+	 *               id (execution id),build_id,tester_id,execution_ts,
+	 *               status,testplan_id,tcversion_id,tcversion_number,
+	 *               execution_type,notes.
+	 *
+	 *               if test case has not been execute,
+	 *               array('id' => -1)
+	 *
+	 * @access public
+	 */
+	public function getExecutionResults($args)
+	{
+		$operation=__FUNCTION__;
+		$msg_prefix="({$operation}) - ";
+
+		$this->_setArgs($args);
+		$resultInfo = array();
+		$status_ok=true;
+
+		// Checks are done in order
+		$checkFunctions = array('authenticate','checkTestPlanID','checkTestCaseIdentity');
+
+		$status_ok=$this->_runChecks($checkFunctions,$msg_prefix) &&
+		           $this->_checkTCIDAndTPIDValid(null,$msg_prefix) &&
+		           $this->userHasRight("mgt_view_tc");
+
+		if( $status_ok )
+		{
+			// get all, then return last
+			$sql = " SELECT * FROM {$this->tables['executions']} " .
+			       " WHERE testplan_id = {$this->args[self::$testPlanIDParamName]} " .
+			       " AND tcversion_id IN (" .
+			       " SELECT id FROM {$this->tables['nodes_hierarchy']} " .
+			       " WHERE parent_id = {$this->args[self::$testCaseIDParamName]})" .
+			       " ORDER BY id DESC";
+
+			$limit   = $this->args[self::$numexecsParamName] > 0 ? $this->args[self::$numexecsParamName] : -1;
+			$records = $this->dbObj->get_recordset($sql, null, $limit);
+
+			if(null == $records)
+			{
+				// has not been executed
+				// execution id = -1 => test case has not been runned.
+				$resultInfo[]=array('id' => -1);
+			}
+			else
+			{
+				$resultInfo = $records;
+			}
+		}
+
+		return $status_ok ? $resultInfo : $this->errors;
+	}
+
+	/**
      * Gets the result of LAST EXECUTION for a particular testcase
      * on a test plan, but WITHOUT checking for a particular build
      *

This function suffers from a few warts, but they are ones mostly inherited from getLastExecutionResult(). If I were to polish this up (beyond my normal TestLink API beefs like some sort of standardized return format), I would definitely add optional buildid and platformid parameters so you could narrow down the executions you’re looking for even more. But that’s a problem for another day…

In short, expect’s [exec] functionality requires SIGCHLD to be functional to work correctly. If you have ignored the signal, you get a very nice explanation of why your script has just died. For instance:

lappy 0 /home/jetmore/swap > cat ./run-expect
#!/usr/bin/expect
trap SIG_IGN SIGCHLD
puts "[exec date]: Expect: This is stdout"
lappy 0 /home/jetmore/swap > ./run-expect
Wed Mar 28 13:16:44 CDT 2012
error waiting for process to exit: child process lost (is SIGCHLD ignored or trapped?)
    while executing
"exec date"
    invoked from within
"puts "[exec date]: Expect: This is stdout""
    (file "./run-expect" line 3)

This is great if you’re actually seeing the script’s STDERR. As it happened I was presented with this problem in an environment in which, coincidentally, the tool executing the expect script was also throwing away STDERR. Any attempt I made to capture STDERR or STDOUT made the script start working. A heisenbug. I finally saw the error above by attaching the the expect script using strace -e write=2 -p $PID

After confirming that the calling tool was indeed setting SIGCHLD to IGNORE and that manually ignoring SIGCHLD broke the script (as in the example above), I found that the following script (which sets SIGCHLD back the the system’s default behavior) would survive even if the caller had IGNOREd SIGCHLD:

#!/usr/bin/expect
trap SIG_DFL SIGCHLD
puts "[exec date]: Expect: This is stdout"

So, the hopefully-googleable moral of the story is that expect’s exec function requires that SIGCHLD not be set to ignore, and this should be checked if your expect script is working in one environment but not another (ie, working from command line but failing when called by another program).

Downloads:

• Project Page: http://jetmore.org/john/code/swaks/
• v20120320.0 distribution: http://jetmore.org/john/code/swaks/swaks-20120320.0.tar.gz
• v20120320.0 script only: http://jetmore.org/john/code/swaks/swaks-20120320.0/swaks
• v20120320.0 reference: http://jetmore.org/john/code/swaks/swaks-20120320.0/doc/ref.txt
• v20120320.0 changelog: http://jetmore.org/john/code/swaks/swaks-20120320.0/doc/Changes.txt

IPv6 Support

The largest feature of this release is IPv6 support. This functionality survived a reasonable pre-release test period largely intact. I am still not convinced that my handling of MX records that point to both IPv4 and IPv6 domains is the best, but I didn’t receive any feedback on alternate solutions. I decided to release as is and see how my initial implementation held up to wider use.

New Features:

• -4 and -6 options to force IPv4 or IPv6.
• Added –local-port option
• Added –dump-as-body and –dump-as-body-shows-password options, allowing session configuration information to be sent in the test email itself. (Suggested by Chris Pimlott)
• –dump (and therefore –dump-as-body) includes a new line for a “reconstructed command line”. This is a sort of a synthetic command line including the real command line, any environment variable configs, and any config files.

Notable Changes:

• The DIGEST-SHA1 authentication type now requires the Digest::SHA perl module instead of Digest::SHA1. Digest::SHA1 has always been an extra install step, while Digest::SHA has been in the core perl distribution for many years. (Suggested by Andreas Metzler)
• The -m option, marked deprecated since 2007, has been removed.

Notable Bugs Fixed:

• In some very rare cases, a server response can be a base64-encoded success response, or a plaintext failure. Previously in that situation swaks did not handle the case of the plaintext error and the –auth-plaintext option well, resulting in confusing output.

The only micro-controller stuff I’ve ever done is with an Arduino. I would like to change that, so I bought an Alpha Clock Five from Evil Mad Science to play with. Not only could I learn about AVR programming, I’ve had an idea since about 2001 for a product that doesn’t exist which is built around a digital clock. Got the kit and an AVR ISP programmer, built them both, very happy with the clock with its default programming, and the AVR programmer responds to “pings” from avrdude. Woot!

Soda cans not included...

But! I had no idea how to actually program the chip. Hrm. OK, found a couple of pages about building minimalist AVR programming boards (like this one, coincidentally also from EMSL), pretty much confirming what I had been thinking: A ZIF socket, some perf board, a male header, and some leads. That actually kind of sounded like a fun little thing to put together. Then I started thinking about how it would suck to have to pull the chip out of the clock for each program/test cycle, so maybe I could expand that minimalist board to include full headers for the 40-pin ZIF that could go back to the socket on the clock. Cool, I could do this!

I’ve been tossing this around in my head overnight, deciding that it was definitely something I could build, and even sounded like fun. Two things were nagging me though. First, if this is a real problem, why aren’t there more solutions. Second, why didn’t EMSL mention this in their otherwise excellent docs. Then a snippet I read last night on what an ISP actually is (In System Programmer) popped up in my head.

I suddenly became 100% sure that there would be an empty 6- or 10-pin header on the back of the clock. I happened to be in the shower right at that moment so it was a bit before I could check, but sure enough, there it was.

Why hello there you sexy beast...

I went and checked the build docs to see what they called that header. Sure enough it’s the “Six-pin DIL ISP Header”. I guess I don’t need to build the little barebones programmer I had laid out in my head (maybe some future project).

This post has two points. The first is that I’m constantly amazed at what I don’t know. These kits are put together by people who are striving very hard to make it very easy for beginners to engage with them (I assume they are at least, on the theory that a happy newb is more likely to be a repeat customer) and yet I still almost managed to wander off into the weeds.

The second is this. That header was the inspiration for this little blurb I posted on Google plus a couple of days ago:

I have made an important discovery tonight (actually I made it last night, forgot it, and re-discovered it tonight). I think this is a fundamental contribution to hobby electronics, as I haven’t seen it written down anywhere. Ready?

If you try the “tack one post, then press down on the component while re-heating to fully seat” trick with a male header, you will burn the ever-loving *&^% out of your finger. Those pins go all the way through people.

This component had actually gotten my attention enough to make me go out of my way to write about it, but it still didn’t come to mind when I was trying to figure out how to program the darn thing.

But, the upside of all of this is that I get to play with programming my clock tonight without having to order parts for a programmer board!

Updated 2012-03-12: …except that I didn’t get to play with it, because, while the ISP method of programming is technically supported, the provided source code won’t work with an ISP. The system also comes with an FTDI interface, and it’s through this interface that the default firmware is expected to be loaded. As shipped, the chip is pre-loaded with a slightly modified Arduino environment, and then the default system for the clock is coded against and run via that Arduino environment. The ISP works, but it would only do low level programming, overwriting the Arduino environment, and clock source has been written against the bare metal. The only way to load into the Arduino environment, using the default clock code, is via the FTDI interface. That’s fine, except I don’t own a FTDI (USB-TTL) cable. Reading back through all the docs, this was all stated, I just didn’t understand what was being stated. I think the only thing that would have saved me was something like “Note that there is no example source code available for programming the clock via the ISP interface” in the ISP section. I saw that the clock was programmable via the ISP and assumed the example code would work with it. I have a USB-TTL cable on order, so no big deal, just more examples of not knowing what I don’t know.

Also amusing in this last vignette is the realization that I still won’t have been working outside of the Arduino environment. Oh well, the clock’s still awesome…