Datasets:

Minata

/

1024src_fm_fc_ms_ff_method2testcases_v0

like 0

### Question: GreedyForKnapsack { public static boolean[] solveByBestRatioFirst(KnapsackProblem problem){ List<KnapsackProblem.Item> items = problem.getCopyOfItems(); items.sort((a,b) -> { if(a.getWeight() == 0){ return -1; } if(b.getWeight() == 0){ return 1; } double ra = a.getValue() / a.getWeight(); double rb = b.getValue() / b.getWeight(); double diff = ra - rb; if(diff < 0){ return 1; } else if(diff > 0){ return -1; } else { return 0; } }); return solve(problem, items); } static boolean[] solveByHeavierFirst(KnapsackProblem problem); static boolean[] solveByLighterFirst(KnapsackProblem problem); static boolean[] solveByBestRatioFirst(KnapsackProblem problem); }### Answer: @Test public void testSolveByBestRatioFirst(){ KnapsackInstanceWithSolution p = KnapsackInstanceWithSolution.problemP05(); boolean[] heavier = GreedyForKnapsack.solveByHeavierFirst(p.getProblem()); boolean[] ratio = GreedyForKnapsack.solveByBestRatioFirst(p.getProblem()); assertArrayEquals(heavier, ratio); }

### Question: DnaCompressor { public static byte[] compress(String dna){ BitWriter writer = new BitWriter(); writer.write(dna.length()); for(int i=0; i<dna.length(); i++){ char c = dna.charAt(i); if(c== 'A'){ writer.write(true); writer.write(true); } else if(c== 'C'){ writer.write(true); writer.write(false); }else if(c== 'G'){ writer.write(false); writer.write(true); }else if(c== 'T'){ writer.write(false); writer.write(false); } else { throw new IllegalArgumentException("Unrecognized character: " + c); } } return writer.extract(); } static byte[] compress(String dna); static String decompress(byte[] data); }### Answer: @Test public void testDecreaseSize(){ String dna = "AAAGTACCTGAGTAAAGTACCTGAGTAAAGTACCTGAGTTTTGCTGCTGCTGCTGCTGCTGCTGCTGCTGCTTTTTTT"; checkPreserveInformation(dna); int nonCompressedSize = dna.getBytes(StandardCharsets.UTF_8).length; byte[] compressed = DnaCompressor.compress(dna); assertTrue(compressed.length < nonCompressedSize); double ratio = (double) compressed.length / (double) nonCompressedSize; assertTrue(ratio < 0.33); assertTrue(ratio >= 0.25); } @Test public void testIncreaseSize(){ String dna = "A"; checkPreserveInformation(dna); int nonCompressedSize = dna.getBytes(StandardCharsets.UTF_8).length; byte[] compressed = DnaCompressor.compress(dna); assertTrue(compressed.length > nonCompressedSize); }

### Question: BitReader { public byte readByte(){ if(bits % 8 == 0){ int i = bits / 8; bits += 8; return data[i]; } byte tmp = 0; for(int j=0; j<8; j++){ tmp = (byte) (tmp << 1); boolean k = readBoolean(); if(k){ tmp |= 1; } } return tmp; } BitReader(byte[] data); byte readByte(); boolean readBoolean(); int readInt(); int readInt(int nbits); char readChar(); }### Answer: @Test public void testByte(){ byte val = 5; BitReader reader = new BitReader(new byte[]{val}); byte res = reader.readByte(); assertEquals(val, res); } @Test public void testNegativeByte(){ byte val = -125; BitReader reader = new BitReader(new byte[]{val}); byte res = reader.readByte(); assertEquals(val, res); }

### Question: BitReader { public boolean readBoolean(){ int i = bits / 8; if(i >= data.length){ throw new IllegalStateException("No more data to read"); } byte b = data[i]; int k = bits % 8; bits++; return ((b >>> (8 - k - 1)) & 1) == 1; } BitReader(byte[] data); byte readByte(); boolean readBoolean(); int readInt(); int readInt(int nbits); char readChar(); }### Answer: @Test public void testBoolean(){ byte val = (byte)0b1000_0000; BitReader reader = new BitReader(new byte[]{val}); boolean b = reader.readBoolean(); assertTrue(b); } @Test public void testTrueFalseTrue(){ byte val = (byte)0b1010_0000; BitReader reader = new BitReader(new byte[]{val}); assertTrue(reader.readBoolean()); assertFalse(reader.readBoolean()); assertTrue(reader.readBoolean()); }

### Question: BitReader { public int readInt(){ int x; byte a = readByte(); x = a & 0xFF; byte b = readByte(); x = x << 8; x |= (b & 0xFF); byte c = readByte(); x = x << 8; x |= (c & 0xFF); byte d = readByte(); x = x << 8; x |= (d & 0xFF); return x; } BitReader(byte[] data); byte readByte(); boolean readBoolean(); int readInt(); int readInt(int nbits); char readChar(); }### Answer: @Test public void testSmallInt(){ int val = 5; BitWriter writer = new BitWriter(); writer.write(val); BitReader reader = new BitReader(writer.extract()); int res = reader.readInt(); assertEquals(val, res); } @Test public void testIntWithNegativeBytes(){ int val = 0b1000_0000_1000_0000; BitWriter writer = new BitWriter(); writer.write(val); BitReader reader = new BitReader(writer.extract()); int res = reader.readInt(); assertEquals(val, res); }

### Question: BitReader { public char readChar(){ int x; byte a = readByte(); x = a & 0xFF; byte b = readByte(); x = x << 8; x |= (b & 0xFF); return (char) x; } BitReader(byte[] data); byte readByte(); boolean readBoolean(); int readInt(); int readInt(int nbits); char readChar(); }### Answer: @Test public void testStringChar(){ String val = "abc"; BitWriter writer = new BitWriter(); writer.write(val); BitReader reader = new BitReader(writer.extract()); char a = reader.readChar(); char b = reader.readChar(); char c = reader.readChar(); assertEquals('a', a); assertEquals('b', b); assertEquals('c', c); }

### Question: MyMapBinarySearchTree implements MyMapTreeBased<K, V> { @Override public int getMaxTreeDepth() { if (root == null) { return 0; } return depth(root); } @Override void put(K key, V value); @Override void delete(K key); @Override V get(K key); @Override int size(); @Override int getMaxTreeDepth(); }### Answer: @Test public void testDepthZero() { assertEquals(0, map.getMaxTreeDepth()); }

### Question: LambdaExamples { public static void useRunnable(Runnable runnable){ System.out.println("Before runnable"); runnable.run(); System.out.println("After runnable"); } static void useRunnable(Runnable runnable); static void useConsumer(Consumer<String> consumer); static String usePredicate(Predicate<String> predicate); static int useFunction(Function<String, Integer> function); }### Answer: @Test public void testRunnable() { Runnable anonymousClass = new Runnable() { @Override public void run() { System.out.println("Executing method run()"); } }; Runnable lambda = () -> System.out.println("Executing method run()"); LambdaExamples.useRunnable(anonymousClass); LambdaExamples.useRunnable(lambda); LambdaExamples.useRunnable(() -> System.out.println("Executing method run()")); }

### Question: LambdaExamples { public static void useConsumer(Consumer<String> consumer){ String foo = "foo"; System.out.println("Before consumer"); consumer.accept(foo); System.out.println("After consumer"); } static void useRunnable(Runnable runnable); static void useConsumer(Consumer<String> consumer); static String usePredicate(Predicate<String> predicate); static int useFunction(Function<String, Integer> function); }### Answer: @Test public void testConsumer() { Consumer<String> anonymousClass = new Consumer<String>() { @Override public void accept(String s) { System.out.println(s.toUpperCase()); } }; Consumer<String> lambda = s -> System.out.println(s.toUpperCase()); LambdaExamples.useConsumer(anonymousClass); LambdaExamples.useConsumer(lambda); LambdaExamples.useConsumer(s -> System.out.println(s.toUpperCase())); }

### Question: LambdaExamples { public static String usePredicate(Predicate<String> predicate){ String foo = "foo"; if(predicate.test(foo)){ return foo; } else { return null; } } static void useRunnable(Runnable runnable); static void useConsumer(Consumer<String> consumer); static String usePredicate(Predicate<String> predicate); static int useFunction(Function<String, Integer> function); }### Answer: @Test public void testPredicate() { Predicate<String> anonymousClass = new Predicate<String>() { @Override public boolean test(String s) { return s.length() > 5; } }; Predicate<String> lambda = s -> s.toUpperCase().equals("FOO"); assertNull(LambdaExamples.usePredicate(anonymousClass)); assertNotNull(LambdaExamples.usePredicate(lambda)); assertNotNull(LambdaExamples.usePredicate(s -> { int length = s.length(); return length == 3; } )); }

### Question: LambdaExamples { public static int useFunction(Function<String, Integer> function){ String input = "foo"; return function.apply(input); } static void useRunnable(Runnable runnable); static void useConsumer(Consumer<String> consumer); static String usePredicate(Predicate<String> predicate); static int useFunction(Function<String, Integer> function); }### Answer: @Test public void testFunction(){ Function<String, Integer> anonymousClass = new Function<String, Integer>() { @Override public Integer apply(String s) { return s.length(); } }; Function<String, Integer> lambda = s -> 5; assertEquals(3, LambdaExamples.useFunction(anonymousClass)); assertEquals(5, LambdaExamples.useFunction(lambda)); assertEquals(6, LambdaExamples.useFunction(s -> s.length() * 2)); }

### Question: MyIterableLinkedList implements Iterable<T> { public void add(T value) { ListNode node = new ListNode(); node.value = value; size++; modificationCounter++; if (head == null) { head = node; tail = node; return; } tail.next = node; tail = node; } @Override Iterator<T> iterator(); void delete(int index); T get(int index); void add(T value); int size(); boolean isEmpty(); boolean contains(T value); }### Answer: @Test public void testIterable(){ MyIterableLinkedList<String> data = new MyIterableLinkedList<>(); data.add("a"); data.add("b"); data.add("c"); String buffer = ""; for(String value : data){ buffer += value; } assertEquals("abc", buffer); }

### Question: MyIterableLinkedList implements Iterable<T> { public int size() { return size; } @Override Iterator<T> iterator(); void delete(int index); T get(int index); void add(T value); int size(); boolean isEmpty(); boolean contains(T value); }### Answer: @Test public void testEmpty(){ MyIterableLinkedList<Integer> data = new MyIterableLinkedList<>(); assertEquals(0, data.size()); }

### Question: AllPathsGraph extends UndirectedGraph<V> { public List<List<V>> findAllPaths(V start, V end) { if (!graph.containsKey(start) && !graph.containsKey(end)) { return Collections.emptyList(); } if (start.equals(end)) { throw new IllegalArgumentException(); } Deque<V> stack = new ArrayDeque<>(); List<List<V>> paths = new ArrayList<>(); dfs(paths, stack, start, end); return paths; } List<List<V>> findAllPaths(V start, V end); }### Answer: @Test public void test(){ AllPathsGraph<String> graph = new AllPathsGraph<>(); graph.addEdge("0","X"); graph.addEdge("X","1"); graph.addEdge("X","Y"); graph.addEdge("1","2"); graph.addEdge("2","Y"); graph.addEdge("1","3"); graph.addEdge("3","4"); graph.addEdge("3","5"); graph.addEdge("4","5"); List<List<String>> paths = graph.findAllPaths("X","5"); assertEquals(4, paths.size()); assertTrue(paths.stream().anyMatch(p -> p.size() == 4)); assertTrue(paths.stream().anyMatch(p -> p.size() == 5)); assertTrue(paths.stream().anyMatch(p -> p.size() == 6)); assertTrue(paths.stream().anyMatch(p -> p.size() == 7)); }

### Question: MyIterableLinkedList implements Iterable<T> { public T get(int index) { if (index < 0 || index >= size()) { throw new IndexOutOfBoundsException(); } ListNode current = head; int counter = 0; while (current != null) { if (counter == index) { return current.value; } current = current.next; counter++; } assert false; return null; } @Override Iterator<T> iterator(); void delete(int index); T get(int index); void add(T value); int size(); boolean isEmpty(); boolean contains(T value); }### Answer: @Test public void testOutOfIndex(){ MyIterableLinkedList<String> data = new MyIterableLinkedList<>(); assertThrows(IndexOutOfBoundsException.class, () -> data.get(-5)); assertThrows(IndexOutOfBoundsException.class, () -> data.get(42)); }

### Question: MyIterableHashMap implements MyHashMap<K,V>, Iterable<V> { @Override public void put(K key, V value) { modificationCounter++; int i = index(key); if(data[i] == null){ data[i] = new ArrayList<>(); } List<Entry> list = data[i]; for(int j=0; j<list.size(); j++){ Entry entry = list.get(j); if(key.equals(entry.key)){ entry.value = value; return; } } list.add(new Entry(key, value)); } MyIterableHashMap(); MyIterableHashMap(int capacity); @Override Iterator<V> iterator(); @Override void put(K key, V value); @Override void delete(K key); @Override V get(K key); @Override int size(); }### Answer: @Test public void testIterable(){ MyIterableHashMap<Integer, String> map = new MyIterableHashMap<>(); map.put(0, "a"); map.put(1, "b"); map.put(2, "c"); String buffer = ""; for(String value : map){ buffer += value; } assertEquals(3, buffer.length()); assertTrue(buffer.contains("a")); assertTrue(buffer.contains("b")); assertTrue(buffer.contains("c")); }

### Question: MyIterableHashMap implements MyHashMap<K,V>, Iterable<V> { @Override public int size() { int size = 0; for(int i=0; i<data.length; i++){ if(data[i] != null){ size += data[i].size(); } } return size; } MyIterableHashMap(); MyIterableHashMap(int capacity); @Override Iterator<V> iterator(); @Override void put(K key, V value); @Override void delete(K key); @Override V get(K key); @Override int size(); }### Answer: @Test public void testEmpty() { MyIterableHashMap<String, Integer> map = new MyIterableHashMap<>(); assertEquals(0, map.size()); assertTrue(map.isEmpty()); }

### Question: MyIterableHashMap implements MyHashMap<K,V>, Iterable<V> { @Override public void delete(K key) { int i = index(key); if(data[i] == null){ return; } List<Entry> list = data[i]; for(int j=0; j<list.size(); j++){ Entry entry = list.get(j); if(key.equals(entry.key)){ list.remove(j); modificationCounter++; return; } } } MyIterableHashMap(); MyIterableHashMap(int capacity); @Override Iterator<V> iterator(); @Override void put(K key, V value); @Override void delete(K key); @Override V get(K key); @Override int size(); }### Answer: @Test public void testDelete() { MyIterableHashMap<String, Integer> map = new MyIterableHashMap<>(); int n = map.size(); String key = "foo"; int x = 42; map.put(key, x); assertEquals(x, map.get(key).intValue()); assertEquals(n + 1, map.size()); map.delete(key); assertNull(map.get(key)); assertEquals(n, map.size()); }

### Question: TernaryTreeMap implements MyMapTreeBased<K, V> { @Override public int getMaxTreeDepth() { if (root == null) { return 0; } return depth(root); } @Override void put(K key, V value); @Override void delete(K key); @Override V get(K key); @Override int size(); @Override int getMaxTreeDepth(); }### Answer: @Test public void testDepthZero() { assertEquals(0, map.getMaxTreeDepth()); }

### Question: MyArrayListInteger { public int size() { return size; } MyArrayListInteger(); MyArrayListInteger(int maxSize); Integer get(int index); void add(Integer value); int size(); }### Answer: @Test public void testEmpty(){ assertEquals(0, data.size()); }

### Question: MyArrayListInteger { public Integer get(int index) { if(index < 0 || index >= size){ return null; } return data[index]; } MyArrayListInteger(); MyArrayListInteger(int maxSize); Integer get(int index); void add(Integer value); int size(); }### Answer: @Test public void testOutOfIndex(){ assertNull(data.get(-5)); assertNull(data.get(42)); }

### Question: AxonDBEventStore extends AbstractEventStore { @Override public TrackingEventStream openStream(TrackingToken trackingToken) { return storageEngine().openStream(trackingToken); } AxonDBEventStore(AxonDBConfiguration configuration, Serializer serializer); AxonDBEventStore(AxonDBConfiguration configuration, Serializer serializer, EventUpcaster upcasterChain); AxonDBEventStore(AxonDBConfiguration configuration, Serializer snapshotSerializer, Serializer eventSerializer, EventUpcaster upcasterChain); @Override TrackingEventStream openStream(TrackingToken trackingToken); QueryResultStream query(String query, boolean liveUpdates); }### Answer: @Test public void testPublishAndConsumeEvents() throws Exception { UnitOfWork<Message<?>> uow = DefaultUnitOfWork.startAndGet(null); testSubject.publish(GenericEventMessage.asEventMessage("Test1"), GenericEventMessage.asEventMessage("Test2"), GenericEventMessage.asEventMessage("Test3")); uow.commit(); TrackingEventStream stream = testSubject.openStream(null); List<String> received = new ArrayList<>(); while(stream.hasNextAvailable(100, TimeUnit.MILLISECONDS)) { received.add(stream.nextAvailable().getPayload().toString()); } stream.close(); assertEquals(Arrays.asList("Test1", "Test2", "Test3"), received); }

### Question: IdGenerator { public static long newRandomId(@Nullable Set<Long> existingIds) { while (true) { long candidateId = ThreadLocalRandom.current().nextLong(); if (MIN <= candidateId && candidateId <= MAX) { if (existingIds == null) { return candidateId; } if (!existingIds.contains(candidateId)) { return candidateId; } } } } static long newRandomId(@Nullable Set<Long> existingIds); static long newLinearId(AtomicLong longValue); static final long MIN; static final long MAX; }### Answer: @Test public void testNewRandomId() { assertThat(IdGenerator.newRandomId(null)).isBetween(IdGenerator.MIN, IdGenerator.MAX); Set<Long> ids = new HashSet<>(); ids.add(1L); assertThat(IdGenerator.newRandomId(ids)).isBetween(IdGenerator.MIN, IdGenerator.MAX); }

### Question: IdGenerator { public static long newLinearId(AtomicLong longValue) { long candiateId = longValue.incrementAndGet(); if (candiateId > IdGenerator.MAX) { longValue.set(1L); candiateId = longValue.longValue(); } return candiateId; } static long newRandomId(@Nullable Set<Long> existingIds); static long newLinearId(AtomicLong longValue); static final long MIN; static final long MAX; }### Answer: @Test public void testNewLinearId() { AtomicLong id = new AtomicLong(0); assertThat(IdGenerator.newLinearId(id)).isEqualTo(1); assertThat(IdGenerator.newLinearId(id)).isEqualTo(2); id.set(IdGenerator.MAX - 1L); assertThat(IdGenerator.newLinearId(id)).isEqualTo(IdGenerator.MAX); assertThat(IdGenerator.newLinearId(id)).isEqualTo(1L); }

