when:
        Map<String, Set<String>> result = withConnection { connection ->
            connection.action(new FetchAllTaskSelectorsBuildAction()).run() }

        then:
        result != null
        result.keySet() == ['test', 'a', 'b', 'c'] as Set
        result['test'] == rootProjectImplicitSelectors + ['t1', 't2', 't3'] as Set
        result['b'] == implicitSelectors + ['t1', 't2', 't3'] as Set

		ch <- result{nil, lresult.err}
		return
	}
	if rresult.err != nil {
		ch <- result{nil, rresult.err}
		return
	}
	ch <- result{s.interiorHash(lresult.update, rresult.update, height, iBatch, root, shortcut, store, keys,
		values, batch), nil}
}

// updateRight updates the right side of the tree
func (s *smt) updateRight(lnode, rnode, root []byte, keys, values, batch [][]byte, iBatch, height int, shortcut,

        when:
        def result = parser.parse(['-a', '-b', '-c'])

        then:
        !result.hasOption('a')
        !result.hasOption('b')
        result.hasOption('c')
        result.hasOption('long-option')

        when:
        result = parser.parse(['-a', '-b', '--long-option'])

        then:
        !result.hasOption('a')
        !result.hasOption('b')
        result.hasOption('c')

        }
        if (permissions.contains(GROUP_WRITE)) {
            result = result | 020;
        }
        if (permissions.contains(GROUP_EXECUTE)) {
            result = result | 010;
        }
        if (permissions.contains(OTHERS_READ)) {
            result = result | 04;
        }
        if (permissions.contains(OTHERS_WRITE)) {
            result = result | 02;
        }

        when:
        def result = serialize(event, serializer)

        then:
        result instanceof StyledTextOutputEvent
        result.timestamp == TIMESTAMP
        result.category == CATEGORY
        result.logLevel == LogLevel.LIFECYCLE
        result.spans.size() == 2
        result.spans[0].style == StyledTextOutput.Style.Description
        result.spans[0].text == "description"

        result.addStatement("Class<?> $L = argumentClasses[argIndex]", nextArg);
        result.beginControlFlow("if ($2L != null && !$1T.class.isAssignableFrom($2L))", entryParamType, nextArg);
        result.addStatement("$L = false", varargMatched);
        result.addStatement("break");
        result.endControlFlow();
        result.endControlFlow();
        result.beginControlFlow("if ($L)", varargMatched);

        when:
        def result = new DefaultTestResult(state)

        then:
        result.getStartTime() == 100L
        result.getEndTime() == 200L
        result.resultType == ResultType.SKIPPED
        result.exceptions == state.failures.collect { it.rawFailure }
        result.testCount == state.testCount
        result.successfulTestCount == state.successfulCount
        result.failedTestCount == state.failedCount
    }

        def result = serialize(event, serializer)

        then:
        result instanceof LogEvent
        result.timestamp == TIMESTAMP
        result.category == CATEGORY
        result.logLevel == LogLevel.LIFECYCLE
        result.message == MESSAGE
        result.throwable.getClass() == event.throwable.getClass()
        result.throwable.message == event.throwable.message

    }

    @Override
    protected <RESULT extends WebConfig> RESULT createEntity(Map<String, Object> source, Class<? extends RESULT> entityType) {
        try {
            final RESULT result = entityType.newInstance();
            result.setAvailable(DfTypeUtil.toBoolean(source.get("available")));
            result.setBoost(DfTypeUtil.toFloat(source.get("boost")));

    def "caches result from backing cache and reuses for other instances with the same cache id"() {
        given:
        def cache = cacheFactory.decorator(100, true).decorate("path/fileSnapshots.bin", "fileSnapshots", target, crossProcessCacheAccess, asyncCacheAccess)

        when:
        def result = cache.getIfPresent("key")

        then:
        result == "result"

        and: