ref and out parameters

pass value objects into or “out of” methods by reference

properties

allow exposing properties as fields, backed by getter and/or setter methods

static constructors

where it is possible to initialize static fields

finalizers

where it is possible to clean up resources used by an instance. Syntax is reminiscent of syntax for C++ destructors.

indexers

allows the square bracket operator (i.e. [5]) to be applied to instances

delegates

essentially closures that invoke zero or more methods with the same signature. Event handlers are implemented as delegates, such that adding and removing listeners is accomplished using the += and -= operators.

partial classes

allow classes to be defined / extended across multiple files

using statements

a convenience construct that maps to a try { ... } finally { ... } block, calling Dispose() (from IDisposable) on the used object if an exception is thrown

attributes

essentially Java annotations

inherited methods with virtual, override, new

method overridding must be explicitly permitted with virtual. Overriding and hiding also must be explicitly called out, via override and new.

iterator blocks, yield return statements

when defining new iterators for use in foreach statements

nullable value types, ?? (null coalescing operator)

value types can be allowed to have the value null. The null coalescing operator allows an alternative value to be specified more concisely, when a variable is found to be null. Similar to Groovy’s “elvis” operator ?: .

implicit and explicit type conversions

conversions can be defined between types for which an inheritance relationship does not exist. Overall, this seems like a confusingly “clever” feature to use, and probably best avoided.

generics and constraints (where clauses)

like Java generics, but with more expressive type constraints expressed as where clauses.

is, as, typeof()

how to dynamically check type information; is is like Java’s instanceof; as is like a C++ dynamic_cast; and typeof() returns a Type object.

I soon entered a world of character code hurt – unbeknownst to me at the time, the filesystems of international editions of Windows are essentially incompatible with each other! Apparently, the set of supported filesystem character codes is fixed in each localized Windows kernel – short of installing Windows in that language, you will be unable to read any filesystems created using its character code!

Fortunately, Ubuntu comes to the rescue! Albeit not without some confusion and a healthy dose of wasted time. Here I outline the steps I took to copy the Japanese-encoded FAT32 filesystem content to an English Vista NTFS drive. You might be able to skip some of the steps, but I include them all for completeness.

1. Connect the FAT32 drive to an Ubuntu box.
2. In a terminal, change to the superuser (we’ll need to be root for most steps): sudo su
3. Mount the drive using the Japanese character code: mount -o codepage=932,iocharset=utf8 -t vfat /dev/sdb1 /mnt/temp
4. Copy the drive contents to the local drive. (You might be able to skip this step by copying directly to the USB drive.) cp -r /mnt/temp ~/backup
5. Did I say you needed a USB drive handy? Well, how else were you planning to transfer the files? We need to have an NTFS partition on the drive. I did this using GParted, so that I could have a FAT32 partition alongside an NTFS partition. GParted should be pretty straightforward to use – the only thing to note is that creating the initial partition tables will delete any existing data on the drive. We’ll also need NTFS write support. Install the following packages: apt-get install gparted ntfs-3g ntfs-config ntfsprogs
6. Run ntfs-config . You can cancel out of the first dialog, but make sure “Enable write support for external device” is checked in the second dialog.
7. Install the Ubuntu Japanese language pack, if you haven’t already. In Interpid: System > Administration > Language Support, tick “Japanese” and hit “OK”.
8. Verify the locale was added: locale -a | grep ja_JP
9. Set the LANG and LANGUAGE environment variables: export LANG=\"ja_JP.utf8", then export LANGUAGE=\"ja_JP.utf8" .
10. Make sure the USB drive is not mounted. If it was automounted, for example on /media, unmount it: umount /media/disk . If the FAT32 drive is still mounted, you can unmount that too.
11. Mount the USB drive specifying a Japanese locale: mount -o locale=ja_JP.utf8 /dev/sdf2 /mnt/temp
12. Copy the files from the local drive to the USB drive: cp -r ~/backup /mnt/temp/
13. Unmount the USB drive and disconnect it from the Ubuntu box, reconnecting it to the Vista box.
14. In Vista, perform a simple file copy from the USB drive to the desired location.

I hope this helps any poor souls out there put in the same situation as I was, for Japanese or any other multibyte language!

Here’s the updated documentation link (if it doesn’t move again).

In other news, there is now a Groovy formatter for Selenium IDE, and support for a special GroovySeleneseTestCase which makes it possible to merge *AndWait commands into single commands. For example:

clickAndWait | foo

with the Java formatter translates into:

selenium.click("foo");
selenium.waitForPageToLoad("30000");

while the Groovy formatter simply says:

selenium.clickAndWait("foo")

Cleaner, and more expressive.

It should be now.

If you build from r2291 or greater from the RC trunk, you can play with it. Basically, the extension Javascript must be specified before the browser is launched, and stays in-play until the session is closed. A sample test has been checked in here:

SessionExtensionJsTest.java

This probably doesn’t work for proxy injection mode yet.

Happy extending!

Update

It appears too easy to encounter the “414 Request URI Too Large” issue. I’m looking into this.

Update

Looks like the 414 issue is related specifically to the Perl driver (see this Clearspace post); I noticed it when using Perl, but did not see the issue when running an equivalent test in Groovy:

import com.thoughtworks.selenium.*

class URILengthTest extends GroovyTestCase {
    def selenium

    @Override
    void setUp() {
        selenium = new DefaultSelenium('localhost',
            4444, '*firefox',
            'http://alistapart.com')
    }

    @Override
    void tearDown() {
        selenium.stop()
    }

    void testURILength() {
        def extensionJs = new File(
            'selenium-core/src/main/resources/core/scripts/ui-map-sample.js').text

        selenium.setExtensionJs(extensionJs)
        selenium.start()
        selenium.open('http://alistapart.com')
        selenium.click(
            'ui=allPages::section(section=topics)')
        selenium.waitForPageToLoad('5000')
    }
}

Update

Unfortunately, the 414 issue also affects the Python and Ruby client drivers (I just tested and verified this). I’m not about to fix them right this moment, so it appears the you can only truly take advantage of the per-session extension feature (i.e. include extensions of arbitrary size) in Java and Groovy for now. The good news is that this issue has already been reported, and JIRA tickets created (SRC-319 for Perl, SRC-321 for Python, SRC-322 for Ruby, and others for C# and PHP).