### Question: CollectionHelper { @SafeVarargs @Nullable public static <T> List<T> toList(@Nullable T... arguments) { if (arguments != null) { if (arguments.length == 1) { return Collections.singletonList(arguments[0]); } if (arguments.length > 1) { return Arrays.asList(arguments); } } return null; } @SafeVarargs @Nullable static List<T> toList(@Nullable T... arguments); @SuppressWarnings("unchecked") @Nullable static List<Object> toList(@Nullable Collection<T> collection); @Nullable static Set<Long> toSet(@Nullable Collection<Long> collection); }### Answer: @Test public void testToListTArray() { assertThat(CollectionHelper.toList()).isNull(); assertThat(CollectionHelper.toList(1)).isInstanceOf(List.class) .containsExactly(1); assertThat(CollectionHelper.toList(1, 2, 3)).isInstanceOf(List.class) .containsExactly(1, 2, 3); } @Test public void testToListCollectionOfT() { assertThat(CollectionHelper.toList((List<String>) null)).isNull(); assertThat(CollectionHelper.toList(Arrays.asList(1))).isInstanceOf(List.class) .containsExactly(1); assertThat(CollectionHelper.toList(Arrays.asList(1, 2, 3))) .isInstanceOf(List.class).containsExactly(1, 2, 3); Set<Long> set = new HashSet<>(); set.add(11L); set.add(22L); assertThat(CollectionHelper.toList(set)).isInstanceOf(List.class) .containsOnly(11L, 22L); }

### Question: CollectionHelper { @Nullable public static Set<Long> toSet(@Nullable Collection<Long> collection) { if (collection != null) { if (collection instanceof Set) { return (Set<Long>) collection; } return new HashSet<>(collection); } return null; } @SafeVarargs @Nullable static List<T> toList(@Nullable T... arguments); @SuppressWarnings("unchecked") @Nullable static List<Object> toList(@Nullable Collection<T> collection); @Nullable static Set<Long> toSet(@Nullable Collection<Long> collection); }### Answer: @Test public void testToSet() { assertThat(CollectionHelper.toSet((Set<Long>) null)).isNull(); Set<Long> set = new HashSet<>(); set.add(33L); set.add(44L); assertThat(CollectionHelper.toSet(set)).isInstanceOf(Set.class).containsOnly(33L, 44L); assertThat(CollectionHelper.toSet(Arrays.asList(1L))).isInstanceOf(Set.class) .containsExactly(1L); assertThat(CollectionHelper.toSet(Arrays.asList(1L, 2L, 3L))) .isInstanceOf(Set.class).containsExactly(1L, 2L, 3L); }

### Question: CallMessage extends WampMessage { @Override public void serialize(JsonGenerator generator) throws IOException { generator.writeNumber(getCode()); generator.writeNumber(this.requestId); generator.writeStartObject(); if (this.discloseMe) { generator.writeBooleanField("disclose_me", this.discloseMe); } generator.writeEndObject(); generator.writeString(this.procedure); if (this.argumentsKw != null) { if (this.arguments == null) { generator.writeStartArray(); generator.writeEndArray(); } else { generator.writeObject(this.arguments); } generator.writeObject(this.argumentsKw); } else if (this.arguments != null) { generator.writeObject(this.arguments); } } CallMessage(long request, String procedure); CallMessage(long request, String procedure, @Nullable List<Object> arguments); CallMessage(long request, String procedure, @Nullable Map<String, Object> argumentsKw); CallMessage(long requestId, String procedure, @Nullable List<Object> arguments, @Nullable Map<String, Object> argumentsKw, boolean discloseMe); static CallMessage deserialize(JsonParser jp); @Override void serialize(JsonGenerator generator); long getRequestId(); String getProcedure(); @Nullable List<Object> getArguments(); @Nullable Map<String, Object> getArgumentsKw(); boolean isDiscloseMe(); @Override String toString(); static final int CODE; }### Answer: @Test public void serializeTest() { CallMessage callMessage = new CallMessage(1, "call"); assertThat(callMessage.getCode()).isEqualTo(48); assertThat(callMessage.getRequestId()).isEqualTo(1); assertThat(callMessage.getProcedure()).isEqualTo("call"); assertThat(callMessage.isDiscloseMe()).isFalse(); assertThat(callMessage.getArguments()).isNull(); assertThat(callMessage.getArgumentsKw()).isNull(); String json = serializeToJson(callMessage); assertThat(json).isEqualTo("[48,1,{},\"call\"]"); callMessage = new CallMessage(1, "call", Arrays.asList("Hello world")); assertThat(callMessage.getCode()).isEqualTo(48); assertThat(callMessage.getRequestId()).isEqualTo(1); assertThat(callMessage.getProcedure()).isEqualTo("call"); assertThat(callMessage.isDiscloseMe()).isFalse(); assertThat(callMessage.getArguments()).containsExactly("Hello world"); assertThat(callMessage.getArgumentsKw()).isNull(); json = serializeToJson(callMessage); assertThat(json).isEqualTo("[48,1,{},\"call\",[\"Hello world\"]]"); Map<String, Object> argumentsKw = new HashMap<>(); argumentsKw.put("firstname", "John"); argumentsKw.put("surname", "Doe"); callMessage = new CallMessage(1, "call", Arrays.asList("johnny"), argumentsKw, false); assertThat(callMessage.getCode()).isEqualTo(48); assertThat(callMessage.getRequestId()).isEqualTo(1); assertThat(callMessage.getProcedure()).isEqualTo("call"); assertThat(callMessage.isDiscloseMe()).isFalse(); assertThat(callMessage.getArguments()).containsExactly("johnny"); assertThat(callMessage.getArgumentsKw()).containsExactly( MapEntry.entry("firstname", "John"), MapEntry.entry("surname", "Doe")); json = serializeToJson(callMessage); assertThat(json).isEqualTo( "[48,1,{},\"call\",[\"johnny\"],{\"firstname\":\"John\",\"surname\":\"Doe\"}]"); callMessage = new CallMessage(1, "call", Arrays.asList("Hello world"), null, true); assertThat(callMessage.getCode()).isEqualTo(48); assertThat(callMessage.getRequestId()).isEqualTo(1); assertThat(callMessage.getProcedure()).isEqualTo("call"); assertThat(callMessage.isDiscloseMe()).isTrue(); assertThat(callMessage.getArguments()).containsExactly("Hello world"); assertThat(callMessage.getArgumentsKw()).isNull(); json = serializeToJson(callMessage); assertThat(json) .isEqualTo("[48,1,{\"disclose_me\":true},\"call\",[\"Hello world\"]]"); }

### Question: ErrorMessage extends WampMessage { public static ErrorMessage deserialize(JsonParser jp) throws IOException { jp.nextToken(); int type = jp.getIntValue(); jp.nextToken(); long request = jp.getLongValue(); jp.nextToken(); ParserUtil.readObject(jp); jp.nextToken(); String error = jp.getValueAsString(); List<Object> arguments = null; JsonToken token = jp.nextToken(); if (token == JsonToken.START_ARRAY) { arguments = ParserUtil.readArray(jp); } Map<String, Object> argumentsKw = null; token = jp.nextToken(); if (token == JsonToken.START_OBJECT) { argumentsKw = ParserUtil.readObject(jp); } return new ErrorMessage(type, request, error, arguments, argumentsKw); } ErrorMessage(int type, long requestId, String error, @Nullable List<Object> arguments, @Nullable Map<String, Object> argumentsKw); ErrorMessage(ErrorMessage errorMessage, CallMessage callMessage); ErrorMessage(SubscribeMessage subscribeMessage, WampError error); ErrorMessage(UnsubscribeMessage unsubscribeMessage, WampError error); ErrorMessage(PublishMessage publishMessage, WampError error); ErrorMessage(RegisterMessage registerMessage, WampError error); ErrorMessage(UnregisterMessage unregisterMessage, WampError error); ErrorMessage(CallMessage callMessage, WampError error); ErrorMessage(CallMessage callMessage, String error, @Nullable List<Object> arguments, @Nullable Map<String, Object> argumentsKw); ErrorMessage(InvocationMessage invocationMessage, WampError error); static ErrorMessage deserialize(JsonParser jp); @Override void serialize(JsonGenerator generator); int getType(); long getRequestId(); String getError(); @Nullable List<Object> getArguments(); @Nullable Map<String, Object> getArgumentsKw(); @Override String toString(); }### Answer: @Test public void deserializeTest() throws IOException { String json = "[8, 64, 25349185, {}, \"wamp.error.procedure_already_exists\"]"; ErrorMessage errorMessage = WampMessage.deserialize(getJsonFactory(), json.getBytes(StandardCharsets.UTF_8)); assertThat(errorMessage.getCode()).isEqualTo(8); assertThat(errorMessage.getType()).isEqualTo(64); assertThat(errorMessage.getRequestId()).isEqualTo(25349185L); assertThat(errorMessage.getError()) .isEqualTo("wamp.error.procedure_already_exists"); assertThat(errorMessage.getArguments()).isNull(); assertThat(errorMessage.getArgumentsKw()).isNull(); json = "[8, 66, 788923562, {}, \"wamp.error.no_such_registration\",[\"No such registration\"]]"; errorMessage = WampMessage.deserialize(getJsonFactory(), json.getBytes(StandardCharsets.UTF_8)); assertThat(errorMessage.getCode()).isEqualTo(8); assertThat(errorMessage.getType()).isEqualTo(66); assertThat(errorMessage.getRequestId()).isEqualTo(788923562L); assertThat(errorMessage.getError()).isEqualTo("wamp.error.no_such_registration"); assertThat(errorMessage.getArguments()).containsExactly("No such registration"); assertThat(errorMessage.getArgumentsKw()).isNull(); json = "[8, 68, 6131533, {}, \"com.myapp.error.object_write_protected\", [\"Object is write protected.\"], {\"severity\": 3}]"; errorMessage = WampMessage.deserialize(getJsonFactory(), json.getBytes(StandardCharsets.UTF_8)); assertThat(errorMessage.getCode()).isEqualTo(8); assertThat(errorMessage.getType()).isEqualTo(68); assertThat(errorMessage.getRequestId()).isEqualTo(6131533L); assertThat(errorMessage.getError()) .isEqualTo("com.myapp.error.object_write_protected"); assertThat(errorMessage.getArguments()) .containsExactly("Object is write protected."); assertThat(errorMessage.getArgumentsKw()) .containsExactly(MapEntry.entry("severity", 3)); }

### Question: RegisteredMessage extends WampMessage { @Override public void serialize(JsonGenerator generator) throws IOException { generator.writeNumber(getCode()); generator.writeNumber(this.requestId); generator.writeNumber(this.registrationId); } RegisteredMessage(long requestId, long registrationId); RegisteredMessage(RegisterMessage registerMessage, long registrationId); static RegisteredMessage deserialize(JsonParser jp); @Override void serialize(JsonGenerator generator); long getRequestId(); long getRegistrationId(); @Override String toString(); }### Answer: @Test public void serializeTest() { RegisteredMessage registeredMessage = new RegisteredMessage(11, 127172L); assertThat(registeredMessage.getCode()).isEqualTo(65); assertThat(registeredMessage.getRequestId()).isEqualTo(11); assertThat(registeredMessage.getRegistrationId()).isEqualTo(127172L); String json = serializeToJson(registeredMessage); assertThat(json).isEqualTo("[65,11,127172]"); }

### Question: RegisteredMessage extends WampMessage { public static RegisteredMessage deserialize(JsonParser jp) throws IOException { jp.nextToken(); long request = jp.getLongValue(); jp.nextToken(); long registration = jp.getLongValue(); return new RegisteredMessage(request, registration); } RegisteredMessage(long requestId, long registrationId); RegisteredMessage(RegisterMessage registerMessage, long registrationId); static RegisteredMessage deserialize(JsonParser jp); @Override void serialize(JsonGenerator generator); long getRequestId(); long getRegistrationId(); @Override String toString(); }### Answer: @Test public void deserializeTest() throws IOException { String json = "[65, 25349185, 2103333224]"; RegisteredMessage registeredMessage = WampMessage.deserialize(getJsonFactory(), json.getBytes(StandardCharsets.UTF_8)); assertThat(registeredMessage.getCode()).isEqualTo(65); assertThat(registeredMessage.getRequestId()).isEqualTo(25349185L); assertThat(registeredMessage.getRegistrationId()).isEqualTo(2103333224L); }

### Question: UnsubscribedMessage extends WampMessage { @Override public void serialize(JsonGenerator generator) throws IOException { generator.writeNumber(getCode()); generator.writeNumber(this.requestId); if (this.subscriptionId != null || this.reason != null) { generator.writeStartObject(); if (this.reason != null) { generator.writeStringField("reason", this.reason); } if (this.subscriptionId != null) { generator.writeNumberField("subscription", this.subscriptionId); } generator.writeEndObject(); } } UnsubscribedMessage(long requestId); UnsubscribedMessage(long requestId, @Nullable Long subscriptionId, @Nullable String reason); UnsubscribedMessage(UnsubscribeMessage unsubscribeMessage); static UnsubscribedMessage deserialize(JsonParser jp); @Override void serialize(JsonGenerator generator); long getRequestId(); @Nullable Long getSubscriptionId(); @Nullable String getReason(); @Override String toString(); }### Answer: @Test public void serializeTest() { UnsubscribedMessage unsubscribedMessage = new UnsubscribedMessage(1); assertThat(unsubscribedMessage.getCode()).isEqualTo(35); assertThat(unsubscribedMessage.getRequestId()).isEqualTo(1); assertThat(unsubscribedMessage.getSubscriptionId()).isNull(); assertThat(unsubscribedMessage.getReason()).isNull(); String json = serializeToJson(unsubscribedMessage); assertThat(json).isEqualTo("[35,1]"); unsubscribedMessage = new UnsubscribedMessage(2, 1208L, "removed"); assertThat(unsubscribedMessage.getCode()).isEqualTo(35); assertThat(unsubscribedMessage.getRequestId()).isEqualTo(2); assertThat(unsubscribedMessage.getSubscriptionId()).isEqualTo(1208L); assertThat(unsubscribedMessage.getReason()).isEqualTo("removed"); json = serializeToJson(unsubscribedMessage); assertThat(json) .isEqualTo("[35,2,{\"reason\":\"removed\",\"subscription\":1208}]"); }

### Question: UnsubscribedMessage extends WampMessage { public static UnsubscribedMessage deserialize(JsonParser jp) throws IOException { jp.nextToken(); long request = jp.getLongValue(); Long subscriptionId = null; String reason = null; JsonToken token = jp.nextToken(); if (token == JsonToken.START_OBJECT) { Map<String, Object> details = ParserUtil.readObject(jp); reason = (String) details.get("reason"); Object subscriptionObj = details.get("subscription"); if (subscriptionObj != null) { subscriptionId = ((Number) subscriptionObj).longValue(); } } return new UnsubscribedMessage(request, subscriptionId, reason); } UnsubscribedMessage(long requestId); UnsubscribedMessage(long requestId, @Nullable Long subscriptionId, @Nullable String reason); UnsubscribedMessage(UnsubscribeMessage unsubscribeMessage); static UnsubscribedMessage deserialize(JsonParser jp); @Override void serialize(JsonGenerator generator); long getRequestId(); @Nullable Long getSubscriptionId(); @Nullable String getReason(); @Override String toString(); }### Answer: @Test public void deserializeTest() throws IOException { String json = "[35, 85346237]"; UnsubscribedMessage unsubscribedMessage = WampMessage .deserialize(getJsonFactory(), json.getBytes(StandardCharsets.UTF_8)); assertThat(unsubscribedMessage.getCode()).isEqualTo(35); assertThat(unsubscribedMessage.getRequestId()).isEqualTo(85346237L); assertThat(unsubscribedMessage.getSubscriptionId()).isNull(); assertThat(unsubscribedMessage.getReason()).isNull(); json = "[35, 0, {\"subscription\":1213,\"reason\":\"the reason\"}]"; unsubscribedMessage = WampMessage.deserialize(getJsonFactory(), json.getBytes(StandardCharsets.UTF_8)); assertThat(unsubscribedMessage.getCode()).isEqualTo(35); assertThat(unsubscribedMessage.getRequestId()).isEqualTo(0); assertThat(unsubscribedMessage.getSubscriptionId()).isEqualTo(1213L); assertThat(unsubscribedMessage.getReason()).isEqualTo("the reason"); }

### Question: PublishedMessage extends WampMessage { @Override public void serialize(JsonGenerator generator) throws IOException { generator.writeNumber(getCode()); generator.writeNumber(this.requestId); generator.writeNumber(this.publicationId); } PublishedMessage(long requestId, long publicationId); PublishedMessage(PublishMessage publishMessage, long publicationId); static PublishedMessage deserialize(JsonParser jp); @Override void serialize(JsonGenerator generator); long getRequestId(); long getPublicationId(); @Override String toString(); }### Answer: @Test public void serializeTest() { PublishedMessage publishedMessage = new PublishedMessage(44, 121); assertThat(publishedMessage.getCode()).isEqualTo(17); assertThat(publishedMessage.getRequestId()).isEqualTo(44); assertThat(publishedMessage.getPublicationId()).isEqualTo(121); String json = serializeToJson(publishedMessage); assertThat(json).isEqualTo("[17,44,121]"); }

### Question: PublishedMessage extends WampMessage { public static PublishedMessage deserialize(JsonParser jp) throws IOException { jp.nextToken(); long request = jp.getLongValue(); jp.nextToken(); long subscription = jp.getLongValue(); return new PublishedMessage(request, subscription); } PublishedMessage(long requestId, long publicationId); PublishedMessage(PublishMessage publishMessage, long publicationId); static PublishedMessage deserialize(JsonParser jp); @Override void serialize(JsonGenerator generator); long getRequestId(); long getPublicationId(); @Override String toString(); }### Answer: @Test public void deserializeTest() throws IOException { String json = "[17, 239714735, 4429313566]"; PublishedMessage publishedMessage = WampMessage.deserialize(getJsonFactory(), json.getBytes(StandardCharsets.UTF_8)); assertThat(publishedMessage.getCode()).isEqualTo(17); assertThat(publishedMessage.getRequestId()).isEqualTo(239714735L); assertThat(publishedMessage.getPublicationId()).isEqualTo(4429313566L); }

### Question: ResultMessage extends WampMessage { @Override public void serialize(JsonGenerator generator) throws IOException { generator.writeNumber(getCode()); generator.writeNumber(this.requestId); generator.writeStartObject(); generator.writeEndObject(); if (this.argumentsKw != null) { if (this.arguments == null) { generator.writeStartArray(); generator.writeEndArray(); } else { generator.writeObject(this.arguments); } generator.writeObject(this.argumentsKw); } else if (this.arguments != null) { generator.writeObject(this.arguments); } } ResultMessage(long requestId, @Nullable List<Object> arguments, @Nullable Map<String, Object> argumentsKw); ResultMessage(CallMessage callMessage, @Nullable List<Object> arguments, @Nullable Map<String, Object> argumentsKw); ResultMessage(YieldMessage yieldMessage, CallMessage callMessage); static ResultMessage deserialize(JsonParser jp); @Override void serialize(JsonGenerator generator); long getRequestId(); @Nullable List<Object> getArguments(); @Nullable Map<String, Object> getArgumentsKw(); @Override String toString(); final long requestId; }### Answer: @Test public void serializeTest() { ResultMessage resultMessage = new ResultMessage(111, null, null); assertThat(resultMessage.getCode()).isEqualTo(50); assertThat(resultMessage.getRequestId()).isEqualTo(111); assertThat(resultMessage.getArguments()).isNull(); assertThat(resultMessage.getArgumentsKw()).isNull(); String json = serializeToJson(resultMessage); assertThat(json).isEqualTo("[50,111,{}]"); resultMessage = new ResultMessage(111, Arrays.asList("Hello world"), null); assertThat(resultMessage.getCode()).isEqualTo(50); assertThat(resultMessage.getRequestId()).isEqualTo(111); assertThat(resultMessage.getArguments()).containsExactly("Hello world"); assertThat(resultMessage.getArgumentsKw()).isNull(); json = serializeToJson(resultMessage); assertThat(json).isEqualTo("[50,111,{},[\"Hello world\"]]"); Map<String, Object> argumentsKw = new HashMap<>(); argumentsKw.put("firstname", "John"); argumentsKw.put("surname", "Doe"); resultMessage = new ResultMessage(111, Arrays.asList("johnny"), argumentsKw); assertThat(resultMessage.getCode()).isEqualTo(50); assertThat(resultMessage.getRequestId()).isEqualTo(111); assertThat(resultMessage.getArguments()).containsExactly("johnny"); assertThat(resultMessage.getArgumentsKw()).containsExactly( MapEntry.entry("firstname", "John"), MapEntry.entry("surname", "Doe")); json = serializeToJson(resultMessage); assertThat(json).isEqualTo( "[50,111,{},[\"johnny\"],{\"firstname\":\"John\",\"surname\":\"Doe\"}]"); argumentsKw = new HashMap<>(); argumentsKw.put("firstname", "John"); argumentsKw.put("surname", "Doe"); resultMessage = new ResultMessage(111, null, argumentsKw); assertThat(resultMessage.getCode()).isEqualTo(50); assertThat(resultMessage.getRequestId()).isEqualTo(111); assertThat(resultMessage.getArguments()).isNull(); assertThat(resultMessage.getArgumentsKw()).containsExactly( MapEntry.entry("firstname", "John"), MapEntry.entry("surname", "Doe")); json = serializeToJson(resultMessage); assertThat(json) .isEqualTo("[50,111,{},[],{\"firstname\":\"John\",\"surname\":\"Doe\"}]"); }

