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.

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).

To get the card to work (as opposed to simply flashing its lights while the “network is unreachable”), something like the following script should be run. It used to work without the sleep command, but it’s more touchy now than it used to be.

# starts the rt2500 ra0 interface
ifconfig ra0 up
ifconfig ra0 192.168.2.20
route add default gw 192.168.2.1
sleep 15s
iwconfig ra0 mode managed essid  \
channel 1 key restricted