From 20b1226b4eb10e85497862bd73fe9e9a2f05191d Mon Sep 17 00:00:00 2001 From: Carlo Zancanaro Date: Fri, 5 Jun 2015 14:51:03 +1000 Subject: First cut of a stateful testing framework (it's pretty hacky at the moment, but all the pieces are there) --- .../au/id/zancanaro/javacheck/statem/Command.java | 23 ++++++ .../id/zancanaro/javacheck/statem/CommandList.java | 85 ++++++++++++++++++++++ .../javacheck/statem/CommandListGenerator.java | 50 +++++++++++++ .../zancanaro/javacheck/statem/CommandResult.java | 31 ++++++++ .../zancanaro/javacheck/statem/CommandValue.java | 60 +++++++++++++++ .../javacheck/statem/GeneratedCommand.java | 56 ++++++++++++++ 6 files changed, 305 insertions(+) create mode 100644 src/main/java/au/id/zancanaro/javacheck/statem/Command.java create mode 100644 src/main/java/au/id/zancanaro/javacheck/statem/CommandList.java create mode 100644 src/main/java/au/id/zancanaro/javacheck/statem/CommandListGenerator.java create mode 100644 src/main/java/au/id/zancanaro/javacheck/statem/CommandResult.java create mode 100644 src/main/java/au/id/zancanaro/javacheck/statem/CommandValue.java create mode 100644 src/main/java/au/id/zancanaro/javacheck/statem/GeneratedCommand.java (limited to 'src/main/java/au/id/zancanaro/javacheck') diff --git a/src/main/java/au/id/zancanaro/javacheck/statem/Command.java b/src/main/java/au/id/zancanaro/javacheck/statem/Command.java new file mode 100644 index 0000000..a741f0a --- /dev/null +++ b/src/main/java/au/id/zancanaro/javacheck/statem/Command.java @@ -0,0 +1,23 @@ +package au.id.zancanaro.javacheck.statem; + +import au.id.zancanaro.javacheck.Generator; + +public abstract class Command { + public Generator argsGenerator(State state) { + return Generator.pure(null); + } + + public boolean preCondition(State state, Args args) { + return true; + } + + public abstract Result runCommand(Args args); + + public State nextState(State state, Args args, CommandValue result) { + return state; + } + + public boolean postCondition(State oldState, State newState, Args args, Result result) { + return true; + } +} diff --git a/src/main/java/au/id/zancanaro/javacheck/statem/CommandList.java b/src/main/java/au/id/zancanaro/javacheck/statem/CommandList.java new file mode 100644 index 0000000..9e8948a --- /dev/null +++ b/src/main/java/au/id/zancanaro/javacheck/statem/CommandList.java @@ -0,0 +1,85 @@ +package au.id.zancanaro.javacheck.statem; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +public class CommandList { + private final List> commands; + + public CommandList(List> commands) { + this.commands = new ArrayList<>(commands); + } + + public CommandResult run(State initialState) { + Map values = new HashMap<>(); + CommandResult result = CommandResult.success(initialState); + for (GeneratedCommand generated : commands) { + result = runRealCommand(generated, result.getState(), values); + if (result.isFailed()) { + break; + } + } + return result; + } + + private static CommandResult runRealCommand( + GeneratedCommand generated, + State state, + Map values) { + int id = generated.getId(); + Command command = generated.getCommand(); + Args args = generated.getArgs(); + try { + if (!command.preCondition(state, args)) { + return CommandResult.fail(state, new Error("Precondition failed")); + } + Result result = command.runCommand(args); + values.put(id, result); + State oldState = state; + state = command.nextState(state, args, new CommandValue.ConcreteValue<>(id, values)); + if (!command.postCondition(oldState, state, args, result)) { + return CommandResult.fail(state, new Error("Postcondition failed")); + } + return CommandResult.success(state); + } catch (Throwable ex) { + return CommandResult.fail(state, ex); + } + } + + private static CommandResult runAbstractCommand( + GeneratedCommand generated, + State state) { + int id = generated.getId(); + Command command = generated.getCommand(); + Args args = generated.getArgs(); + try { + if (!command.preCondition(state, args)) { + return CommandResult.fail(state, new Error("Precondition failed")); + } + state = command.nextState(state, args, new CommandValue.AbstractValue<>(id)); + return CommandResult.success(state); + } catch (Throwable ex) { + return CommandResult.fail(state, ex); + } + } + + public boolean isValid() { + CommandResult result = CommandResult.success(null); + for (GeneratedCommand generated : commands) { + result = runAbstractCommand(generated, result.getState()); + if (result.isFailed()) { + break; + } + } + return !result.isFailed(); + } + + @Override + public String toString() { + return "CommandList{" + + "commands=" + commands + + '}'; + } +} diff --git a/src/main/java/au/id/zancanaro/javacheck/statem/CommandListGenerator.java b/src/main/java/au/id/zancanaro/javacheck/statem/CommandListGenerator.java new file mode 100644 index 0000000..a0df66f --- /dev/null +++ b/src/main/java/au/id/zancanaro/javacheck/statem/CommandListGenerator.java @@ -0,0 +1,50 @@ +package au.id.zancanaro.javacheck.statem; + +import au.id.zancanaro.javacheck.Generator; +import au.id.zancanaro.javacheck.ShrinkTree; + +import java.util.Random; +import java.util.function.Function; + +import static au.id.zancanaro.javacheck.Generator.pure; +import static au.id.zancanaro.javacheck.Generators.noShrink; + +public class CommandListGenerator implements Generator> { + private final Function>> generateCommand; + + public CommandListGenerator(Function>> generateCommand) { + this.generateCommand = generateCommand; + } + + public Generator> commandGenerator(int id, State state) { + return noShrink(generateCommand.apply(state)) + .flatMap(command -> generateSingleCommand(id, command, state)); + } + + public Generator> generateSingleCommand(int id, Command command, State state) { + return command.argsGenerator(state).flatMap(generatedArgs -> + command.preCondition(state, generatedArgs) ? + pure(new GeneratedCommand<>(id, command, generatedArgs)) : + commandGenerator(id, state)); + } + + public State nextState(int id, GeneratedCommand generatedCommand, State state) { + return generatedCommand.getCommand().nextState(state, generatedCommand.getArgs(), new CommandValue.AbstractValue<>(id)); + } + + @Override + public ShrinkTree> generate(Random random, int size) { + int count = random.nextInt(size); + @SuppressWarnings("unchecked") + ShrinkTree>[] commandTrees = (ShrinkTree>[]) new ShrinkTree[count]; + State state = null; + for (int i = 0; i < count; ++i) { + commandTrees[i] = commandGenerator(i, state).generate(random, size); + GeneratedCommand generatedCommand = commandTrees[i].getValue(); + state = nextState(i, generatedCommand, state); + } + return ShrinkTree.combine(commandTrees, ShrinkTree::removeAndPromoteChildren) + .map(list -> new CommandList<>(list)) + .filter(CommandList::isValid); + } +} diff --git a/src/main/java/au/id/zancanaro/javacheck/statem/CommandResult.java b/src/main/java/au/id/zancanaro/javacheck/statem/CommandResult.java new file mode 100644 index 0000000..dc5b085 --- /dev/null +++ b/src/main/java/au/id/zancanaro/javacheck/statem/CommandResult.java @@ -0,0 +1,31 @@ +package au.id.zancanaro.javacheck.statem; + +public class CommandResult { + private final State state; + private final Throwable thrown; + + private CommandResult(State state, Throwable thrown) { + this.state = state; + this.thrown = thrown; + } + + public State getState() { + return state; + } + + public boolean isFailed() { + return thrown != null; + } + + public Throwable getThrown() { + return thrown; + } + + public static CommandResult success(State state) { + return new CommandResult<>(state, null); + } + + public static CommandResult fail(State state, Throwable ex) { + return new CommandResult<>(state, ex); + } +} diff --git a/src/main/java/au/id/zancanaro/javacheck/statem/CommandValue.java b/src/main/java/au/id/zancanaro/javacheck/statem/CommandValue.java new file mode 100644 index 0000000..0a1fb61 --- /dev/null +++ b/src/main/java/au/id/zancanaro/javacheck/statem/CommandValue.java @@ -0,0 +1,60 @@ +package au.id.zancanaro.javacheck.statem; + +import java.util.Map; +import java.util.NoSuchElementException; + +public abstract class CommandValue { + private final int id; + + public CommandValue(int id) { + this.id = id; + } + + public abstract boolean isAbstract(); + + public abstract T get(); + + public int getId() { + return id; + } + + static class AbstractValue extends CommandValue { + public AbstractValue(int id) { + super(id); + } + + @Override + public boolean isAbstract() { + return true; + } + + @Override + public T get() { + throw new NoSuchElementException("Abstract values cannot be supplied"); + } + } + + static class ConcreteValue extends CommandValue { + private final Map values; + + public ConcreteValue(int id, Map values) { + super(id); + this.values = values; + } + + @Override + public boolean isAbstract() { + return true; + } + + @Override + @SuppressWarnings("unchecked") + public T get() { + if (values.containsKey(getId())) { + return (T) values.get(getId()); + } else { + throw new NoSuchElementException("Concrete values cannot be supplied prior to being calculated"); + } + } + } +} diff --git a/src/main/java/au/id/zancanaro/javacheck/statem/GeneratedCommand.java b/src/main/java/au/id/zancanaro/javacheck/statem/GeneratedCommand.java new file mode 100644 index 0000000..5e576b4 --- /dev/null +++ b/src/main/java/au/id/zancanaro/javacheck/statem/GeneratedCommand.java @@ -0,0 +1,56 @@ +package au.id.zancanaro.javacheck.statem; + +public class GeneratedCommand { + private final int id; + private final Command command; + private final Args args; + + public GeneratedCommand(int id, Command command, Args args) { + this.id = id; + this.command = command; + this.args = args; + } + + public int getId() { + return id; + } + + public Command getCommand() { + return command; + } + + public Args getArgs() { + return args; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + + GeneratedCommand that = (GeneratedCommand) o; + + if (args != null ? !args.equals(that.args) : that.args != null) + return false; + if (command != null ? !command.equals(that.command) : that.command != null) + return false; + + return true; + } + + @Override + public int hashCode() { + int result = command != null ? command.hashCode() : 0; + result = 31 * result + (args != null ? args.hashCode() : 0); + return result; + } + + @Override + public String toString() { + return "GeneratedCommand{" + + "id=" + id + + ", command=" + command + + ", args=" + args + + '}'; + } +} -- cgit v1.2.3