### Question: ResultMessage extends WampMessage { public static ResultMessage deserialize(JsonParser jp) throws IOException { jp.nextToken(); long request = jp.getLongValue(); jp.nextToken(); ParserUtil.readObject(jp); List<Object> arguments = null; JsonToken token = jp.nextToken(); if (token == JsonToken.START_ARRAY) { arguments = ParserUtil.readArray(jp); } Map<String, Object> argumentsKw = null; token = jp.nextToken(); if (token == JsonToken.START_OBJECT) { argumentsKw = ParserUtil.readObject(jp); } return new ResultMessage(request, arguments, argumentsKw); } ResultMessage(long requestId, @Nullable List<Object> arguments, @Nullable Map<String, Object> argumentsKw); ResultMessage(CallMessage callMessage, @Nullable List<Object> arguments, @Nullable Map<String, Object> argumentsKw); ResultMessage(YieldMessage yieldMessage, CallMessage callMessage); static ResultMessage deserialize(JsonParser jp); @Override void serialize(JsonGenerator generator); long getRequestId(); @Nullable List<Object> getArguments(); @Nullable Map<String, Object> getArgumentsKw(); @Override String toString(); final long requestId; }### Answer: @Test public void deserializeTest() throws IOException { String json = "[50, 7814135, {}]"; ResultMessage resultMessage = WampMessage.deserialize(getJsonFactory(), json.getBytes(StandardCharsets.UTF_8)); assertThat(resultMessage.getCode()).isEqualTo(50); assertThat(resultMessage.getRequestId()).isEqualTo(7814135L); assertThat(resultMessage.getArguments()).isNull(); assertThat(resultMessage.getArgumentsKw()).isNull(); json = "[50, 7814135, {}, [\"Hello, world!\"]]"; resultMessage = WampMessage.deserialize(getJsonFactory(), json.getBytes(StandardCharsets.UTF_8)); assertThat(resultMessage.getCode()).isEqualTo(50); assertThat(resultMessage.getRequestId()).isEqualTo(7814135L); assertThat(resultMessage.getArguments()).containsExactly("Hello, world!"); assertThat(resultMessage.getArgumentsKw()).isNull(); json = "[50, 7814135, {}, [30]]"; resultMessage = WampMessage.deserialize(getJsonFactory(), json.getBytes(StandardCharsets.UTF_8)); assertThat(resultMessage.getCode()).isEqualTo(50); assertThat(resultMessage.getRequestId()).isEqualTo(7814135L); assertThat(resultMessage.getArguments()).containsExactly(30); assertThat(resultMessage.getArgumentsKw()).isNull(); json = "[50, 7814135, {}, [], {\"userid\": 123, \"karma\": 10}]"; resultMessage = WampMessage.deserialize(getJsonFactory(), json.getBytes(StandardCharsets.UTF_8)); assertThat(resultMessage.getCode()).isEqualTo(50); assertThat(resultMessage.getRequestId()).isEqualTo(7814135L); assertThat(resultMessage.getArguments()).isEmpty(); assertThat(resultMessage.getArgumentsKw()) .containsOnly(MapEntry.entry("userid", 123), MapEntry.entry("karma", 10)); json = "[50, 7814135, {}, [\"a\",\"b\",\"c\"], {\"userid\": 123, \"karma\": 10}]"; resultMessage = WampMessage.deserialize(getJsonFactory(), json.getBytes(StandardCharsets.UTF_8)); assertThat(resultMessage.getCode()).isEqualTo(50); assertThat(resultMessage.getRequestId()).isEqualTo(7814135L); assertThat(resultMessage.getArguments()).containsExactly("a", "b", "c"); assertThat(resultMessage.getArgumentsKw()) .containsOnly(MapEntry.entry("userid", 123), MapEntry.entry("karma", 10)); }

### Question: RegisterMessage extends WampMessage { @Override public void serialize(JsonGenerator generator) throws IOException { generator.writeNumber(getCode()); generator.writeNumber(this.requestId); generator.writeStartObject(); if (this.discloseCaller) { generator.writeBooleanField("disclose_caller", this.discloseCaller); } generator.writeEndObject(); generator.writeString(this.procedure); } RegisterMessage(long requestId, String procedure); RegisterMessage(long requestId, String procedure, boolean discloseCaller); static RegisterMessage deserialize(JsonParser jp); @Override void serialize(JsonGenerator generator); long getRequestId(); String getProcedure(); boolean isDiscloseCaller(); @Override String toString(); static final int CODE; }### Answer: @Test public void serializeTest() { RegisterMessage registerMessage = new RegisterMessage(11, "bean.method"); assertThat(registerMessage.getCode()).isEqualTo(64); assertThat(registerMessage.getRequestId()).isEqualTo(11); assertThat(registerMessage.getProcedure()).isEqualTo("bean.method"); assertThat(registerMessage.isDiscloseCaller()).isFalse(); String json = serializeToJson(registerMessage); assertThat(json).isEqualTo("[64,11,{},\"bean.method\"]"); registerMessage = new RegisterMessage(927639114088448L, "com.maypp.add2", true); assertThat(registerMessage.getCode()).isEqualTo(64); assertThat(registerMessage.getRequestId()).isEqualTo(927639114088448L); assertThat(registerMessage.getProcedure()).isEqualTo("com.maypp.add2"); assertThat(registerMessage.isDiscloseCaller()).isTrue(); json = serializeToJson(registerMessage); assertThat(json).isEqualTo( "[64,927639114088448,{\"disclose_caller\":true},\"com.maypp.add2\"]"); }

### Question: RegisterMessage extends WampMessage { public static RegisterMessage deserialize(JsonParser jp) throws IOException { jp.nextToken(); long request = jp.getLongValue(); boolean discloseCaller = false; jp.nextToken(); Map<String, Object> options = ParserUtil.readObject(jp); if (options != null) { discloseCaller = (boolean) options.getOrDefault("disclose_caller", false); } jp.nextToken(); String procedure = jp.getValueAsString(); return new RegisterMessage(request, procedure, discloseCaller); } RegisterMessage(long requestId, String procedure); RegisterMessage(long requestId, String procedure, boolean discloseCaller); static RegisterMessage deserialize(JsonParser jp); @Override void serialize(JsonGenerator generator); long getRequestId(); String getProcedure(); boolean isDiscloseCaller(); @Override String toString(); static final int CODE; }### Answer: @Test public void deserializeTest() throws IOException { String json = "[64, 25349185, {}, \"com.myapp.myprocedure\"]"; RegisterMessage registerMessage = WampMessage.deserialize(getJsonFactory(), json.getBytes(StandardCharsets.UTF_8)); assertThat(registerMessage.getCode()).isEqualTo(64); assertThat(registerMessage.getRequestId()).isEqualTo(25349185L); assertThat(registerMessage.getProcedure()).isEqualTo("com.myapp.myprocedure"); assertThat(registerMessage.isDiscloseCaller()).isFalse(); json = "[64, 927639114088448, {\"disclose_caller\":true},\"com.maypp.add2\"]"; registerMessage = WampMessage.deserialize(getJsonFactory(), json.getBytes(StandardCharsets.UTF_8)); assertThat(registerMessage.getCode()).isEqualTo(64); assertThat(registerMessage.getRequestId()).isEqualTo(927639114088448L); assertThat(registerMessage.getProcedure()).isEqualTo("com.maypp.add2"); assertThat(registerMessage.isDiscloseCaller()).isTrue(); }

### Question: UnsubscribeMessage extends WampMessage { @Override public void serialize(JsonGenerator generator) throws IOException { generator.writeNumber(getCode()); generator.writeNumber(this.requestId); generator.writeNumber(this.subscriptionId); } UnsubscribeMessage(long requestId, long subscriptionId); static UnsubscribeMessage deserialize(JsonParser jp); @Override void serialize(JsonGenerator generator); long getRequestId(); long getSubscriptionId(); @Override String toString(); }### Answer: @Test public void serializeTest() { UnsubscribeMessage unsubscribeMessage = new UnsubscribeMessage(1, 2); assertThat(unsubscribeMessage.getCode()).isEqualTo(34); assertThat(unsubscribeMessage.getRequestId()).isEqualTo(1); assertThat(unsubscribeMessage.getSubscriptionId()).isEqualTo(2); String json = serializeToJson(unsubscribeMessage); assertThat(json).isEqualTo("[34,1,2]"); }

### Question: UnsubscribeMessage extends WampMessage { public static UnsubscribeMessage deserialize(JsonParser jp) throws IOException { jp.nextToken(); long request = jp.getLongValue(); jp.nextToken(); long subscription = jp.getLongValue(); return new UnsubscribeMessage(request, subscription); } UnsubscribeMessage(long requestId, long subscriptionId); static UnsubscribeMessage deserialize(JsonParser jp); @Override void serialize(JsonGenerator generator); long getRequestId(); long getSubscriptionId(); @Override String toString(); }### Answer: @Test public void deserializeTest() throws IOException { String json = "[34, 85346237, 5512315355]"; UnsubscribeMessage unsubscribeMessage = WampMessage.deserialize(getJsonFactory(), json.getBytes(StandardCharsets.UTF_8)); assertThat(unsubscribeMessage.getCode()).isEqualTo(34); assertThat(unsubscribeMessage.getRequestId()).isEqualTo(85346237L); assertThat(unsubscribeMessage.getSubscriptionId()).isEqualTo(5512315355L); }

### Question: UnregisteredMessage extends WampMessage { @Override public void serialize(JsonGenerator generator) throws IOException { generator.writeNumber(getCode()); generator.writeNumber(this.requestId); if (this.registrationId != null || this.reason != null) { generator.writeStartObject(); if (this.reason != null) { generator.writeStringField("reason", this.reason); } if (this.registrationId != null) { generator.writeNumberField("registration", this.registrationId); } generator.writeEndObject(); } } UnregisteredMessage(long requestId); UnregisteredMessage(long requestId, @Nullable Long registrationId, @Nullable String reason); UnregisteredMessage(UnregisterMessage unregisterMessage); static UnregisteredMessage deserialize(JsonParser jp); @Override void serialize(JsonGenerator generator); long getRequestId(); @Nullable Long getRegistrationId(); @Nullable String getReason(); @Override String toString(); }### Answer: @Test public void serializeTest() { UnregisteredMessage unregisteredMessage = new UnregisteredMessage(13); assertThat(unregisteredMessage.getCode()).isEqualTo(67); assertThat(unregisteredMessage.getRequestId()).isEqualTo(13); assertThat(unregisteredMessage.getRegistrationId()).isNull(); assertThat(unregisteredMessage.getReason()).isNull(); String json = serializeToJson(unregisteredMessage); assertThat(json).isEqualTo("[67,13]"); unregisteredMessage = new UnregisteredMessage(13, 333L, "a reason"); assertThat(unregisteredMessage.getCode()).isEqualTo(67); assertThat(unregisteredMessage.getRequestId()).isEqualTo(13); assertThat(unregisteredMessage.getRegistrationId()).isEqualTo(333); assertThat(unregisteredMessage.getReason()).isEqualTo("a reason"); json = serializeToJson(unregisteredMessage); assertThat(json) .isEqualTo("[67,13,{\"reason\":\"a reason\",\"registration\":333}]"); }

### Question: UnregisteredMessage extends WampMessage { public static UnregisteredMessage deserialize(JsonParser jp) throws IOException { jp.nextToken(); long request = jp.getLongValue(); Long registrationId = null; String reason = null; JsonToken token = jp.nextToken(); if (token == JsonToken.START_OBJECT) { Map<String, Object> details = ParserUtil.readObject(jp); reason = (String) details.get("reason"); Object registrationObj = details.get("registration"); if (registrationObj != null) { registrationId = ((Number) registrationObj).longValue(); } } return new UnregisteredMessage(request, registrationId, reason); } UnregisteredMessage(long requestId); UnregisteredMessage(long requestId, @Nullable Long registrationId, @Nullable String reason); UnregisteredMessage(UnregisterMessage unregisterMessage); static UnregisteredMessage deserialize(JsonParser jp); @Override void serialize(JsonGenerator generator); long getRequestId(); @Nullable Long getRegistrationId(); @Nullable String getReason(); @Override String toString(); }### Answer: @Test public void deserializeTest() throws IOException { String json = "[67, 788923562]"; UnregisteredMessage unregisteredMessage = WampMessage .deserialize(getJsonFactory(), json.getBytes(StandardCharsets.UTF_8)); assertThat(unregisteredMessage.getCode()).isEqualTo(67); assertThat(unregisteredMessage.getRequestId()).isEqualTo(788923562L); assertThat(unregisteredMessage.getRegistrationId()).isNull(); assertThat(unregisteredMessage.getReason()).isNull(); json = "[67, 0, {\"registration\":334,\"reason\":\"another reason\"}]"; unregisteredMessage = WampMessage.deserialize(getJsonFactory(), json.getBytes(StandardCharsets.UTF_8)); assertThat(unregisteredMessage.getCode()).isEqualTo(67); assertThat(unregisteredMessage.getRequestId()).isEqualTo(0); assertThat(unregisteredMessage.getRegistrationId()).isEqualTo(334); assertThat(unregisteredMessage.getReason()).isEqualTo("another reason"); }

### Question: YieldMessage extends WampMessage { @Override public void serialize(JsonGenerator generator) throws IOException { generator.writeNumber(getCode()); generator.writeNumber(this.requestId); generator.writeStartObject(); generator.writeEndObject(); if (this.argumentsKw != null) { if (this.arguments == null) { generator.writeStartArray(); generator.writeEndArray(); } else { generator.writeObject(this.arguments); } generator.writeObject(this.argumentsKw); } else if (this.arguments != null) { generator.writeObject(this.arguments); } } YieldMessage(long requestId, @Nullable List<Object> arguments, @Nullable Map<String, Object> argumentsKw); static YieldMessage deserialize(JsonParser jp); @Override void serialize(JsonGenerator generator); long getRequestId(); @Nullable List<Object> getArguments(); @Nullable Map<String, Object> getArgumentsKw(); @Override String toString(); }### Answer: @Test public void serializeTest() { YieldMessage yieldMessage = new YieldMessage(111, null, null); assertThat(yieldMessage.getCode()).isEqualTo(70); assertThat(yieldMessage.getRequestId()).isEqualTo(111); assertThat(yieldMessage.getArguments()).isNull(); assertThat(yieldMessage.getArgumentsKw()).isNull(); String json = serializeToJson(yieldMessage); assertThat(json).isEqualTo("[70,111,{}]"); yieldMessage = new YieldMessage(111, Arrays.asList("Hello world"), null); assertThat(yieldMessage.getCode()).isEqualTo(70); assertThat(yieldMessage.getRequestId()).isEqualTo(111); assertThat(yieldMessage.getArguments()).containsExactly("Hello world"); assertThat(yieldMessage.getArgumentsKw()).isNull(); json = serializeToJson(yieldMessage); assertThat(json).isEqualTo("[70,111,{},[\"Hello world\"]]"); Map<String, Object> argumentsKw = new HashMap<>(); argumentsKw.put("firstname", "John"); argumentsKw.put("surname", "Doe"); yieldMessage = new YieldMessage(111, Arrays.asList("johnny"), argumentsKw); assertThat(yieldMessage.getCode()).isEqualTo(70); assertThat(yieldMessage.getRequestId()).isEqualTo(111); assertThat(yieldMessage.getArguments()).containsExactly("johnny"); assertThat(yieldMessage.getArgumentsKw()).containsExactly( MapEntry.entry("firstname", "John"), MapEntry.entry("surname", "Doe")); json = serializeToJson(yieldMessage); assertThat(json).isEqualTo( "[70,111,{},[\"johnny\"],{\"firstname\":\"John\",\"surname\":\"Doe\"}]"); argumentsKw = new HashMap<>(); argumentsKw.put("firstname", "John"); argumentsKw.put("surname", "Doe"); yieldMessage = new YieldMessage(111, null, argumentsKw); assertThat(yieldMessage.getCode()).isEqualTo(70); assertThat(yieldMessage.getRequestId()).isEqualTo(111); assertThat(yieldMessage.getArguments()).isNull(); assertThat(yieldMessage.getArgumentsKw()).containsExactly( MapEntry.entry("firstname", "John"), MapEntry.entry("surname", "Doe")); json = serializeToJson(yieldMessage); assertThat(json) .isEqualTo("[70,111,{},[],{\"firstname\":\"John\",\"surname\":\"Doe\"}]"); }

