op.consumerOperationParameters.jvmArguments == ['-Xmx']
    }

    class TestOperation extends AbstractLongRunningOperation<TestOperation> {
        protected TestOperation(ConnectionParameters parameters) {
            super(parameters)
            operationParamsBuilder.entryPoint = "test"
        }

        @Override
        protected TestOperation getThis() {
            return this
        }
    }

                        queue.add(new TestOperation(startedLatch))
                        queue.add(new TestOperation(startedLatch))
                        startedLatch.await()
                        throw new Exception("queue failure")
                    }
                }
            }

            class TestOperation implements RunnableBuildOperation {

        });
    }

    private void batchInsertOperation(Connection connection, R results, long executionId) throws SQLException {
        try (PreparedStatement statement = connection.prepareStatement("insert into testOperation(testExecution, displayName, tasks, args, gradleOpts, daemon, totalTime, cleanTasks) values (?, ?, ?, ?, ?, ?, ?, ?)")) {
            for (BuildDisplayInfo displayInfo : results.getBuilds()) {

    private void batchInsertOperation(Connection connection, CrossVersionPerformanceResults results, long testId) throws SQLException {
        try (PreparedStatement statement = connection.prepareStatement(insertStatement("testOperation", "testExecution", "version", "totalTime"))) {
            addOperations(statement, testId, null, results.getCurrent());
            for (BaselineVersion baselineVersion : results.getBaselineVersions()) {

			}
		}
		for _, m := range tt.noMatch {
			r := Matcher{tt.rule, m}
			if r.version() {
				t.Errorf("%v: expected no match %#v", name, m)
			}
		}
	}
}

func TestOperation(t *testing.T) {
	table := tests{
		"wildcard": {
			rule: adreg.RuleWithOperations{Operations: []adreg.OperationType{adreg.OperationAll}},
			match: attrList(

	scenarios := []struct {
		s                     string
		capitalizeFirstLetter bool
		expectedResult        string
	}{
		{
			s:                     "test_operation",
			capitalizeFirstLetter: true,
			expectedResult:        "Test_operation",
		},
		{
			s:                     "test operation& test",
			capitalizeFirstLetter: true,
			expectedResult:        "TestOperationTest",
		},
		{

    /**
     * Returns all tests, in the order started.
     */
    List<Operation> getTests() {
        assertHasZeroOrMoreTrees()
        def testOperations = operations.findAll { it.test } as List
        testOperations.forEach { it.assertIsTest() }
        return testOperations
    }

    /**
     * Returns all events for test class and method execution
     */
    List<Operation> getTestClassesAndMethods() {

            defaultSerializerRegistry.build(SerializableParent)
        }
        then:
        noExceptionThrown()
        conditions.await(5.0)
        where:
        // Rerun this test 10 times
        testIteration << (0..9)
    }

    static class SerializableParent implements Serializable {}

    static class Serializable1 extends SerializableParent {}

    static class Serializable2 extends SerializableParent {}