Datasets:

Minata
/

512src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Files and versions Community

Split (2)

train · 184k rows

method2testcases stringlengths 118 3.08k
### Question: NthItem extends KorypheFunction<Iterable<T>, T> { @Override @SuppressFBWarnings(value = "DE_MIGHT_IGNORE", justification = "Any exceptions are to be ignored") public T apply(final Iterable<T> input) { if (null == input) { throw new IllegalArgumentException("Input cannot be null"); } try { return Iterables.get(input, selection); } finally { CloseableUtil.close(input); } } NthItem(); NthItem(final int selection); @Override @SuppressFBWarnings(value = "DE_MIGHT_IGNORE", justification = "Any exceptions are to be ignored") T apply(final Iterable<T> input); void setSelection(final int selection); int getSelection(); @Override boolean equals(final Object o); @Override int hashCode(); }### Answer: @Test public void shouldReturnCorrectValueWithInteger() { final NthItem<Integer> function = new NthItem<>(2); final Integer result = function.apply(Arrays.asList(1, 2, 3, 4, 5)); assertNotNull(result); assertEquals(3, result); } @Test public void shouldReturnCorrectValueWithString() { final NthItem<String> function = new NthItem<>(1); final String result = function.apply(Arrays.asList("these", "are", "test", "strings")); assertNotNull(result); assertEquals("are", result); } @Test public void shouldReturnNullForNullElement() { final NthItem<Integer> function = new NthItem<>(1); final Integer result = function.apply(Arrays.asList(1, null, 3)); assertNull(result); } @Test public void shouldThrowExceptionForNullInput() { final NthItem<Integer> function = new NthItem<>(); final Exception exception = assertThrows(IllegalArgumentException.class, () -> function.apply(null)); assertEquals("Input cannot be null", exception.getMessage()); }
### Question: LastItem extends KorypheFunction<Iterable<T>, T> { @Override @SuppressFBWarnings(value = "DE_MIGHT_IGNORE", justification = "Any exceptions are to be ignored") public T apply(final Iterable<T> input) { if (null == input) { throw new IllegalArgumentException("Input cannot be null"); } try { return Iterables.getLast(input, null); } finally { CloseableUtil.close(input); } } @Override @SuppressFBWarnings(value = "DE_MIGHT_IGNORE", justification = "Any exceptions are to be ignored") T apply(final Iterable<T> input); }### Answer: @Test public void shouldReturnCorrectValueWithInteger() { final LastItem<Integer> function = new LastItem<>(); final Integer result = function.apply(Arrays.asList(2, 3, 5, 7, 11)); assertNotNull(result); assertEquals(new Integer(11), result); } @Test public void shouldReturnCorrectValueWithString() { final LastItem<String> function = new LastItem<>(); final String result = function.apply(Arrays.asList("these", "are", "test", "strings")); assertNotNull(result); assertEquals("strings", result); } @Test public void shouldReturnNullForNullElement() { final LastItem<Integer> function = new LastItem<>(); final Integer result = function.apply(Arrays.asList(1, 2, null)); assertNull(result); } @Test public void shouldThrowExceptionForNullInput() { final LastItem<Integer> function = new LastItem<>(); final Exception exception = assertThrows(IllegalArgumentException.class, () -> function.apply(null)); assertEquals("Input cannot be null", exception.getMessage()); }
### Question: Divide extends KorypheFunction2<Integer, Integer, Tuple2<Integer, Integer>> { @Override public Tuple2<Integer, Integer> apply(final Integer input1, final Integer input2) { int in2 = input2 == null ? 1 : input2; if (input1 == null) { return null; } else { return new Tuple2<>(input1 / in2, input1 % in2); } } @Override Tuple2<Integer, Integer> apply(final Integer input1, final Integer input2); }### Answer: @Test public void shouldDivide2() { final Divide function = new Divide(); Tuple2<Integer, Integer> output = function.apply(4, 2); assertEquals(new Tuple2<>(2, 0), output); } @Test public void shouldDivideBy2WithRemainder() { final Divide function = new Divide(); Tuple2<Integer, Integer> output = function.apply(5, 2); assertEquals(new Tuple2<>(2, 1), output); } @Test public void shouldDivide1IfNull() { final Divide function = new Divide(); Tuple2<Integer, Integer> output = function.apply(9, null); assertEquals(new Tuple2<>(9, 0), output); }
### Question: DictionaryLookup extends KorypheFunction<K, V> { @Override public V apply(final K key) { if (dictionary == null) { throw new IllegalArgumentException("The " + DictionaryLookup.class.getName() + " KorypheFunction has not been provided with a dictionary"); } return dictionary.get(key); } DictionaryLookup(); DictionaryLookup(final Map<K, V> dictionary); @Override V apply(final K key); Map<K, V> getDictionary(); void setDictionary(final Map<K, V> dictionary); @Override boolean equals(final Object o); @Override int hashCode(); }### Answer: @Test public void shouldReturnExistingValueInDictionary() { assertEquals(1, (int) dictionaryLookUp.apply("one")); assertEquals(2, (int) dictionaryLookUp.apply("two")); } @Test public void shouldReturnNullIfNullKeyIsSupplied() { assertNull(dictionaryLookUp.apply(null)); } @Test public void shouldReturnNullIfItemDoesntExistInDictionary() { assertNull(dictionaryLookUp.apply("three")); } @Test public void shouldThrowExceptionIfDictionaryIsSetToNull() { final Exception exception = assertThrows(IllegalArgumentException.class, () -> new DictionaryLookup<>().apply("four")); final String expected = "The uk.gov.gchq.koryphe.impl.function.DictionaryLookup KorypheFunction has not been provided with a dictionary"; assertEquals(expected, exception.getMessage()); }
### Question: CsvLinesToMaps extends KorypheFunction<Iterable<String>, Iterable<Map<String, Object>>> implements Serializable { @Override public Iterable<Map<String, Object>> apply(final Iterable<String> csvStrings) { if (isNull(csvStrings)) { return null; } final CloseableIterable<String> csvRecords = IterableUtil.limit(csvStrings, firstRow, null, false); return IterableUtil.map(csvRecords, (item) -> createMap((String) item)); } @Override Iterable<Map<String, Object>> apply(final Iterable<String> csvStrings); List<String> getHeader(); void setHeader(final List<String> header); int getFirstRow(); void setFirstRow(final int firstRow); CsvLinesToMaps firstRow(final int firstRow); CsvLinesToMaps header(final String... header); CsvLinesToMaps header(final Collection<String> header); char getDelimiter(); void setDelimiter(final char delimiter); CsvLinesToMaps delimiter(final char delimiter); boolean isQuoted(); void setQuoted(final boolean quoted); CsvLinesToMaps quoted(); CsvLinesToMaps quoted(final boolean quoted); char getQuoteChar(); void setQuoteChar(final char quoteChar); CsvLinesToMaps quoteChar(final char quoteChar); @Override boolean equals(final Object o); @Override int hashCode(); }### Answer: @Test public void shouldReturnNullForNullInput() { final CsvLinesToMaps function = new CsvLinesToMaps(); final List<String> input = null; final Object result = function.apply(input); assertNull(result); }
### Question: Gunzip extends KorypheFunction<byte[], byte[]> { @SuppressFBWarnings(value = "PZLA_PREFER_ZERO_LENGTH_ARRAYS", justification = "Returning null means the input was null") @Override public byte[] apply(final byte[] compressed) { if (isNull(compressed)) { return null; } if (compressed.length == 0) { return new byte[0]; } try (final GZIPInputStream gzipStream = new GZIPInputStream(new ByteArrayInputStream(compressed))) { return IOUtils.toByteArray(gzipStream); } catch (final IOException e) { throw new RuntimeException("Failed to decompress provided gzipped string", e); } } @SuppressFBWarnings(value = "PZLA_PREFER_ZERO_LENGTH_ARRAYS", justification = "Returning null means the input was null") @Override byte[] apply(final byte[] compressed); }### Answer: @Test public void shouldUncompressString() throws IOException { final Gunzip function = new Gunzip(); final byte[] input = "test string".getBytes(); final byte[] gzip; try (final ByteArrayOutputStream out = new ByteArrayOutputStream(); final GZIPOutputStream gzipOut = new GZIPOutputStream(out)) { gzipOut.write(input); gzipOut.flush(); gzipOut.close(); gzip = out.toByteArray(); } final byte[] result = function.apply(gzip); assertArrayEquals(input, result); } @Test public void shouldReturnNullForNullInput() { final Gunzip function = new Gunzip(); final byte[] result = function.apply(null); assertNull(result); }
### Question: Length extends KorypheFunction<Object, Integer> implements InputValidator { @Override public ValidationResult isInputValid(final Class<?>... arguments) { final ValidationResult result = new ValidationResult(); if (null == arguments \|\| 1 != arguments.length \|\| null == arguments[0]) { result.addError("Incorrect number of arguments for " + getClass().getName() + ". One (1) argument is required."); return result; } if (!String.class.isAssignableFrom(arguments[0]) && !Object[].class.isAssignableFrom(arguments[0]) && !Iterable.class.isAssignableFrom(arguments[0]) && !Map.class.isAssignableFrom(arguments[0])) { result.addError("Input class " + arguments[0].getName() + " must be one of the following: " + String.class.getName() + ", " + Object[].class.getName() + ", " + Iterable.class.getName() + ", " + Map.class.getName()); } return result; } Length(); Length(final Integer maxLength); @Override Integer apply(final Object value); @Override ValidationResult isInputValid(final Class<?>... arguments); Integer getMaxLength(); void setMaxLength(final Integer maxLength); @Override boolean equals(final Object o); @Override int hashCode(); }### Answer: @Test public void shouldCheckInputClass() { final Length function = new Length(); assertTrue(function.isInputValid(String.class).isValid()); assertTrue(function.isInputValid(Object[].class).isValid()); assertTrue(function.isInputValid(Integer[].class).isValid()); assertTrue(function.isInputValid(Collection.class).isValid()); assertTrue(function.isInputValid(List.class).isValid()); assertTrue(function.isInputValid(Map.class).isValid()); assertTrue(function.isInputValid(HashMap.class).isValid()); assertFalse(function.isInputValid(String.class, HashMap.class).isValid()); assertFalse(function.isInputValid(Double.class).isValid()); assertFalse(function.isInputValid(Integer.class, Integer.class).isValid()); }
### Question: DeserialiseJson extends KorypheFunction<String, T> implements Serializable { public DeserialiseJson<T> outputClass(final Class<T> outputClass) { setOutputClass(outputClass); return this; } DeserialiseJson(); DeserialiseJson(final Class<T> outputClass); @Override T apply(final String json); Class<T> getOutputClass(); DeserialiseJson<T> outputClass(final Class<T> outputClass); void setOutputClass(final Class<T> outputClass); @Override boolean equals(final Object o); @Override int hashCode(); }### Answer: @Test @Override public void shouldJsonSerialiseAndDeserialise() throws IOException { final DeserialiseJson function = new DeserialiseJson().outputClass(Map.class); final String json = JsonSerialiser.serialise(function); JsonSerialiser.assertEquals(String.format("{%n" + " \"class\" : \"uk.gov.gchq.koryphe.impl.function.DeserialiseJson\",%n" + " \"outputClass\" : \"java.util.Map\"" + "}"), json); }
### Question: DeserialiseJson extends KorypheFunction<String, T> implements Serializable { @Override public T apply(final String json) { if (isNull(json)) { return null; } try { return MAPPER.readValue(json, outputClass); } catch (final IOException e) { throw new RuntimeException("Failed to deserialise JSON", e); } } DeserialiseJson(); DeserialiseJson(final Class<T> outputClass); @Override T apply(final String json); Class<T> getOutputClass(); DeserialiseJson<T> outputClass(final Class<T> outputClass); void setOutputClass(final Class<T> outputClass); @Override boolean equals(final Object o); @Override int hashCode(); }### Answer: @Test public void shouldParseJson() { final DeserialiseJson function = new DeserialiseJson(); final String input = "{\"elements\": [{\"value\": \"value1\"}, {\"value\": \"value2\"}]}"; Object result = function.apply(input); Map<String, Object> element2aMap = new HashMap<>(); element2aMap.put("value", "value1"); Map<String, Object> element2bMap = new HashMap<>(); element2bMap.put("value", "value2"); HashMap<Object, Object> expectedRootMap = new HashMap<>(); expectedRootMap.put("elements", Arrays.asList(element2aMap, element2bMap)); assertEquals(expectedRootMap, result); } @Test public void shouldReturnNullForNullInput() { final DeserialiseJson function = new DeserialiseJson(); Object result = function.apply(null); assertNull(result); }
### Question: AdaptedPredicate extends InputAdapted<I, PI> implements Predicate<I> { public Predicate<PI> getPredicate() { return predicate; } AdaptedPredicate(); AdaptedPredicate(final Function<I, PI> inputAdapter, final Predicate<PI> predicate); @Override boolean test(final I input); Predicate<PI> getPredicate(); void setPredicate(final Predicate<PI> predicate); @Override boolean equals(final Object o); @Override int hashCode(); }### Answer: @Test public void shouldJsonSerialiseAndDeserialise() throws IOException { final AdaptedPredicate original = new AdaptedPredicate(new ToString(), new IsEqual("3")); final String serialised = JsonSerialiser.serialise(original); String expected = "{" + "\"inputAdapter\":{" + "\"class\":\"uk.gov.gchq.koryphe.impl.function.ToString\"" + "}," + "\"predicate\":{" + "\"class\":\"uk.gov.gchq.koryphe.impl.predicate.IsEqual\"," + "\"value\":\"3\"" + "}" + "}"; assertEquals(expected, serialised); final AdaptedPredicate deserialised = JsonSerialiser.deserialise(serialised, AdaptedPredicate.class); assertEquals(original.getPredicate().getClass(), deserialised.getPredicate().getClass()); assertEquals(original.getInputAdapter().getClass(), deserialised.getInputAdapter().getClass()); assertEquals(((IsEqual) original.getPredicate()).getControlValue(), ((IsEqual) deserialised.getPredicate()).getControlValue()); }
### Question: ExtractValue extends KorypheFunction<Map<K, V>, V> { public K getKey() { return key; } ExtractValue(); ExtractValue(final K key); K getKey(); void setKey(final K key); @Override V apply(final Map<K, V> map); @Override boolean equals(final Object o); @Override int hashCode(); }### Answer: @Test @Override public void shouldJsonSerialiseAndDeserialise() throws IOException { final ExtractValue<String, Integer> function = new ExtractValue<>("test"); final String json = JsonSerialiser.serialise(function); JsonSerialiser.assertEquals(String.format("{%n" + " \"class\" : \"uk.gov.gchq.koryphe.impl.function.ExtractValue\",%n" + " \"key\" : \"test\"%n" + "}"), json); final ExtractValue deserialised = JsonSerialiser.deserialise(json, ExtractValue.class); assertNotNull(deserialised); assertEquals("test", deserialised.getKey()); }
### Question: ExtractValue extends KorypheFunction<Map<K, V>, V> { @Override public V apply(final Map<K, V> map) { return null == map ? null : map.get(key); } ExtractValue(); ExtractValue(final K key); K getKey(); void setKey(final K key); @Override V apply(final Map<K, V> map); @Override boolean equals(final Object o); @Override int hashCode(); }### Answer: @Test public void shouldExtractCorrectValueFromMap() { final ExtractValue<String, Integer> function = new ExtractValue<>("secondKey"); final Map<String, Integer> input = new HashMap<>(); input.put("firstKey", 1); input.put("secondKey", 3); input.put("thirdKey", 6); input.put("second", 12); final Integer result = function.apply(input); assertEquals(3, result); } @Test public void shouldThrowExceptionForEmptyInput() { final ExtractValue<String, Integer> function = new ExtractValue<>(); final Integer result = function.apply(null); assertNull(result); }
### Question: MultiplyLongBy extends KorypheFunction<Long, Long> { public Long apply(final Long input) { if (null == input) { return null; } else { return input * by; } } MultiplyLongBy(); MultiplyLongBy(final long by); long getBy(); void setBy(final long by); Long apply(final Long input); @Override boolean equals(final Object o); @Override int hashCode(); }### Answer: @Test public void shouldMultiplyBy2() { final MultiplyLongBy function = new MultiplyLongBy(2L); long output = function.apply(4L); assertEquals(8L, output); } @Test public void shouldMultiplyBy1IfByIsNotSet() { final MultiplyLongBy function = new MultiplyLongBy(); long output = function.apply(9L); assertEquals(9L, output); } @Test public void shouldReturnNullIfInputIsNull() { final MultiplyLongBy function = new MultiplyLongBy(2L); Long output = function.apply(null); assertNull(output); }
### Question: MultiplyLongBy extends KorypheFunction<Long, Long> { public long getBy() { return by; } MultiplyLongBy(); MultiplyLongBy(final long by); long getBy(); void setBy(final long by); Long apply(final Long input); @Override boolean equals(final Object o); @Override int hashCode(); }### Answer: @Test @Override public void shouldJsonSerialiseAndDeserialise() throws IOException { final MultiplyLongBy function = new MultiplyLongBy(4L); final String json = JsonSerialiser.serialise(function); JsonSerialiser.assertEquals(String.format("{%n" + " \"class\" : \"uk.gov.gchq.koryphe.impl.function.MultiplyLongBy\",%n" + " \"by\" : 4%n" + "}"), json); final MultiplyLongBy deserialisedMultiplyLongBy = JsonSerialiser.deserialise(json, MultiplyLongBy.class); assertNotNull(deserialisedMultiplyLongBy); assertEquals(4L, deserialisedMultiplyLongBy.getBy()); }
### Question: CsvToMaps extends KorypheFunction<String, Iterable<Map<String, Object>>> implements Serializable { @Override public Iterable<Map<String, Object>> apply(final String csv) { if (isNull(csv)) { return null; } try { final CSVParser csvParser = new CSVParser(new StringReader(csv), getCsvFormat()); final CloseableIterable<CSVRecord> csvRecords = IterableUtil.limit(csvParser.getRecords(), firstRow, null, false); return IterableUtil.map(csvRecords, (item) -> extractMap((CSVRecord) item)); } catch (final IOException e) { throw new RuntimeException("Unable to parse csv", e); } } @Override Iterable<Map<String, Object>> apply(final String csv); List<String> getHeader(); void setHeader(final List<String> header); int getFirstRow(); void setFirstRow(final int firstRow); CsvToMaps firstRow(final int firstRow); CsvToMaps header(final String... header); CsvToMaps header(final Collection<String> header); char getDelimiter(); void setDelimiter(final char delimiter); CsvToMaps delimiter(final char delimiter); boolean isQuoted(); void setQuoted(final boolean quoted); CsvToMaps quoted(); CsvToMaps quoted(final boolean quoted); char getQuoteChar(); void setQuoteChar(final char quoteChar); CsvToMaps quoteChar(final char quoteChar); @Override boolean equals(final Object o); @Override int hashCode(); }### Answer: @Test public void shouldReturnNullForNullInput() { final CsvToMaps function = new CsvToMaps(); Object result = function.apply(null); assertNull(result); }
### Question: Multiply extends KorypheFunction2<Integer, Integer, Integer> { @Override public Integer apply(final Integer input1, final Integer input2) { if (input2 == null) { return input1; } else if (input1 == null) { return null; } else { return input1 * input2; } } @Override Integer apply(final Integer input1, final Integer input2); }### Answer: @Test public void shouldMultiply2() { final Multiply function = new Multiply(); final int output = function.apply(4, 2); assertEquals(8, output); } @Test public void shouldMultiply1IfSecondIsNull() { final Multiply function = new Multiply(); final int output = function.apply(9, null); assertEquals(9, output); } @Test public void shouldMultiply1IfFirstIsNull() { final Multiply function = new Multiply(); final Integer output = function.apply(null, 9); assertEquals(null, output); }
### Question: IsEmpty extends KorypheFunction<Iterable, Boolean> { @Override @SuppressFBWarnings(value = "DE_MIGHT_IGNORE", justification = "Any exceptions are to be ignored") public Boolean apply(final Iterable input) { if (null == input) { throw new IllegalArgumentException("Input cannot be null"); } try { return Iterables.isEmpty(input); } finally { CloseableUtil.close(input); } } @Override @SuppressFBWarnings(value = "DE_MIGHT_IGNORE", justification = "Any exceptions are to be ignored") Boolean apply(final Iterable input); }### Answer: @Test public void shouldReturnTrueForEmptyIterable() { final IsEmpty function = new IsEmpty(); final Iterable input = Sets.newHashSet(); final Boolean result = function.apply(input); assertTrue(result); } @Test public void shouldReturnFalseForPopulatedIterable() { final IsEmpty function = new IsEmpty(); final Iterable input = Arrays.asList(3, 1, 4, 1, 6); final Boolean result = function.apply(input); assertFalse(result); } @Test public void shouldReturnFalseForNullElements() { final IsEmpty function = new IsEmpty(); final Iterable input = Arrays.asList(null, null); final Boolean result = function.apply(input); assertFalse(result); } @Test public void shouldThrowExceptionForNullInput() { final IsEmpty function = new IsEmpty(); final Exception exception = assertThrows(IllegalArgumentException.class, () -> function.apply(null)); assertEquals("Input cannot be null", exception.getMessage()); }
### Question: IterableLongest extends KorypheFunction<Iterable<?>, Object> { @Override public Object apply(final Iterable<?> items) { if (nonNull(items)) { return getLongest(items); } return null; } IterableLongest(); @Override Object apply(final Iterable<?> items); }### Answer: @Test public void shouldHandleNullInput() { final IterableLongest function = getInstance(); final Object result = function.apply(null); assertNull(result); } @Test public void shouldGetLongestItemFromList() { final IterableLongest function = getInstance(); final List<String> list = Lists.newArrayList("a", "ab", "abc"); final Object result = function.apply(list); assertEquals("abc", result); }
### Question: ToInteger extends KorypheFunction<Object, Integer> { @Override public Integer apply(final Object value) { if (null == value) { return null; } if (value instanceof Number) { return ((Number) value).intValue(); } if (value instanceof String) { return Integer.valueOf(((String) value)); } throw new IllegalArgumentException("Could not convert value to Integer: " + value); } @Override Integer apply(final Object value); }### Answer: @Test public void shouldConvertToInteger() { final ToInteger function = new ToInteger(); Object output = function.apply(new Long(5)); assertEquals(5, output); assertEquals(Integer.class, output.getClass()); }
### Question: ToList extends KorypheFunction<Object, List<?>> { @Override public List<?> apply(final Object value) { if (null == value) { return Lists.newArrayList((Object) null); } if (value instanceof Object[]) { return Lists.newArrayList((Object[]) value); } if (value instanceof Iterable) { if (value instanceof List) { return (List<?>) value; } return Lists.newArrayList((Iterable) value); } return Lists.newArrayList(value); } @Override List<?> apply(final Object value); }### Answer: @Test public void shouldConvertNullToList() { final ToList function = new ToList(); final Object result = function.apply(null); assertEquals(Lists.newArrayList((Object) null), result); } @Test public void shouldConvertStringToList() { final ToList function = new ToList(); final Object value = "value1"; final Object result = function.apply(value); assertEquals(Lists.newArrayList(value), result); } @Test public void shouldConvertArrayToList() { final ToList function = new ToList(); final Object value = new String[] {"value1", "value2"}; final Object result = function.apply(value); assertEquals(Lists.newArrayList((Object[]) value), result); } @Test public void shouldConvertSetToList() { final ToList function = new ToList(); final Set<String> value = Sets.newLinkedHashSet(Arrays.asList("value1", "value2")); final Object result = function.apply(value); assertEquals(Lists.newArrayList(value), result); } @Test public void shouldReturnAGivenList() { final ToList function = new ToList(); final Object value = Lists.newArrayList("value1", "value2"); final Object result = function.apply(value); assertSame(value, result); }
### Question: ReverseString extends KorypheFunction<String, String> { @Override public String apply(final String value) { return StringUtils.reverse(value); } @Override String apply(final String value); }### Answer: @Test public void shouldHandleNullInput() { final ReverseString function = new ReverseString(); final String result = function.apply(null); assertNull(result); } @Test public void shouldReverseString() { final ReverseString function = new ReverseString(); final String input = "12345"; final String result = function.apply(input); assertEquals("54321", result); }
### Question: ToNull extends KorypheFunction<Object, Object> { @Override public Object apply(final Object value) { return null; } @Override Object apply(final Object value); }### Answer: @Test public void shouldReturnNullWhenValueIsNotNull() { final ToNull function = new ToNull(); final Object output = function.apply("test"); assertNull(output); } @Test public void shouldReturnNullWhenValueIsNull() { final ToNull function = new ToNull(); final Object output = function.apply(null); assertNull(output); }
### Question: StringAppend extends KorypheFunction<String, String> { @Override public String apply(final String value) { if (null == value) { return null; } if (null == suffix) { return value; } return value + suffix; } StringAppend(); StringAppend(final String suffix); @Override String apply(final String value); String getSuffix(); void setSuffix(final String suffix); @Override boolean equals(final Object o); @Override int hashCode(); }### Answer: @Test public void shouldHandleNullInput() { final StringAppend function = new StringAppend("!"); final String result = function.apply(null); assertNull(result); } @Test public void shouldHandleNullSuffix() { final StringAppend function = new StringAppend(null); final String result = function.apply("Hello"); assertEquals("Hello", result); } @Test public void shouldAppendStringToInput() { final StringAppend function = new StringAppend("!"); final String result = function.apply("Hello"); assertEquals("Hello!", result); } @Test public void shouldHandleUnsetSuffix() { final StringAppend function = new StringAppend(); final String result = function.apply("Hello"); assertEquals("Hello", result); }
### Question: CallMethod extends KorypheFunction<Object, Object> { @Override public Object apply(final Object obj) { if (null == obj) { return null; } Class clazz = obj.getClass(); Method method = cache.get(clazz); if (null == method) { method = getMethodFromClass(clazz); Map<Class, Method> newCache = new HashMap<>(cache); newCache.put(clazz, method); cache = newCache; } try { return method.invoke(obj); } catch (final IllegalAccessException \| InvocationTargetException e) { throw new RuntimeException("Unable to invoke " + getMethod() + " on object class " + clazz, e); } } CallMethod(); CallMethod(final String method); String getMethod(); void setMethod(final String method); @Override Object apply(final Object obj); @Override boolean equals(final Object o); @Override int hashCode(); }### Answer: @Test public void shouldCallMethod() { final CallMethod function = new CallMethod(TEST_METHOD); final Object output = function.apply(this); assertEquals(5, output); }
### Question: CallMethod extends KorypheFunction<Object, Object> { public String getMethod() { return method; } CallMethod(); CallMethod(final String method); String getMethod(); void setMethod(final String method); @Override Object apply(final Object obj); @Override boolean equals(final Object o); @Override int hashCode(); }### Answer: @Test @Override public void shouldJsonSerialiseAndDeserialise() throws IOException { final CallMethod function = new CallMethod(TEST_METHOD); final String json = JsonSerialiser.serialise(function); JsonSerialiser.assertEquals(String.format("{%n" + " \"class\" : \"uk.gov.gchq.koryphe.impl.function.CallMethod\",%n" + " \"method\" : \"testMethod\"%n" + "}"), json); final CallMethod deserialisedCallMethod = JsonSerialiser.deserialise(json, CallMethod.class); assertNotNull(deserialisedCallMethod); assertEquals(TEST_METHOD, deserialisedCallMethod.getMethod()); }
### Question: Size extends KorypheFunction<Iterable, Integer> { @Override @SuppressFBWarnings(value = "DE_MIGHT_IGNORE", justification = "Any exceptions are to be ignored") public Integer apply(final Iterable input) { if (null == input) { throw new IllegalArgumentException("Input cannot be null"); } try { return Iterables.size(input); } finally { CloseableUtil.close(input); } } @Override @SuppressFBWarnings(value = "DE_MIGHT_IGNORE", justification = "Any exceptions are to be ignored") Integer apply(final Iterable input); }### Answer: @Test public void shouldReturnSizeForGivenIterable() { final Size function = new Size(); final Iterable input = Arrays.asList(1, 2, 3, 4, 5); final int result = function.apply(input); assertEquals(5, result); } @Test public void shouldHandleIterableWithNullElement() { final Size function = new Size(); final Iterable<Integer> input = Arrays.asList(1, 2, null, 4, 5); final int result = function.apply(input); assertEquals(5, result); } @Test public void shouldHandleIterableOfAllNullElements() { final Size function = new Size(); final Iterable<Object> input = Arrays.asList(null, null, null); final int result = function.apply(input); assertEquals(3, result); } @Test public void shouldThrowExceptionForNullInput() { final Size function = new Size(); final Exception exception = assertThrows(IllegalArgumentException.class, () -> function.apply(null)); assertEquals("Input cannot be null", exception.getMessage()); }
### Question: Concat extends KorypheFunction2<Object, Object, String> { @Override public String apply(final Object input1, final Object input2) { if (null == input1) { if (null == input2) { return null; } return String.valueOf(input2); } if (null == input2) { return String.valueOf(input1); } return input1 + separator + input2; } Concat(); Concat(final String separator); @Override String apply(final Object input1, final Object input2); String getSeparator(); void setSeparator(final String separator); @Override boolean equals(final Object obj); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void shouldConcatStringsWithDefaultSeparator() { final Concat concat = new Concat(); String output = concat.apply("1", "2"); assertEquals("1,2", output); } @Test public void shouldConvertNullValuesToEmptyStringWhenConcatenating() { final Concat concat = new Concat(); final String output = concat.apply("1", null); assertEquals("1", output); } @Test public void shouldReturnNullForNullInput() { final Concat concat = new Concat(); final String output = concat.apply(null, null); assertNull(output); }
### Question: ParseDate extends KorypheFunction<String, Date> { @Override public Date apply(final String dateString) { if (isNull(dateString)) { return null; } try { final Date date; if (isNull(format)) { date = DateUtil.parse(dateString, timeZone); } else { final SimpleDateFormat simpleDateFormat = new SimpleDateFormat(format); if (nonNull(timeZone)) { simpleDateFormat.setTimeZone(timeZone); } date = simpleDateFormat.parse(dateString); } return date; } catch (final ParseException e) { throw new IllegalArgumentException("Date string could not be parsed: " + dateString, e); } } ParseDate(); @Override Date apply(final String dateString); String getFormat(); void setFormat(final String format); ParseDate format(final String format); TimeZone getTimeZone(); @JsonGetter("timeZone") String getTimeZoneAsString(); @JsonSetter void setTimeZone(final String timeZone); void setTimeZone(final TimeZone timeZone); ParseDate timeZone(final String timeZone); ParseDate timeZone(final TimeZone timeZone); @Override boolean equals(final Object o); @Override int hashCode(); }### Answer: @Test public void shouldParseDate() throws ParseException { final ParseDate function = new ParseDate(); final String input = "2000-01-02 03:04:05.006"; final Date result = function.apply(input); assertEquals(new SimpleDateFormat("yyyy-MM-dd hh:mm:ss.SSS").parse(input), result); } @Test public void shouldReturnNullForNullInput() { final ParseDate function = new ParseDate(); final Object result = function.apply(null); assertNull(result); }
### Question: IterableFlatten extends KorypheFunction<Iterable<I_ITEM>, I_ITEM> { @Override public I_ITEM apply(final Iterable<I_ITEM> items) { if (nonNull(items) && nonNull(operator)) { return StreamSupport.stream(items.spliterator(), false) .onClose(() -> CloseableUtil.close(items)) .reduce(operator) .orElse(null); } return null; } IterableFlatten(); IterableFlatten(final BinaryOperator<I_ITEM> operator); @Override I_ITEM apply(final Iterable<I_ITEM> items); @JsonTypeInfo(use = JsonTypeInfo.Id.CLASS, include = JsonTypeInfo.As.PROPERTY, property = "class") BinaryOperator<I_ITEM> getOperator(); void setOperator(final BinaryOperator<I_ITEM> operator); @Override boolean equals(final Object o); @Override int hashCode(); }### Answer: @Test public void shouldHandleNullInput() { final IterableFlatten<?> function = new IterableFlatten<>(); final Object result = function.apply(null); assertNull(result); } @Test public void shouldFlattenIterableNumbers() { final IterableFlatten<Number> function = new IterableFlatten<>(new Sum()); final List<Number> input = Lists.newArrayList(1, 2, 3, 4, 5); final Number result = function.apply(input); assertEquals(15, result); } @Test public void shouldFlattenIterableStrings() { final IterableFlatten<String> function = new IterableFlatten<>((a, b) -> a + b); final Set<String> input = Sets.newHashSet("a", "b", "c"); final String result = function.apply(input); assertEquals("abc", result); }
### Question: SetValue extends KorypheFunction<Object, Object> { @Override public Object apply(final Object o) { return value; } SetValue(); SetValue(final Object returnValue); @Override Object apply(final Object o); Object getValue(); void setValue(final Object identity); @Override boolean equals(final Object o); @Override int hashCode(); }### Answer: @Test public void shouldSetValue() { final SetValue function = new SetValue(SET_VALUE); Object output = function.apply("test"); assertEquals(SET_VALUE, output); }
### Question: SetValue extends KorypheFunction<Object, Object> { public Object getValue() { return value; } SetValue(); SetValue(final Object returnValue); @Override Object apply(final Object o); Object getValue(); void setValue(final Object identity); @Override boolean equals(final Object o); @Override int hashCode(); }### Answer: @Test public void shouldSerialiseAndDeserialiseLong() throws IOException { final SetValue function = new SetValue(1L); final String json = JsonSerialiser.serialise(function); JsonSerialiser.assertEquals(String.format("{%n" + " \"class\" : \"uk.gov.gchq.koryphe.impl.function.SetValue\",%n" + " \"value\" : {\"java.lang.Long\" : 1}%n" + "}"), json); final SetValue deserialisedFunction = JsonSerialiser.deserialise(json, SetValue.class); assertEquals(1L, deserialisedFunction.getValue()); }
### Question: MapToTuple extends KorypheFunction<Map<K, Object>, Tuple<K>> implements Serializable { @Override public Tuple<K> apply(final Map<K, Object> map) { return new MapTuple<>(map); } @Override Tuple<K> apply(final Map<K, Object> map); }### Answer: @Test public void shouldConvertMapIntoMapTuple() { final MapToTuple function = new MapToTuple(); Map<String, Object> input = new HashMap<>(); input.put("A", 1); input.put("B", 2); input.put("C", 3); Tuple output = function.apply(input); assertEquals(new MapTuple<>(input), output); }
### Question: IterableFunction extends KorypheFunction<Iterable<I_ITEM>, Iterable<O_ITEM>> { @JsonTypeInfo(use = JsonTypeInfo.Id.CLASS, include = JsonTypeInfo.As.PROPERTY, property = "class") public List<Function> getFunctions() { return functions; } IterableFunction(); IterableFunction(final Function function); IterableFunction(final List<Function> functions); @Override Iterable<O_ITEM> apply(final Iterable<I_ITEM> items); @JsonTypeInfo(use = JsonTypeInfo.Id.CLASS, include = JsonTypeInfo.As.PROPERTY, property = "class") List<Function> getFunctions(); void setFunctions(final List<Function> functions); @Override boolean equals(final Object obj); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void shouldPopulateFunctionFromBuilder() { final Function<Integer, String> func = Object::toString; final Function<String, Integer> func1 = Integer::valueOf; final Function<Integer, String> func2 = Object::toString; final IterableFunction<Integer, String> function = new IterableFunction.Builder<Integer>() .first(func) .then(func1) .then(func2) .build(); assertEquals(3, function.getFunctions().size()); assertEquals(Arrays.asList(func, func1, func2), function.getFunctions()); }
### Question: ToLowerCase extends KorypheFunction<Object, String> { @Override public String apply(final Object value) { if (null == value) { return null; } if (value instanceof String) { return StringUtils.lowerCase((String) value); } return StringUtils.lowerCase(value.toString()); } @Override String apply(final Object value); }### Answer: @Test public void shouldLowerCaseInputString() { final Function function = getInstance(); final Object output = function.apply(TEST_STRING); assertEquals(StringUtils.lowerCase(TEST_STRING), output); } @Test public void shouldLowerCaseInputObject() { final Function function = getInstance(); final ToLowerCaseTestObject input = new ToLowerCaseTestObject(); final Object output = function.apply(input); assertEquals(StringUtils.lowerCase(input.getClass().getSimpleName().toUpperCase()), output); } @Test public void shouldHandleNullInput() { final Function function = getInstance(); Object output = function.apply(null); assertNull(output); }
### Question: PredicateMap extends KoryphePredicate<Map<?, T>> { @JsonTypeInfo(use = JsonTypeInfo.Id.CLASS, include = JsonTypeInfo.As.WRAPPER_OBJECT) public Object getKey() { return key; } PredicateMap(); PredicateMap(final Object key, final Predicate<? super T> predicate); @Override boolean test(final Map<?, T> map); @JsonTypeInfo(use = JsonTypeInfo.Id.CLASS, include = JsonTypeInfo.As.PROPERTY, property = "class") Predicate<? super T> getPredicate(); void setPredicate(final Predicate<? super T> predicate); @JsonTypeInfo(use = JsonTypeInfo.Id.CLASS, include = JsonTypeInfo.As.WRAPPER_OBJECT) Object getKey(); void setKey(final Object key); @Override boolean equals(final Object obj); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void shouldJsonSerialiseAndDeserialise() throws IOException { final PredicateMap<String> mapFilter = new PredicateMap<>(DATE_KEY, new IsA(Map.class)); final String json = JsonSerialiser.serialise(mapFilter); JsonSerialiser.assertEquals(String.format("{\n" + " \"class\" : \"uk.gov.gchq.koryphe.predicate.PredicateMap\",\n" + " \"predicate\" : {\n" + " \"class\" : \"uk.gov.gchq.koryphe.impl.predicate.IsA\",\n" + " \"type\" : \"java.util.Map\"\n" + " },\n" + " \"key\" : {\n" + " \"java.util.Date\" : " + DATE_KEY.getTime() + "%n" + " }\n" + "}"), json); final PredicateMap deserialisedFilter = JsonSerialiser.deserialise(json, PredicateMap.class); assertNotNull(deserialisedFilter); assertEquals(DATE_KEY, deserialisedFilter.getKey()); }
### Question: DeserialiseXml extends KorypheFunction<String, Map<String, Object>> implements Serializable { @Override public Map<String, Object> apply(final String xml) { if (isNull(xml)) { return null; } return XML.toJSONObject(xml).toMap(); } @Override Map<String, Object> apply(final String xml); }### Answer: @Test public void shouldParseXml() { final DeserialiseXml function = new DeserialiseXml(); final String input = "<root><element1><element2 attr=\"attr1\">value1</element2></element1><element1><element2>value2</element2></element1></root>"; Map<String, Object> result = function.apply(input); Map<String, Object> element2aMap = new HashMap<>(); Map<String, Object> element2aAttrContentMap = new HashMap<>(); element2aAttrContentMap.put("attr", "attr1"); element2aAttrContentMap.put("content", "value1"); element2aMap.put("element2", element2aAttrContentMap); Map<String, Object> element2bMap = new HashMap<>(); element2bMap.put("element2", "value2"); HashMap<Object, Object> element1Map = new HashMap<>(); element1Map.put("element1", Arrays.asList(element2aMap, element2bMap)); HashMap<Object, Object> expectedRootMap = new HashMap<>(); expectedRootMap.put("root", element1Map); assertEquals(expectedRootMap, result); } @Test public void shouldReturnNullForNullInput() { final DeserialiseXml function = new DeserialiseXml(); Map<String, Object> result = function.apply(null); assertNull(result); }
### Question: IterableFilter extends KorypheFunction<Iterable<I_ITEM>, Iterable<I_ITEM>> { @JsonTypeInfo(use = JsonTypeInfo.Id.CLASS, include = JsonTypeInfo.As.PROPERTY, property = "class") public Predicate<I_ITEM> getPredicate() { return predicate; } IterableFilter(); IterableFilter(final Predicate predicate); @Override Iterable<I_ITEM> apply(final Iterable<I_ITEM> items); @JsonTypeInfo(use = JsonTypeInfo.Id.CLASS, include = JsonTypeInfo.As.PROPERTY, property = "class") Predicate<I_ITEM> getPredicate(); IterableFilter<I_ITEM> predicate(final Predicate predicate); IterableFilter<I_ITEM> setPredicate(final Predicate<I_ITEM> predicate); @Override boolean equals(final Object o); @Override int hashCode(); }### Answer: @Test @Override public void shouldJsonSerialiseAndDeserialise() throws IOException { final IterableFilter predicate = getInstance(); final String json = JsonSerialiser.serialise(predicate); JsonSerialiser.assertEquals("{" + "\"class\":\"uk.gov.gchq.koryphe.impl.function.IterableFilter\"," + "\"predicate\":{\"class\":\"uk.gov.gchq.koryphe.impl.predicate.IsMoreThan\",\"orEqualTo\":false,\"value\":1}" + "}", json); final IterableFilter deserialised = JsonSerialiser.deserialise(json, IterableFilter.class); assertNotNull(deserialised); assertEquals(1, ((IsMoreThan) deserialised.getPredicate()).getControlValue()); }
### Question: MultiplyBy extends KorypheFunction<Integer, Integer> { public Integer apply(final Integer input) { if (input == null) { return null; } else { return input * by; } } MultiplyBy(); MultiplyBy(final int by); int getBy(); void setBy(final int by); Integer apply(final Integer input); @Override boolean equals(final Object o); @Override int hashCode(); }### Answer: @Test public void shouldMultiplyBy2() { final MultiplyBy function = new MultiplyBy(2); int output = function.apply(4); assertEquals(8, output); } @Test public void shouldMultiplyBy1IfByIsNotSet() { final MultiplyBy function = new MultiplyBy(); int output = function.apply(9); assertEquals(9, output); } @Test public void shouldReturnNullIfInputIsNull() { final MultiplyBy function = new MultiplyBy(2); Integer output = function.apply(null); assertNull(output); }
### Question: MultiplyBy extends KorypheFunction<Integer, Integer> { public int getBy() { return by; } MultiplyBy(); MultiplyBy(final int by); int getBy(); void setBy(final int by); Integer apply(final Integer input); @Override boolean equals(final Object o); @Override int hashCode(); }### Answer: @Test @Override public void shouldJsonSerialiseAndDeserialise() throws IOException { final MultiplyBy function = new MultiplyBy(4); final String json = JsonSerialiser.serialise(function); JsonSerialiser.assertEquals(String.format("{%n" + " \"class\" : \"uk.gov.gchq.koryphe.impl.function.MultiplyBy\",%n" + " \"by\" : 4%n" + "}"), json); final MultiplyBy deserialisedMultiplyBy = JsonSerialiser.deserialise(json, MultiplyBy.class); assertNotNull(deserialisedMultiplyBy); assertEquals(4, deserialisedMultiplyBy.getBy()); }
### Question: StringReplace extends KorypheFunction<String, String> { @Override public String apply(final String input) { return StringUtils.replace(input, searchString, replacement); } StringReplace(); StringReplace(final String searchString, final String replacement); @Override String apply(final String input); String getReplacement(); void setReplacement(final String replacement); String getSearchString(); void setSearchString(final String searchString); @Override boolean equals(final Object o); @Override int hashCode(); }### Answer: @Test public void shouldHandleNullInput() { final StringReplace function = new StringReplace(); final String result = function.apply(null); assertNull(result); } @Test public void shouldHandleNullSearchString() { final StringReplace function = new StringReplace(null, "output"); final String input = "An input string."; final String result = function.apply(input); assertEquals("An input string.", result); } @Test public void shouldHandleNullReplacement() { final StringReplace function = new StringReplace("input", null); final String input = "An input string."; final String result = function.apply(input); assertEquals("An input string.", result); } @Test public void shouldHandleNullSearchStringAndReplacement() { final StringReplace function = new StringReplace(null, null); final String input = "An input string."; final String result = function.apply(input); assertEquals("An input string.", result); } @Test public void shouldReplaceInString() { final StringReplace function = new StringReplace("input", "output"); final String input = "An input string."; final String result = function.apply(input); assertEquals("An output string.", result); }
### Question: ExtractValues extends KorypheFunction<Map<K, V>, Iterable<V>> { @Override public Iterable<V> apply(final Map<K, V> map) { return null == map ? null : map.values(); } @Override Iterable<V> apply(final Map<K, V> map); }### Answer: @Test public void shouldExtractValuesFromGivenMap() { final ExtractValues<String, Integer> function = new ExtractValues<>(); final Map<String, Integer> input = new HashMap<>(); input.put("first", 1); input.put("second", 2); input.put("third", 3); final Iterable<Integer> results = function.apply(input); assertThat(results, containsInAnyOrder(1, 2, 3)); } @Test public void shouldReturnEmptySetForEmptyMap() { final ExtractValues<String, Integer> function = new ExtractValues<>(); final Iterable<Integer> results = function.apply(new HashMap<>()); assertTrue(Iterables.isEmpty(results)); } @Test public void shouldReturnNullForNullInput() { final ExtractValues<String, String> function = new ExtractValues<>(); final Map<String, String> input = null; final Iterable result = function.apply(input); assertNull(result); }
### Question: IterableConcat extends KorypheFunction<Iterable<Iterable<I_ITEM>>, Iterable<I_ITEM>> { @Override public Iterable<I_ITEM> apply(final Iterable<Iterable<I_ITEM>> items) { return IterableUtil.concat(items); } @Override Iterable<I_ITEM> apply(final Iterable<Iterable<I_ITEM>> items); }### Answer: @Test public void shouldFlattenNestedIterables() { final IterableConcat<Integer> function = new IterableConcat<>(); final Iterable<Integer> result = function.apply(Arrays.asList( Arrays.asList(1, 2, 3), Arrays.asList(4, 5, 6))); assertNotNull(result); assertEquals(Arrays.asList(1, 2, 3, 4, 5, 6), Lists.newArrayList(result)); } @Test public void shouldHandleNullInputIterable() { final IterableConcat<Integer> function = new IterableConcat<>(); final Exception exception = assertThrows(IllegalArgumentException.class, () -> function.apply(null)); assertEquals("iterables are required", exception.getMessage()); } @Test public void shouldReturnEmptyIterableForEmptyInput() { final IterableConcat<Integer> function = new IterableConcat<>(); final Iterable<Iterable<Integer>> input = new ArrayList<>(); final Iterable<Integer> results = function.apply(input); assertTrue(Iterables.isEmpty(results)); } @Test public void shouldHandleNullElementsOfInnerIterable() { final IterableConcat<Integer> function = new IterableConcat<>(); final Iterable<Iterable<Integer>> input = Arrays.asList( Arrays.asList(1, 2, null, 4), Arrays.asList(5, null, 7)); final Iterable<Integer> results = function.apply(input); assertEquals(Arrays.asList(1, 2, null, 4, 5, null, 7), Lists.newArrayList(results)); }
### Question: DefaultIfEmpty extends KorypheFunction<Object, Object> { @Override public Object apply(final Object iterable) { if (null == iterable) { return null; } return (delegate.apply(iterable) == 0) ? defaultValue : iterable; } DefaultIfEmpty(); DefaultIfEmpty(final Object defaultValue); @Override Object apply(final Object iterable); Object getDefaultValue(); void setDefaultValue(final Object defaultValue); @Override boolean equals(final Object o); @Override int hashCode(); }### Answer: @Test public void shouldHandleNullInput() { final DefaultIfEmpty function = new DefaultIfEmpty(); final Object result = function.apply(null); assertNull(result); } @Test public void shouldReturnDefaultValueIfEmpty() { final DefaultIfEmpty defaultIfEmpty = new DefaultIfEmpty(DEFAULT_VALUE); final Object result = defaultIfEmpty.apply(Collections.emptyList()); assertEquals(DEFAULT_VALUE, result); } @Test public void shouldReturnOriginalValueIfNotEmpty() { final List<String> iterable = Lists.newArrayList("first", "second"); final DefaultIfEmpty defaultIfEmpty = new DefaultIfEmpty(DEFAULT_VALUE); final Object result = defaultIfEmpty.apply(iterable); assertEquals(iterable, result); }
### Question: ApplyBiFunction extends KorypheFunction2<T, U, R> implements WrappedBiFunction<T, U, R> { @Override public R apply(final T t, final U u) { return nonNull(function) ? function.apply(t, u) : null; } ApplyBiFunction(); ApplyBiFunction(final BiFunction<T, U, R> function); @Override R apply(final T t, final U u); @Override @JsonTypeInfo(use = JsonTypeInfo.Id.CLASS, include = JsonTypeInfo.As.PROPERTY, property = "class") BiFunction<T, U, R> getFunction(); void setFunction(final BiFunction<T, U, R> function); @Override boolean equals(final Object o); @Override int hashCode(); }### Answer: @Test public void shouldApplyBiFunction() { final ApplyBiFunction<Number, Number, Number> function = new ApplyBiFunction<>(new Sum()); final Tuple2<Number, Number> input = new Tuple2<>(1, 2); final Number result = function.apply(input); assertEquals(3, result); } @Test public void shouldReturnNullForNullFunction() { final ApplyBiFunction<Number, Number, Number> function = new ApplyBiFunction<>(); final Tuple2<Number, Number> input = new Tuple2<>(1, 2); final Object result = function.apply(input); assertNull(result); }
### Question: Base64Decode extends KorypheFunction<byte[], byte[]> { @SuppressFBWarnings(value = "PZLA_PREFER_ZERO_LENGTH_ARRAYS", justification = "Returning null means the input was null") @Override public byte[] apply(final byte[] base64Encoded) { if (isNull(base64Encoded)) { return null; } if (base64Encoded.length == 0) { return new byte[0]; } return Base64.decodeBase64(base64Encoded); } @SuppressFBWarnings(value = "PZLA_PREFER_ZERO_LENGTH_ARRAYS", justification = "Returning null means the input was null") @Override byte[] apply(final byte[] base64Encoded); }### Answer: @Test public void shouldDecodeBase64() { final Base64Decode function = new Base64Decode(); byte[] input = "test string".getBytes(); final byte[] base64 = Base64.encodeBase64(input); final byte[] result = function.apply(base64); assertArrayEquals(input, result); } @Test public void shouldReturnNullForNullInput() { final Base64Decode function = new Base64Decode(); final byte[] result = function.apply(null); assertNull(result); }
### Question: ToSet extends KorypheFunction<Object, Set<?>> { @Override public Set<?> apply(final Object value) { if (null == value) { return Sets.newHashSet((Object) null); } if (value instanceof Object[]) { return Sets.newHashSet((Object[]) value); } if (value instanceof Iterable) { if (value instanceof Set) { return (Set<?>) value; } return Sets.newHashSet((Iterable) value); } return Sets.newHashSet(value); } @Override Set<?> apply(final Object value); }### Answer: @Test public void shouldConvertNullToSet() { final ToSet function = new ToSet(); final Object result = function.apply(null); assertEquals(Sets.newHashSet((Object) null), result); } @Test public void shouldConvertStringToSet() { final ToSet function = new ToSet(); final Object value = "value1"; final Object result = function.apply(value); assertEquals(Sets.newHashSet(value), result); } @Test public void shouldConvertArrayToSet() { final ToSet function = new ToSet(); final Object value = new String[] {"value1", "value2"}; Object result = function.apply(value); assertEquals(Sets.newHashSet((Object[]) value), result); } @Test public void shouldConvertListToSet() { final ToSet function = new ToSet(); final Object value = Lists.newArrayList("value1", "value2"); final Object result = function.apply(value); assertEquals(Sets.newHashSet((List) value), result); } @Test public void shouldReturnAGivenSet() { final ToSet function = new ToSet(); final Object value = Sets.newHashSet("value1", "value2"); final Object result = function.apply(value); assertSame(value, result); }
### Question: CreateObject extends KorypheFunction<Object, Object> { public Class<?> getObjectClass() { return objectClass; } CreateObject(); CreateObject(final Class<?> objectClass); @Override Object apply(final Object value); Class<?> getObjectClass(); void setObjectClass(final Class<?> objectClass); @Override boolean equals(final Object o); @Override int hashCode(); }### Answer: @Test @Override public void shouldJsonSerialiseAndDeserialise() throws IOException { final CreateObject function = new CreateObject(ArrayList.class); final String json = JsonSerialiser.serialise(function); JsonSerialiser.assertEquals(String.format("{%n" + " \"class\" : \"uk.gov.gchq.koryphe.impl.function.CreateObject\",%n" + " \"objectClass\" : \"" + ArrayList.class.getName() + "\"%n" + "}"), json); final CreateObject deserialised = JsonSerialiser.deserialise(json, CreateObject.class); assertNotNull(deserialised); assertEquals(ArrayList.class, deserialised.getObjectClass()); }
### Question: StringTrim extends KorypheFunction<String, String> { @Override public String apply(final String input) { return StringUtils.trim(input); } StringTrim(); @Override String apply(final String input); }### Answer: @Test public void shouldHandleNullInput() { final StringTrim function = new StringTrim(); final String result = function.apply(null); assertNull(result); } @Test public void shouldTrimInputString() { final StringTrim function = new StringTrim(); final String input = " Input String "; final String result = function.apply(input); assertEquals("Input String", result); }
### Question: DefaultIfNull extends KorypheFunction<Object, Object> { @Override public Object apply(final Object input) { return null == input ? defaultValue : input; } DefaultIfNull(); DefaultIfNull(final Object defaultValue); @Override Object apply(final Object input); void setDefaultValue(final Object defaultValue); Object getDefaultValue(); @Override boolean equals(final Object o); @Override int hashCode(); }### Answer: @Test public void shouldReturnDefaultValueIfNull() { final DefaultIfNull defaultIfNull = new DefaultIfNull(DEFAULT_VALUE); final Object result = defaultIfNull.apply(null); assertEquals(result, DEFAULT_VALUE); } @Test public void shouldReturnOriginalValueIfNotNull() { final DefaultIfNull defaultIfNull = new DefaultIfNull(DEFAULT_VALUE); final Object result = defaultIfNull.apply("input"); assertEquals(result, "input"); }
### Question: StringTruncate extends KorypheFunction<String, String> { @Override public String apply(final String input) { if (null == input) { return null; } String truncated = input.substring(0, Math.min(input.length(), length)); if (ellipses && truncated.length() < input.length()) { truncated += ELLIPSES; } return truncated; } StringTruncate(); StringTruncate(final int length); StringTruncate(final int length, final boolean ellipses); @Override String apply(final String input); int getLength(); void setLength(final int length); boolean isEllipses(); void setEllipses(final boolean ellipses); @Override boolean equals(final Object o); @Override int hashCode(); }### Answer: @Test public void shouldHandleNullInput() { final StringTruncate function = new StringTruncate(); final String result = function.apply(null); assertNull(result); } @Test public void shouldTruncateString() { final StringTruncate function = new StringTruncate(10); final String input = "A long input string"; final String result = function.apply(input); assertEquals("A long inp", result); } @Test public void shouldTruncateStringWithEllipses() { final StringTruncate function = new StringTruncate(10, true); final String input = "A long input string"; final String result = function.apply(input); assertEquals("A long inp...", result); } @Test public void shouldReturnFullStringIfInputShorterThanMaxLength() { final StringTruncate function = new StringTruncate(10); final String input = "123 56"; final String result = function.apply(input); assertEquals(result, input); }
### Question: ToArray extends KorypheFunction<Object, Object[]> { @Override public Object[] apply(final Object value) { if (null == value) { return new Object[]{null}; } if (value instanceof Object[]) { return ((Object[]) value); } if (value instanceof Iterable) { return Iterables.toArray(((Iterable) value), Object.class); } return new Object[]{value}; } @Override Object[] apply(final Object value); }### Answer: @Test public void shouldConvertNullToArray() { final ToArray function = new ToArray(); final Object[] result = function.apply(null); assertArrayEquals(new Object[] {null}, result); } @Test public void shouldConvertStringToArray() { final ToArray function = new ToArray(); final Object value = "value1"; final Object[] result = function.apply(value); assertArrayEquals(new Object[] {value}, result); } @Test public void shouldConvertListToArray() { final ToArray function = new ToArray(); final Object value = Lists.newArrayList("value1", "value2"); final Object[] result = function.apply(value); assertArrayEquals(new Object[] {"value1", "value2"}, result); } @Test public void shouldConvertSetToArray() { final ToArray function = new ToArray(); final Object value = Sets.newLinkedHashSet(Arrays.asList("value1", "value2")); final Object[] result = function.apply(value); assertArrayEquals(new Object[] {"value1", "value2"}, result); } @Test public void shouldReturnAGivenArray() { final ToArray function = new ToArray(); final Object value = new Object[] {"value1"}; final Object[] result = function.apply(value); assertSame(value, result); }
### Question: FirstItem extends KorypheFunction<Iterable<T>, T> { @Override @SuppressFBWarnings(value = "DE_MIGHT_IGNORE", justification = "Any exceptions are to be ignored") public T apply(final Iterable<T> input) { if (null == input) { throw new IllegalArgumentException("Input cannot be null"); } try { return Iterables.getFirst(input, null); } finally { CloseableUtil.close(input); } } @Override @SuppressFBWarnings(value = "DE_MIGHT_IGNORE", justification = "Any exceptions are to be ignored") T apply(final Iterable<T> input); }### Answer: @Test public void shouldReturnCorrectValueWithInteger() { final FirstItem<Integer> function = new FirstItem<>(); final Integer result = function.apply(Arrays.asList(1, 2, 3, 4)); assertNotNull(result); assertEquals(1, result); } @Test public void shouldReturnCorrectValueWithString() { final FirstItem<String> function = new FirstItem<>(); final String result = function.apply(Arrays.asList("these", "are", "test", "strings")); assertNotNull(result); assertEquals("these", result); } @Test public void shouldReturnNullForNullElement() { final FirstItem<String> function = new FirstItem<>(); final String result = function.apply(Arrays.asList(null, "two", "three")); assertNull(result); } @Test public void shouldThrowErrorForNullInput() { final FirstItem<String> function = new FirstItem<>(); final Exception exception = assertThrows(IllegalArgumentException.class, () -> function.apply(null)); assertTrue(exception.getMessage().contains("Input cannot be null")); }
### Question: ToUpperCase extends KorypheFunction<Object, String> { @Override public String apply(final Object value) { if (null == value) { return null; } if (value instanceof String) { return StringUtils.upperCase((String) value); } return StringUtils.upperCase(value.toString()); } @Override String apply(final Object value); }### Answer: @Test public void shouldUpperCaseInputString() { final Function function = getInstance(); final Object output = function.apply(TEST_STRING); assertEquals(StringUtils.upperCase(TEST_STRING), output); } @Test public void shouldUpperCaseInputObject() { final Function function = getInstance(); final ToUpperCaseTestObject input = new ToUpperCaseTestObject(); final Object output = function.apply(input); assertEquals(StringUtils.upperCase(input.getClass().getSimpleName().toLowerCase()), output); } @Test public void shouldHandleNullInput() { final Function function = getInstance(); Object output = function.apply(null); assertNull(output); }
### Question: Cast extends KorypheFunction<I, O> { @Override public O apply(final I value) { return outputClass.cast(value); } Cast(); Cast(final Class<O> outputClass); @Override O apply(final I value); Class<O> getOutputClass(); void setOutputClass(final Class<O> outputClass); @Override boolean equals(final Object o); @Override int hashCode(); }### Answer: @Disabled @Test public void shouldCast() { final Cast function = new Cast(Integer.class); Object output = function.apply(new Long(5)); assertEquals(Integer.class, output.getClass()); }
### Question: StringRegexReplace extends KorypheFunction<String, String> { @Override public String apply(final String input) { if (null == input) { return null; } return input.replaceAll(regex, replacement); } StringRegexReplace(); StringRegexReplace(final String regex, final String replacement); @Override String apply(final String input); String getRegex(); void setRegex(final String regex); String getReplacement(); void setReplacement(final String replacement); @Override boolean equals(final Object o); @Override int hashCode(); }### Answer: @Test public void shouldHandleNullInput() { final StringRegexReplace function = new StringRegexReplace(); final String result = function.apply(null); assertNull(result); } @Test public void shouldReplaceStringSimple() { final StringRegexReplace function = new StringRegexReplace("input","output"); final String input = "An input string."; final String result = function.apply(input); assertEquals("An output string.", result); } @Test public void shouldReplaceStringRegex() { final StringRegexReplace function = new StringRegexReplace("t\\s+s"," "); final String input = "An input string."; final String result = function.apply(input); assertEquals("An inpu tring.", result); }
### Question: ParseTime extends KorypheFunction<String, Long> { @Override public Long apply(final String dateString) { if (isNull(dateString)) { return null; } try { final Long time; if (isNull(format)) { time = DateUtil.parseTime(dateString, timeZone); } else { final SimpleDateFormat simpleDateFormat = new SimpleDateFormat(format); if (nonNull(timeZone)) { simpleDateFormat.setTimeZone(timeZone); } time = simpleDateFormat.parse(dateString).getTime(); } return timeUnit.fromMilliSeconds(time); } catch (final ParseException e) { throw new IllegalArgumentException("Date string could not be parsed: " + dateString, e); } } ParseTime(); @Override Long apply(final String dateString); String getFormat(); void setFormat(final String format); ParseTime format(final String format); TimeZone getTimeZone(); @JsonGetter("timeZone") String getTimeZoneAsString(); @JsonSetter void setTimeZone(final String timeZone); void setTimeZone(final TimeZone timeZone); ParseTime timeZone(final String timeZone); ParseTime timeZone(final TimeZone timeZone); TimeUnit getTimeUnit(); @JsonSetter void setTimeUnit(final TimeUnit timeUnit); void setTimeUnit(final String timeUnit); ParseTime timeUnit(final String timeUnit); ParseTime timeUnit(final TimeUnit timeUnit); @Override boolean equals(final Object o); @Override int hashCode(); }### Answer: @Test public void shouldParseTime() throws ParseException { final ParseTime function = new ParseTime(); final String input = "2000-01-02 03:04:05.006"; long result = function.apply(input); assertEquals(new SimpleDateFormat("yyyy-MM-dd hh:mm:ss.SSS").parse(input).getTime(), result); } @Test public void shouldReturnNullForNullInput() { final ParseTime function = new ParseTime(); final Object result = function.apply(null); assertNull(result); }
### Question: BinaryOperatorMap extends KorypheBinaryOperator<Map<K, T>> { public void setBinaryOperator(final BinaryOperator<? super T> binaryOperator) { this.binaryOperator = binaryOperator; } BinaryOperatorMap(); BinaryOperatorMap(final BinaryOperator<? super T> binaryOperator); void setBinaryOperator(final BinaryOperator<? super T> binaryOperator); BinaryOperator<? super T> getBinaryOperator(); @Override Map<K, T> _apply(final Map<K, T> state, final Map<K, T> input); }### Answer: @Test public void testMapAggregation() { int inA = 1; int inB = 2; int noInputs = 3; Map<String, Integer>[] inputs = new HashMap[noInputs]; for (int i = 0; i < noInputs; i++) { inputs[i] = new HashMap<>(); inputs[i].put("a", inA); inputs[i].put("b", inB); } BinaryOperator<Integer> aggregator = mock(BinaryOperator.class); for (int i = 0; i < noInputs; i++) { Integer expectedA = null; Integer expectedB = null; if (i > 0) { expectedA = i * inA; expectedB = i * inB; } given(aggregator.apply(expectedA, inA)).willReturn(inA + (expectedA == null ? 0 : expectedA)); given(aggregator.apply(expectedB, inB)).willReturn(inB + (expectedB == null ? 0 : expectedB)); } BinaryOperatorMap<String, Integer> mapBinaryOperator = new BinaryOperatorMap<>(); mapBinaryOperator.setBinaryOperator(aggregator); Map<String, Integer> state = null; for (Map<String, Integer> input : inputs) { state = mapBinaryOperator.apply(state, input); } assertEquals(noInputs * inA, (int) state.get("a")); assertEquals(noInputs * inB, (int) state.get("b")); }
### Question: ToString extends KorypheFunction<Object, String> { @Override public String apply(final Object o) { if (null == o) { return null; } if (o instanceof byte[]) { return new String(((byte[]) o), charset); } if (o instanceof Object[]) { return Arrays.toString((Object[]) o); } return String.valueOf(o); } ToString(); ToString(final String charsetString); ToString(final Charset charset); @Override String apply(final Object o); Charset getCharset(); void setCharset(final Charset charset); @JsonSetter("charset") void setCharset(final String charsetString); @JsonGetter("charset") String getCharsetAsString(); @Override boolean equals(final Object o); @Override int hashCode(); static final Charset DEFAULT_CHARSET; }### Answer: @Test public void shouldReturnString() { final ToString ts = new ToString(); final String output = ts.apply("test string"); assertEquals("test string", output); } @Test public void shouldHandleArray() { final ToString ts = new ToString(); final String[] testArray = new String[] {"test", "string"}; final String output = ts.apply(testArray); assertEquals("[test, string]", output); } @Test public void shouldHandleByteArrayWithUtf8Charset() { final ToString ts = new ToString(StandardCharsets.UTF_8); final byte[] bytes = "test string".getBytes(StandardCharsets.UTF_8); final String output = ts.apply(bytes); assertEquals("test string", output); } @Test public void shouldHandleByteArrayWithUtf16Charset() { final ToString ts = new ToString(StandardCharsets.UTF_16); final byte[] bytes = "test string".getBytes(StandardCharsets.UTF_16); final String output = ts.apply(bytes); assertEquals("test string", output); } @Test public void shouldHandleNullObject() { final ToString ts = new ToString(); final String output = ts.apply(null); assertNull(output); }
### Question: StringPrepend extends KorypheFunction<String, String> { @Override public String apply(final String input) { if (null == input) { return null; } if (null == prefix) { return input; } return prefix + input; } StringPrepend(); StringPrepend(final String prefix); @Override String apply(final String input); String getPrefix(); void setPrefix(final String prefix); @Override boolean equals(final Object o); @Override int hashCode(); }### Answer: @Test public void shouldHandleNullInput() { final StringPrepend function = new StringPrepend("!"); final String result = function.apply(null); assertNull(result); } @Test public void shouldHandleNullPrefix() { final StringPrepend function = new StringPrepend(null); final String result = function.apply("Hello"); assertEquals("Hello", result); } @Test public void shouldHandleUnsetSuffix() { final StringPrepend function = new StringPrepend(); final String result = function.apply("Hello"); assertEquals("Hello", result); } @Test public void shouldPrependInputWithString() { final StringPrepend function = new StringPrepend("!"); final String result = function.apply("Hello"); assertEquals("!Hello", result); }
### Question: StringSplit extends KorypheFunction<String, List<String>> { @Override public List<String> apply(final String input) { final String[] arr = StringUtils.split(input, delimiter); if (null == arr) { return null; } return Arrays.asList(arr); } StringSplit(); StringSplit(final String delimiter); @Override List<String> apply(final String input); String getDelimiter(); void setDelimiter(final String delimiter); @Override boolean equals(final Object o); @Override int hashCode(); }### Answer: @Test public void shouldHandleNullInput() { final StringSplit function = new StringSplit(); final List<String> result = function.apply(null); assertNull(result); } @Test public void shouldHandleNullDelimiter() { final StringSplit function = new StringSplit(null); final String input = "first,second,third"; final List<String> result = function.apply(input); assertThat(result, hasItems("first,second,third")); assertThat(result, hasSize(1)); } @Test public void shouldSplitString() { final StringSplit function = new StringSplit(","); final String input = "first,second,third"; final List<String> result = function.apply(input); assertThat(result, hasItems("first", "second", "third")); } @Test public void shouldSplitEmptyString() { final StringSplit function = new StringSplit(","); final String input = ""; final List<String> result = function.apply(input); assertThat(result, is(empty())); }
### Question: BinaryOperatorComposite extends Composite<C> implements BinaryOperator<T> { @Override public T apply(final T state, final T input) { T result = state; for (final BinaryOperator<T> component : this.components) { result = component.apply(result, input); } return result; } BinaryOperatorComposite(); BinaryOperatorComposite(final List<C> binaryOperators); @JsonProperty("operators") List<C> getComponents(); @Override T apply(final T state, final T input); }### Answer: @Test public void shouldExecuteEachBinaryOperatorInOrder() { BinaryOperatorComposite instance = getInstance(); BinaryOperatorComposite reversed = new BinaryOperatorComposite(Arrays.asList( new Product(), new Sum() )); Object aggregated = instance.apply(5, 10); Object aggregatedInReverseOrder = reversed.apply(5, 10); assertEquals(150, aggregated); assertEquals(60, aggregatedInReverseOrder); }
### Question: InputAdapted { protected AI adaptInput(final I input) { return inputAdapter == null ? (AI) input : inputAdapter.apply(input); } InputAdapted(); InputAdapted(final Function<I, AI> inputAdapter); Function<I, AI> getInputAdapter(); @JsonTypeInfo(use = JsonTypeInfo.Id.CLASS, include = JsonTypeInfo.As.PROPERTY, property = "class") void setInputAdapter(final Function<I, AI> inputAdapter); @Override boolean equals(final Object o); @Override int hashCode(); }### Answer: @Test public void shouldApplyInputAdapterToInput() { Integer input = 5; InputAdapted<Object, Long> inputAdapted = new InputAdapted<>(new ToLong()); Long output = inputAdapted.adaptInput(input); assertEquals(Long.class, output.getClass()); assertEquals(5L, output); }
### Question: StateAgnosticOutputAdapter implements BiFunction<T, U, R> { @Override public R apply(final T ignoredState, final U output) { if (adapter == null) { return (R) output; } return adapter.apply(output); } StateAgnosticOutputAdapter(); StateAgnosticOutputAdapter(final Function<U, R> adapter); @Override R apply(final T ignoredState, final U output); Function<U, R> getAdapter(); void setAdapter(final Function<U, R> adapter); @Override boolean equals(final Object o); @Override int hashCode(); }### Answer: @Test public void shouldReturnTheUnadaptedOutputIfNoAdapterIsProvided() { StateAgnosticOutputAdapter<Object, Object, Object> soa = new StateAgnosticOutputAdapter<>(); Object output = soa.apply(null, "input"); assertEquals("input", output); } @Test public void shouldApplyAnOutputAdapter() { StateAgnosticOutputAdapter<Object, Integer, Integer> soa = new StateAgnosticOutputAdapter<>(new MultiplyBy(10)); Object output = soa.apply(null, 10); assertEquals(100, output); }
### Question: SimpleClassDeserializer extends FromStringDeserializer<Class> { @Override protected Class<?> _deserialize(final String value, final DeserializationContext ctxt) throws IOException { try { return ctxt.findClass(SimpleClassNameIdResolver.getClassName(value)); } catch (final Exception e) { throw ctxt.instantiationException(_valueClass, ClassUtil.getRootCause(e)); } } SimpleClassDeserializer(); }### Answer: @Test public void shouldDeserialiseFromSimpleClassName() throws IOException, ClassNotFoundException { final SimpleClassDeserializer deserialiser = new SimpleClassDeserializer(); final DeserializationContext context = mock(DeserializationContext.class); final Class expectedClass = IsA.class; final String id = expectedClass.getSimpleName(); given(context.findClass(expectedClass.getName())).willReturn(expectedClass); final Class<?> clazz = deserialiser._deserialize(id, context); assertEquals(expectedClass, clazz); verify(context).findClass(expectedClass.getName()); } @Test public void shouldDeserialiseFromFullClassName() throws IOException, ClassNotFoundException { final SimpleClassDeserializer deserialiser = new SimpleClassDeserializer(); final DeserializationContext context = mock(DeserializationContext.class); final Class expectedClass = IsA.class; final String id = expectedClass.getName(); given(context.findClass(expectedClass.getName())).willReturn(expectedClass); final Class<?> clazz = deserialiser._deserialize(id, context); assertEquals(expectedClass, clazz); verify(context).findClass(expectedClass.getName()); } @Test public void shouldDeserialiseFromFullClassNameForUnknownClass() throws IOException, ClassNotFoundException { final SimpleClassDeserializer deserialiser = new SimpleClassDeserializer(); final DeserializationContext context = mock(DeserializationContext.class); final Class expectedClass = UnsignedLong.class; final String id = expectedClass.getName(); given(context.findClass(expectedClass.getName())).willReturn(expectedClass); final Class<?> clazz = deserialiser._deserialize(id, context); assertEquals(expectedClass, clazz); verify(context).findClass(expectedClass.getName()); }
### Question: SimpleClassKeySerializer extends StdKeySerializer { @Override public void serialize(final Object value, final JsonGenerator g, final SerializerProvider provider) throws IOException { String str; Class<?> cls = value.getClass(); if (cls == String.class) { str = (String) value; } else if (cls.isEnum()) { Enum<?> en = (Enum<?>) value; if (provider.isEnabled(SerializationFeature.WRITE_ENUMS_USING_TO_STRING)) { str = en.toString(); } else { str = en.name(); } } else if (value instanceof Date) { provider.defaultSerializeDateKey((Date) value, g); return; } else if (cls == Class.class) { str = SimpleClassNameCache.getSimpleClassName(((Class<?>) value)); } else { str = value.toString(); } g.writeFieldName(str); } @Override void serialize(final Object value, final JsonGenerator g, final SerializerProvider provider); }### Answer: @Test public void shouldSerialiseToSimpleClassName() throws IOException { SimpleClassNameCache.setUseFullNameForSerialisation(false); final SimpleClassKeySerializer serialiser = new SimpleClassKeySerializer(); final JsonGenerator jgen = mock(JsonGenerator.class); final Class clazz = IsA.class; serialiser.serialize(clazz, jgen, null); verify(jgen).writeFieldName(clazz.getSimpleName()); } @Test public void shouldSerialiseToFullClassName() throws IOException { SimpleClassNameCache.setUseFullNameForSerialisation(true); final SimpleClassKeySerializer serialiser = new SimpleClassKeySerializer(); final JsonGenerator jgen = mock(JsonGenerator.class); final Class clazz = IsA.class; serialiser.serialize(clazz, jgen, null); verify(jgen).writeFieldName(clazz.getName()); } @Test public void shouldSerialiseToFullClassNameWhenUnknown() throws IOException { SimpleClassNameCache.setUseFullNameForSerialisation(false); final SimpleClassKeySerializer serialiser = new SimpleClassKeySerializer(); final JsonGenerator jgen = mock(JsonGenerator.class); final Class clazz = UnsignedLong.class; serialiser.serialize(clazz, jgen, null); verify(jgen).writeFieldName(clazz.getName()); }
### Question: SimpleClassSerializer extends ClassSerializer { @Override public void serialize(final Class<?> value, final JsonGenerator jgen, final SerializerProvider provider) throws IOException, JsonGenerationException { jgen.writeString(SimpleClassNameCache.getSimpleClassName(value)); } static SimpleModule getModule(); @Override void serialize(final Class<?> value, final JsonGenerator jgen, final SerializerProvider provider); }### Answer: @Test public void shouldSerialiseToSimpleClassName() throws IOException { SimpleClassNameCache.setUseFullNameForSerialisation(false); final SimpleClassSerializer serialiser = new SimpleClassSerializer(); final JsonGenerator jgen = mock(JsonGenerator.class); final Class clazz = IsA.class; serialiser.serialize(clazz, jgen, null); verify(jgen).writeString(clazz.getSimpleName()); } @Test public void shouldSerialiseToFullClassName() throws IOException { SimpleClassNameCache.setUseFullNameForSerialisation(true); final SimpleClassSerializer serialiser = new SimpleClassSerializer(); final JsonGenerator jgen = mock(JsonGenerator.class); final Class clazz = IsA.class; serialiser.serialize(clazz, jgen, null); verify(jgen).writeString(clazz.getName()); } @Test public void shouldSerialiseToFullClassNameWhenUnknown() throws IOException { SimpleClassNameCache.setUseFullNameForSerialisation(false); final SimpleClassSerializer serialiser = new SimpleClassSerializer(); final JsonGenerator jgen = mock(JsonGenerator.class); final Class clazz = UnsignedLong.class; serialiser.serialize(clazz, jgen, null); verify(jgen).writeString(clazz.getName()); }
### Question: FunctionComposite extends Composite<C> implements Function<I, O> { @Override public O apply(final I input) { Object result = input; if (nonNull(components)) { for (final Function function : this.components) { result = function.apply(result); } } return (O) result; } FunctionComposite(); FunctionComposite(final List<C> functions); @JsonProperty("functions") List<C> getComponents(); @Override O apply(final I input); }### Answer: @Test public void shouldReturnInputIfNoComponentsAreProvided() { FunctionComposite<String, String, Function> functionComposite = new FunctionComposite<>(); String output = functionComposite.apply("test"); assertEquals("test", output); } @Test public void shouldApplyFunctionsInOrder() { FunctionComposite<String, Long, Function> functionComposite = new FunctionComposite<>(Arrays.asList( new ToLong(), new MultiplyLongBy(100L) )); Long transformed = functionComposite.apply("4"); assertEquals(400L, transformed); } @Test public void shouldThrowExceptionIfInputsAndOutputsDontMatch() { FunctionComposite<Integer, Long, Function> functionComposite = new FunctionComposite<>(Arrays.asList( new ToLong(), new StringSplit(" ") )); ClassCastException e = assertThrows(ClassCastException.class, () -> { functionComposite.apply(5); }); assertNotNull(e.getMessage()); }
### Question: StreamIterable implements CloseableIterable<T> { @Override public CloseableIterator<T> iterator() { return new StreamIterator<>(streamSupplier.get()); } StreamIterable(final Supplier<Stream<T>> streamSupplier); @Override void close(); @Override CloseableIterator<T> iterator(); @JsonIgnore Stream<T> getStream(); }### Answer: @Test public void shouldDelegateIteratorToIterable() { final Supplier<Stream<Object>> streamSupplier = mock(Supplier.class); final Stream<Object> stream = mock(Stream.class); given(streamSupplier.get()).willReturn(stream); final StreamIterable<Object> wrappedIterable = new StreamIterable<>(streamSupplier); final Iterator<Object> iterator = mock(Iterator.class); given(stream.iterator()).willReturn(iterator); final CloseableIterator<Object> result = wrappedIterable.iterator(); result.hasNext(); verify(iterator).hasNext(); }
### Question: ValidationResult { public boolean isValid() { return isValid; } ValidationResult(); ValidationResult(final String errorMsg); void addError(final String msg); void add(final ValidationResult validationResult); void add(final ValidationResult validationResult, final String errorMessage); boolean isValid(); Set<String> getErrors(); void logErrors(); void logWarns(); void logInfo(); void logDebug(); void logTrace(); @JsonIgnore String getErrorString(); @Override boolean equals(final Object o); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void shouldInitiallyBeValid() { ValidationResult validationResult = new ValidationResult(); boolean valid = validationResult.isValid(); assertTrue(valid); }
### Question: ValidationResult { public Set<String> getErrors() { if (null == errors) { return Collections.emptySet(); } return errors; } ValidationResult(); ValidationResult(final String errorMsg); void addError(final String msg); void add(final ValidationResult validationResult); void add(final ValidationResult validationResult, final String errorMessage); boolean isValid(); Set<String> getErrors(); void logErrors(); void logWarns(); void logInfo(); void logDebug(); void logTrace(); @JsonIgnore String getErrorString(); @Override boolean equals(final Object o); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void shouldReturnEmptySetIfValid() { ValidationResult validationResult = new ValidationResult(); Set<String> errors = validationResult.getErrors(); assertEquals(new HashSet<>(), errors); }
### Question: ValidationResult { @JsonIgnore public String getErrorString() { return "Validation errors: " + System.lineSeparator() + StringUtils.join(getErrors(), System.lineSeparator()); } ValidationResult(); ValidationResult(final String errorMsg); void addError(final String msg); void add(final ValidationResult validationResult); void add(final ValidationResult validationResult, final String errorMessage); boolean isValid(); Set<String> getErrors(); void logErrors(); void logWarns(); void logInfo(); void logDebug(); void logTrace(); @JsonIgnore String getErrorString(); @Override boolean equals(final Object o); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void shouldReturnStringForErrorStringIfNoErrorsArePresent() { ValidationResult validationResult = new ValidationResult(); String errorString = validationResult.getErrorString(); assertEquals("Validation errors: " + System.lineSeparator(), errorString); }
### Question: TupleOutputAdapter implements BiFunction<Tuple<R>, FO, Tuple<R>> { @Override public Tuple<R> apply(final Tuple<R> state, final FO output) { if (null == projection) { throw new IllegalArgumentException("Projection is required"); } if (null != state) { if (1 == projection.length) { state.put(projection[0], output); } else { int i = 0; for (final Object obj : (Iterable) output) { state.put(projection[i++], obj); } } } return state; } TupleOutputAdapter(); TupleOutputAdapter(final R[] projection); @Override Tuple<R> apply(final Tuple<R> state, final FO output); @SuppressFBWarnings(value = "EI_EXPOSE_REP2", justification = "Cloning the array would be expensive - we will have to reply on users not modifying the array") void setProjection(final R[] projection); R[] getProjection(); @Override boolean equals(final Object o); @Override int hashCode(); }### Answer: @Test public void shouldAddToTuple() { ArrayTuple state = new ArrayTuple(3); state.put(0, "thing"); state.put(1, 50L); TupleOutputAdapter<Integer, Object> adapter = new TupleOutputAdapter<>(new Integer[]{2}); Tuple<Integer> adapted = adapter.apply(state, "test"); assertEquals("test", adapted.get(2)); } @Test public void shouldReplaceAnyExistingValueInTuple() { ArrayTuple state = new ArrayTuple(3); state.put(0, "thing"); state.put(1, 50L); state.put(2, "Replace me"); TupleOutputAdapter<Integer, Object> adapter = new TupleOutputAdapter<>(new Integer[]{2}); Tuple<Integer> adapted = adapter.apply(state, "test"); assertEquals("test", adapted.get(2)); }
### Question: TupleInputAdapter extends KorypheFunction<Tuple<R>, FI> { @Override public FI apply(final Tuple<R> input) { if (null == selection) { throw new IllegalArgumentException("Selection is required"); } if (null != input) { if (1 == selection.length) { return (FI) input.get(selection[0]); } } return (FI) new ReferenceArrayTuple<>(input, selection); } TupleInputAdapter(); TupleInputAdapter(final R[] selection); @Override FI apply(final Tuple<R> input); R[] getSelection(); @SuppressFBWarnings(value = "EI_EXPOSE_REP2", justification = "Cloning the array would be expensive - we will have to reply on users not modifying the array") void setSelection(final R[] selection); @Override boolean equals(final Object o); @Override int hashCode(); }### Answer: @Test public void shouldReturnObjectIfSingleSelectionIsProvided() { MapTuple<String> objects = new MapTuple<>(); objects.put("one", 1); objects.put("two", 2); TupleInputAdapter<String, Object> inputAdapter = new TupleInputAdapter<>(new String[]{"one"}); Object adapted = inputAdapter.apply(objects); assertEquals(1, adapted); } @Test public void shouldReturnNullIfTheObjectReferencedDoesntExist() { MapTuple<String> objects = new MapTuple<>(); objects.put("one", 1); objects.put("two", 2); TupleInputAdapter<String, Object> inputAdapter = new TupleInputAdapter<>(new String[]{ "three" }); Object adapted = inputAdapter.apply(objects); assertNull(adapted); } @Test public void shouldReturnAReferenceArrayTupleIfMoreThanOneSelectionIsProvided() { MapTuple<String> objects = new MapTuple<>(); objects.put("one", 1); objects.put("two", 2); objects.put("three", 3); TupleInputAdapter<String, Object> inputAdapter = new TupleInputAdapter<>(new String[]{ "one", "two" }); Object adapted = inputAdapter.apply(objects); ReferenceArrayTuple<String> expected = new ReferenceArrayTuple<>(objects, new String[]{"one", "two"}); assertEquals(expected, adapted); }
### Question: DateUtil { public static Long parseTime(final String dateString) { return parseTime(dateString, TIME_ZONE_DEFAULT); } private DateUtil(); static TimeZone getTimeZoneDefault(); static Date parse(final String dateString); static Date parse(final String dateString, final TimeZone timeZone); static Long parseTime(final String dateString); static Long parseTime(final String dateString, final TimeZone timeZone); static final double MICROSECONDS_TO_MILLISECONDS; static final long SECONDS_TO_MILLISECONDS; static final long MINUTES_TO_MILLISECONDS; static final long HOURS_TO_MILLISECONDS; static final long DAYS_TO_MILLISECONDS; static final String TIME_ZONE; }### Answer: @Test public void shouldParseTimestampInMilliseconds() { final long timestamp = System.currentTimeMillis(); final Long result = DateUtil.parseTime(Long.toString(timestamp)); assertEquals(timestamp, (long) result); } @Test public void shouldParseTimestampInMillisecondsWithTimeZone() { final long timestamp = System.currentTimeMillis(); final Long result = DateUtil.parseTime(Long.toString(timestamp), TimeZone.getTimeZone("Etc/GMT+6")); assertEquals(timestamp, (long) result); }
### Question: TupleAdaptedBinaryOperator extends AdaptedBinaryOperator<Tuple<R>, OT> { @JsonIgnore @Override public TupleInputAdapter<R, OT> getInputAdapter() { return (TupleInputAdapter<R, OT>) super.getInputAdapter(); } TupleAdaptedBinaryOperator(); TupleAdaptedBinaryOperator(final BinaryOperator<OT> binaryOperator, final R[] selection); R[] getSelection(); void setSelection(final R[] selection); @JsonIgnore @Override TupleInputAdapter<R, OT> getInputAdapter(); @JsonIgnore @Override TupleOutputAdapter<R, OT> getOutputAdapter(); }### Answer: @Test public void shouldJsonSerialiseAndDeserialise() throws IOException { TupleAdaptedBinaryOperator<String, Integer> binaryOperator = new TupleAdaptedBinaryOperator<>(); MockBinaryOperator function = new MockBinaryOperator(); TupleInputAdapter<String, Integer> inputAdapter = new TupleInputAdapter(); binaryOperator.setInputAdapter(inputAdapter); binaryOperator.setBinaryOperator(function); String json = JsonSerialiser.serialise(binaryOperator); TupleAdaptedBinaryOperator<String, Integer> deserialisedBinaryOperator = JsonSerialiser.deserialise(json, TupleAdaptedBinaryOperator.class); assertNotSame(binaryOperator, deserialisedBinaryOperator); BinaryOperator<Integer> deserialisedFunction = deserialisedBinaryOperator.getBinaryOperator(); assertNotSame(function, deserialisedFunction); assertTrue(deserialisedFunction instanceof MockBinaryOperator); Function<Tuple<String>, Integer> deserialisedInputMask = deserialisedBinaryOperator.getInputAdapter(); assertNotSame(inputAdapter, deserialisedInputMask); assertTrue(deserialisedInputMask instanceof Function); }
### Question: ReflectiveTuple implements Tuple<String> { @Override public Iterable<Object> values() { throw new UnsupportedOperationException("This " + getClass().getSimpleName() + " does not support listing all values."); } ReflectiveTuple(final Object record); protected ReflectiveTuple(final Object record, final Cache<Field> fieldCache, final Cache<Method> methodCache); Object getRecord(); @Override Object get(final String reference); @Override void put(final String reference, final Object value); @Override Iterable<Object> values(); @Override boolean equals(final Object o); @Override int hashCode(); static final String SELECTION_S_DOES_NOT_EXIST; static final String ERROR_WRONG_PARAM; }### Answer: @Test public void shouldNotValues() { assertThrows(UnsupportedOperationException.class, () -> testObj.values()); }
### Question: StringContains extends KoryphePredicate<String> { @Override public boolean test(final String input) { if (null == input \|\| null == value) { return false; } if (ignoreCase) { return StringUtils.containsIgnoreCase(input, value); } return input.contains(value); } StringContains(); StringContains(final String value); StringContains(final String value, final boolean ignoreCase); String getValue(); void setValue(final String value); boolean getIgnoreCase(); void setIgnoreCase(final boolean ignoreCase); @Override boolean test(final String input); @Override boolean equals(final Object obj); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void shouldAcceptWhenStringInValue() { final StringContains stringContains = new StringContains("used"); boolean accepted = stringContains.test(INPUT); assertTrue(accepted); } @Test public void shouldRejectMismatchedCases() { final StringContains stringContains = new StringContains("stringcontains"); boolean accepted = stringContains.test(INPUT); assertFalse(accepted); } @Test public void shouldAcceptEmptyString() { final StringContains stringContains = new StringContains(""); boolean accepted = stringContains.test(INPUT); assertTrue(accepted); } @Test public void shouldRejectNullValue() { final StringContains stringContains = new StringContains(null); boolean accepted = stringContains.test(INPUT); assertFalse(accepted); } @Test public void shouldRejectNullInput() { final StringContains stringContains = new StringContains("test"); boolean accepted = stringContains.test(null); assertFalse(accepted); }
### Question: StringContains extends KoryphePredicate<String> { public String getValue() { return value; } StringContains(); StringContains(final String value); StringContains(final String value, final boolean ignoreCase); String getValue(); void setValue(final String value); boolean getIgnoreCase(); void setIgnoreCase(final boolean ignoreCase); @Override boolean test(final String input); @Override boolean equals(final Object obj); @Override int hashCode(); @Override String toString(); }### Answer: @Override @Test public void shouldJsonSerialiseAndDeserialise() throws IOException { final String value = "stringcontains"; final StringContains filter = new StringContains(value); final String json = JsonSerialiser.serialise(filter); JsonSerialiser.assertEquals(String.format("{%n" + " \"class\" : \"uk.gov.gchq.koryphe.impl.predicate.StringContains\",%n" + " \"value\" : \"stringcontains\",%n" + " \"ignoreCase\" : false%n" + "}"), json); final StringContains deserialisedFilter = JsonSerialiser.deserialise(json, StringContains.class); assertNotNull(deserialisedFilter); assertEquals(value, deserialisedFilter.getValue()); }
### Question: AbstractContentTemplatingElement extends AbstractTemplatingElement { protected void setAttributesInWebContext(final Map<String, Object> attributes, int scope) { if(attributes == null){ return; } switch(scope) { case WebContext.APPLICATION_SCOPE: case WebContext.SESSION_SCOPE: case WebContext.LOCAL_SCOPE: break; default: throw new IllegalArgumentException("Scope is not valid. Use one of the scopes defined in info.magnolia.context.WebContext"); } final WebContext webContext = MgnlContext.getWebContext(); for(Entry<String, Object> entry : attributes.entrySet()) { final String key = entry.getKey(); if(webContext.containsKey(key)) { savedCtxAttributes.put(key, webContext.get(key)); } webContext.setAttribute(key, entry.getValue(), scope); } } AbstractContentTemplatingElement(ServerConfiguration server, RenderingContext renderingContext); Node getContent(); void setContent(Node node); String getWorkspace(); void setWorkspace(String workspace); String getNodeIdentifier(); void setNodeIdentifier(String nodeIdentifier); String getPath(); void setPath(String path); }### Answer: @Test public void testSetAttributesInWebContext() throws Exception { final RenderingContext aggregationState = mock(RenderingContext.class); final WebContext ctx = new MockWebContext(); ctx.setAttribute("foo", "foo value", WebContext.LOCAL_SCOPE); ctx.setAttribute("bar", 1, WebContext.LOCAL_SCOPE); ctx.setAttribute("baz", true, WebContext.LOCAL_SCOPE); MgnlContext.setInstance(ctx); assertEquals(3, ctx.getAttributes().size()); final AbstractContentTemplatingElement compo = new DummyComponent(null, aggregationState); Map<String,Object> attributes = new HashMap<String, Object>(); attributes.put("foo", "new foo"); attributes.put("qux", "blah"); compo.setAttributesInWebContext(attributes, WebContext.LOCAL_SCOPE); assertEquals(4, ctx.getAttributes().size()); assertEquals("new foo", ctx.getAttribute("foo")); assertEquals("blah", ctx.getAttribute("qux")); }
### Question: InitElement extends AbstractContentTemplatingElement { @Override public void end(Appendable out) throws IOException, RenderException { if (!isAdmin()) { return; } MarkupHelper helper = new MarkupHelper(out); helper.append("\n<!-- end js and css added by @cms.init -->\n"); } InitElement(ServerConfiguration server, RenderingContext renderingContext); @Override void begin(Appendable out); @Override void end(Appendable out); void setDialog(String dialog); static final String PAGE_EDITOR_JS_SOURCE; static final String PAGE_EDITOR_CSS; }### Answer: @Test public void testOutputEndPart() throws Exception { element.end(out); assertThat(out.toString(), containsString("<!-- end js and css added by @cms.init -->")); }
### Question: ComponentElement extends AbstractContentTemplatingElement { @Override public void end(Appendable out) throws IOException, RenderException { if(isAdmin()){ if (renderEditbar) { new MarkupHelper(out).closeComment("cms:component"); } } } @Inject ComponentElement(ServerConfiguration server, RenderingContext renderingContext, RenderingEngine renderingEngine, TemplateDefinitionAssignment templateDefinitionAssignment ); @Override void begin(Appendable out); @Override void end(Appendable out); Map<String, Object> getContextAttributes(); void setContextAttributes(Map<String, Object> contextAttributes); void setDialog(String dialog); void setEditable(Boolean editable); Boolean getEditable(); boolean isRenderEditbar(); void setRenderEditbar(boolean renderEditbar); }### Answer: @Test public void testPostRender() throws Exception { element.end(out); assertEquals("<!-- /cms:component -->\n", out.toString()); }
### Question: MarkupHelper implements Appendable { public MarkupHelper attribute(String name, String value) throws IOException { if (value != null) { appendable.append(SPACE).append(name).append(EQUALS).append(QUOTE).append(value).append(QUOTE); } return this; } MarkupHelper(Appendable appendable); MarkupHelper attribute(String name, String value); MarkupHelper startContent(Node node); MarkupHelper endContent(Node node); MarkupHelper openTag(String tagName); MarkupHelper closeTag(String tagName); MarkupHelper openComment(String tagName); MarkupHelper closeComment(String tagName); @Override Appendable append(CharSequence charSequence); @Override Appendable append(CharSequence charSequence, int i, int i1); @Override Appendable append(char c); }### Answer: @Test public void testParam() throws Exception { final StringWriter out = new StringWriter(); final MarkupHelper compo = new MarkupHelper(out); final String paramName = "param1"; final String paramValue = "value1"; compo.attribute(paramName, paramValue); assertEquals(out.toString(), " param1=\"value1\"", out.toString()); } @Test public void testParamsKeepCamelCaseNotation() throws Exception { final StringWriter out = new StringWriter(); final MarkupHelper compo = new MarkupHelper(out); final String paramName = "iAmACamelCaseParamName"; final String paramValue = "iAmACamelCaseParamValue"; compo.attribute(paramName, paramValue); assertEquals(out.toString(), " iAmACamelCaseParamName=\"iAmACamelCaseParamValue\"", out.toString()); }
### Question: AbstractDirective implements TemplateDirectiveModel { protected void checkBody(TemplateDirectiveBody body, boolean needsBody) throws TemplateModelException { if ((body == null) == needsBody) { throw new TemplateModelException("This directive " + (needsBody ? "needs a body" : "does not support a body")); } } @Override void execute(Environment env, Map params, TemplateModel[] loopVars, TemplateDirectiveBody body); static final String PATH_ATTRIBUTE; static final String UUID_ATTRIBUTE; static final String WORKSPACE_ATTRIBUTE; static final String CONTENT_ATTRIBUTE; }### Answer: @Test public void testBodyCheck() throws TemplateModelException { final TemplateDirectiveBody dummyDirBody = new TemplateDirectiveBody() { @Override public void render(Writer out) throws TemplateException, IOException { } }; final AbstractDirective dir = new TestAbstractDirective(); dir.checkBody(null, false); dir.checkBody(dummyDirBody, true); try { dir.checkBody(null, true); fail("should have failed"); } catch (TemplateModelException e) { assertEquals("This directive needs a body", e.getMessage()); } try { dir.checkBody(dummyDirBody, false); fail("should have failed"); } catch (TemplateModelException e) { assertEquals("This directive does not support a body", e.getMessage()); } }
### Question: AbstractDirective implements TemplateDirectiveModel { protected void initContentElement(Map<String, TemplateModel> params, AbstractContentTemplatingElement component) throws TemplateModelException { Node content = node(params, CONTENT_ATTRIBUTE, null); String workspace = string(params, WORKSPACE_ATTRIBUTE, null); String nodeIdentifier = string(params, UUID_ATTRIBUTE, null); String path = string(params, PATH_ATTRIBUTE, null); component.setContent(content); component.setWorkspace(workspace); component.setNodeIdentifier(nodeIdentifier); component.setPath(path); } @Override void execute(Environment env, Map params, TemplateModel[] loopVars, TemplateDirectiveBody body); static final String PATH_ATTRIBUTE; static final String UUID_ATTRIBUTE; static final String WORKSPACE_ATTRIBUTE; static final String CONTENT_ATTRIBUTE; }### Answer: @Test public void testInitContentComponent() throws TemplateModelException { final AbstractDirective dir = new TestAbstractDirective(); AbstractContentTemplatingElement component = mock(AbstractContentTemplatingElement.class); Map<String, TemplateModel> params = new LinkedHashMap<String, TemplateModel>(); dir.initContentElement(params, component); }
### Question: AppendableWriter extends Writer { @Override public void write(char[] chars, int start, int end) throws IOException { appendable.append(new String(chars), start, end); } AppendableWriter(Appendable appendable); @Override void close(); @Override void flush(); @Override void write(char[] chars, int start, int end); }### Answer: @Test public void testWrite() throws IOException { StringBuilder builder = new StringBuilder(); AppendableWriter writer = new AppendableWriter(builder); try { writer.append("superLongWord", 5, 9); assertEquals("Long", builder.toString()); } finally { writer.close(); } }
### Question: RenderingModelImpl implements RenderingModel<RD> { @Override public Node getNode() { return this.content; } RenderingModelImpl(Node content, RD definition, RenderingModel<?> parent); @Override RenderingModel<?> getParent(); @Override RenderingModel<?> getRoot(); @Override Node getNode(); @Override ContentMap getContent(); RD getDef(); @Override RD getDefinition(); @Override String execute(); }### Answer: @Test public void testGetNode() { MockNode content = new MockNode(); RenderingModelImpl<ConfiguredRenderableDefinition> model = new RenderingModelImpl<ConfiguredRenderableDefinition>(content, null,null); Node result = model.getNode(); assertEquals(content, result); }
### Question: RenderingModelImpl implements RenderingModel<RD> { public RD getDef() { return getDefinition(); } RenderingModelImpl(Node content, RD definition, RenderingModel<?> parent); @Override RenderingModel<?> getParent(); @Override RenderingModel<?> getRoot(); @Override Node getNode(); @Override ContentMap getContent(); RD getDef(); @Override RD getDefinition(); @Override String execute(); }### Answer: @Test public void testGetDef() { ConfiguredRenderableDefinition definition = new ConfiguredRenderableDefinition(); RenderingModelImpl<ConfiguredRenderableDefinition> model = new RenderingModelImpl<ConfiguredRenderableDefinition>(null, definition,null); ConfiguredRenderableDefinition result = model.getDef(); assertEquals(definition, result); }
### Question: RenderingModelImpl implements RenderingModel<RD> { @Override public RD getDefinition() { return this.definition; } RenderingModelImpl(Node content, RD definition, RenderingModel<?> parent); @Override RenderingModel<?> getParent(); @Override RenderingModel<?> getRoot(); @Override Node getNode(); @Override ContentMap getContent(); RD getDef(); @Override RD getDefinition(); @Override String execute(); }### Answer: @Test public void testGetDefinition() { ConfiguredRenderableDefinition definition = new ConfiguredRenderableDefinition(); RenderingModelImpl<ConfiguredRenderableDefinition> model = new RenderingModelImpl<ConfiguredRenderableDefinition>(null, definition,null); ConfiguredRenderableDefinition result = model.getDefinition(); assertEquals(definition, result); }
### Question: RenderingModelImpl implements RenderingModel<RD> { @Override public RenderingModel<?> getRoot(){ RenderingModel<?> model = this; while(model.getParent() != null){ model = model.getParent(); } return model; } RenderingModelImpl(Node content, RD definition, RenderingModel<?> parent); @Override RenderingModel<?> getParent(); @Override RenderingModel<?> getRoot(); @Override Node getNode(); @Override ContentMap getContent(); RD getDef(); @Override RD getDefinition(); @Override String execute(); }### Answer: @Test public void testGetRoot() { RenderingModelImpl<ConfiguredRenderableDefinition> parent = new RenderingModelImpl<ConfiguredRenderableDefinition>(null, null,null); RenderingModelImpl<ConfiguredRenderableDefinition> child = new RenderingModelImpl<ConfiguredRenderableDefinition>(null, null, parent); RenderingModelImpl<ConfiguredRenderableDefinition> childOfChild = new RenderingModelImpl<ConfiguredRenderableDefinition>(null, null, child); RenderingModel<?> result = childOfChild.getRoot(); assertEquals(parent, result); }
### Question: RenderingModelImpl implements RenderingModel<RD> { @Override public String execute() { return null; } RenderingModelImpl(Node content, RD definition, RenderingModel<?> parent); @Override RenderingModel<?> getParent(); @Override RenderingModel<?> getRoot(); @Override Node getNode(); @Override ContentMap getContent(); RD getDef(); @Override RD getDefinition(); @Override String execute(); }### Answer: @Test public void testExecute() { String result = new RenderingModelImpl<ConfiguredRenderableDefinition>(null, null, null).execute(); assertNull(result); }
### Question: ConfiguredRendererProvider implements RendererProvider { @Override public Renderer getRenderer() throws RegistrationException { return renderer; } ConfiguredRendererProvider(String type, Node configNode); @Override String getType(); @Override Renderer getRenderer(); @Override String toString(); }### Answer: @Test public void testGetDefinition() throws RepositoryException, Content2BeanException, IOException, RegistrationException, Node2BeanException { Session session = SessionTestUtil.createSession(RepositoryConstants.CONFIG, "/test.class=" + TestRenderer.class.getName(), "/test.someProperty=foobar123" ); MockUtil.setSystemContextSessionAndHierarchyManager(session); ComponentsTestUtil.setImplementation(Node2BeanTransformer.class, Node2BeanTransformerImpl.class); ComponentsTestUtil.setImplementation(TypeMapping.class, TypeMappingImpl.class); ComponentsTestUtil.setImplementation(Node2BeanProcessor.class, Node2BeanProcessorImpl.class); ConfiguredRendererProvider provider = new ConfiguredRendererProvider("test", session.getNode("/test")); TestRenderer renderer = (TestRenderer) provider.getRenderer(); assertEquals("foobar123", renderer.getSomeProperty()); }
### Question: AbstractRenderer implements Renderer, RenderingModelBasedRenderer { @Override public RenderingModel<?> newModel(final Node content, final RenderableDefinition definition, final RenderingModel<?> parentModel) throws RenderException { Class clazz = definition.getModelClass(); if (clazz == null) { clazz = RenderingModelImpl.class; } final Node wrappedContent = wrapNodeForModel(content); return newModel(clazz, wrappedContent, definition, parentModel); } @Override void render(RenderingContext renderingCtx, Map<String, Object> contextObjects); @Override RenderingModel<?> newModel(final Node content, final RenderableDefinition definition, final RenderingModel<?> parentModel); Map<String, ContextAttributeConfiguration> getContextAttributes(); void setContextAttributes(Map<String, ContextAttributeConfiguration> contextAttributes); void addContextAttribute(String name, ContextAttributeConfiguration contextAttributeConfiguration); }### Answer: @Test public void testWillNotFailModelCreationWhenSquareBracketIsInQueryString() throws RenderException { Map<String, String[]> map = new HashMap<String, String[]>(); map.put("checkbox[]", new String[] { "a", "b", "c" }); map.put("param", new String[] { "value" }); map.put("number", new String[] { "10" }); when(request.getParameterMap()).thenReturn(map); DummyRenderer renderer = new DummyRenderer(); RenderableDefinition definition = mock(RenderableDefinition.class); MyDummyModel model = renderer.newModel(MyDummyModel.class, content, definition, parentModel); assertEquals("value", model.getParam()); assertEquals(10, model.getNumber()); assertArrayEquals(new String[] { "a", "b", "c" }, model.getCheckbox()); }
### Question: FreemarkerRenderer extends AbstractRenderer { @Override protected void onRender(Node content, RenderableDefinition definition, RenderingContext renderingCtx, Map<String, Object> ctx, String templateScript) throws RenderException { final Locale locale = MgnlContext.getAggregationState().getLocale(); try { AppendableWriter out = renderingCtx.getAppendable(); fmHelper.render(templateScript, locale, definition.getI18nBasename(), ctx, out); } catch (TemplateException e) { throw new RenderException(e); } catch (IOException e) { throw new RenderException(e); } } FreemarkerRenderer(); FreemarkerRenderer(FreemarkerHelper fmRenderer); FreemarkerHelper getFmHelper(); }### Answer: @Test public void testOnRender() throws Exception { final RenderingContext rctx = mock(RenderingContext.class); final AppendableWriter writer = mock(AppendableWriter.class); when(rctx.getAppendable()).thenReturn(writer); final ConfiguredRenderableDefinition rd = new ConfiguredRenderableDefinition(); final String i18nBasename = "basename"; rd.setI18nBasename(i18nBasename); renderer.onRender(null, rd, rctx, null, null); verify(renderer.getFmHelper()).render(null, null, i18nBasename, null, writer); } @Test(expected = RenderException.class) public void testOnRenderThrowsRenderExceptionOnInternalIOException() throws Exception { final RenderingContext rctx = mock(RenderingContext.class); doThrow(new IOException()).when(rctx).getAppendable(); renderer.onRender(null, null, rctx, null, null); }
### Question: DefaultRenderingEngine implements RenderingEngine { protected Renderer getRendererFor(RenderableDefinition definition) throws RenderException { final String renderType = definition.getRenderType(); if (renderType == null) { throw new RenderException("No renderType defined for definition [" + definition + "]"); } try { return rendererRegistry.getRenderer(renderType); } catch (RegistrationException e) { throw new RenderException("Can't find renderer [" + renderType + "]", e); } } protected DefaultRenderingEngine(); DefaultRenderingEngine(RendererRegistry rendererRegistry, TemplateDefinitionAssignment templateDefinitionAssignment, RenderableVariationResolver variationResolver, Provider<RenderingContext> renderingContextProvider); @Override void render(Node content, OutputProvider out); @Override void render(Node content, Map<String, Object> contextObjects, OutputProvider out); @Override void render(Node content, RenderableDefinition definition, Map<String, Object> contextObjects, OutputProvider out); @Override RenderingContext getRenderingContext(); }### Answer: @Test(expected = RenderException.class) public void testGetRendererForThrowsExceptionWhenNoneIsRegistered() throws RenderException { DefaultRenderingEngine renderingEngine = createDefaultRenderingEngine(); TemplateDefinition templateDefinition = mock(TemplateDefinition.class); when(templateDefinition.getRenderType()).thenReturn(FREEMARKER_RENDERER_TYPE); renderingEngine.getRendererFor(templateDefinition); } @Test(expected = RenderException.class) public void testGetRendererForThrowsExceptionOnUnkownRenderType() throws RenderException { final RenderableDefinition def = new ConfiguredRenderableDefinition(); DefaultRenderingEngine renderingEngine = new DefaultRenderingEngine(null, null, null, null); renderingEngine.getRendererFor(def); }
### Question: DefaultRenderingEngine implements RenderingEngine { @Override public RenderingContext getRenderingContext() { return renderingContextProvider.get(); } protected DefaultRenderingEngine(); DefaultRenderingEngine(RendererRegistry rendererRegistry, TemplateDefinitionAssignment templateDefinitionAssignment, RenderableVariationResolver variationResolver, Provider<RenderingContext> renderingContextProvider); @Override void render(Node content, OutputProvider out); @Override void render(Node content, Map<String, Object> contextObjects, OutputProvider out); @Override void render(Node content, RenderableDefinition definition, Map<String, Object> contextObjects, OutputProvider out); @Override RenderingContext getRenderingContext(); }### Answer: @Test public void testGetRenderingContextWhenNotYetSet() { final AggregationStateBasedRenderingContext renderingContext = mock(AggregationStateBasedRenderingContext.class); DefaultRenderingEngine renderingEngine = createDefaultRenderingEngine(renderingContext); RenderingContext result = renderingEngine.getRenderingContext(); assertEquals(renderingContext, result); }
### Question: AggregationStateBasedRenderingContext implements RenderingContext { @Override public Node getMainContent() { Content mainContent = aggregationState.getMainContent(); return mainContent != null ? mainContent.getJCRNode() : null; } @Inject AggregationStateBasedRenderingContext(Provider<AggregationState> aggregationStateProvider, RenderExceptionHandler exceptionHandler); AggregationStateBasedRenderingContext(AggregationState aggregationState, RenderExceptionHandler exceptionHandler); @Override Node getMainContent(); @Override Node getCurrentContent(); @Override RenderableDefinition getRenderableDefinition(); @Override void push(Node content, RenderableDefinition renderableDefinition); @Override void push(Node content, RenderableDefinition renderableDefinition, OutputProvider outputProvider); @Override void pop(); @Override OutputProvider getOutputProvider(); @Override AppendableWriter getAppendable(); @Override OutputStream getOutputStream(); @Override void handleException(RenderException renderException); }### Answer: @Test public void usesAggregationStateFromProvider() throws Exception { aggregationState.setMainContent(mainContent); context = new AggregationStateBasedRenderingContext(Providers.of(aggregationState), null); Node returnedMainContent = context.getMainContent(); assertSame(mainNode, returnedMainContent); } @Test public void testGetMainContent() { aggregationState.setMainContent(mainContent); Node result = context.getMainContent(); assertEquals(mainNode, result); }
### Question: AggregationStateBasedRenderingContext implements RenderingContext { @Override public Node getCurrentContent() { Content currentContent = aggregationState.getCurrentContent(); return currentContent != null ? currentContent.getJCRNode() : null; } @Inject AggregationStateBasedRenderingContext(Provider<AggregationState> aggregationStateProvider, RenderExceptionHandler exceptionHandler); AggregationStateBasedRenderingContext(AggregationState aggregationState, RenderExceptionHandler exceptionHandler); @Override Node getMainContent(); @Override Node getCurrentContent(); @Override RenderableDefinition getRenderableDefinition(); @Override void push(Node content, RenderableDefinition renderableDefinition); @Override void push(Node content, RenderableDefinition renderableDefinition, OutputProvider outputProvider); @Override void pop(); @Override OutputProvider getOutputProvider(); @Override AppendableWriter getAppendable(); @Override OutputStream getOutputStream(); @Override void handleException(RenderException renderException); }### Answer: @Test public void testGetCurrentContent() { aggregationState.setCurrentContent(mainContent); Node result = context.getCurrentContent(); assertEquals(mainNode, result); }
### Question: AggregationStateBasedRenderingContext implements RenderingContext { @Override public void pop() { if (depth == 0) { throw new EmptyStackException(); } else if (depth == 1) { aggregationState.setCurrentContent(null); currentRenderableDefinition = null; currentOutputProvider = null; } else { StackState state = stack.pop(); aggregationState.setCurrentContent(state.legacyContent); currentRenderableDefinition = state.renderableDefinition; currentOutputProvider = state.outputProvider; } depth--; } @Inject AggregationStateBasedRenderingContext(Provider<AggregationState> aggregationStateProvider, RenderExceptionHandler exceptionHandler); AggregationStateBasedRenderingContext(AggregationState aggregationState, RenderExceptionHandler exceptionHandler); @Override Node getMainContent(); @Override Node getCurrentContent(); @Override RenderableDefinition getRenderableDefinition(); @Override void push(Node content, RenderableDefinition renderableDefinition); @Override void push(Node content, RenderableDefinition renderableDefinition, OutputProvider outputProvider); @Override void pop(); @Override OutputProvider getOutputProvider(); @Override AppendableWriter getAppendable(); @Override OutputStream getOutputStream(); @Override void handleException(RenderException renderException); }### Answer: @Test public void testPop() throws Exception { Node second = mock(Node.class); when(second.getSession()).thenReturn(session); RenderableDefinition firstRenderableDefinition = mock(RenderableDefinition.class); RenderableDefinition secondRenderableDefinition = mock(RenderableDefinition.class); context.push(mainNode, firstRenderableDefinition, null); context.push(second, secondRenderableDefinition, null); context.pop(); assertEquals(mainNode, context.getCurrentContent()); assertEquals(firstRenderableDefinition, context.getRenderableDefinition()); } @Test(expected = EmptyStackException.class) public void testPopWithoutPrecedingPush() { context.pop(); }
### Question: AggregationStateBasedRenderingContext implements RenderingContext { @Override public RenderableDefinition getRenderableDefinition() { return currentRenderableDefinition; } @Inject AggregationStateBasedRenderingContext(Provider<AggregationState> aggregationStateProvider, RenderExceptionHandler exceptionHandler); AggregationStateBasedRenderingContext(AggregationState aggregationState, RenderExceptionHandler exceptionHandler); @Override Node getMainContent(); @Override Node getCurrentContent(); @Override RenderableDefinition getRenderableDefinition(); @Override void push(Node content, RenderableDefinition renderableDefinition); @Override void push(Node content, RenderableDefinition renderableDefinition, OutputProvider outputProvider); @Override void pop(); @Override OutputProvider getOutputProvider(); @Override AppendableWriter getAppendable(); @Override OutputStream getOutputStream(); @Override void handleException(RenderException renderException); }### Answer: @Test public void testGetRenderableDefinition() throws Exception { Node second = mock(Node.class); when(second.getSession()).thenReturn(session); RenderableDefinition firstRenderableDefinition = mock(RenderableDefinition.class); RenderableDefinition secondRenderableDefinition = mock(RenderableDefinition.class); context.push(mainNode, firstRenderableDefinition, null); context.push(second, secondRenderableDefinition, null); RenderableDefinition result = context.getRenderableDefinition(); assertEquals(result, secondRenderableDefinition); } @Test public void testGetRenderableDefinitionBeforePushReturnsNull() { RenderableDefinition result = context.getRenderableDefinition(); assertNull(result); }
### Question: RenderingModule implements ModuleLifecycle { @Override public void start(ModuleLifecycleContext moduleLifecycleContext) { templateDefinitionManager.start(); rendererManager.start(); } @Inject RenderingModule(ConfiguredTemplateDefinitionManager templateDefinitionManager, ConfiguredRendererManager rendererManager); @Override void start(ModuleLifecycleContext moduleLifecycleContext); @Override void stop(ModuleLifecycleContext moduleLifecycleContext); }### Answer: @Test public void testStartsManagers() { ConfiguredTemplateDefinitionManager configuredTemplateDefinitionManager = mock(ConfiguredTemplateDefinitionManager.class); ConfiguredRendererManager configuredRendererManager = mock(ConfiguredRendererManager.class); RenderingModule renderingModule = new RenderingModule(configuredTemplateDefinitionManager, configuredRendererManager); renderingModule.start(mock(ModuleLifecycleContext.class)); verify(configuredTemplateDefinitionManager).start(); verify(configuredRendererManager).start(); }

Subsets and Splits

No community queries yet

The top public SQL queries from the community will appear here once available.