### Question: YieldMessage extends WampMessage { public static YieldMessage deserialize(JsonParser jp) throws IOException { jp.nextToken(); long request = jp.getLongValue(); jp.nextToken(); ParserUtil.readObject(jp); List<Object> arguments = null; JsonToken token = jp.nextToken(); if (token == JsonToken.START_ARRAY) { arguments = ParserUtil.readArray(jp); } Map<String, Object> argumentsKw = null; token = jp.nextToken(); if (token == JsonToken.START_OBJECT) { argumentsKw = ParserUtil.readObject(jp); } return new YieldMessage(request, arguments, argumentsKw); } YieldMessage(long requestId, @Nullable List<Object> arguments, @Nullable Map<String, Object> argumentsKw); static YieldMessage deserialize(JsonParser jp); @Override void serialize(JsonGenerator generator); long getRequestId(); @Nullable List<Object> getArguments(); @Nullable Map<String, Object> getArgumentsKw(); @Override String toString(); }### Answer: @Test public void deserializeTest() throws IOException { String json = "[70, 6131533, {}]"; YieldMessage yieldMessage = WampMessage.deserialize(getJsonFactory(), json.getBytes(StandardCharsets.UTF_8)); assertThat(yieldMessage.getCode()).isEqualTo(70); assertThat(yieldMessage.getRequestId()).isEqualTo(6131533L); assertThat(yieldMessage.getArguments()).isNull(); assertThat(yieldMessage.getArgumentsKw()).isNull(); json = "[70, 6131533, {}, [\"Hello, world!\"]]"; yieldMessage = WampMessage.deserialize(getJsonFactory(), json.getBytes(StandardCharsets.UTF_8)); assertThat(yieldMessage.getCode()).isEqualTo(70); assertThat(yieldMessage.getRequestId()).isEqualTo(6131533L); assertThat(yieldMessage.getArguments()).containsExactly("Hello, world!"); assertThat(yieldMessage.getArgumentsKw()).isNull(); json = "[70, 6131533, {}, [30]]"; yieldMessage = WampMessage.deserialize(getJsonFactory(), json.getBytes(StandardCharsets.UTF_8)); assertThat(yieldMessage.getCode()).isEqualTo(70); assertThat(yieldMessage.getRequestId()).isEqualTo(6131533L); assertThat(yieldMessage.getArguments()).containsExactly(30); assertThat(yieldMessage.getArgumentsKw()).isNull(); json = "[70, 6131533, {}, [], {\"userid\": 123, \"karma\": 10}]"; yieldMessage = WampMessage.deserialize(getJsonFactory(), json.getBytes(StandardCharsets.UTF_8)); assertThat(yieldMessage.getCode()).isEqualTo(70); assertThat(yieldMessage.getRequestId()).isEqualTo(6131533L); assertThat(yieldMessage.getArguments()).isEmpty(); assertThat(yieldMessage.getArgumentsKw()) .containsOnly(MapEntry.entry("userid", 123), MapEntry.entry("karma", 10)); json = "[70, 6131533, {}, [\"a\",\"b\",\"c\"], {\"userid\": 123, \"karma\": 10}]"; yieldMessage = WampMessage.deserialize(getJsonFactory(), json.getBytes(StandardCharsets.UTF_8)); assertThat(yieldMessage.getCode()).isEqualTo(70); assertThat(yieldMessage.getRequestId()).isEqualTo(6131533L); assertThat(yieldMessage.getArguments()).containsExactly("a", "b", "c"); assertThat(yieldMessage.getArgumentsKw()) .containsOnly(MapEntry.entry("userid", 123), MapEntry.entry("karma", 10)); }

### Question: UnregisterMessage extends WampMessage { @Override public void serialize(JsonGenerator generator) throws IOException { generator.writeNumber(getCode()); generator.writeNumber(this.requestId); generator.writeNumber(this.registrationId); } UnregisterMessage(long requestId, long registrationId); static UnregisterMessage deserialize(JsonParser jp); @Override void serialize(JsonGenerator generator); long getRequestId(); long getRegistrationId(); @Override String toString(); }### Answer: @Test public void serializeTest() { UnregisterMessage unregisterMessage = new UnregisterMessage(14, 23); assertThat(unregisterMessage.getCode()).isEqualTo(66); assertThat(unregisterMessage.getRequestId()).isEqualTo(14); assertThat(unregisterMessage.getRegistrationId()).isEqualTo(23); String json = serializeToJson(unregisterMessage); assertThat(json).isEqualTo("[66,14,23]"); }

### Question: UnregisterMessage extends WampMessage { public static UnregisterMessage deserialize(JsonParser jp) throws IOException { jp.nextToken(); long request = jp.getLongValue(); jp.nextToken(); long registration = jp.getLongValue(); return new UnregisterMessage(request, registration); } UnregisterMessage(long requestId, long registrationId); static UnregisterMessage deserialize(JsonParser jp); @Override void serialize(JsonGenerator generator); long getRequestId(); long getRegistrationId(); @Override String toString(); }### Answer: @Test public void deserializeTest() throws IOException { String json = "[66, 788923562, 2103333224]"; UnregisterMessage unregisterMessage = WampMessage.deserialize(getJsonFactory(), json.getBytes(StandardCharsets.UTF_8)); assertThat(unregisterMessage.getCode()).isEqualTo(66); assertThat(unregisterMessage.getRequestId()).isEqualTo(788923562L); assertThat(unregisterMessage.getRegistrationId()).isEqualTo(2103333224L); }

### Question: SubscribeMessage extends WampMessage { @Override public void serialize(JsonGenerator generator) throws IOException { generator.writeNumber(getCode()); generator.writeNumber(this.requestId); generator.writeStartObject(); if (this.matchPolicy != MatchPolicy.EXACT) { generator.writeStringField("match", this.matchPolicy.getExternalValue()); } if (this.getRetained) { generator.writeBooleanField("get_retained", this.getRetained); } generator.writeEndObject(); generator.writeString(this.topic); } SubscribeMessage(long requestId, String topic); SubscribeMessage(long requestId, String topic, boolean get_retained); SubscribeMessage(long requestId, String topic, MatchPolicy match); SubscribeMessage(long requestId, String topic, MatchPolicy match, boolean getRetained); static SubscribeMessage deserialize(JsonParser jp); @Override void serialize(JsonGenerator generator); long getRequestId(); MatchPolicy getMatchPolicy(); String getTopic(); boolean isGetRetained(); @Override String toString(); static final int CODE; }### Answer: @Test public void serializeTest() { SubscribeMessage subscribeMessage = new SubscribeMessage(1, "topic", MatchPolicy.PREFIX, false); assertThat(subscribeMessage.getCode()).isEqualTo(32); assertThat(subscribeMessage.getRequestId()).isEqualTo(1); assertThat(subscribeMessage.getTopic()).isEqualTo("topic"); assertThat(subscribeMessage.getMatchPolicy()).isEqualTo(MatchPolicy.PREFIX); assertThat(subscribeMessage.isGetRetained()).isFalse(); String json = serializeToJson(subscribeMessage); assertThat(json).isEqualTo("[32,1,{\"match\":\"prefix\"},\"topic\"]"); subscribeMessage = new SubscribeMessage(2, "topic2"); assertThat(subscribeMessage.getCode()).isEqualTo(32); assertThat(subscribeMessage.getRequestId()).isEqualTo(2); assertThat(subscribeMessage.getTopic()).isEqualTo("topic2"); assertThat(subscribeMessage.getMatchPolicy()).isEqualTo(MatchPolicy.EXACT); assertThat(subscribeMessage.isGetRetained()).isFalse(); json = serializeToJson(subscribeMessage); assertThat(json).isEqualTo("[32,2,{},\"topic2\"]"); subscribeMessage = new SubscribeMessage(2, "topic2", true); assertThat(subscribeMessage.getCode()).isEqualTo(32); assertThat(subscribeMessage.getRequestId()).isEqualTo(2); assertThat(subscribeMessage.getTopic()).isEqualTo("topic2"); assertThat(subscribeMessage.getMatchPolicy()).isEqualTo(MatchPolicy.EXACT); assertThat(subscribeMessage.isGetRetained()).isTrue(); json = serializeToJson(subscribeMessage); assertThat(json).isEqualTo("[32,2,{\"get_retained\":true},\"topic2\"]"); subscribeMessage = new SubscribeMessage(2, "topic2", MatchPolicy.WILDCARD, true); assertThat(subscribeMessage.getCode()).isEqualTo(32); assertThat(subscribeMessage.getRequestId()).isEqualTo(2); assertThat(subscribeMessage.getTopic()).isEqualTo("topic2"); assertThat(subscribeMessage.getMatchPolicy()).isEqualTo(MatchPolicy.WILDCARD); assertThat(subscribeMessage.isGetRetained()).isTrue(); json = serializeToJson(subscribeMessage); assertThat(json).isEqualTo( "[32,2,{\"match\":\"wildcard\",\"get_retained\":true},\"topic2\"]"); }

### Question: SubscribeMessage extends WampMessage { public static SubscribeMessage deserialize(JsonParser jp) throws IOException { jp.nextToken(); long request = jp.getLongValue(); MatchPolicy match = MatchPolicy.EXACT; jp.nextToken(); boolean getRetained = false; Map<String, Object> options = ParserUtil.readObject(jp); if (options != null) { String extValue = (String) options.get("match"); if (extValue != null) { match = MatchPolicy.fromExtValue(extValue); if (match == null) { match = MatchPolicy.EXACT; } } getRetained = (boolean) options.getOrDefault("get_retained", false); } jp.nextToken(); String topic = jp.getValueAsString(); return new SubscribeMessage(request, topic, match, getRetained); } SubscribeMessage(long requestId, String topic); SubscribeMessage(long requestId, String topic, boolean get_retained); SubscribeMessage(long requestId, String topic, MatchPolicy match); SubscribeMessage(long requestId, String topic, MatchPolicy match, boolean getRetained); static SubscribeMessage deserialize(JsonParser jp); @Override void serialize(JsonGenerator generator); long getRequestId(); MatchPolicy getMatchPolicy(); String getTopic(); boolean isGetRetained(); @Override String toString(); static final int CODE; }### Answer: @Test public void deserializeTest() throws IOException { String json = "[32,1,{\"match\":\"prefix\"},\"topic\"]"; SubscribeMessage subscribeMessage = WampMessage.deserialize(getJsonFactory(), json.getBytes(StandardCharsets.UTF_8)); assertThat(subscribeMessage.getCode()).isEqualTo(32); assertThat(subscribeMessage.getRequestId()).isEqualTo(1); assertThat(subscribeMessage.getTopic()).isEqualTo("topic"); assertThat(subscribeMessage.getMatchPolicy()).isEqualTo(MatchPolicy.PREFIX); assertThat(subscribeMessage.isGetRetained()).isFalse(); json = "[32,2,{},\"topic2\"]"; subscribeMessage = WampMessage.deserialize(getJsonFactory(), json.getBytes(StandardCharsets.UTF_8)); assertThat(subscribeMessage.getCode()).isEqualTo(32); assertThat(subscribeMessage.getRequestId()).isEqualTo(2); assertThat(subscribeMessage.getTopic()).isEqualTo("topic2"); assertThat(subscribeMessage.getMatchPolicy()).isEqualTo(MatchPolicy.EXACT); assertThat(subscribeMessage.isGetRetained()).isFalse(); json = "[32,2,{\"get_retained\":false},\"topic2\"]"; subscribeMessage = WampMessage.deserialize(getJsonFactory(), json.getBytes(StandardCharsets.UTF_8)); assertThat(subscribeMessage.getCode()).isEqualTo(32); assertThat(subscribeMessage.getRequestId()).isEqualTo(2); assertThat(subscribeMessage.getTopic()).isEqualTo("topic2"); assertThat(subscribeMessage.getMatchPolicy()).isEqualTo(MatchPolicy.EXACT); assertThat(subscribeMessage.isGetRetained()).isFalse(); json = "[32,2,{\"get_retained\":true},\"topic2\"]"; subscribeMessage = WampMessage.deserialize(getJsonFactory(), json.getBytes(StandardCharsets.UTF_8)); assertThat(subscribeMessage.getCode()).isEqualTo(32); assertThat(subscribeMessage.getRequestId()).isEqualTo(2); assertThat(subscribeMessage.getTopic()).isEqualTo("topic2"); assertThat(subscribeMessage.getMatchPolicy()).isEqualTo(MatchPolicy.EXACT); assertThat(subscribeMessage.isGetRetained()).isTrue(); json = "[32,2,{\"match\":\"wildcard\",\"get_retained\":true},\"topic2\"]"; subscribeMessage = WampMessage.deserialize(getJsonFactory(), json.getBytes(StandardCharsets.UTF_8)); assertThat(subscribeMessage.getCode()).isEqualTo(32); assertThat(subscribeMessage.getRequestId()).isEqualTo(2); assertThat(subscribeMessage.getTopic()).isEqualTo("topic2"); assertThat(subscribeMessage.getMatchPolicy()).isEqualTo(MatchPolicy.WILDCARD); assertThat(subscribeMessage.isGetRetained()).isTrue(); }

### Question: GoodbyeMessage extends WampMessage { @Override public void serialize(JsonGenerator generator) throws IOException { generator.writeNumber(getCode()); generator.writeStartObject(); if (this.message != null) { generator.writeStringField("message", this.message); } generator.writeEndObject(); generator.writeString(this.reason); } GoodbyeMessage(WampError reason, @Nullable String message); GoodbyeMessage(WampError reason); private GoodbyeMessage(String reason, @Nullable String message); static GoodbyeMessage deserialize(JsonParser jp); @Override void serialize(JsonGenerator generator); String getReason(); @Nullable String getMessage(); @Override String toString(); }### Answer: @Test public void serializeTest() { GoodbyeMessage goodbyeMessage = new GoodbyeMessage(WampError.GOODBYE_AND_OUT, "theMessage"); assertThat(goodbyeMessage.getCode()).isEqualTo(6); assertThat(goodbyeMessage.getMessage()).isEqualTo("theMessage"); assertThat(goodbyeMessage.getReason()) .isEqualTo(WampError.GOODBYE_AND_OUT.getExternalValue()); String json = serializeToJson(goodbyeMessage); assertThat(json).isEqualTo( "[6,{\"message\":\"theMessage\"},\"wamp.error.goodbye_and_out\"]"); goodbyeMessage = new GoodbyeMessage(WampError.NO_SUCH_PROCEDURE); json = serializeToJson(goodbyeMessage); assertThat(json).isEqualTo("[6,{},\"wamp.error.no_such_procedure\"]"); }

### Question: GoodbyeMessage extends WampMessage { public static GoodbyeMessage deserialize(JsonParser jp) throws IOException { String msg = null; jp.nextToken(); Map<String, Object> details = ParserUtil.readObject(jp); if (details != null) { msg = (String) details.get("message"); } jp.nextToken(); return new GoodbyeMessage(jp.getValueAsString(), msg); } GoodbyeMessage(WampError reason, @Nullable String message); GoodbyeMessage(WampError reason); private GoodbyeMessage(String reason, @Nullable String message); static GoodbyeMessage deserialize(JsonParser jp); @Override void serialize(JsonGenerator generator); String getReason(); @Nullable String getMessage(); @Override String toString(); }### Answer: @Test public void deserializeTest() throws IOException { String json = "[6, {\"message\": \"The host is shutting down now.\"},\"wamp.error.system_shutdown\"]"; GoodbyeMessage goodbyeMessage = WampMessage.deserialize(getJsonFactory(), json.getBytes(StandardCharsets.UTF_8)); assertThat(goodbyeMessage.getCode()).isEqualTo(6); assertThat(goodbyeMessage.getMessage()) .isEqualTo("The host is shutting down now."); assertThat(goodbyeMessage.getReason()).isEqualTo("wamp.error.system_shutdown"); json = "[6,{},\"wamp.error.no_such_procedure\"]"; goodbyeMessage = WampMessage.deserialize(getJsonFactory(), json.getBytes(StandardCharsets.UTF_8)); assertThat(goodbyeMessage.getCode()).isEqualTo(6); assertThat(goodbyeMessage.getMessage()).isNull(); assertThat(goodbyeMessage.getReason()).isEqualTo("wamp.error.no_such_procedure"); }

### Question: HelloMessage extends WampMessage { @Override public void serialize(JsonGenerator generator) throws IOException { generator.writeNumber(getCode()); generator.writeString(this.realm); generator.writeStartObject(); generator.writeObjectFieldStart("roles"); for (WampRole wampRole : this.roles) { generator.writeObjectFieldStart(wampRole.getRole()); if (wampRole.hasFeatures()) { generator.writeObjectFieldStart("features"); for (String feature : wampRole.getFeatures()) { generator.writeBooleanField(feature, true); } generator.writeEndObject(); } generator.writeEndObject(); } generator.writeEndObject(); generator.writeEndObject(); } HelloMessage(@Nullable String realm, List<WampRole> roles); @SuppressWarnings("unchecked") static HelloMessage deserialize(JsonParser jp); @Override void serialize(JsonGenerator generator); @Nullable String getRealm(); List<WampRole> getRoles(); @Override String toString(); }### Answer: @Test public void serializeTest() { List<WampRole> roles = createRoles(); HelloMessage helloMessage = new HelloMessage("aRealm", roles); assertThat(helloMessage.getCode()).isEqualTo(1); assertThat(helloMessage.getRealm()).isEqualTo("aRealm"); assertThat(helloMessage.getRoles()).isEqualTo(roles); String json = serializeToJson(helloMessage); assertThat(json).isEqualTo( "[1,\"aRealm\",{\"roles\":{\"publisher\":{\"features\":{\"publisher_exclusion\":true}},\"subscriber\":{\"features\":{\"subscriber_blackwhite_listing\":true}}}}]"); }

### Question: HelloMessage extends WampMessage { @SuppressWarnings("unchecked") public static HelloMessage deserialize(JsonParser jp) throws IOException { jp.nextToken(); String realm = jp.getValueAsString(); List<WampRole> roles = new ArrayList<>(); jp.nextToken(); Map<String, Object> details = ParserUtil.readObject(jp); if (details != null) { Map<String, Map<String, Map<String, Boolean>>> rolesMap = (Map<String, Map<String, Map<String, Boolean>>>) details .get("roles"); for (Map.Entry<String, Map<String, Map<String, Boolean>>> entry : rolesMap .entrySet()) { WampRole wampRole = new WampRole(entry.getKey()); Map<String, Boolean> features = entry.getValue().get("features"); if (features != null) { for (String feature : features.keySet()) { wampRole.addFeature(feature); } } roles.add(wampRole); } } return new HelloMessage(realm, roles); } HelloMessage(@Nullable String realm, List<WampRole> roles); @SuppressWarnings("unchecked") static HelloMessage deserialize(JsonParser jp); @Override void serialize(JsonGenerator generator); @Nullable String getRealm(); List<WampRole> getRoles(); @Override String toString(); }### Answer: @Test public void deserializeTest() throws IOException { String json = "[1, \"somerealm\", { \"roles\": { \"publisher\": {}, \"subscriber\": {} } }]"; HelloMessage helloMessage = WampMessage.deserialize(getJsonFactory(), json.getBytes(StandardCharsets.UTF_8)); assertThat(helloMessage.getCode()).isEqualTo(1); assertThat(helloMessage.getRealm()).isEqualTo("somerealm"); assertThat(helloMessage.getRoles()).containsOnly(new WampRole("publisher"), new WampRole("subscriber")); json = "[1,\"aRealm\",{\"roles\":{\"publisher\":{\"features\":{\"publisher_exclusion\":true}},\"subscriber\":{\"features\":{\"subscriber_blackwhite_listing\":true}}}}]"; helloMessage = WampMessage.deserialize(getJsonFactory(), json.getBytes(StandardCharsets.UTF_8)); assertThat(helloMessage.getCode()).isEqualTo(1); assertThat(helloMessage.getRealm()).isEqualTo("aRealm"); assertThat(helloMessage.getRoles()).containsOnlyElementsOf(createRoles()); }

### Question: WelcomeMessage extends WampMessage { @Override public void serialize(JsonGenerator generator) throws IOException { generator.writeNumber(getCode()); generator.writeNumber(this.sessionId); generator.writeStartObject(); generator.writeObjectFieldStart("roles"); for (WampRole wampRole : this.roles) { generator.writeObjectFieldStart(wampRole.getRole()); if (wampRole.hasFeatures()) { generator.writeObjectFieldStart("features"); for (String feature : wampRole.getFeatures()) { generator.writeBooleanField(feature, true); } generator.writeEndObject(); } generator.writeEndObject(); } generator.writeEndObject(); if (this.realm != null) { generator.writeStringField("realm", this.realm); } generator.writeEndObject(); } WelcomeMessage(long sessionId, List<WampRole> roles, @Nullable String realm); WelcomeMessage(HelloMessage helloMessage, long sessionId, List<WampRole> roles); @SuppressWarnings("unchecked") static WelcomeMessage deserialize(JsonParser jp); @Override void serialize(JsonGenerator generator); long getSessionId(); List<WampRole> getRoles(); @Nullable String getRealm(); @Override String toString(); }### Answer: @SuppressWarnings({ "unchecked" }) @Test public void serializeTest() throws JsonParseException, JsonMappingException, IOException { List<WampRole> roles = createRoles(); WelcomeMessage welcomeMessage = new WelcomeMessage(9129137332L, roles, "realm"); assertThat(welcomeMessage.getCode()).isEqualTo(2); assertThat(welcomeMessage.getSessionId()).isEqualTo(9129137332L); assertThat(welcomeMessage.getRoles()).isEqualTo(roles); String json = serializeToJson(welcomeMessage); String expected = "[2,9129137332,{\"roles\":{\"dealer\":{\"features\":{\"caller_identification\":true}},\"broker\":{\"features\":{\"subscriber_blackwhite_listing\":true,\"publisher_exclusion\":true,\"publisher_identification\":true,\"pattern_based_subscription\":true}}},\"realm\":\"realm\"}]"; ObjectMapper om = new ObjectMapper(); assertThat(om.readValue(json, List.class)) .isEqualTo(om.readValue(expected, List.class)); }

