extensionClasses = []
boolean inheritParentExtensions = true
void addPackageImport(String pkg) {
compiler.addPackageImport(pkg)
}
void addPackageImport(Package pkg) {
compiler.addPackageImport(pkg)
}
void addClassImport(String className) {
compiler.addClassImport(className)
}
void addClassImport(Class clazz) {
compiler.addClassImport(clazz)
}
void addClassMemberImport(String className) {
compiler.addClassMemberImport(className)
}
void addClassMemberImport(Class clazz) {
compiler.addClassMemberImport(clazz)
}
Result runRequest(Request request) {
withNewContext {
doRunRequest(request)
}
}
Result runClasses(List classes) {
withNewContext {
doRunRequest(Request.classes(classes.findAll { !Modifier.isAbstract(it.modifiers) } as Class[]))
}
}
// it's very important to open a new context BEFORE Request.aClass/classes is invoked
// this is because Sputnik is already constructed by those methods, and has to pop
// the correct context from the stack
Result runClass(Class clazz) {
withNewContext {
doRunRequest(Request.aClass(clazz))
}
}
Result run(String source) {
runClasses(compiler.compile(source))
}
Result runWithImports(String source) {
runClasses(compiler.compileWithImports(source))
}
Result runSpecBody(String source) {
runClass(compiler.compileSpecBody(source))
}
Result runFeatureBody(String source) {
runClass(compiler.compileFeatureBody(source))
}
def withNewContext(Closure block) {
def script = configurationScript ?
new ConfigurationScriptLoader().loadClosureBasedScript(configurationScript) : null
RunContext.withNewContext(script, extensionClasses, inheritParentExtensions, block as IThrowableFunction)
}
private Result doRunRequest(Request request) {
def junitCore = new JUnitCore()
listeners.each { junitCore.addListener(it) }
def result = junitCore.run(request)
if (throwFailure && result.failureCount > 0) throw result.failures[0].exception
result
}
} spock-0.6-groovy-1.8/spock-core/src/main/groovy/spock/util/concurrent/ 0000775 0000000 0000000 00000000000 12020225233 0025677 5 ustar 00root root 0000000 0000000 spock-0.6-groovy-1.8/spock-core/src/main/groovy/spock/util/concurrent/BlockingVariables.groovy 0000664 0000000 0000000 00000005611 12020225233 0032532 0 ustar 00root root 0000000 0000000 /*
* Copyright 2010 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* http://www.apache.org/licenses/LICENSE-2.0
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package spock.util.concurrent
import java.util.concurrent.TimeUnit
import org.spockframework.util.ThreadSafe
/**
* Provides an unlimited number of dynamic variables. Reading the value of a
* variable will block until some other thread has set the value of the variable,
* or a timeout expires. Useful for verifying state in an expect- or then-block
* that has been captured in some other thread.
*
* Example:
*
*
* // create object under specification
* def machine = new Machine()
*
* BlockingVariables vars = new BlockingVariables()
*
* // register async callback
* machine.workDone << { result ->
* vars.result = result
* }
*
* when:
* machine.start()
*
* then:
* // blocks until workDone callback has set result, or a timeout expires
* vars.result == WorkResult.OK
*
* cleanup:
* // shut down all threads
* machine?.shutdown()
*
*
* @author Peter Niederwieser
*/
@ThreadSafe
class BlockingVariables {
private final BlockingVariablesImpl impl
/**
* Same as BlockingVariables(1, TimeUnit.SECONDS) .
*/
BlockingVariables() {
this(1, TimeUnit.SECONDS)
}
/**
* Instantiates a BlockingVariable with the specified timeout in seconds.
*
* @param timeout timeout (seconds) for reading a variable's value.
*/
BlockingVariables(int timeout) {
this(timeout, TimeUnit.SECONDS)
}
/**
* Instantiates a BlockingVariables instance with the specified
* timeout.
*
* @param timeout timeout for reading a variable's value
*
* @param unit the timeout's time unit
*/
BlockingVariables(int timeout, TimeUnit unit) {
impl = new BlockingVariablesImpl(timeout, unit)
}
/**
* Sets a variable's value. This method should not be called directly
* but by setting a dynamic variable's value.
*
* @param name the variable's name
* @param value the variable's value
*/
void setProperty(String name, Object value) {
impl.put(name, value)
}
/**
* Gets a variable's value. Blocks until a value has been set for the variable
* or a timeout expires. This method should not be called directly but by
* getting a dynamic variable's value.
*
* @param name the variable's name
*
* @return the variable's value
*/
Object getProperty(String name) {
impl.get(name)
}
} spock-0.6-groovy-1.8/spock-core/src/main/groovy/spock/util/matcher/ 0000775 0000000 0000000 00000000000 12020225233 0025140 5 ustar 00root root 0000000 0000000 spock-0.6-groovy-1.8/spock-core/src/main/groovy/spock/util/matcher/HamcrestMatchers.groovy 0000664 0000000 0000000 00000002730 12020225233 0031646 0 ustar 00root root 0000000 0000000 /*
* Copyright 2010 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package spock.util.matcher
import org.hamcrest.Matcher
/**
* Factory for Hamcrest matchers that ship with Spock.
*
* @author Peter Niederwieser
*/
class HamcrestMatchers {
/**
* Tells if two numbers are equal within some range of acceptable error.
* In contrast to the equally named matcher in the Hamcrest library, this
* matcher also handles BigDecimal s (and any other Number s),
* which is important for Groovy interoperability.
*
* Example usage:
*
*
* expect:
* myPi closeTo(3.1415, 0.01)
*
*
* @param operand the expected number
* @param error the range of acceptable error
* @return a matcher that tells if two numbers are equal within some range of
* acceptable error
*/
static Matcher closeTo(Number operand, Number error) {
return new IsCloseTo(operand, error)
}
}
spock-0.6-groovy-1.8/spock-core/src/main/groovy/spock/util/matcher/IsCloseTo.groovy 0000664 0000000 0000000 00000003363 12020225233 0030260 0 ustar 00root root 0000000 0000000 /*
* Copyright 2010 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package spock.util.matcher
import org.hamcrest.TypeSafeMatcher
import org.hamcrest.Description
/**
* Generalization of org.hamcrest.number.IsCloseTo to arbitrary
* Number s (in particular BigDecimal s). Otherwise almost
* identical to that class.
*/
public class IsCloseTo extends TypeSafeMatcher {
private final Number delta
private final Number value
IsCloseTo(Number value, Number error) {
this.delta = error
this.value = value
}
@Override
boolean matchesSafely(Number item) {
actualDelta(item) <= 0
}
@Override
void describeMismatchSafely(Number item, Description mismatchDescription) {
mismatchDescription.appendValue(item)
.appendText(" differed by ")
.appendValue(actualDelta(item))
}
void describeTo(Description description) {
description.appendText("a numeric value within ")
.appendValue(delta)
.appendText(" of ")
.appendValue(value)
}
private Number actualDelta(Number item) {
(item - value).abs() - delta
}
}
spock-0.6-groovy-1.8/spock-core/src/main/java/ 0000775 0000000 0000000 00000000000 12020225233 0021015 5 ustar 00root root 0000000 0000000 spock-0.6-groovy-1.8/spock-core/src/main/java/org/ 0000775 0000000 0000000 00000000000 12020225233 0021604 5 ustar 00root root 0000000 0000000 spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/ 0000775 0000000 0000000 00000000000 12020225233 0024641 5 ustar 00root root 0000000 0000000 spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/builder/ 0000775 0000000 0000000 00000000000 12020225233 0026267 5 ustar 00root root 0000000 0000000 spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/builder/AddSlotFactory.java 0000664 0000000 0000000 00000002226 12020225233 0032016 0 ustar 00root root 0000000 0000000 /*
* Copyright 2010 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* http://www.apache.org/licenses/LICENSE-2.0
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.builder;
import java.lang.reflect.Type;
import groovy.lang.MetaMethod;
import org.spockframework.util.GroovyRuntimeUtil;
public class AddSlotFactory implements ISlotFactory {
public ISlot create(Object owner, Type ownerType, String name) {
String addMethodName = GroovyRuntimeUtil.propertyToMethodName("add", name);
MetaMethod addMethod = GroovyRuntimeUtil.getMetaClass(owner).pickMethod(addMethodName, new Class[]{Object.class});
return addMethod != null ? new SetterLikeSlot(owner, ownerType, addMethod) : null;
}
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/builder/BuilderHelper.java 0000664 0000000 0000000 00000003276 12020225233 0031670 0 ustar 00root root 0000000 0000000 /*
* Copyright 2010 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* http://www.apache.org/licenses/LICENSE-2.0
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.builder;
import java.lang.reflect.Modifier;
import org.codehaus.groovy.runtime.MetaClassHelper;
import org.spockframework.util.GroovyRuntimeUtil;
public class BuilderHelper {
public static Object createInstance(Class clazz, Object... args) {
if (args.length == 1) {
Object arg = args[0];
if (MetaClassHelper.isAssignableFrom(clazz, arg.getClass())) return arg;
// IDEA: could do additional coercions here, like Groovy does when setting a property
// (note that we don't know if we are setting a property or invoking a method):
// int -> byte (at least if it fits), etc.
}
// IDEA: could support creation of collection types here
if ((clazz.getModifiers() & Modifier.ABSTRACT) != 0) {
String kind = clazz.isPrimitive() ? "primitive" : clazz.isInterface() ? "interface" : "abstract";
throw new RuntimeException(String.format( "Cannot instantiate %s type %s", kind, clazz.getName()));
}
// TODO: need exception handling for better error messages?
return GroovyRuntimeUtil.invokeConstructor(clazz, args);
}
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/builder/ClosureBlueprint.java 0000664 0000000 0000000 00000002371 12020225233 0032436 0 ustar 00root root 0000000 0000000 /*
* Copyright 2010 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* http://www.apache.org/licenses/LICENSE-2.0
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.builder;
import groovy.lang.Closure;
import org.spockframework.util.GroovyRuntimeUtil;
public class ClosureBlueprint implements IBlueprint {
private final Closure closure;
private final Object subject;
public ClosureBlueprint(Closure closure, Object subject) {
this.closure = closure;
this.subject = subject;
closure.setResolveStrategy(Closure.DELEGATE_ONLY);
}
public Object getThisObject() {
return closure.getThisObject();
}
public void setDelegate(Object delegate) {
closure.setDelegate(delegate);
}
public void evaluate() {
GroovyRuntimeUtil.invokeClosure(closure, subject);
}
} spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/builder/CollectionSlot.java 0000664 0000000 0000000 00000005476 12020225233 0032103 0 ustar 00root root 0000000 0000000 /*
* Copyright 2010 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* http://www.apache.org/licenses/LICENSE-2.0
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.builder;
import java.lang.reflect.*;
import java.util.*;
import org.spockframework.gentyref.GenericTypeReflector;
import org.spockframework.util.MopUtil;
import org.spockframework.util.UnreachableCodeError;
import groovy.lang.MetaProperty;
public class CollectionSlot implements ISlot {
private final String name;
private final Object owner;
private final Type ownerType;
private final MetaProperty property;
CollectionSlot(String name, Object owner, Type ownerType, MetaProperty property) {
this.name = name;
this.owner = owner;
this.ownerType = ownerType;
this.property = property;
}
public Type getType() {
Type type = getCollectionType();
if (type instanceof ParameterizedType) return ((ParameterizedType)type).getActualTypeArguments()[0];
if (type instanceof Class) return Object.class;
throw new UnreachableCodeError();
}
private Type getCollectionType() {
Method getter = MopUtil.getterFor(property);
if (getter != null) return GenericTypeReflector.getExactReturnType(getter, ownerType);
Field field = MopUtil.fieldFor(property);
if (field != null) return GenericTypeReflector.getExactFieldType(field, ownerType);
throw new UnreachableCodeError();
}
@SuppressWarnings("unchecked")
public void write(Object value) {
Collection collection = (Collection) property.getProperty(owner);
if (collection == null) {
if (MopUtil.isWriteable(property)) {
collection = createCollection(property.getType());
property.setProperty(owner, collection);
} else {
throw new RuntimeException(String.format(
"Cannot add element to collection property '%s' because it is neither initialized nor does it have a setter",
name));
}
}
collection.add(value);
}
private Collection createCollection(Class clazz) {
if ((clazz.getModifiers() & Modifier.ABSTRACT) == 0) {
return (Collection)BuilderHelper.createInstance(clazz);
}
if (List.class.isAssignableFrom(clazz)) return new ArrayList();
if (Set.class.isAssignableFrom(clazz)) return new HashSet();
throw new RuntimeException(String.format("Don't know how to create a collection of type '%s'", clazz.getName()));
}
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/builder/CollectionSlotFactory.java 0000664 0000000 0000000 00000003242 12020225233 0033420 0 ustar 00root root 0000000 0000000 /*
* Copyright 2010 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* http://www.apache.org/licenses/LICENSE-2.0
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.builder;
import java.lang.reflect.Type;
import java.util.Collection;
import java.util.regex.Pattern;
import org.spockframework.util.GroovyRuntimeUtil;
import org.spockframework.util.MopUtil;
import groovy.lang.MetaProperty;
public class CollectionSlotFactory implements ISlotFactory {
private static final Pattern pluralIESPattern = Pattern.compile(".*[^aeiouy]y", Pattern.CASE_INSENSITIVE);
public ISlot create(Object owner, Type ownerType, String name) {
String plural = toPluralForm(name);
MetaProperty property = GroovyRuntimeUtil.getMetaClass(owner).getMetaProperty(plural);
return property != null && Collection.class.isAssignableFrom(property.getType()) && MopUtil.isReadable(property) ?
new CollectionSlot(plural, owner, ownerType, property) : null;
}
private String toPluralForm(String word) {
if (word.toLowerCase().endsWith("s")) return word + "es";
boolean matchesIESRule = pluralIESPattern.matcher(word).matches();
return matchesIESRule ? word.substring(0, word.length() - 1) + "ies" : word + "s";
}
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/builder/DelegatingScript.java 0000664 0000000 0000000 00000003164 12020225233 0032366 0 ustar 00root root 0000000 0000000 /*
* Copyright 2010 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* http://www.apache.org/licenses/LICENSE-2.0
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.builder;
import groovy.lang.*;
import org.spockframework.util.GroovyRuntimeUtil;
public abstract class DelegatingScript extends Script {
private volatile Object $delegate;
public void $setDelegate(Object delegate) {
this.$delegate = delegate;
}
@Override
public Object getProperty(String property) {
try {
return GroovyRuntimeUtil.getProperty($delegate, property);
} catch (MissingPropertyException e) {
return super.getProperty(property);
}
}
@Override
public void setProperty(String property, Object newValue) {
try {
GroovyRuntimeUtil.setProperty($delegate, property, newValue);
} catch (MissingPropertyException e) {
super.setProperty(property, newValue);
}
}
@Override
public Object invokeMethod(String name, Object args) {
try {
return GroovyRuntimeUtil.invokeMethod($delegate, name, GroovyRuntimeUtil.asArray(args));
} catch (MissingMethodException e) {
return super.invokeMethod(name, args);
}
}
}
DelegatingScriptBlueprint.java 0000664 0000000 0000000 00000002022 12020225233 0034164 0 ustar 00root root 0000000 0000000 spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/builder /*
* Copyright 2010 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* http://www.apache.org/licenses/LICENSE-2.0
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.builder;
public class DelegatingScriptBlueprint implements IBlueprint {
private final DelegatingScript script;
public DelegatingScriptBlueprint(DelegatingScript script) {
this.script = script;
}
public Object getThisObject() {
return null;
}
public void setDelegate(final Object delegate) {
script.$setDelegate(delegate);
}
public void evaluate() {
script.run();
}
} spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/builder/GestaltBuilder.java 0000664 0000000 0000000 00000001363 12020225233 0032047 0 ustar 00root root 0000000 0000000 /*
* Copyright 2010 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* http://www.apache.org/licenses/LICENSE-2.0
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.builder;
public class GestaltBuilder {
public void build(IGestalt root) {
new Sculpturer().$form(root);
}
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/builder/IBlueprint.java 0000664 0000000 0000000 00000001462 12020225233 0031212 0 ustar 00root root 0000000 0000000 /*
* Copyright 2010 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* http://www.apache.org/licenses/LICENSE-2.0
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.builder;
import org.spockframework.util.Nullable;
public interface IBlueprint {
@Nullable
Object getThisObject();
void setDelegate(Object delegate);
void evaluate();
} spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/builder/IConfigurationRegistry.java0000664 0000000 0000000 00000001333 12020225233 0033603 0 ustar 00root root 0000000 0000000 /*
* Copyright 2010 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* http://www.apache.org/licenses/LICENSE-2.0
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.builder;
public interface IConfigurationRegistry {
Object getConfiguration(String name);
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/builder/IGestalt.java 0000664 0000000 0000000 00000001574 12020225233 0030655 0 ustar 00root root 0000000 0000000 /*
* Copyright 2010 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* http://www.apache.org/licenses/LICENSE-2.0
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.builder;
import org.spockframework.util.Nullable;
public interface IGestalt {
@Nullable IBlueprint getBlueprint();
Object getProperty(String name);
void setProperty(String name, Object value);
Object invokeMethod(String name, Object[] args);
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/builder/ISlot.java 0000664 0000000 0000000 00000001357 12020225233 0030172 0 ustar 00root root 0000000 0000000 /*
* Copyright 2010 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* http://www.apache.org/licenses/LICENSE-2.0
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.builder;
import java.lang.reflect.Type;
public interface ISlot {
Type getType();
void write(Object value);
} spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/builder/ISlotFactory.java 0000664 0000000 0000000 00000001467 12020225233 0031524 0 ustar 00root root 0000000 0000000 /*
* Copyright 2010 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* http://www.apache.org/licenses/LICENSE-2.0
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.builder;
import java.lang.reflect.Type;
import org.spockframework.util.Nullable;
public interface ISlotFactory {
@Nullable ISlot create(Object owner, Type ownerType, String name);
} spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/builder/PojoBuilder.java 0000664 0000000 0000000 00000003516 12020225233 0031355 0 ustar 00root root 0000000 0000000 /*
* Copyright 2010 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* http://www.apache.org/licenses/LICENSE-2.0
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.builder;
import java.util.Arrays;
import java.util.List;
import groovy.lang.Closure;
// TODO: test building pojo enriched with expandometaclass/category property
// TODO: test call to void varargs method in expect: block
// (related: find all calls to MetaMethod.invoke and replace with doMethodInvoke)
// IDEA: allow syntax foo = { ... } to make it clear built object should be assigned to a property (can't handle all cases with method syntax)
// IDEA: helpful coercions (esp. for configuration): List -> Set (enables the use of list literals for sets), potentially String -> Enum
// TODO: provide a way to set visibility of methods/properties to look for
public class PojoBuilder {
private final GestaltBuilder gestaltBuilder = new GestaltBuilder();
private final List slotFactories =
Arrays.asList(new SetterSlotFactory(), new AddSlotFactory(), new CollectionSlotFactory());
public Object build(Object pojo, Closure closure) {
return build(pojo, new ClosureBlueprint(closure, pojo));
}
public Object build(Object pojo, IBlueprint blueprint) {
IGestalt gestalt = new PojoGestalt(pojo, pojo.getClass(), blueprint, slotFactories);
gestaltBuilder.build(gestalt);
return pojo;
}
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/builder/PojoGestalt.java 0000664 0000000 0000000 00000006405 12020225233 0031372 0 ustar 00root root 0000000 0000000 /*
* Copyright 2010 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* http://www.apache.org/licenses/LICENSE-2.0
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.builder;
import java.lang.reflect.Type;
import java.util.List;
import org.spockframework.gentyref.GenericTypeReflector;
import org.spockframework.util.CollectionUtil;
import groovy.lang.Closure;
import org.spockframework.util.GroovyRuntimeUtil;
public class PojoGestalt implements IGestalt {
private final Object pojo;
private final Type pojoType;
private final IBlueprint blueprint;
private final List slotFactories;
public PojoGestalt(Object pojo, Type pojoType, IBlueprint blueprint, List slotFactories) {
this.pojo = pojo;
this.pojoType = pojoType;
this.blueprint = blueprint;
this.slotFactories = slotFactories;
}
public Object getSubject() {
return pojo;
}
public IBlueprint getBlueprint() {
return blueprint;
}
public Object getProperty(String name) {
return GroovyRuntimeUtil.getProperty(pojo, name);
}
public void setProperty(String name, Object value) {
GroovyRuntimeUtil.setProperty(pojo, name, value);
}
// foo([a:1],b) and foo(a:1,b) are currently not distinguishable in Groovy
// neither are foo([a:1],b) and foo(b,a:1)
// so we should probably add some heuristics to tell them apart (look at subject's method signatures)
// same for telling apart last arg (could be blueprint or last constructor arg)
// current impl is dead stupid:
// - named args not treated specially
// - last arg is closure => treat as blueprint
public Object invokeMethod(String name, Object[] args) {
ISlot slot = findSlot(name, args);
PojoGestalt gestalt = createGestalt(slot.getType(), args);
new Sculpturer().$form(gestalt);
slot.write(gestalt.getSubject());
return gestalt.getSubject();
}
private ISlot findSlot(String name, Object[] args) {
for (ISlotFactory factory : slotFactories) {
ISlot slot = factory.create(pojo, pojoType, name);
if (slot != null) return slot;
}
throw new RuntimeException(String.format("Cannot find a slot named '%s'", name));
}
private PojoGestalt createGestalt(Type newType, Object[] args) {
Closure closure = null;
if (args != null && args.length > 0 && args[args.length - 1] instanceof Closure) {
closure = (Closure)args[args.length - 1];
args = CollectionUtil.copyArray(args, 0, args.length - 1);
}
Class newClazz = GenericTypeReflector.erase(newType); // TODO: check that this succeeds (Type could be a TypeVariable etc.)
Object newPojo = BuilderHelper.createInstance(newClazz, args);
ClosureBlueprint newBlueprint = closure == null ? null : new ClosureBlueprint(closure, newPojo);
return new PojoGestalt(newPojo, newType, newBlueprint, slotFactories);
}
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/builder/PropertySlot.java 0000664 0000000 0000000 00000003222 12020225233 0031617 0 ustar 00root root 0000000 0000000 /*
* Copyright 2010 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* http://www.apache.org/licenses/LICENSE-2.0
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.builder;
import java.lang.reflect.*;
import org.spockframework.gentyref.GenericTypeReflector;
import org.spockframework.util.MopUtil;
import org.spockframework.util.UnreachableCodeError;
import groovy.lang.MetaProperty;
public class PropertySlot implements ISlot {
private final Object owner;
private final Type ownerType;
private final MetaProperty property;
PropertySlot(Object owner, Type ownerType, MetaProperty property) {
this.owner = owner;
this.ownerType = ownerType;
this.property = property;
}
public Type getType() {
// could possibly add fast path here, but be careful (inner classes etc.)
Method setter = MopUtil.setterFor(property);
if (setter != null) return GenericTypeReflector.getExactParameterTypes(setter, ownerType)[0];
Field field = MopUtil.fieldFor(property);
if (field != null) return GenericTypeReflector.getExactFieldType(field, ownerType);
throw new UnreachableCodeError();
}
public void write(Object value) {
property.setProperty(owner, value);
}
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/builder/Sculpturer.java 0000664 0000000 0000000 00000004113 12020225233 0031301 0 ustar 00root root 0000000 0000000 /*
* Copyright 2010 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* http://www.apache.org/licenses/LICENSE-2.0
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.builder;
import groovy.lang.*;
import org.spockframework.util.GroovyRuntimeUtil;
/**
* Forms a gestalt from its blueprint.
*/
public class Sculpturer extends GroovyObjectSupport {
private IGestalt $gestalt;
public void $form(IGestalt gestalt) {
IBlueprint blueprint = gestalt.getBlueprint();
if (blueprint == null) return;
$gestalt = gestalt;
blueprint.setDelegate(this);
blueprint.evaluate();
}
public Object getProperty(String name) {
Object thisObject = $gestalt.getBlueprint().getThisObject();
if (thisObject != null) {
try {
return GroovyRuntimeUtil.getProperty(thisObject, name);
} catch (MissingPropertyException ignored) {}
}
return $gestalt.getProperty(name);
}
public void setProperty(String name, Object value) {
Object thisObject = $gestalt.getBlueprint().getThisObject();
if (thisObject != null) {
try {
GroovyRuntimeUtil.setProperty(thisObject, name, value);
return;
} catch (MissingPropertyException ignored) {}
}
$gestalt.setProperty(name, value);
}
public Object invokeMethod(String name, Object args) {
Object thisObject = $gestalt.getBlueprint().getThisObject();
if (thisObject != null) {
try {
return GroovyRuntimeUtil.invokeMethod(thisObject, name, GroovyRuntimeUtil.asArray(args));
} catch (MissingMethodException ignored) {}
}
return $gestalt.invokeMethod(name, GroovyRuntimeUtil.asArray(args));
}
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/builder/SetterLikeSlot.java 0000664 0000000 0000000 00000003057 12020225233 0032054 0 ustar 00root root 0000000 0000000 /*
* Copyright 2010 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* http://www.apache.org/licenses/LICENSE-2.0
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.builder;
import java.lang.reflect.Method;
import java.lang.reflect.Type;
import org.spockframework.gentyref.GenericTypeReflector;
import org.spockframework.util.GroovyRuntimeUtil;
import org.spockframework.util.MopUtil;
import groovy.lang.MetaMethod;
public class SetterLikeSlot implements ISlot {
private final Object owner;
private final Type ownerType;
private final MetaMethod setterLikeMethod;
public SetterLikeSlot(Object owner, Type ownerType, MetaMethod setterLikeMethod) {
this.owner = owner;
this.ownerType = ownerType;
this.setterLikeMethod = setterLikeMethod;
}
public Type getType() {
Method m = MopUtil.methodFor(setterLikeMethod);
return m != null ? GenericTypeReflector.getExactParameterTypes(m, ownerType)[0] :
setterLikeMethod.getNativeParameterTypes()[0];
}
public void write(Object value) {
setterLikeMethod.doMethodInvoke(owner, GroovyRuntimeUtil.asArray(value));
}
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/builder/SetterSlotFactory.java 0000664 0000000 0000000 00000002163 12020225233 0032574 0 ustar 00root root 0000000 0000000 /*
* Copyright 2010 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* http://www.apache.org/licenses/LICENSE-2.0
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.builder;
import java.lang.reflect.Type;
import org.spockframework.util.GroovyRuntimeUtil;
import org.spockframework.util.MopUtil;
import groovy.lang.MetaProperty;
public class SetterSlotFactory implements ISlotFactory {
public ISlot create(Object owner, Type ownerType, String name) {
MetaProperty property = GroovyRuntimeUtil.getMetaClass(owner).getMetaProperty(name);
return property != null && MopUtil.isWriteable(property) ? new PropertySlot(owner, ownerType, property) : null;
}
}
SpockConfigurationGestalt.java 0000664 0000000 0000000 00000004742 12020225233 0034215 0 ustar 00root root 0000000 0000000 spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/builder /*
* Copyright 2010 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* http://www.apache.org/licenses/LICENSE-2.0
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.builder;
import java.util.List;
import groovy.lang.*;
public class SpockConfigurationGestalt implements IGestalt {
private final List configurations;
private final IBlueprint blueprint;
private final List slotFactories;
public SpockConfigurationGestalt(List configurations, IBlueprint blueprint,
List slotFactories) {
this.configurations = configurations;
this.blueprint = blueprint;
this.slotFactories = slotFactories;
}
public IBlueprint getBlueprint() {
return blueprint;
}
public Object getProperty(String name) {
Object config = getConfiguration(name);
if (config == null) throw new MissingPropertyException("configuration not found");
return config;
}
public void setProperty(String name, Object value) {
throw new MissingPropertyException("configurations cannot be set directly");
}
public Object invokeMethod(String name, Object[] args) {
if (args.length != 1 || !(args[0] instanceof Closure))
throw new MissingMethodException(name, this.getClass(), args);
Object config = getConfiguration(name);
if (config == null) throw new MissingMethodException(name, this.getClass(), args);
ClosureBlueprint blueprint = new ClosureBlueprint((Closure)args[0], config);
IGestalt gestalt = new PojoGestalt(config, config.getClass(), blueprint, slotFactories);
new Sculpturer().$form(gestalt);
return null;
}
private Object getConfiguration(String name) {
for (Object config : configurations) {
String configName = getConfigurationName(config);
if (configName.equalsIgnoreCase(name)) return config;
}
return null;
}
private String getConfigurationName(Object config) {
String className = config.getClass().getSimpleName();
return className.substring(0, className.length() - "Configuration".length());
}
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/buildsupport/ 0000775 0000000 0000000 00000000000 12020225233 0027375 5 ustar 00root root 0000000 0000000 spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/buildsupport/AsmClassReader.java 0000664 0000000 0000000 00000003741 12020225233 0033076 0 ustar 00root root 0000000 0000000 /*
* Copyright 2010 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* http://www.apache.org/licenses/LICENSE-2.0
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.buildsupport;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Method;
import org.objectweb.asm.ClassReader;
import org.objectweb.asm.ClassVisitor;
import org.spockframework.util.*;
/**
* Wrapper for org.objectweb.asm.ClassReader that works with ASM 2.2.3, 3.0, 3.1, and 3.2.
*/
class AsmClassReader {
private static final Method acceptMethod;
private static final Object acceptMethodSecondArg;
private final ClassReader reader;
static {
Method m = ReflectionUtil.getMethodBySignature(ClassReader.class, "accept", ClassVisitor.class, boolean.class); // ASM 2.2.3
Object arg = true;
if (m == null) {
m = ReflectionUtil.getMethodBySignature(ClassReader.class, "accept", ClassVisitor.class, int.class); // ASM 3.0 and higher
arg = 1 | 2 | 4; // ClassReader.SKIP_CODE | ClassReader.SKIP_DEBUG | ClassReader.SKIP_FRAMES
}
if (m == null)
throw new InternalSpockError(
"failed to find method org.objectweb.asm.ClassReader.accept(); seems like an incompatible version of ASM is on the class path");
acceptMethod = m;
acceptMethodSecondArg = arg;
}
AsmClassReader(InputStream stream) throws IOException {
reader = new ClassReader(stream);
}
void accept(SpecClassFileVisitor visitor) {
ReflectionUtil.invokeMethod(reader, acceptMethod, visitor, acceptMethodSecondArg);
}
}
EmptyAnnotationVisitor.java 0000664 0000000 0000000 00000002032 12020225233 0034667 0 ustar 00root root 0000000 0000000 spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/buildsupport /*
* Copyright 2010 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* http://www.apache.org/licenses/LICENSE-2.0
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.buildsupport;
import org.objectweb.asm.AnnotationVisitor;
class EmptyAnnotationVisitor implements AnnotationVisitor {
public void visit(String s, Object o) {}
public void visitEnum(String s, String s1, String s2) {}
public AnnotationVisitor visitAnnotation(String s, String s1) {
return this;
}
public AnnotationVisitor visitArray(String s) {
return this;
}
public void visitEnd() {}
} SpecClassFileFinder.java 0000664 0000000 0000000 00000003626 12020225233 0034000 0 ustar 00root root 0000000 0000000 spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/buildsupport /**
* Copyright 2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.buildsupport;
import java.io.*;
import java.util.*;
/**
* Finds all class files below a base directory that contain a runnable spec.
*
* @author Peter Niederwieser
*/
public class SpecClassFileFinder {
public List findRunnableSpecs(File baseDir) throws IOException {
if (!baseDir.isDirectory())
throw new FileNotFoundException(String.format("directory %s not found", baseDir));
List specs = new ArrayList();
doFindRunnableSpecs(baseDir, specs);
Collections.sort(specs);
return specs;
}
private void doFindRunnableSpecs(File dir, List foundSpecs) throws IOException {
for (File path: dir.listFiles())
if (path.isDirectory())
doFindRunnableSpecs(path, foundSpecs);
else if (isRunnableSpec(path))
foundSpecs.add(path);
}
public boolean isRunnableSpec(File file) throws IOException {
if (!(file.getName().endsWith(".class") && file.isFile()))
return false;
InputStream stream = new BufferedInputStream(new FileInputStream(file));
try {
SpecClassFileVisitor visitor = new SpecClassFileVisitor();
AsmClassReader reader = new AsmClassReader(stream);
reader.accept(visitor);
return visitor.isRunnableSpec();
} finally {
stream.close();
}
}
}
SpecClassFileVisitor.java 0000664 0000000 0000000 00000003714 12020225233 0034226 0 ustar 00root root 0000000 0000000 spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/buildsupport /**
* Copyright 2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.buildsupport;
import org.objectweb.asm.*;
class SpecClassFileVisitor implements ClassVisitor {
private final AnnotationVisitor annVisitor = new EmptyAnnotationVisitor();
private boolean hasSpecMetadataAnnotation = false;
private boolean isAbstract;
public boolean isSpec() {
return hasSpecMetadataAnnotation;
}
public boolean isRunnableSpec() {
return isSpec() && !isAbstract;
}
public AnnotationVisitor visitAnnotation(String desc, boolean visible) {
if ("Lorg/spockframework/runtime/model/SpecMetadata;".equals(desc))
hasSpecMetadataAnnotation = true;
return annVisitor;
}
public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) {
isAbstract = (access & Opcodes.ACC_ABSTRACT) != 0;
}
public void visitSource(String s, String s1) {}
public void visitOuterClass(String s, String s1, String s2) {}
public void visitAttribute(Attribute attribute) {}
public void visitInnerClass(String s, String s1, String s2, int i) {}
public FieldVisitor visitField(int i, String s, String s1, String s2, Object o) {
return null; // allowed as per contract
}
public MethodVisitor visitMethod(int i, String s, String s1, String s2, String[] strings) {
return null; // allowed as per contract
}
public void visitEnd() {}
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/buildsupport/ant/ 0000775 0000000 0000000 00000000000 12020225233 0030157 5 ustar 00root root 0000000 0000000 SpecClassFileSelector.java 0000664 0000000 0000000 00000002631 12020225233 0035126 0 ustar 00root root 0000000 0000000 spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/buildsupport/ant /*
* Copyright 2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.buildsupport.ant;
import java.io.File;
import java.io.IOException;
import org.apache.tools.ant.Project;
import org.apache.tools.ant.types.selectors.BaseExtendSelector;
import org.spockframework.buildsupport.SpecClassFileFinder;
/**
* Ant selector that selects class files containing Spock specifications.
*/
public class SpecClassFileSelector extends BaseExtendSelector {
private final SpecClassFileFinder finder = new SpecClassFileFinder();
@Override
public boolean isSelected(File baseDir, String filename, File file) {
try {
return finder.isRunnableSpec(file);
} catch (IOException e) {
String msg = e.getMessage();
log("Error reading class file '" + filename + (msg == null ? "'" : "': " + msg), Project.MSG_WARN);
return false;
}
}
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/compiler/ 0000775 0000000 0000000 00000000000 12020225233 0026453 5 ustar 00root root 0000000 0000000 spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/compiler/AbstractSpecVisitor.java 0000775 0000000 0000000 00000003264 12020225233 0033264 0 ustar 00root root 0000000 0000000 /*
* Copyright 2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.compiler;
import org.spockframework.compiler.model.*;
// IDEA: store context (SpecInfo, method, etc.); e.g. by overriding new visitNode method and making it final
public class AbstractSpecVisitor implements ISpecVisitor {
public void visitSpec(Spec spec) throws Exception {}
public void visitSpecAgain(Spec spec) throws Exception {}
public void visitField(Field field) throws Exception {}
public void visitMethod(Method method) throws Exception {}
public void visitMethodAgain(Method method) throws Exception {}
public void visitAnyBlock(Block block) throws Exception {}
public void visitAnonymousBlock(AnonymousBlock block) throws Exception {}
public void visitSetupBlock(SetupBlock block) throws Exception {}
public void visitExpectBlock(ExpectBlock block) throws Exception {}
public void visitWhenBlock(WhenBlock block) throws Exception {}
public void visitThenBlock(ThenBlock block) throws Exception {}
public void visitCleanupBlock(CleanupBlock block) throws Exception {}
public void visitWhereBlock(WhereBlock block) throws Exception {}
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/compiler/AstNodeCache.java 0000775 0000000 0000000 00000006507 12020225233 0031612 0 ustar 00root root 0000000 0000000 /*
* Copyright 2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.compiler;
import org.codehaus.groovy.ast.*;
import org.spockframework.mock.*;
import org.spockframework.runtime.SpockRuntime;
import org.spockframework.runtime.ValueRecorder;
import org.spockframework.runtime.model.*;
import spock.lang.*;
/**
* Provides access to frequently used AST nodes.
*
* @author Peter Niederwieser
*/
public class AstNodeCache {
public final ClassNode SpockRuntime = ClassHelper.makeWithoutCaching(SpockRuntime.class);
public final ClassNode ValueRecorder = ClassHelper.makeWithoutCaching(ValueRecorder.class);
public final ClassNode Specification = ClassHelper.makeWithoutCaching(Specification.class);
public final MethodNode SpockRuntime_VerifyCondition =
SpockRuntime.getDeclaredMethods(org.spockframework.runtime.SpockRuntime.VERIFY_CONDITION).get(0);
public final MethodNode SpockRuntime_VerifyMethodCondition =
SpockRuntime.getDeclaredMethods(org.spockframework.runtime.SpockRuntime.VERIFY_METHOD_CONDITION).get(0);
public final MethodNode ValueRecorder_Reset =
ValueRecorder.getDeclaredMethods(org.spockframework.runtime.ValueRecorder.RESET).get(0);
public final MethodNode ValueRecorder_Record =
ValueRecorder.getDeclaredMethods(org.spockframework.runtime.ValueRecorder.RECORD).get(0);
public final MethodNode ValueRecorder_RealizeNas =
ValueRecorder.getDeclaredMethods(org.spockframework.runtime.ValueRecorder.REALIZE_NAS).get(0);
// annotations and annotation elements
public final ClassNode SpecMetadata = ClassHelper.makeWithoutCaching(SpecMetadata.class);
public final ClassNode FieldMetadata = ClassHelper.makeWithoutCaching(FieldMetadata.class);
public final ClassNode FeatureMetadata = ClassHelper.makeWithoutCaching(FeatureMetadata.class);
public final ClassNode DataProviderMetadata = ClassHelper.makeWithoutCaching(DataProviderMetadata.class);
public final ClassNode BlockMetadata = ClassHelper.makeWithoutCaching(BlockMetadata.class);
public final ClassNode BlockKind = ClassHelper.makeWithoutCaching(BlockKind.class);
// mocking API
public final ClassNode MockController = ClassHelper.makeWithoutCaching(MockController.class);
public final ClassNode InteractionBuilder = ClassHelper.makeWithoutCaching(InteractionBuilder.class);
public final FieldNode DefaultMockFactory_INSTANCE;
// external types
public final ClassNode Throwable = ClassHelper.makeWithoutCaching(Throwable.class);
public AstNodeCache() {
ClassNode factory = ClassHelper.makeWithoutCaching(DefaultMockFactory.class);
// since ClassNode.getField(String) does not trigger class node initialization, we call getFields() first
factory.getFields();
DefaultMockFactory_INSTANCE = factory.getField(DefaultMockFactory.INSTANCE_FIELD);
}
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/compiler/AstUtil.java 0000775 0000000 0000000 00000035542 12020225233 0030717 0 ustar 00root root 0000000 0000000 /*
* Copyright 2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.compiler;
import java.util.*;
import org.codehaus.groovy.ast.*;
import org.codehaus.groovy.ast.expr.*;
import org.codehaus.groovy.ast.stmt.*;
import org.codehaus.groovy.syntax.Types;
import org.objectweb.asm.Opcodes;
import org.spockframework.lang.Wildcard;
import org.spockframework.runtime.SpockRuntime;
import org.spockframework.util.InternalSpockError;
import org.spockframework.util.Nullable;
import spock.lang.Specification;
/**
* Utility methods for AST processing.
*
* @author Peter Niederwieser
*/
public abstract class AstUtil {
/**
* Tells whether the given node has an annotation of the given type.
*
* @param node an AST node
* @param annotationType an annotation type
* @return true iff the given node has an annotation of the given type
*/
public static boolean hasAnnotation(ASTNode node, Class annotationType) {
return getAnnotation(node, annotationType) != null;
}
public static AnnotationNode getAnnotation(ASTNode node, Class annotationType) {
if (!(node instanceof AnnotatedNode)) return null;
AnnotatedNode annotated = (AnnotatedNode)node;
@SuppressWarnings("unchecked")
List annotations = annotated.getAnnotations();
for (AnnotationNode a : annotations)
if (a.getClassNode().getName().equals(annotationType.getName())) return a;
return null;
}
/**
* Returns a list of statements of the given method. Modifications to the returned list
* will affect the method's statements.
*
* @param method a method (node)
* @return a list of statements of the given method
*/
@SuppressWarnings("unchecked")
public static List getStatements(MethodNode method) {
Statement code = method.getCode();
if (!(code instanceof BlockStatement)) { // null or single statement
BlockStatement block = new BlockStatement();
if (code != null) block.addStatement(code);
method.setCode(block);
}
return ((BlockStatement)method.getCode()).getStatements();
}
@SuppressWarnings("unchecked")
public static List getStatements(ClosureExpression closure) {
BlockStatement blockStat = (BlockStatement)closure.getCode();
return blockStat == null ?
Collections. emptyList() : // it's not possible to add any statements to such a ClosureExpression, so immutable list is OK
blockStat.getStatements();
}
public static boolean isMethodInvocation(Expression expr) {
return expr instanceof MethodCallExpression
|| expr instanceof StaticMethodCallExpression;
}
public static Expression getInvocationTarget(Expression expr) {
if (expr instanceof PropertyExpression)
return ((PropertyExpression)expr).getObjectExpression();
if (expr instanceof MethodCallExpression)
return ((MethodCallExpression)expr).getObjectExpression();
if (expr instanceof StaticMethodCallExpression)
return new ClassExpression(((StaticMethodCallExpression)expr).getOwnerType());
return null;
}
public static boolean isWildcardRef(Expression expr) {
VariableExpression varExpr = AstUtil.asInstance(expr, VariableExpression.class);
if (varExpr == null || !varExpr.getName().equals(Wildcard.INSTANCE.toString())) return false;
Variable accessedVar = varExpr.getAccessedVariable();
if (!(accessedVar instanceof FieldNode)) return false;
return ((FieldNode) accessedVar).getOwner().getName().equals(Specification.class.getName());
}
public static boolean isJavaIdentifier(String id) {
if (id == null || id.length() == 0
|| !Character.isJavaIdentifierStart(id.charAt(0)))
return false;
for (int i = 1; i < id.length(); i++)
if (!Character.isJavaIdentifierPart(id.charAt(i)))
return false;
return true;
}
public static T getExpression(Statement stat, Class type) {
ExpressionStatement exprStat = asInstance(stat, ExpressionStatement.class);
if (exprStat == null) return null;
return asInstance(exprStat.getExpression(), type);
}
@SuppressWarnings("unchecked")
public static @Nullable T asInstance(Object obj, Class type) {
return type.isInstance(obj) ? (T) obj : null;
}
public static boolean isSynthetic(MethodNode method) {
return method.isSynthetic() || (method.getModifiers() & Opcodes.ACC_SYNTHETIC) != 0;
}
/**
* Tells if the source position for the given AST node is plausible.
* Does not imply that the source position is correct.
*
* @param node an AST node
* @return true iff the AST node has a plausible source position
*/
public static boolean hasPlausibleSourcePosition(ASTNode node) {
return node.getLineNumber() > 0 && node.getLastLineNumber() >= node.getLineNumber()
&& node.getColumnNumber() > 0 && node.getLastColumnNumber() > node.getColumnNumber();
}
// Note: The returned list may contain SpreadExpression's,
// which can't be used outside an ArgumentListExpression.
// To pass an argument list to the Groovy or Spock runtime,
// use this method together with AstUtil.toArgumentArray().
public static List getArguments(Expression expr) {
if (expr instanceof MethodCallExpression)
return getArguments((MethodCallExpression)expr);
else if (expr instanceof StaticMethodCallExpression)
return getArguments((StaticMethodCallExpression)expr);
else return null;
}
@SuppressWarnings("unchecked")
public static List getArguments(MethodCallExpression expr) {
// MethodCallExpression.getArguments() may return an ArgumentListExpression,
// a TupleExpression that wraps a NamedArgumentListExpression,
// or (at least in 1.6) a NamedArgumentListExpression
if (expr.getArguments() instanceof NamedArgumentListExpression)
// return same result as for NamedArgumentListExpression wrapped in TupleExpression
return Collections.singletonList(expr.getArguments());
return ((TupleExpression) expr.getArguments()).getExpressions();
}
@SuppressWarnings("unchecked")
public static List getArguments(StaticMethodCallExpression expr) {
// see comments in getArguments(MethodCallExpression)
if (expr.getArguments() instanceof NamedArgumentListExpression)
return Collections.singletonList(expr.getArguments());
return ((TupleExpression)expr.getArguments()).getExpressions();
}
/**
* Turns an argument list obtained from AstUtil.getArguments() into an Object[] array
* suitable to be passed to InvokerHelper or SpockRuntime. The main challenge is
* to handle SpreadExpression's correctly.
*/
public static Expression toArgumentArray(List argList, IRewriteResources resources) {
List normalArgs = new ArrayList();
List spreadArgs = new ArrayList();
List spreadPositions = new ArrayList();
for (int i = 0; i < argList.size(); i++) {
Expression arg = argList.get(i);
if (arg instanceof SpreadExpression) {
spreadArgs.add(((SpreadExpression) arg).getExpression());
spreadPositions.add(new ConstantExpression(i));
} else {
normalArgs.add(arg);
}
}
if (spreadArgs.isEmpty())
return new ArrayExpression(ClassHelper.OBJECT_TYPE, argList);
return new MethodCallExpression(
new ClassExpression(resources.getAstNodeCache().SpockRuntime),
new ConstantExpression(SpockRuntime.DESPREAD_LIST),
new ArgumentListExpression(
new ArrayExpression(ClassHelper.OBJECT_TYPE, normalArgs),
new ArrayExpression(ClassHelper.OBJECT_TYPE, spreadArgs),
new ArrayExpression(ClassHelper.int_TYPE, spreadPositions)
));
}
public static boolean isBuiltinMemberAssignmentOrCall(Expression expr, String methodName, int minArgs, int maxArgs) {
return expr instanceof BinaryExpression
&& isBuiltinMemberAssignment((BinaryExpression)expr, methodName, minArgs, maxArgs)
|| expr instanceof MethodCallExpression
&& isBuiltinMemberCall((MethodCallExpression) expr, methodName, minArgs, maxArgs);
}
public static boolean isBuiltinMemberAssignment(BinaryExpression expr, String methodName, int minArgs, int maxArgs) {
return expr.getOperation().getType() == Types.ASSIGN
&& isBuiltinMemberAssignmentOrCall(expr.getRightExpression(), methodName, minArgs, maxArgs);
}
public static boolean isBuiltinMemberCall(Expression expr, String methodName, int minArgs, int maxArgs) {
return expr instanceof MethodCallExpression
&& isBuiltinMemberCall((MethodCallExpression)expr, methodName, minArgs, maxArgs);
}
// call of the form "this.(...)" or "(...)"
public static boolean isBuiltinMemberCall(MethodCallExpression expr, String methodName, int minArgs, int maxArgs) {
return
(isThisExpression(expr.getObjectExpression()) || isSuperExpression(expr.getObjectExpression()))
&& methodName.equals(expr.getMethodAsString()) // getMethodAsString() may return null
&& getArguments(expr).size() >= minArgs
&& getArguments(expr).size() <= maxArgs;
}
public static void expandBuiltinMemberAssignmentOrCall(Expression builtinMemberAssignmentOrCall, Expression... additionalArgs)
throws InvalidSpecCompileException {
if (builtinMemberAssignmentOrCall instanceof BinaryExpression)
expandBuiltinMemberAssignment((BinaryExpression)builtinMemberAssignmentOrCall, additionalArgs);
else
expandBuiltinMemberCall(builtinMemberAssignmentOrCall, additionalArgs);
}
/*
* Expands an assignment of the form "(def) x = builtinMethodCall(...)", where x is a field or local variable.
* Assumes isBuiltinMemberAssignment(...).
*/
public static void expandBuiltinMemberAssignment(BinaryExpression builtinMemberAssignment, Expression... additionalArgs)
throws InvalidSpecCompileException {
Expression builtinMemberCall = builtinMemberAssignment.getRightExpression();
String name = getInferredName(builtinMemberAssignment);
Expression type = getType(builtinMemberCall, getInferredType(builtinMemberAssignment));
doExpandBuiltinMemberCall(builtinMemberCall, name, type, additionalArgs);
}
public static void expandBuiltinMemberCall(Expression builtinMemberCall, Expression... additionalArgs)
throws InvalidSpecCompileException {
doExpandBuiltinMemberCall(builtinMemberCall, null, getType(builtinMemberCall, null), additionalArgs);
}
private static Expression getType(Expression builtinMemberCall, Expression inferredType)
throws InvalidSpecCompileException {
List args = AstUtil.getArguments(builtinMemberCall);
assert args != null;
if (args.isEmpty()) {
if (inferredType == null)
// TODO: improve error message (not clear that it originates from Mock() or thrown())
throw new InvalidSpecCompileException(builtinMemberCall, "Type cannot be inferred; please specify one explicitely");
return inferredType;
}
return args.get(0);
}
private static String getInferredName(BinaryExpression builtinMemberAssignment) {
Expression left = builtinMemberAssignment.getLeftExpression();
if (left instanceof Variable) return ((Variable)left).getName();
if (left instanceof FieldExpression) return ((FieldExpression)left).getFieldName();
return null;
}
private static ClassExpression getInferredType(BinaryExpression builtinMemberAssignment) {
ClassNode type = builtinMemberAssignment.getLeftExpression().getType();
return type == null || type == ClassHelper.DYNAMIC_TYPE ?
null : new ClassExpression(type);
}
private static void doExpandBuiltinMemberCall(Expression builtinMemberCall, String name,
Expression type, Expression... additionalArgs) {
checkIsSafeToMutateArgs(builtinMemberCall);
List args = getArguments(builtinMemberCall);
args.clear();
args.add(type);
args.add(new ConstantExpression(name));
args.addAll(Arrays.asList(additionalArgs));
}
private static void checkIsSafeToMutateArgs(Expression methodCall) {
Expression args = ((MethodCallExpression)methodCall).getArguments();
if (args == ArgumentListExpression.EMPTY_ARGUMENTS)
throw new InternalSpockError("checkIsSafeToMutateArgs");
}
@Nullable
public static Expression getAssertionMessage(AssertStatement stat) {
Expression msg = stat.getMessageExpression();
if (msg == null) return null; // should not happen
if (!(msg instanceof ConstantExpression)) return msg;
return ((ConstantExpression) msg).isNullExpression() ? null : msg;
}
public static boolean isThisExpression(Expression expr) {
return expr instanceof VariableExpression
&& ((VariableExpression)expr).isThisExpression();
}
public static boolean isSuperExpression(Expression expr) {
return expr instanceof VariableExpression
&& ((VariableExpression)expr).isSuperExpression();
}
public static void setVisibility(MethodNode method, int visibility) {
int modifiers = method.getModifiers();
modifiers &= ~(Opcodes.ACC_PUBLIC | Opcodes.ACC_PROTECTED | Opcodes.ACC_PRIVATE);
method.setModifiers(modifiers | visibility);
}
public static int getVisibility(FieldNode field) {
return field.getModifiers() & (Opcodes.ACC_PUBLIC | Opcodes.ACC_PROTECTED | Opcodes.ACC_PRIVATE);
}
public static void setVisibility(FieldNode field, int visibility) {
int modifiers = field.getModifiers();
modifiers &= ~(Opcodes.ACC_PUBLIC | Opcodes.ACC_PROTECTED | Opcodes.ACC_PRIVATE);
field.setModifiers(modifiers | visibility);
}
public static boolean isJointCompiled(ClassNode clazz) {
return clazz.getModule().getUnit().getConfig().getJointCompilationOptions() != null;
}
public static MethodCallExpression createDirectMethodCall(Expression target, MethodNode method, Expression arguments) {
MethodCallExpression result = new MethodCallExpression(target, method.getName(), arguments);
result.setMethodTarget(method);
result.setImplicitThis(false); // see http://groovy.329449.n5.nabble.com/Problem-with-latest-2-0-beta-3-snapshot-and-Spock-td5496353.html
return result;
}
public static void deleteMethod(ClassNode clazz, MethodNode method) {
// as of 1.8.6, this is the best possible implementation
clazz.getMethods().remove(method);
clazz.getDeclaredMethods(method.getName()).remove(method);
}
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/compiler/ConditionRewriter.java 0000775 0000000 0000000 00000052577 12020225233 0033013 0 ustar 00root root 0000000 0000000 /*
* Copyright 2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.compiler;
import java.util.*;
import org.codehaus.groovy.ast.MethodNode;
import org.codehaus.groovy.ast.expr.*;
import org.codehaus.groovy.ast.stmt.*;
import org.codehaus.groovy.classgen.BytecodeExpression;
import org.codehaus.groovy.syntax.Types;
import org.spockframework.runtime.ValueRecorder;
import org.spockframework.util.*;
// NOTE: currently some conversions reference old expression objects rather than copying them;
// this can potentially lead to aliasing problems (e.g. for Condition.originalExpression)
// background: it was found that transformExpression() cannot be used to copy all expressions
// (some implementations just return original expression); as a consequence, the design goal
// of copying everything was dropped for the time being
// IDEA: record type literals as class objects (since we also record other literals)
// but since a type literal cannot be evaluated, we would have to record class object
// before/after evaluating next/previous expression
/**
* Rewrites explicit ("assert x > 3") and implicit ("x > 3") condition
* statements. Replacing the original statement with the rewritten one is up
* to clients.
*
* @author Peter Niederwieser
*/
public class ConditionRewriter extends AbstractExpressionConverter {
private final IRewriteResources resources;
private int recordCount = 0;
private boolean doNotRecordNextConstant = false;
private ConditionRewriter(IRewriteResources resources) {
this.resources = resources;
}
public static Statement rewriteExplicitCondition(AssertStatement stat, IRewriteResources resources) {
ConditionRewriter rewriter = new ConditionRewriter(resources);
Expression message = AstUtil.getAssertionMessage(stat);
return rewriter.rewriteCondition(stat, stat.getBooleanExpression().getExpression(), message, true);
}
public static Statement rewriteImplicitCondition(ExpressionStatement stat, IRewriteResources resources) {
ConditionRewriter rewriter = new ConditionRewriter(resources);
return rewriter.rewriteCondition(stat, stat.getExpression(), null, false);
}
public void visitMethodCallExpression(MethodCallExpression expr) {
// at runtime, condition AST is only parsed up to phase conversion,
// and hence looks differently in cases where groovyc inserts ".call"
// in phase semantic analysis; we need to compensate for that
// (in other cases, ".call" is only inserted after transform has
// run, and hence we don't need to compensate)
boolean objectExprSeenAsMethodNameAtRuntime =
!expr.isImplicitThis()
&& expr.getObjectExpression() instanceof VariableExpression
&& "call".equals(expr.getMethodAsString())
&& (!AstUtil.hasPlausibleSourcePosition(expr.getMethod()) // before GROOVY-4344 fix
|| (expr.getMethod().getColumnNumber() == expr.getObjectExpression().getColumnNumber())); // after GROOVY-4344 fix
MethodCallExpression conversion =
new MethodCallExpression(
expr.isImplicitThis() ?
expr.getObjectExpression() :
convert(expr.getObjectExpression()),
objectExprSeenAsMethodNameAtRuntime ?
expr.getMethod() :
convert(expr.getMethod()),
convert(expr.getArguments()));
conversion.setSafe(expr.isSafe());
conversion.setSpreadSafe(expr.isSpreadSafe());
conversion.setSourcePosition(expr);
result = record(conversion);
}
// only used for statically imported methods called by their simple name
public void visitStaticMethodCallExpression(StaticMethodCallExpression expr) {
StaticMethodCallExpression conversion =
new StaticMethodCallExpression(
expr.getOwnerType(),
recordNa(expr.getMethod()),
convert(expr.getArguments()));
conversion.setSourcePosition(expr);
conversion.setMetaMethod(expr.getMetaMethod());
result = record(conversion);
}
public void visitBytecodeExpression(BytecodeExpression expr) {
unsupported(); // cannot occur in condition
}
@SuppressWarnings("unchecked")
public void visitArgumentlistExpression(ArgumentListExpression expr) {
ArgumentListExpression conversion =
new ArgumentListExpression(
convertAll(expr.getExpressions()));
conversion.setSourcePosition(expr);
result = recordNa(conversion);
}
public void visitPropertyExpression(PropertyExpression expr) {
PropertyExpression conversion =
new PropertyExpression(
expr.isImplicitThis() ?
expr.getObjectExpression() :
convert(expr.getObjectExpression()),
expr.getProperty(),
expr.isSafe());
conversion.setSourcePosition(expr);
conversion.setSpreadSafe(expr.isSpreadSafe());
conversion.setStatic(expr.isStatic());
conversion.setImplicitThis(expr.isImplicitThis());
result = record(conversion);
}
public void visitAttributeExpression(AttributeExpression expr) {
AttributeExpression conversion =
new AttributeExpression(
expr.isImplicitThis() ?
expr.getObjectExpression() :
convert(expr.getObjectExpression()),
expr.getProperty(),
expr.isSafe());
conversion.setSourcePosition(expr);
conversion.setSpreadSafe(expr.isSpreadSafe());
conversion.setStatic(expr.isStatic());
conversion.setImplicitThis(expr.isImplicitThis());
result = record(conversion);
}
// as of Groovy 1.7.3, used for:
// - references to statically imported fields
// - compiler-generated code
// - code generated by some transforms
public void visitFieldExpression(FieldExpression expr) {
result = record(expr);
}
public void visitMethodPointerExpression(MethodPointerExpression expr) {
MethodPointerExpression conversion =
new MethodPointerExpression(
convert(expr.getExpression()),
convert(expr.getMethodName()));
conversion.setSourcePosition(expr);
result = record(conversion);
}
public void visitVariableExpression(VariableExpression expr) {
if (expr instanceof OldValueExpression) {
Expression originalExpr = ((OldValueExpression)expr).getOrginalExpression();
originalExpr.visit(this); // just to count up recordCount and produce the correct number of N/A values at runtime
doNotRecordNextConstant = true; // we know Specification.old() has been rewritten to include a dummy as second argument
result = expr;
return;
}
result = record(expr);
}
public void visitDeclarationExpression(DeclarationExpression expr) {
unsupported(); // cannot occur in condition
}
public void visitBinaryExpression(BinaryExpression expr) {
BinaryExpression conversion =
new BinaryExpression(
Types.ofType(expr.getOperation().getType(), Types.ASSIGNMENT_OPERATOR) ?
// prevent lvalue from getting turned into record(lvalue), which can no longer be assigned to
convertAndRecordNa(expr.getLeftExpression()) :
convert(expr.getLeftExpression()),
expr.getOperation(),
convert(expr.getRightExpression()));
conversion.setSourcePosition(expr);
result = record(conversion);
}
public void visitConstantExpression(ConstantExpression expr) {
if (doNotRecordNextConstant) {
doNotRecordNextConstant = false;
result = expr;
return;
}
result = record(expr);
}
public void visitClassExpression(ClassExpression expr) {
result = expr;
// ensure this isn't the class part of a class member access where the member has been
// imported statically and the class is therefore not present in the
// code; instead of looking through imports, we try to infer this from
// source position information
if (!AstUtil.hasPlausibleSourcePosition(expr)) return;
// because runtime condition parsing only proceeds up to compiler phase
// CONVERSION, this ClassExpression will be seen as a VariableExpression
// (e.g. "Type"), or a VariableExpression nested within one or more PropertyExpressions
// (e.g. "org.Type", "Type.class", "org.Type.class");
// therefore we have to provide one N/A value for every part of the class name
String text = resources.getSourceText(expr);
// NOTE: remove guessing (text == null) once underlying Groovy problem has been fixed
recordCount += text == null ? 1 : TextUtil.countOccurrences(text, '.') + 1;
}
public void visitUnaryMinusExpression(UnaryMinusExpression expr) {
UnaryMinusExpression conversion =
new UnaryMinusExpression(
convert(expr.getExpression()));
conversion.setSourcePosition(expr);
result = record(conversion);
}
public void visitUnaryPlusExpression(UnaryPlusExpression expr) {
UnaryPlusExpression conversion =
new UnaryPlusExpression(
convert(expr.getExpression()));
conversion.setSourcePosition(expr);
result = record(conversion);
}
public void visitBitwiseNegationExpression(BitwiseNegationExpression expr) {
BitwiseNegationExpression conversion =
new BitwiseNegationExpression(
convert(expr.getExpression()));
conversion.setSourcePosition(expr);
result = record(conversion);
}
public void visitCastExpression(CastExpression expr) {
CastExpression conversion =
new CastExpression(
expr.getType(),
convert(expr.getExpression()),
expr.isIgnoringAutoboxing());
conversion.setSourcePosition(expr);
conversion.setCoerce(expr.isCoerce());
result = record(conversion);
}
public void visitClosureListExpression(ClosureListExpression expr) {
unsupported(); // cannot occur in condition
}
public void visitNotExpression(NotExpression expr) {
NotExpression conversion =
new NotExpression(
convert(expr.getExpression()));
conversion.setSourcePosition(expr);
result = record(conversion);
}
@SuppressWarnings("unchecked")
public void visitListExpression(ListExpression expr) {
ListExpression conversion =
new ListExpression(
convertAll(expr.getExpressions()));
conversion.setSourcePosition(expr);
result = record(conversion);
}
public void visitRangeExpression(RangeExpression expr) {
RangeExpression conversion =
new RangeExpression(
convert(expr.getFrom()),
convert(expr.getTo()),
expr.isInclusive());
conversion.setSourcePosition(expr);
result = record(conversion);
}
@SuppressWarnings("unchecked")
public void visitMapExpression(MapExpression expr) {
boolean namedArgumentListExpr = expr instanceof NamedArgumentListExpression;
MapExpression conversion =
namedArgumentListExpr ?
new NamedArgumentListExpression(
(List) convertAll(expr.getMapEntryExpressions())) :
new MapExpression(
(List) convertAll(expr.getMapEntryExpressions()));
conversion.setSourcePosition(expr);
result = namedArgumentListExpr ? recordNa(conversion) : record(conversion);
}
public void visitMapEntryExpression(MapEntryExpression expr) {
MapEntryExpression conversion =
new MapEntryExpression(
convert(expr.getKeyExpression()),
convert(expr.getValueExpression()));
conversion.setSourcePosition(expr);
result = recordNa(conversion);
}
public void visitConstructorCallExpression(ConstructorCallExpression expr) {
ConstructorCallExpression conversion =
new ConstructorCallExpression(
expr.getType(),
convert(expr.getArguments()));
conversion.setSourcePosition(expr);
result = record(conversion);
}
@SuppressWarnings("unchecked")
public void visitGStringExpression(GStringExpression expr) {
GStringExpression conversion =
new GStringExpression(
expr.getText(),
expr.getStrings(),
convertAll(expr.getValues()));
conversion.setSourcePosition(expr);
result = record(conversion);
}
@SuppressWarnings("unchecked")
public void visitArrayExpression(ArrayExpression expr) {
ArrayExpression conversion =
new ArrayExpression(
expr.getElementType(),
convertAll(expr.getExpressions()),
convertAll(expr.getSizeExpression()));
conversion.setSourcePosition(expr);
result = record(conversion);
}
public void visitSpreadExpression(SpreadExpression expr) {
SpreadExpression conversion =
new SpreadExpression(
convert(expr.getExpression()));
conversion.setSourcePosition(expr);
result = recordNa(conversion);
}
public void visitSpreadMapExpression(SpreadMapExpression expr) {
// to not record the underlying MapExpression twice, we do nothing here
// see http://jira.codehaus.org/browse/GROOVY-3421
result = recordNa(expr);
}
public void visitTernaryExpression(TernaryExpression expr) {
TernaryExpression conversion =
new TernaryExpression(
convertCompatibly(expr.getBooleanExpression()),
convert(expr.getTrueExpression()),
convert(expr.getFalseExpression()));
conversion.setSourcePosition(expr);
result = record(conversion);
}
public void visitShortTernaryExpression(ElvisOperatorExpression expr) {
ElvisOperatorExpression conversion =
new ElvisOperatorExpression(
convert(expr.getTrueExpression()),
convert(expr.getFalseExpression()));
conversion.setSourcePosition(expr);
result = record(conversion);
}
public void visitPrefixExpression(PrefixExpression expr) {
PrefixExpression conversion =
new PrefixExpression(
expr.getOperation(),
convertAndRecordNa(expr.getExpression()));
conversion.setSourcePosition(expr);
result = record(conversion);
}
public void visitPostfixExpression(PostfixExpression expr) {
PostfixExpression conversion =
new PostfixExpression(
convertAndRecordNa(expr.getExpression()),
expr.getOperation());
conversion.setSourcePosition(expr);
result = record(conversion);
}
public void visitBooleanExpression(BooleanExpression expr) {
BooleanExpression conversion =
new BooleanExpression(
convert(expr.getExpression())
);
conversion.setSourcePosition(expr);
result = recordNa(conversion);
}
public void visitClosureExpression(ClosureExpression expr) {
result = record(expr);
}
// used in the following places:
// - LHS of multi-assignment
// - wraps NamedArgumentListExpression (not always in 1.6.x)
@SuppressWarnings("unchecked")
public void visitTupleExpression(TupleExpression expr) {
TupleExpression conversion =
new TupleExpression(
// prevent each lvalue from getting turned into record(lvalue),
// which no longer is an lvalue
convertAllAndRecordNa(expr.getExpressions()));
conversion.setSourcePosition(expr);
result = recordNa(conversion);
}
private Expression record(Expression expr) {
return AstUtil.createDirectMethodCall(
new VariableExpression("$spock_valueRecorder"),
resources.getAstNodeCache().ValueRecorder_Record,
new ArgumentListExpression(new ConstantExpression(recordCount++), expr));
}
private Expression realizeNas(Expression expr) {
return AstUtil.createDirectMethodCall(
new VariableExpression("$spock_valueRecorder"),
resources.getAstNodeCache().ValueRecorder_RealizeNas,
new ArgumentListExpression(new ConstantExpression(recordCount), expr));
}
private T recordNa(T expr) {
recordCount++;
return expr;
}
private Expression convertAndRecordNa(Expression expr) {
return unrecord(convert(expr));
}
private List convertAllAndRecordNa(List expressions) {
List conversions = new ArrayList(expressions.size());
for (Expression expr : expressions) conversions.add(convertAndRecordNa(expr));
return conversions;
}
@SuppressWarnings("unchecked")
private T convertCompatibly(T expr) {
Expression conversion = convert(expr);
Assert.that(expr.getClass().isInstance(conversion));
return (T) conversion;
}
// unrecord(record(expr)) == expr
// does not change recordCount, resulting in one N/A value at runtime
private Expression unrecord(Expression expr) {
if (!(expr instanceof MethodCallExpression)) return expr;
MethodCallExpression methodExpr = (MethodCallExpression) expr;
Expression targetExpr = methodExpr.getObjectExpression();
if (!(targetExpr instanceof VariableExpression)) return expr;
VariableExpression var = (VariableExpression)targetExpr;
if (!var.getName().equals("$spock_valueRecorder")) return expr;
if(!methodExpr.getMethodAsString().equals(ValueRecorder.RECORD)) return expr;
return ((ArgumentListExpression)methodExpr.getArguments()).getExpression(1);
}
private Statement rewriteCondition(Statement conditionStat, Expression conditionExpr, Expression message, boolean explicit) {
Statement result = new ExpressionStatement(rewriteCondition(conditionExpr, message, explicit));
result.setSourcePosition(conditionStat);
return result;
}
private Expression rewriteCondition(Expression expr, Expression message, boolean explicit) {
// method conditions with spread operator are not lifted because MOP doesn't support spreading
if (expr instanceof MethodCallExpression && !((MethodCallExpression) expr).isSpreadSafe())
return rewriteMethodCondition((MethodCallExpression) expr, message, explicit);
if (expr instanceof StaticMethodCallExpression)
return rewriteStaticMethodCondition((StaticMethodCallExpression) expr, message, explicit);
return rewriteOtherCondition(expr, message);
}
private Expression rewriteMethodCondition(MethodCallExpression condition, Expression message, boolean explicit) {
MethodCallExpression rewritten = message == null ?
(MethodCallExpression) unrecord(convert(condition)) : condition;
List args = new ArrayList();
args.add(rewritten.getObjectExpression());
args.add(rewritten.getMethod());
args.add(AstUtil.toArgumentArray(AstUtil.getArguments(rewritten), resources));
// rewriting has produced N/A's that haven't been realized yet, so do that now
args.add(realizeNas(new ConstantExpression(rewritten.isSafe())));
args.add(new ConstantExpression(explicit));
return rewriteToSpockRuntimeCall(resources.getAstNodeCache().SpockRuntime_VerifyMethodCondition, condition, message, args);
}
private Expression rewriteStaticMethodCondition(StaticMethodCallExpression condition, Expression message,
boolean explicit) {
StaticMethodCallExpression rewritten = message == null ?
(StaticMethodCallExpression) unrecord(convert(condition)) : condition;
List args = new ArrayList();
args.add(new ClassExpression(rewritten.getOwnerType()));
args.add(new ConstantExpression(rewritten.getMethod()));
args.add(AstUtil.toArgumentArray(AstUtil.getArguments(rewritten), resources));
// rewriting has produced N/A's that haven't been realized yet, so do that now
args.add(realizeNas(ConstantExpression.FALSE));
args.add(new ConstantExpression(explicit));
return rewriteToSpockRuntimeCall(resources.getAstNodeCache().SpockRuntime_VerifyMethodCondition, condition, message, args);
}
private Expression rewriteOtherCondition(Expression condition, Expression message) {
Expression rewritten = message == null ? convert(condition) : condition;
return rewriteToSpockRuntimeCall(resources.getAstNodeCache().SpockRuntime_VerifyCondition,
condition, message, Collections.singletonList(rewritten));
}
private Expression rewriteToSpockRuntimeCall(MethodNode method, Expression condition, Expression message,
List additionalArgs) {
List args = new ArrayList();
MethodCallExpression result = AstUtil.createDirectMethodCall(
new ClassExpression(resources.getAstNodeCache().SpockRuntime), method,
new ArgumentListExpression(args));
args.add(message == null ?
AstUtil.createDirectMethodCall(
new VariableExpression("$spock_valueRecorder"),
resources.getAstNodeCache().ValueRecorder_Reset,
ArgumentListExpression.EMPTY_ARGUMENTS) :
new ConstantExpression(null));
args.add(new ConstantExpression(resources.getSourceText(condition)));
args.add(new ConstantExpression(condition.getLineNumber()));
args.add(new ConstantExpression(condition.getColumnNumber()));
// the following means that "assert x, exprEvaluatingToNull" will be
// treated the same as "assert x"; but probably it doesn't matter too much
args.add(message == null ? new ConstantExpression(null) : message);
args.addAll(additionalArgs);
result.setSourcePosition(condition);
return result;
}
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/compiler/DeepStatementRewriter.java0000664 0000000 0000000 00000015606 12020225233 0033614 0 ustar 00root root 0000000 0000000 /*
* Copyright 2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.compiler;
import java.util.List;
import org.codehaus.groovy.ast.*;
import org.codehaus.groovy.ast.expr.*;
import org.codehaus.groovy.ast.stmt.*;
import org.spockframework.compiler.model.*;
import org.spockframework.util.Identifiers;
/**
* Walks the statement and expression tree to:
* - rewrite explicit conditions,
* - rewrite interactions,
* - rewrite core language primitives (members of class Specification)
* - Forbid
*
* Also records whether conditions and interactions were found.
*
* @author Peter Niederwieser
*/
public class DeepStatementRewriter extends StatementReplacingVisitorSupport {
private final IRewriteResources resources;
private boolean conditionFound = false;
private boolean interactionFound = false;
// scope for the current closure; null if not in a closure
private VariableScope closureScope;
public DeepStatementRewriter(IRewriteResources resources) {
this.resources = resources;
}
public boolean isConditionFound() {
return conditionFound;
}
public boolean isInteractionFound() {
return interactionFound;
}
public void visitBlock(Block block) {
replaceAll(block.getAst());
}
@Override
public void visitAssertStatement(AssertStatement stat) {
super.visitAssertStatement(stat);
conditionFound = true;
replaceVisitedStatementWith(
ConditionRewriter.rewriteExplicitCondition(stat, resources));
}
@Override
public void visitExpressionStatement(ExpressionStatement stat) {
super.visitExpressionStatement(stat);
Statement rewritten = new InteractionRewriter(resources).rewrite(stat);
if (rewritten == null) return;
interactionFound = true;
replaceVisitedStatementWith(rewritten);
}
@Override
public void visitClosureExpression(ClosureExpression expr) {
// because a closure might be executed asynchronously, its conditions
// and interactions are handled independently from the conditions
// and interactions of the closure's context
boolean oldConditionFound = conditionFound;
boolean oldInteractionFound = interactionFound;
VariableScope oldClosureScope = closureScope;
conditionFound = false;
interactionFound = false;
closureScope = expr.getVariableScope();
fixupParameters(closureScope, true);
super.visitClosureExpression(expr);
if (conditionFound) defineValueRecorder(expr);
conditionFound = oldConditionFound;
interactionFound = oldInteractionFound;
closureScope = oldClosureScope;
}
private void defineValueRecorder(ClosureExpression expr) {
resources.defineValueRecorder(AstUtil.getStatements(expr));
}
private void fixupParameters(VariableScope scope, boolean isClosureScope) {
Method method = resources.getCurrentMethod();
if (!(method instanceof FeatureMethod)) return;
// if this is a parameterized feature method w/o explicit parameter list,
// update any references to parameterization variables
// (parameterization variables used to be free variables,
// but have been changed to method parameters by WhereBlockRewriter)
for (Parameter param : method.getAst().getParameters()) {
Variable var = scope.getReferencedClassVariable(param.getName());
if (var instanceof DynamicVariable) {
scope.removeReferencedClassVariable(param.getName());
scope.putReferencedLocalVariable(param);
if (isClosureScope)
param.setClosureSharedVariable(true);
}
}
}
@Override
public void visitBlockStatement(BlockStatement stat) {
super.visitBlockStatement(stat);
fixupParameters(stat.getVariableScope(), false);
}
@Override
public void visitDeclarationExpression(DeclarationExpression expr) {
visitBinaryExpression(expr);
}
@Override
public void visitBinaryExpression(BinaryExpression expr) {
if (AstUtil.isBuiltinMemberAssignment(expr, Identifiers.MOCK, 0, 1))
try {
AstUtil.expandBuiltinMemberAssignment(expr, resources.getMockControllerRef());
} catch (InvalidSpecCompileException e) {
resources.getErrorReporter().error(e);
return;
}
// only descend after we have expanded Specification.Mock so that it's not
// expanded by visit(Static)MethodCallExpression instead
super.visitBinaryExpression(expr);
}
@Override
public void visitMethodCallExpression(MethodCallExpression expr) {
super.visitMethodCallExpression(expr);
forbidUseOfSuperInFixtureMethod(expr);
handleMockAndOldCalls(expr);
}
// Forbid the use of super.foo() in fixture method foo,
// because it is most likely a mistake (user thinks he is overriding
// the base method and doesn't know that it will be run automatically)
private void forbidUseOfSuperInFixtureMethod(MethodCallExpression expr) {
Method currMethod = resources.getCurrentMethod();
Expression target = expr.getObjectExpression();
if (currMethod instanceof FixtureMethod
&& target instanceof VariableExpression
&& ((VariableExpression)target).isSuperExpression()
&& currMethod.getName().equals(expr.getMethodAsString())) {
resources.getErrorReporter().error(expr,
"A base class fixture method should not be called explicitely " +
"because it is always run automatically by the framework");
}
}
private void handleMockAndOldCalls(Expression expr) {
if (AstUtil.isBuiltinMemberCall(expr, Identifiers.MOCK, 0, 1))
handleMockCall(expr);
else if (AstUtil.isBuiltinMemberCall(expr, Identifiers.OLD, 1, 1))
handleOldCall(expr);
}
private void handleMockCall(Expression expr) {
try {
AstUtil.expandBuiltinMemberCall(expr, resources.getMockControllerRef());
} catch (InvalidSpecCompileException e) {
resources.getErrorReporter().error(e);
}
}
private void handleOldCall(Expression expr) {
if (!(resources.getCurrentBlock() instanceof ThenBlock)) {
resources.getErrorReporter().error(expr, "old() may only be used in a 'then' block");
return;
}
List args = AstUtil.getArguments(expr);
VariableExpression oldValue = resources.captureOldValue(args.get(0));
args.set(0, oldValue);
args.add(ConstantExpression.FALSE); // dummy arg
if (closureScope != null) {
oldValue.setClosureSharedVariable(true);
closureScope.putReferencedLocalVariable(oldValue);
}
}
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/compiler/ErrorReporter.java 0000664 0000000 0000000 00000004552 12020225233 0032140 0 ustar 00root root 0000000 0000000 /*
* Copyright 2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* http://www.apache.org/licenses/LICENSE-2.0
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.compiler;
import java.io.PrintWriter;
import java.io.StringWriter;
import org.codehaus.groovy.ast.ASTNode;
import org.codehaus.groovy.control.*;
import org.codehaus.groovy.control.messages.*;
import org.spockframework.util.TextUtil;
/**
* Reporting facility for problems found during compilation.
* In general, error(ASTNode) is the preferred method to use.
* error(InvalidSpecCompileException) should only be used if compilation cannot
* continue in the same method where the error was found (because some
* steps need to be skipped). In that case, a InvalidSpecCompileException should be
* thrown at the point where the error is detected, and an outer method
* should catch the exception and pass it on to ErrorReporter.
*
* @author Peter Niederwieser
*/
public class ErrorReporter {
private final SourceUnit sourceUnit;
public ErrorReporter(SourceUnit sourceUnit) {
this.sourceUnit = sourceUnit;
}
public void error(String msg, Object... args) {
sourceUnit.getErrorCollector().addErrorAndContinue(
new SimpleMessage(String.format(msg, args), sourceUnit));
}
public void error(String msg, Throwable cause, Object... args) {
sourceUnit.getErrorCollector().addErrorAndContinue(
new SimpleMessage(String.format(msg, args) + "\n\n" + TextUtil.printStackTrace(cause), sourceUnit));
}
public void error(ASTNode node, String msg, Object... args) {
error(new InvalidSpecCompileException(node, msg, args));
}
public void error(int line, int column, String msg, Object... args) {
error(new InvalidSpecCompileException(line, column, msg, args));
}
public void error(InvalidSpecCompileException e) {
sourceUnit.getErrorCollector().addErrorAndContinue(new SyntaxErrorMessage(e, sourceUnit));
}
}
ExpressionReplacingVisitorSupport.java 0000664 0000000 0000000 00000031300 12020225233 0036175 0 ustar 00root root 0000000 0000000 spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/compiler /*
* Copyright 2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.compiler;
import java.util.List;
import java.util.ListIterator;
import org.codehaus.groovy.ast.expr.*;
import org.codehaus.groovy.ast.stmt.*;
import org.codehaus.groovy.classgen.BytecodeExpression;
/**
* Groovy AST visitor that allows to replace both statements and expressions.
*
* @author Peter Niederwieser
*/
public class ExpressionReplacingVisitorSupport extends StatementReplacingVisitorSupport {
private Expression replacementExpr;
public Expression replaceExpr(Expression expr) {
replacementExpr = null;
expr.visit(this);
Expression result = replacementExpr == null ? expr : replacementExpr;
replacementExpr = null;
return result;
}
@SuppressWarnings("unchecked")
protected void replaceAllExprs(List exprs) {
ListIterator iter = exprs.listIterator();
while (iter.hasNext())
iter.set((T) replaceExpr(iter.next()));
}
/*
* Replaces the currently visited expression with the specified expression.
*/
protected void replaceVisitedExpressionWith(Expression other) {
replacementExpr = other;
}
@Override
@SuppressWarnings("unchecked")
public void visitBlockStatement(BlockStatement stat) {
replaceAll(stat.getStatements());
}
@Override
public void visitForLoop(ForStatement stat) {
stat.setCollectionExpression(replaceExpr(stat.getCollectionExpression()));
stat.setLoopBlock(replace(stat.getLoopBlock()));
}
@Override
public void visitWhileLoop(WhileStatement stat) {
stat.setBooleanExpression((BooleanExpression)replaceExpr(stat.getBooleanExpression()));
stat.setLoopBlock(replace(stat.getLoopBlock()));
}
@Override
public void visitDoWhileLoop(DoWhileStatement stat) {
stat.setBooleanExpression((BooleanExpression)replaceExpr(stat.getBooleanExpression()));
stat.setLoopBlock(replace(stat.getLoopBlock()));
}
@Override
public void visitIfElse(IfStatement stat) {
stat.setBooleanExpression((BooleanExpression)replaceExpr(stat.getBooleanExpression()));
stat.setIfBlock(replace(stat.getIfBlock()));
stat.setElseBlock(replace(stat.getElseBlock()));
}
@Override
@SuppressWarnings("unchecked")
public void visitTryCatchFinally(TryCatchStatement stat) {
stat.setTryStatement(replace(stat.getTryStatement()));
replaceAll(stat.getCatchStatements());
stat.setFinallyStatement(replace(stat.getFinallyStatement()));
}
@Override
@SuppressWarnings("unchecked")
public void visitSwitch(SwitchStatement stat) {
stat.setExpression(replaceExpr(stat.getExpression()));
replaceAll(stat.getCaseStatements());
stat.setDefaultStatement(replace(stat.getDefaultStatement()));
}
@Override
public void visitCaseStatement(CaseStatement stat) {
stat.setExpression(replaceExpr(stat.getExpression()));
stat.setCode(replace(stat.getCode()));
}
@Override
public void visitSynchronizedStatement(SynchronizedStatement stat) {
stat.setExpression(replaceExpr(stat.getExpression()));
stat.setCode(replace(stat.getCode()));
}
@Override
public void visitCatchStatement(CatchStatement stat) {
stat.setCode(replace(stat.getCode()));
}
@Override
public void visitMethodCallExpression(MethodCallExpression expr) {
expr.setObjectExpression(replaceExpr(expr.getObjectExpression()));
expr.setMethod(replaceExpr(expr.getMethod()));
expr.setArguments(replaceExpr(expr.getArguments()));
}
@Override
public void visitStaticMethodCallExpression(StaticMethodCallExpression expr) {
StaticMethodCallExpression result = new StaticMethodCallExpression(
expr.getOwnerType(),
expr.getMethod(),
replaceExpr(expr.getArguments()));
result.setType(expr.getType());
result.setSourcePosition(expr);
replaceVisitedExpressionWith(result);
}
@Override
public void visitConstructorCallExpression(ConstructorCallExpression expr) {
ConstructorCallExpression result = new ConstructorCallExpression(
expr.getType(),
replaceExpr(expr.getArguments()));
result.setSourcePosition(expr);
replaceVisitedExpressionWith(result);
}
@Override
public void visitBinaryExpression(BinaryExpression expr) {
expr.setLeftExpression(replaceExpr(expr.getLeftExpression()));
expr.setRightExpression(replaceExpr(expr.getRightExpression()));
}
@Override
public void visitTernaryExpression(TernaryExpression expr) {
TernaryExpression result = new TernaryExpression(
(BooleanExpression)replaceExpr(expr.getBooleanExpression()),
replaceExpr(expr.getTrueExpression()),
replaceExpr(expr.getFalseExpression()));
result.setType(expr.getType());
result.setSourcePosition(expr);
replaceVisitedExpressionWith(result);
}
@Override
public void visitShortTernaryExpression(ElvisOperatorExpression expr) {
ElvisOperatorExpression result = new ElvisOperatorExpression(
replaceExpr(expr.getTrueExpression()),
replaceExpr(expr.getFalseExpression()));
result.setType(expr.getType());
result.setSourcePosition(expr);
replaceVisitedExpressionWith(result);
}
@Override
public void visitPostfixExpression(PostfixExpression expr) {
expr.setExpression(replaceExpr(expr.getExpression()));
}
@Override
public void visitPrefixExpression(PrefixExpression expr) {
expr.setExpression(replaceExpr(expr.getExpression()));
}
@Override
public void visitBooleanExpression(BooleanExpression expr) {
BooleanExpression result = new BooleanExpression(
replaceExpr(expr.getExpression()));
result.setType(expr.getType());
result.setSourcePosition(expr);
replaceVisitedExpressionWith(result);
}
@Override
public void visitNotExpression(NotExpression expr) {
NotExpression result = new NotExpression(
replaceExpr(expr.getExpression()));
result.setType(expr.getType());
result.setSourcePosition(expr);
replaceVisitedExpressionWith(result);
}
@Override
public void visitClosureExpression(ClosureExpression expr) {
super.visitClosureExpression(expr);
replaceVisitedExpressionWith(expr);
}
@Override
@SuppressWarnings("unchecked")
public void visitTupleExpression(TupleExpression expr) {
replaceAllExprs(expr.getExpressions());
}
@Override
@SuppressWarnings("unchecked")
public void visitListExpression(ListExpression expr) {
replaceAllExprs(expr.getExpressions());
}
@Override
@SuppressWarnings("unchecked")
public void visitArrayExpression(ArrayExpression expr) {
replaceAllExprs(expr.getExpressions());
replaceAllExprs(expr.getSizeExpression());
}
@Override
@SuppressWarnings("unchecked")
public void visitMapExpression(MapExpression expr) {
replaceAllExprs(expr.getMapEntryExpressions());
}
@Override
public void visitMapEntryExpression(MapEntryExpression expr) {
MapEntryExpression result = new MapEntryExpression(
replaceExpr(expr.getKeyExpression()),
replaceExpr(expr.getValueExpression())
);
result.setType(expr.getType());
result.setSourcePosition(expr);
replaceVisitedExpressionWith(result);
}
@Override
public void visitRangeExpression(RangeExpression expr) {
RangeExpression result = new RangeExpression(
replaceExpr(expr.getFrom()),
replaceExpr(expr.getTo()),
expr.isInclusive()
);
result.setType(expr.getType());
result.setSourcePosition(expr);
replaceVisitedExpressionWith(result);
}
@Override
public void visitSpreadExpression(SpreadExpression expr) {
SpreadExpression result = new SpreadExpression(
replaceExpr(expr.getExpression())
);
result.setType(expr.getType());
result.setSourcePosition(expr);
replaceVisitedExpressionWith(result);
}
@Override
public void visitSpreadMapExpression(SpreadMapExpression expr) {
SpreadMapExpression result = new SpreadMapExpression(
replaceExpr(expr.getExpression())
);
result.setType(expr.getType());
result.setSourcePosition(expr);
replaceVisitedExpressionWith(result);
}
@Override
public void visitMethodPointerExpression(MethodPointerExpression expr) {
MethodPointerExpression result = new MethodPointerExpression(
replaceExpr(expr.getExpression()),
expr.getMethodName()
);
result.setType(expr.getType());
result.setSourcePosition(expr);
replaceVisitedExpressionWith(result);
}
@Override
public void visitUnaryMinusExpression(UnaryMinusExpression expr) {
UnaryMinusExpression result = new UnaryMinusExpression(
replaceExpr(expr.getExpression())
);
result.setType(expr.getType());
result.setSourcePosition(expr);
replaceVisitedExpressionWith(result);
}
@Override
public void visitUnaryPlusExpression(UnaryPlusExpression expr) {
UnaryPlusExpression result = new UnaryPlusExpression(
replaceExpr(expr.getExpression())
);
result.setType(expr.getType());
result.setSourcePosition(expr);
replaceVisitedExpressionWith(result);
}
@Override
public void visitBitwiseNegationExpression(BitwiseNegationExpression expr) {
BitwiseNegationExpression result = new BitwiseNegationExpression(
replaceExpr(expr.getExpression())
);
result.setType(expr.getType());
result.setSourcePosition(expr);
replaceVisitedExpressionWith(result);
}
@Override
public void visitCastExpression(CastExpression expr) {
CastExpression result = new CastExpression(
expr.getType(),
replaceExpr(expr.getExpression()),
expr.isIgnoringAutoboxing()
);
result.setCoerce(expr.isCoerce());
result.setType(expr.getType());
result.setSourcePosition(expr);
replaceVisitedExpressionWith(result);
}
@Override
public void visitDeclarationExpression(DeclarationExpression expr) {
visitBinaryExpression(expr);
replaceVisitedExpressionWith(expr);
}
@Override
public void visitPropertyExpression(PropertyExpression expr) {
PropertyExpression result = new PropertyExpression(
replaceExpr(expr.getObjectExpression()),
replaceExpr(expr.getProperty()),
expr.isSafe()
);
result.setSpreadSafe(expr.isSpreadSafe());
result.setStatic(expr.isStatic());
result.setImplicitThis(expr.isImplicitThis());
result.setType(expr.getType());
result.setSourcePosition(expr);
replaceVisitedExpressionWith(result);
}
@Override
public void visitAttributeExpression(AttributeExpression expr) {
visitPropertyExpression(expr);
replaceVisitedExpressionWith(expr);
}
@Override
@SuppressWarnings("unchecked")
public void visitGStringExpression(GStringExpression expr) {
replaceAllExprs(expr.getStrings());
replaceAllExprs(expr.getValues());
}
@Override
public void visitArgumentlistExpression(ArgumentListExpression expr) {
visitTupleExpression(expr);
replaceVisitedExpressionWith(expr);
}
@Override
public void visitClosureListExpression(ClosureListExpression expr) {
visitListExpression(expr);
replaceVisitedExpressionWith(expr);
}
@Override
public void visitAssertStatement(AssertStatement stat) {
replaceExpr(stat.getBooleanExpression());
replaceExpr(stat.getMessageExpression());
}
@Override
public void visitExpressionStatement(ExpressionStatement stat) {
replaceExpr(stat.getExpression());
}
@Override
public void visitReturnStatement(ReturnStatement stat) {
replaceExpr(stat.getExpression());
}
@Override
public void visitThrowStatement(ThrowStatement stat) {
replaceExpr(stat.getExpression());
}
@Override
protected void visitListOfExpressions(List exprs) {
throw new UnsupportedOperationException("visitListOfExpressions");
}
// remaining methods are here to make sure we didn't forget anything
@Override
public void visitBreakStatement(BreakStatement stat) {}
@Override
public void visitContinueStatement(ContinueStatement stat) {}
@Override
public void visitConstantExpression(ConstantExpression expr) {}
@Override
public void visitClassExpression(ClassExpression expr) {}
@Override
public void visitVariableExpression(VariableExpression expr) {}
@Override
public void visitFieldExpression(FieldExpression expr) {}
@Override
public void visitBytecodeExpression(BytecodeExpression expr) {}
}
FieldInitializationExpression.java 0000664 0000000 0000000 00000002603 12020225233 0035253 0 ustar 00root root 0000000 0000000 spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/compiler /*
* Copyright 2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.compiler;
import org.codehaus.groovy.ast.FieldNode;
import org.codehaus.groovy.ast.expr.BinaryExpression;
import org.codehaus.groovy.ast.expr.FieldExpression;
import org.codehaus.groovy.syntax.Token;
import org.codehaus.groovy.syntax.Types;
/**
* An assignment of the form "x = expr", where x is a field and expr is a field
* initializer expression. The purpose of this class is to make field
* initializations distinguishable from other assignments while traversing
* the AST.
*
* @author Peter Niederwieser
*/
public class FieldInitializationExpression extends BinaryExpression {
public FieldInitializationExpression(FieldNode field) {
super(new FieldExpression(field), Token.newSymbol(Types.ASSIGN, -1, -1), field.getInitialValueExpression());
}
} spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/compiler/IRewriteResources.java 0000664 0000000 0000000 00000002641 12020225233 0032746 0 ustar 00root root 0000000 0000000 /*
* Copyright 2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.compiler;
import java.util.List;
import org.codehaus.groovy.ast.ASTNode;
import org.codehaus.groovy.ast.expr.Expression;
import org.codehaus.groovy.ast.expr.VariableExpression;
import org.codehaus.groovy.ast.stmt.Statement;
import org.spockframework.compiler.model.Block;
import org.spockframework.compiler.model.Method;
import org.spockframework.compiler.model.Spec;
/**
*
* @author Peter Niederwieser
*/
public interface IRewriteResources {
Spec getCurrentSpec();
Method getCurrentMethod();
Block getCurrentBlock();
void defineValueRecorder(List stats);
VariableExpression captureOldValue(Expression oldValue);
VariableExpression getMockControllerRef();
AstNodeCache getAstNodeCache();
String getSourceText(ASTNode node);
ErrorReporter getErrorReporter();
}
InstanceFieldAccessChecker.java 0000664 0000000 0000000 00000005116 12020225233 0034361 0 ustar 00root root 0000000 0000000 spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/compiler /*
* Copyright 2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.compiler;
import org.codehaus.groovy.ast.ASTNode;
import org.codehaus.groovy.ast.ClassCodeVisitorSupport;
import org.codehaus.groovy.ast.FieldNode;
import org.codehaus.groovy.ast.Variable;
import org.codehaus.groovy.ast.expr.Expression;
import org.codehaus.groovy.ast.expr.FieldExpression;
import org.codehaus.groovy.ast.expr.VariableExpression;
import org.codehaus.groovy.ast.stmt.Statement;
import org.codehaus.groovy.control.SourceUnit;
import org.spockframework.compiler.model.Block;
import org.spockframework.compiler.model.Method;
import org.spockframework.util.UnreachableCodeError;
import spock.lang.Shared;
// we don't currently check this.x and super.x because
// it's not as clear how this should be done (for example,
// 'x' could refer to a property)
public class InstanceFieldAccessChecker extends ClassCodeVisitorSupport {
private final IRewriteResources resources;
public InstanceFieldAccessChecker(IRewriteResources resources) {
this.resources = resources;
}
public void check(Expression expr) {
expr.visit(this);
}
public void check(Method method) {
for (Block block : method.getBlocks())
for (Statement stat : block.getAst())
stat.visit(this);
}
@Override
public void visitVariableExpression(VariableExpression expr) {
super.visitVariableExpression(expr);
Variable var = expr.getAccessedVariable();
if (!(var instanceof FieldNode)) return;
checkFieldAccess(expr, (FieldNode) var);
}
@Override
public void visitFieldExpression(FieldExpression expr) {
super.visitFieldExpression(expr);
checkFieldAccess(expr, expr.getField());
}
@Override
protected SourceUnit getSourceUnit() {
throw new UnreachableCodeError();
}
private void checkFieldAccess(ASTNode context, FieldNode field) {
if (AstUtil.hasAnnotation(field, Shared.class) || field.isStatic()) return;
resources.getErrorReporter().error(context, "Only @Shared and static fields may be accessed from here");
}
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/compiler/InteractionRewriter.java 0000775 0000000 0000000 00000025362 12020225233 0033334 0 ustar 00root root 0000000 0000000 /*
* Copyright 2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.compiler;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.codehaus.groovy.ast.expr.*;
import org.codehaus.groovy.ast.stmt.ExpressionStatement;
import org.codehaus.groovy.ast.stmt.Statement;
import org.codehaus.groovy.syntax.Types;
import org.spockframework.lang.Wildcard;
import org.spockframework.mock.InteractionBuilder;
import org.spockframework.mock.MockController;
import org.spockframework.util.Assert;
import org.spockframework.util.Nullable;
/**
* Creates the AST representation of an InteractionBuilder build sequence.
*
* @author Peter Niederwieser
*/
public class InteractionRewriter {
private final IRewriteResources resources;
// information about the interaction; filled in by parse()
private ExpressionStatement stat;
private Expression count;
private Expression call;
private boolean wildcardCall;
private List results = new ArrayList();
// holds the incrementally constructed expression, which looks roughly as follows:
// "new InteractionBuilder(..).setCount(..).setTarget(..).setMethod(..).addArg(..).addResult(..).build()"
private Expression builderExpr;
public InteractionRewriter(IRewriteResources resources) {
this.resources = resources;
}
/**
* If the given statement is a valid interaction definition, returns the rewritten statement.
* If the given statement is not an interaction definition, returns null.
* If the given statement is an invalid interaction definition, records a compile error
* and returns null.
*/
public @Nullable Statement rewrite(ExpressionStatement stat) {
try {
if (!parse(stat)) return null;
createBuilder();
setCount();
setCall();
addResults();
build();
return register();
} catch (InvalidSpecCompileException e) {
resources.getErrorReporter().error(e);
return null;
}
}
private boolean parse(ExpressionStatement stat) throws InvalidSpecCompileException {
this.stat = stat;
Expression expr = parseCount(parseResults(stat.getExpression()));
return (count != null || !results.isEmpty()) && parseCall(expr);
}
private Expression parseResults(Expression expr) {
while (expr instanceof BinaryExpression) {
BinaryExpression binExpr = (BinaryExpression) expr;
int type = binExpr.getOperation().getType();
if (type != Types.RIGHT_SHIFT && type != Types.RIGHT_SHIFT_UNSIGNED) break;
results.add(new InteractionResult(binExpr.getRightExpression(), type == Types.RIGHT_SHIFT_UNSIGNED));
expr = binExpr.getLeftExpression();
}
return expr;
}
private Expression parseCount(Expression expr) {
BinaryExpression binExpr = AstUtil.asInstance(expr, BinaryExpression.class);
if (binExpr == null || binExpr.getOperation().getType() != Types.MULTIPLY) return expr;
count = binExpr.getLeftExpression();
return binExpr.getRightExpression();
}
private boolean parseCall(Expression expr) throws InvalidSpecCompileException {
call = expr;
if (AstUtil.isWildcardRef(expr)) {
wildcardCall = true;
return true;
}
if (expr instanceof PropertyExpression) {
PropertyExpression propExpr = (PropertyExpression)expr;
// isImplicitThis() and isStatic() always seem to return false for
// properties, but checking them can't hurt
if (propExpr.isImplicitThis()) return false;
if (propExpr.isStatic()) staticMembersNotSupported(expr);
if (propExpr.getObjectExpression() instanceof ClassExpression)
staticMembersNotSupported(expr);
return true;
}
if (expr instanceof MethodCallExpression) {
MethodCallExpression mcExpr = (MethodCallExpression)expr;
if (mcExpr.isImplicitThis()) return false;
if (mcExpr.getObjectExpression() instanceof ClassExpression)
staticMembersNotSupported(expr);
return true;
}
// StaticMethodCallExpression is only used for unqualified calls to static methods
if (expr instanceof StaticMethodCallExpression) return false;
return false;
}
private void staticMembersNotSupported(Expression expr) throws InvalidSpecCompileException {
throw new InvalidSpecCompileException(expr,
"Stubbing/mocking of static methods and properties is not supported.");
}
private void createBuilder() {
// ExpressionStatements w/ label have wrong source position,
// but source position of the contained expression is OK
Expression expr = stat.getExpression();
builderExpr = new ConstructorCallExpression(
resources.getAstNodeCache().InteractionBuilder,
new ArgumentListExpression(
Arrays. asList(
new ConstantExpression(expr.getLineNumber()),
new ConstantExpression(expr.getColumnNumber()),
new ConstantExpression(resources.getSourceText(expr)))));
}
private void setCount() {
if (count == null) return;
if (count instanceof RangeExpression) {
RangeExpression range = (RangeExpression)count;
call(InteractionBuilder.SET_RANGE_COUNT,
range.getFrom(),
range.getTo(),
new ConstantExpression(range.isInclusive()));
return;
}
call(InteractionBuilder.SET_FIXED_COUNT, count);
}
private void setCall() {
if (wildcardCall)
call(InteractionBuilder.ADD_EQUAL_METHOD_NAME, new ConstantExpression(Wildcard.INSTANCE.toString()));
else if (call instanceof PropertyExpression)
setPropertyCall();
else
setMethodCall();
}
private void setPropertyCall() {
setTarget();
setPropertyName();
}
private void setPropertyName() {
Expression propertyNameExpr = ((PropertyExpression)call).getProperty();
String constraint = selectNameConstraint(propertyNameExpr,
InteractionBuilder.ADD_EQUAL_PROPERTY_NAME, InteractionBuilder.ADD_REGEX_PROPERTY_NAME);
call(constraint, propertyNameExpr);
}
private void setMethodCall() {
setTarget();
setMethodName();
addArgs();
}
private void setTarget() {
call(InteractionBuilder.ADD_EQUAL_TARGET, AstUtil.getInvocationTarget(call));
}
private void setMethodName() {
Expression methodNameExpr = ((MethodCallExpression)call).getMethod();
String constraint = selectNameConstraint(methodNameExpr,
InteractionBuilder.ADD_EQUAL_METHOD_NAME, InteractionBuilder.ADD_REGEX_METHOD_NAME);
call(constraint, methodNameExpr);
}
private String selectNameConstraint(Expression nameExpr, String constraint1, String constraint2) {
if (!(nameExpr instanceof ConstantExpression)) // dynamically generated name
return constraint1;
String method = (String)((ConstantExpression)nameExpr).getValue();
// NOTE: we cannot tell from the AST if a method (or property) name is defined using
// slashy string syntax ("/somePattern/"); hence, we consider any name
// that isn't a valid Java identifier a pattern. While this isn't entirely
// safe (the JVM allows almost all characters in method names), it should
// work out well in practice because it's very unlikely that a
// collaborator has a method name that is not a valid Java identifier.
return AstUtil.isJavaIdentifier(method) ? constraint1 : constraint2;
}
private void addArgs() {
if (call instanceof PropertyExpression) return;
Expression args = ((MethodCallExpression)call).getArguments();
if (args == ArgumentListExpression.EMPTY_ARGUMENTS) return; // fast lane
call(InteractionBuilder.SET_ARG_LIST_KIND,
new ConstantExpression(args instanceof ArgumentListExpression));
if (args instanceof ArgumentListExpression)
addPositionalArgs((ArgumentListExpression)args);
else if (args instanceof NamedArgumentListExpression)
addNamedArgs((NamedArgumentListExpression)args);
else Assert.that(false, "unknown kind of argument list: " + args);
}
@SuppressWarnings("unchecked")
private void addPositionalArgs(ArgumentListExpression args) {
for (Expression arg: args.getExpressions())
addArg(arg);
}
@SuppressWarnings("unchecked")
private void addNamedArgs(NamedArgumentListExpression args) {
for (MapEntryExpression arg : args.getMapEntryExpressions()) {
addName(arg.getKeyExpression());
addArg(arg.getValueExpression());
}
}
private void addName(Expression name) {
call(InteractionBuilder.ADD_ARG_NAME, name);
}
private void addArg(Expression arg) {
if (arg instanceof NotExpression) {
NotExpression not = (NotExpression)arg;
addArg(not.getExpression());
call(InteractionBuilder.NEGATE_LAST_ARG);
return;
}
if (arg instanceof CastExpression) {
CastExpression cast = (CastExpression)arg;
addArg(cast.getExpression());
call(InteractionBuilder.TYPE_LAST_ARG, new ClassExpression(cast.getType()));
return;
}
if (arg instanceof ClosureExpression) {
call(InteractionBuilder.ADD_CODE_ARG, arg);
return;
}
call(InteractionBuilder.ADD_EQUAL_ARG, arg);
}
private void addResults() {
for (InteractionResult result : results) {
if (result.iterable) {
call(InteractionBuilder.ADD_ITERABLE_RESULT, result.expr);
} else if (result.expr instanceof ClosureExpression) {
call(InteractionBuilder.ADD_CODE_RESULT, result.expr);
} else {
call(InteractionBuilder.ADD_CONSTANT_RESULT, result.expr);
}
}
}
private void build() {
call(InteractionBuilder.BUILD);
}
private Statement register() {
Statement result =
new ExpressionStatement(
new MethodCallExpression(
resources.getMockControllerRef(),
MockController.ADD_INTERACTION,
new ArgumentListExpression(builderExpr)));
result.setSourcePosition(stat);
return result;
}
private void call(String method, Expression... args) {
builderExpr = new MethodCallExpression(
builderExpr,
method,
new ArgumentListExpression(args));
}
private static class InteractionResult {
final Expression expr;
final boolean iterable;
private InteractionResult(Expression expr, boolean iterable) {
this.expr = expr;
this.iterable = iterable;
}
}
}
InvalidSpecCompileException.java 0000775 0000000 0000000 00000003433 12020225233 0034636 0 ustar 00root root 0000000 0000000 spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/compiler /*
* Copyright 2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.compiler;
import org.codehaus.groovy.ast.ASTNode;
import org.codehaus.groovy.syntax.SyntaxException;
/**
* Indicates that a spec was found to contain a (syntactic or semantic)
* error during compilation. As such, this is the compile-time equivalent
* of InvalidSpecException.
* Inherits from SyntaxException so that line information can
* be exploited by integrators (IDEs etc.).
*
* Most of the time it is not necessary to use this class directly (see
* documentation of class ErrorReporter).
*
* @author Peter Niederwieser
*/
public class InvalidSpecCompileException extends SyntaxException {
public InvalidSpecCompileException(int line, int column, String msg, Object... args) {
super(String.format(msg, args), line, column);
}
public InvalidSpecCompileException(ASTNode node, String msg, Object... args) {
this(getLine(node), getColumn(node), msg, args);
}
private static int getLine(ASTNode node) {
return node.getLineNumber() > 0 ? node.getLineNumber() : node.getLastLineNumber();
}
private static int getColumn(ASTNode node) {
return node.getColumnNumber() > 0 ? node.getColumnNumber() : node.getLastColumnNumber();
}
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/compiler/OldValueExpression.java 0000664 0000000 0000000 00000002534 12020225233 0033115 0 ustar 00root root 0000000 0000000 /*
* Copyright 2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.compiler;
import org.codehaus.groovy.ast.expr.Expression;
import org.codehaus.groovy.ast.expr.VariableExpression;
/**
* Used to represent the argument to Specification.old() once it has been processed
* by IRewriteResources.captureOldValue(). The original expression is
* kept in case ConditionRewriter still needs it.
*
* @author Peter Niederwieser
*/
public class OldValueExpression extends VariableExpression {
private final Expression originalExpression;
public OldValueExpression(Expression originalExpression, String substitutedVariable) {
super(substitutedVariable);
this.originalExpression = originalExpression;
}
public Expression getOrginalExpression() {
return originalExpression;
}
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/compiler/SourceLookup.java 0000664 0000000 0000000 00000004327 12020225233 0031756 0 ustar 00root root 0000000 0000000 /*
* Copyright 2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.compiler;
import org.codehaus.groovy.ast.ASTNode;
import org.codehaus.groovy.control.Janitor;
import org.codehaus.groovy.control.SourceUnit;
public class SourceLookup {
private final SourceUnit sourceUnit;
private final Janitor janitor = new Janitor();
public SourceLookup(SourceUnit sourceUnit) {
this.sourceUnit = sourceUnit;
}
public String lookup(ASTNode node) {
String text = "";
for (int i = node.getLineNumber(); i <= node.getLastLineNumber(); i++) {
String line = sourceUnit.getSample(i, 0, janitor);
if (line == null) {
return null; // most probably a Groovy bug, but we'd like to handle this situation gracefully
// throw new Error(String.format("null line detected; lineNum=%s, expr=%s", i, node.getText()));
}
try {
if (i == node.getLastLineNumber()) line = line.substring(0, node.getLastColumnNumber() - 1);
if (i == node.getLineNumber()) line = line.substring(node.getColumnNumber() - 1);
text += line;
if (i != node.getLastLineNumber()) text += '\n';
} catch (StringIndexOutOfBoundsException e) {
return null; // most probably a Groovy bug, but we'd like to handle this situation gracefully
// throw new RuntimeException(String.format("error getting node text; expr='%s', lineNumber='%s', lastLineNumber='%s', columnNumber='%s', lastColumnNumber='%s', currentLine='%s'", node, node.getLineNumber(), node.getLastLineNumber(), node.getColumnNumber(), node.getLastColumnNumber(), line), e);
}
}
return text.trim();
}
public void close() {
janitor.cleanup();
}
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/compiler/SpecAnnotator.java 0000775 0000000 0000000 00000011031 12020225233 0032075 0 ustar 00root root 0000000 0000000 /*
* Copyright 2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.compiler;
import java.io.File;
import org.codehaus.groovy.ast.AnnotationNode;
import org.codehaus.groovy.ast.Parameter;
import org.codehaus.groovy.ast.expr.*;
import org.spockframework.compiler.model.*;
import org.spockframework.runtime.model.*;
/**
* Puts all spec information required at runtime into annotations
* attached to class members.
*
* @author Peter Niederwieser
*/
public class SpecAnnotator extends AbstractSpecVisitor {
private final AstNodeCache nodeCache;
private ListExpression blockAnnElems;
public SpecAnnotator(AstNodeCache nodeCache) {
this.nodeCache = nodeCache;
}
@Override
public void visitSpec(Spec spec) throws Exception {
addSpecMetadata(spec);
}
private void addSpecMetadata(Spec spec) {
AnnotationNode ann = new AnnotationNode(nodeCache.SpecMetadata);
String pathname = spec.getAst().getModule().getContext().getName();
String filename = new File(pathname).getName();
ann.setMember(SpecMetadata.FILENAME, new ConstantExpression(filename));
ann.setMember(SpecMetadata.LINE, new ConstantExpression(spec.getAst().getLineNumber()));
spec.getAst().addAnnotation(ann);
}
@Override
public void visitField(Field field) throws Exception {
addFieldMetadata(field);
}
private void addFieldMetadata(Field field) {
AnnotationNode ann = new AnnotationNode(nodeCache.FieldMetadata);
ann.setMember(FieldMetadata.NAME, new ConstantExpression(field.getName()));
ann.setMember(FieldMetadata.ORDINAL, new ConstantExpression(field.getOrdinal()));
ann.setMember(FieldMetadata.LINE, new ConstantExpression(field.getAst().getLineNumber()));
field.getAst().addAnnotation(ann);
}
@Override
public void visitMethod(Method method) throws Exception {
if (method instanceof FeatureMethod)
addFeatureMetadata((FeatureMethod)method);
}
private void addFeatureMetadata(FeatureMethod feature) {
AnnotationNode ann = new AnnotationNode(nodeCache.FeatureMetadata);
ann.setMember(FeatureMetadata.NAME, new ConstantExpression(feature.getName()));
ann.setMember(FeatureMetadata.ORDINAL, new ConstantExpression(feature.getOrdinal()));
ann.setMember(FeatureMetadata.LINE, new ConstantExpression(feature.getAst().getLineNumber()));
ann.setMember(FeatureMetadata.BLOCKS, blockAnnElems = new ListExpression());
ListExpression paramNames = new ListExpression();
for (Parameter param : feature.getAst().getParameters())
paramNames.addExpression(new ConstantExpression(param.getName()));
ann.setMember(FeatureMetadata.PARAMETER_NAMES, paramNames);
feature.getAst().addAnnotation(ann);
}
private void addBlockMetadata(Block block, BlockKind kind) {
AnnotationNode blockAnn = new AnnotationNode(nodeCache.BlockMetadata);
blockAnn.setMember(BlockMetadata.KIND, new PropertyExpression(
new ClassExpression(nodeCache.BlockKind), kind.name()));
ListExpression textExprs = new ListExpression();
for (String text : block.getDescriptions())
textExprs.addExpression(new ConstantExpression(text));
blockAnn.setMember(BlockMetadata.TEXTS, textExprs);
blockAnnElems.addExpression(new AnnotationConstantExpression(blockAnn));
}
@Override
public void visitSetupBlock(SetupBlock block) throws Exception {
addBlockMetadata(block, BlockKind.SETUP);
}
@Override
public void visitExpectBlock(ExpectBlock block) throws Exception {
addBlockMetadata(block, BlockKind.EXPECT);
}
@Override
public void visitWhenBlock(WhenBlock block) throws Exception {
addBlockMetadata(block, BlockKind.WHEN);
}
@Override
public void visitThenBlock(ThenBlock block) throws Exception {
addBlockMetadata(block, BlockKind.THEN);
}
@Override
public void visitCleanupBlock(CleanupBlock block) throws Exception {
addBlockMetadata(block, BlockKind.CLEANUP);
}
@Override
public void visitWhereBlock(WhereBlock block) throws Exception {
addBlockMetadata(block, BlockKind.WHERE);
}
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/compiler/SpecParser.java 0000775 0000000 0000000 00000020566 12020225233 0031401 0 ustar 00root root 0000000 0000000 /*
* Copyright 2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.compiler;
import java.util.List;
import org.codehaus.groovy.ast.*;
import org.codehaus.groovy.ast.expr.ConstantExpression;
import org.codehaus.groovy.ast.stmt.Statement;
import static org.spockframework.util.Identifiers.*;
import org.spockframework.compiler.model.*;
import spock.lang.Shared;
/**
* Given the abstract syntax tree of a Groovy class representing a Spock
* specification, builds an object model of the specification.
*
* @author Peter Niederwieser
*/
public class SpecParser implements GroovyClassVisitor {
private final ErrorReporter errorReporter;
private Spec spec;
private int fieldCount = 0;
private int featureMethodCount = 0;
public SpecParser(ErrorReporter errorReporter) {
this.errorReporter = errorReporter;
}
public Spec build(ClassNode clazz) {
spec = new Spec(clazz);
clazz.visitContents(this);
return spec;
}
public void visitClass(ClassNode clazz) {
throw new UnsupportedOperationException("visitClass");
}
// might only want to include fields relating to a user-provided
// definition, but it's hard to tell them apart; for example,
// field.isSynthetic() is true for a property's backing field
// although it IS related to a user-provided definition
public void visitField(FieldNode gField) {
PropertyNode owner = spec.getAst().getProperty(gField.getName());
if (gField.isStatic()) return;
Field field = new Field(spec, gField, fieldCount++);
field.setShared(AstUtil.hasAnnotation(gField, Shared.class));
field.setOwner(owner);
spec.getFields().add(field);
}
public void visitProperty(PropertyNode node) {}
public void visitConstructor(ConstructorNode constructor) {
if (AstUtil.isSynthetic(constructor)) return;
if (constructorMayHaveBeenAddedByCompiler(constructor)) return;
errorReporter.error(constructor,
"Constructors are not allowed; instead, define a 'setup()' or 'setupSpec()' method");
}
// In case of joint compilation, Verifier - which may add a default constructor
// - is run in phase CONVERSION. Additionally, groovyc 1.7 and above no longer
// marks default constructors as synthetic (following javac). Therefore, we have
// to add special logic to detect this case.
private boolean constructorMayHaveBeenAddedByCompiler(ConstructorNode constructor) {
Parameter[] params = constructor.getParameters();
Statement firstStat = constructor.getFirstStatement();
return AstUtil.isJointCompiled(spec.getAst()) && constructor.isPublic()
&& params != null && params.length == 0 && firstStat == null;
}
public void visitMethod(MethodNode method) {
if (isIgnoredMethod(method)) return;
if (isFixtureMethod(method))
buildFixtureMethod(method);
else if (isFeatureMethod(method))
buildFeatureMethod(method);
else buildHelperMethod(method);
}
private boolean isIgnoredMethod(MethodNode method) {
return AstUtil.isSynthetic(method);
}
// IDEA: check for misspellings other than wrong capitalization
private boolean isFixtureMethod(MethodNode method) {
String name = method.getName();
for (String fmName : FIXTURE_METHODS) {
if (!fmName.equalsIgnoreCase(name)) continue;
// assertion: is (meant to be) a fixture method, so we'll return true in the end
if (method.isStatic())
errorReporter.error(method, "Fixture methods must not be static");
if (!fmName.equals(name))
errorReporter.error(method, "Misspelled '%s()' method (wrong capitalization)", fmName);
return true;
}
return false;
}
private void buildFixtureMethod(MethodNode method) {
FixtureMethod fixtureMethod = new FixtureMethod(spec, method);
Block block = new AnonymousBlock(fixtureMethod);
fixtureMethod.addBlock(block);
List stats = AstUtil.getStatements(method);
block.getAst().addAll(stats);
stats.clear();
String name = method.getName();
if (name.equals(SETUP)) spec.setSetupMethod(fixtureMethod);
else if (name.equals(CLEANUP)) spec.setCleanupMethod(fixtureMethod);
else if (name.equals(SETUP_SPEC_METHOD)) spec.setSetupSpecMethod(fixtureMethod);
else spec.setCleanupSpecMethod(fixtureMethod);
}
// IDEA: recognize feature methods by looking at signature only
// rationale: current solution can sometimes be unintuitive, e.g.
// for methods with empty body, or for methods with single assert
// potential indicators for feature methods:
// - public visibility (and no fixture method)
// - no visibility modifier (and no fixture method) (source lookup required?)
// - method name given as string literal (requires source lookup)
private boolean isFeatureMethod(MethodNode method) {
for (Statement stat : AstUtil.getStatements(method)) {
String label = stat.getStatementLabel();
if (label == null) continue;
// assertion: is (meant to be) a feature method, so we'll return true in the end
if (method.isStatic())
errorReporter.error(method, "Feature methods must not be static");
return true;
}
return false;
}
private void buildFeatureMethod(MethodNode method) {
Method feature = new FeatureMethod(spec, method, featureMethodCount++);
try {
buildBlocks(feature);
} catch (InvalidSpecCompileException e) {
errorReporter.error(e);
return;
}
spec.getMethods().add(feature);
}
private void buildHelperMethod(MethodNode method) {
Method helper = new HelperMethod(spec, method);
spec.getMethods().add(helper);
Block block = helper.addBlock(new AnonymousBlock(helper));
List stats = AstUtil.getStatements(method);
block.getAst().addAll(stats);
stats.clear();
}
private void buildBlocks(Method method) throws InvalidSpecCompileException {
List stats = AstUtil.getStatements(method.getAst());
Block currBlock = method.addBlock(new AnonymousBlock(method));
for (Statement stat : stats) {
if (stat.getStatementLabel() == null)
currBlock.getAst().add(stat);
else
currBlock = addBlock(method, stat);
}
checkIsValidSuccessor(method, BlockParseInfo.METHOD_END,
method.getAst().getLastLineNumber(), method.getAst().getLastColumnNumber());
// now that statements have been copied to blocks, the original statement
// list is cleared; statements will be copied back after rewriting is done
stats.clear();
}
private Block addBlock(Method method, Statement stat) throws InvalidSpecCompileException {
String label = stat.getStatementLabel();
for (BlockParseInfo blockInfo: BlockParseInfo.values()) {
if (!label.equals(blockInfo.toString())) continue;
checkIsValidSuccessor(method, blockInfo, stat.getLineNumber(), stat.getColumnNumber());
Block block = blockInfo.addNewBlock(method);
String description = getDescription(stat);
if (description == null)
block.getAst().add(stat);
else
block.getDescriptions().add(description);
return block;
}
throw new InvalidSpecCompileException(stat, "Unrecognized block label: " + label);
}
private String getDescription(Statement stat) {
ConstantExpression constExpr = AstUtil.getExpression(stat, ConstantExpression.class);
return constExpr == null || !(constExpr.getValue() instanceof String) ?
null : (String)constExpr.getValue();
}
private void checkIsValidSuccessor(Method method, BlockParseInfo blockInfo, int line, int column)
throws InvalidSpecCompileException {
BlockParseInfo oldBlockInfo = method.getLastBlock().getParseInfo();
if (!oldBlockInfo.getSuccessors(method).contains(blockInfo))
throw new InvalidSpecCompileException(line, column, "'%s' is not allowed here; instead, use one of: %s",
blockInfo, oldBlockInfo.getSuccessors(method), method.getName(), oldBlockInfo, blockInfo);
}
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/compiler/SpecRewriter.java 0000775 0000000 0000000 00000062525 12020225233 0031751 0 ustar 00root root 0000000 0000000 /*
* Copyright 2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.compiler;
import java.util.*;
import org.codehaus.groovy.ast.*;
import org.codehaus.groovy.ast.expr.*;
import org.codehaus.groovy.ast.stmt.*;
import org.codehaus.groovy.runtime.MetaClassHelper;
import org.codehaus.groovy.syntax.Token;
import org.codehaus.groovy.syntax.Types;
import org.objectweb.asm.Opcodes;
import org.spockframework.compiler.model.*;
import org.spockframework.mock.MockController;
import org.spockframework.util.InternalIdentifiers;
import org.spockframework.util.Identifiers;
/**
* A Spec visitor responsible for most of the rewriting of a Spec's AST.
*
* @author Peter Niederwieser
*/
// IDEA: mock controller / leaveScope calls should only be inserted when necessary (increases robustness)
public class SpecRewriter extends AbstractSpecVisitor implements IRewriteResources {
private final AstNodeCache nodeCache;
private final SourceLookup lookup;
private final ErrorReporter errorReporter;
private Spec spec;
private int specDepth;
private Method method;
private Block block;
private VariableExpression thrownExceptionRef; // reference to field $spock_thrown; always accessed through getter
private VariableExpression mockControllerRef; // reference to field $spock_mockController; always accessed through getter
private VariableExpression sharedInstanceRef; // reference to field $spock_sharedInstance
private boolean methodHasCondition;
private boolean movedStatsBackToMethod;
private boolean thenBlockHasExceptionCondition; // reset once per chain of then-blocks
private int fieldInitializerCount = 0;
private int sharedFieldInitializerCount = 0;
private int oldValueCount = 0;
public SpecRewriter(AstNodeCache nodeCache, SourceLookup lookup, ErrorReporter errorReporter) {
this.nodeCache = nodeCache;
this.lookup = lookup;
this.errorReporter = errorReporter;
}
public void visitSpec(Spec spec) {
this.spec = spec;
specDepth = computeDepth(spec.getAst());
createThrownExceptionFieldAndRef();
createMockControllerFieldAndRef();
createSharedInstanceFieldAndRef();
}
private int computeDepth(ClassNode node) {
if (node.equals(ClassHelper.OBJECT_TYPE) || node.equals(nodeCache.Specification)) return -1;
return computeDepth(node.getSuperClass()) + 1;
}
public void visitSpecAgain(Spec spec) throws Exception {
addMockControllerFieldInitializer();
}
private void createThrownExceptionFieldAndRef() {
Variable var;
if (isDirectlyExtendingSpecification())
var = spec.getAst().addField(
"$spock_thrown",
Opcodes.ACC_PROTECTED | Opcodes.ACC_SYNTHETIC,
ClassHelper.DYNAMIC_TYPE,
null);
else
var = new DynamicVariable("$spock_thrown", false);
thrownExceptionRef = new VariableExpression(var);
}
private void createMockControllerFieldAndRef() {
Variable var;
if (isDirectlyExtendingSpecification())
var = spec.getAst().addField(
"$spock_mockController",
Opcodes.ACC_PROTECTED | Opcodes.ACC_SYNTHETIC,
ClassHelper.DYNAMIC_TYPE,
null);
else
var = new DynamicVariable("$spock_mockController", false);
mockControllerRef = new VariableExpression(var);
}
private void createSharedInstanceFieldAndRef() {
Variable var;
if (isDirectlyExtendingSpecification())
var = spec.getAst().addField(
InternalIdentifiers.SHARED_INSTANCE_NAME,
Opcodes.ACC_PUBLIC | Opcodes.ACC_SYNTHETIC, // public s.t. runner can easily set it
ClassHelper.DYNAMIC_TYPE,
null);
else
var = new DynamicVariable(InternalIdentifiers.SHARED_INSTANCE_NAME, false);
sharedInstanceRef = new VariableExpression(var);
}
private void addMockControllerFieldInitializer() {
if (!isDirectlyExtendingSpecification()) return;
// mock controller needs to be initialized before all other fields
getInitializerMethod().getStatements().add(0,
new ExpressionStatement(
new BinaryExpression(
mockControllerRef,
Token.newSymbol(Types.ASSIGN, -1, -1),
new ConstructorCallExpression(
nodeCache.MockController,
new FieldExpression(nodeCache.DefaultMockFactory_INSTANCE)))));
}
private boolean isDirectlyExtendingSpecification() {
ClassNode superClass = spec.getAst().getSuperClass();
return superClass.equals(ClassHelper.OBJECT_TYPE)
|| superClass.equals(nodeCache.Specification);
}
public void visitField(Field field) {
if (field.isShared())
handleSharedField(field);
else
handleNonSharedField(field);
}
private void handleSharedField(Field field) {
changeSharedFieldInternalName(field);
createSharedFieldGetter(field);
createSharedFieldSetter(field);
moveSharedFieldInitializer(field);
makeSharedFieldProtectedAndVolatile(field);
}
// field.getAst().getName() changes, field.getName() remains the same
private void changeSharedFieldInternalName(Field field) {
field.getAst().rename(InternalIdentifiers.getSharedFieldName(field.getName()));
}
private void createSharedFieldGetter(Field field) {
String getterName = "get" + MetaClassHelper.capitalize(field.getName());
MethodNode getter = spec.getAst().getMethod(getterName, Parameter.EMPTY_ARRAY);
if (getter != null) {
errorReporter.error(field.getAst(),
"@Shared field '%s' conflicts with method '%s'; please rename either of them",
field.getName(), getter.getName());
return;
}
BlockStatement getterBlock = new BlockStatement();
getter = new MethodNode(getterName, determineVisibilityForSharedFieldAccessor(field) | Opcodes.ACC_SYNTHETIC,
ClassHelper.DYNAMIC_TYPE, Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, getterBlock);
getterBlock.addStatement(
new ReturnStatement(
new ExpressionStatement(
new AttributeExpression(
sharedInstanceRef,
// use internal name
new ConstantExpression(field.getAst().getName())))));
getter.setSourcePosition(field.getAst());
spec.getAst().addMethod(getter);
}
private void createSharedFieldSetter(Field field) {
String setterName = "set" + MetaClassHelper.capitalize(field.getName());
Parameter[] params = new Parameter[] { new Parameter(field.getAst().getType(), "$spock_value") };
MethodNode setter = spec.getAst().getMethod(setterName, params);
if (setter != null) {
errorReporter.error(field.getAst(),
"@Shared field '%s' conflicts with method '%s'; please rename either of them",
field.getName(), setter.getName());
return;
}
BlockStatement setterBlock = new BlockStatement();
setter = new MethodNode(setterName, determineVisibilityForSharedFieldAccessor(field) | Opcodes.ACC_SYNTHETIC,
ClassHelper.VOID_TYPE, params, ClassNode.EMPTY_ARRAY, setterBlock);
setterBlock.addStatement(
new ExpressionStatement(
new BinaryExpression(
new AttributeExpression(
sharedInstanceRef,
// use internal name
new ConstantExpression(field.getAst().getName())),
Token.newSymbol(Types.ASSIGN, -1, -1),
new VariableExpression("$spock_value"))));
setter.setSourcePosition(field.getAst());
spec.getAst().addMethod(setter);
}
// we try to use the visibility of the original field, but change
// private to protected to solve http://issues.spockframework.org/detail?id=151
private int determineVisibilityForSharedFieldAccessor(Field field) {
if (field.getOwner() == null) { // true field
int visibility = AstUtil.getVisibility(field.getAst());
if (visibility == Opcodes.ACC_PRIVATE) visibility = Opcodes.ACC_PROTECTED;
return visibility;
} else { // property
return Opcodes.ACC_PUBLIC;
}
}
private void moveSharedFieldInitializer(Field field) {
if (field.getAst().getInitialValueExpression() != null)
moveInitializer(field, getSharedInitializerMethod(), sharedFieldInitializerCount++);
}
/*
We would prefer to make shared fields private, but this doesn't work in the following case:
class BaseSpec {
public sharedInstance
private sharedField = 5
def sharedFieldGetter() { sharedInstance.sharedField }
}
class DerivedSpec extends BaseSpec {}
// when DerivedSpec is run:
def sharedInstance = new DerivedSpec()
def spec = new DerivedSpec()
spec.sharedInstance = sharedInstance
spec.sharedFieldGetter() // would normally occur within a specification
groovy.lang.MissingPropertyException: No such property: sharedField for class: DerivedSpec
Solutions:
1. Make sharedField protected
2. Route all accesses to sharedField through sharedInstance's (!) sharedFieldGetter()
(from there, sharedField can be accessed w/o qualification)
Reasons why we chose 1:
- A bit easier to implement
- We might at some point decide that we need to reroute some
VariableExpression/AttributeExpression/PropertyExpression that accesses
sharedField directly (but on the wrong instance). However, these kinds of
expressions cannot be replaced with a MethodCallExpression (calling
sharedFieldGetter/Setter). Instead, we would have to replace them with
an AttributeExpression/PropertyExpression of the form sharedInstance.sharedField,
which would again require as to make sharedField protected.
If we find that making shared fields protected can potentially cause name clashes within
an inheritance chain, we should make sure that shared field names are unique within
a chain. For example, this could be done by mixing in a number that measures
the distance between the declaring class and class Specification. (That's how it's done
in Groovy.)
*/
private static void makeSharedFieldProtectedAndVolatile(Field field) {
AstUtil.setVisibility(field.getAst(), Opcodes.ACC_PROTECTED);
field.getAst().setModifiers(field.getAst().getModifiers() | Opcodes.ACC_VOLATILE);
}
private void handleNonSharedField(Field field) {
if (field.getAst().getInitialValueExpression() != null)
moveInitializer(field, getInitializerMethod(), fieldInitializerCount++);
}
/*
* Moves initialization of the given field to the given position of the first block of the given method.
*/
private void moveInitializer(Field field, Method method, int position) {
method.getFirstBlock().getAst().add(position,
new ExpressionStatement(
new FieldInitializationExpression(field.getAst())));
field.getAst().setInitialValueExpression(null);
}
public void visitMethod(Method method) {
this.method = method;
methodHasCondition = false;
movedStatsBackToMethod = false;
if (method instanceof FixtureMethod) {
checkFieldAccessInFixtureMethod(method);
// de-virtualize method s.t. multiple fixture methods along hierarchy can be called independently
AstUtil.setVisibility(method.getAst(), Opcodes.ACC_PRIVATE);
} else if (method instanceof FeatureMethod) {
transplantMethod(method);
handleWhereBlock(method);
}
}
private void checkFieldAccessInFixtureMethod(Method method) {
if (method != spec.getSetupSpecMethod() && method != spec.getCleanupSpecMethod()) return;
new InstanceFieldAccessChecker(this).check(method);
}
private void transplantMethod(Method method) {
FeatureMethod feature = (FeatureMethod) method;
MethodNode oldAst = feature.getAst();
MethodNode newAst = copyMethod(oldAst, createInternalName(feature));
spec.getAst().addMethod(newAst);
feature.setAst(newAst);
AstUtil.deleteMethod(spec.getAst(), oldAst);
}
private String createInternalName(FeatureMethod feature) {
return String.format("$spock_feature_%d_%d", specDepth, feature.getOrdinal());
}
private MethodNode copyMethod(MethodNode method, String newName) {
// can't hurt to set return type to void
MethodNode newMethod = new MethodNode(newName, method.getModifiers(),
ClassHelper.VOID_TYPE, method.getParameters(), method.getExceptions(), method.getCode());
newMethod.addAnnotations(method.getAnnotations());
newMethod.setSynthetic(method.isSynthetic());
newMethod.setDeclaringClass(method.getDeclaringClass());
newMethod.setSourcePosition(method);
newMethod.setVariableScope(method.getVariableScope());
newMethod.setGenericsTypes(method.getGenericsTypes());
newMethod.setAnnotationDefault(method.hasAnnotationDefault());
return newMethod;
}
// where block must be rewritten before all other blocks
// s.t. missing method parameters are added; these parameters
// will then be used by DeepStatementRewriter.fixupVariableScope()
private void handleWhereBlock(Method method) {
Block block = method.getLastBlock();
if (!(block instanceof WhereBlock)) {
Parameter[] params = method.getAst().getParameters();
if (params.length > 0)
errorReporter.error(params[0], "Feature methods without 'where' block may not declare parameters");
return;
}
new DeepStatementRewriter(this).visitBlock(block);
WhereBlockRewriter.rewrite((WhereBlock) block, this);
}
public void visitMethodAgain(Method method) {
this.block = null;
if (methodHasCondition)
defineValueRecorder(method.getStatements());
if (!movedStatsBackToMethod)
for (Block b : method.getBlocks())
method.getStatements().addAll(b.getAst());
// for global required interactions
if (method instanceof FeatureMethod)
method.getStatements().add(createMockControllerCall(MockController.LEAVE_SCOPE));
}
public void visitAnyBlock(Block block) {
this.block = block;
if (block instanceof ExpectBlock || block instanceof ThenBlock) return;
DeepStatementRewriter deep = new DeepStatementRewriter(this);
deep.visitBlock(block);
methodHasCondition |= deep.isConditionFound();
}
public void visitExpectBlock(ExpectBlock block) {
ListIterator iter = block.getAst().listIterator();
while(iter.hasNext()) {
Statement stat = iter.next();
DeepStatementRewriter deep = new DeepStatementRewriter(this);
Statement newStat = deep.replace(stat);
methodHasCondition |= deep.isConditionFound();
if (stat instanceof AssertStatement)
iter.set(newStat);
else if (isExceptionCondition(newStat)) {
errorReporter.error(newStat, "Exception conditions are only allowed in 'then' blocks");
} else if (statHasInteraction(newStat, deep))
errorReporter.error(newStat, "Interactions are only allowed in 'then' blocks");
else if (isImplicitCondition(newStat)) {
checkIsValidCondition(newStat);
iter.set(rewriteImplicitCondition(newStat));
methodHasCondition = true;
}
}
}
public void visitThenBlock(ThenBlock block) {
ListIterator iter = block.getAst().listIterator();
List interactions = new ArrayList();
if (block.isFirstInChain()) thenBlockHasExceptionCondition = false;
while(iter.hasNext()) {
Statement stat = iter.next();
DeepStatementRewriter deep = new DeepStatementRewriter(this);
Statement newStat = deep.replace(stat);
methodHasCondition |= deep.isConditionFound();
if (stat instanceof AssertStatement)
iter.set(newStat);
else if (isExceptionCondition(newStat)) {
rewriteExceptionCondition(newStat);
if (!thenBlockHasExceptionCondition) {
rewriteWhenBlockForExceptionCondition(block.getPrevious(WhenBlock.class));
thenBlockHasExceptionCondition = true;
}
} else if (statHasInteraction(newStat, deep)) {
interactions.add(newStat);
iter.remove();
} else if (isImplicitCondition(newStat)) {
checkIsValidCondition(newStat);
iter.set(rewriteImplicitCondition(newStat));
methodHasCondition = true;
}
}
insertInteractions(interactions, block);
}
private boolean isImplicitCondition(Statement stat) {
return stat instanceof ExpressionStatement
&& !(((ExpressionStatement)stat).getExpression() instanceof DeclarationExpression);
}
private void checkIsValidCondition(Statement stat) {
BinaryExpression binExpr = AstUtil.getExpression(stat, BinaryExpression.class);
if (binExpr == null) return;
if (Types.ofType(binExpr.getOperation().getType(), Types.ASSIGNMENT_OPERATOR)) {
errorReporter.error(stat, "Expected a condition, but found an assignment. Did you intend to write '==' ?");
}
}
private Statement rewriteImplicitCondition(Statement stat) {
return ConditionRewriter.rewriteImplicitCondition((ExpressionStatement)stat, this);
}
private boolean isExceptionCondition(Statement stat) {
Expression expr = AstUtil.getExpression(stat, Expression.class);
return expr != null && AstUtil.isBuiltinMemberAssignmentOrCall(expr, Identifiers.THROWN, 0, 1);
}
private void rewriteExceptionCondition(Statement stat) {
if (thenBlockHasExceptionCondition) {
errorReporter.error(stat, "A 'then' block may only have one exception condition");
return;
}
Expression expr = AstUtil.getExpression(stat, Expression.class);
assert expr != null;
try {
AstUtil.expandBuiltinMemberAssignmentOrCall(expr, thrownExceptionRef);
} catch (InvalidSpecCompileException e) {
errorReporter.error(e);
}
}
private boolean statHasInteraction(Statement stat, DeepStatementRewriter deep) {
if (deep.isInteractionFound()) return true;
Expression expr = AstUtil.getExpression(stat, Expression.class);
return expr != null && AstUtil.isBuiltinMemberCall(expr, Identifiers.INTERACTION, 0, 1);
}
private void insertInteractions(List interactions, ThenBlock block) {
if (interactions.isEmpty()) return;
List statsBeforeWhenBlock = block.getPrevious(WhenBlock.class).getPrevious().getAst();
statsBeforeWhenBlock.add(createMockControllerCall(
block.isFirstInChain() ? MockController.ENTER_SCOPE : MockController.ADD_BARRIER));
statsBeforeWhenBlock.addAll(interactions);
if (block.isFirstInChain())
// insert at beginning of then-block rather than end of when-block
// s.t. it's outside of try-block inserted for exception conditions
block.getAst().add(0, createMockControllerCall(MockController.LEAVE_SCOPE));
}
private Statement createMockControllerCall(String methodName) {
return new ExpressionStatement(
new MethodCallExpression(
mockControllerRef,
methodName,
ArgumentListExpression.EMPTY_ARGUMENTS));
}
public void visitCleanupBlock(CleanupBlock block) {
for (Block b : method.getBlocks()) {
if (b == block) break;
moveVariableDeclarations(b.getAst(), method.getStatements());
}
List tryStats = new ArrayList();
for (Block b : method.getBlocks()) {
if (b == block) break;
tryStats.addAll(b.getAst());
}
List finallyStats = new ArrayList();
finallyStats.addAll(block.getAst());
TryCatchStatement tryFinally =
new TryCatchStatement(
new BlockStatement(tryStats, new VariableScope()),
new BlockStatement(finallyStats, new VariableScope()));
method.getStatements().add(tryFinally);
// a cleanup-block may only be followed by a where-block, whose
// statements are copied to newly generated methods rather than
// the original method
movedStatsBackToMethod = true;
}
// IRewriteResources members
public Spec getCurrentSpec() {
return spec;
}
public Method getCurrentMethod() {
return method;
}
public Block getCurrentBlock() {
return block;
}
public void defineValueRecorder(List stats) {
// recorder variable needs to be defined in outermost scope,
// hence we insert it at the beginning of the block
stats.add(0,
new ExpressionStatement(
new DeclarationExpression(
new VariableExpression("$spock_valueRecorder"),
Token.newSymbol(Types.ASSIGN, -1, -1),
new ConstructorCallExpression(
nodeCache.ValueRecorder,
ArgumentListExpression.EMPTY_ARGUMENTS))));
}
public VariableExpression captureOldValue(Expression oldValue) {
VariableExpression var = new OldValueExpression(oldValue, "$spock_oldValue" + oldValueCount++);
DeclarationExpression decl = new DeclarationExpression(
var,
Token.newSymbol(Types.ASSIGN, -1, -1),
oldValue);
decl.setSourcePosition(oldValue);
// add declaration at end of block immediately preceding when-block
// avoids any problems if when-block gets wrapped in try-statement
block.getPrevious().getPrevious().getAst().add(new ExpressionStatement(decl));
return var;
}
public VariableExpression getMockControllerRef() {
return mockControllerRef;
}
public AstNodeCache getAstNodeCache() {
return nodeCache;
}
private FixtureMethod getInitializerMethod() {
if (spec.getInitializerMethod() == null) {
// method is private s.t. multiple initializer methods along hierarchy can be called independently
MethodNode gMethod = new MethodNode(InternalIdentifiers.INITIALIZER_METHOD, Opcodes.ACC_PRIVATE | Opcodes.ACC_SYNTHETIC,
ClassHelper.DYNAMIC_TYPE, Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, new BlockStatement());
spec.getAst().addMethod(gMethod);
FixtureMethod method = new FixtureMethod(spec, gMethod);
method.addBlock(new AnonymousBlock(method));
spec.setInitializerMethod(method);
}
return spec.getInitializerMethod();
}
public String getSourceText(ASTNode node) {
return lookup.lookup(node);
}
public ErrorReporter getErrorReporter() {
return errorReporter;
}
private FixtureMethod getSharedInitializerMethod() {
if (spec.getSharedInitializerMethod() == null) {
// method is private s.t. multiple initializer methods along hierarchy can be called independently
MethodNode gMethod = new MethodNode(InternalIdentifiers.SHARED_INITIALIZER_METHOD, Opcodes.ACC_PRIVATE | Opcodes.ACC_SYNTHETIC,
ClassHelper.DYNAMIC_TYPE, Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, new BlockStatement());
spec.getAst().addMethod(gMethod);
FixtureMethod method = new FixtureMethod(spec, gMethod);
method.addBlock(new AnonymousBlock(method));
spec.setSharedInitializerMethod(method);
}
return spec.getSharedInitializerMethod();
}
private void rewriteWhenBlockForExceptionCondition(WhenBlock block) {
List tryStats = block.getAst();
List blockStats = new ArrayList();
block.setAst(blockStats);
blockStats.add(
new ExpressionStatement(
new BinaryExpression(
thrownExceptionRef,
Token.newSymbol(Types.ASSIGN, -1, -1),
ConstantExpression.NULL)));
// ensure variables remain in same scope
// by moving variable defs to the very beginning of the method, they don't
// need to be moved again if feature method also has a cleanup-block
moveVariableDeclarations(tryStats, method.getStatements());
TryCatchStatement tryCatchStat =
new TryCatchStatement(
new BlockStatement(tryStats, new VariableScope()),
new BlockStatement());
blockStats.add(tryCatchStat);
tryCatchStat.addCatch(
new CatchStatement(
new Parameter(nodeCache.Throwable, "$spock_ex"),
new BlockStatement(
Arrays. asList(
new ExpressionStatement(
new BinaryExpression(
thrownExceptionRef,
Token.newSymbol(Types.ASSIGN, -1, -1),
new VariableExpression("$spock_ex")))),
new VariableScope())));
}
/*
* Moves variable declarations from one statement list to another. Initializer
* expressions are kept at their former place.
*/
private static void moveVariableDeclarations(List from, List to) {
for (Statement stat : from) {
if (!(stat instanceof ExpressionStatement)) continue;
ExpressionStatement exprStat = (ExpressionStatement)stat;
if (!(exprStat.getExpression() instanceof DeclarationExpression)) continue;
DeclarationExpression declExpr = (DeclarationExpression)exprStat.getExpression();
exprStat.setExpression(
new BinaryExpression(
new VariableExpression(declExpr.getVariableExpression().getName()),
Token.newSymbol(Types.ASSIGN, -1, -1),
declExpr.getRightExpression()));
declExpr.setRightExpression(ConstantExpression.NULL);
to.add(new ExpressionStatement(declExpr));
}
}
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/compiler/SpockTransform.java 0000775 0000000 0000000 00000006106 12020225233 0032277 0 ustar 00root root 0000000 0000000 /*
* Copyright 2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.compiler;
import java.util.List;
import org.codehaus.groovy.ast.*;
import org.codehaus.groovy.control.*;
import org.codehaus.groovy.transform.ASTTransformation;
import org.codehaus.groovy.transform.GroovyASTTransformation;
import org.spockframework.compiler.model.Spec;
import org.spockframework.util.VersionChecker;
/**
* AST transformation for rewriting Spock specifications. Runs after phase
* SEMANTIC_ANALYSIS, which means that the AST is semantically accurate
* and already decorated with reflection information. On the flip side,
* because types and variables have already been resolved,
* program elements like import statements and variable definitions
* can no longer be manipulated at will.
*
* @author Peter Niederwieser
*/
@SuppressWarnings("UnusedDeclaration")
@GroovyASTTransformation(phase = CompilePhase.SEMANTIC_ANALYSIS)
public class SpockTransform implements ASTTransformation {
public SpockTransform() {
VersionChecker.checkGroovyVersion("compiler plugin");
}
public void visit(ASTNode[] nodes, SourceUnit sourceUnit) {
new Impl().visit(nodes, sourceUnit);
}
// use of nested class defers linking until after groovy version check
private static class Impl {
final static AstNodeCache nodeCache = new AstNodeCache();
void visit(ASTNode[] nodes, SourceUnit sourceUnit) {
ErrorReporter errorReporter = new ErrorReporter(sourceUnit);
SourceLookup sourceLookup = new SourceLookup(sourceUnit);
try {
ModuleNode module = (ModuleNode) nodes[0];
@SuppressWarnings("unchecked")
List classes = module.getClasses();
for (ClassNode clazz : classes)
if (isSpec(clazz)) processSpec(clazz, errorReporter, sourceLookup);
} finally {
sourceLookup.close();
}
}
boolean isSpec(ClassNode clazz) {
return clazz.isDerivedFrom(nodeCache.Specification);
}
void processSpec(ClassNode clazz, ErrorReporter errorReporter, SourceLookup sourceLookup) {
try {
Spec spec = new SpecParser(errorReporter).build(clazz);
spec.accept(new SpecRewriter(nodeCache, sourceLookup, errorReporter));
spec.accept(new SpecAnnotator(nodeCache));
} catch (Exception e) {
errorReporter.error(
"Unexpected error during compilation of spec '%s'. Maybe you have used invalid Spock syntax? Anyway, please file a bug report at http://issues.spockframework.org.",
e, clazz.getName());
}
}
}
} StatementReplacingVisitorSupport.java 0000664 0000000 0000000 00000010164 12020225233 0036007 0 ustar 00root root 0000000 0000000 spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/compiler /*
* Copyright 2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.compiler;
import java.util.List;
import java.util.ListIterator;
import org.codehaus.groovy.ast.ClassCodeVisitorSupport;
import org.codehaus.groovy.ast.stmt.*;
import org.codehaus.groovy.control.SourceUnit;
/**
* Adds the ability to replace statements.
*
* @author Peter Niederwieser
*/
// Implementation note: It is only necessary to override visit methods
// for AST nodes that reference statements. For ClosureExpression we rely on
// the assumption that it always references a BlockStatement and hence our
// visitBlockStatement() method gets called.
public abstract class StatementReplacingVisitorSupport extends ClassCodeVisitorSupport {
private Statement replacement;
/**
* Visits the specified statement. If the statement's visit method calls
* replaceVisitedMethodWith(), the statement will be replaced.
*/
public Statement replace(Statement stat) {
replacement = null;
stat.visit(this);
Statement result = replacement == null ? stat : replacement;
replacement = null;
return result;
}
/**
* Visits the statements in the specified mutable list. If a statement's
* visit method calls replaceVisitedMethodWith(), the statement will be
* replaced.
*/
@SuppressWarnings("unchecked")
protected void replaceAll(List stats) {
ListIterator iter = stats.listIterator();
while (iter.hasNext())
iter.set((T) replace(iter.next()));
}
/**
* Replaces the currently visited statement with the specified statement.
*/
protected void replaceVisitedStatementWith(Statement other) {
replacement = other;
}
@SuppressWarnings("unchecked")
@Override
public void visitBlockStatement(BlockStatement stat) {
replaceAll(stat.getStatements());
}
@Override
public void visitForLoop(ForStatement stat) {
stat.getCollectionExpression().visit(this);
stat.setLoopBlock(replace(stat.getLoopBlock()));
}
@Override
public void visitWhileLoop(WhileStatement stat) {
stat.getBooleanExpression().visit(this);
stat.setLoopBlock(replace(stat.getLoopBlock()));
}
@Override
public void visitDoWhileLoop(DoWhileStatement stat) {
stat.getBooleanExpression().visit(this);
stat.setLoopBlock(replace(stat.getLoopBlock()));
}
@Override
public void visitIfElse(IfStatement stat) {
stat.getBooleanExpression().visit(this);
stat.setIfBlock(replace(stat.getIfBlock()));
stat.setElseBlock(replace(stat.getElseBlock()));
}
@SuppressWarnings("unchecked")
@Override
public void visitTryCatchFinally(TryCatchStatement stat) {
stat.setTryStatement(replace(stat.getTryStatement()));
replaceAll(stat.getCatchStatements());
stat.setFinallyStatement(replace(stat.getFinallyStatement()));
}
@SuppressWarnings("unchecked")
@Override
public void visitSwitch(SwitchStatement stat) {
stat.getExpression().visit(this);
replaceAll(stat.getCaseStatements());
stat.setDefaultStatement(replace(stat.getDefaultStatement()));
}
@Override
public void visitCaseStatement(CaseStatement stat) {
stat.getExpression().visit(this);
stat.setCode(replace(stat.getCode()));
}
@Override
public void visitSynchronizedStatement(SynchronizedStatement stat) {
stat.getExpression().visit(this);
stat.setCode(replace(stat.getCode()));
}
@Override
public void visitCatchStatement(CatchStatement stat) {
stat.setCode(replace(stat.getCode()));
}
@Override
protected SourceUnit getSourceUnit() {
throw new UnsupportedOperationException("getSourceUnit");
}
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/compiler/WhereBlockRewriter.java 0000775 0000000 0000000 00000034752 12020225233 0033105 0 ustar 00root root 0000000 0000000 /*
* Copyright 2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.compiler;
import java.util.*;
import org.codehaus.groovy.ast.*;
import org.codehaus.groovy.ast.expr.*;
import org.codehaus.groovy.ast.stmt.*;
import org.codehaus.groovy.syntax.Token;
import org.codehaus.groovy.syntax.Types;
import org.objectweb.asm.Opcodes;
import org.spockframework.compiler.model.WhereBlock;
import org.spockframework.runtime.model.DataProviderMetadata;
import org.spockframework.util.*;
/**
*
* @author Peter Niederwieser
*/
public class WhereBlockRewriter {
private final WhereBlock whereBlock;
private final IRewriteResources resources;
private final InstanceFieldAccessChecker instanceFieldAccessChecker;
private int dataProviderCount = 0;
// parameters of the data processor method (one for each data provider)
private final List dataProcessorParams = new ArrayList();
// statements of the data processor method (one for each parameterization variable)
private final List dataProcessorStats = new ArrayList();
// parameterization variables of the data processor method
private final List dataProcessorVars = new ArrayList();
private WhereBlockRewriter(WhereBlock whereBlock, IRewriteResources resources) {
this.whereBlock = whereBlock;
this.resources = resources;
instanceFieldAccessChecker = new InstanceFieldAccessChecker(resources);
}
public static void rewrite(WhereBlock block, IRewriteResources resources) {
new WhereBlockRewriter(block, resources).rewrite();
}
private void rewrite() {
ListIterator stats = whereBlock.getAst().listIterator();
while (stats.hasNext())
try {
rewriteWhereStat(stats);
} catch (InvalidSpecCompileException e) {
resources.getErrorReporter().error(e);
}
whereBlock.getAst().clear();
handleFeatureParameters();
createDataProcessorMethod();
}
private void rewriteWhereStat(ListIterator stats) throws InvalidSpecCompileException {
Statement stat = stats.next();
BinaryExpression binExpr = AstUtil.getExpression(stat, BinaryExpression.class);
if (binExpr == null || binExpr.getClass() != BinaryExpression.class) // don't allow subclasses like DeclarationExpression
notAParameterization(stat);
@SuppressWarnings("ConstantConditions")
int type = binExpr.getOperation().getType();
if (type == Types.LEFT_SHIFT) {
Expression leftExpr = binExpr.getLeftExpression();
if (leftExpr instanceof VariableExpression)
rewriteSimpleParameterization(binExpr, stat);
else if (leftExpr instanceof ListExpression)
rewriteMultiParameterization(binExpr, stat);
else notAParameterization(stat);
} else if (type == Types.ASSIGN)
rewriteDerivedParameterization(binExpr, stat);
else if (getOrExpression(binExpr) != null) {
stats.previous();
rewriteTableLikeParameterization(stats);
}
else notAParameterization(stat);
}
private void createDataProviderMethod(Expression dataProviderExpr, int nextDataVariableIndex) {
instanceFieldAccessChecker.check(dataProviderExpr);
MethodNode method =
new MethodNode(
InternalIdentifiers.getDataProviderName(whereBlock.getParent().getAst().getName(), dataProviderCount++),
Opcodes.ACC_PUBLIC | Opcodes.ACC_SYNTHETIC,
ClassHelper.OBJECT_TYPE,
Parameter.EMPTY_ARRAY,
ClassNode.EMPTY_ARRAY,
new BlockStatement(
Arrays. asList(
new ReturnStatement(
new ExpressionStatement(dataProviderExpr))),
new VariableScope()));
method.addAnnotation(createDataProviderAnnotation(dataProviderExpr, nextDataVariableIndex));
whereBlock.getParent().getParent().getAst().addMethod(method);
}
private AnnotationNode createDataProviderAnnotation(Expression dataProviderExpr, int nextDataVariableIndex) {
AnnotationNode ann = new AnnotationNode(resources.getAstNodeCache().DataProviderMetadata);
ann.addMember(DataProviderMetadata.LINE, new ConstantExpression(dataProviderExpr.getLineNumber()));
List dataVariableNames = new ArrayList();
for (int i = nextDataVariableIndex; i < dataProcessorVars.size(); i++)
dataVariableNames.add(new ConstantExpression(dataProcessorVars.get(i).getName()));
ann.addMember(DataProviderMetadata.DATA_VARIABLES, new ListExpression(dataVariableNames));
return ann;
}
private Parameter createDataProcessorParameter() {
Parameter p = new Parameter(ClassHelper.DYNAMIC_TYPE, "$spock_p" + dataProcessorParams.size());
dataProcessorParams.add(p);
return p;
}
// generates: arg = argMethodParam
private void rewriteSimpleParameterization(BinaryExpression binExpr, ASTNode sourcePos)
throws InvalidSpecCompileException {
int nextDataVariableIndex = dataProcessorVars.size();
Parameter dataProcessorParameter = createDataProcessorParameter();
VariableExpression arg = (VariableExpression) binExpr.getLeftExpression();
VariableExpression dataVar = createDataProcessorVariable(arg, sourcePos);
ExpressionStatement exprStat = new ExpressionStatement(
new DeclarationExpression(
dataVar,
Token.newSymbol(Types.ASSIGN, -1, -1),
new VariableExpression(dataProcessorParameter)));
exprStat.setSourcePosition(sourcePos);
dataProcessorStats.add(exprStat);
createDataProviderMethod(binExpr.getRightExpression(), nextDataVariableIndex);
}
// generates:
// arg0 = argMethodParam.getAt(0)
// arg1 = argMethodParam.getAt(1)
private void rewriteMultiParameterization(BinaryExpression binExpr, Statement enclosingStat)
throws InvalidSpecCompileException {
int nextDataVariableIndex = dataProcessorVars.size();
Parameter dataProcessorParameter = createDataProcessorParameter();
ListExpression list = (ListExpression) binExpr.getLeftExpression();
@SuppressWarnings("unchecked")
List listElems = list.getExpressions();
for (int i = 0; i < listElems.size(); i++) {
Expression listElem = listElems.get(i);
if (AstUtil.isWildcardRef(listElem)) continue;
VariableExpression dataVar = createDataProcessorVariable(listElem, enclosingStat);
ExpressionStatement exprStat =
new ExpressionStatement(
new DeclarationExpression(
dataVar,
Token.newSymbol(Types.ASSIGN, -1, -1),
new MethodCallExpression(
new VariableExpression(dataProcessorParameter),
"getAt",
new ConstantExpression(i))));
exprStat.setSourcePosition(enclosingStat);
dataProcessorStats.add(exprStat);
}
createDataProviderMethod(binExpr.getRightExpression(), nextDataVariableIndex);
}
private void rewriteDerivedParameterization(BinaryExpression parameterization, Statement enclosingStat)
throws InvalidSpecCompileException {
VariableExpression dataVar = createDataProcessorVariable(parameterization.getLeftExpression(), enclosingStat);
ExpressionStatement exprStat =
new ExpressionStatement(
new DeclarationExpression(
dataVar,
Token.newSymbol(Types.ASSIGN, -1, -1),
parameterization.getRightExpression()));
exprStat.setSourcePosition(enclosingStat);
dataProcessorStats.add(exprStat);
}
private void rewriteTableLikeParameterization(ListIterator stats) throws InvalidSpecCompileException {
LinkedList> rows = new LinkedList>();
while (stats.hasNext()) {
Statement stat = stats.next();
BinaryExpression orExpr = getOrExpression(stat);
if (orExpr == null) {
stats.previous();
break;
}
List row = new ArrayList();
splitRow(orExpr, row);
if (rows.size() > 0 && rows.getLast().size() != row.size())
throw new InvalidSpecCompileException(stat, String.format("Row in data table has wrong number of elements (%s instead of %s)", row.size(), rows.getLast().size()));
rows.add(row);
}
for (List column : transposeTable(rows))
turnIntoSimpleParameterization(column);
}
List> transposeTable(List> rows) {
List> columns = new ArrayList>();
if (rows.isEmpty()) return columns;
for (int i = 0; i < rows.get(0).size(); i++)
columns.add(new ArrayList());
for (List row : rows)
for (int i = 0; i < row.size(); i++)
columns.get(i).add(row.get(i));
return columns;
}
private void turnIntoSimpleParameterization(List column) throws InvalidSpecCompileException {
VariableExpression varExpr = AstUtil.asInstance(column.get(0), VariableExpression.class);
if (varExpr == null)
throw new InvalidSpecCompileException(column.get(0),
"Header of data table may only contain variable names");
ListExpression listExpr = new ListExpression(column.subList(1, column.size()));
BinaryExpression binExpr = new BinaryExpression(varExpr, Token.newSymbol(Types.LEFT_SHIFT, -1, -1), listExpr);
// NOTE: varExpr may not be the "perfect" source position here, but as long as we rewrite data tables
// into simple parameterizations, it seems like the best approximation; also this source position is
// unlikely to make it into a compile error, because header variable has already been checked, and the
// assignment itself is unlikely to cause a compile error. (It's more likely that the rval causes a
// compile error, but the rval's source position is retained.)
rewriteSimpleParameterization(binExpr, varExpr);
}
private void splitRow(Expression row, List parts) {
BinaryExpression orExpr = getOrExpression(row);
if (orExpr == null)
parts.add(row);
else {
splitRow(orExpr.getLeftExpression(), parts);
splitRow(orExpr.getRightExpression(), parts);
}
}
private BinaryExpression getOrExpression(Statement stat) {
Expression expr = AstUtil.getExpression(stat, Expression.class);
return getOrExpression(expr);
}
private BinaryExpression getOrExpression(Expression expr) {
BinaryExpression binExpr = AstUtil.asInstance(expr, BinaryExpression.class);
if (binExpr == null) return null;
int binExprType = binExpr.getOperation().getType();
if (binExprType == Types.BITWISE_OR || binExprType == Types.LOGICAL_OR) return binExpr;
return null;
}
private VariableExpression createDataProcessorVariable(Expression varExpr, ASTNode sourcePos)
throws InvalidSpecCompileException {
if (!(varExpr instanceof VariableExpression))
notAParameterization(sourcePos);
VariableExpression typedVarExpr = (VariableExpression)varExpr;
verifyDataProcessorVariable(typedVarExpr);
VariableExpression result = new VariableExpression(typedVarExpr.getName(), typedVarExpr.getType());
dataProcessorVars.add(result);
return result;
}
private void verifyDataProcessorVariable(VariableExpression varExpr) {
Variable accessedVar = varExpr.getAccessedVariable();
if (accessedVar instanceof VariableExpression) { // local variable
resources.getErrorReporter().error(varExpr, "A variable named '%s' already exists in this scope", varExpr.getName());
return;
}
if (getDataProcessorVariable(varExpr.getName()) != null) {
resources.getErrorReporter().error(varExpr, "Duplicate declaration of data variable '%s'", varExpr.getName());
return;
}
if (whereBlock.getParent().getAst().getParameters().length > 0 && !(accessedVar instanceof Parameter)) {
resources.getErrorReporter().error(varExpr,
"Data variable '%s' needs to be declared as method parameter",
varExpr.getName());
}
}
private VariableExpression getDataProcessorVariable(String name) {
for (VariableExpression var : dataProcessorVars)
if (var.getName().equals(name)) return var;
return null;
}
private void handleFeatureParameters() {
Parameter[] parameters = whereBlock.getParent().getAst().getParameters();
if (parameters.length == 0)
addFeatureParameters();
else
checkAllParametersAreDataVariables(parameters);
}
private void checkAllParametersAreDataVariables(Parameter[] parameters) {
for (Parameter param : parameters)
if (getDataProcessorVariable(param.getName()) == null)
resources.getErrorReporter().error(param, "Parameter '%s' does not refer to a data variable", param.getName());
}
private void addFeatureParameters() {
Parameter[] parameters = new Parameter[dataProcessorVars.size()];
for (int i = 0; i < dataProcessorVars.size(); i++)
parameters[i] = new Parameter(ClassHelper.DYNAMIC_TYPE, dataProcessorVars.get(i).getName());
whereBlock.getParent().getAst().setParameters(parameters);
}
@SuppressWarnings("unchecked")
private void createDataProcessorMethod() {
if (dataProcessorVars.isEmpty()) return;
dataProcessorStats.add(
new ReturnStatement(
new ArrayExpression(
ClassHelper.OBJECT_TYPE,
(List)dataProcessorVars)));
whereBlock.getParent().getParent().getAst().addMethod(
new MethodNode(
InternalIdentifiers.getDataProcessorName(whereBlock.getParent().getAst().getName()),
Opcodes.ACC_PUBLIC | Opcodes.ACC_SYNTHETIC,
ClassHelper.OBJECT_TYPE,
dataProcessorParams.toArray(new Parameter[dataProcessorParams.size()]),
ClassNode.EMPTY_ARRAY,
new BlockStatement(
dataProcessorStats,
new VariableScope())));
}
private static void notAParameterization(ASTNode stat) throws InvalidSpecCompileException {
throw new InvalidSpecCompileException(stat,
"where-blocks may only contain parameterizations (e.g. 'salary << [1000, 5000, 9000]; salaryk = salary / 1000')");
}
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/compiler/model/ 0000775 0000000 0000000 00000000000 12020225233 0027553 5 ustar 00root root 0000000 0000000 spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/compiler/model/AnonymousBlock.java 0000664 0000000 0000000 00000002230 12020225233 0033356 0 ustar 00root root 0000000 0000000 /*
* Copyright 2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.compiler.model;
/**
* A block without a label at the beginning of a method. Every Method
* has a (possibly empty) AnonymousBlock as its first block.
*
* @author Peter Niederwieser
*/
public class AnonymousBlock extends Block {
public AnonymousBlock(Method parent) {
super(parent);
}
@Override
public void accept(ISpecVisitor visitor) throws Exception {
visitor.visitAnyBlock(this);
visitor.visitAnonymousBlock(this);
}
public BlockParseInfo getParseInfo() {
return BlockParseInfo.ANONYMOUS;
}
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/compiler/model/Block.java 0000775 0000000 0000000 00000004367 12020225233 0031465 0 ustar 00root root 0000000 0000000 /*
* Copyright 2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.compiler.model;
import java.util.ArrayList;
import java.util.List;
import org.codehaus.groovy.ast.stmt.Statement;
/**
* AST node representing a block in a feature method. There are six kinds
* of blocks: setup-block, expect-block, when-block, then-block, cleanup-block,
* and where-block.
*
* @author Peter Niederwieser
*/
public abstract class Block extends Node> {
private final List descriptions = new ArrayList(3);
private Block prev;
private Block next;
public Block(Method parent) {
super(parent, new ArrayList());
}
public List getDescriptions() {
return descriptions;
}
public Block getPrevious() {
return prev;
}
public void setPrevious(Block block) {
prev = block;
}
public Block getNext() {
return next;
}
public void setNext(Block block) {
next = block;
}
public T getPrevious(Class blockType) {
Block block = prev;
while (block != null && !blockType.isInstance(block)) block = block.prev;
return blockType.cast(block);
}
public T getNext(Class blockType) {
Block block = next;
while (block != null && !blockType.isInstance(block)) block = block.next;
return blockType.cast(block);
}
public boolean isFirst() {
return prev == null;
}
public boolean isLast() {
return next == null;
}
public boolean isFirstInChain() {
return isFirst() || getClass() != prev.getClass();
}
public abstract BlockParseInfo getParseInfo();
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/compiler/model/BlockParseInfo.java 0000664 0000000 0000000 00000006746 12020225233 0033274 0 ustar 00root root 0000000 0000000 /*
* Copyright 2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.compiler.model;
import java.util.EnumSet;
/**
*
* @author Peter Niederwieser
*/
public enum BlockParseInfo {
AND {
public EnumSet getSuccessors(Method method) {
return method.getLastBlock().getParseInfo().getSuccessors(method);
}
public Block addNewBlock(Method method) {
return method.getLastBlock();
}
},
ANONYMOUS {
public Block addNewBlock(Method method) {
return method.addBlock(new AnonymousBlock(method));
}
public EnumSet getSuccessors(Method method) {
return EnumSet.of(SETUP, GIVEN, EXPECT, WHEN, CLEANUP, WHERE, METHOD_END);
}
},
SETUP {
public Block addNewBlock(Method method) {
return method.addBlock(new SetupBlock(method));
}
public EnumSet getSuccessors(Method method) {
return EnumSet.of(AND, EXPECT, WHEN, CLEANUP, WHERE, METHOD_END);
}
},
GIVEN {
public Block addNewBlock(Method method) {
return SETUP.addNewBlock(method);
}
public EnumSet getSuccessors(Method method) {
return SETUP.getSuccessors(method);
}
},
EXPECT {
public Block addNewBlock(Method method) {
return method.addBlock(new ExpectBlock(method));
}
public EnumSet getSuccessors(Method method) {
return EnumSet.of(AND, WHEN, CLEANUP, WHERE, METHOD_END);
}
},
WHEN {
public Block addNewBlock(Method method) {
return method.addBlock(new WhenBlock(method));
}
public EnumSet getSuccessors(Method method) {
return EnumSet.of(AND, THEN);
}
},
THEN {
public Block addNewBlock(Method method) {
return method.addBlock(new ThenBlock(method));
}
public EnumSet getSuccessors(Method method) {
return EnumSet.of(AND, EXPECT, WHEN, THEN, CLEANUP, WHERE, METHOD_END);
}
},
CLEANUP {
public Block addNewBlock(Method method) {
return method.addBlock(new CleanupBlock(method));
}
public EnumSet getSuccessors(Method method) {
return EnumSet.of(AND, WHERE, METHOD_END);
}
},
WHERE {
public Block addNewBlock(Method method) {
return method.addBlock(new WhereBlock(method));
}
public EnumSet getSuccessors(Method method) {
return EnumSet.of(AND, METHOD_END);
}
},
METHOD_END {
public Block addNewBlock(Method method) {
throw new UnsupportedOperationException("addNewBlock");
}
public EnumSet getSuccessors(Method method) {
throw new UnsupportedOperationException("getSuccessors");
}
public String toString() {
return "end-of-method";
}
};
public String toString() {
return super.toString().toLowerCase();
}
public abstract Block addNewBlock(Method method);
public abstract EnumSet getSuccessors(Method method);
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/compiler/model/CleanupBlock.java 0000664 0000000 0000000 00000002157 12020225233 0032765 0 ustar 00root root 0000000 0000000 /*
* Copyright 2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.compiler.model;
/**
* AST node representing a cleanup-block in a feature method.
*
* @author Peter Niederwieser
*/
public class CleanupBlock extends Block {
public CleanupBlock(Method parent) {
super(parent);
}
@Override
public void accept(ISpecVisitor visitor) throws Exception {
visitor.visitAnyBlock(this);
visitor.visitCleanupBlock(this);
}
public BlockParseInfo getParseInfo() {
return BlockParseInfo.CLEANUP;
}
} spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/compiler/model/ExpectBlock.java 0000775 0000000 0000000 00000002011 12020225233 0032616 0 ustar 00root root 0000000 0000000 /*
* Copyright 2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.compiler.model;
/**
*
* @author Peter Niederwieser
*/
public class ExpectBlock extends Block {
public ExpectBlock(Method parent) {
super(parent);
}
@Override
public void accept(ISpecVisitor visitor) throws Exception {
visitor.visitAnyBlock(this);
visitor.visitExpectBlock(this);
}
public BlockParseInfo getParseInfo() {
return BlockParseInfo.EXPECT;
}
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/compiler/model/FeatureMethod.java 0000775 0000000 0000000 00000002070 12020225233 0033154 0 ustar 00root root 0000000 0000000 /*
* Copyright 2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.compiler.model;
import org.codehaus.groovy.ast.MethodNode;
/**
* AST node representing a feature method.
*
* @author Peter Niederwieser
*/
public class FeatureMethod extends Method {
private final int ordinal;
public FeatureMethod(Spec parent, MethodNode code, int ordinal) {
super(parent, code);
this.ordinal = ordinal;
}
public int getOrdinal() {
return ordinal;
}
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/compiler/model/Field.java 0000664 0000000 0000000 00000003226 12020225233 0031444 0 ustar 00root root 0000000 0000000 /*
* Copyright 2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.compiler.model;
import org.codehaus.groovy.ast.FieldNode;
import org.codehaus.groovy.ast.PropertyNode;
/**
* AST node representing a user-defined instance field.
* (A generated field underlying a user-defined property also counts as such.)
*
* @author Peter Niederwieser
*/
public class Field extends Node {
private final int ordinal;
private boolean isShared;
private PropertyNode owner;
public Field(Spec parent, FieldNode ast, int ordinal) {
super(parent, ast);
setName(ast.getName());
this.ordinal = ordinal;
}
public int getOrdinal() {
return ordinal;
}
public boolean isShared() {
return isShared;
}
public void setShared(boolean shared) {
isShared = shared;
}
// null for a true field that has no associated property
public PropertyNode getOwner() {
return owner;
}
public void setOwner(PropertyNode owner) {
this.owner = owner;
}
@Override
public void accept(ISpecVisitor visitor) throws Exception {
visitor.visitField(this);
}
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/compiler/model/FixtureMethod.java 0000775 0000000 0000000 00000002075 12020225233 0033214 0 ustar 00root root 0000000 0000000 /*
* Copyright 2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.compiler.model;
import org.codehaus.groovy.ast.MethodNode;
/**
* AST node representing a fixture method. In source code, a fixture method
* corresponds to an instance method named one of "setup", "cleanup",
* "setupSpec", "cleanupSpec".
*
* @author Peter Niederwieser
*/
public class FixtureMethod extends Method {
public FixtureMethod(Spec parent, MethodNode code) {
super(parent, code);
}
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/compiler/model/HelperMethod.java 0000664 0000000 0000000 00000001551 12020225233 0033000 0 ustar 00root root 0000000 0000000 /*
* Copyright 2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.compiler.model;
import org.codehaus.groovy.ast.MethodNode;
/**
*
* @author Peter Niederwieser
*/
public class HelperMethod extends Method {
public HelperMethod(Spec parent, MethodNode code) {
super(parent, code);
}
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/compiler/model/ISpecVisitor.java 0000775 0000000 0000000 00000002732 12020225233 0033010 0 ustar 00root root 0000000 0000000 /*
* Copyright 2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.compiler.model;
/**
* @author Peter Niederwieser
*/
public interface ISpecVisitor {
void visitSpec(Spec spec) throws Exception;
void visitSpecAgain(Spec spec) throws Exception;
void visitField(Field field) throws Exception;
void visitMethod(Method method) throws Exception;
void visitMethodAgain(Method method) throws Exception;
void visitAnyBlock(Block block) throws Exception;
void visitAnonymousBlock(AnonymousBlock block) throws Exception;
void visitSetupBlock(SetupBlock block) throws Exception;
void visitExpectBlock(ExpectBlock block) throws Exception;
void visitWhenBlock(WhenBlock block) throws Exception;
void visitThenBlock(ThenBlock block) throws Exception;
void visitCleanupBlock(CleanupBlock block) throws Exception;
void visitWhereBlock(WhereBlock block) throws Exception;
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/compiler/model/Method.java 0000775 0000000 0000000 00000005135 12020225233 0031645 0 ustar 00root root 0000000 0000000 /*
* Copyright 2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.compiler.model;
import java.util.*;
import org.codehaus.groovy.ast.MethodNode;
import org.codehaus.groovy.ast.stmt.Statement;
import org.spockframework.compiler.AstUtil;
/**
* AST node representing a Spec method (one of fixture method, feature method, helper method).
*
* @author Peter Niederwieser
*/
public abstract class Method extends Node {
private Block firstBlock;
private Block lastBlock;
public Method(Spec parent, MethodNode code) {
super(parent, code);
setName(code.getName());
}
public Block getFirstBlock() {
return firstBlock;
}
public Block getLastBlock() {
return lastBlock;
}
public List getStatements() {
return AstUtil.getStatements(getAst());
}
public Iterable getBlocks() {
return new BlockIterable(firstBlock);
}
public Block addBlock(Block block) {
if (firstBlock == null)
firstBlock = lastBlock = block;
else {
lastBlock.setNext(block);
block.setPrevious(lastBlock);
lastBlock = block;
}
return block;
}
@Override
public void accept(ISpecVisitor visitor) throws Exception {
visitor.visitMethod(this);
for (Block b: getBlocks()) b.accept(visitor);
visitor.visitMethodAgain(this);
}
}
class BlockIterable implements Iterable {
private final Block first;
BlockIterable(Block first) {
this.first = first;
}
public Iterator iterator() {
return new Iterator() {
Block block = first;
public boolean hasNext() {
return block != null;
}
public Block next() {
if (hasNext()) {
Block result = block;
block = block.getNext();
return result;
} else
throw new NoSuchElementException();
}
public void remove() {
throw new UnsupportedOperationException("remove");
}
};
}
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/compiler/model/Node.java 0000775 0000000 0000000 00000003144 12020225233 0031310 0 ustar 00root root 0000000 0000000 /*
* Copyright 2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.compiler.model;
/**
* Base class for all SpecL AST nodes.
*
* @author Peter Niederwieser
*/
public abstract class Node {
private final P parent;
private A ast;
private String name;
public Node(P parent, A ast) {
this.parent = parent;
this.ast = ast;
}
/**
* The parent of this node.
* @return the parent of this node
*/
public P getParent() {
return parent;
}
/**
* The Groovy AST representation of this node.
* @return the Groovy AST representation of this node
*/
public A getAst() {
return ast;
}
public void setAst(A ast) {
this.ast = ast;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return getClass().getSimpleName() + ": " + name;
}
public abstract void accept(ISpecVisitor visitor) throws Exception;
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/compiler/model/SetupBlock.java 0000775 0000000 0000000 00000002151 12020225233 0032473 0 ustar 00root root 0000000 0000000 /*
* Copyright 2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.compiler.model;
/**
* AST node representing a setup-block in a feature method.
*
* @author Peter Niederwieser
*/
public class SetupBlock extends Block {
public SetupBlock(Method parent) {
super(parent);
}
@Override
public void accept(ISpecVisitor visitor) throws Exception {
visitor.visitAnyBlock(this);
visitor.visitSetupBlock(this);
}
public BlockParseInfo getParseInfo() {
return BlockParseInfo.SETUP;
}
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/compiler/model/Spec.java 0000775 0000000 0000000 00000005712 12020225233 0031320 0 ustar 00root root 0000000 0000000 /*
* Copyright 2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.compiler.model;
import java.util.ArrayList;
import java.util.List;
import org.codehaus.groovy.ast.ClassNode;
/**
* AST node representing a Spock specification. In source
* code, a Spec corresponds to one class definition extends from class Specification.
*
* @author Peter Niederwieser
*/
public class Spec extends Node {
private final List fields = new ArrayList();
private final List methods = new ArrayList();
private FixtureMethod initializerMethod;
private FixtureMethod sharedInitializerMethod;
private FixtureMethod setupMethod;
private FixtureMethod cleanupMethod;
private FixtureMethod setupSpecMethod;
private FixtureMethod cleanupSpecMethod;
public Spec(ClassNode code) {
super(null, code);
setName(code.getName());
}
public List getFields() {
return fields;
}
public List getMethods() {
return methods;
}
public FixtureMethod getInitializerMethod() {
return initializerMethod;
}
public void setInitializerMethod(FixtureMethod method) {
initializerMethod = method;
methods.add(method);
}
public FixtureMethod getSharedInitializerMethod() {
return sharedInitializerMethod;
}
public void setSharedInitializerMethod(FixtureMethod method) {
sharedInitializerMethod = method;
methods.add(method);
}
public FixtureMethod getSetupMethod() {
return setupMethod;
}
public void setSetupMethod(FixtureMethod method) {
setupMethod = method;
methods.add(method);
}
public FixtureMethod getCleanupMethod() {
return cleanupMethod;
}
public void setCleanupMethod(FixtureMethod method) {
cleanupMethod = method;
methods.add(method);
}
public FixtureMethod getSetupSpecMethod() {
return setupSpecMethod;
}
public void setSetupSpecMethod(FixtureMethod method) {
setupSpecMethod = method;
methods.add(method);
}
public FixtureMethod getCleanupSpecMethod() {
return cleanupSpecMethod;
}
public void setCleanupSpecMethod(FixtureMethod method) {
cleanupSpecMethod = method;
methods.add(method);
}
@Override
public void accept(ISpecVisitor visitor) throws Exception {
visitor.visitSpec(this);
for (Field f : fields) f.accept(visitor);
for (Method m : methods) m.accept(visitor);
visitor.visitSpecAgain(this);
}
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/compiler/model/ThenBlock.java 0000775 0000000 0000000 00000002143 12020225233 0032272 0 ustar 00root root 0000000 0000000 /*
* Copyright 2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.compiler.model;
/**
* AST node representing a then-block in a feature method.
*
* @author Peter Niederwieser
*/
public class ThenBlock extends Block {
public ThenBlock(Method parent) {
super(parent);
}
@Override
public void accept(ISpecVisitor visitor) throws Exception {
visitor.visitAnyBlock(this);
visitor.visitThenBlock(this);
}
public BlockParseInfo getParseInfo() {
return BlockParseInfo.THEN;
}
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/compiler/model/WhenBlock.java 0000775 0000000 0000000 00000002276 12020225233 0032304 0 ustar 00root root 0000000 0000000 /*
* Copyright 2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.compiler.model;
/**
* AST node representing a when-block in a feature method.
*
* @author Peter Niederwieser
*/
public class WhenBlock extends Block {
public WhenBlock(Method parent) {
super(parent);
}
@Override
public void accept(ISpecVisitor visitor) throws Exception {
visitor.visitAnyBlock(this);
visitor.visitWhenBlock(this);
}
@Override
public ThenBlock getNext() {
return (ThenBlock)super.getNext();
}
public BlockParseInfo getParseInfo() {
return BlockParseInfo.WHEN;
}
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/compiler/model/WhereBlock.java 0000775 0000000 0000000 00000001773 12020225233 0032456 0 ustar 00root root 0000000 0000000 /*
* Copyright 2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.compiler.model;
public class WhereBlock extends Block {
public WhereBlock(Method parent) {
super(parent);
}
@Override
public void accept(ISpecVisitor visitor) throws Exception {
visitor.visitAnyBlock(this);
visitor.visitWhereBlock(this);
}
public BlockParseInfo getParseInfo() {
return BlockParseInfo.WHERE;
}
} spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/gentyref/ 0000775 0000000 0000000 00000000000 12020225233 0026464 5 ustar 00root root 0000000 0000000 spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/gentyref/CaptureType.java 0000664 0000000 0000000 00000002150 12020225233 0031572 0 ustar 00root root 0000000 0000000 package org.spockframework.gentyref;
import java.lang.reflect.Type;
import java.lang.reflect.WildcardType;
/**
* CaptureType represents a wildcard that has gone through capture conversion.
* It is a custom subinterface of Type, not part of the java builtin Type hierarchy.
*
* @author Wouter Coekaerts
*/
public interface CaptureType extends Type {
/**
* Returns an array of Type objects representing the upper
* bound(s) of this capture. This includes both the upper bound of a ? extends wildcard,
* and the bounds declared with the type variable.
* References to other (or the same) type variables in bounds coming from the type variable are
* replaced by their matching capture.
*/
Type[] getUpperBounds();
/**
* Returns an array of Type objects representing the
* lower bound(s) of this type variable. This is the bound of a ? super wildcard.
* This normally contains only one or no types; it is an array for consistency with {@link WildcardType#getLowerBounds()}.
*/
Type[] getLowerBounds();
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/gentyref/CaptureTypeImpl.java 0000664 0000000 0000000 00000003774 12020225233 0032431 0 ustar 00root root 0000000 0000000 package org.spockframework.gentyref;
import java.lang.reflect.Type;
import java.lang.reflect.TypeVariable;
import java.lang.reflect.WildcardType;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
class CaptureTypeImpl implements CaptureType {
private final WildcardType wildcard;
private final TypeVariable variable;
private final Type[] lowerBounds;
private Type[] upperBounds;
/**
* Creates an uninitialized CaptureTypeImpl. Before using this type, {@link #init(VarMap)} must be called.
* @param wildcard The wildcard this is a capture of
* @param variable The type variable where the wildcard is a parameter for.
*/
public CaptureTypeImpl(WildcardType wildcard, TypeVariable variable) {
this.wildcard = wildcard;
this.variable = variable;
this.lowerBounds = wildcard.getLowerBounds();
}
/**
* Initialize this CaptureTypeImpl.
* This is needed for type variable bounds referring to each other: we need the capture of the argument.
*/
void init(VarMap varMap) {
ArrayList upperBoundsList = new ArrayList();
upperBoundsList.addAll(Arrays.asList(varMap.map(variable.getBounds())));
List wildcardUpperBounds = Arrays.asList(wildcard.getUpperBounds());
if (wildcardUpperBounds.size() > 0 && wildcardUpperBounds.get(0) == Object.class) {
// skip the Object bound, we already have a first upper bound from 'variable'
upperBoundsList.addAll(wildcardUpperBounds.subList(1, wildcardUpperBounds.size()));
} else {
upperBoundsList.addAll(wildcardUpperBounds);
}
upperBounds = new Type[upperBoundsList.size()];
upperBoundsList.toArray(upperBounds);
}
/*
* @see com.googlecode.gentyref.CaptureType#getLowerBounds()
*/
public Type[] getLowerBounds() {
return lowerBounds.clone();
}
/*
* @see com.googlecode.gentyref.CaptureType#getUpperBounds()
*/
public Type[] getUpperBounds() {
assert upperBounds != null;
return upperBounds.clone();
}
@Override
public String toString() {
return "capture of " + wildcard;
}
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/gentyref/GenericArrayTypeImpl.java 0000664 0000000 0000000 00000002235 12020225233 0033370 0 ustar 00root root 0000000 0000000 package org.spockframework.gentyref;
import java.lang.reflect.Array;
import java.lang.reflect.GenericArrayType;
import java.lang.reflect.Type;
class GenericArrayTypeImpl implements GenericArrayType {
private Type componentType;
static Class createArrayType(Class componentType) {
// there's no (clean) other way to create a array class, then create an instance of it
return Array.newInstance(componentType, 0).getClass();
}
static Type createArrayType(Type componentType) {
if (componentType instanceof Class) {
return createArrayType((Class)componentType);
} else {
return new GenericArrayTypeImpl(componentType);
}
}
private GenericArrayTypeImpl(Type componentType) {
super();
this.componentType = componentType;
}
public Type getGenericComponentType() {
return componentType;
}
@Override
public boolean equals(Object obj) {
if (!(obj instanceof GenericArrayType))
return false;
return componentType.equals(((GenericArrayType)obj).getGenericComponentType());
}
@Override
public int hashCode() {
return componentType.hashCode() * 7;
}
@Override
public String toString() {
return componentType + "[]";
}
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/gentyref/GenericTypeReflector.java 0000664 0000000 0000000 00000042012 12020225233 0033412 0 ustar 00root root 0000000 0000000 package org.spockframework.gentyref;
import java.io.Serializable;
import java.lang.reflect.Field;
import java.lang.reflect.GenericArrayType;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.lang.reflect.TypeVariable;
import java.lang.reflect.WildcardType;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;
/**
* Utility class for doing reflection on types.
*
* @author Wouter Coekaerts
*/
public class GenericTypeReflector {
private static final Type UNBOUND_WILDCARD = new WildcardTypeImpl(new Type[]{Object.class}, new Type[]{});
/**
* Returns the erasure of the given type.
*/
public static Class erase(Type type) {
if (type instanceof Class) {
return (Class)type;
} else if (type instanceof ParameterizedType) {
return (Class)((ParameterizedType) type).getRawType();
} else if (type instanceof TypeVariable) {
TypeVariable tv = (TypeVariable)type;
if (tv.getBounds().length == 0)
return Object.class;
else
return erase(tv.getBounds()[0]);
} else if (type instanceof GenericArrayType) {
GenericArrayType aType = (GenericArrayType) type;
return GenericArrayTypeImpl.createArrayType(erase(aType.getGenericComponentType()));
} else {
// TODO at least support CaptureType here
throw new RuntimeException("not supported: " + type.getClass());
}
}
/**
* Maps type parameters in a type to their values.
* @param toMapType Type possibly containing type arguments
* @param typeAndParams must be either ParameterizedType, or (in case there are no type arguments, or it's a raw type) Class
* @return toMapType, but with type parameters from typeAndParams replaced.
*/
private static Type mapTypeParameters(Type toMapType, Type typeAndParams) {
if (isMissingTypeParameters(typeAndParams)) {
return erase(toMapType);
} else {
VarMap varMap = new VarMap();
Type handlingTypeAndParams = typeAndParams;
while(handlingTypeAndParams instanceof ParameterizedType) {
ParameterizedType pType = (ParameterizedType)handlingTypeAndParams;
Class clazz = (Class)pType.getRawType(); // getRawType should always be Class
varMap.addAll(clazz.getTypeParameters(), pType.getActualTypeArguments());
handlingTypeAndParams = pType.getOwnerType();
}
return varMap.map(toMapType);
}
}
/**
* Checks if the given type is a class that is supposed to have type parameters, but doesn't.
* In other words, if it's a really raw type.
*/
private static boolean isMissingTypeParameters(Type type) {
if (type instanceof Class) {
for (Class clazz = (Class) type; clazz != null; clazz = clazz.getEnclosingClass()) {
if (clazz.getTypeParameters().length != 0)
return true;
}
return false;
} else if (type instanceof ParameterizedType) {
return false;
} else {
throw new AssertionError("Unexpected type " + type.getClass());
}
}
/**
* Returns a type representing the class, with all type parameters the unbound wildcard ("?").
* For example, addWildcardParameters(Map.class) returns a type representing Map<?,?> .
* @return
* If clazz is a class or interface without type parameters, clazz itself is returned.
* If clazz is a class or interface with type parameters, an instance of ParameterizedType is returned.
* if clazz is an array type, an array type is returned with unbound wildcard parameters added in the the component type.
*
*/
public static Type addWildcardParameters(Class clazz) {
if (clazz.isArray()) {
return GenericArrayTypeImpl.createArrayType(addWildcardParameters(clazz.getComponentType()));
} else if (isMissingTypeParameters(clazz)) {
TypeVariable[] vars = clazz.getTypeParameters();
Type[] arguments = new Type[vars.length];
Arrays.fill(arguments, UNBOUND_WILDCARD);
Type owner = clazz.getDeclaringClass() == null ? null : addWildcardParameters(clazz.getDeclaringClass());
return new ParameterizedTypeImpl(clazz, arguments, owner);
} else {
return clazz;
}
}
/**
* With type a supertype of searchClass, returns the exact supertype of the given class, including type parameters.
* For example, with class StringList implements List<String> , getExactSuperType(StringList.class, Collection.class)
* returns a {@link ParameterizedType} representing Collection<String> .
*
* Returns null if searchClass is not a superclass of type.
* Returns an instance of {@link Class} if type if it is a raw type, or has no type parameters
* Returns an instance of {@link ParameterizedType} if the type does have parameters
* Returns an instance of {@link GenericArrayType} if searchClass is an array type, and the actual type has type parameters
*
*/
public static Type getExactSuperType(Type type, Class searchClass) {
if (type instanceof ParameterizedType || type instanceof Class || type instanceof GenericArrayType) {
Class clazz = erase(type);
if (searchClass == clazz) {
return type;
}
if (! searchClass.isAssignableFrom(clazz))
return null;
}
for (Type superType: getExactDirectSuperTypes(type)) {
Type result = getExactSuperType(superType, searchClass);
if (result != null)
return result;
}
return null;
}
/**
* Gets the type parameter for a given type that is the value for a given type variable.
* For example, with class StringList implements List<String> ,
* getTypeParameter(StringList.class, Collection.class.getTypeParameters()[0])
* returns String .
*
* @param type The type to inspect.
* @param variable The type variable to find the value for.
* @return The type parameter for the given variable. Or null if type is not a subtype of the
* type that declares the variable, or if the variable isn't known (because of raw types).
*/
public static Type getTypeParameter(Type type, TypeVariable> variable) {
Class clazz = variable.getGenericDeclaration();
Type superType = getExactSuperType(type, clazz);
if (superType instanceof ParameterizedType) {
int index = Arrays.asList(clazz.getTypeParameters()).indexOf(variable);
return ((ParameterizedType)superType).getActualTypeArguments()[index];
} else {
return null;
}
}
/**
* Checks if the capture of subType is a subtype of superType
*/
public static boolean isSuperType(Type superType, Type subType) {
if (superType instanceof ParameterizedType || superType instanceof Class || superType instanceof GenericArrayType) {
Class superClass = erase(superType);
Type mappedSubType = getExactSuperType(capture(subType), superClass);
if (mappedSubType == null) {
return false;
} else if (superType instanceof Class) {
return true;
} else if (mappedSubType instanceof Class) {
// TODO treat supertype by being raw type differently ("supertype, but with warnings")
return true; // class has no parameters, or it's a raw type
} else if (mappedSubType instanceof GenericArrayType) {
Type superComponentType = getArrayComponentType(superType);
assert superComponentType != null;
Type mappedSubComponentType = getArrayComponentType(mappedSubType);
assert mappedSubComponentType != null;
return isSuperType(superComponentType, mappedSubComponentType);
} else {
assert mappedSubType instanceof ParameterizedType;
ParameterizedType pMappedSubType = (ParameterizedType) mappedSubType;
assert pMappedSubType.getRawType() == superClass;
ParameterizedType pSuperType = (ParameterizedType)superType;
Type[] superTypeArgs = pSuperType.getActualTypeArguments();
Type[] subTypeArgs = pMappedSubType.getActualTypeArguments();
assert superTypeArgs.length == subTypeArgs.length;
for (int i = 0; i < superTypeArgs.length; i++) {
if (! contains(superTypeArgs[i], subTypeArgs[i])) {
return false;
}
}
// params of the class itself match, so if the owner types are supertypes too, it's a supertype.
return pSuperType.getOwnerType() == null || isSuperType(pSuperType.getOwnerType(), pMappedSubType.getOwnerType());
}
} else if (superType instanceof CaptureType) {
if (superType.equals(subType))
return true;
for (Type lowerBound : ((CaptureType) superType).getLowerBounds()) {
if (isSuperType(lowerBound, subType)) {
return true;
}
}
return false;
} else if (superType instanceof GenericArrayType) {
return isArraySupertype(superType, subType);
} else {
throw new RuntimeException("not implemented: " + superType.getClass());
}
}
private static boolean isArraySupertype(Type arraySuperType, Type subType) {
Type superTypeComponent = getArrayComponentType(arraySuperType);
assert superTypeComponent != null;
Type subTypeComponent = getArrayComponentType(subType);
if (subTypeComponent == null) { // subType is not an array type
return false;
} else {
return isSuperType(superTypeComponent, subTypeComponent);
}
}
/**
* If type is an array type, returns the type of the component of the array.
* Otherwise, returns null.
*/
public static Type getArrayComponentType(Type type) {
if (type instanceof Class) {
Class clazz = (Class)type;
return clazz.getComponentType();
} else if (type instanceof GenericArrayType) {
GenericArrayType aType = (GenericArrayType) type;
return aType.getGenericComponentType();
} else {
return null;
}
}
private static boolean contains(Type containingType, Type containedType) {
if (containingType instanceof WildcardType) {
WildcardType wContainingType = (WildcardType)containingType;
for (Type upperBound : wContainingType.getUpperBounds()) {
if (! isSuperType(upperBound, containedType)) {
return false;
}
}
for (Type lowerBound : wContainingType.getLowerBounds()) {
if (! isSuperType(containedType, lowerBound)) {
return false;
}
}
return true;
} else {
return containingType.equals(containedType);
}
}
/**
* Returns the direct supertypes of the given type. Resolves type parameters.
*/
private static Type[] getExactDirectSuperTypes(Type type) {
if (type instanceof ParameterizedType || type instanceof Class) {
Class clazz;
if (type instanceof ParameterizedType) {
clazz = (Class)((ParameterizedType)type).getRawType();
} else {
// TODO primitive types?
clazz = (Class)type;
if (clazz.isArray())
return getArrayExactDirectSuperTypes(clazz);
}
Type[] superInterfaces = clazz.getGenericInterfaces();
Type superClass = clazz.getGenericSuperclass();
Type[] result;
int resultIndex;
if (superClass == null) {
result = new Type[superInterfaces.length];
resultIndex = 0;
} else {
result = new Type[superInterfaces.length + 1];
resultIndex = 1;
result[0] = mapTypeParameters(superClass, type);
}
for (Type superInterface : superInterfaces) {
result[resultIndex++] = mapTypeParameters(superInterface, type);
}
return result;
} else if (type instanceof TypeVariable) {
TypeVariable tv = (TypeVariable) type;
return tv.getBounds();
} else if (type instanceof WildcardType) {
// This should be a rare case: normally this wildcard is already captured.
// But it does happen if the upper bound of a type variable contains a wildcard
// TODO shouldn't upper bound of type variable have been captured too? (making this case impossible?)
return ((WildcardType) type).getUpperBounds();
} else if (type instanceof CaptureType) {
return ((CaptureType)type).getUpperBounds();
} else if (type instanceof GenericArrayType) {
return getArrayExactDirectSuperTypes(type);
} else {
throw new RuntimeException("not implemented type: " + type);
}
}
private static Type[] getArrayExactDirectSuperTypes(Type arrayType) {
// see http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.10.3
Type typeComponent = getArrayComponentType(arrayType);
Type[] result;
int resultIndex;
if (typeComponent instanceof Class && ((Class)typeComponent).isPrimitive()) {
resultIndex = 0;
result = new Type[3];
} else {
Type[] componentSupertypes = getExactDirectSuperTypes(typeComponent);
result = new Type[componentSupertypes.length + 3];
for (resultIndex = 0; resultIndex < componentSupertypes.length; resultIndex++) {
result[resultIndex] = GenericArrayTypeImpl.createArrayType(componentSupertypes[resultIndex]);
}
}
result[resultIndex++] = Object.class;
result[resultIndex++] = Cloneable.class;
result[resultIndex++] = Serializable.class;
return result;
}
public static Type[] getExactParameterTypes(Method m, Type type) {
Type[] parameterTypes = m.getGenericParameterTypes();
Type exactDeclaringType = getExactSuperType(capture(type), m.getDeclaringClass());
Type[] result = new Type[parameterTypes.length];
for (int i = 0; i < parameterTypes.length; i++) {
result[i] = mapTypeParameters(parameterTypes[i], exactDeclaringType);
}
return result;
}
/**
* Returns the exact return type of the given method in the given type.
* This may be different from m.getGenericReturnType() when the method was declared in a superclass,
* of type is a raw type.
*/
public static Type getExactReturnType(Method m, Type type) {
Type returnType = m.getGenericReturnType();
Type exactDeclaringType = getExactSuperType(capture(type), m.getDeclaringClass());
return mapTypeParameters(returnType, exactDeclaringType);
}
/**
* Returns the exact type of the given field in the given type.
* This may be different from f.getGenericType() when the field was declared in a superclass,
* of type is a raw type.
*/
public static Type getExactFieldType(Field f, Type type) {
Type returnType = f.getGenericType();
Type exactDeclaringType = getExactSuperType(capture(type), f.getDeclaringClass());
return mapTypeParameters(returnType, exactDeclaringType);
}
/**
* Applies capture conversion to the given type.
*/
public static Type capture(Type type) {
VarMap varMap = new VarMap();
List toInit = new ArrayList();
if (type instanceof ParameterizedType) {
ParameterizedType pType = (ParameterizedType)type;
Class clazz = (Class)pType.getRawType();
Type[] arguments = pType.getActualTypeArguments();
TypeVariable[] vars = clazz.getTypeParameters();
Type[] capturedArguments = new Type[arguments.length];
assert arguments.length == vars.length;
for (int i = 0; i < arguments.length; i++) {
Type argument = arguments[i];
if (argument instanceof WildcardType) {
CaptureTypeImpl captured = new CaptureTypeImpl((WildcardType)argument, vars[i]);
argument = captured;
toInit.add(captured);
}
capturedArguments[i] = argument;
varMap.add(vars[i], argument);
}
for (CaptureTypeImpl captured : toInit) {
captured.init(varMap);
}
Type ownerType = (pType.getOwnerType() == null) ? null : capture(pType.getOwnerType());
return new ParameterizedTypeImpl(clazz, capturedArguments, ownerType);
} else {
return type;
}
}
/**
* Returns the display name of a Type.
*/
public static String getTypeName(Type type) {
if(type instanceof Class) {
Class clazz = (Class) type;
return clazz.isArray() ? (getTypeName(clazz.getComponentType()) + "[]") : clazz.getName();
} else {
return type.toString();
}
}
/**
* Returns list of classes and interfaces that are supertypes of the given type.
* For example given this class:
* class Foo<A extends Number & Iterable<A>, B extends A> B (Foo.class.getTypeParameters()[1] )
* returns a list containing Number and Iterable .
*
* This is mostly useful if you get a type from one of the other methods in GenericTypeReflector ,
* but you don't want to deal with all the different sorts of types,
* and you are only really interested in concrete classes and interfaces.
*
*
* @return A List of classes, each of them a supertype of the given type.
* If the given type is a class or interface itself, returns a List with just the given type.
* The list contains no duplicates, and is ordered in the order the upper bounds are defined on the type.
*/
public static List> getUpperBoundClassAndInterfaces(Type type) {
LinkedHashSet> result = new LinkedHashSet>();
buildUpperBoundClassAndInterfaces(type, result);
return new ArrayList>(result);
}
/**
* Helper method for getUpperBoundClassAndInterfaces, adding the result to the given set.
*/
private static void buildUpperBoundClassAndInterfaces(Type type, Set> result) {
if (type instanceof ParameterizedType || type instanceof Class) {
result.add(erase(type));
return;
}
for (Type superType: getExactDirectSuperTypes(type)) {
buildUpperBoundClassAndInterfaces(superType, result);
}
}
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/gentyref/ParameterizedTypeImpl.java0000664 0000000 0000000 00000004047 12020225233 0033614 0 ustar 00root root 0000000 0000000 package org.spockframework.gentyref;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.Arrays;
class ParameterizedTypeImpl implements ParameterizedType {
private final Class rawType;
private final Type[] actualTypeArguments;
private final Type ownerType;
public ParameterizedTypeImpl(Class rawType, Type[] actualTypeArguments, Type ownerType) {
this.rawType = rawType;
this.actualTypeArguments = actualTypeArguments;
this.ownerType = ownerType;
}
public Type getRawType() {
return rawType;
}
public Type[] getActualTypeArguments() {
return actualTypeArguments;
}
public Type getOwnerType() {
return ownerType;
}
@Override
public boolean equals(Object obj) {
if (!(obj instanceof ParameterizedType))
return false;
ParameterizedType other = (ParameterizedType) obj;
return rawType.equals(other.getRawType())
&& Arrays.equals(actualTypeArguments, other.getActualTypeArguments())
&& (ownerType == null ? other.getOwnerType() == null : ownerType.equals(other.getOwnerType()));
}
@Override
public int hashCode() {
int result = rawType.hashCode() ^ Arrays.hashCode(actualTypeArguments);
if (ownerType != null)
result ^= ownerType.hashCode();
return result;
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
String clazz = rawType.getName();
if (ownerType != null) {
sb.append(GenericTypeReflector.getTypeName(ownerType)).append('.');
String prefix = (ownerType instanceof ParameterizedType) ? ((Class)((ParameterizedType)ownerType).getRawType()).getName() + '$'
: ((Class)ownerType).getName() + '$';
if (clazz.startsWith(prefix))
clazz = clazz.substring(prefix.length());
}
sb.append(clazz);
if(actualTypeArguments.length != 0) {
sb.append('<');
for (int i = 0; i < actualTypeArguments.length; i++) {
Type arg = actualTypeArguments[i];
if (i != 0)
sb.append(", ");
sb.append(GenericTypeReflector.getTypeName(arg));
}
sb.append('>');
}
return sb.toString();
}
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/gentyref/TypeToken.java 0000664 0000000 0000000 00000003517 12020225233 0031257 0 ustar 00root root 0000000 0000000 package org.spockframework.gentyref;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
/**
* Wrapper around {@link Type}.
*
* You can use this to create instances of Type for a type known at compile
* time.
*
* For example, to get the Type that represents List<String>:
* Type listOfString = new TypeToken<List<String>>(){}.getType();
*
* @author Wouter Coekaerts
*
* @param
* The type represented by this TypeToken.
*/
public abstract class TypeToken {
private final Type type;
/**
* Constructs a type token.
*/
protected TypeToken() {
this.type = extractType();
}
private TypeToken(Type type) {
this.type = type;
}
public Type getType() {
return type;
}
private Type extractType() {
Type t = getClass().getGenericSuperclass();
if (!(t instanceof ParameterizedType)) {
throw new RuntimeException("Invalid TypeToken; must specify type parameters");
}
ParameterizedType pt = (ParameterizedType) t;
if (pt.getRawType() != TypeToken.class) {
throw new RuntimeException("Invalid TypeToken; must directly extend TypeToken");
}
return pt.getActualTypeArguments()[0];
}
/**
* Gets type token for the given {@code Class} instance.
*/
public static TypeToken get(Class type) {
return new SimpleTypeToken(type);
}
/**
* Gets type token for the given {@code Type} instance.
*/
public static TypeToken get(Type type) {
return new SimpleTypeToken(type);
}
private static class SimpleTypeToken extends TypeToken {
public SimpleTypeToken(Type type) {
super(type);
}
}
@Override
public boolean equals(Object obj) {
return (obj instanceof TypeToken) && type.equals(((TypeToken) obj).type);
}
@Override
public int hashCode() {
return type.hashCode();
}
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/gentyref/VarMap.java 0000664 0000000 0000000 00000003746 12020225233 0030527 0 ustar 00root root 0000000 0000000 /**
*
*/
package org.spockframework.gentyref;
import java.lang.reflect.GenericArrayType;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.lang.reflect.TypeVariable;
import java.lang.reflect.WildcardType;
import java.util.HashMap;
import java.util.Map;
/**
* Mapping between type variables and actual parameters.
*
* @author Wouter Coekaerts
*/
class VarMap {
private final Map, Type> map = new HashMap, Type>();
/**
* Creates an empty VarMap
*/
VarMap() {
}
void add(TypeVariable variable, Type value) {
map.put(variable, value);
}
void addAll(TypeVariable[] variables, Type[] values) {
assert variables.length == values.length;
for (int i = 0; i < variables.length; i++) {
map.put(variables[i], values[i]);
}
}
VarMap(TypeVariable[] variables, Type[] values) {
addAll(variables, values);
}
Type map(Type type) {
if (type instanceof Class) {
return type;
} else if (type instanceof TypeVariable) {
assert map.containsKey(type);
return map.get(type);
} else if (type instanceof ParameterizedType) {
ParameterizedType pType = (ParameterizedType) type;
return new ParameterizedTypeImpl((Class)pType.getRawType(), map(pType.getActualTypeArguments()), pType.getOwnerType() == null ? pType.getOwnerType() : map(pType.getOwnerType()));
} else if (type instanceof WildcardType) {
WildcardType wType = (WildcardType) type;
return new WildcardTypeImpl(map(wType.getUpperBounds()), map(wType.getLowerBounds()));
} else if (type instanceof GenericArrayType) {
return GenericArrayTypeImpl.createArrayType(map(((GenericArrayType)type).getGenericComponentType()));
} else {
throw new RuntimeException("not implemented: mapping " + type.getClass() + " (" + type + ")");
}
}
Type[] map(Type[] types) {
Type[] result = new Type[types.length];
for (int i = 0; i < types.length; i++) {
result[i] = map(types[i]);
}
return result;
}
} spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/gentyref/WildcardTypeImpl.java 0000664 0000000 0000000 00000002564 12020225233 0032553 0 ustar 00root root 0000000 0000000 /**
*
*/
package org.spockframework.gentyref;
import java.lang.reflect.Type;
import java.lang.reflect.WildcardType;
import java.util.Arrays;
class WildcardTypeImpl implements WildcardType {
private final Type[] upperBounds;
private final Type[] lowerBounds;
public WildcardTypeImpl(Type[] upperBounds, Type[] lowerBounds) {
if (upperBounds.length == 0)
throw new IllegalArgumentException("There must be at least one upper bound. For an unbound wildcard, the upper bound must be Object");
this.upperBounds = upperBounds;
this.lowerBounds = lowerBounds;
}
public Type[] getUpperBounds() {
return upperBounds.clone();
}
public Type[] getLowerBounds() {
return lowerBounds.clone();
}
@Override
public boolean equals(Object obj) {
if (! (obj instanceof WildcardType))
return false;
WildcardType other = (WildcardType)obj;
return Arrays.equals(lowerBounds, other.getLowerBounds())
&& Arrays.equals(upperBounds, other.getUpperBounds());
}
@Override
public int hashCode() {
return Arrays.hashCode(lowerBounds) ^ Arrays.hashCode(upperBounds);
}
@Override
public String toString() {
if (lowerBounds.length > 0) {
return "? super " + GenericTypeReflector.getTypeName(lowerBounds[0]);
} else if (upperBounds[0] == Object.class) {
return "?";
} else {
return "? extends " + GenericTypeReflector.getTypeName(upperBounds[0]);
}
}
} spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/lang/ 0000775 0000000 0000000 00000000000 12020225233 0025562 5 ustar 00root root 0000000 0000000 spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/lang/SpreadWildcard.java 0000664 0000000 0000000 00000001507 12020225233 0031320 0 ustar 00root root 0000000 0000000 /*
* Copyright 2011 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* http://www.apache.org/licenses/LICENSE-2.0
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.lang;
public class SpreadWildcard {
public static final SpreadWildcard INSTANCE = new SpreadWildcard();
private SpreadWildcard() {}
@Override
public String toString() {
return "*_";
}
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/lang/Wildcard.java 0000664 0000000 0000000 00000002420 12020225233 0030154 0 ustar 00root root 0000000 0000000 /*
* Copyright 2011 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* http://www.apache.org/licenses/LICENSE-2.0
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.lang;
import java.util.AbstractList;
// make it List rather than List
// because IDE type inference might like this better
public class Wildcard extends AbstractList {
public static final Wildcard INSTANCE = new Wildcard();
private Wildcard() {}
@Override
public Object get(int index) {
if (index != 0) throw new IndexOutOfBoundsException("Wildcard.INSTANCE only has a single element");
return SpreadWildcard.INSTANCE;
}
@Override
public int size() {
return 1;
}
@Override
public String toString() {
return "_"; // both compiler and runtime sometimes need String representation
}
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/mock/ 0000775 0000000 0000000 00000000000 12020225233 0025572 5 ustar 00root root 0000000 0000000 spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/mock/CannotCreateMockException.java0000775 0000000 0000000 00000002312 12020225233 0033475 0 ustar 00root root 0000000 0000000 /*
* Copyright 2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.mock;
/**
* Thrown when an attempt to create a mock object fails.
*
* @author Peter Niederwieser
*/
// IDEA: filter stack trace so that the top entry is the point of mock declaration
public class CannotCreateMockException extends RuntimeException {
public CannotCreateMockException(Class mockType, String msg) {
super(String.format("Cannot create mock for %s because %s", mockType.getName(), msg));
}
public CannotCreateMockException(Class mockType, Throwable cause) {
super(String.format("Cannot create mock for %s.", mockType.getName()), cause);
}
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/mock/CodeArgumentConstraint.java 0000775 0000000 0000000 00000002156 12020225233 0033066 0 ustar 00root root 0000000 0000000 /*
* Copyright 2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.mock;
import org.spockframework.util.GroovyRuntimeUtil;
import groovy.lang.Closure;
/**
*
* @author Peter Niederwieser
*/
// IDEA: reify instead of separate matcher?
public class CodeArgumentConstraint implements IArgumentConstraint {
private final Closure code;
public CodeArgumentConstraint(Closure code) {
this.code = code;
}
public boolean isSatisfiedBy(Object argument) {
return GroovyRuntimeUtil.isTruthy(GroovyRuntimeUtil.invokeClosure(code, argument));
}
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/mock/CodeResultGenerator.java 0000775 0000000 0000000 00000003170 12020225233 0032361 0 ustar 00root root 0000000 0000000 /*
* Copyright 2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.mock;
import org.spockframework.util.GroovyRuntimeUtil;
import groovy.lang.Closure;
/**
*
* @author Peter Niederwieser
*/
public class CodeResultGenerator extends SingleResultGenerator {
private final Closure code;
private final boolean provideExtendedInfo;
public CodeResultGenerator(Closure code) {
this.code = code;
Class[] paramTypes = code.getParameterTypes();
provideExtendedInfo = paramTypes.length == 1 && paramTypes[0] == IMockInvocation.class;
}
public Object generateSingle(IMockInvocation invocation) {
Object result = GroovyRuntimeUtil.invokeClosure(code, provideExtendedInfo ? invocation : invocation.getArguments());
Class returnType = invocation.getMethod().getReturnType();
// don't attempt cast for void methods (closure could be an action that accidentally returns a value)
if (returnType == void.class || returnType == Void.class) return null;
return GroovyRuntimeUtil.coerce(result, invocation.getMethod().getReturnType());
}
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/mock/ConstantResultGenerator.java 0000775 0000000 0000000 00000002076 12020225233 0033304 0 ustar 00root root 0000000 0000000 /*
* Copyright 2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.mock;
import org.spockframework.util.GroovyRuntimeUtil;
/**
*
* @author Peter Niederwieser
*/
public class ConstantResultGenerator extends SingleResultGenerator {
private final Object constant;
public ConstantResultGenerator(Object constant) {
this.constant = constant;
}
public Object generateSingle(IMockInvocation invocation) {
return GroovyRuntimeUtil.coerce(constant, invocation.getMethod().getReturnType());
}
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/mock/DefaultEqualsInteraction.java 0000664 0000000 0000000 00000002520 12020225233 0033373 0 ustar 00root root 0000000 0000000 /*
* Copyright 2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* http://www.apache.org/licenses/LICENSE-2.0
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.mock;
import java.lang.reflect.Method;
public class DefaultEqualsInteraction extends DefaultInteraction {
public static final DefaultEqualsInteraction INSTANCE = new DefaultEqualsInteraction();
private DefaultEqualsInteraction() {}
public String getText() {
return "default equals() interaction";
}
public boolean matches(IMockInvocation invocation) {
Method method = invocation.getMethod();
return method.getName().equals("equals")
&& method.getParameterTypes().length == 1
&& method.getParameterTypes()[0] == Object.class;
}
public Object accept(IMockInvocation invocation) {
return invocation.getMockObject().getInstance() == invocation.getArguments().get(0);
}
}
DefaultHashCodeInteraction.java 0000664 0000000 0000000 00000002347 12020225233 0033547 0 ustar 00root root 0000000 0000000 spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/mock /*
* Copyright 2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* http://www.apache.org/licenses/LICENSE-2.0
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.mock;
public class DefaultHashCodeInteraction extends DefaultInteraction {
public static final DefaultHashCodeInteraction INSTANCE = new DefaultHashCodeInteraction();
private DefaultHashCodeInteraction() {}
public String getText() {
return "default hashCode() interaction";
}
public boolean matches(IMockInvocation invocation) {
return invocation.getMethod().getName().equals("hashCode")
&& invocation.getMethod().getParameterTypes().length == 0;
}
public Object accept(IMockInvocation invocation) {
return System.identityHashCode(invocation.getMockObject().getInstance());
}
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/mock/DefaultInteraction.java 0000664 0000000 0000000 00000001626 12020225233 0032226 0 ustar 00root root 0000000 0000000 /*
* Copyright 2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* http://www.apache.org/licenses/LICENSE-2.0
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.mock;
public abstract class DefaultInteraction implements IMockInteraction {
public int getLine() {
return -1;
}
public int getColumn() {
return -1;
}
public boolean isSatisfied() {
return true;
}
public boolean isExhausted() {
return false;
}
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/mock/DefaultInteractionScope.java 0000664 0000000 0000000 00000003255 12020225233 0033220 0 ustar 00root root 0000000 0000000 /*
* Copyright 2010 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* http://www.apache.org/licenses/LICENSE-2.0
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.mock;
import java.util.Arrays;
import java.util.List;
import org.spockframework.util.UnreachableCodeError;
public class DefaultInteractionScope implements IInteractionScope {
public static final DefaultInteractionScope INSTANCE = new DefaultInteractionScope();
private DefaultInteractionScope() {}
private final List interactions = Arrays.asList(
DefaultEqualsInteraction.INSTANCE, DefaultHashCodeInteraction.INSTANCE,
DefaultToStringInteraction.INSTANCE, DefaultStubbedInteraction.INSTANCE);
public void addInteraction(IMockInteraction interaction) {
throw new UnreachableCodeError("addInteraction");
}
public void addOrderingBarrier() {
throw new UnreachableCodeError("addOrderingBarrier()");
}
public IMockInteraction match(IMockInvocation invocation) {
for (IMockInteraction interaction : interactions)
if (interaction.matches(invocation))
return interaction;
return null;
}
public void verifyInteractions() {
throw new UnreachableCodeError("verifyInteractions");
}
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/mock/DefaultMockFactory.java 0000664 0000000 0000000 00000011775 12020225233 0032176 0 ustar 00root root 0000000 0000000 /*
* Copyright 2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.mock;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.*;
import java.lang.reflect.Proxy;
import java.util.*;
import org.objenesis.*;
import net.sf.cglib.proxy.*;
import groovy.lang.*;
import org.spockframework.util.*;
/**
*
* Some implementation details of this class are stolen from Spring, EasyMock
* Class Extensions, and this thread:
* http://www.nabble.com/Callbacks%2C-classes-and-instances-to4092596.html
*
* @author Peter Niederwieser
*/
public class DefaultMockFactory implements IMockFactory {
public static final String INSTANCE_FIELD = "INSTANCE";
public static final DefaultMockFactory INSTANCE = new DefaultMockFactory();
private static final boolean cglibAvailable = ReflectionUtil.isClassAvailable("net.sf.cglib.proxy.Enhancer");
private static final boolean objenesisAvailable = ReflectionUtil.isClassAvailable("org.objenesis.Objenesis");
public Object create(String mockName, Class mockType, IInvocationDispatcher dispatcher) {
if (Modifier.isFinal(mockType.getModifiers()))
throw new CannotCreateMockException(mockType, "mocking final classes is not supported.");
if (mockType.isInterface())
return createDynamicProxyMock(mockName, mockType, dispatcher);
if (cglibAvailable)
return CglibMockFactory.create(mockName, mockType, dispatcher);
throw new CannotCreateMockException(mockType,
"by default, only mocking of interfaces is supported; to allow mocking of classes, put cglib-nodep-2.2 or higher on the classpath."
);
}
private Object createDynamicProxyMock(final String mockName,
final Class mockType, final IInvocationDispatcher dispatcher) {
return Proxy.newProxyInstance(
mockType.getClassLoader(),
new Class[] {mockType},
new InvocationHandler() {
public Object invoke(Object mockInstance, Method method, Object[] args) {
IMockObject mockObject = new MockObject(mockName, mockType, mockInstance);
IMockInvocation invocation = new MockInvocation(mockObject, method, normalizeArgs(args));
return dispatcher.dispatch(invocation);
}
}
);
}
private static List normalizeArgs(Object[] args) {
return args == null ? Collections.emptyList() : Arrays.asList(args);
}
private static class CglibMockFactory {
static Object create(final String mockName, final Class mockType, final IInvocationDispatcher dispatcher) {
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(mockType);
final boolean isGroovyObject = GroovyObject.class.isAssignableFrom(mockType);
MethodInterceptor interceptor = new MethodInterceptor() {
public Object intercept(Object mockInstance, Method method, Object[] args, MethodProxy proxy) {
if (isGroovyObject) {
if (isMethod(method, "getMetaClass", 0))
return GroovySystem.getMetaClassRegistry().getMetaClass(mockInstance.getClass());
}
IMockObject mockObject = new MockObject(mockName, mockType, mockInstance);
IMockInvocation invocation = new MockInvocation(mockObject, method, normalizeArgs(args));
return dispatcher.dispatch(invocation);
}
};
if (objenesisAvailable) {
enhancer.setCallbackType(interceptor.getClass());
Object instance = ObjenesisInstantiator.instantiate(enhancer.createClass());
((Factory)instance).setCallback(0, interceptor);
return instance;
}
try {
enhancer.setCallback(interceptor);
return enhancer.create(); // throws what if no parameterless superclass constructor available?
} catch (Exception e) {
throw new CannotCreateMockException(mockType,
"the latter has no parameterless constructor; to allow mocking of classes without parameterless constructor, put objenesis-1.2 or higher on the classpath."
);
}
}
private static boolean isMethod(Method method, String name, int parameterCount) {
return method.getName().equals(name) && method.getParameterTypes().length == parameterCount;
}
private static class ObjenesisInstantiator {
static final Objenesis objenesis = new ObjenesisStd();
static Object instantiate(Class mockType) {
try {
return objenesis.newInstance(mockType);
} catch (ObjenesisException e) {
throw new CannotCreateMockException(mockType, e);
}
}
}
}
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/mock/DefaultResultGenerator.java 0000775 0000000 0000000 00000002001 12020225233 0033063 0 ustar 00root root 0000000 0000000 /*
* Copyright 2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.mock;
import org.spockframework.util.ReflectionUtil;
/**
* Returns the default value for the invoked method's return type.
*
* @author Peter Niederwieser
*/
public class DefaultResultGenerator extends SingleResultGenerator {
public Object generateSingle(IMockInvocation invocation) {
return ReflectionUtil.getDefaultValue(invocation.getMethod().getReturnType());
}
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/mock/DefaultStubbedInteraction.java0000664 0000000 0000000 00000002244 12020225233 0033534 0 ustar 00root root 0000000 0000000 /*
* Copyright 2010 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* http://www.apache.org/licenses/LICENSE-2.0
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.mock;
import org.spockframework.util.ReflectionUtil;
public class DefaultStubbedInteraction extends DefaultInteraction {
public static final DefaultStubbedInteraction INSTANCE = new DefaultStubbedInteraction();
private DefaultStubbedInteraction() {}
public String getText() {
return "default stubbed interaction";
}
public boolean matches(IMockInvocation invocation) {
return true;
}
public Object accept(IMockInvocation invocation) {
return ReflectionUtil.getDefaultValue(invocation.getMethod().getReturnType());
}
} DefaultToStringInteraction.java 0000664 0000000 0000000 00000003047 12020225233 0033640 0 ustar 00root root 0000000 0000000 spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/mock /*
* Copyright 2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* http://www.apache.org/licenses/LICENSE-2.0
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.mock;
public class DefaultToStringInteraction extends DefaultInteraction {
public static final DefaultToStringInteraction INSTANCE = new DefaultToStringInteraction();
private DefaultToStringInteraction() {}
public String getText() {
return "default toString() interaction";
}
public boolean matches(IMockInvocation invocation) {
return invocation.getMethod().getName().equals("toString")
&& invocation.getMethod().getParameterTypes().length == 0;
}
public Object accept(IMockInvocation invocation) {
StringBuilder builder = new StringBuilder();
builder.append("Mock for type '");
builder.append(invocation.getMockObject().getType().getSimpleName());
builder.append("'");
String name = invocation.getMockObject().getName();
if (name != null) {
builder.append(" named '");
builder.append(name);
builder.append("'");
}
return builder.toString();
}
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/mock/EqualArgumentConstraint.java 0000775 0000000 0000000 00000002253 12020225233 0033261 0 ustar 00root root 0000000 0000000 /*
* Copyright 2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.mock;
import org.spockframework.runtime.HamcrestFacade;
import org.spockframework.util.GroovyRuntimeUtil;
/**
*
* @author Peter Niederwieser
*/
public class EqualArgumentConstraint implements IArgumentConstraint {
private final Object expected;
public EqualArgumentConstraint(Object expected) {
this.expected = expected;
}
public boolean isSatisfiedBy(Object arg) {
if (HamcrestFacade.isMatcher(expected)) {
return HamcrestFacade.matches(expected, arg);
}
return GroovyRuntimeUtil.equals(arg, expected);
}
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/mock/EqualMethodNameConstraint.java0000775 0000000 0000000 00000002003 12020225233 0033511 0 ustar 00root root 0000000 0000000 /*
* Copyright 2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.mock;
/**
*
* @author Peter Niederwieser
*/
public class EqualMethodNameConstraint implements IInvocationConstraint {
private final String methodName;
public EqualMethodNameConstraint(String methodName) {
this.methodName = methodName;
}
public boolean isSatisfiedBy(IMockInvocation invocation) {
return invocation.getMethod().getName().equals(methodName);
}
}
EqualPropertyNameConstraint.java 0000775 0000000 0000000 00000002137 12020225233 0034046 0 ustar 00root root 0000000 0000000 spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/mock /*
* Copyright 2010 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* http://www.apache.org/licenses/LICENSE-2.0
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.mock;
import org.spockframework.util.ReflectionUtil;
/**
*
* @author Peter Niederwieser
*/
public class EqualPropertyNameConstraint implements IInvocationConstraint {
private final String propertyName;
public EqualPropertyNameConstraint(String propertyName) {
this.propertyName = propertyName;
}
public boolean isSatisfiedBy(IMockInvocation invocation) {
return propertyName.equals(ReflectionUtil.getPropertyNameForGetterMethod(invocation.getMethod()));
}
} spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/mock/IArgumentConstraint.java 0000775 0000000 0000000 00000001454 12020225233 0032404 0 ustar 00root root 0000000 0000000 /*
* Copyright 2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.mock;
/**
* A constraint on an invocation argument.
*
* @author Peter Niederwieser
*/
public interface IArgumentConstraint {
boolean isSatisfiedBy(Object arg);
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/mock/IInteractionScope.java 0000664 0000000 0000000 00000001774 12020225233 0032030 0 ustar 00root root 0000000 0000000 /*
* Copyright 2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.mock;
/**
* An interaction scope holds a group of interactions that will be verified,
* and thereafter removed, at the same time.
*
* @author Peter Niederwieser
*/
public interface IInteractionScope {
void addInteraction(IMockInteraction interaction);
void addOrderingBarrier();
IMockInteraction match(IMockInvocation invocation);
void verifyInteractions();
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/mock/IInvocationConstraint.java 0000775 0000000 0000000 00000001423 12020225233 0032727 0 ustar 00root root 0000000 0000000 /*
* Copyright 2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.mock;
/**
*
* @author Peter Niederwieser
*/
public interface IInvocationConstraint {
boolean isSatisfiedBy(IMockInvocation invocation);
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/mock/IInvocationDispatcher.java 0000775 0000000 0000000 00000001415 12020225233 0032672 0 ustar 00root root 0000000 0000000 /*
* Copyright 2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.mock;
/**
*
* @author Peter Niederwieser
*/
public interface IInvocationDispatcher {
Object dispatch(IMockInvocation invocation);
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/mock/IMockFactory.java 0000775 0000000 0000000 00000001515 12020225233 0030774 0 ustar 00root root 0000000 0000000 /*
* Copyright 2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.mock;
/**
*
* @author Peter Niederwieser
*/
public interface IMockFactory {
Object create(String mockName, Class mockType, IInvocationDispatcher dispatcher) throws CannotCreateMockException;
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/mock/IMockInteraction.java 0000775 0000000 0000000 00000001761 12020225233 0031647 0 ustar 00root root 0000000 0000000 /*
* Copyright 2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.mock;
/**
* An anticipated interaction between the SUT and one or more mock objects.
*
* @author Peter Niederwieser
*/
public interface IMockInteraction {
int getLine();
int getColumn();
String getText();
boolean matches(IMockInvocation invocation);
Object accept(IMockInvocation invocation);
boolean isSatisfied();
boolean isExhausted();
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/mock/IMockInvocation.java 0000775 0000000 0000000 00000002452 12020225233 0031477 0 ustar 00root root 0000000 0000000 /*
* Copyright 2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.mock;
import java.lang.reflect.Method;
import java.util.List;
/**
* A method invocation on a mock object.
*
* @author Peter Niederwieser
*/
// IDEA: add method "MockType mockType" that tells which interface or class was mocked,
// the kind of mock involved (dynamic proxy, cglib, etc.), etc.
public interface IMockInvocation {
/**
* The mock object that received the invocation.
*/
IMockObject getMockObject();
/**
* The invoked method.
*/
// IDEA: replace with our own Method abstraction so that we can also
// represent dynamic Groovy calls
Method getMethod();
/**
* The arguments for the invocation.
*/
List getArguments();
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/mock/IMockObject.java 0000664 0000000 0000000 00000001347 12020225233 0030573 0 ustar 00root root 0000000 0000000 /*
* Copyright 2010 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* http://www.apache.org/licenses/LICENSE-2.0
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.mock;
public interface IMockObject {
String getName();
Class getType();
Object getInstance();
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/mock/IResultGenerator.java 0000775 0000000 0000000 00000001535 12020225233 0031702 0 ustar 00root root 0000000 0000000 /*
* Copyright 2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.mock;
/**
* Generates return values for invocations on mock objects.
*
* @author Peter Niederwieser
*/
public interface IResultGenerator {
boolean isExhausted();
Object generate(IMockInvocation invocation);
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/mock/IdenticalTargetConstraint.java0000775 0000000 0000000 00000002040 12020225233 0033544 0 ustar 00root root 0000000 0000000 /*
* Copyright 2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.mock;
/**
*
* @author Peter Niederwieser
*/
// IDEA: check that target actually is a mock
public class IdenticalTargetConstraint implements IInvocationConstraint {
private final Object target;
public IdenticalTargetConstraint(Object target) {
this.target = target;
}
public boolean isSatisfiedBy(IMockInvocation invocation) {
return invocation.getMockObject().getInstance() == target;
}
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/mock/InteractionBuilder.java 0000775 0000000 0000000 00000015412 12020225233 0032231 0 ustar 00root root 0000000 0000000 /*
* Copyright 2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.mock;
import java.util.ArrayList;
import java.util.List;
import groovy.lang.Closure;
import org.spockframework.lang.SpreadWildcard;
import org.spockframework.lang.Wildcard;
import org.spockframework.runtime.InvalidSpecException;
/**
*
* @author Peter Niederwieser
*/
public class InteractionBuilder {
private final int line;
private final int column;
private final String text;
private int minCount = 0;
private int maxCount = Integer.MAX_VALUE;
private List invConstraints = new ArrayList();
private List argNames;
private List argConstraints;
private ResultGeneratorChain resultGenerators = new ResultGeneratorChain();
public InteractionBuilder(int line, int column, String text) {
this.line = line;
this.column = column;
this.text = text;
}
public static final String SET_FIXED_COUNT = "setFixedCount";
public InteractionBuilder setFixedCount(Object count) {
if (count instanceof Wildcard) {
minCount = 0;
maxCount = Integer.MAX_VALUE;
} else
minCount = maxCount = convertCount(count, true);
return this;
}
public static final String SET_RANGE_COUNT = "setRangeCount";
public InteractionBuilder setRangeCount(Object minCount, Object maxCount, boolean inclusive) {
this.minCount = minCount instanceof Wildcard ? 0 : convertCount(minCount, true);
this.maxCount = maxCount instanceof Wildcard ? Integer.MAX_VALUE : convertCount(maxCount, inclusive);
if (this.minCount > this.maxCount)
throw new InvalidSpecException("lower bound of invocation count must come before upper bound");
return this;
}
public static final String ADD_EQUAL_TARGET = "addEqualTarget";
public InteractionBuilder addEqualTarget(Object target) {
if (!(target instanceof Wildcard))
invConstraints.add(new IdenticalTargetConstraint(target));
return this;
}
public static final String ADD_EQUAL_PROPERTY_NAME = "addEqualPropertyName";
public InteractionBuilder addEqualPropertyName(String name) {
if (name.equals(Wildcard.INSTANCE.toString()))
invConstraints.add(WildcardMethodNameConstraint.INSTANCE);
else
invConstraints.add(new EqualPropertyNameConstraint(name));
return this;
}
public static final String ADD_REGEX_PROPERTY_NAME = "addRegexPropertyName";
public InteractionBuilder addRegexPropertyName(String regex) {
invConstraints.add(new RegexPropertyNameConstraint(regex));
return this;
}
public static final String ADD_EQUAL_METHOD_NAME = "addEqualMethodName";
public InteractionBuilder addEqualMethodName(String name) {
if (name.equals(Wildcard.INSTANCE.toString()))
invConstraints.add(WildcardMethodNameConstraint.INSTANCE);
else
invConstraints.add(new EqualMethodNameConstraint(name));
return this;
}
public static final String ADD_REGEX_METHOD_NAME = "addRegexMethodName";
public InteractionBuilder addRegexMethodName(String regex) {
invConstraints.add(new RegexMethodNameConstraint(regex));
return this;
}
public static final String SET_ARG_LIST_KIND = "setArgListKind";
public InteractionBuilder setArgListKind(boolean isPositional) {
argConstraints = new ArrayList();
if (isPositional)
invConstraints.add(new PositionalArgumentListConstraint(argConstraints));
else {
argNames = new ArrayList();
invConstraints.add(new NamedArgumentListConstraint(argNames, argConstraints));
}
return this;
}
public static final String ADD_ARG_NAME= "addArgName";
public InteractionBuilder addArgName(String name) {
argNames.add(name);
return this;
}
public static final String ADD_CODE_ARG = "addCodeArg";
public InteractionBuilder addCodeArg(Closure closure) {
argConstraints.add(new CodeArgumentConstraint(closure));
return this;
}
public static final String ADD_EQUAL_ARG = "addEqualArg";
public InteractionBuilder addEqualArg(Object arg) {
argConstraints.add(arg instanceof Wildcard ? WildcardArgumentConstraint.INSTANCE :
arg instanceof SpreadWildcard ? SpreadWildcardArgumentConstraint.INSTANCE :
new EqualArgumentConstraint(arg));
return this;
}
public static final String TYPE_LAST_ARG = "typeLastArg";
public InteractionBuilder typeLastArg(Class type) {
IArgumentConstraint last = argConstraints.get(argConstraints.size() - 1);
argConstraints.set(argConstraints.size() - 1, new TypeArgumentConstraint(type, last));
return this;
}
public static final String NEGATE_LAST_ARG = "negateLastArg";
public InteractionBuilder negateLastArg() {
IArgumentConstraint last = argConstraints.get(argConstraints.size() - 1);
argConstraints.set(argConstraints.size() - 1, new NegatingArgumentConstraint(last));
return this;
}
public static final String ADD_CONSTANT_RESULT = "setConstantResult";
public InteractionBuilder setConstantResult(Object constant) {
resultGenerators.addFirst(constant instanceof Wildcard ? new DefaultResultGenerator() : new ConstantResultGenerator(constant));
return this;
}
public static final String ADD_CODE_RESULT = "setCodeResult";
public InteractionBuilder setCodeResult(Closure closure) {
resultGenerators.addFirst(new CodeResultGenerator(closure));
return this;
}
public static final String ADD_ITERABLE_RESULT = "setIterableResult";
public InteractionBuilder setIterableResult(Object iterable) {
resultGenerators.addFirst(new IterableResultGenerator(iterable));
return this;
}
public static final String BUILD = "build";
public IMockInteraction build() {
if (resultGenerators.isEmpty())
resultGenerators.addFirst(new DefaultResultGenerator());
return new MockInteraction(line, column, text,
minCount, maxCount, invConstraints, resultGenerators);
}
private static int convertCount(Object count, boolean inclusive) {
if (!(count instanceof Number))
throw new InvalidSpecException("invocation count must be a number");
int intCount = ((Number)count).intValue();
if (!inclusive) intCount--;
if (intCount < 0)
throw new InvalidSpecException("invocation count must be >= 0");
return intCount;
}
}
InteractionNotSatisfiedError.java 0000664 0000000 0000000 00000001717 12020225233 0034172 0 ustar 00root root 0000000 0000000 spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/mock /*
* Copyright 2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.mock;
import org.spockframework.runtime.SpockAssertionError;
/**
* Base class for exceptions indicating that one or more interactions
* have not been satisfied (i.e. have seen to few or too many invocations).
*
* @author Peter Niederwieser
*/
public abstract class InteractionNotSatisfiedError extends SpockAssertionError {}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/mock/InteractionScope.java 0000664 0000000 0000000 00000004147 12020225233 0031714 0 ustar 00root root 0000000 0000000 /*
* Copyright 2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.mock;
import java.util.ArrayList;
import java.util.List;
/**
* A scope for interactions defined outside a then-block
*
* @author Peter Niederwieser
*/
public class InteractionScope implements IInteractionScope {
private final List interactions = new ArrayList();
private int currentRegistrationZone = 0;
private int currentExecutionZone = 0;
public void addInteraction(IMockInteraction interaction) {
interactions.add(new MockInteractionDecorator(interaction) {
final int myRegistrationZone = currentRegistrationZone;
@Override
public Object accept(IMockInvocation invocation) {
Object result = super.accept(invocation);
if (currentExecutionZone > myRegistrationZone)
throw new WrongInvocationOrderError(decorated, invocation);
currentExecutionZone = myRegistrationZone;
return result;
}
});
}
public void addOrderingBarrier() {
currentRegistrationZone++;
}
public IMockInteraction match(IMockInvocation invocation) {
for (IMockInteraction interaction : interactions)
if (interaction.matches(invocation))
return interaction;
return null;
}
public void verifyInteractions() {
List unsatisfieds = new ArrayList();
for (IMockInteraction i : interactions)
if (!i.isSatisfied()) unsatisfieds.add(i);
if (!unsatisfieds.isEmpty())
throw new TooFewInvocationsError(unsatisfieds);
}
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/mock/IterableResultGenerator.java 0000664 0000000 0000000 00000002614 12020225233 0033235 0 ustar 00root root 0000000 0000000 /*
* Copyright 2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.mock;
import java.util.Iterator;
import org.spockframework.util.GroovyRuntimeUtil;
/**
* Generates result values from an iterable object. If the iterator has no more
* values left, the previous value is returned.
*
* @author Peter Niederwieser
*/
public class IterableResultGenerator implements IResultGenerator {
private final Iterator iterator;
private Object nextValue;
public IterableResultGenerator(Object iterable) {
iterator = GroovyRuntimeUtil.asIterator(iterable);
}
public boolean isExhausted() {
return !iterator.hasNext();
}
public Object generate(IMockInvocation invocation) {
if (iterator.hasNext()) nextValue = iterator.next();
return GroovyRuntimeUtil.coerce(nextValue, invocation.getMethod().getReturnType());
}
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/mock/MockController.java 0000775 0000000 0000000 00000005206 12020225233 0031400 0 ustar 00root root 0000000 0000000 /*
* Copyright 2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.mock;
import java.util.*;
import org.spockframework.util.InternalSpockError;
/**
* @author Peter Niederwieser
*/
public class MockController implements IInvocationDispatcher {
private final IMockFactory factory;
private final LinkedList scopes = new LinkedList();
private final List errors = new ArrayList();
public MockController(IMockFactory factory) {
this.factory = factory;
scopes.addFirst(DefaultInteractionScope.INSTANCE);
scopes.addFirst(new InteractionScope());
}
public synchronized Object dispatch(IMockInvocation invocation) {
for (IInteractionScope scope : scopes) {
IMockInteraction interaction = scope.match(invocation);
if (interaction != null)
try {
return interaction.accept(invocation);
} catch (InteractionNotSatisfiedError e) {
errors.add(e);
throw e;
}
}
throw new InternalSpockError("No interaction matched invocation: %s").withArgs(invocation);
}
public static final String ADD_INTERACTION = "addInteraction";
public synchronized void addInteraction(IMockInteraction interaction) {
scopes.getFirst().addInteraction(interaction);
}
public static final String ADD_BARRIER = "addBarrier";
public synchronized void addBarrier() {
scopes.getFirst().addOrderingBarrier();
}
public static final String ENTER_SCOPE = "enterScope";
public synchronized void enterScope() {
throwAnyPreviousError();
scopes.addFirst(new InteractionScope());
}
public static final String LEAVE_SCOPE = "leaveScope";
public synchronized void leaveScope() {
throwAnyPreviousError();
IInteractionScope scope = scopes.removeFirst();
scope.verifyInteractions();
}
public synchronized Object create(String mockName, Class mockType) {
return factory.create(mockName, mockType, this);
}
private void throwAnyPreviousError() {
if (!errors.isEmpty()) throw errors.get(0);
}
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/mock/MockInteraction.java 0000775 0000000 0000000 00000004504 12020225233 0031534 0 ustar 00root root 0000000 0000000 /*
* Copyright 2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.mock;
import java.util.List;
/**
* An anticipated interaction between the SUT and one or more mock objects.
*
* @author Peter Niederwieser
*/
public class MockInteraction implements IMockInteraction {
private final int line;
private final int column;
private final String text;
private final int minCount;
private final int maxCount;
private final List matchers;
private final IResultGenerator resultGenerator;
private int acceptedCount;
public MockInteraction(int line, int column, String text, int minCount,
int maxCount, List matchers,
IResultGenerator resultGenerator) {
this.line = line;
this.column = column;
this.text = text;
this.minCount = minCount;
this.maxCount = maxCount;
this.matchers = matchers;
this.resultGenerator = resultGenerator;
}
public boolean matches(IMockInvocation invocation) {
for (IInvocationConstraint matcher : matchers)
if (!matcher.isSatisfiedBy(invocation)) return false;
return true;
}
public Object accept(IMockInvocation invocation) {
acceptedCount++;
if (acceptedCount > maxCount)
throw new TooManyInvocationsError(this, invocation);
return resultGenerator.generate(invocation);
}
public boolean isSatisfied() {
return acceptedCount >= minCount;
}
public boolean isExhausted() {
return acceptedCount >= maxCount;
}
public int getLine() {
return line;
}
public int getColumn() {
return column;
}
public String getText() {
return text;
}
public String toString() {
return String.format("%s (%d %s)", text, acceptedCount, acceptedCount == 1 ? "invocation" : "invocations");
}
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/mock/MockInteractionDecorator.java 0000664 0000000 0000000 00000002723 12020225233 0033375 0 ustar 00root root 0000000 0000000 /*
* Copyright 2010 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* http://www.apache.org/licenses/LICENSE-2.0
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.mock;
public abstract class MockInteractionDecorator implements IMockInteraction {
protected final IMockInteraction decorated;
public MockInteractionDecorator(IMockInteraction decorated) {
this.decorated = decorated;
}
public int getLine() {
return decorated.getLine();
}
public int getColumn() {
return decorated.getColumn();
}
public String getText() {
return decorated.getText();
}
public boolean matches(IMockInvocation invocation) {
return decorated.matches(invocation);
}
public Object accept(IMockInvocation invocation) {
return decorated.accept(invocation);
}
public boolean isSatisfied() {
return decorated.isSatisfied();
}
public boolean isExhausted() {
return decorated.isExhausted();
}
@Override
public String toString() {
return decorated.toString();
}
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/mock/MockInvocation.java 0000775 0000000 0000000 00000003543 12020225233 0031370 0 ustar 00root root 0000000 0000000 /*
* Copyright 2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.mock;
import java.lang.reflect.Method;
import java.util.*;
import org.codehaus.groovy.runtime.DefaultGroovyMethods;
import org.spockframework.util.TextUtil;
/**
*
* @author Peter Niederwieser
*/
public class MockInvocation implements IMockInvocation {
private final IMockObject mockObject;
private final Method method;
private final List arguments;
public MockInvocation(IMockObject mockObject, Method method, List arguments) {
this.mockObject = mockObject;
this.method = method;
this.arguments = arguments;
}
public IMockObject getMockObject() {
return mockObject;
}
public Method getMethod() {
return method;
}
public List getArguments() {
return arguments;
}
@Override
public String toString() {
String mockName = mockObject.getName();
if (mockName == null) mockName = String.format("<%s>", mockObject.getType().getSimpleName());
return String.format("%s.%s(%s)", mockName, method.getName(), render(arguments));
}
private String render(List arguments) {
List strings = new ArrayList();
for (Object arg : arguments) strings.add(DefaultGroovyMethods.inspect(arg));
return TextUtil.join(", ", strings);
}
}
spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/mock/MockObject.java 0000664 0000000 0000000 00000002106 12020225233 0030454 0 ustar 00root root 0000000 0000000 /*
* Copyright 2010 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* http://www.apache.org/licenses/LICENSE-2.0
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.mock;
public class MockObject implements IMockObject {
private final String name;
private final Class type;
private final Object instance;
public MockObject(String name, Class type, Object instance) {
this.name = name;
this.type = type;
this.instance = instance;
}
public String getName() {
return name;
}
public Class getType() {
return type;
}
public Object getInstance() {
return instance;
}
}
NamedArgumentListConstraint.java 0000775 0000000 0000000 00000006047 12020225233 0034020 0 ustar 00root root 0000000 0000000 spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/mock /*
* Copyright 2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.mock;
import java.util.*;
import org.spockframework.util.Assert;
/**
*
* @author Peter Niederwieser
*/
public class NamedArgumentListConstraint implements IInvocationConstraint {
// NOTE: why not use List here?
private final List argNames; // name == "_" -> unnamed matcher (considered matching if it matches any arg)
private final List argConstraints;
public NamedArgumentListConstraint(List argNames, List argConstraints) {
Assert.that(argNames.size() == argConstraints.size());
this.argNames = argNames;
this.argConstraints = argConstraints;
}
@SuppressWarnings("unchecked")
public boolean isSatisfiedBy(IMockInvocation invocation) {
List args = invocation.getArguments();
if (args.size() == 1 && args.get(0) instanceof Map)
return matchesArgMap(new HashMap((Map)args.get(0)));
return matchesArgList(new ArrayList(args));
}
private boolean matchesArgList(List args) {
nextMatcher:
for (int i = 0; i < argConstraints.size(); i++) {
Object name = argNames.get(i);
if (!name.equals("_")) return false; // cannot possibly match because we have unnamed args
IArgumentConstraint matcher = argConstraints.get(i);
Iterator argIter = args.iterator();
while (argIter.hasNext())
if (matcher.isSatisfiedBy(argIter.next())) {
argIter.remove();
continue nextMatcher;
}
return false;
}
return true;
}
private boolean matchesArgMap(Map argMap) {
// first pass: named matchers
for (int i = 0; i < argConstraints.size(); i++) {
Object name = argNames.get(i);
if (name.equals("_")) continue;
IArgumentConstraint matcher = argConstraints.get(i);
if (!argMap.containsKey(name) || !matcher.isSatisfiedBy(argMap.remove(name)))
return false;
}
// second pass: unnamed matchers
nextMatcher:
for (int i = 0; i < argConstraints.size(); i++) {
Object name = argNames.get(i);
if (!name.equals("_")) continue;
IArgumentConstraint matcher = argConstraints.get(i);
@SuppressWarnings("unchecked")
Iterator argIter = argMap.values().iterator();
while (argIter.hasNext())
if (matcher.isSatisfiedBy(argIter.next())) {
argIter.remove();
continue nextMatcher;
}
return false;
}
return true;
}
} NegatingArgumentConstraint.java 0000664 0000000 0000000 00000001770 12020225233 0033667 0 ustar 00root root 0000000 0000000 spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/mock /*
* Copyright 2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.mock;
/**
*
* @author Peter Niederwieser
*/
public class NegatingArgumentConstraint implements IArgumentConstraint {
private final IArgumentConstraint constraint;
public NegatingArgumentConstraint(IArgumentConstraint constraint) {
this.constraint = constraint;
}
public boolean isSatisfiedBy(Object arg) {
return !constraint.isSatisfiedBy(arg);
}
}
PositionalArgumentListConstraint.java 0000775 0000000 0000000 00000005202 12020225233 0035105 0 ustar 00root root 0000000 0000000 spock-0.6-groovy-1.8/spock-core/src/main/java/org/spockframework/mock /*
* Copyright 2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.spockframework.mock;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.spockframework.util.*;
/**
*
* @author Peter Niederwieser
*/
public class PositionalArgumentListConstraint implements IInvocationConstraint {
private final List argConstraints;
public PositionalArgumentListConstraint(List argConstraints) {
this.argConstraints = argConstraints;
}
public boolean isSatisfiedBy(IMockInvocation invocation) {
List args = invocation.getArguments();
if (areConstraintsSatisfiedBy(args)) return true;
if (!canBeCalledWithVarArgSyntax(invocation.getMethod())) return false;
return areConstraintsSatisfiedBy(expandVarArgs(args));
}
/**
* Tells if the given method can be called with vararg syntax from Groovy(!).
* If yes, we also support vararg syntax in the interaction definition.
*/
private boolean canBeCalledWithVarArgSyntax(Method method) {
Class[] paramTypes = method.getParameterTypes();
return paramTypes.length > 0 && paramTypes[paramTypes.length - 1].isArray();
}
private List expandVarArgs(List args) {
List