### Question: WelcomeMessage extends WampMessage { @SuppressWarnings("unchecked") public static WelcomeMessage deserialize(JsonParser jp) throws IOException { jp.nextToken(); long session = jp.getLongValue(); List<WampRole> roles = new ArrayList<>(); String realm = null; jp.nextToken(); Map<String, Object> details = ParserUtil.readObject(jp); if (details != null) { Map<String, Map<String, Map<String, Boolean>>> rolesMap = (Map<String, Map<String, Map<String, Boolean>>>) details .get("roles"); for (Map.Entry<String, Map<String, Map<String, Boolean>>> entry : rolesMap .entrySet()) { WampRole wampRole = new WampRole(entry.getKey()); Map<String, Boolean> features = entry.getValue().get("features"); if (features != null) { for (String feature : features.keySet()) { wampRole.addFeature(feature); } } roles.add(wampRole); } realm = (String) details.get("realm"); } return new WelcomeMessage(session, roles, realm); } WelcomeMessage(long sessionId, List<WampRole> roles, @Nullable String realm); WelcomeMessage(HelloMessage helloMessage, long sessionId, List<WampRole> roles); @SuppressWarnings("unchecked") static WelcomeMessage deserialize(JsonParser jp); @Override void serialize(JsonGenerator generator); long getSessionId(); List<WampRole> getRoles(); @Nullable String getRealm(); @Override String toString(); }### Answer: @Test public void deserializeTest() throws IOException { String json = "[ 2 , 9129137332 , { \"roles\" : { \"broker\" : {} }}]"; WelcomeMessage welcomeMessage = WampMessage.deserialize(getJsonFactory(), json.getBytes(StandardCharsets.UTF_8)); assertThat(welcomeMessage.getCode()).isEqualTo(2); assertThat(welcomeMessage.getSessionId()).isEqualTo(9129137332L); assertThat(welcomeMessage.getRoles()).containsExactly(new WampRole("broker")); json = "[2,9129137332,{\"roles\":{\"dealer\":{\"features\":{\"caller_identification\":true}},\"broker\":{\"features\":{\"subscriber_blackwhite_listing\":true,\"publisher_exclusion\":true,\"publisher_identification\":true,\"pattern_based_subscription\":true}}},\"realm\":\"realm\"}]"; welcomeMessage = WampMessage.deserialize(getJsonFactory(), json.getBytes(StandardCharsets.UTF_8)); assertThat(welcomeMessage.getCode()).isEqualTo(2); assertThat(welcomeMessage.getSessionId()).isEqualTo(9129137332L); assertThat(welcomeMessage.getRoles()).containsOnlyElementsOf(createRoles()); }

### Question: SubscribedMessage extends WampMessage { @Override public void serialize(JsonGenerator generator) throws IOException { generator.writeNumber(getCode()); generator.writeNumber(this.requestId); generator.writeNumber(this.subscriptionId); } SubscribedMessage(long requestId, long subscriptionId); SubscribedMessage(SubscribeMessage subscribeMessage, long subscriptionId); static SubscribedMessage deserialize(JsonParser jp); @Override void serialize(JsonGenerator generator); long getRequestId(); long getSubscriptionId(); @Override String toString(); }### Answer: @Test public void serializeTest() { SubscribedMessage subscribedMessage = new SubscribedMessage(1, 2); assertThat(subscribedMessage.getCode()).isEqualTo(33); assertThat(subscribedMessage.getRequestId()).isEqualTo(1); assertThat(subscribedMessage.getSubscriptionId()).isEqualTo(2); String json = serializeToJson(subscribedMessage); assertThat(json).isEqualTo("[33,1,2]"); }

### Question: SubscribedMessage extends WampMessage { public static SubscribedMessage deserialize(JsonParser jp) throws IOException { jp.nextToken(); long request = jp.getLongValue(); jp.nextToken(); long subscription = jp.getLongValue(); return new SubscribedMessage(request, subscription); } SubscribedMessage(long requestId, long subscriptionId); SubscribedMessage(SubscribeMessage subscribeMessage, long subscriptionId); static SubscribedMessage deserialize(JsonParser jp); @Override void serialize(JsonGenerator generator); long getRequestId(); long getSubscriptionId(); @Override String toString(); }### Answer: @Test public void deserializeTest() throws IOException { String json = "[33, 713845233, 5512315355]"; SubscribedMessage subscribedMessage = WampMessage.deserialize(getJsonFactory(), json.getBytes(StandardCharsets.UTF_8)); assertThat(subscribedMessage.getCode()).isEqualTo(33); assertThat(subscribedMessage.getRequestId()).isEqualTo(713845233L); assertThat(subscribedMessage.getSubscriptionId()).isEqualTo(5512315355L); }

### Question: ParserUtil { @Nullable public static List<Object> readArray(JsonParser jp) throws IOException { if (jp.currentToken() != JsonToken.START_ARRAY) { return null; } List<Object> result = new ArrayList<>(); JsonToken token = jp.nextToken(); while (token != JsonToken.END_ARRAY) { if (token == JsonToken.START_ARRAY) { result.add(readArray(jp)); } else if (token == JsonToken.START_OBJECT) { result.add(readObject(jp)); } else { result.add(getValue(jp)); } token = jp.nextToken(); } return result; } @Nullable static List<Object> readArray(JsonParser jp); @Nullable static Map<String, Object> readObject(JsonParser jp); }### Answer: @SuppressWarnings("resource") @Test public void testReadArray() throws JsonParseException, IOException { ObjectMapper om = new ObjectMapper(); JsonParser jp = om.getFactory().createParser("\"test\""); jp.nextToken(); assertThat(ParserUtil.readArray(jp)).isNull(); jp = om.getFactory().createParser("[1,2,3]"); jp.nextToken(); assertThat(ParserUtil.readArray(jp)).containsExactly(1, 2, 3); jp = om.getFactory().createParser("[[\"k\",\"l\",\"m\"],[\"a\",\"b\",\"c\"]]"); jp.nextToken(); assertThat(ParserUtil.readArray(jp)).containsExactly(Arrays.asList("k", "l", "m"), Arrays.asList("a", "b", "c")); }

### Question: ParserUtil { @Nullable public static Map<String, Object> readObject(JsonParser jp) throws IOException { if (jp.currentToken() != JsonToken.START_OBJECT) { return null; } Map<String, Object> result = new HashMap<>(); JsonToken token = jp.nextToken(); while (token != JsonToken.END_OBJECT) { String key = jp.getText(); token = jp.nextToken(); if (token == JsonToken.START_ARRAY) { result.put(key, readArray(jp)); } else if (token == JsonToken.START_OBJECT) { result.put(key, readObject(jp)); } else { result.put(key, getValue(jp)); } token = jp.nextToken(); } return result; } @Nullable static List<Object> readArray(JsonParser jp); @Nullable static Map<String, Object> readObject(JsonParser jp); }### Answer: @SuppressWarnings({ "resource", "unchecked" }) @Test public void testReadObject() throws JsonParseException, IOException { ObjectMapper om = new ObjectMapper(); JsonParser jp = om.getFactory().createParser("\"test\""); jp.nextToken(); assertThat(ParserUtil.readArray(jp)).isNull(); jp = om.getFactory().createParser("{\"key1\":1,\"key2\":2}"); jp.nextToken(); assertThat(ParserUtil.readObject(jp)).containsOnly(MapEntry.entry("key1", 1), MapEntry.entry("key2", 2)); jp = om.getFactory().createParser("{\"keyA\":1.1,\"keyB\":2.2}"); jp.nextToken(); assertThat(ParserUtil.readObject(jp)).containsOnly(MapEntry.entry("keyA", 1.1), MapEntry.entry("keyB", 2.2)); jp = om.getFactory().createParser("{\"k1\":\"one\",\"k2\":\"two\"}"); jp.nextToken(); assertThat(ParserUtil.readObject(jp)).containsOnly(MapEntry.entry("k1", "one"), MapEntry.entry("k2", "two")); jp = om.getFactory().createParser("{\"k1\":true,\"k2\":false, \"k3\":null}"); jp.nextToken(); assertThat(ParserUtil.readObject(jp)).containsOnly(MapEntry.entry("k1", true), MapEntry.entry("k2", false), MapEntry.entry("k3", null)); jp = om.getFactory().createParser( "{\"o1\":{\"a1\":1,\"a2\":2},\"o2\":{\"b1\":11,\"b2\":22},\"o3\":{\"c1\":111,\"c2\":222}}"); jp.nextToken(); Map<String, Object> m = ParserUtil.readObject(jp); assertThat(m).containsKeys("o1", "o2", "o3"); assertThat((Map<String, Object>) m.get("o1")) .containsOnly(MapEntry.entry("a1", 1), MapEntry.entry("a2", 2)); assertThat((Map<String, Object>) m.get("o2")) .containsOnly(MapEntry.entry("b1", 11), MapEntry.entry("b2", 22)); assertThat((Map<String, Object>) m.get("o3")) .containsOnly(MapEntry.entry("c1", 111), MapEntry.entry("c2", 222)); }

### Question: AbortMessage extends WampMessage { @Override public void serialize(JsonGenerator generator) throws IOException { generator.writeNumber(getCode()); generator.writeStartObject(); if (this.message != null) { generator.writeStringField("message", this.message); } generator.writeEndObject(); generator.writeString(this.reason); } AbortMessage(WampError reason, @Nullable String message); AbortMessage(WampError reason); private AbortMessage(String reason, @Nullable String message); static AbortMessage deserialize(JsonParser jp); @Override void serialize(JsonGenerator generator); @Nullable String getMessage(); @Nullable String getReason(); @Override String toString(); }### Answer: @Test public void serializeTest() { AbortMessage abortMessage = new AbortMessage(WampError.NO_SUCH_REGISTRATION, "No such registration"); assertThat(abortMessage.getCode()).isEqualTo(3); assertThat(abortMessage.getMessage()).isEqualTo("No such registration"); assertThat(abortMessage.getReason()).isEqualTo("wamp.error.no_such_registration"); String json = serializeToJson(abortMessage); assertThat(json).isEqualTo( "[3,{\"message\":\"No such registration\"},\"wamp.error.no_such_registration\"]"); abortMessage = new AbortMessage(WampError.NO_SUCH_REGISTRATION); assertThat(abortMessage.getCode()).isEqualTo(3); assertThat(abortMessage.getMessage()).isNull(); assertThat(abortMessage.getReason()).isEqualTo("wamp.error.no_such_registration"); json = serializeToJson(abortMessage); assertThat(json).isEqualTo("[3,{},\"wamp.error.no_such_registration\"]"); }

### Question: AbortMessage extends WampMessage { public static AbortMessage deserialize(JsonParser jp) throws IOException { String msg = null; jp.nextToken(); Map<String, Object> details = ParserUtil.readObject(jp); if (details != null) { msg = (String) details.get("message"); } jp.nextToken(); return new AbortMessage(jp.getValueAsString(), msg); } AbortMessage(WampError reason, @Nullable String message); AbortMessage(WampError reason); private AbortMessage(String reason, @Nullable String message); static AbortMessage deserialize(JsonParser jp); @Override void serialize(JsonGenerator generator); @Nullable String getMessage(); @Nullable String getReason(); @Override String toString(); }### Answer: @Test public void deserializeTest() throws IOException { String json = "[3, {\"message\": \"The realm does not exist.\"}, \"wamp.error.no_such_realm\"]"; AbortMessage abortMessage = WampMessage.deserialize(getJsonFactory(), json.getBytes(StandardCharsets.UTF_8)); assertThat(abortMessage.getCode()).isEqualTo(3); assertThat(abortMessage.getMessage()).isEqualTo("The realm does not exist."); assertThat(abortMessage.getReason()).isEqualTo("wamp.error.no_such_realm"); json = "[3, {}, \"wamp.error.no_such_realm\"]"; abortMessage = WampMessage.deserialize(getJsonFactory(), json.getBytes(StandardCharsets.UTF_8)); assertThat(abortMessage.getCode()).isEqualTo(3); assertThat(abortMessage.getMessage()).isNull(); assertThat(abortMessage.getReason()).isEqualTo("wamp.error.no_such_realm"); }

### Question: WampPublisher { public <T> void publishToAll(String topic, @Nullable T... arguments) { publish(publishMessageBuilder(topic).arguments(CollectionHelper.toList(arguments)) .build()); } WampPublisher(MessageChannel clientInboundChannel); void publish(PublishMessage publishMessage); void publishToAll(String topic, @Nullable T... arguments); void publishToAll(String topic, @Nullable Collection<T> arguments); void publishToAll(String topic, @Nullable Map<String, T> arguments); void publishTo(Collection<Long> eligibleWampSessionIds, String topic, @Nullable T... arguments); void publishTo(Collection<Long> eligibleWampSessionIds, String topic, @Nullable Collection<T> arguments); void publishTo(Collection<Long> eligibleWampSessionIds, String topic, @Nullable Map<String, T> arguments); void publishTo(long eligibleWampSessionId, String topic, @Nullable T... arguments); void publishTo(long eligibleWampSessionId, String topic, @Nullable Collection<T> arguments); void publishTo(long eligibleWampSessionId, String topic, @Nullable Map<String, T> arguments); void publishToAllExcept(Collection<Long> excludeWampSessionIds, String topic, @Nullable T... arguments); void publishToAllExcept(Collection<Long> excludeWampSessionIds, String topic, @Nullable Collection<T> arguments); void publishToAllExcept(Collection<Long> excludeWampSessionIds, String topic, @Nullable Map<String, T> arguments); void publishToAllExcept(long excludeWampSessionId, String topic, @Nullable T... arguments); void publishToAllExcept(long excludeWampSessionId, String topic, @Nullable Collection<T> arguments); void publishToAllExcept(long excludeWampSessionId, String topic, @Nullable Map<String, T> arguments); Builder publishMessageBuilder(String topic); }### Answer: @Test public void testPublishToAll() { this.wampPublisher.publishToAll("topic", 1); Mockito.verify(this.clientOutboundChannel, Mockito.times(1)) .send(this.messageCaptor.capture()); PublishMessage publishMessage = this.messageCaptor.getValue(); assertPublishMessage(publishMessage, "topic", Collections.singletonList(1), null, null); } @Test public void testPublishToAllList() { List<String> value = Arrays.asList("a", "b", "c"); this.wampPublisher.publishToAll("topic2", value); Mockito.verify(this.clientOutboundChannel, Mockito.times(1)) .send(this.messageCaptor.capture()); PublishMessage publishMessage = this.messageCaptor.getValue(); assertPublishMessage(publishMessage, "topic2", value, null, null); } @Test public void testPublishToAllMap() { Map<String, Integer> mapValue = new HashMap<>(); mapValue.put("one", 1); mapValue.put("two", 2); mapValue.put("three", 3); this.wampPublisher.publishToAll("topic3", mapValue); Mockito.verify(this.clientOutboundChannel, Mockito.times(1)) .send(this.messageCaptor.capture()); PublishMessage publishMessage = this.messageCaptor.getValue(); assertPublishMessage(publishMessage, "topic3", mapValue, null, null); }

### Question: WampSessionIdMethodArgumentResolver implements HandlerMethodArgumentResolver { @Override public boolean supportsParameter(MethodParameter parameter) { return parameter.hasParameterAnnotation(WampSessionId.class); } @Override boolean supportsParameter(MethodParameter parameter); @Override Object resolveArgument(MethodParameter parameter, Message<?> message); }### Answer: @Test public void supportsParameterTest() { assertThat(this.resolver.supportsParameter(this.wampSessionIdParameter)).isTrue(); assertThat(this.resolver.supportsParameter(this.stringParameter)).isFalse(); }

### Question: WampSessionIdMethodArgumentResolver implements HandlerMethodArgumentResolver { @Override public Object resolveArgument(MethodParameter parameter, Message<?> message) throws Exception { return message.getHeaders().get(WampMessageHeader.WAMP_SESSION_ID.name()); } @Override boolean supportsParameter(MethodParameter parameter); @Override Object resolveArgument(MethodParameter parameter, Message<?> message); }### Answer: @Test public void resolveArgumentTest() throws Exception { CallMessage callMessage = new CallMessage(1, "call"); callMessage.setHeader(WampMessageHeader.WAMP_SESSION_ID, 23L); assertThat( this.resolver.resolveArgument(this.wampSessionIdParameter, callMessage)) .isEqualTo(23L); }

### Question: PrincipalMethodArgumentResolver implements HandlerMethodArgumentResolver { @Override public boolean supportsParameter(MethodParameter parameter) { Class<?> paramType = parameter.getParameterType(); return Principal.class.isAssignableFrom(paramType); } @Override boolean supportsParameter(MethodParameter parameter); @Override Object resolveArgument(MethodParameter parameter, Message<?> message); }### Answer: @Test public void supportsParameterTest() { assertThat(this.resolver.supportsParameter(this.principalParameter)).isTrue(); assertThat(this.resolver.supportsParameter(this.stringParameter)).isFalse(); }

### Question: PrincipalMethodArgumentResolver implements HandlerMethodArgumentResolver { @Override public Object resolveArgument(MethodParameter parameter, Message<?> message) throws Exception { Principal user = ((WampMessage) message).getPrincipal(); if (user == null) { throw new MessageHandlingException(message, "No \"PRINCIPAL\" header in message"); } return user; } @Override boolean supportsParameter(MethodParameter parameter); @Override Object resolveArgument(MethodParameter parameter, Message<?> message); }### Answer: @Test public void resolveArgumentTest() throws Exception { CallMessage callMessage = new CallMessage(1, "call"); TestPrincipal testPrincipal = new TestPrincipal("testPrincipal"); callMessage.setHeader(WampMessageHeader.PRINCIPAL, testPrincipal); assertThat(this.resolver.resolveArgument(this.principalParameter, callMessage)) .isEqualTo(testPrincipal); } @Test(expected = MessageHandlingException.class) public void missingPrincipalTest() throws Exception { CallMessage callMessage = new CallMessage(1, "call"); TestPrincipal testPrincipal = new TestPrincipal("testPrincipal"); assertThat(this.resolver.resolveArgument(this.principalParameter, callMessage)) .isEqualTo(testPrincipal); }

### Question: WampMessageMethodArgumentResolver implements HandlerMethodArgumentResolver { @Override public boolean supportsParameter(MethodParameter parameter) { return WampMessage.class.isAssignableFrom(parameter.getParameterType()); } @Override boolean supportsParameter(MethodParameter parameter); @Override Object resolveArgument(MethodParameter parameter, Message<?> message); }### Answer: @Test public void supportsParameterTest() { assertThat(this.resolver.supportsParameter(this.messageParameter)).isTrue(); assertThat(this.resolver.supportsParameter(this.stringParameter)).isFalse(); }

### Question: WampMessageMethodArgumentResolver implements HandlerMethodArgumentResolver { @Override public Object resolveArgument(MethodParameter parameter, Message<?> message) throws Exception { return message; } @Override boolean supportsParameter(MethodParameter parameter); @Override Object resolveArgument(MethodParameter parameter, Message<?> message); }### Answer: @Test public void resolveArgumentTest() throws Exception { CallMessage callMessage = new CallMessage(1, "call"); assertThat(this.resolver.resolveArgument(this.messageParameter, callMessage)) .isEqualTo(callMessage); }

### Question: Features { public List<Feature> enabledDealerFeatures() { List<Feature> dealerFeatures = new ArrayList<>(); if (isEnabled(Feature.DEALER_CALLER_IDENTIFICATION)) { dealerFeatures.add(Feature.DEALER_CALLER_IDENTIFICATION); } return dealerFeatures; } void disable(Feature feature); boolean isEnabled(Feature feature); boolean isDisabled(Feature feature); List<Feature> enabledDealerFeatures(); List<Feature> enabledBrokerFeatures(); }### Answer: @Test public void testEnabledDealerFeatures() { Features feat = new Features(); assertThat(feat.enabledDealerFeatures()) .containsExactly(Feature.DEALER_CALLER_IDENTIFICATION); feat.disable(Feature.DEALER_CALLER_IDENTIFICATION); assertThat(feat.enabledDealerFeatures()).isEmpty(); }

### Question: Features { public List<Feature> enabledBrokerFeatures() { List<Feature> brokerFeatures = new ArrayList<>(); if (isEnabled(Feature.BROKER_SUBSCRIBER_BLACKWHITE_LISTING)) { brokerFeatures.add(Feature.BROKER_SUBSCRIBER_BLACKWHITE_LISTING); } if (isEnabled(Feature.BROKER_PUBLISHER_EXCLUSION)) { brokerFeatures.add(Feature.BROKER_PUBLISHER_EXCLUSION); } if (isEnabled(Feature.BROKER_PUBLISHER_IDENTIFICATION)) { brokerFeatures.add(Feature.BROKER_PUBLISHER_IDENTIFICATION); } if (isEnabled(Feature.BROKER_PATTERN_BASED_SUBSCRIPTION)) { brokerFeatures.add(Feature.BROKER_PATTERN_BASED_SUBSCRIPTION); } if (isEnabled(Feature.BROKER_EVENT_RETENTION)) { brokerFeatures.add(Feature.BROKER_EVENT_RETENTION); } return brokerFeatures; } void disable(Feature feature); boolean isEnabled(Feature feature); boolean isDisabled(Feature feature); List<Feature> enabledDealerFeatures(); List<Feature> enabledBrokerFeatures(); }### Answer: @Test public void testEnabledBrokerFeatures() { Features feat = new Features(); assertThat(feat.enabledBrokerFeatures()).containsExactly( Feature.BROKER_SUBSCRIBER_BLACKWHITE_LISTING, Feature.BROKER_PUBLISHER_EXCLUSION, Feature.BROKER_PUBLISHER_IDENTIFICATION, Feature.BROKER_PATTERN_BASED_SUBSCRIPTION, Feature.BROKER_EVENT_RETENTION); feat.disable(Feature.BROKER_SUBSCRIBER_BLACKWHITE_LISTING); assertThat(feat.enabledBrokerFeatures()).containsExactly( Feature.BROKER_PUBLISHER_EXCLUSION, Feature.BROKER_PUBLISHER_IDENTIFICATION, Feature.BROKER_PATTERN_BASED_SUBSCRIPTION, Feature.BROKER_EVENT_RETENTION); feat.disable(Feature.BROKER_PUBLISHER_EXCLUSION); assertThat(feat.enabledBrokerFeatures()).containsExactly( Feature.BROKER_PUBLISHER_IDENTIFICATION, Feature.BROKER_PATTERN_BASED_SUBSCRIPTION, Feature.BROKER_EVENT_RETENTION); feat.disable(Feature.BROKER_PUBLISHER_IDENTIFICATION); assertThat(feat.enabledBrokerFeatures()).containsExactly( Feature.BROKER_PATTERN_BASED_SUBSCRIPTION, Feature.BROKER_EVENT_RETENTION); feat.disable(Feature.BROKER_PATTERN_BASED_SUBSCRIPTION); assertThat(feat.enabledBrokerFeatures()) .containsExactly(Feature.BROKER_EVENT_RETENTION); feat.disable(Feature.BROKER_EVENT_RETENTION); assertThat(feat.enabledBrokerFeatures()).isEmpty(); }

### Question: DuplicateChangeSetException extends LiquibaseException { public DuplicateChangeSetException(String message) { super(message); } DuplicateChangeSetException(String message); }### Answer: @Test public void duplicateChangeSetException() throws Exception { DuplicateChangeSetException duplicateChangeSetException = new DuplicateChangeSetException("MESSAGE HERE"); assertEquals("MESSAGE HERE", duplicateChangeSetException.getMessage()); }

### Question: StringUtils { public static String stripComments(String multiLineSQL) { String strippedSingleLines = Pattern.compile("(.*?)\\s*\\-\\-.*\n").matcher(multiLineSQL).replaceAll("$1\n"); strippedSingleLines = Pattern.compile("(.*?)\\s*\\-\\-.*$").matcher(strippedSingleLines).replaceAll("$1\n"); return Pattern.compile("/\\*.*?\\*/", Pattern.DOTALL).matcher(strippedSingleLines).replaceAll("").trim(); } static String trimToEmpty(String string); static String trimToNull(String string); static String[] processMutliLineSQL(String multiLineSQL,boolean stripComments, boolean splitStatements, String endDelimiter); static String[] splitSQL(String multiLineSQL, String endDelimiter); static String stripComments(String multiLineSQL); static String join(String[] array, String delimiter); static String join(Collection<String> collection, String delimiter); static List<String> splitAndTrim(String s, String regex); static String repeat(String string, int times); static String join(Integer[] array, String delimiter); static String join(int[] array, String delimiter); }### Answer: @Test public void multiLineAfterSQL() { String sql = "some sql"; String comment = "" ; String total = sql + comment; String result = StringUtils.stripComments(total); assertEquals(sql.trim(),result); } @Test public void multiLineFinishesWithTextOnLine() { String sql = "some sql"; String comment = "" ; String total = comment + sql; String result = StringUtils.stripComments(total); assertEquals(sql.trim(),result); } @Test public void multiLineStartAndFinishWithSQL() { String sql = "some sql"; String comment = "" ; String total = sql + comment + sql; String result = StringUtils.stripComments(total); assertEquals(sql.trim() + sql,result); } @Test public void noComments() { String noComments=" Some text but no comments"; String result = StringUtils.stripComments(noComments); assertEquals(noComments.trim(),result); } @Test public void singleLineNoNewLine() { String sql = "Some text" ; String comment = " -- with comment"; String totalLine=sql + comment ; String result = StringUtils.stripComments(totalLine); assertEquals(sql,result); } @Test public void singleLineNoFollowOnLine() { String sql = "Some text" ; String comment = " -- with comment\n"; String totalLine=sql + comment ; String result = StringUtils.stripComments(totalLine); assertEquals(sql.trim(),result); } @Test public void singleLineMultipleComments() { String sql = "Some text" ; String comment = " -- with comment"; String totalLine=sql + comment + "\n"+ sql + comment ; String result = StringUtils.stripComments(totalLine); assertEquals(sql+"\n"+sql,result); } @Test public void singleLineWithFollowupLine() { String sql = "Some text" ; String comment = " -- with comment"; String totalLine=sql + comment + "\n" + sql ; String result = StringUtils.stripComments(totalLine); assertEquals(sql + "\n" + sql,result); } @Test public void multiLineOnOwnLine() { String sql = "" ; String result = StringUtils.stripComments(sql); assertEquals("",result); }

### Question: StringUtils { public static String[] processMutliLineSQL(String multiLineSQL,boolean stripComments, boolean splitStatements, String endDelimiter) { String stripped = stripComments ? stripComments(multiLineSQL) : multiLineSQL; if (splitStatements) { return splitSQL(stripped, endDelimiter); } else { return new String[]{stripped}; } } static String trimToEmpty(String string); static String trimToNull(String string); static String[] processMutliLineSQL(String multiLineSQL,boolean stripComments, boolean splitStatements, String endDelimiter); static String[] splitSQL(String multiLineSQL, String endDelimiter); static String stripComments(String multiLineSQL); static String join(String[] array, String delimiter); static String join(Collection<String> collection, String delimiter); static List<String> splitAndTrim(String s, String regex); static String repeat(String string, int times); static String join(Integer[] array, String delimiter); static String join(int[] array, String delimiter); }### Answer: @Test public void shouldStripComments() { String sql = "some sql"; String comment = "" ; String total = sql + comment + sql; String[] result = StringUtils.processMutliLineSQL(total,true, false, null); assertEquals(1,result.length); assertEquals(sql+sql,result[0]); } @Test public void stripComments2() { String sql = "insert into test_table values(1, 'hello');\n" + "insert into test_table values(2, 'hello');\n" + "--insert into test_table values(3, 'hello');\n" + "insert into test_table values(4, 'hello');"; String[] result = StringUtils.processMutliLineSQL(sql, true, true, ";"); assertEquals(3, result.length); } @Test public void shouldNotStripComments() { String sql = "some sql"; String comment = "" ; String total = sql + comment + sql; String[] result = StringUtils.processMutliLineSQL(total,false, false, null); assertEquals(1,result.length); assertEquals(total,result[0]); } @Test public void multilineComment() { String sql = "\n" + "\n" + "Select * from Test;\n" + "Update Test set field = 1"; String[] result = StringUtils.processMutliLineSQL(sql,true, true, null); assertEquals(2,result.length); assertEquals("Select * from Test",result[0]); assertEquals("Update Test set field = 1",result[1]); } @Test public void testSplitWithSemicolon() { StringBuilder sb = new StringBuilder(); sb.append("select * from simple_select_statement;\n"); sb.append("insert into table ( col ) values (' value with; semicolon ');"); String[] result = StringUtils.processMutliLineSQL(sb.toString(), true, true, null); assertEquals("Unexpected amount of statements returned",2, result.length); } @Test public void commentRemoval() { String testString = "--\n" + "-- Create the blog table.\n" + "--\n" + "CREATE TABLE blog\n" + "(\n" + " ID NUMBER(15) NOT NULL\n" + ")"; String[] strings = StringUtils.processMutliLineSQL(testString, true, false, null); assertEquals(1, strings.length); assertTrue(strings[0].startsWith("CREATE TABLE blog")); } @Test public void windowsDelimiter() { String sql = "\n" + "\n" + "Select * from Test;\n" + "Update Test set field = 1"; String[] result = StringUtils.processMutliLineSQL(sql,true, true, ";"); assertEquals(2,result.length); assertEquals("Select * from Test",result[0]); assertEquals("Update Test set field = 1",result[1]); } @Test public void multipleComments() { String raw = "\n" + "create table sqlfilerollback (id int);\n" + "\n" + "\n" + "create table sqlfilerollback2 (id int);"; String[] strings = StringUtils.processMutliLineSQL(raw, true, true, null); assertEquals(2, strings.length); assertEquals("create table sqlfilerollback (id int)", strings[0]); assertEquals("create table sqlfilerollback2 (id int)", strings[1]); }

### Question: ChangeSet implements Conditional { public CheckSum generateCheckSum() { StringBuffer stringToMD5 = new StringBuffer(); for (Change change : getChanges()) { stringToMD5.append(change.generateCheckSum()).append(":"); } for (SqlVisitor visitor : this.getSqlVisitors()) { stringToMD5.append(visitor.generateCheckSum()).append(";"); } return CheckSum.compute(stringToMD5.toString()); } ChangeSet(String id, String author, boolean alwaysRun, boolean runOnChange, String filePath, String contextList, String dbmsList); ChangeSet(String id, String author, boolean alwaysRun, boolean runOnChange, String filePath, String contextList, String dbmsList, boolean runInTransaction); boolean shouldAlwaysRun(); boolean shouldRunOnChange(); String getFilePath(); CheckSum generateCheckSum(); ExecType execute(DatabaseChangeLog databaseChangeLog, Database database); void rollback(Database database); List<Change> getChanges(); void addChange(Change change); String getId(); String getAuthor(); Set<String> getContexts(); Set<String> getDbmsSet(); String toString(boolean includeMD5Sum); @Override String toString(); String getComments(); void setComments(String comments); boolean isAlwaysRun(); boolean isRunOnChange(); boolean isRunInTransaction(); Change[] getRollBackChanges(); void addRollBackSQL(String sql); void addRollbackChange(Change change); boolean supportsRollback(Database database); String getDescription(); Boolean getFailOnError(); void setFailOnError(Boolean failOnError); ValidationFailOption getOnValidationFail(); void setOnValidationFail(ValidationFailOption onValidationFail); void setValidationFailed(boolean validationFailed); void addValidCheckSum(String text); boolean isCheckSumValid(CheckSum storedCheckSum); PreconditionContainer getPreconditions(); void setPreconditions(PreconditionContainer preconditionContainer); void addSqlVisitor(SqlVisitor sqlVisitor); List<SqlVisitor> getSqlVisitors(); }### Answer: @Test public void generateCheckSum() { ChangeSet changeSet1 = new ChangeSet("testId", "testAuthor", false, false,null, null, null); ChangeSet changeSet2 = new ChangeSet("testId", "testAuthor", false, false,null, null, null); AddDefaultValueChange change = new AddDefaultValueChange(); change.setSchemaName("SCHEMA_NAME"); change.setTableName("TABLE_NAME"); change.setColumnName("COLUMN_NAME"); change.setDefaultValue("DEF STRING"); change.setDefaultValueNumeric("42"); change.setDefaultValueBoolean(true); change.setDefaultValueDate("2007-01-02"); changeSet1.addChange(change); changeSet2.addChange(change); CheckSum md5Sum1 = changeSet1.generateCheckSum(); change.setSchemaName("SCHEMA_NAME2"); CheckSum md5Sum2 = changeSet2.generateCheckSum(); assertFalse(md5Sum1.equals(md5Sum2)); }

### Question: ChangeSet implements Conditional { public boolean isCheckSumValid(CheckSum storedCheckSum) { CheckSum currentMd5Sum = generateCheckSum(); if (currentMd5Sum == null) { return true; } if (storedCheckSum == null) { return true; } if (currentMd5Sum.equals(storedCheckSum)) { return true; } for (CheckSum validCheckSum : validCheckSums) { if (validCheckSum.toString().equalsIgnoreCase("1:any")) { return true; } if (currentMd5Sum.equals(validCheckSum)) { return true; } } return false; } ChangeSet(String id, String author, boolean alwaysRun, boolean runOnChange, String filePath, String contextList, String dbmsList); ChangeSet(String id, String author, boolean alwaysRun, boolean runOnChange, String filePath, String contextList, String dbmsList, boolean runInTransaction); boolean shouldAlwaysRun(); boolean shouldRunOnChange(); String getFilePath(); CheckSum generateCheckSum(); ExecType execute(DatabaseChangeLog databaseChangeLog, Database database); void rollback(Database database); List<Change> getChanges(); void addChange(Change change); String getId(); String getAuthor(); Set<String> getContexts(); Set<String> getDbmsSet(); String toString(boolean includeMD5Sum); @Override String toString(); String getComments(); void setComments(String comments); boolean isAlwaysRun(); boolean isRunOnChange(); boolean isRunInTransaction(); Change[] getRollBackChanges(); void addRollBackSQL(String sql); void addRollbackChange(Change change); boolean supportsRollback(Database database); String getDescription(); Boolean getFailOnError(); void setFailOnError(Boolean failOnError); ValidationFailOption getOnValidationFail(); void setOnValidationFail(ValidationFailOption onValidationFail); void setValidationFailed(boolean validationFailed); void addValidCheckSum(String text); boolean isCheckSumValid(CheckSum storedCheckSum); PreconditionContainer getPreconditions(); void setPreconditions(PreconditionContainer preconditionContainer); void addSqlVisitor(SqlVisitor sqlVisitor); List<SqlVisitor> getSqlVisitors(); }### Answer: @Test public void isCheckSumValid_invalidCheckSum() { CheckSum checkSum = CheckSum.parse("2:asdf"); ChangeSet changeSet = new ChangeSet("1", "2",false, false, "/test.xml",null, null); assertFalse(changeSet.isCheckSumValid(checkSum)); }

### Question: AlreadyRanChangeSetFilter extends RanChangeSetFilter { public boolean accepts(ChangeSet changeSet) { return getRanChangeSet(changeSet) != null; } AlreadyRanChangeSetFilter(List<RanChangeSet> ranChangeSets); boolean accepts(ChangeSet changeSet); }### Answer: @Test public void accepts_noneRun() { AlreadyRanChangeSetFilter filter = new AlreadyRanChangeSetFilter(new ArrayList<RanChangeSet>()); assertFalse(filter.accepts(new ChangeSet("1", "testAuthor", false, false, "path/changelog",null, null))); } @Test public void accepts() { ArrayList<RanChangeSet> ranChanges = new ArrayList<RanChangeSet>(); ranChanges.add(new RanChangeSet("path/changelog", "1", "testAuthor", CheckSum.parse("12345"), new Date(), null, null)); ranChanges.add(new RanChangeSet("path/changelog", "2", "testAuthor", CheckSum.parse("12345"), new Date(), null, null)); AlreadyRanChangeSetFilter filter = new AlreadyRanChangeSetFilter(ranChanges); assertTrue(filter.accepts(new ChangeSet("1", "testAuthor", false, false, "path/changelog", null, null))); assertTrue(filter.accepts(new ChangeSet("1", "testAuthor", true, false, "path/changelog", null, null))); assertTrue(filter.accepts(new ChangeSet("1", "testAuthor", false, true, "path/changelog", null, null))); assertFalse(filter.accepts(new ChangeSet("3", "testAuthor", false, false, "path/changelog", null, null))); assertFalse(filter.accepts(new ChangeSet("1", "otherAuthor", false, false, "path/changelog", null, null))); assertFalse(filter.accepts(new ChangeSet("1", "testAuthor", false, false, "other/changelog", null, null))); }

### Question: ShouldRunChangeSetFilter implements ChangeSetFilter { @SuppressWarnings({"RedundantIfStatement"}) public boolean accepts(ChangeSet changeSet) { for (RanChangeSet ranChangeSet : ranChangeSets) { if (ranChangeSet.getId().equals(changeSet.getId()) && ranChangeSet.getAuthor().equals(changeSet.getAuthor()) && isPathEquals(changeSet, ranChangeSet)) { if (changeSet.shouldAlwaysRun() && ranChangeSet.getLastCheckSum() != null) { return true; } else if (changeSet.shouldRunOnChange() && !changeSet.generateCheckSum().equals(ranChangeSet.getLastCheckSum())) { return true; } else { return false; } } } return true; } ShouldRunChangeSetFilter(Database database); @SuppressWarnings({"RedundantIfStatement"}) boolean accepts(ChangeSet changeSet); public List<RanChangeSet> ranChangeSets; }### Answer: @Test public void accepts_noneRun() throws DatabaseException { Database database = createMock(Database.class); expect(database.getRanChangeSetList()).andReturn(new ArrayList<RanChangeSet>()); replay(database); ShouldRunChangeSetFilter filter = new ShouldRunChangeSetFilter(database); assertTrue(filter.accepts(new ChangeSet("1", "testAuthor", false, false, "path/changelog", null, null))); } @Test public void accepts() throws DatabaseException { ArrayList<RanChangeSet> ranChanges = new ArrayList<RanChangeSet>(); ranChanges.add(new RanChangeSet("path/changelog", "1", "testAuthor", CheckSum.parse("12345"), new Date(), null, null)); ranChanges.add(new RanChangeSet("path/changelog", "2", "testAuthor", CheckSum.parse("12345"), new Date(), null, null)); Database database = createMock(Database.class); expect(database.getRanChangeSetList()).andReturn(ranChanges); expect(database.getDatabaseChangeLogTableName()).andReturn("DATABASECHANGELOG").anyTimes(); expect(database.getDefaultSchemaName()).andReturn(null).anyTimes(); Executor template = createMock(Executor.class); expect(template.update(isA(UpdateStatement.class))).andReturn(1).anyTimes(); replay(database); replay(template); ExecutorService.getInstance().setExecutor(database, template); ShouldRunChangeSetFilter filter = new ShouldRunChangeSetFilter(database); assertFalse(filter.accepts(new ChangeSet("1", "testAuthor", false, false, "path/changelog", null, null))); assertTrue(filter.accepts(new ChangeSet("1", "testAuthor", true, false, "path/changelog", null, null))); assertTrue(filter.accepts(new ChangeSet("1", "testAuthor", false, true, "path/changelog", null, null))); assertTrue(filter.accepts(new ChangeSet("3", "testAuthor", false, false, "path/changelog", null, null))); assertTrue(filter.accepts(new ChangeSet("1", "otherAuthor", false, false, "path/changelog", null, null))); assertTrue(filter.accepts(new ChangeSet("1", "testAuthor", false, false, "other/changelog", null, null))); }

### Question: AfterTagChangeSetFilter implements ChangeSetFilter { public boolean accepts(ChangeSet changeSet) { return changeLogsAfterTag.contains(changeLogToString(changeSet.getId(), changeSet.getAuthor(), changeSet.getFilePath())); } AfterTagChangeSetFilter(String tag, List<RanChangeSet> ranChangeSets); boolean accepts(ChangeSet changeSet); }### Answer: @Test public void accepts() throws Exception { ArrayList<RanChangeSet> ranChanges = new ArrayList<RanChangeSet>(); ranChanges.add(new RanChangeSet("path/changelog", "1", "testAuthor", CheckSum.parse("12345"), new Date(), null, null)); ranChanges.add(new RanChangeSet("path/changelog", "2", "testAuthor", CheckSum.parse("12345"), new Date(), "tag1", null)); ranChanges.add(new RanChangeSet("path/changelog", "3", "testAuthor", CheckSum.parse("12345"), new Date(), null, null)); AfterTagChangeSetFilter filter = new AfterTagChangeSetFilter("tag1", ranChanges); assertFalse(filter.accepts(new ChangeSet("1", "testAuthor", false, false, "path/changelog", null, null))); assertFalse(filter.accepts(new ChangeSet("2", "testAuthor", false, false, "path/changelog", null, null))); assertTrue(filter.accepts(new ChangeSet("3", "testAuthor", false, false, "path/changelog", null, null))); }

### Question: ExecutedAfterChangeSetFilter implements ChangeSetFilter { public boolean accepts(ChangeSet changeSet) { return changeLogsAfterDate.contains(changeLogToString(changeSet.getId(), changeSet.getAuthor(), changeSet.getFilePath())); } ExecutedAfterChangeSetFilter(Date date, List<RanChangeSet> ranChangeSets); boolean accepts(ChangeSet changeSet); }### Answer: @Test public void accepts_noRan() throws Exception { ExecutedAfterChangeSetFilter filter = new ExecutedAfterChangeSetFilter(new Date(), new ArrayList<RanChangeSet>()); assertFalse(filter.accepts(new ChangeSet("1", "testAuthor", false, false, "path/changelog", null, null))); } @Test public void accepts_nullDate() throws Exception { ArrayList<RanChangeSet> ranChanges = new ArrayList<RanChangeSet>(); ranChanges.add(new RanChangeSet("path/changelog", "1", "testAuthor", CheckSum.parse("12345"), new Date(), null, null)); ranChanges.add(new RanChangeSet("path/changelog", "2", "testAuthor", CheckSum.parse("12345"), null, null, null)); ranChanges.add(new RanChangeSet("path/changelog", "3", "testAuthor", CheckSum.parse("12345"), new Date(), null, null)); ExecutedAfterChangeSetFilter filter = new ExecutedAfterChangeSetFilter(new Date(), ranChanges); assertFalse(filter.accepts(new ChangeSet("1", "testAuthor", false, false, "path/changelog", null, null))); } @Test public void accepts() throws Exception { ArrayList<RanChangeSet> ranChanges = new ArrayList<RanChangeSet>(); ranChanges.add(new RanChangeSet("path/changelog", "1", "testAuthor", CheckSum.parse("12345"), new Date(new Date().getTime() - 10*1000*60*60), null, null)); ranChanges.add(new RanChangeSet("path/changelog", "2", "testAuthor", CheckSum.parse("12345"), new Date(new Date().getTime() - 8*1000*60*60), null, null)); ranChanges.add(new RanChangeSet("path/changelog", "3", "testAuthor", CheckSum.parse("12345"), new Date(new Date().getTime() - 4*1000*60*60), null, null)); ExecutedAfterChangeSetFilter filter = new ExecutedAfterChangeSetFilter(new Date(new Date().getTime() - 6*1000*60*60), ranChanges); assertFalse(filter.accepts(new ChangeSet("1", "testAuthor", false, false, "path/changelog", null, null))); assertFalse(filter.accepts(new ChangeSet("2", "testAuthor", false, false, "path/changelog", null, null))); assertTrue(filter.accepts(new ChangeSet("3", "testAuthor", false, false, "path/changelog",null, null))); }

### Question: CountChangeSetFilter implements ChangeSetFilter { public boolean accepts(ChangeSet changeSet) { changeSetsSeen++; return changeSetsSeen <= changeSetsToAllow; } CountChangeSetFilter(int changeSetsToAllow); boolean accepts(ChangeSet changeSet); }### Answer: @Test public void acceptsZeroCorrectly() { CountChangeSetFilter filter = new CountChangeSetFilter(0); assertFalse(filter.accepts(new ChangeSet("a1","b1",false, false, "c1", null, null))); assertFalse(filter.accepts(new ChangeSet("a2","b2",false, false, "c2", null, null))); } @Test public void acceptsOneCorrectly() { CountChangeSetFilter filter = new CountChangeSetFilter(1); assertTrue(filter.accepts(new ChangeSet("a1","b1",false, false, "c1", null, null))); assertFalse(filter.accepts(new ChangeSet("a2","b2",false, false, "c2", null, null))); } @Test public void acceptsTwoCorrectly() { CountChangeSetFilter filter = new CountChangeSetFilter(2); assertTrue(filter.accepts(new ChangeSet("a1","b1",false, false, "c1", null, null))); assertTrue(filter.accepts(new ChangeSet("a2","b2",false, false, "c2", null, null))); assertFalse(filter.accepts(new ChangeSet("a3","b3",false, false, "c3", null, null))); }

### Question: DbmsChangeSetFilter implements ChangeSetFilter { public boolean accepts(ChangeSet changeSet) { List<SqlVisitor> visitorsToRemove = new ArrayList<SqlVisitor>(); for (SqlVisitor visitor : changeSet.getSqlVisitors()) { if (databaseString != null && visitor.getApplicableDbms() != null && visitor.getApplicableDbms().size() > 0) { boolean shouldRemove = true; if (visitor.getApplicableDbms().contains(databaseString)) { shouldRemove = false; } if (shouldRemove) { visitorsToRemove.add(visitor); } } } changeSet.getSqlVisitors().removeAll(visitorsToRemove); if (databaseString == null) { return true; } if (changeSet.getDbmsSet() == null) { return true; } for (String dbms : changeSet.getDbmsSet()) { if (databaseString.equals(dbms)) { return true; } } return false; } DbmsChangeSetFilter(Database database); boolean accepts(ChangeSet changeSet); }### Answer: @Test public void singleDbms() { DbmsChangeSetFilter filter = new DbmsChangeSetFilter(new MySQLDatabase()); assertTrue(filter.accepts(new ChangeSet(null, null, false, false, null,null, "mysql"))); assertTrue(filter.accepts(new ChangeSet(null, null, false, false, null,null, "mysql, oracle"))); assertFalse(filter.accepts(new ChangeSet(null, null, false, false, null,null, "oracle"))); assertTrue(filter.accepts(new ChangeSet(null, null, false, false, null, null, null))); }

### Question: ChangeLogIterator { public void run(ChangeSetVisitor visitor, Database database) throws LiquibaseException { List<ChangeSet> changeSetList = databaseChangeLog.getChangeSets(); if (visitor.getDirection().equals(ChangeSetVisitor.Direction.REVERSE)) { Collections.reverse(changeSetList); } for (ChangeSet changeSet : changeSetList) { boolean shouldVisit = true; if (changeSetFilters != null) { for (ChangeSetFilter filter : changeSetFilters) { if (!filter.accepts(changeSet)) { shouldVisit = false; break; } } } if (shouldVisit) { visitor.visit(changeSet, databaseChangeLog, database); } } } ChangeLogIterator(DatabaseChangeLog databaseChangeLog, ChangeSetFilter... changeSetFilters); ChangeLogIterator(List<RanChangeSet> changeSetList, DatabaseChangeLog changeLog, ChangeSetFilter... changeSetFilters); void run(ChangeSetVisitor visitor, Database database); }### Answer: @Test public void runChangeSet_emptyFiltersIterator() throws Exception { TestChangeSetVisitor testChangeLogVisitor = new TestChangeSetVisitor(); ChangeLogIterator iterator = new ChangeLogIterator(changeLog); iterator.run(testChangeLogVisitor, null); assertEquals(6, testChangeLogVisitor.visitedChangeSets.size()); } @Test public void runChangeSet_singleFilterIterator() throws Exception { TestChangeSetVisitor testChangeLogVisitor = new TestChangeSetVisitor(); ChangeLogIterator iterator = new ChangeLogIterator(changeLog, new ContextChangeSetFilter("test1")); iterator.run(testChangeLogVisitor, null); assertEquals(4, testChangeLogVisitor.visitedChangeSets.size()); } @Test public void runChangeSet_doubleFilterIterator() throws Exception { TestChangeSetVisitor testChangeLogVisitor = new TestChangeSetVisitor(); ChangeLogIterator iterator = new ChangeLogIterator(changeLog, new ContextChangeSetFilter("test1"), new DbmsChangeSetFilter(new MySQLDatabase())); iterator.run(testChangeLogVisitor, null); assertEquals(3, testChangeLogVisitor.visitedChangeSets.size()); assertEquals("1", testChangeLogVisitor.visitedChangeSets.get(0).getId()); assertEquals("4", testChangeLogVisitor.visitedChangeSets.get(1).getId()); assertEquals("5", testChangeLogVisitor.visitedChangeSets.get(2).getId()); } @Test public void runChangeSet_reverseVisitor() throws Exception { TestChangeSetVisitor testChangeLogVisitor = new ReverseChangeSetVisitor(); ChangeLogIterator iterator = new ChangeLogIterator(changeLog, new ContextChangeSetFilter("test1"), new DbmsChangeSetFilter(new MySQLDatabase())); iterator.run(testChangeLogVisitor, null); assertEquals(3, testChangeLogVisitor.visitedChangeSets.size()); assertEquals("5", testChangeLogVisitor.visitedChangeSets.get(0).getId()); assertEquals("4", testChangeLogVisitor.visitedChangeSets.get(1).getId()); assertEquals("1", testChangeLogVisitor.visitedChangeSets.get(2).getId()); }

### Question: ChangeLogParameters { public Object getValue(String key) { ChangeLogParameter parameter = findParameter(key); return parameter != null ? parameter.getValue() : null; } ChangeLogParameters(); ChangeLogParameters(Database currentDatabase); void addContext(String context); void setContexts(Collection<String> contexts); void set(String paramter, Object value); void set(String key, String value, String contexts, String databases); Object getValue(String key); boolean hasValue(String key); String expandExpressions(String string); }### Answer: @Test public void getParameterValue_systemProperty() { ChangeLogParameters changeLogParameters = new ChangeLogParameters(); assertEquals(System.getProperty("user.name"), changeLogParameters.getValue("user.name")); }

### Question: StringUtils { public static String[] splitSQL(String multiLineSQL, String endDelimiter) { if (endDelimiter == null) { endDelimiter = ";\\s*\n|;$|\n[gG][oO]\\s*\n|\n[Gg][oO]\\s*$"; } else { if (endDelimiter.equalsIgnoreCase("go")) { endDelimiter = "\n[gG][oO]\\s*\n|\n[Gg][oO]\\s*$"; } } String[] initialSplit = multiLineSQL.split(endDelimiter); List<String> strings = new ArrayList<String>(); for (String anInitialSplit : initialSplit) { String singleLineSQL = anInitialSplit.trim(); if (singleLineSQL.length() > 0) { strings.add(singleLineSQL); } } return strings.toArray(new String[strings.size()]); } static String trimToEmpty(String string); static String trimToNull(String string); static String[] processMutliLineSQL(String multiLineSQL,boolean stripComments, boolean splitStatements, String endDelimiter); static String[] splitSQL(String multiLineSQL, String endDelimiter); static String stripComments(String multiLineSQL); static String join(String[] array, String delimiter); static String join(Collection<String> collection, String delimiter); static List<String> splitAndTrim(String s, String regex); static String repeat(String string, int times); static String join(Integer[] array, String delimiter); static String join(int[] array, String delimiter); }### Answer: @Test public void splitOngo() { String sql = "some sql\ngo\nmore sql"; String[] result = StringUtils.splitSQL(sql, null); assertEquals(2,result.length); assertEquals("some sql",result[0]); assertEquals("more sql",result[1]); } @Test public void splitOnGO() { String sql = "some sql\nGO\nmore sql"; String[] result = StringUtils.splitSQL(sql, null); assertEquals(2,result.length); assertEquals("some sql",result[0]); assertEquals("more sql",result[1]); } @Test public void splitWithGo() { String testString = "SELECT *\n" + " FROM sys.objects\n" + " WHERE object_id = OBJECT_ID(N'[test].[currval]')\n" + " AND type in (N'FN', N'IF', N'TF', N'FS', N'FT')\n" + " )\n" + " DROP FUNCTION [test].[currval]\n" + "go\n" + " IF EXISTS\n" + " (\n" + " SELECT *\n" + " FROM sys.objects\n" + " WHERE object_id = OBJECT_ID(N'[test].[nextval]')\n" + " AND type in (N'P', N'PC')\n" + " )\n" + " DROP PROCEDURE [test].[nextval]:"; String[] strings = StringUtils.splitSQL(testString, null); assertEquals(2, strings.length); } @Test public void splitWithX() { String testString = "insert into datatable (col) values ('a value with a ;') X\n"+ "insert into datatable (col) values ('another value with a ;') X"; String[] strings = StringUtils.splitSQL(testString, "X"); assertEquals(2, strings.length); assertEquals("insert into datatable (col) values ('a value with a ;')", strings[0]); assertEquals("insert into datatable (col) values ('another value with a ;')", strings[1]); }

### Question: RollbackVisitor implements ChangeSetVisitor { public void visit(ChangeSet changeSet, DatabaseChangeLog databaseChangeLog, Database database) throws LiquibaseException { LogFactory.getLogger().info("Rolling Back Changeset:" + changeSet); changeSet.rollback(this.database); this.database.removeRanStatus(changeSet); this.database.commit(); } RollbackVisitor(Database database); Direction getDirection(); void visit(ChangeSet changeSet, DatabaseChangeLog databaseChangeLog, Database database); }### Answer: @Test public void visit() throws Exception { Database database = createMock(Database.class); ChangeSet changeSet = createMock(ChangeSet.class); changeSet.rollback(database); expectLastCall(); database.removeRanStatus(changeSet); expectLastCall(); database.commit(); expectLastCall(); replay(changeSet); replay(database); RollbackVisitor visitor = new RollbackVisitor(database); visitor.visit(changeSet, new DatabaseChangeLog(), database); verify(database); verify(changeSet); }

### Question: UpdateVisitor implements ChangeSetVisitor { public void visit(ChangeSet changeSet, DatabaseChangeLog databaseChangeLog, Database database) throws LiquibaseException { ChangeSet.RunStatus runStatus = this.database.getRunStatus(changeSet); log.debug("Running Changeset:" + changeSet); ChangeSet.ExecType execType = changeSet.execute(databaseChangeLog, this.database); if (!runStatus.equals(ChangeSet.RunStatus.NOT_RAN)) { execType = ChangeSet.ExecType.RERAN; } this.database.markChangeSetExecStatus(changeSet, execType); this.database.commit(); } UpdateVisitor(Database database); Direction getDirection(); void visit(ChangeSet changeSet, DatabaseChangeLog databaseChangeLog, Database database); }### Answer: @Test public void visit_unrun() throws Exception { Database database = createMock(Database.class); ChangeSet changeSet = createMock(ChangeSet.class); expect(changeSet.execute(new DatabaseChangeLog("test.xml"), database)).andReturn(ChangeSet.ExecType.EXECUTED); expect(database.getRunStatus(changeSet)).andReturn(ChangeSet.RunStatus.NOT_RAN); database.markChangeSetExecStatus(changeSet, ChangeSet.ExecType.EXECUTED); expectLastCall(); database.commit(); expectLastCall(); replay(changeSet); replay(database); UpdateVisitor visitor = new UpdateVisitor(database); visitor.visit(changeSet, new DatabaseChangeLog("test.xml"), database); verify(database); verify(changeSet); }

### Question: SqlGeneratorChain { public Sql[] generateSql(SqlStatement statement, Database database) { if (sqlGenerators == null) { return null; } if (!sqlGenerators.hasNext()) { return new Sql[0]; } return sqlGenerators.next().generateSql(statement, database, this); } SqlGeneratorChain(SortedSet<SqlGenerator> sqlGenerators); Sql[] generateSql(SqlStatement statement, Database database); Warnings warn(SqlStatement statement, Database database); ValidationErrors validate(SqlStatement statement, Database database); }### Answer: @Test public void generateSql_nullGenerators() { SqlGeneratorChain chain = new SqlGeneratorChain(null); assertNull(chain.generateSql(new MockSqlStatement(), new MockDatabase())); } @Test public void generateSql_noGenerators() { SortedSet<SqlGenerator> generators = new TreeSet<SqlGenerator>(new SqlGeneratorComparator()); SqlGeneratorChain chain = new SqlGeneratorChain(generators); assertEquals(0, chain.generateSql(new MockSqlStatement(), new MockDatabase()).length); } @Test public void generateSql_oneGenerators() { SortedSet<SqlGenerator> generators = new TreeSet<SqlGenerator>(new SqlGeneratorComparator()); generators.add(new MockSqlGenerator(1, "A1", "A2")); SqlGeneratorChain chain = new SqlGeneratorChain(generators); Sql[] sql = chain.generateSql(new MockSqlStatement(), new MockDatabase()); assertEquals(2, sql.length); assertEquals("A1", sql[0].toSql()); assertEquals("A2", sql[1].toSql()); } @Test public void generateSql_twoGenerators() { SortedSet<SqlGenerator> generators = new TreeSet<SqlGenerator>(new SqlGeneratorComparator()); generators.add(new MockSqlGenerator(2, "B1", "B2")); generators.add(new MockSqlGenerator(1, "A1", "A2")); SqlGeneratorChain chain = new SqlGeneratorChain(generators); Sql[] sql = chain.generateSql(new MockSqlStatement(), new MockDatabase()); assertEquals(4, sql.length); assertEquals("B1", sql[0].toSql()); assertEquals("B2", sql[1].toSql()); assertEquals("A1", sql[2].toSql()); assertEquals("A2", sql[3].toSql()); } @Test public void generateSql_threeGenerators() { SortedSet<SqlGenerator> generators = new TreeSet<SqlGenerator>(new SqlGeneratorComparator()); generators.add(new MockSqlGenerator(2, "B1", "B2")); generators.add(new MockSqlGenerator(1, "A1", "A2")); generators.add(new MockSqlGenerator(3, "C1", "C2")); SqlGeneratorChain chain = new SqlGeneratorChain(generators); Sql[] sql = chain.generateSql(new MockSqlStatement(), new MockDatabase()); assertEquals(6, sql.length); assertEquals("C1", sql[0].toSql()); assertEquals("C2", sql[1].toSql()); assertEquals("B1", sql[2].toSql()); assertEquals("B2", sql[3].toSql()); assertEquals("A1", sql[4].toSql()); assertEquals("A2", sql[5].toSql()); }

### Question: SqlGeneratorChain { public ValidationErrors validate(SqlStatement statement, Database database) { if (sqlGenerators == null || !sqlGenerators.hasNext()) { return new ValidationErrors(); } return sqlGenerators.next().validate(statement, database, this); } SqlGeneratorChain(SortedSet<SqlGenerator> sqlGenerators); Sql[] generateSql(SqlStatement statement, Database database); Warnings warn(SqlStatement statement, Database database); ValidationErrors validate(SqlStatement statement, Database database); }### Answer: @Test public void validate_nullGenerators() { SqlGeneratorChain chain = new SqlGeneratorChain(null); ValidationErrors validationErrors = chain.validate(new MockSqlStatement(), new MockDatabase()); assertFalse(validationErrors.hasErrors()); } @Test public void validate_oneGenerators_noErrors() { SortedSet<SqlGenerator> generators = new TreeSet<SqlGenerator>(new SqlGeneratorComparator()); generators.add(new MockSqlGenerator(1, "A1", "A2")); SqlGeneratorChain chain = new SqlGeneratorChain(generators); ValidationErrors validationErrors = chain.validate(new MockSqlStatement(), new MockDatabase()); assertFalse(validationErrors.hasErrors()); } @Test public void validate_oneGenerators_hasErrors() { SortedSet<SqlGenerator> generators = new TreeSet<SqlGenerator>(new SqlGeneratorComparator()); generators.add(new MockSqlGenerator(1, "A1", "A2").addValidationError("E1")); SqlGeneratorChain chain = new SqlGeneratorChain(generators); ValidationErrors validationErrors = chain.validate(new MockSqlStatement(), new MockDatabase()); assertTrue(validationErrors.hasErrors()); } @Test public void validate_twoGenerators_noErrors() { SortedSet<SqlGenerator> generators = new TreeSet<SqlGenerator>(new SqlGeneratorComparator()); generators.add(new MockSqlGenerator(2, "B1", "B2")); generators.add(new MockSqlGenerator(1, "A1", "A2")); SqlGeneratorChain chain = new SqlGeneratorChain(generators); ValidationErrors validationErrors = chain.validate(new MockSqlStatement(), new MockDatabase()); assertFalse(validationErrors.hasErrors()); } @Test public void validate_twoGenerators_firstHasErrors() { SortedSet<SqlGenerator> generators = new TreeSet<SqlGenerator>(new SqlGeneratorComparator()); generators.add(new MockSqlGenerator(2, "B1", "B2").addValidationError("E1")); generators.add(new MockSqlGenerator(1, "A1", "A2")); SqlGeneratorChain chain = new SqlGeneratorChain(generators); ValidationErrors validationErrors = chain.validate(new MockSqlStatement(), new MockDatabase()); assertTrue(validationErrors.hasErrors()); } @Test public void validate_twoGenerators_secondHasErrors() { SortedSet<SqlGenerator> generators = new TreeSet<SqlGenerator>(new SqlGeneratorComparator()); generators.add(new MockSqlGenerator(2, "B1", "B2")); generators.add(new MockSqlGenerator(1, "A1", "A2").addValidationError("E1")); SqlGeneratorChain chain = new SqlGeneratorChain(generators); ValidationErrors validationErrors = chain.validate(new MockSqlStatement(), new MockDatabase()); assertTrue(validationErrors.hasErrors()); }

### Question: DropIndexGenerator extends AbstractSqlGenerator<DropIndexStatement> { public Sql[] generateSql(DropIndexStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) { List<String> associatedWith = StringUtils.splitAndTrim(statement.getAssociatedWith(), ","); if (associatedWith != null) { if (associatedWith.contains(Index.MARK_PRIMARY_KEY)|| associatedWith.contains(Index.MARK_UNIQUE_CONSTRAINT)) { return new Sql[0]; } else if (associatedWith.contains(Index.MARK_FOREIGN_KEY) ) { if (!(database instanceof OracleDatabase || database instanceof MSSQLDatabase)) { return new Sql[0]; } } } String schemaName = statement.getTableSchemaName(); if (database instanceof MySQLDatabase) { return new Sql[] {new UnparsedSql("DROP INDEX " + database.escapeIndexName(null, statement.getIndexName()) + " ON " + database.escapeTableName(schemaName, statement.getTableName())) }; } else if (database instanceof MSSQLDatabase) { return new Sql[] {new UnparsedSql("DROP INDEX " + database.escapeTableName(schemaName, statement.getTableName()) + "." + database.escapeIndexName(null, statement.getIndexName())) }; } else if (database instanceof PostgresDatabase) { return new Sql[]{new UnparsedSql("DROP INDEX " + database.escapeIndexName(schemaName, statement.getIndexName()))}; } return new Sql[] {new UnparsedSql("DROP INDEX " + database.escapeIndexName(schemaName, statement.getIndexName())) }; } ValidationErrors validate(DropIndexStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain); Sql[] generateSql(DropIndexStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain); }### Answer: @Test public void shouldDropIndexInPostgreSQL() throws Exception { DropIndexGenerator dropIndexGenerator = new DropIndexGenerator(); DropIndexStatement statement = new DropIndexStatement("indexName", "defaultSchema", "aTable", null); Database database = new PostgresDatabase(); SortedSet<SqlGenerator> sqlGenerators = new TreeSet<SqlGenerator>(); SqlGeneratorChain sqlGenerationChain = new SqlGeneratorChain(sqlGenerators); Sql[] sqls = dropIndexGenerator.generateSql(statement, database, sqlGenerationChain); assertEquals("DROP INDEX \"defaultSchema\".\"indexName\"", sqls[0].toSql()); statement = new DropIndexStatement("index_name", "default_schema", "a_table", null); sqls = dropIndexGenerator.generateSql(statement, database, sqlGenerationChain); assertEquals("DROP INDEX default_schema.index_name", sqls[0].toSql()); statement = new DropIndexStatement("index_name", null, "a_table", null); sqls = dropIndexGenerator.generateSql(statement, database, sqlGenerationChain); assertEquals("DROP INDEX index_name", sqls[0].toSql()); }

### Question: AddColumnGeneratorDefaultClauseBeforeNotNull extends AddColumnGenerator { @Override public ValidationErrors validate(AddColumnStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) { ValidationErrors validationErrors = super.validate(statement, database, sqlGeneratorChain); if (database instanceof DerbyDatabase && statement.isAutoIncrement()) { validationErrors.addError("Cannot add an identity column to a database"); } return validationErrors; } @Override int getPriority(); @Override boolean supports(AddColumnStatement statement, Database database); @Override ValidationErrors validate(AddColumnStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain); @Override Sql[] generateSql(AddColumnStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain); }### Answer: @Test public void validate_noAutoIncrementWithDerby() { ValidationErrors validationErrors = generatorUnderTest.validate(new AddColumnStatement(null, "table_name", "column_name", "int", null, new AutoIncrementConstraint("column_name")), new DerbyDatabase(), new MockSqlGeneratorChain()); assertTrue(validationErrors.getErrorMessages().contains("Cannot add an identity column to a database")); }

### Question: InsertOrUpdateGeneratorMSSQL extends InsertOrUpdateGenerator { protected String getRecordCheck(InsertOrUpdateStatement insertOrUpdateStatement, Database database, String whereClause) { StringBuffer recordCheck = new StringBuffer(); recordCheck.append("DECLARE @reccount integer\n"); recordCheck.append("SELECT @reccount = count(*) FROM "); recordCheck.append(database.escapeTableName(insertOrUpdateStatement.getSchemaName(),insertOrUpdateStatement.getTableName())); recordCheck.append(" WHERE "); recordCheck.append(whereClause); recordCheck.append("\n"); recordCheck.append("IF @reccount = 0\n"); return recordCheck.toString(); } boolean supports(InsertOrUpdateStatement statement, Database database); @Override Sql[] generateSql(InsertOrUpdateStatement insertOrUpdateStatement, Database database, SqlGeneratorChain sqlGeneratorChain); }### Answer: @Test public void getRecordCheck(){ InsertOrUpdateGeneratorMSSQL generator = new InsertOrUpdateGeneratorMSSQL(); MSSQLDatabase database = new MSSQLDatabase(); InsertOrUpdateStatement statement = new InsertOrUpdateStatement("myschema","mytable","pk_col1"); statement.addColumnValue("pk_col1","value1"); statement.addColumnValue("col2","value2"); String where = "1 = 1"; Class c = InsertOrUpdateGenerator.class.getClass(); String recordCheck = (String)invokePrivateMethod(generator,"getRecordCheck", new Object[] {statement,database,where}); Integer lineNumber = 0; String[] lines = recordCheck.split("\n"); assertEquals("DECLARE @reccount integer", lines[lineNumber]); lineNumber++; assertEquals("SELECT @reccount = count(*) FROM [myschema].[mytable] WHERE " + where, lines[lineNumber]); lineNumber++; assertEquals("IF @reccount = 0", lines[lineNumber]); }

### Question: InsertOrUpdateGeneratorMSSQL extends InsertOrUpdateGenerator { protected String getElse(Database database) { return "ELSE\n"; } boolean supports(InsertOrUpdateStatement statement, Database database); @Override Sql[] generateSql(InsertOrUpdateStatement insertOrUpdateStatement, Database database, SqlGeneratorChain sqlGeneratorChain); }### Answer: @Test public void getElse(){ InsertOrUpdateGeneratorMSSQL generator = new InsertOrUpdateGeneratorMSSQL(); MSSQLDatabase database = new MSSQLDatabase(); InsertOrUpdateStatement statement = new InsertOrUpdateStatement("myschema","mytable","pk_col1"); statement.addColumnValue("pk_col1","value1"); statement.addColumnValue("col2","value2"); String where = "1 = 1"; Class c = InsertOrUpdateGenerator.class.getClass(); String insertStatement = (String)invokePrivateMethod(generator,"getElse", new Object[] {database}); Integer lineNumber = 0; String[] lines = insertStatement.split("\n"); assertEquals("ELSE", lines[lineNumber]); }

### Question: AutoIncrementConstraint implements ColumnConstraint { public String getColumnName() { return columnName; } AutoIncrementConstraint(); AutoIncrementConstraint(String columnName); AutoIncrementConstraint( String columnName, BigInteger startWith, BigInteger incrementBy); String getColumnName(); AutoIncrementConstraint setColumnName(String columnName); BigInteger getStartWith(); AutoIncrementConstraint setStartWith(BigInteger startWith); BigInteger getIncrementBy(); AutoIncrementConstraint setIncrementBy(BigInteger incrementBy); }### Answer: @Test public void ctor() { AutoIncrementConstraint constraint = new AutoIncrementConstraint("COL_NAME"); assertEquals("COL_NAME", constraint.getColumnName()); }

### Question: GetViewDefinitionGeneratorSybase extends GetViewDefinitionGenerator { @Override public Sql[] generateSql(GetViewDefinitionStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) { try { String sql = "select text from syscomments where id = object_id('" + database.convertRequestedSchemaToSchema(statement.getSchemaName()) + "." + statement.getViewName() + "') order by colid"; return new Sql[]{ new UnparsedSql(sql) }; } catch (DatabaseException e) { throw new UnexpectedLiquibaseException(e); } } @Override int getPriority(); @Override boolean supports(GetViewDefinitionStatement statement, Database database); @Override Sql[] generateSql(GetViewDefinitionStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain); }### Answer: @Test public void testGenerateSqlForDefaultSchema() { GetViewDefinitionGeneratorSybase generator = new GetViewDefinitionGeneratorSybase(); GetViewDefinitionStatement statement = new GetViewDefinitionStatement(null, "view_name"); Sql[] sql = generator.generateSql(statement, new SybaseDatabase(), null); assertEquals(1, sql.length); assertEquals("select text from syscomments where id = object_id('dbo.view_name') order by colid", sql[0].toSql()); } @Test public void testGenerateSqlForNamedSchema() { GetViewDefinitionGeneratorSybase generator = new GetViewDefinitionGeneratorSybase(); GetViewDefinitionStatement statement = new GetViewDefinitionStatement("owner", "view_name"); Sql[] sql = generator.generateSql(statement, new SybaseDatabase(), null); assertEquals(1, sql.length); assertEquals("select text from syscomments where id = object_id('owner.view_name') order by colid", sql[0].toSql()); }

### Question: SqlGeneratorFactory { public static SqlGeneratorFactory getInstance() { if (instance == null) { instance = new SqlGeneratorFactory(); } return instance; } private SqlGeneratorFactory(); static SqlGeneratorFactory getInstance(); static void reset(); void register(SqlGenerator generator); void unregister(SqlGenerator generator); void unregister(Class generatorClass); Sql[] generateSql(SqlStatement statement, Database database); boolean requiresCurrentDatabaseMetadata(SqlStatement statement, Database database); boolean supports(SqlStatement statement, Database database); ValidationErrors validate(SqlStatement statement, Database database); Warnings warn(SqlStatement statement, Database database); Set<DatabaseObject> getAffectedDatabaseObjects(SqlStatement statement, Database database); }### Answer: @Test public void getInstance() { assertNotNull(SqlGeneratorFactory.getInstance()); assertTrue(SqlGeneratorFactory.getInstance() == SqlGeneratorFactory.getInstance()); }

### Question: SqlGeneratorFactory { public void register(SqlGenerator generator) { generators.add(generator); } private SqlGeneratorFactory(); static SqlGeneratorFactory getInstance(); static void reset(); void register(SqlGenerator generator); void unregister(SqlGenerator generator); void unregister(Class generatorClass); Sql[] generateSql(SqlStatement statement, Database database); boolean requiresCurrentDatabaseMetadata(SqlStatement statement, Database database); boolean supports(SqlStatement statement, Database database); ValidationErrors validate(SqlStatement statement, Database database); Warnings warn(SqlStatement statement, Database database); Set<DatabaseObject> getAffectedDatabaseObjects(SqlStatement statement, Database database); }### Answer: @Test public void register() { SqlGeneratorFactory.getInstance().getGenerators().clear(); assertEquals(0, SqlGeneratorFactory.getInstance().getGenerators().size()); SqlGeneratorFactory.getInstance().register(new MockSqlGenerator(1, "A1")); assertEquals(1, SqlGeneratorFactory.getInstance().getGenerators().size()); }

### Question: SqlGeneratorFactory { public static void reset() { instance = new SqlGeneratorFactory(); } private SqlGeneratorFactory(); static SqlGeneratorFactory getInstance(); static void reset(); void register(SqlGenerator generator); void unregister(SqlGenerator generator); void unregister(Class generatorClass); Sql[] generateSql(SqlStatement statement, Database database); boolean requiresCurrentDatabaseMetadata(SqlStatement statement, Database database); boolean supports(SqlStatement statement, Database database); ValidationErrors validate(SqlStatement statement, Database database); Warnings warn(SqlStatement statement, Database database); Set<DatabaseObject> getAffectedDatabaseObjects(SqlStatement statement, Database database); }### Answer: @Test public void reset() { SqlGeneratorFactory instance1 = SqlGeneratorFactory.getInstance(); SqlGeneratorFactory.reset(); assertFalse(instance1 == SqlGeneratorFactory.getInstance()); }

### Question: SqlGeneratorFactory { protected Collection<SqlGenerator> getGenerators() { return generators; } private SqlGeneratorFactory(); static SqlGeneratorFactory getInstance(); static void reset(); void register(SqlGenerator generator); void unregister(SqlGenerator generator); void unregister(Class generatorClass); Sql[] generateSql(SqlStatement statement, Database database); boolean requiresCurrentDatabaseMetadata(SqlStatement statement, Database database); boolean supports(SqlStatement statement, Database database); ValidationErrors validate(SqlStatement statement, Database database); Warnings warn(SqlStatement statement, Database database); Set<DatabaseObject> getAffectedDatabaseObjects(SqlStatement statement, Database database); }### Answer: @Test public void getGenerators() { SortedSet<SqlGenerator> allGenerators = SqlGeneratorFactory.getInstance().getGenerators(new AddAutoIncrementStatement(null, "person", "name", "varchar(255)", null, null), new H2Database()); assertNotNull(allGenerators); assertEquals(1, allGenerators.size()); }

### Question: PreconditionFactory { public static PreconditionFactory getInstance() { if (instance == null) { instance = new PreconditionFactory(); } return instance; } @SuppressWarnings("unchecked") private PreconditionFactory(); static PreconditionFactory getInstance(); static void reset(); Map<String, Class<? extends Precondition>> getPreconditions(); void register(Class<? extends Precondition> clazz); void unregister(String name); Precondition create(String tagName); }### Answer: @Test public void getInstance() { assertNotNull(PreconditionFactory.getInstance()); assertTrue(PreconditionFactory.getInstance() == PreconditionFactory.getInstance()); }

### Question: PreconditionFactory { public void register(Class<? extends Precondition> clazz) { try { preconditions.put(clazz.newInstance().getName(), clazz); } catch (Exception e) { throw new UnexpectedLiquibaseException(e); } } @SuppressWarnings("unchecked") private PreconditionFactory(); static PreconditionFactory getInstance(); static void reset(); Map<String, Class<? extends Precondition>> getPreconditions(); void register(Class<? extends Precondition> clazz); void unregister(String name); Precondition create(String tagName); }### Answer: @Test public void register() { PreconditionFactory.getInstance().getPreconditions().clear(); assertEquals(0, PreconditionFactory.getInstance().getPreconditions().size()); PreconditionFactory.getInstance().register(MockPrecondition.class); assertEquals(1, PreconditionFactory.getInstance().getPreconditions().size()); }

### Question: PreconditionFactory { public static void reset() { instance = new PreconditionFactory(); } @SuppressWarnings("unchecked") private PreconditionFactory(); static PreconditionFactory getInstance(); static void reset(); Map<String, Class<? extends Precondition>> getPreconditions(); void register(Class<? extends Precondition> clazz); void unregister(String name); Precondition create(String tagName); }### Answer: @Test public void reset() { PreconditionFactory instance1 = PreconditionFactory.getInstance(); PreconditionFactory.reset(); assertFalse(instance1 == PreconditionFactory.getInstance()); }