Datasets:

Minata
/

1024src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Files and versions Community

Split (2)

train · 269k rows

method2testcases stringlengths 118 6.63k
### Question: TelephoneNumber { public static TelephoneNumber of(String number) { String normalized = number.replaceAll("[\$\$\\.\\s-_]", ""); LOGGER.debug("Normalized telephone number: {}", normalized); if (!normalized.matches("^\\+?\\d+$")) { throw new IllegalArgumentException("bad number"); } String prefix = "", suffix = ""; if (normalized.startsWith("+")) { for (int i = 1; i <= 3; i++) { prefix = normalized.substring(1, i); suffix = normalized.substring(i); LOGGER.debug("prefix: {} suffix: {}", prefix, suffix); if (COUNTRY_CODES.containsKey(prefix)) { break; } } } else { prefix = "0"; suffix = normalized; } return new TelephoneNumber(Integer.valueOf(prefix), new BigInteger(suffix)); } private TelephoneNumber(int countryCode, BigInteger nationalNumber); static String getRegion(int countryCode); static TelephoneNumber of(String number); static TelephoneNumber of(int countryCode, BigInteger nationalNumber); int getCountryCode(); BigInteger getNationalNumber(); String getRegion(); String getStringValue(); @Override String toString(); }### Answer: @Test public void testInvalidCountryCode() { assertThrows(new Closure() { @Override public void execute() throws Throwable { TelephoneNumber.of(1000, new BigInteger("1234567890")); } }, IllegalArgumentException.class, "Should throw IllegalArgumentException"); } @Test public void testTooLongTelephoneNumber() { assertThrows(new Closure() { @Override public void execute() throws Throwable { TelephoneNumber.of("+32 12345678901234"); } }, IllegalArgumentException.class, "Should throw IllegalArgumentException"); } @Test public void testInvalidCharacters() { assertThrows(new Closure() { @Override public void execute() throws Throwable { TelephoneNumber.of("+32 abcdefg"); } }, IllegalArgumentException.class, "Should throw IllegalArgumentException"); assertThrows(new Closure() { @Override public void execute() throws Throwable { TelephoneNumber.of("+32 %1234)56789"); } }, IllegalArgumentException.class, "Should throw IllegalArgumentException"); }
### Question: CIDR { public static CIDR of(String cidr) { String[] parts = cidr.split("\\/"); if (parts.length == 1) { try { InetAddress address = InetAddress.getByName(parts[0]); int length = address instanceof Inet4Address ? 32 : 128; return new CIDR(address.getAddress(), length); } catch (UnknownHostException e) { throw new IllegalArgumentException(e); } } if (parts.length != 2) { throw new IllegalArgumentException("Invalid format"); } try { InetAddress address = InetAddress.getByName(parts[0]); return new CIDR(address.getAddress(),Integer.parseInt(parts[1])); } catch (UnknownHostException e) { throw new IllegalArgumentException(e); } } CIDR(byte[] address, int size); byte[] getAddress(); int getSize(); byte[] getMask(); boolean contains(InetAddress inet); static CIDR of(String cidr); }### Answer: @Test public void testDoesItSmoke() { Assert.assertThrows(new Assert.Closure() { @Override public void execute() throws Throwable { CIDR.of("1.1.1.1/-1"); } }, IllegalArgumentException.class, "negative prefix size"); }
### Question: AlphanumStringComparator implements Comparator<String> { @Override public int compare(String s1, String s2) { int c = 0; Matcher m1 = prefixRexp.matcher(s1); Matcher m2 = prefixRexp.matcher(s2); if (m1.find() && m2.find()) { Integer i1 = Integer.valueOf(m1.group(1)); Integer i2 = Integer.valueOf(m2.group(1)); c = i1.compareTo(i2); } else { throw new IllegalArgumentException("Can not compare strings missing 'digit@' pattern"); } return c; } @Override int compare(String s1, String s2); }### Answer: @Test public void should_correctly_compare_alphanumerical_strings() throws Exception { AlphanumStringComparator comparator = new AlphanumStringComparator(); assertTrue(comparator.compare("10@foo", "2@foo") > 0); assertTrue(comparator.compare("2@foo", "10@foo") < 0); assertTrue(comparator.compare("10@foo", "10@foo") == 0); }
### Question: MapUtils { public static List<Map<String, List<String>>> splitToChunksOfSize(Map<String, List<String>> rawMap, int chunkSize) { List<Map<String, List<String>>> mapChunks = new LinkedList<Map<String, List<String>>>(); Set<Map.Entry<String, List<String>>> rawEntries = rawMap.entrySet(); Map<String, List<String>> currentChunk = new LinkedHashMap<String, List<String>>(); int rawEntryIndex = 0; for(Map.Entry<String, List<String>> rawEntry : rawEntries) { if(rawEntryIndex % chunkSize == 0) { if(currentChunk.size() > 0) { mapChunks.add(currentChunk); } currentChunk = new LinkedHashMap<String, List<String>>(); } currentChunk.put(rawEntry.getKey(), rawEntry.getValue()); rawEntryIndex++; if(rawEntryIndex == rawMap.size()) { mapChunks.add(currentChunk); } } return mapChunks; } private MapUtils(); static List<Map<String, List<String>>> splitToChunksOfSize(Map<String, List<String>> rawMap, int chunkSize); }### Answer: @Test public void splitToChunksOfSize_should_split_entries_exceeding_size() throws Exception { Map<String, List<String>> attributes = new LinkedHashMap<String, List<String>>(); for(int i = 0; i < SAMPLE_MAP_SIZE + 100; i++) { List<String> list = new ArrayList<String>(); list.add("Value: " + i); attributes.put("Key: " + i, list); } List<Map<String, List<String>>> chunks = MapUtils.splitToChunksOfSize(attributes, SAMPLE_MAP_SIZE); assertEquals(2, chunks.size()); Map<String, List<String>> firstChunk = chunks.get(0); assertEquals(SAMPLE_MAP_SIZE, firstChunk.size()); Map<String, List<String>> secondChunk = chunks.get(1); assertEquals(100, secondChunk.size()); assertTrue(secondChunk.containsKey("Key: " + 256)); assertTrue(secondChunk.containsKey("Key: " + 355)); }
### Question: PartTreeConverter { public static String toIndexedQuery(final PartTree tree) { final StringBuilder result = new StringBuilder(); final Iterator<OrPart> orIt = tree.iterator(); while(orIt.hasNext()) { final OrPart orPart = orIt.next(); final Iterator<Part> partIt = orPart.iterator(); while(partIt.hasNext()) { final Part part = partIt.next(); result.append(" " + part.getProperty().getSegment() + " "); result.append(convertOperator(part.getType())); if(partIt.hasNext()) { result.append(" AND "); } } if(orIt.hasNext()) { result.append(" OR "); } } return StringUtil.removeExtraSpaces(result.toString()); } private PartTreeConverter(); static String toIndexedQuery(final PartTree tree); }### Answer: @Test public void should_create_corect_query_for_simple_property() { final String methodName = "findByItemName"; final PartTree tree = new PartTree(methodName, SimpleDbSampleEntity.class); final String query = PartTreeConverter.toIndexedQuery(tree); final String expected = " itemName = ? "; assertEquals(expected, query); } @Test public void should_create_corect_query_for_between() { final String methodName = "readByAgeBetween"; final PartTree tree = new PartTree(methodName, SimpleDbSampleEntity.class); final String query = PartTreeConverter.toIndexedQuery(tree); final String expected = " age BETWEEN ? and ? "; assertEquals(expected, query); } @Test public void should_create_corect_query_for_complex_operators() { final String methodName = "getByItemNameLikeOrAgeGreaterThanAndAgeLessThan"; final PartTree tree = new PartTree(methodName, SimpleDbSampleEntity.class); final String query = PartTreeConverter.toIndexedQuery(tree); final String expected = " itemName LIKE ? OR age > ? AND age < ? "; assertEquals(expected, query); } @Test(expected = MappingException.class) public void shoud_fail_for_unsupported_operator() { final String methodName = "readByAgeEndsWith"; final PartTree tree = new PartTree(methodName, SimpleDbSampleEntity.class); PartTreeConverter.toIndexedQuery(tree); }
### Question: SimpleDbRepositoryQuery implements RepositoryQuery { void assertNotHavingNestedQueryParameters(String query) { List<String> attributesFromQuery = QueryUtils.getQueryPartialFieldNames(query); final Class<?> domainClass = method.getDomainClazz(); for(String attribute : attributesFromQuery) { try { Field field = ReflectionUtils.getDeclaredFieldInHierarchy(domainClass, attribute); if(FieldTypeIdentifier.isOfType(field, FieldType.NESTED_ENTITY)) { throw new IllegalArgumentException("Invalid query parameter :" + attribute + " is nested object"); } } catch(NoSuchFieldException e) { } } } SimpleDbRepositoryQuery(SimpleDbQueryMethod method, SimpleDbOperations simpledbOperations); @Override Object execute(Object[] parameters); @Override QueryMethod getQueryMethod(); static RepositoryQuery fromQueryAnnotation(SimpleDbQueryMethod queryMethod, SimpleDbOperations simpleDbOperations); }### Answer: @SuppressWarnings({ "rawtypes", "unchecked" }) @Test(expected = IllegalArgumentException.class) public void assertNotHavingNestedQueryParameters_should_fail_for_nested_attributes() { SimpleDbQueryMethod method = Mockito.mock(SimpleDbQueryMethod.class); Mockito.when(method.getDomainClazz()).thenReturn((Class) SampleEntity.class); SimpleDbRepositoryQuery repositoryQuery = new SimpleDbRepositoryQuery(method, null); repositoryQuery.assertNotHavingNestedQueryParameters("select sampleNestedAttribute from SampleEntity"); }
### Question: SimpleDbQueryRunner { public Object executeSingleResultQuery() { List<?> returnListFromDb = executeQuery(); return getSingleResult(returnListFromDb); } SimpleDbQueryRunner(SimpleDbOperations simpledbOperations, Class<?> domainClass, String query); SimpleDbQueryRunner(SimpleDbOperations simpledbOperations, Class<?> domainClass, String query, Pageable pageable); List<?> executeQuery(); Object executeSingleResultQuery(); long executeCount(); List<String> getRequestedQueryFieldNames(); String getSingleQueryFieldName(); Page<?> executePagedQuery(); }### Answer: @Test(expected = IllegalArgumentException.class) public void executeSingleResultQuery_should_fail_if_multiple_results_are_retrieved() { SimpleDbOperations simpleDbOperations = Mockito.mock(SimpleDbOperations.class); List<SampleEntity> sampleMultipleResults = new ArrayList<SampleEntity>(); sampleMultipleResults.add(new SampleEntity()); sampleMultipleResults.add(new SampleEntity()); Mockito.when(simpleDbOperations.find(Mockito.same(SampleEntity.class), Mockito.anyString())).thenReturn( sampleMultipleResults); SimpleDbQueryRunner runner = new SimpleDbQueryRunner((SimpleDbOperations) simpleDbOperations, SampleEntity.class, null); runner.executeSingleResultQuery(); }
### Question: SimpleDbQueryRunner { Object getSingleResult(List<?> returnListFromDb) { Assert.isTrue(returnListFromDb.size() <= 1, "Select statement should return only one entity from database, returned elements size=" + returnListFromDb.size() + ", for Query=" + query); return returnListFromDb.size() > 0 ? returnListFromDb.get(0) : null; } SimpleDbQueryRunner(SimpleDbOperations simpledbOperations, Class<?> domainClass, String query); SimpleDbQueryRunner(SimpleDbOperations simpledbOperations, Class<?> domainClass, String query, Pageable pageable); List<?> executeQuery(); Object executeSingleResultQuery(); long executeCount(); List<String> getRequestedQueryFieldNames(); String getSingleQueryFieldName(); Page<?> executePagedQuery(); }### Answer: @Test public void getSingleResult_should_return_null_for_empty_list() { SimpleDbQueryRunner runner = new SimpleDbQueryRunner(null, SampleEntity.class, null); final Object result = runner.getSingleResult(new ArrayList<SampleEntity>()); assertNull(result); } @Test public void getSingleResult_should_return_single_value_from_list_with_one_element() { SimpleDbQueryRunner runner = new SimpleDbQueryRunner(null, SampleEntity.class, null); final ArrayList<SampleEntity> results = new ArrayList<SampleEntity>(); results.add(new SampleEntity()); final Object result = runner.getSingleResult(results); assertNotNull(result); } @Test(expected = IllegalArgumentException.class) public void getSingleResult_should_fail_for_list_with_multiple_elements() { SimpleDbQueryRunner runner = new SimpleDbQueryRunner(null, SampleEntity.class, null); final ArrayList<SampleEntity> results = new ArrayList<SampleEntity>(); results.add(new SampleEntity()); results.add(new SampleEntity()); runner.getSingleResult(results); }
### Question: SimpleDbResultConverter { public static List<Object> filterNamedAttributesAsList(List<?> domainObjects, String attributeName) { List<Object> ret = new ArrayList<Object>(); for(Object object : domainObjects) { ret.add(ReflectionUtils.callGetter(object, attributeName)); } return ret; } private SimpleDbResultConverter(); static List<Object> filterNamedAttributesAsList(List<?> domainObjects, String attributeName); static Set<Object> filterNamedAttributesAsSet(List<?> domainObjects, String attributeName); static List<List<Object>> toListOfListOfObject(List<?> entityList, List<String> requestedQueryFieldNames); }### Answer: @Test public void filterNamedAttributesAsList_should_return_list_of_named_attributes() throws Exception { List<SampleEntity> entities = new ArrayList<SampleEntity>(); SampleEntity entity = new SampleEntity(); entity.setSampleAttribute(SAMPLE_INT_VALUE); entities.add(entity); List<Object> filteredAttributes = SimpleDbResultConverter.filterNamedAttributesAsList(entities, "sampleAttribute"); assertEquals(1, filteredAttributes.size()); Object firstElement = filteredAttributes.get(0); assertEquals(SAMPLE_INT_VALUE, firstElement); } @Test public void filterNamedAttributesAsList_should_work_for_list_attributes() throws Exception { List<SampleEntity> entities = new ArrayList<SampleEntity>(); SampleEntity entity = new SampleEntity(); entity.setSampleList(new ArrayList<Integer>()); entities.add(entity); List<Object> filteredAttributes = SimpleDbResultConverter.filterNamedAttributesAsList(entities, "sampleList"); assertEquals(1, filteredAttributes.size()); Object firstElement = filteredAttributes.get(0); assertTrue(firstElement instanceof List); } @Test(expected = MappingException.class) public void filterNamedAttributesAsList_should_not_return_list_of_named_attributes_for_wrong_att() throws Exception { List<SampleEntity> entities = new ArrayList<SampleEntity>(); SampleEntity entity = new SampleEntity(); entities.add(entity); SimpleDbResultConverter.filterNamedAttributesAsList(entities, "wrongAttribute"); }
### Question: SimpleDbResultConverter { public static Set<Object> filterNamedAttributesAsSet(List<?> domainObjects, String attributeName) { Set<Object> ret = new LinkedHashSet<Object>(); for(Object object : domainObjects) { ret.add(ReflectionUtils.callGetter(object, attributeName)); } return ret; } private SimpleDbResultConverter(); static List<Object> filterNamedAttributesAsList(List<?> domainObjects, String attributeName); static Set<Object> filterNamedAttributesAsSet(List<?> domainObjects, String attributeName); static List<List<Object>> toListOfListOfObject(List<?> entityList, List<String> requestedQueryFieldNames); }### Answer: @Test public void filterNamedAttributesAsSet_should_return_Set_of_named_attributes() throws Exception { List<SampleEntity> entities = new ArrayList<SampleEntity>(); SampleEntity entity = new SampleEntity(); entity.setSampleAttribute(SAMPLE_INT_VALUE); entities.add(entity); Set<Object> filteredAttributes = SimpleDbResultConverter .filterNamedAttributesAsSet(entities, "sampleAttribute"); assertEquals(1, filteredAttributes.size()); Object firstElement = filteredAttributes.iterator().next(); assertEquals(SAMPLE_INT_VALUE, firstElement); }
### Question: SimpleDbResultConverter { public static List<List<Object>> toListOfListOfObject(List<?> entityList, List<String> requestedQueryFieldNames) { if(entityList.size() > 0) { List<List<Object>> rows = new ArrayList<List<Object>>(); for(Object entity : entityList) { List<Object> cols = new ArrayList<Object>(); for(String fieldName : requestedQueryFieldNames) { Object value = ReflectionUtils.callGetter(entity, fieldName); cols.add(value); } rows.add(cols); } return rows; } else { return Collections.emptyList(); } } private SimpleDbResultConverter(); static List<Object> filterNamedAttributesAsList(List<?> domainObjects, String attributeName); static Set<Object> filterNamedAttributesAsSet(List<?> domainObjects, String attributeName); static List<List<Object>> toListOfListOfObject(List<?> entityList, List<String> requestedQueryFieldNames); }### Answer: @Test public void toListOfListOfObject_should_return_List_of_Lists_containing_requested_attributes() { List<SampleEntity> entities = new ArrayList<SampleEntity>(); SampleEntity entity = new SampleEntity(); entity.setSampleAttribute(SAMPLE_INT_VALUE); entity.setSampleList(new ArrayList<Integer>()); entities.add(entity); List<String> attributes = Arrays.asList("sampleAttribute", "sampleList"); List<List<Object>> filteredAttributes = SimpleDbResultConverter.toListOfListOfObject(entities, attributes); assertEquals(1, filteredAttributes.size()); List<Object> columns = filteredAttributes.get(0); assertEquals(2, columns.size()); assertEquals(SAMPLE_INT_VALUE, columns.get(0)); }
### Question: PagedResultExecution extends AbstractSimpleDbQueryExecution { @Override protected Object doExecute(SimpleDbQueryMethod queryMethod, SimpleDbQueryRunner queryRunner) { final Page<?> pagedResult = queryRunner.executePagedQuery(); if(queryMethod.isPageQuery()) { return pagedResult; } return pagedResult.getContent(); } PagedResultExecution(SimpleDbOperations simpleDbOperations); }### Answer: @Test @SuppressWarnings({ "rawtypes", "unchecked" }) public void doExecute_should_return_Page_type() throws Exception { final SimpleDbQueryMethod repositoryMethod = prepareQueryMethodToTest("selectAllIntoPage", SampleEntity.class); final PagedResultExecution execution = new PagedResultExecution(null); final SimpleDbQueryRunner queryRunner = Mockito.mock(SimpleDbQueryRunner.class); when(queryRunner.executePagedQuery()).thenReturn(new PageImpl(new ArrayList())); final Object result = execution.doExecute(repositoryMethod, queryRunner); assertTrue(Page.class.isAssignableFrom(result.getClass())); } @Test @SuppressWarnings({ "rawtypes", "unchecked" }) public void doExecute_should_return_List_type() throws Exception { final SimpleDbQueryMethod repositoryMethod = prepareQueryMethodToTest("selectAllIntoList", SampleEntity.class); final PagedResultExecution execution = new PagedResultExecution(null); final SimpleDbQueryRunner queryRunner = Mockito.mock(SimpleDbQueryRunner.class); when(queryRunner.executePagedQuery()).thenReturn(new PageImpl(new ArrayList())); final Object result = execution.doExecute(repositoryMethod, queryRunner); assertTrue(List.class.isAssignableFrom(result.getClass())); }
### Question: SimpleDBAttributeConverter { public static Object decodeToPrimitiveArray(List<String> fromSimpleDbAttValues, Class<?> retType) throws ParseException { Object primitiveCollection = Array.newInstance(retType, fromSimpleDbAttValues.size()); int idx = 0; for(Iterator<String> iterator = fromSimpleDbAttValues.iterator(); iterator.hasNext(); idx++) { Array.set(primitiveCollection, idx, decodeToFieldOfType(iterator.next(), retType)); } return primitiveCollection; } private SimpleDBAttributeConverter(); static String encode(Object ob); static List<String> encodeArray(final Object arrayValues); static Object decodeToFieldOfType(String value, Class<?> retType); static Object decodeToPrimitiveArray(List<String> fromSimpleDbAttValues, Class<?> retType); }### Answer: @Test public void toSimpleDBAttributeValues_should_return_an_string_representation_of_concatenated_array_elements() throws ParseException { final int[] expectedIntArray = { 1, 2, 3, 4 }; final List<String> simpleDBValues = Arrays.asList("1", "2", "3", "4"); Object returnedPrimitiveCol = SimpleDBAttributeConverter.decodeToPrimitiveArray(simpleDBValues, int.class); int arrayLength = Array.getLength(returnedPrimitiveCol); for(int idx = 0; idx < arrayLength; idx++) { assertEquals(expectedIntArray[idx], Array.get(returnedPrimitiveCol, idx)); } }
### Question: SimpleDbAttributeValueSplitter { public static Map<String, List<String>> splitAttributeValuesWithExceedingLengths(Map<String, String> rawAttributes) { Map<String, List<String>> splitAttributes = new LinkedHashMap<String, List<String>>(); Set<Map.Entry<String, String>> rawEntries = rawAttributes.entrySet(); for(Map.Entry<String, String> rawEntry : rawEntries) { splitAttributes.put(rawEntry.getKey(), new ArrayList<String>()); if(rawEntry.getValue().length() > MAX_ATTR_VALUE_LEN) { splitAttributes.get(rawEntry.getKey()).addAll(splitExceedingValue(rawEntry.getValue())); } else { splitAttributes.get(rawEntry.getKey()).add(rawEntry.getValue()); } } return splitAttributes; } private SimpleDbAttributeValueSplitter(); static Map<String, List<String>> splitAttributeValuesWithExceedingLengths(Map<String, String> rawAttributes); static Map<String, String> combineAttributeValuesWithExceedingLengths(Map<String, List<String>> multiValueAttributes); static final int MAX_ATTR_VALUE_LEN; }### Answer: @Test public void splitAttributeValuesWithExceedingLengths_should_detect_long_attributes() throws Exception { Map<String, String> rawAttributes = new LinkedHashMap<String, String>(); rawAttributes.put(SAMPLE_ATT_NAME, STRING_OF_MAX_SIMPLE_DB_LENGTH + "c"); Map<String, List<String>> splitAttributes = SimpleDbAttributeValueSplitter .splitAttributeValuesWithExceedingLengths(rawAttributes); assertEquals("count(keys) == 1", 1, splitAttributes.keySet().size()); Iterator<List<String>> iterator = splitAttributes.values().iterator(); List<String> next = null; if (iterator.hasNext()) { next = iterator.next(); } assertNotNull(next); assertEquals("count(values) == 2", 2, next.size()); } @Test public void splitAttributeValuesWithExceedingLengths_should_not_split_short_attributes() throws Exception { Map<String, String> rawAttributes = new LinkedHashMap<String, String>(); rawAttributes.put(SAMPLE_ATT_NAME, "shortValue"); Map<String, List<String>> splitAttributes = SimpleDbAttributeValueSplitter .splitAttributeValuesWithExceedingLengths(rawAttributes); assertEquals(1, splitAttributes.keySet().size()); List<String> firstSplitAttribute = splitAttributes.values().iterator().next(); assertEquals("shortValue", firstSplitAttribute.get(0)); }
### Question: QueryBuilder { @Override public String toString() { String result = query.toString(); LOGGER.debug("Created query: {}", result); return result; } QueryBuilder(SimpleDbEntityInformation<?, ?> entityInformation); QueryBuilder(SimpleDbEntityInformation<?, ?> entityInformation, boolean shouldCount); QueryBuilder(String customQuery); QueryBuilder(String customQuery, boolean shouldCount); QueryBuilder withLimit(final int limit); QueryBuilder withIds(Iterable<?> iterable); QueryBuilder with(Sort sort); QueryBuilder with(Pageable pageable); @Override String toString(); }### Answer: @Test public void should_create_correct_queries_if_no_other_clauses_are_specified() throws Exception { QueryBuilder builder = new QueryBuilder(SimpleDbSampleEntity.entityInformation()); String returnedQuery = builder.toString(); assertEquals("select * from `simpleDbSampleEntity`", returnedQuery); } @Test public void should_include_count_clause_if_requested() throws Exception { QueryBuilder builder = new QueryBuilder(SimpleDbSampleEntity.entityInformation(), true); String returnedQuery = builder.toString(); assertThat(returnedQuery, containsString("select count(*) from")); }
### Question: EntityWrapper { public Map<String, String> serialize() { return serialize(""); } EntityWrapper(SimpleDbEntityInformation<T, ?> entityInformation, T item); EntityWrapper(SimpleDbEntityInformation<T, ?> entityInformation, T item, boolean isNested); EntityWrapper(SimpleDbEntityInformation<T, ?> entityInformation); EntityWrapper(SimpleDbEntityInformation<T, ?> entityInformation, boolean isNested); String getDomain(); String getItemName(); Map<String, String> getAttributes(); T getItem(); void generateIdIfNotSet(); void setId(String itemName); Map<String, String> serialize(); Object deserialize(final Map<String, String> attributes); Map<String, List<String>> toMultiValueAttributes(); }### Answer: @Test public void test_getSerializedPrimitiveAttributes() throws ParseException { final SampleEntity entity = new SampleEntity(); entity.setIntField(11); entity.setLongField(123); entity.setShortField((short) -12); entity.setFloatField(-0.01f); entity.setDoubleField(1.2d); entity.setByteField((byte) 1); entity.setBooleanField(Boolean.TRUE); entity.setStringField("string"); entity.setDoubleWrapper(Double.valueOf("2323.32d")); EntityWrapper<SampleEntity, String> sdbEntity = new EntityWrapper<SampleEntity, String>( EntityInformationSupport.readEntityInformation(SampleEntity.class), entity); assertNotNull(sdbEntity); final Map<String, String> attributes = sdbEntity.serialize(); assertNotNull(attributes); String intValues = attributes.get("intField"); assertNotNull(intValues); assertEquals(entity.getIntField(), ((Integer) SimpleDBAttributeConverter.decodeToFieldOfType(intValues, Integer.class)).intValue()); String longValues = attributes.get("longField"); assertEquals(entity.getLongField(), ((Long) SimpleDBAttributeConverter.decodeToFieldOfType(longValues, Long.class)).longValue()); String shortValues = attributes.get("shortField"); assertEquals(entity.getShortField(), ((Short) SimpleDBAttributeConverter.decodeToFieldOfType(shortValues, Short.class)).shortValue()); String floatValues = attributes.get("floatField"); assertTrue(entity.getFloatField() == ((Float) SimpleDBAttributeConverter.decodeToFieldOfType(floatValues, Float.class)).floatValue()); String doubleValues = attributes.get("doubleField"); assertTrue(entity.getDoubleField() == ((Double) SimpleDBAttributeConverter.decodeToFieldOfType(doubleValues, Double.class)).doubleValue()); String byteValues = attributes.get("byteField"); assertTrue(entity.getByteField() == ((Byte) SimpleDBAttributeConverter.decodeToFieldOfType(byteValues, Byte.class)).byteValue()); String booleanValues = attributes.get("booleanField"); assertTrue(entity.getBooleanField() == ((Boolean) SimpleDBAttributeConverter.decodeToFieldOfType(booleanValues, Boolean.class)).booleanValue()); } @Test public void should_generate_attribute_keys_for_nested_domain_fields() { final AClass aDomain = new AClass(); { aDomain.nestedB = new BClass(); { aDomain.nestedB.floatField = 21f; aDomain.nestedB.nestedNestedC = new CClass(); { aDomain.nestedB.nestedNestedC.doubleField = 14d; } } } EntityWrapper<AClass, String> sdbEntity = new EntityWrapper<AClass, String>( EntityInformationSupport.readEntityInformation(AClass.class), aDomain); final Map<String, String> attributes = sdbEntity.serialize(); assertNotNull(attributes); assertEquals(3, attributes.size()); final Set<String> keySet = attributes.keySet(); assertTrue(keySet.contains("intField")); assertTrue(keySet.contains("nestedB.floatField")); assertTrue(keySet.contains("nestedB.nestedNestedC.doubleField")); }
### Question: DomainItemBuilder { public T populateDomainItem(SimpleDbEntityInformation<T, ?> entityInformation, Item item) { return buildDomainItem(entityInformation, item); } List<T> populateDomainItems(SimpleDbEntityInformation<T, ?> entityInformation, SelectResult selectResult); T populateDomainItem(SimpleDbEntityInformation<T, ?> entityInformation, Item item); }### Answer: @Test public void populateDomainItem_should_convert_item_name() { Item sampleItem = new Item(SAMPLE_ITEM_NAME, new ArrayList<Attribute>()); SimpleDbEntityInformation<SimpleDbSampleEntity, String> entityInformation = SimpleDbSampleEntity .entityInformation(); domainItemBuilder = new DomainItemBuilder<SimpleDbSampleEntity>(); SimpleDbSampleEntity returnedDomainEntity = domainItemBuilder.populateDomainItem(entityInformation, sampleItem); assertEquals(SAMPLE_ITEM_NAME, returnedDomainEntity.getItemName()); } @Test public void populateDomainItem_should_convert_attributes() { List<Attribute> attributeList = new ArrayList<Attribute>(); attributeList.add(new Attribute("booleanField", "" + SAMPLE_BOOLEAN_ATT_VALUE)); Item sampleItem = new Item(SAMPLE_ITEM_NAME, attributeList); SimpleDbEntityInformation<SimpleDbSampleEntity, String> entityInformation = SimpleDbSampleEntity .entityInformation(); domainItemBuilder = new DomainItemBuilder<SimpleDbSampleEntity>(); SimpleDbSampleEntity returnedDomainEntity = domainItemBuilder.populateDomainItem(entityInformation, sampleItem); assertTrue(returnedDomainEntity.getBooleanField() == SAMPLE_BOOLEAN_ATT_VALUE); }
### Question: Util { public static Map<String, String> objectToStringMap(Object object) { TypeReference<HashMap<String, String>> typeReference = new TypeReference<HashMap<String, String>>() {}; return objectMapper.convertValue(object, typeReference); } private Util(); static String getDefaultMusicFolder(); static String getDefaultPodcastFolder(); static String getDefaultPlaylistFolder(); static boolean isWindows(); static void setContentLength(HttpServletResponse response, long length); static List<T> subList(List<T> list, long offset, long max); static List<Integer> toIntegerList(int[] values); static int[] toIntArray(List<Integer> values); static String debugObject(Object object); static String getURLForRequest(HttpServletRequest request); static String getAnonymizedURLForRequest(HttpServletRequest request); static boolean isInstanceOfClassName(Object o, String className); static Map<String, String> objectToStringMap(Object object); static T stringMapToObject(Class<T> clazz, Map<String, String> data); static T stringMapToValidObject(Class<T> clazz, Map<String, String> data); }### Answer: @Test public void objectToStringMapNull() { MediaLibraryStatistics statistics = null; Map<String, String> stringStringMap = Util.objectToStringMap(statistics); assertNull(stringStringMap); } @Test public void objectToStringMap() { Date date = new Date(1568350960725L); MediaLibraryStatistics statistics = new MediaLibraryStatistics(date); statistics.incrementAlbums(5); statistics.incrementSongs(4); statistics.incrementArtists(910823); statistics.incrementTotalDurationInSeconds(30); statistics.incrementTotalLengthInBytes(2930491082L); Map<String, String> stringStringMap = Util.objectToStringMap(statistics); assertEquals("5", stringStringMap.get("albumCount")); assertEquals("4", stringStringMap.get("songCount")); assertEquals("910823", stringStringMap.get("artistCount")); assertEquals("30", stringStringMap.get("totalDurationInSeconds")); assertEquals("2930491082", stringStringMap.get("totalLengthInBytes")); assertEquals("1568350960725", stringStringMap.get("scanDate")); }
### Question: InternetRadioService { public List<InternetRadioSource> getInternetRadioSources(InternetRadio radio) { List<InternetRadioSource> sources; if (cachedSources.containsKey(radio.getId())) { LOG.debug("Got cached sources for internet radio {}!", radio.getStreamUrl()); sources = cachedSources.get(radio.getId()); } else { LOG.debug("Retrieving sources for internet radio {}...", radio.getStreamUrl()); try { sources = retrieveInternetRadioSources(radio); if (sources.isEmpty()) { LOG.warn("No entries found for internet radio {}.", radio.getStreamUrl()); } else { LOG.info("Retrieved playlist for internet radio {}, got {} sources.", radio.getStreamUrl(), sources.size()); } } catch (Exception e) { LOG.error("Failed to retrieve sources for internet radio {}.", radio.getStreamUrl(), e); sources = new ArrayList<>(); } cachedSources.put(radio.getId(), sources); } return sources; } InternetRadioService(); void clearInternetRadioSourceCache(); void clearInternetRadioSourceCache(Integer internetRadioId); List<InternetRadioSource> getInternetRadioSources(InternetRadio radio); }### Answer: @Test public void testRedirectLoop() { List<InternetRadioSource> radioSources = internetRadioService.getInternetRadioSources(radioMoveLoop); Assert.assertEquals(0, radioSources.size()); } @Test public void testParseSimplePlaylist() { List<InternetRadioSource> radioSources = internetRadioService.getInternetRadioSources(radio1); Assert.assertEquals(2, radioSources.size()); Assert.assertEquals(TEST_STREAM_URL_1, radioSources.get(0).getStreamUrl()); Assert.assertEquals(TEST_STREAM_URL_2, radioSources.get(1).getStreamUrl()); } @Test public void testRedirects() { List<InternetRadioSource> radioSources = internetRadioService.getInternetRadioSources(radioMove); Assert.assertEquals(2, radioSources.size()); Assert.assertEquals(TEST_STREAM_URL_3, radioSources.get(0).getStreamUrl()); Assert.assertEquals(TEST_STREAM_URL_4, radioSources.get(1).getStreamUrl()); } @Test public void testLargeInput() { List<InternetRadioSource> radioSources = internetRadioService.getInternetRadioSources(radioLarge); Assert.assertEquals(250, radioSources.size()); } @Test public void testLargeInputURL() { List<InternetRadioSource> radioSources = internetRadioService.getInternetRadioSources(radioLarge2); Assert.assertEquals(1, radioSources.size()); }
### Question: Util { public static <T> T stringMapToObject(Class<T> clazz, Map<String, String> data) { return objectMapper.convertValue(data, clazz); } private Util(); static String getDefaultMusicFolder(); static String getDefaultPodcastFolder(); static String getDefaultPlaylistFolder(); static boolean isWindows(); static void setContentLength(HttpServletResponse response, long length); static List<T> subList(List<T> list, long offset, long max); static List<Integer> toIntegerList(int[] values); static int[] toIntArray(List<Integer> values); static String debugObject(Object object); static String getURLForRequest(HttpServletRequest request); static String getAnonymizedURLForRequest(HttpServletRequest request); static boolean isInstanceOfClassName(Object o, String className); static Map<String, String> objectToStringMap(Object object); static T stringMapToObject(Class<T> clazz, Map<String, String> data); static T stringMapToValidObject(Class<T> clazz, Map<String, String> data); }### Answer: @Test public void stringMapToObject() { Map<String, String> stringStringMap = new HashMap<>(); stringStringMap.put("albumCount", "5"); stringStringMap.put("songCount", "4"); stringStringMap.put("artistCount", "910823"); stringStringMap.put("totalDurationInSeconds", "30"); stringStringMap.put("totalLengthInBytes", "2930491082"); stringStringMap.put("scanDate", "1568350960725"); MediaLibraryStatistics statistics = Util.stringMapToObject(MediaLibraryStatistics.class, stringStringMap); assertEquals(new Integer(5), statistics.getAlbumCount()); assertEquals(new Integer(4), statistics.getSongCount()); assertEquals(new Integer(910823), statistics.getArtistCount()); assertEquals(new Long(30L), statistics.getTotalDurationInSeconds()); assertEquals(new Long(2930491082L), statistics.getTotalLengthInBytes()); assertEquals(new Date(1568350960725L), statistics.getScanDate()); } @Test public void stringMapToObjectWithExtraneousData() { Map<String, String> stringStringMap = new HashMap<>(); stringStringMap.put("albumCount", "5"); stringStringMap.put("songCount", "4"); stringStringMap.put("artistCount", "910823"); stringStringMap.put("totalDurationInSeconds", "30"); stringStringMap.put("totalLengthInBytes", "2930491082"); stringStringMap.put("scanDate", "1568350960725"); stringStringMap.put("extraneousData", "nothingHereToLookAt"); MediaLibraryStatistics statistics = Util.stringMapToObject(MediaLibraryStatistics.class, stringStringMap); assertEquals(new Integer(5), statistics.getAlbumCount()); assertEquals(new Integer(4), statistics.getSongCount()); assertEquals(new Integer(910823), statistics.getArtistCount()); assertEquals(new Long(30L), statistics.getTotalDurationInSeconds()); assertEquals(new Long(2930491082L), statistics.getTotalLengthInBytes()); assertEquals(new Date(1568350960725L), statistics.getScanDate()); }
### Question: Util { public static <T> T stringMapToValidObject(Class<T> clazz, Map<String, String> data) { T object = stringMapToObject(clazz, data); Set<ConstraintViolation<T>> validate = validator.validate(object); if (validate.isEmpty()) { return object; } else { throw new IllegalArgumentException("Created object was not valid"); } } private Util(); static String getDefaultMusicFolder(); static String getDefaultPodcastFolder(); static String getDefaultPlaylistFolder(); static boolean isWindows(); static void setContentLength(HttpServletResponse response, long length); static List<T> subList(List<T> list, long offset, long max); static List<Integer> toIntegerList(int[] values); static int[] toIntArray(List<Integer> values); static String debugObject(Object object); static String getURLForRequest(HttpServletRequest request); static String getAnonymizedURLForRequest(HttpServletRequest request); static boolean isInstanceOfClassName(Object o, String className); static Map<String, String> objectToStringMap(Object object); static T stringMapToObject(Class<T> clazz, Map<String, String> data); static T stringMapToValidObject(Class<T> clazz, Map<String, String> data); }### Answer: @Test(expected = IllegalArgumentException.class) public void stringMapToValidObjectWithNoData() { Map<String, String> stringStringMap = new HashMap<>(); MediaLibraryStatistics statistics = Util.stringMapToValidObject(MediaLibraryStatistics.class, stringStringMap); }
### Question: JWTSecurityService { public String addJWTToken(String uri) { return addJWTToken(UriComponentsBuilder.fromUriString(uri)).build().toString(); } @Autowired JWTSecurityService(SettingsService settingsService); static String generateKey(); static Algorithm getAlgorithm(String jwtKey); String addJWTToken(String uri); UriComponentsBuilder addJWTToken(UriComponentsBuilder builder); UriComponentsBuilder addJWTToken(UriComponentsBuilder builder, Date expires); static DecodedJWT verify(String jwtKey, String token); DecodedJWT verify(String credentials); static final String JWT_PARAM_NAME; static final String CLAIM_PATH; static final int DEFAULT_DAYS_VALID_FOR; }### Answer: @Test public void addJWTToken() { UriComponentsBuilder builder = UriComponentsBuilder.fromUriString(uriString); String actualUri = service.addJWTToken(builder).build().toUriString(); String jwtToken = UriComponentsBuilder.fromUriString(actualUri).build().getQueryParams().getFirst( JWTSecurityService.JWT_PARAM_NAME); DecodedJWT verify = verifier.verify(jwtToken); Claim claim = verify.getClaim(JWTSecurityService.CLAIM_PATH); assertEquals(expectedClaimString, claim.asString()); }
### Question: ReadmeBuilder { @Override public String toString() { Parser markdownParser = Parser.builder().build(); Node markdownDocument = markdownParser.parse(this.markdownText); HtmlRenderer renderer = HtmlRenderer.builder().build(); return TEMPLATE.replace(README_TEMPLATE_TITLE_KEY, this.pageTitle) .replace(README_TEMPLATE_BODY_KEY, renderer.render(markdownDocument)); } ReadmeBuilder(String markdownText, String pageTitle); static ReadmeBuilder fromMarkdownResource(String title, String path, TransformationContext context); @Override String toString(); }### Answer: @Test public void testBuilderWithMarkdownString() { logger.info("Initilaizing Readme Builder"); ReadmeBuilder builder = new ReadmeBuilder("# Hello World", "Hello"); logger.info("Rendering"); String result = builder.toString(); logger.info("Rendered: {}", result); assertTrue(result.contains("<h1>Hello World</h1>")); assertTrue(result.contains("<title>Hello</title>")); }
### Question: KubernetesPlugin extends ToscanaPlugin<KubernetesLifecycle> { @Override public KubernetesLifecycle getInstance(TransformationContext context) throws Exception { return new KubernetesLifecycle(context, mapper); } @Autowired KubernetesPlugin(BaseImageMapper mapper); @Override KubernetesLifecycle getInstance(TransformationContext context); static final String DOCKER_PUSH_TO_REGISTRY_PROPERTY_KEY; static final String DOCKER_REGISTRY_URL_PROPERTY_KEY; static final String DOCKER_REGISTRY_USERNAME_PROPERTY_KEY; static final String DOCKER_REGISTRY_PASSWORD_PROPERTY_KEY; static final String DOCKER_REGISTRY_REPOSITORY_PROPERTY_KEY; }### Answer: @Test(expected = ValidationFailureException.class) public void modelCheckTest() throws Exception { EffectiveModel singleComputeModel = new EffectiveModelFactory().create(TestCsars.VALID_SINGLE_COMPUTE_WINDOWS_TEMPLATE, logMock()); TransformationContext context = setUpMockTransformationContext(singleComputeModel); KubernetesLifecycle lifecycle = plugin.getInstance(context); plugin.transform(lifecycle); }
### Question: SudoUtils { public static Optional<String> getSudoInstallCommand(String baseImage) { String imageName = baseImage.split(":")[0]; return Optional.ofNullable(IMAGE_MAP.get(imageName)); } static Optional<String> getSudoInstallCommand(String baseImage); }### Answer: @Test public void validate() { Optional<String> result = SudoUtils.getSudoInstallCommand(input); if (expected == null) { assertTrue(!result.isPresent()); return; } String r = result.get(); assertEquals(r, expected); }
### Question: ResourceFileCreator { public HashMap<String, String> getResourceYaml() throws JsonProcessingException { HashMap<String, String> result = new HashMap<>(); for (IKubernetesResource<?> resource : resources) { result.put(resource.getName(), resource.toYaml()); } return result; } ResourceFileCreator(Collection<Pod> pods); HashMap<String, String> getResourceYaml(); }### Answer: @Test public void testReplicationControllerCreation() { ResourceFileCreator resourceFileCreator = new ResourceFileCreator(Pod.getPods(TestNodeStacks.getLampNodeStacks(logMock()))); HashMap<String, String> result = null; try { result = resourceFileCreator.getResourceYaml(); } catch (JsonProcessingException e) { e.printStackTrace(); fail(); } String service = result.get(appServiceName); String deployment = result.get(appDeploymentName); Yaml yaml = new Yaml(); deploymentTest((Map) yaml.load(deployment)); }
### Question: MapperUtils { public static boolean anythingSet(OsCapability capability) { Optional[] optionals = { capability.getDistribution(), capability.getArchitecture(), capability.getType(), capability.getVersion() }; return Arrays.stream(optionals).anyMatch(Optional::isPresent); } static boolean anythingSet(OsCapability capability); static final Comparator<DockerImageTag> TAG_COMPARATOR_MINOR_VERSION; }### Answer: @Test public void testNoneSet() { assertFalse(anythingSet(new OsCapability(entity))); } @Test public void testOneSet() { assertTrue(anythingSet(new OsCapability(entity).setType(Type.LINUX))); }
### Question: CapabilityMapper { public String mapOsCapabilityToImageId(OsCapability osCapability) throws SdkClientException, ParseException, IllegalArgumentException { AmazonEC2 ec2 = AmazonEC2ClientBuilder.standard() .withCredentials(new AWSStaticCredentialsProvider(awsCredentials)) .withRegion(awsRegion) .build(); DescribeImagesRequest describeImagesRequest = new DescribeImagesRequest() .withFilters( new Filter("virtualization-type").withValues("hvm"), new Filter("root-device-type").withValues("ebs")) .withOwners("099720109477"); if (osCapability.getType().isPresent() && osCapability.getType().get().equals(OsCapability.Type.WINDOWS)) { describeImagesRequest.withFilters(new Filter("platform").withValues("windows")); } if (osCapability.getDistribution().isPresent()) { if (osCapability.getDistribution().get().equals(OsCapability.Distribution.UBUNTU)) { describeImagesRequest.withFilters(new Filter("name").withValues("ubuntu/images/")); } else { describeImagesRequest.withFilters(new Filter("name").withValues("" + osCapability.getDistribution() .toString() + "")); } } if (osCapability.getVersion().isPresent()) { describeImagesRequest.withFilters(new Filter("name").withValues("" + osCapability.getVersion().get() + "")); } if (osCapability.getArchitecture().isPresent()) { if (osCapability.getArchitecture().get().equals(OsCapability.Architecture.x86_64)) { describeImagesRequest.withFilters(new Filter("architecture").withValues(ARCH_x86_64)); } else if (osCapability.getArchitecture().get().equals(OsCapability.Architecture.x86_32)) { describeImagesRequest.withFilters(new Filter("architecture").withValues(ARCH_x86_32)); } else { throw new UnsupportedOperationException("This architecture is not supported " + osCapability .getArchitecture()); } } else { describeImagesRequest.withFilters(new Filter("architecture").withValues(ARCH_x86_64)); } try { DescribeImagesResult describeImagesResult = ec2.describeImages(describeImagesRequest); String imageId = processResult(describeImagesResult); logger.debug("ImageId is: '{}'", imageId); return imageId; } catch (SdkClientException se) { logger.error("Cannot connect to AWS to request image Ids"); throw se; } catch (ParseException pe) { logger.error("Error parsing date format of image creation dates"); throw pe; } catch (IllegalArgumentException ie) { logger.error("With the filters created from the OsCapability there are no valid images received"); throw ie; } } CapabilityMapper(String awsRegion, AWSCredentials awsCredentials, Logger logger); String mapOsCapabilityToImageId(OsCapability osCapability); String mapComputeCapabilityToInstanceType(ComputeCapability computeCapability, String distinction); Integer mapComputeCapabilityToRDSAllocatedStorage(ComputeCapability computeCapability); void mapDiskSize(ComputeCapability computeCapability, CloudFormationModule cfnModule, String nodeName); static final String EC2_DISTINCTION; static final String RDS_DISTINCTION; }### Answer: @Test public void testMapOsCapabilityToImageId() throws ParseException { try { String imageId = capabilityMapper.mapOsCapabilityToImageId(osCapability); Assert.assertThat(imageId, CoreMatchers.containsString("ami-")); } catch (SdkClientException se) { logger.info("Probably no internet connection / credentials, omitting test"); } }
### Question: CapabilityMapper { public String mapComputeCapabilityToInstanceType(ComputeCapability computeCapability, String distinction) throws IllegalArgumentException { Integer numCpus = computeCapability.getNumCpus().orElse(0); Integer memSize = computeCapability.getMemSizeInMb().orElse(0); final ImmutableList<InstanceType> instanceTypes; if (EC2_DISTINCTION.equals(distinction)) { instanceTypes = EC2_INSTANCE_TYPES; } else if (RDS_DISTINCTION.equals(distinction)) { instanceTypes = RDS_INSTANCE_CLASSES; } else { throw new IllegalArgumentException("Distinction not supported: " + distinction); } List<Integer> allNumCpus = instanceTypes.stream() .map(InstanceType::getNumCpus) .sorted() .collect(Collectors.toList()); List<Integer> allMemSizes = instanceTypes.stream() .map(InstanceType::getMemSize) .sorted() .collect(Collectors.toList()); try { logger.debug("Check numCpus: '{}'", numCpus); numCpus = checkValue(numCpus, allNumCpus); logger.debug("Check memSize: '{}'", memSize); memSize = checkValue(memSize, allMemSizes); } catch (IllegalArgumentException ie) { logger.error("Values numCpus: '{}' and/or memSize: are too big. No InstanceType found", numCpus, memSize); throw ie; } String instanceType = findCombination(numCpus, memSize, instanceTypes, allNumCpus, allMemSizes); logger.debug("InstanceType is: '{}'", instanceType); return instanceType; } CapabilityMapper(String awsRegion, AWSCredentials awsCredentials, Logger logger); String mapOsCapabilityToImageId(OsCapability osCapability); String mapComputeCapabilityToInstanceType(ComputeCapability computeCapability, String distinction); Integer mapComputeCapabilityToRDSAllocatedStorage(ComputeCapability computeCapability); void mapDiskSize(ComputeCapability computeCapability, CloudFormationModule cfnModule, String nodeName); static final String EC2_DISTINCTION; static final String RDS_DISTINCTION; }### Answer: @Test public void testMapComputeCapabilityToInstanceTypeEC2() { String instanceType = capabilityMapper.mapComputeCapabilityToInstanceType(containerCapability, EC2_DISTINCTION); Assert.assertEquals(instanceType, expectedEC2); } @Test public void testMapComputeCapabilityToInstanceTypeRDS() { String instanceType = capabilityMapper.mapComputeCapabilityToInstanceType(containerCapability, RDS_DISTINCTION); Assert.assertEquals(instanceType, expectedRDS); }
### Question: CapabilityMapper { public Integer mapComputeCapabilityToRDSAllocatedStorage(ComputeCapability computeCapability) { final Integer minSize = 20; final Integer maxSize = 6144; Integer diskSize = computeCapability.getDiskSizeInMb().orElse(minSize * 1000); diskSize = diskSize / 1000; if (diskSize > maxSize) { logger.debug("Disk size: '{}'", maxSize); return maxSize; } if (diskSize < minSize) { logger.debug("Disk size: '{}'", minSize); return minSize; } logger.debug("Disk size: '{}'", diskSize); return diskSize; } CapabilityMapper(String awsRegion, AWSCredentials awsCredentials, Logger logger); String mapOsCapabilityToImageId(OsCapability osCapability); String mapComputeCapabilityToInstanceType(ComputeCapability computeCapability, String distinction); Integer mapComputeCapabilityToRDSAllocatedStorage(ComputeCapability computeCapability); void mapDiskSize(ComputeCapability computeCapability, CloudFormationModule cfnModule, String nodeName); static final String EC2_DISTINCTION; static final String RDS_DISTINCTION; }### Answer: @Test public void testMapComputeCapabilityToRDSAllocatedStorage() { int newDiskSize = capabilityMapper.mapComputeCapabilityToRDSAllocatedStorage(containerCapability); Assert.assertEquals(newDiskSize, expectedDiskSize); }
### Question: CloudFormationFileCreator { public void writeScripts() throws IOException { writeFileUploadScript(); writeStackCreationScript(); writeDeployScript(); writeCleanUpScript(); } CloudFormationFileCreator(TransformationContext context, CloudFormationModule cfnModule); void copyFiles(); void writeScripts(); void copyUtilScripts(); void copyUtilDependencies(); void writeReadme(TransformationContext context); static final String CLI_COMMAND_CREATESTACK; static final String CLI_COMMAND_DELETESTACK; static final String CLI_COMMAND_DELETEBUCKET; static final String COMMAND_ECHO; static final String STRING_DELETESTACK; static final String CLI_PARAM_STACKNAME; static final String CLI_PARAM_TEMPLATEFILE; static final String CLI_PARAM_PARAMOVERRIDES; static final String CLI_PARAM_CAPABILITIES; static final String CLI_PARAM_BUCKET; static final String CLI_PARAM_FORCE; static final String CAPABILITY_IAM; static final String FILENAME_DEPLOY; static final String FILENAME_UPLOAD; static final String FILENAME_CREATE_STACK; static final String FILENAME_CLEANUP; static final String TEMPLATE_YAML; static final String CHANGE_TO_PARENT_DIRECTORY; static final String RELATIVE_DIRECTORY_PREFIX; static final String FILEPATH_CLOUDFORMATION; static final String FILEPATH_SCRIPTS_UTIL; static final String FILEPATH_FILES_UTIL; }### Answer: @Test public void testWriteScripts() throws Exception { cfnModule.addFileUpload(new FileUpload(FILENAME_TEST_FILE, FROM_CSAR)); fileCreator.writeScripts(); File deployScript = new File(targetDir, SCRIPTS_DIR_PATH + FILENAME_DEPLOY + BASH_FILE_ENDING); File fileUploadScript = new File(targetDir, SCRIPTS_DIR_PATH + FILENAME_UPLOAD + BASH_FILE_ENDING); File createStackScript = new File(targetDir, SCRIPTS_DIR_PATH + FILENAME_CREATE_STACK + BASH_FILE_ENDING); assertTrue(deployScript.exists()); assertTrue(fileUploadScript.exists()); String expectedDeployContent = SHEBANG + "\n" + SOURCE_UTIL_ALL + "\n" + SUBCOMMAND_EXIT + "\n" + "check \"aws\"\n" + "source file-upload.sh\n" + "source create-stack.sh\n"; String expectedFileUploadContent = SHEBANG + "\n" + SOURCE_UTIL_ALL + "\n" + SUBCOMMAND_EXIT + "\n" + "createBucket " + cfnModule.getBucketName() + " " + cfnModule.getAWSRegion() + "\n" + "uploadFile " + cfnModule.getBucketName() + " \"" + FILENAME_TEST_FILE + "\" \"" + FILEPATH_TARGET_TEST_FILE_LOCAL + "\"" + "\n"; String expectedCreateStackContent = SHEBANG + "\n" + SOURCE_UTIL_ALL + "\n" + SUBCOMMAND_EXIT + "\n" + CLI_COMMAND_CREATESTACK + CLI_PARAM_STACKNAME + cfnModule.getStackName() + " " + CLI_PARAM_TEMPLATEFILE + "../" + TEMPLATE_YAML + " " + CLI_PARAM_CAPABILITIES + " " + CAPABILITY_IAM + "\n"; String actualDeployContent = FileUtils.readFileToString(deployScript, StandardCharsets.UTF_8); String actualFileUploadContent = FileUtils.readFileToString(fileUploadScript, StandardCharsets.UTF_8); String actualCreateStackContent = FileUtils.readFileToString(createStackScript, StandardCharsets.UTF_8); assertEquals(expectedDeployContent, actualDeployContent); assertEquals(expectedFileUploadContent, actualFileUploadContent); assertEquals(expectedCreateStackContent, actualCreateStackContent); }
### Question: CloudFormationFileCreator { public void copyUtilScripts() throws IOException { List<String> utilScripts = IOUtils.readLines( getClass().getResourceAsStream(FILEPATH_SCRIPTS_UTIL + "scripts-list"), Charsets.UTF_8 ); logger.debug("Copying util scripts to the target artifact."); copyUtilFile(utilScripts, FILEPATH_SCRIPTS_UTIL, UTIL_DIR_PATH); } CloudFormationFileCreator(TransformationContext context, CloudFormationModule cfnModule); void copyFiles(); void writeScripts(); void copyUtilScripts(); void copyUtilDependencies(); void writeReadme(TransformationContext context); static final String CLI_COMMAND_CREATESTACK; static final String CLI_COMMAND_DELETESTACK; static final String CLI_COMMAND_DELETEBUCKET; static final String COMMAND_ECHO; static final String STRING_DELETESTACK; static final String CLI_PARAM_STACKNAME; static final String CLI_PARAM_TEMPLATEFILE; static final String CLI_PARAM_PARAMOVERRIDES; static final String CLI_PARAM_CAPABILITIES; static final String CLI_PARAM_BUCKET; static final String CLI_PARAM_FORCE; static final String CAPABILITY_IAM; static final String FILENAME_DEPLOY; static final String FILENAME_UPLOAD; static final String FILENAME_CREATE_STACK; static final String FILENAME_CLEANUP; static final String TEMPLATE_YAML; static final String CHANGE_TO_PARENT_DIRECTORY; static final String RELATIVE_DIRECTORY_PREFIX; static final String FILEPATH_CLOUDFORMATION; static final String FILEPATH_SCRIPTS_UTIL; static final String FILEPATH_FILES_UTIL; }### Answer: @Test public void copyUtilScripts() throws Exception { fileCreator.copyUtilScripts(); File createBucketUtilScript = new File(targetDir, UTIL_DIR_PATH + FILENAME_CREATE_BUCKET + BASH_FILE_ENDING); File uploadFileUtilScript = new File(targetDir, UTIL_DIR_PATH + FILENAME_UPLOAD_FILE + BASH_FILE_ENDING); assertTrue(createBucketUtilScript.exists()); assertTrue(uploadFileUtilScript.exists()); }
### Question: CloudFormationFileCreator { public void copyFiles() { List<String> fileUploadList = getFilePaths(getFileUploadByType(cfnModule.getFileUploadList(), FROM_CSAR)); logger.debug("Checking if files need to be copied."); if (!fileUploadList.isEmpty()) { logger.debug("Files to be copied found. Attempting to copy files to the target artifact."); fileUploadList.forEach((filePath) -> { String targetPath = FILEPATH_TARGET + filePath; try { cfnModule.getFileAccess().copy(filePath, targetPath); } catch (IOException e) { throw new TransformationFailureException("Copying of files to the target artifact failed.", e); } }); } else { logger.debug("No files to be copied found. Skipping copying of files."); } } CloudFormationFileCreator(TransformationContext context, CloudFormationModule cfnModule); void copyFiles(); void writeScripts(); void copyUtilScripts(); void copyUtilDependencies(); void writeReadme(TransformationContext context); static final String CLI_COMMAND_CREATESTACK; static final String CLI_COMMAND_DELETESTACK; static final String CLI_COMMAND_DELETEBUCKET; static final String COMMAND_ECHO; static final String STRING_DELETESTACK; static final String CLI_PARAM_STACKNAME; static final String CLI_PARAM_TEMPLATEFILE; static final String CLI_PARAM_PARAMOVERRIDES; static final String CLI_PARAM_CAPABILITIES; static final String CLI_PARAM_BUCKET; static final String CLI_PARAM_FORCE; static final String CAPABILITY_IAM; static final String FILENAME_DEPLOY; static final String FILENAME_UPLOAD; static final String FILENAME_CREATE_STACK; static final String FILENAME_CLEANUP; static final String TEMPLATE_YAML; static final String CHANGE_TO_PARENT_DIRECTORY; static final String RELATIVE_DIRECTORY_PREFIX; static final String FILEPATH_CLOUDFORMATION; static final String FILEPATH_SCRIPTS_UTIL; static final String FILEPATH_FILES_UTIL; }### Answer: @Test public void copyFiles() { cfnModule.addFileUpload(new FileUpload(FILENAME_TEST_FILE, FROM_CSAR)); fileCreator.copyFiles(); assertTrue(FILEPATH_TARGET_TEST_FILE.exists()); }
### Question: BashScript { public void append(String string) throws IOException { logger.debug("Appending {} to {}.sh", string, name); access.access(scriptPath).appendln(string).close(); } BashScript(PluginFileAccess access, String name); void append(String string); void checkEnvironment(String command); String getScriptPath(); static final String SHEBANG; static final String SOURCE_UTIL_ALL; static final String SUBCOMMAND_EXIT; }### Answer: @Test public void appendTest() throws IOException { String string = UUID.randomUUID().toString(); bashScript.append(string); File expectedGeneratedScript = new File(targetScriptFolder, fileName + ".sh"); List<String> result = IOUtils.readLines(new FileInputStream(expectedGeneratedScript)); assertEquals(string, result.get(result.size() - 1)); }
### Question: ZipUtility { public static boolean unzip(ZipInputStream zipIn, String destDirectory) throws IOException { File destDir = new File(destDirectory); if (!destDir.exists()) { destDir.mkdir(); } ZipEntry entry = zipIn.getNextEntry(); if (entry == null) { return false; } while (entry != null) { String filePath = destDirectory + File.separator + entry.getName(); if (!entry.isDirectory()) { extractFile(zipIn, filePath); } else { logger.trace("Creating directory: {}", filePath); File dir = new File(filePath); dir.mkdir(); } zipIn.closeEntry(); entry = zipIn.getNextEntry(); } zipIn.close(); return true; } static boolean unzip(ZipInputStream zipIn, String destDirectory); static void compressDirectory(File directory, OutputStream output); }### Answer: @Test public void unzipFile() throws IOException { ZipInputStream is = new ZipInputStream(new FileInputStream(TestCsars.VALID_LAMP_INPUT)); boolean result = ZipUtility.unzip(is, tmpdir.toString()); assertTrue(result); } @Test public void unzipNotAFile() throws IOException { ZipInputStream is = new ZipInputStream(new FileInputStream(TestCsars.VALID_LAMP_INPUT_TEMPLATE)); boolean result = ZipUtility.unzip(is, tmpdir.toString()); assertFalse(result); }
### Question: PluginFileAccess { public void copy(String relativePath) throws IOException { copy(relativePath, relativePath); } PluginFileAccess(File sourceDir, File targetDir, Log log); void copy(String relativePath); void copy(String relativeSourcePath, String relativeTargetPath); BufferedLineWriter access(String relativePath); BufferedOutputStream accessAsOutputStream(String relativePath); String read(String relativePath); String getAbsolutePath(String relativePath); void delete(String relativePath); void createDirectories(String relativePath); }### Answer: @Test public void copyFile() throws Exception { String filename = "testFile"; File file = new File(sourceDir, "testFile"); file.createNewFile(); File expectedFile = new File(targetDir, filename); assertFalse(expectedFile.exists()); access.copy(filename); assertTrue(expectedFile.exists()); } @Test public void copyDirRecursively() throws IOException { String dirname = "dir"; File dir = new File(sourceDir, dirname); dir.mkdir(); for (int i = 0; i < 10; i++) { new File(dir, String.valueOf(i)).createNewFile(); } File expectedDir = new File(targetDir, dirname); assertFalse(expectedDir.exists()); access.copy(dirname); assertTrue(expectedDir.exists()); for (int i = 0; i < 10; i++) { assertTrue(new File(expectedDir, String.valueOf(i)).exists()); } } @Test(expected = FileNotFoundException.class) public void copyInvalidPathThrowsException() throws IOException { String file = "nonexistent_file"; access.copy(file); } @Test public void copySourceToGivenTargetSuccessful() throws IOException { String filename = "some-file"; File file = new File(sourceDir, filename); file.createNewFile(); String alternativeDirName = "some-dir/nested/even-deeper"; File alternateDirectory = new File(targetDir, alternativeDirName); File targetFile = new File(alternateDirectory, filename); String relativeTargetPath = String.format("%s/%s", alternativeDirName, filename); access.copy(filename, relativeTargetPath); assertTrue(targetFile.exists()); }
### Question: PluginFileAccess { public BufferedLineWriter access(String relativePath) throws IOException { File target = new File(targetDir, relativePath); target.getParentFile().mkdirs(); try { return new BufferedLineWriter(new FileWriter(target, true)); } catch (FileNotFoundException e) { logger.error("Failed to create OutputStream for file '{}'", target); throw e; } } PluginFileAccess(File sourceDir, File targetDir, Log log); void copy(String relativePath); void copy(String relativeSourcePath, String relativeTargetPath); BufferedLineWriter access(String relativePath); BufferedOutputStream accessAsOutputStream(String relativePath); String read(String relativePath); String getAbsolutePath(String relativePath); void delete(String relativePath); void createDirectories(String relativePath); }### Answer: @Test public void write() throws Exception { String secondString = "second_test_string"; access.access(targetFileName).appendln(fileContent).close(); access.access(targetFileName).append(secondString).close(); assertTrue(targetFile.isFile()); List<String> result = IOUtils.readLines(new FileInputStream(targetFile)); assertEquals(fileContent, result.get(result.size() - 2)); assertEquals(secondString, result.get(result.size() - 1)); } @Test(expected = IOException.class) public void writePathIsDirectoryThrowsException() throws IOException { targetFile.mkdir(); access.access(targetFileName); } @Test public void writeSubDirectoriesGetAutomaticallyCreated() throws IOException { String path = "test/some/subdirs/filename"; access.access(path).append(fileContent).close(); File targetFile = new File(targetDir, path); assertTrue(targetFile.isFile()); assertEquals(fileContent, FileUtils.readFileToString(targetFile)); }
### Question: PluginFileAccess { public String read(String relativePath) throws IOException { File source = new File(sourceDir, relativePath); try { return FileUtils.readFileToString(source); } catch (IOException e) { logger.error("Failed to read content from file '{}'", source); throw e; } } PluginFileAccess(File sourceDir, File targetDir, Log log); void copy(String relativePath); void copy(String relativeSourcePath, String relativeTargetPath); BufferedLineWriter access(String relativePath); BufferedOutputStream accessAsOutputStream(String relativePath); String read(String relativePath); String getAbsolutePath(String relativePath); void delete(String relativePath); void createDirectories(String relativePath); }### Answer: @Test public void readSuccessful() throws IOException { String path = "file"; File file = new File(sourceDir, path); InputStream inputStream = IOUtils.toInputStream(fileContent, "UTF-8"); FileUtils.copyInputStreamToFile(inputStream, file); String result = access.read(path); assertNotNull(result); assertEquals(fileContent, result); } @Test(expected = IOException.class) public void readFileNotExists() throws IOException { String path = "nonexistent-file"; access.read(path); }
### Question: PluginFileAccess { public String getAbsolutePath(String relativePath) throws FileNotFoundException { File targetFile = new File(targetDir, relativePath); if (targetFile.exists()) { return targetFile.getAbsolutePath(); } else { throw new FileNotFoundException(String.format("File '%s' not found", targetFile)); } } PluginFileAccess(File sourceDir, File targetDir, Log log); void copy(String relativePath); void copy(String relativeSourcePath, String relativeTargetPath); BufferedLineWriter access(String relativePath); BufferedOutputStream accessAsOutputStream(String relativePath); String read(String relativePath); String getAbsolutePath(String relativePath); void delete(String relativePath); void createDirectories(String relativePath); }### Answer: @Test public void getAbsolutePathSuccess() throws IOException { String filename = "some-source-file"; File sourceFile = new File(targetDir, filename); sourceFile.createNewFile(); String result = access.getAbsolutePath(filename); assertEquals(sourceFile.getAbsolutePath(), result); } @Test(expected = FileNotFoundException.class) public void getAbsolutePathNoSuchFile() throws FileNotFoundException { String filename = "nonexistent-file"; access.getAbsolutePath(filename); fail("getAbsolutePath() should have raised FileNotFoundException."); }
### Question: PluginFileAccess { public void delete(String relativePath) { File file = new File(targetDir, relativePath); FileUtils.deleteQuietly(file); } PluginFileAccess(File sourceDir, File targetDir, Log log); void copy(String relativePath); void copy(String relativeSourcePath, String relativeTargetPath); BufferedLineWriter access(String relativePath); BufferedOutputStream accessAsOutputStream(String relativePath); String read(String relativePath); String getAbsolutePath(String relativePath); void delete(String relativePath); void createDirectories(String relativePath); }### Answer: @Test public void delete() throws IOException { String filename = "some-file"; File file = new File(targetDir, filename); file.createNewFile(); assertTrue(file.exists()); access.delete(filename); assertFalse(file.exists()); }
### Question: PluginFileAccess { public void createDirectories(String relativePath) { File targetFolder = new File(targetDir, relativePath); targetFolder.mkdirs(); } PluginFileAccess(File sourceDir, File targetDir, Log log); void copy(String relativePath); void copy(String relativeSourcePath, String relativeTargetPath); BufferedLineWriter access(String relativePath); BufferedOutputStream accessAsOutputStream(String relativePath); String read(String relativePath); String getAbsolutePath(String relativePath); void delete(String relativePath); void createDirectories(String relativePath); }### Answer: @Test public void createFolder() { String folder = "some-folder/some-subfolder/some-subsubfolder"; access.createDirectories(folder); File expectedFolder = new File(targetDir, folder); assertTrue(expectedFolder.exists()); }
### Question: LogImpl implements Log { @Override public List<LogEntry> getLogEntries(int first, int last) { return getLogEntries(first, last, true); } LogImpl(File logFile); @Override void addLogEntry(LogEntry e); @Override List<LogEntry> getLogEntries(int first, int last); @Override List<LogEntry> getLogEntries(int firstIndex); @Override Logger getLogger(String context); @Override Logger getLogger(Class context); @Override void close(); }### Answer: @Test public void getAllLogEntries() throws Exception { logger.info("Trying to retrieve complete log"); List<LogEntry> logs = log.getLogEntries(0); logger.info("Checking length"); assertTrue(logs.size() == 100); logger.info("Checking data"); for (int i = 0; i < logs.size(); i++) { LogEntry e = logs.get(i); assertEquals((String.format("Log-Message-%d", i)), e.getMessage()); } logger.info("Done"); } @Test public void getPartialLogEntries() throws Exception { logger.info("Trying to log from index 50"); List<LogEntry> logs = log.getLogEntries(50); logger.info("Checking length"); assertTrue(logs.size() == 50); logger.info("Checking data"); for (int i = 50; i < logs.size(); i++) { LogEntry e = logs.get(i); assertEquals(String.format("Log-Message-%d", i), e.getMessage()); } logger.info("Done"); } @Test public void getLogsFromOuterBound() throws Exception { logger.info("Trying to get logs from index 100"); assertSame(0, log.getLogEntries(101).size()); logger.info("Done"); } @Test public void getFirstTenLogEntries() throws Exception { logger.info("Trying to log from index 0 to 10"); List<LogEntry> logs = log.getLogEntries(0, 9); logger.info("Checking length"); assertSame(10, logs.size()); logger.info("Checking data"); for (int i = 0; i < logs.size(); i++) { LogEntry e = logs.get(i); assertEquals(String.format("Log-Message-%d", i), e.getMessage()); } logger.info("Done"); } @Test(expected = IllegalArgumentException.class) public void getLogEntriesWithInvalidBounds() throws Exception { logger.info("Trying to log from index 0 to 10"); log.getLogEntries(100, 10); } @Test public void logReadsLogfileWithIllegalLogsAndIgnoresThem() throws IOException { PrintWriter pw = new PrintWriter(new BufferedWriter(new FileWriter(logfile))); pw.write("log level which does not adhere to logging format"); log = new LogImpl(logfile); List<LogEntry> entries = log.getLogEntries(0); assertEquals(0, entries.size()); }
### Question: TransformationServiceImpl implements TransformationService { @Override public Transformation createTransformation(Csar csar, Platform targetPlatform) throws PlatformNotFoundException { return transformationDao.create(csar, targetPlatform); } @Autowired TransformationServiceImpl( TransformationDao transformationDao, PluginService pluginService, @Lazy CsarDao csarDao, ArtifactService artifactService ); @Override Transformation createTransformation(Csar csar, Platform targetPlatform); @Override boolean startTransformation(Transformation transformation); @Override boolean abortTransformation(Transformation transformation); @Override boolean deleteTransformation(Transformation transformation); }### Answer: @Test(timeout = TEST_EXECUTION_TIMEOUT_MS) public void createTransformation() throws Exception { Transformation expected = new TransformationImpl(csar, PLATFORM1, log, modelMock()); Transformation transformation = service.createTransformation(csar, PLATFORM1); assertTrue(csar.getTransformation(PLATFORM1.id).isPresent()); assertEquals(expected, transformation); } @Test(timeout = TEST_EXECUTION_TIMEOUT_MS) public void transformationCreationNoProps() throws Exception { Transformation t = service.createTransformation(csar, PASSING_DUMMY.getPlatform()); assertTrue(csar.getTransformation(PASSING_DUMMY.getPlatform().id).isPresent()); assertNotNull(t); assertEquals(TransformationState.READY, t.getState()); } @Test(expected = PlatformNotFoundException.class) public void transformationCreationPlatformNotFound() throws PlatformNotFoundException { service.createTransformation(csar, PLATFORM_NOT_SUPPORTED); } @Test(timeout = TEST_EXECUTION_TIMEOUT_MS) public void transformationCreationInputNeeded() throws Exception { Transformation t = service.createTransformation(csar, PLATFORM_PASSING_INPUT_REQUIRED_DUMMY); assertTrue(csar.getTransformation(PLATFORM_PASSING_INPUT_REQUIRED_DUMMY.id).isPresent()); assertNotNull(t); assertEquals(TransformationState.INPUT_REQUIRED, t.getState()); }
### Question: TransformationServiceImpl implements TransformationService { @Override public boolean startTransformation(Transformation transformation) { if (transformation.getState() == TransformationState.READY) { Future<?> taskFuture = executor.submit( new ExecutionTask( transformation, artifactService, pluginService, csarDao.getContentDir(transformation.getCsar()), transformationDao.getContentDir(transformation) ) ); tasks.put(transformation, taskFuture); return true; } return false; } @Autowired TransformationServiceImpl( TransformationDao transformationDao, PluginService pluginService, @Lazy CsarDao csarDao, ArtifactService artifactService ); @Override Transformation createTransformation(Csar csar, Platform targetPlatform); @Override boolean startTransformation(Transformation transformation); @Override boolean abortTransformation(Transformation transformation); @Override boolean deleteTransformation(Transformation transformation); }### Answer: @Test(timeout = TEST_EXECUTION_TIMEOUT_MS) public void startTransformation() throws Exception { Transformation t = startTransformationInternal(TransformationState.DONE, PASSING_DUMMY.getPlatform()); assertNotNull(t); }
### Question: TransformationServiceImpl implements TransformationService { @Override public boolean abortTransformation(Transformation transformation) { Future<?> task = tasks.get(transformation); if (task == null) { return false; } if (task.isDone()) { return false; } return task.cancel(true); } @Autowired TransformationServiceImpl( TransformationDao transformationDao, PluginService pluginService, @Lazy CsarDao csarDao, ArtifactService artifactService ); @Override Transformation createTransformation(Csar csar, Platform targetPlatform); @Override boolean startTransformation(Transformation transformation); @Override boolean abortTransformation(Transformation transformation); @Override boolean deleteTransformation(Transformation transformation); }### Answer: @Test(timeout = TEST_EXECUTION_TIMEOUT_MS) public void stopNotStarted() throws Exception { transformationCreationNoProps(); Transformation t = csar.getTransformations().get(PASSING_DUMMY.getPlatform().id); assertFalse(service.abortTransformation(t)); }
### Question: TransformationServiceImpl implements TransformationService { @Override public boolean deleteTransformation(Transformation transformation) { if (transformation.getState() == TransformationState.TRANSFORMING) { return false; } transformationDao.delete(transformation); tasks.remove(transformation); return true; } @Autowired TransformationServiceImpl( TransformationDao transformationDao, PluginService pluginService, @Lazy CsarDao csarDao, ArtifactService artifactService ); @Override Transformation createTransformation(Csar csar, Platform targetPlatform); @Override boolean startTransformation(Transformation transformation); @Override boolean abortTransformation(Transformation transformation); @Override boolean deleteTransformation(Transformation transformation); }### Answer: @Test(timeout = TEST_EXECUTION_TIMEOUT_MS) public void deleteTransformation() throws Exception { Transformation transformation = new TransformationImpl(csar, PLATFORM1, log, modelMock()); csar.getTransformations().put(PLATFORM1.id, transformation); service.deleteTransformation(transformation); assertFalse(csar.getTransformations().containsValue(transformation)); }
### Question: TransformationFilesystemDao implements TransformationDao { @Override public File getRootDir(Transformation transformation) { return getRootDir(transformation.getCsar(), transformation.getPlatform()); } @Autowired TransformationFilesystemDao(PlatformService platformService, EffectiveModelFactory effectiveModelFactory); @Override Transformation create(Csar csar, Platform platform); @Override void delete(Transformation transformation); @Override Optional<Transformation> find(Csar csar, Platform platform); @Override List<Transformation> find(Csar csar); @Override TargetArtifact createTargetArtifact(Transformation transformation); @Override File getRootDir(Transformation transformation); @Override File getContentDir(Transformation transformation); @Override void setCsarDao(CsarDao csarDao); final static String ARTIFACT_FAILED_REGEX; final static String ARTIFACT_SUCCESSFUL_REGEX; final static String CONTENT_DIR; }### Answer: @Test public void getRootDir() { doReturn(new File(new File(tmpdir, csar.getIdentifier()), CsarFilesystemDao.TRANSFORMATION_DIR)).when(csarDao).getTransformationsDir(csar); doReturn(new File(tmpdir, csar.getIdentifier())).when(csarDao).getRootDir(csar); File expectedParent = new File(csarDao.getRootDir(csar), CsarFilesystemDao.TRANSFORMATION_DIR); File expected = new File(expectedParent, PLATFORM1.id); File actual = transformationDao.getRootDir(transformation); assertEquals(expected, actual); }
### Question: TransformationFilesystemDao implements TransformationDao { @Override public Transformation create(Csar csar, Platform platform) throws PlatformNotFoundException { if (!platformService.isSupported(platform)) { throw new PlatformNotFoundException(); } Optional<Transformation> oldTransformation = csar.getTransformation(platform.id); if (oldTransformation.isPresent()) { delete(oldTransformation.get()); } else { delete(getRootDir(csar, platform)); } Transformation transformation = createTransformation(csar, platform); csar.getTransformations().put(platform.id, transformation); getContentDir(transformation).mkdirs(); return transformation; } @Autowired TransformationFilesystemDao(PlatformService platformService, EffectiveModelFactory effectiveModelFactory); @Override Transformation create(Csar csar, Platform platform); @Override void delete(Transformation transformation); @Override Optional<Transformation> find(Csar csar, Platform platform); @Override List<Transformation> find(Csar csar); @Override TargetArtifact createTargetArtifact(Transformation transformation); @Override File getRootDir(Transformation transformation); @Override File getContentDir(Transformation transformation); @Override void setCsarDao(CsarDao csarDao); final static String ARTIFACT_FAILED_REGEX; final static String ARTIFACT_SUCCESSFUL_REGEX; final static String CONTENT_DIR; }### Answer: @Test public void createDeletesOldFilesAndCreatesBlankDir() { List<File> files = createRandomFiles(transformationRootDir); assertNotEquals(0, transformationRootDir.list().length); when(platformService.isSupported(PLATFORM1)).thenReturn(true); transformationDao.create(csar, PLATFORM1); for (File file : files) { assertFalse(file.exists()); } assertTrue(transformationRootDir.exists()); File[] result = transformationRootDir.listFiles(); assertEquals(1, result.length); assertEquals(TransformationFilesystemDao.CONTENT_DIR, result[0].getName()); assertEquals(1, result[0].list().length); }
### Question: TransformationFilesystemDao implements TransformationDao { @Override public void delete(Transformation transformation) { transformation.getCsar().getTransformations().remove(transformation.getPlatform().id); File transformationDir = getRootDir(transformation); delete(transformationDir); } @Autowired TransformationFilesystemDao(PlatformService platformService, EffectiveModelFactory effectiveModelFactory); @Override Transformation create(Csar csar, Platform platform); @Override void delete(Transformation transformation); @Override Optional<Transformation> find(Csar csar, Platform platform); @Override List<Transformation> find(Csar csar); @Override TargetArtifact createTargetArtifact(Transformation transformation); @Override File getRootDir(Transformation transformation); @Override File getContentDir(Transformation transformation); @Override void setCsarDao(CsarDao csarDao); final static String ARTIFACT_FAILED_REGEX; final static String ARTIFACT_SUCCESSFUL_REGEX; final static String CONTENT_DIR; }### Answer: @Test public void delete() { createRandomFiles(transformationRootDir); transformationDao.delete(transformation); assertFalse(transformationRootDir.exists()); }
### Question: TransformationFilesystemDao implements TransformationDao { @Override public Optional<Transformation> find(Csar csar, Platform platform) { Set<Transformation> transformations = readFromDisk(csar); return Optional.ofNullable(transformations.stream() .filter(transformation -> transformation.getCsar().equals(csar) && transformation.getPlatform().equals(platform)) .findFirst().orElse(null)); } @Autowired TransformationFilesystemDao(PlatformService platformService, EffectiveModelFactory effectiveModelFactory); @Override Transformation create(Csar csar, Platform platform); @Override void delete(Transformation transformation); @Override Optional<Transformation> find(Csar csar, Platform platform); @Override List<Transformation> find(Csar csar); @Override TargetArtifact createTargetArtifact(Transformation transformation); @Override File getRootDir(Transformation transformation); @Override File getContentDir(Transformation transformation); @Override void setCsarDao(CsarDao csarDao); final static String ARTIFACT_FAILED_REGEX; final static String ARTIFACT_SUCCESSFUL_REGEX; final static String CONTENT_DIR; }### Answer: @Test public void findFromSpecificCsar() { when(csarDao.getTransformationsDir(csar)).thenReturn(tmpdir); createRandomFiles(new File(tmpdir, PLATFORM1.id)); createRandomFiles(new File(tmpdir, PLATFORM2.id)); createRandomFiles(new File(tmpdir, PLATFORM_NOT_SUPPORTED.id)); when(platformService.findPlatformById(PLATFORM1.id)).thenReturn(Optional.of(PLATFORM1)); when(platformService.findPlatformById(PLATFORM2.id)).thenReturn(Optional.of(PLATFORM2)); List<Transformation> transformations = transformationDao.find(csar); assertEquals(2, transformations.size()); } @Test public void findSpecificTransformation() { when(csarDao.getTransformationsDir(csar)).thenReturn(tmpdir); when(platformService.findPlatformById(PLATFORM1.id)).thenReturn(Optional.of(PLATFORM1)); when(platformService.findPlatformById(PLATFORM2.id)).thenReturn(Optional.of(PLATFORM2)); createRandomFiles(new File(tmpdir, PLATFORM1.id)); createRandomFiles(new File(tmpdir, PLATFORM2.id)); Transformation transformation = transformationDao.find(csar, PLATFORM1).get(); assertNotNull(transformation); assertEquals(csar, transformation.getCsar()); assertEquals(PLATFORM1, transformation.getPlatform()); Optional<Transformation> notStoredTransformation = transformationDao.find(csar, PLATFORM3); assertFalse(notStoredTransformation.isPresent()); }
### Question: CsarImpl implements Csar { @Override public Optional<Transformation> getTransformation(String platformId) { Transformation t = transformations.get(platformId); return Optional.ofNullable(t); } CsarImpl(File rootDir, String identifier, Log log); @Override boolean validate(); @Override Map<String, Transformation> getTransformations(); @Override Optional<Transformation> getTransformation(String platformId); @Override String getIdentifier(); @Override Log getLog(); @Override List<LifecyclePhase> getLifecyclePhases(); @Override LifecyclePhase getLifecyclePhase(Phase phase); @Override boolean equals(Object obj); @Override int hashCode(); @Override void setTransformations(List<Transformation> transformations); @Override File getContentDir(); @Override File getTemplate(); @Override String toString(); }### Answer: @Test public void getTransformationsForSpecificPlatform() throws Exception { Optional<Transformation> result = csar.getTransformation(PLATFORM1.id); assertTrue(result.isPresent()); assertEquals(transformation1, result.get()); }
### Question: CsarFilesystemDao implements CsarDao { @Override public Csar create(String identifier, InputStream inputStream) { csarMap.remove(identifier); File csarDir = setupDir(identifier); Csar csar = new CsarImpl(getRootDir(identifier), identifier, getLog(identifier)); File transformationDir = new File(csarDir, TRANSFORMATION_DIR); transformationDir.mkdir(); unzip(identifier, inputStream, csar, csarDir); csarMap.put(identifier, csar); return csar; } @Autowired CsarFilesystemDao(Preferences preferences, @Lazy TransformationDao transformationDao); @PostConstruct void init(); @Override Csar create(String identifier, InputStream inputStream); @Override void delete(String identifier); @Override Optional<Csar> find(String identifier); @Override List<Csar> findAll(); @Override File getRootDir(Csar csar); @Override File getContentDir(Csar csar); @Override File getTransformationsDir(Csar csar); final static String CSARS_DIR; final static String TRANSFORMATION_DIR; }### Answer: @Test public void create() throws Exception { String identifier = "my-csar-checkStateNoPropsSet"; File csarFile = TestCsars.VALID_MINIMAL_DOCKER; InputStream csarStream = new FileInputStream(csarFile); csarDao.create(identifier, csarStream); File csarFolder = new File(generalCsarsDir, identifier); File contentFolder = new File(csarFolder, CsarImpl.CONTENT_DIR); File transformationFolder = new File(csarFolder, CsarFilesystemDao.TRANSFORMATION_DIR); assertTrue(contentFolder.isDirectory()); assertTrue(transformationFolder.isDirectory()); assertTrue(contentFolder.list().length == 1); }
### Question: CsarFilesystemDao implements CsarDao { @Override public void delete(String identifier) { File csarDir = new File(dataDir, identifier); try { FileUtils.deleteDirectory(csarDir); csarMap.remove(identifier); logger.info("Deleted csar directory '{}'", csarDir); } catch (IOException e) { logger.error("Failed to delete csar directory with identifier '{}'", identifier, e); } } @Autowired CsarFilesystemDao(Preferences preferences, @Lazy TransformationDao transformationDao); @PostConstruct void init(); @Override Csar create(String identifier, InputStream inputStream); @Override void delete(String identifier); @Override Optional<Csar> find(String identifier); @Override List<Csar> findAll(); @Override File getRootDir(Csar csar); @Override File getContentDir(Csar csar); @Override File getTransformationsDir(Csar csar); final static String CSARS_DIR; final static String TRANSFORMATION_DIR; }### Answer: @Test public void deleteCsarRemovesDataOnDisk() throws Exception { String identifier = createFakeCsarDirectories(1)[0]; csarDao.delete(identifier); File csarDir = new File(generalCsarsDir, identifier); assertFalse(csarDir.exists()); }
### Question: CsarFilesystemDao implements CsarDao { @Override public Optional<Csar> find(String identifier) { Csar csar = csarMap.get(identifier); return Optional.ofNullable(csar); } @Autowired CsarFilesystemDao(Preferences preferences, @Lazy TransformationDao transformationDao); @PostConstruct void init(); @Override Csar create(String identifier, InputStream inputStream); @Override void delete(String identifier); @Override Optional<Csar> find(String identifier); @Override List<Csar> findAll(); @Override File getRootDir(Csar csar); @Override File getContentDir(Csar csar); @Override File getTransformationsDir(Csar csar); final static String CSARS_DIR; final static String TRANSFORMATION_DIR; }### Answer: @Test public void find() { String identifier = createFakeCsarDirectories(1)[0]; csarDao = new CsarFilesystemDao(preferences, transformationDao); csarDao.init(); Optional<Csar> csar = csarDao.find(identifier); assertTrue(csar.isPresent()); assertEquals(identifier, csar.get().getIdentifier()); }
### Question: CsarFilesystemDao implements CsarDao { @Override public List<Csar> findAll() { List<Csar> csarList = new ArrayList<>(); csarList.addAll(csarMap.values()); return csarList; } @Autowired CsarFilesystemDao(Preferences preferences, @Lazy TransformationDao transformationDao); @PostConstruct void init(); @Override Csar create(String identifier, InputStream inputStream); @Override void delete(String identifier); @Override Optional<Csar> find(String identifier); @Override List<Csar> findAll(); @Override File getRootDir(Csar csar); @Override File getContentDir(Csar csar); @Override File getTransformationsDir(Csar csar); final static String CSARS_DIR; final static String TRANSFORMATION_DIR; }### Answer: @Test public void findAll() { int numberOfCsars = 10; createFakeCsarDirectories(numberOfCsars); csarDao = new CsarFilesystemDao(preferences, transformationDao); csarDao.init(); List<Csar> csarList = csarDao.findAll(); assertEquals("Correct amount of csars returned", numberOfCsars, csarList.size()); }
### Question: ServiceGraph extends SimpleDirectedGraph<Entity, Connection> { public Optional<Entity> getEntity(List<String> path) { Entity current = root; for (String segment : path) { Optional<Entity> child = current.getChild(segment); if (child.isPresent()) { current = child.get(); } else { return Optional.empty(); } } return Optional.of(current); } ServiceGraph(Log log); ServiceGraph(File template, Log log); void finalizeGraph(); boolean inputsValid(); Map<String, InputProperty> getInputs(); Map<String, OutputProperty> getOutputs(); void addEntity(Entity entity); Optional<Entity> getEntity(List<String> path); Optional<Entity> getEntity(EntityId id); Entity getEntityOrThrow(EntityId id); Iterator<Entity> iterator(EntityId id); void replaceEntity(Entity source, Entity target); void addConnection(Entity source, Entity target, String connectionName); Collection<Entity> getChildren(EntityId id); Logger getLogger(); Log getLog(); }### Answer: @Test public void requirementTest() { currentFile = REQUIREMENT; Optional<Entity> fulfiller = getGraph().getEntity(Lists.newArrayList("topology_template", "node_templates", "test-node", "requirements", "test-requirement1", "node")); assertTrue(fulfiller.isPresent()); Optional<Entity> fulfiller2 = getGraph().getEntity(Lists.newArrayList("topology_template", "node_templates", "test-node", "requirements", "test-requirement2", "node")); assertTrue(fulfiller2.isPresent()); MappingEntity capabilityEntity = (MappingEntity) getGraph().getEntity(new EntityId(Lists.newArrayList( "topology_template", "node_templates", "test-node", "requirements", "test-requirement2", "capability"))).get(); DatabaseEndpointCapability capability = TypeWrapper.wrapTypedElement(capabilityEntity); assertNotNull(capability); MappingEntity relationshipEntity = (MappingEntity) getGraph().getEntity(new EntityId(Lists.newArrayList( "topology_template", "node_templates", "test-node", "requirements", "test-requirement2", "relationship"))).get(); ConnectsTo relationship = TypeWrapper.wrapTypedElement(relationshipEntity); assertNotNull(relationship); assertEquals(Lists.newArrayList("1", "2"), getList("topology_template", "node_templates", "test-node", "requirements", "test-requirement2", "occurrences")); }
### Question: ServiceGraph extends SimpleDirectedGraph<Entity, Connection> { public boolean inputsValid() { Map<String, InputProperty> inputs = getInputs(); return inputs.values().stream() .allMatch(InputProperty::isValid); } ServiceGraph(Log log); ServiceGraph(File template, Log log); void finalizeGraph(); boolean inputsValid(); Map<String, InputProperty> getInputs(); Map<String, OutputProperty> getOutputs(); void addEntity(Entity entity); Optional<Entity> getEntity(List<String> path); Optional<Entity> getEntity(EntityId id); Entity getEntityOrThrow(EntityId id); Iterator<Entity> iterator(EntityId id); void replaceEntity(Entity source, Entity target); void addConnection(Entity source, Entity target, String connectionName); Collection<Entity> getChildren(EntityId id); Logger getLogger(); Log getLog(); }### Answer: @Test public void allInputsSetTest() { currentFile = INPUT_NO_VALUE; ServiceGraph graph = getGraph(); assertFalse(graph.inputsValid()); currentFile = INPUT; graph = getGraph(); assertTrue(graph.inputsValid()); }
### Question: NamingUtil { public static String getUniqueName(final String suggestedName, final Set<String> existingNames) { String name = suggestedName != null ? suggestedName.trim() : ""; if (name.isEmpty()) name = "UNDEFINED"; if (existingNames != null && !existingNames.isEmpty()) { if (!isNameTaken(name, existingNames)) return name; Matcher m = PATTERN.matcher(name); int start = 0; if (m.matches()) { name = name.substring(0, m.start(1) - 1); start = Integer.decode(m.group(1)); } for (int i = start; true; i++) { final String numberedName = name + "(" + (i + 1) + ")"; if (!isNameTaken(numberedName, existingNames)) return numberedName; } } return name; } private NamingUtil(); static String getUniqueName(final String suggestedName, final Set<String> existingNames); }### Answer: @Test public void testGetUniqueName() { Set<String> names = Sets.newSet( "My Name A", "My Name B", "My Name B(1)", "My Name B(3)", "My Name C(1)", "My Name D_1", "My Name E (1)" ); assertEquals("My Name", NamingUtil.getUniqueName("My Name", names)); assertEquals("My Name", NamingUtil.getUniqueName(" My Name \t", names)); assertEquals("My Name a", NamingUtil.getUniqueName("My Name a", names)); assertEquals("My Name A(1)", NamingUtil.getUniqueName("My Name A", names)); assertEquals("My Name A(1)", NamingUtil.getUniqueName("My Name A(1)", names)); assertEquals("My Name A(01)", NamingUtil.getUniqueName("My Name A(01)", names)); assertEquals("My Name A_1", NamingUtil.getUniqueName("My Name A_1", names)); assertEquals("My Name B(2)", NamingUtil.getUniqueName("My Name B", names)); assertEquals("My Name B(4)", NamingUtil.getUniqueName("My Name B(3)", names)); assertEquals("My Name B(2)", NamingUtil.getUniqueName("My Name B(2)", names)); assertEquals("My Name C(2)", NamingUtil.getUniqueName("My Name C(1)", names)); assertEquals("My Name D", NamingUtil.getUniqueName("My Name D", names)); assertEquals("My Name D(1)", NamingUtil.getUniqueName("My Name D(1)", names)); assertEquals("My Name E (2)", NamingUtil.getUniqueName("My Name E (1)", names)); }
### Question: LinearNumberInterpolator { public LinearNumberInterpolator(double lowerDomain, double upperDomain, double lowerRange, double upperRange) { this.lowerDomain = lowerDomain; this.lowerRange = lowerRange; this.upperDomain = upperDomain; this.upperRange = upperRange; } LinearNumberInterpolator(double lowerDomain, double upperDomain, double lowerRange, double upperRange); double getRangeValue(double domainValue); LinearNumberInterpolator withDomainCutoff(final double lowerValue, final double upperValue); }### Answer: @Test public void testLinearNumberInterpolator() { LinearNumberInterpolator interpolator = new LinearNumberInterpolator(0.5, 1.0, 0.0, 5.0); assertDouble(0.0, interpolator.getRangeValue(0.5)); assertDouble(1.0, interpolator.getRangeValue(0.6)); assertDouble(2.0, interpolator.getRangeValue(0.7)); assertDouble(3.0, interpolator.getRangeValue(0.8)); assertDouble(4.0, interpolator.getRangeValue(0.9)); assertDouble(5.0, interpolator.getRangeValue(1.0)); assertDouble(-1.0, interpolator.getRangeValue(0.4)); assertDouble(6.0, interpolator.getRangeValue(1.1)); }
### Question: PathUtil { private PathUtil() {} private PathUtil(); static List<Path> dataSetsRoots(Collection<DataSetParameters> dataSets); static Path commonRoot(List<Path> paths); static Path commonRoot(Path p1, Path p2); }### Answer: @Test public void testPathUtil() { { Path c = PathUtil.commonRoot(plist("/a/b/c", "/a/b/d")); assertEquals(Paths.get("/a/b"), c); } { Path c = PathUtil.commonRoot(plist("/a/b/c/d/e", "/a/b/c/x/y", "/a/b/q/w")); assertEquals(Paths.get("/a/b"), c); } { Path c = PathUtil.commonRoot(plist("/x/y/z", "/a/b/d")); assertEquals(Paths.get("/"), c); } { Path c = PathUtil.commonRoot(plist("/", "/a/b/d")); assertEquals(Paths.get("/"), c); } { Path c = PathUtil.commonRoot(plist("/x/y/z", "a/b/d")); assertNull(c); } { Path c = PathUtil.commonRoot(plist("/x/y/z", null)); assertNull(c); } }
### Question: SimilarityKey { public SimilarityKey(String geneSet1, String geneSet2, String interaction, String name) { Objects.requireNonNull(geneSet1); Objects.requireNonNull(interaction); Objects.requireNonNull(geneSet2); this.geneSet1 = geneSet1; this.geneSet2 = geneSet2; this.interaction = interaction; this.name = name; } SimilarityKey(String geneSet1, String geneSet2, String interaction, String name); String getGeneSet1(); String getGeneSet2(); String getInteraction(); boolean isCompound(); String getName(); @Override int hashCode(); @Override boolean equals(Object o); String getCompoundName(); @Override String toString(); final String geneSet1; final String geneSet2; final String interaction; final String name; }### Answer: @Test public void testSimilarityKey() { SimilarityKey k1 = new SimilarityKey("A", "B", "i", null); SimilarityKey k1p = new SimilarityKey("A", "B", "i", null); SimilarityKey k2 = new SimilarityKey("B", "A", "i", null); SimilarityKey k3 = new SimilarityKey("D", "C", "x", null); SimilarityKey k4 = new SimilarityKey("A", "B", "x", null); assertEquals(k1, k1); assertEquals(k1, k1p); assertEquals(k1, k2); assertEquals(k2, k1); assertNotEquals(k1, k3); assertNotEquals(k1, k4); Set<SimilarityKey> keys = new HashSet<>(); Collections.addAll(keys, k1, k1p, k2, k3); assertEquals(2, keys.size()); }
### Question: SimilarityKey { @Override public int hashCode() { return Objects.hash(geneSet1.hashCode() + geneSet2.hashCode(), interaction, name); } SimilarityKey(String geneSet1, String geneSet2, String interaction, String name); String getGeneSet1(); String getGeneSet2(); String getInteraction(); boolean isCompound(); String getName(); @Override int hashCode(); @Override boolean equals(Object o); String getCompoundName(); @Override String toString(); final String geneSet1; final String geneSet2; final String interaction; final String name; }### Answer: @Test public void testSimilarityKeyHashCode() { SimilarityKey k1 = new SimilarityKey("A", "B", "i", null); SimilarityKey k1p = new SimilarityKey("A", "B", "i", null); SimilarityKey k2 = new SimilarityKey("B", "A", "i", null); SimilarityKey k3 = new SimilarityKey("D", "C", "x", null); SimilarityKey k4 = new SimilarityKey("A", "B", "x", null); assertEquals(k1.hashCode(), k1p.hashCode()); assertEquals(k1.hashCode(), k2.hashCode()); assertEquals(k2.hashCode(), k1.hashCode()); assertNotEquals(k1.hashCode(), k3.hashCode()); assertNotEquals(k1.hashCode(), k4.hashCode()); }
### Question: SimilarityKey { @Override public String toString() { return isCompound() ? getCompoundName() : String.format("%s (%s_%s) %s", geneSet1, interaction, name, geneSet2); } SimilarityKey(String geneSet1, String geneSet2, String interaction, String name); String getGeneSet1(); String getGeneSet2(); String getInteraction(); boolean isCompound(); String getName(); @Override int hashCode(); @Override boolean equals(Object o); String getCompoundName(); @Override String toString(); final String geneSet1; final String geneSet2; final String interaction; final String name; }### Answer: @Test public void testSimilarityKeyToString() { SimilarityKey k1 = new SimilarityKey("A", "B", "i", null); SimilarityKey k2 = new SimilarityKey("A", "B", "i", "1"); SimilarityKey k3 = new SimilarityKey("A", "B", "i", "2"); assertEquals("A (i) B", k1.toString()); assertEquals("A (i_1) B", k2.toString()); assertEquals("A (i_2) B", k3.toString()); }
### Question: OpenPathwayCommonsTask extends AbstractTask { public String getPathwayCommonsURL() { EnrichmentMap map = emManager.getEnrichmentMap(network.getSUID()); if(map == null) return null; int port = Integer.parseInt(cy3props.getProperties().getProperty("rest.port")); String pcBaseUri = propertyManager.getValue(PropertyManager.PATHWAY_COMMONS_URL); String nodeLabel = getNodeLabel(map); try { String returnPath; if(node == null) returnPath = "/enrichmentmap/expressions/heatmap"; else returnPath = String.format("/enrichmentmap/expressions/%s/%s", network.getSUID(), node.getSUID()); String returnUri = new URIBuilder() .setScheme("http") .setHost("localhost") .setPath(returnPath) .setPort(port) .build() .toString(); String pcUri = new URIBuilder(pcBaseUri) .addParameter("uri", returnUri) .addParameter("q", nodeLabel) .build() .toString(); return pcUri; } catch(URISyntaxException e) { e.printStackTrace(); return null; } } @AssistedInject OpenPathwayCommonsTask(@Assisted CyNetwork network, @Assisted CyNode node); @AssistedInject OpenPathwayCommonsTask(@Assisted CyNetwork network); String getPathwayCommonsURL(); @Override void run(TaskMonitor taskMonitor); static final String DEFAULT_BASE_URL; }### Answer: @Test public void testPathwayCommonsTask( CyNetworkManager networkManager, OpenBrowser openBrowser, PropertyManager propertyManager, OpenPathwayCommonsTask.Factory pathwayCommonsTaskFactory ) { CyNetwork network = networkManager.getNetwork(map.getNetworkID()); CyNode node = TestUtils.getNodes(network).get("TOP1_PLUS100"); propertyManager.setValue(PropertyManager.PATHWAY_COMMONS_URL, "http: @SuppressWarnings("deprecation") String returnUri = URLEncoder.encode("http: String expectedUri = "http: OpenPathwayCommonsTask task = pathwayCommonsTaskFactory.create(network, node); String uri = task.getPathwayCommonsURL(); assertEquals(expectedUri, uri); }
### Question: SpyEventHandlerSupport { void addSpyEventHandler( @Nonnull final SpyEventHandler handler ) { if ( Arez.shouldCheckApiInvariants() ) { apiInvariant( () -> !_spyEventHandlers.contains( handler ), () -> "Arez-0102: Attempting to add handler " + handler + " that is already " + "in the list of spy handlers." ); } _spyEventHandlers.add( Objects.requireNonNull( handler ) ); } }### Answer: @Test public void addSpyEventHandler_alreadyExists() { final SpyEventHandlerSupport support = new SpyEventHandlerSupport(); final SpyEventHandler handler = new TestSpyEventHandler( Arez.context() ); support.addSpyEventHandler( handler ); assertInvariantFailure( () -> support.addSpyEventHandler( handler ), "Arez-0102: Attempting to add handler " + handler + " that is already " + "in the list of spy handlers." ); }
### Question: ObserverInfoImpl implements ObserverInfo { @Nonnull @Override public ComputableValueInfo asComputableValue() { return _observer.getComputableValue().asInfo(); } ObserverInfoImpl( @Nonnull final Spy spy, @Nonnull final Observer observer ); @Nonnull @Override String getName(); @Override boolean isActive(); @Override boolean isRunning(); @Override boolean isScheduled(); @Override boolean isComputableValue(); @Override boolean isReadOnly(); @Nonnull @Override Priority getPriority(); @Nonnull @Override ComputableValueInfo asComputableValue(); @Nonnull @Override List<ObservableValueInfo> getDependencies(); @Nullable @Override ComponentInfo getComponent(); @Override boolean isDisposed(); @Override String toString(); @Override boolean equals( final Object o ); @Override int hashCode(); }### Answer: @Test public void asComputableValue() { final ArezContext context = Arez.context(); final String name = ValueUtil.randomString(); final ComputableValue<String> computableValue = context.computable( name, () -> "" ); final Observer observer = computableValue.getObserver(); final ObserverInfo info = observer.asInfo(); assertEquals( info.getName(), name ); assertTrue( info.isComputableValue() ); assertEquals( info.asComputableValue().getName(), computableValue.getName() ); assertFalse( info.isActive() ); }
### Question: ObserverInfoImpl implements ObserverInfo { @Nullable @Override public ComponentInfo getComponent() { if ( Arez.shouldCheckInvariants() ) { invariant( Arez::areNativeComponentsEnabled, () -> "Arez-0108: Spy.getComponent invoked when Arez.areNativeComponentsEnabled() returns false." ); } final Component component = _observer.getComponent(); return null == component ? null : component.asInfo(); } ObserverInfoImpl( @Nonnull final Spy spy, @Nonnull final Observer observer ); @Nonnull @Override String getName(); @Override boolean isActive(); @Override boolean isRunning(); @Override boolean isScheduled(); @Override boolean isComputableValue(); @Override boolean isReadOnly(); @Nonnull @Override Priority getPriority(); @Nonnull @Override ComputableValueInfo asComputableValue(); @Nonnull @Override List<ObservableValueInfo> getDependencies(); @Nullable @Override ComponentInfo getComponent(); @Override boolean isDisposed(); @Override String toString(); @Override boolean equals( final Object o ); @Override int hashCode(); }### Answer: @Test public void getComponent_Observer_nativeComponentsDisabled() { ArezTestUtil.disableNativeComponents(); final ArezContext context = Arez.context(); final Spy spy = context.getSpy(); final Observer observer = context.observer( AbstractTest::observeADependency ); assertInvariantFailure( () -> spy.asObserverInfo( observer ).getComponent(), "Arez-0108: Spy.getComponent invoked when Arez.areNativeComponentsEnabled() returns false." ); }
### Question: ObserverInfoImpl implements ObserverInfo { @Override public int hashCode() { return _observer.hashCode(); } ObserverInfoImpl( @Nonnull final Spy spy, @Nonnull final Observer observer ); @Nonnull @Override String getName(); @Override boolean isActive(); @Override boolean isRunning(); @Override boolean isScheduled(); @Override boolean isComputableValue(); @Override boolean isReadOnly(); @Nonnull @Override Priority getPriority(); @Nonnull @Override ComputableValueInfo asComputableValue(); @Nonnull @Override List<ObservableValueInfo> getDependencies(); @Nullable @Override ComponentInfo getComponent(); @Override boolean isDisposed(); @Override String toString(); @Override boolean equals( final Object o ); @Override int hashCode(); }### Answer: @SuppressWarnings( "EqualsWithItself" ) @Test public void equalsAndHashCode() { final ArezContext context = Arez.context(); final ObservableValue<Object> observableValue = context.observable(); final Observer observer1 = context.observer( ValueUtil.randomString(), observableValue::reportObserved ); final Observer observer2 = context.observer( ValueUtil.randomString(), observableValue::reportObserved ); final ObserverInfo info1a = observer1.asInfo(); final ObserverInfo info1b = new ObserverInfoImpl( context.getSpy(), observer1 ); final ObserverInfo info2 = observer2.asInfo(); assertNotEquals( info1a, "" ); assertEquals( info1a, info1a ); assertEquals( info1b, info1a ); assertNotEquals( info2, info1a ); assertEquals( info1a, info1b ); assertEquals( info1b, info1b ); assertNotEquals( info2, info1b ); assertNotEquals( info1a, info2 ); assertNotEquals( info1b, info2 ); assertEquals( info2, info2 ); assertEquals( info1a.hashCode(), observer1.hashCode() ); assertEquals( info1a.hashCode(), info1b.hashCode() ); assertEquals( info2.hashCode(), observer2.hashCode() ); }
### Question: ComputableValueInfoImpl implements ComputableValueInfo { @Override public boolean isComputing() { return _computableValue.isComputing(); } ComputableValueInfoImpl( @Nonnull final ComputableValue<?> computableValue ); @Nonnull @Override String getName(); @Override boolean isComputing(); @Nonnull @Override Priority getPriority(); @Override boolean isActive(); @Nonnull @Override List<ObservableValueInfo> getDependencies(); @Nonnull @Override List<ObserverInfo> getObservers(); @Nullable @Override ComponentInfo getComponent(); @OmitSymbol( unless = "arez.enable_property_introspection" ) @Nullable @Override Object getValue(); @Override boolean isDisposed(); @Override String toString(); @Override boolean equals( final Object o ); @Override int hashCode(); }### Answer: @Test public void isComputing() { final ArezContext context = Arez.context(); final Spy spy = context.getSpy(); final ComputableValue<String> computableValue = context.computable( () -> "" ); assertFalse( spy.asComputableValueInfo( computableValue ).isComputing() ); computableValue.setComputing( true ); assertTrue( spy.asComputableValueInfo( computableValue ).isComputing() ); }
### Question: ComputableValueInfoImpl implements ComputableValueInfo { @Nonnull Transaction getTransactionComputing() { assert _computableValue.isComputing(); final Transaction transaction = getTrackerTransaction( _computableValue.getObserver() ); if ( Arez.shouldCheckInvariants() ) { invariant( () -> transaction != null, () -> "Arez-0106: ComputableValue named '" + _computableValue.getName() + "' is marked as " + "computing but unable to locate transaction responsible for computing ComputableValue" ); } assert null != transaction; return transaction; } ComputableValueInfoImpl( @Nonnull final ComputableValue<?> computableValue ); @Nonnull @Override String getName(); @Override boolean isComputing(); @Nonnull @Override Priority getPriority(); @Override boolean isActive(); @Nonnull @Override List<ObservableValueInfo> getDependencies(); @Nonnull @Override List<ObserverInfo> getObservers(); @Nullable @Override ComponentInfo getComponent(); @OmitSymbol( unless = "arez.enable_property_introspection" ) @Nullable @Override Object getValue(); @Override boolean isDisposed(); @Override String toString(); @Override boolean equals( final Object o ); @Override int hashCode(); }### Answer: @Test public void getTransactionComputing() { final ArezContext context = Arez.context(); final ComputableValue<String> computableValue = context.computable( () -> "" ); final Observer observer = computableValue.getObserver(); final Observer observer2 = context.observer( new CountAndObserveProcedure() ); computableValue.setComputing( true ); final ComputableValueInfoImpl info = (ComputableValueInfoImpl) computableValue.asInfo(); final Transaction transaction = new Transaction( context, null, observer.getName(), observer.isMutation(), observer, false ); Transaction.setTransaction( transaction ); assertEquals( info.getTransactionComputing(), transaction ); final Transaction transaction2 = new Transaction( context, transaction, ValueUtil.randomString(), observer2.isMutation(), observer2, false ); Transaction.setTransaction( transaction2 ); assertEquals( info.getTransactionComputing(), transaction ); }
### Question: RoundBasedTaskExecutor { boolean runNextTask() { if ( 0 == _remainingTasksInCurrentRound ) { final int pendingTaskCount = getPendingTaskCount(); if ( 0 == pendingTaskCount ) { _currentRound = 0; return false; } else if ( _currentRound + 1 > _maxRounds ) { _currentRound = 0; onRunawayTasksDetected(); return false; } else { _currentRound = _currentRound + 1; _remainingTasksInCurrentRound = pendingTaskCount; } } _remainingTasksInCurrentRound--; final Task task = _taskQueue.dequeueTask(); assert null != task; task.executeTask(); return true; } RoundBasedTaskExecutor( @Nonnull final TaskQueue taskQueue, final int maxRounds ); }### Answer: @Test public void runNextTask() { final ArezContext context = Arez.context(); final TaskQueue taskQueue = context.getTaskQueue(); final RoundBasedTaskExecutor executor = new RoundBasedTaskExecutor( taskQueue, 2 ); final AtomicInteger task1CallCount = new AtomicInteger(); final AtomicInteger task2CallCount = new AtomicInteger(); final AtomicInteger task3CallCount = new AtomicInteger(); final Task task1 = context.task( "A", task1CallCount::incrementAndGet, Task.Flags.RUN_LATER ); final Task task2 = context.task( "B", task2CallCount::incrementAndGet, Task.Flags.RUN_LATER ); context.task( "C", task3CallCount::incrementAndGet, Task.Flags.RUN_LATER ); assertEquals( executor.getMaxRounds(), 2 ); assertFalse( executor.areTasksExecuting() ); assertEquals( executor.getCurrentRound(), 0 ); assertEquals( executor.getRemainingTasksInCurrentRound(), 0 ); assertEquals( taskQueue.getQueueSize(), 3 ); assertEquals( task1CallCount.get(), 0 ); assertEquals( task2CallCount.get(), 0 ); assertEquals( task3CallCount.get(), 0 ); assertTrue( executor.runNextTask() ); assertTrue( executor.areTasksExecuting() ); assertEquals( executor.getCurrentRound(), 1 ); assertEquals( executor.getRemainingTasksInCurrentRound(), 2 ); assertEquals( taskQueue.getQueueSize(), 2 ); assertEquals( task1CallCount.get(), 1 ); assertEquals( task2CallCount.get(), 0 ); assertEquals( task3CallCount.get(), 0 ); assertTrue( executor.runNextTask() ); assertTrue( executor.areTasksExecuting() ); assertEquals( executor.getCurrentRound(), 1 ); assertEquals( executor.getRemainingTasksInCurrentRound(), 1 ); assertEquals( taskQueue.getQueueSize(), 1 ); assertEquals( task1CallCount.get(), 1 ); assertEquals( task2CallCount.get(), 1 ); assertEquals( task3CallCount.get(), 0 ); task1.queueTask(); task2.queueTask(); assertEquals( taskQueue.getQueueSize(), 3 ); assertTrue( executor.runNextTask() ); assertTrue( executor.areTasksExecuting() ); assertEquals( executor.getCurrentRound(), 1 ); assertEquals( executor.getRemainingTasksInCurrentRound(), 0 ); assertEquals( taskQueue.getQueueSize(), 2 ); assertEquals( task1CallCount.get(), 1 ); assertEquals( task2CallCount.get(), 1 ); assertEquals( task3CallCount.get(), 1 ); assertTrue( executor.runNextTask() ); assertTrue( executor.areTasksExecuting() ); assertEquals( executor.getCurrentRound(), 2 ); assertEquals( executor.getRemainingTasksInCurrentRound(), 1 ); assertEquals( taskQueue.getQueueSize(), 1 ); assertEquals( task1CallCount.get(), 2 ); assertEquals( task2CallCount.get(), 1 ); assertEquals( task3CallCount.get(), 1 ); assertTrue( executor.runNextTask() ); assertTrue( executor.areTasksExecuting() ); assertEquals( executor.getCurrentRound(), 2 ); assertEquals( executor.getRemainingTasksInCurrentRound(), 0 ); assertEquals( taskQueue.getQueueSize(), 0 ); assertEquals( task1CallCount.get(), 2 ); assertEquals( task2CallCount.get(), 2 ); assertEquals( task3CallCount.get(), 1 ); assertFalse( executor.runNextTask() ); assertFalse( executor.areTasksExecuting() ); }
### Question: RoundBasedTaskExecutor { void runTasks() { while ( true ) { if ( !runNextTask() ) { break; } } } RoundBasedTaskExecutor( @Nonnull final TaskQueue taskQueue, final int maxRounds ); }### Answer: @Test public void runTasks() { final ArezContext context = Arez.context(); final TaskQueue taskQueue = context.getTaskQueue(); final RoundBasedTaskExecutor executor = new RoundBasedTaskExecutor( taskQueue, 2 ); final AtomicInteger task1CallCount = new AtomicInteger(); final AtomicInteger task2CallCount = new AtomicInteger(); final AtomicInteger task3CallCount = new AtomicInteger(); context.task( "A", task1CallCount::incrementAndGet, Task.Flags.RUN_LATER ); context.task( "B", task2CallCount::incrementAndGet, Task.Flags.RUN_LATER ); context.task( "C", task3CallCount::incrementAndGet, Task.Flags.RUN_LATER ); assertEquals( executor.getMaxRounds(), 2 ); assertEquals( executor.getCurrentRound(), 0 ); assertEquals( executor.getRemainingTasksInCurrentRound(), 0 ); assertEquals( taskQueue.getQueueSize(), 3 ); assertEquals( task1CallCount.get(), 0 ); assertEquals( task2CallCount.get(), 0 ); assertEquals( task3CallCount.get(), 0 ); assertFalse( executor.areTasksExecuting() ); executor.runTasks(); assertFalse( executor.areTasksExecuting() ); assertEquals( task1CallCount.get(), 1 ); assertEquals( task2CallCount.get(), 1 ); assertEquals( task3CallCount.get(), 1 ); assertEquals( executor.getCurrentRound(), 0 ); assertEquals( executor.getRemainingTasksInCurrentRound(), 0 ); assertEquals( taskQueue.getQueueSize(), 0 ); assertFalse( executor.runNextTask() ); }
### Question: SpyImpl implements Spy { @Override public boolean isTransactionActive() { return getContext().isTransactionActive(); } SpyImpl( @Nullable final ArezContext context ); @Override void addSpyEventHandler( @Nonnull final SpyEventHandler handler ); @Override void removeSpyEventHandler( @Nonnull final SpyEventHandler handler ); @Override void reportSpyEvent( @Nonnull final Object event ); @Override boolean willPropagateSpyEvents(); @Override boolean isTransactionActive(); @Nonnull @Override TransactionInfo getTransaction(); @Nullable @Override ComponentInfo findComponent( @Nonnull final String type, @Nonnull final Object id ); @Nonnull @Override Collection<ComponentInfo> findAllComponentsByType( @Nonnull final String type ); @Nonnull @Override Collection<String> findAllComponentTypes(); @Nonnull @Override Collection<ObservableValueInfo> findAllTopLevelObservableValues(); @Nonnull @Override Collection<ObserverInfo> findAllTopLevelObservers(); @Nonnull @Override Collection<ComputableValueInfo> findAllTopLevelComputableValues(); @Nonnull @Override Collection<TaskInfo> findAllTopLevelTasks(); @Nonnull @Override ComponentInfo asComponentInfo( @Nonnull final Component component ); @Nonnull @Override ObserverInfo asObserverInfo( @Nonnull final Observer observer ); @Nonnull @Override ObservableValueInfo asObservableValueInfo( @Nonnull final ObservableValue<T> observableValue ); @Nonnull @Override ComputableValueInfo asComputableValueInfo( @Nonnull final ComputableValue<T> computableValue ); @Nonnull @Override TaskInfo asTaskInfo( @Nonnull final Task task ); }### Answer: @Test public void isTransactionActive() { final ArezContext context = Arez.context(); final Spy spy = context.getSpy(); assertFalse( spy.isTransactionActive() ); setupReadOnlyTransaction( context ); assertTrue( spy.isTransactionActive() ); }
### Question: SpyImpl implements Spy { @Nonnull @Override public TransactionInfo getTransaction() { if ( Arez.shouldCheckApiInvariants() ) { apiInvariant( this::isTransactionActive, () -> "Arez-0105: Spy.getTransaction() invoked but no transaction active." ); } return getContext().getTransaction().asInfo(); } SpyImpl( @Nullable final ArezContext context ); @Override void addSpyEventHandler( @Nonnull final SpyEventHandler handler ); @Override void removeSpyEventHandler( @Nonnull final SpyEventHandler handler ); @Override void reportSpyEvent( @Nonnull final Object event ); @Override boolean willPropagateSpyEvents(); @Override boolean isTransactionActive(); @Nonnull @Override TransactionInfo getTransaction(); @Nullable @Override ComponentInfo findComponent( @Nonnull final String type, @Nonnull final Object id ); @Nonnull @Override Collection<ComponentInfo> findAllComponentsByType( @Nonnull final String type ); @Nonnull @Override Collection<String> findAllComponentTypes(); @Nonnull @Override Collection<ObservableValueInfo> findAllTopLevelObservableValues(); @Nonnull @Override Collection<ObserverInfo> findAllTopLevelObservers(); @Nonnull @Override Collection<ComputableValueInfo> findAllTopLevelComputableValues(); @Nonnull @Override Collection<TaskInfo> findAllTopLevelTasks(); @Nonnull @Override ComponentInfo asComponentInfo( @Nonnull final Component component ); @Nonnull @Override ObserverInfo asObserverInfo( @Nonnull final Observer observer ); @Nonnull @Override ObservableValueInfo asObservableValueInfo( @Nonnull final ObservableValue<T> observableValue ); @Nonnull @Override ComputableValueInfo asComputableValueInfo( @Nonnull final ComputableValue<T> computableValue ); @Nonnull @Override TaskInfo asTaskInfo( @Nonnull final Task task ); }### Answer: @Test public void getTransaction() { final ArezContext context = Arez.context(); final Spy spy = context.getSpy(); final String name = ValueUtil.randomString(); context.safeAction( name, () -> { observeADependency(); assertEquals( spy.getTransaction().getName(), name ); } ); }
### Question: SpyImpl implements Spy { @Nullable @Override public ComponentInfo findComponent( @Nonnull final String type, @Nonnull final Object id ) { final Component component = getContext().findComponent( type, id ); return null != component ? component.asInfo() : null; } SpyImpl( @Nullable final ArezContext context ); @Override void addSpyEventHandler( @Nonnull final SpyEventHandler handler ); @Override void removeSpyEventHandler( @Nonnull final SpyEventHandler handler ); @Override void reportSpyEvent( @Nonnull final Object event ); @Override boolean willPropagateSpyEvents(); @Override boolean isTransactionActive(); @Nonnull @Override TransactionInfo getTransaction(); @Nullable @Override ComponentInfo findComponent( @Nonnull final String type, @Nonnull final Object id ); @Nonnull @Override Collection<ComponentInfo> findAllComponentsByType( @Nonnull final String type ); @Nonnull @Override Collection<String> findAllComponentTypes(); @Nonnull @Override Collection<ObservableValueInfo> findAllTopLevelObservableValues(); @Nonnull @Override Collection<ObserverInfo> findAllTopLevelObservers(); @Nonnull @Override Collection<ComputableValueInfo> findAllTopLevelComputableValues(); @Nonnull @Override Collection<TaskInfo> findAllTopLevelTasks(); @Nonnull @Override ComponentInfo asComponentInfo( @Nonnull final Component component ); @Nonnull @Override ObserverInfo asObserverInfo( @Nonnull final Observer observer ); @Nonnull @Override ObservableValueInfo asObservableValueInfo( @Nonnull final ObservableValue<T> observableValue ); @Nonnull @Override ComputableValueInfo asComputableValueInfo( @Nonnull final ComputableValue<T> computableValue ); @Nonnull @Override TaskInfo asTaskInfo( @Nonnull final Task task ); }### Answer: @Test public void findComponent_nativeComponentsDisabled() { ArezTestUtil.disableNativeComponents(); final ArezContext context = Arez.context(); final Spy spy = context.getSpy(); final String type = ValueUtil.randomString(); final String id = ValueUtil.randomString(); assertInvariantFailure( () -> spy.findComponent( type, id ), "Arez-0010: ArezContext.findComponent() invoked when Arez.areNativeComponentsEnabled() returns false." ); }
### Question: SpyImpl implements Spy { @Nonnull @Override public Collection<ComponentInfo> findAllComponentsByType( @Nonnull final String type ) { final List<ComponentInfo> infos = getContext().findAllComponentsByType( type ).stream(). map( Component::asInfo ). collect( Collectors.toList() ); return Collections.unmodifiableCollection( infos ); } SpyImpl( @Nullable final ArezContext context ); @Override void addSpyEventHandler( @Nonnull final SpyEventHandler handler ); @Override void removeSpyEventHandler( @Nonnull final SpyEventHandler handler ); @Override void reportSpyEvent( @Nonnull final Object event ); @Override boolean willPropagateSpyEvents(); @Override boolean isTransactionActive(); @Nonnull @Override TransactionInfo getTransaction(); @Nullable @Override ComponentInfo findComponent( @Nonnull final String type, @Nonnull final Object id ); @Nonnull @Override Collection<ComponentInfo> findAllComponentsByType( @Nonnull final String type ); @Nonnull @Override Collection<String> findAllComponentTypes(); @Nonnull @Override Collection<ObservableValueInfo> findAllTopLevelObservableValues(); @Nonnull @Override Collection<ObserverInfo> findAllTopLevelObservers(); @Nonnull @Override Collection<ComputableValueInfo> findAllTopLevelComputableValues(); @Nonnull @Override Collection<TaskInfo> findAllTopLevelTasks(); @Nonnull @Override ComponentInfo asComponentInfo( @Nonnull final Component component ); @Nonnull @Override ObserverInfo asObserverInfo( @Nonnull final Observer observer ); @Nonnull @Override ObservableValueInfo asObservableValueInfo( @Nonnull final ObservableValue<T> observableValue ); @Nonnull @Override ComputableValueInfo asComputableValueInfo( @Nonnull final ComputableValue<T> computableValue ); @Nonnull @Override TaskInfo asTaskInfo( @Nonnull final Task task ); }### Answer: @Test public void findAllComponentsByType_nativeComponentsDisabled() { ArezTestUtil.disableNativeComponents(); final ArezContext context = Arez.context(); final Spy spy = context.getSpy(); final String type = ValueUtil.randomString(); assertInvariantFailure( () -> spy.findAllComponentsByType( type ), "Arez-0011: ArezContext.findAllComponentsByType() invoked when Arez.areNativeComponentsEnabled() returns false." ); }
### Question: SpyImpl implements Spy { @Nonnull @Override public Collection<TaskInfo> findAllTopLevelTasks() { return TaskInfoImpl.asUnmodifiableInfos( getContext().getTopLevelTasks().values() ); } SpyImpl( @Nullable final ArezContext context ); @Override void addSpyEventHandler( @Nonnull final SpyEventHandler handler ); @Override void removeSpyEventHandler( @Nonnull final SpyEventHandler handler ); @Override void reportSpyEvent( @Nonnull final Object event ); @Override boolean willPropagateSpyEvents(); @Override boolean isTransactionActive(); @Nonnull @Override TransactionInfo getTransaction(); @Nullable @Override ComponentInfo findComponent( @Nonnull final String type, @Nonnull final Object id ); @Nonnull @Override Collection<ComponentInfo> findAllComponentsByType( @Nonnull final String type ); @Nonnull @Override Collection<String> findAllComponentTypes(); @Nonnull @Override Collection<ObservableValueInfo> findAllTopLevelObservableValues(); @Nonnull @Override Collection<ObserverInfo> findAllTopLevelObservers(); @Nonnull @Override Collection<ComputableValueInfo> findAllTopLevelComputableValues(); @Nonnull @Override Collection<TaskInfo> findAllTopLevelTasks(); @Nonnull @Override ComponentInfo asComponentInfo( @Nonnull final Component component ); @Nonnull @Override ObserverInfo asObserverInfo( @Nonnull final Observer observer ); @Nonnull @Override ObservableValueInfo asObservableValueInfo( @Nonnull final ObservableValue<T> observableValue ); @Nonnull @Override ComputableValueInfo asComputableValueInfo( @Nonnull final ComputableValue<T> computableValue ); @Nonnull @Override TaskInfo asTaskInfo( @Nonnull final Task task ); }### Answer: @Test public void findAllTopLevelTasks() { final ArezContext context = Arez.context(); final Task task = context.task( ValueUtil::randomString ); final Spy spy = context.getSpy(); final Collection<TaskInfo> values = spy.findAllTopLevelTasks(); assertEquals( values.size(), 1 ); assertEquals( values.iterator().next().getName(), task.getName() ); assertUnmodifiable( values ); }
### Question: ComputableValueInfoImpl implements ComputableValueInfo { @Nonnull @Override public String getName() { return _computableValue.getName(); } ComputableValueInfoImpl( @Nonnull final ComputableValue<?> computableValue ); @Nonnull @Override String getName(); @Override boolean isComputing(); @Nonnull @Override Priority getPriority(); @Override boolean isActive(); @Nonnull @Override List<ObservableValueInfo> getDependencies(); @Nonnull @Override List<ObserverInfo> getObservers(); @Nullable @Override ComponentInfo getComponent(); @OmitSymbol( unless = "arez.enable_property_introspection" ) @Nullable @Override Object getValue(); @Override boolean isDisposed(); @Override String toString(); @Override boolean equals( final Object o ); @Override int hashCode(); }### Answer: @Test public void getTransactionComputing_missingTracker() { final ArezContext context = Arez.context(); final ComputableValue<String> computableValue = context.computable( () -> "" ); computableValue.setComputing( true ); final ComputableValueInfoImpl info = (ComputableValueInfoImpl) computableValue.asInfo(); setupReadOnlyTransaction( context ); assertInvariantFailure( info::getTransactionComputing, "Arez-0106: ComputableValue named '" + computableValue.getName() + "' is marked as " + "computing but unable to locate transaction responsible for computing ComputableValue" ); }
### Question: SpyImpl implements Spy { @Nonnull @Override public Collection<ObservableValueInfo> findAllTopLevelObservableValues() { return ObservableValueInfoImpl.asUnmodifiableInfos( getContext().getTopLevelObservables().values() ); } SpyImpl( @Nullable final ArezContext context ); @Override void addSpyEventHandler( @Nonnull final SpyEventHandler handler ); @Override void removeSpyEventHandler( @Nonnull final SpyEventHandler handler ); @Override void reportSpyEvent( @Nonnull final Object event ); @Override boolean willPropagateSpyEvents(); @Override boolean isTransactionActive(); @Nonnull @Override TransactionInfo getTransaction(); @Nullable @Override ComponentInfo findComponent( @Nonnull final String type, @Nonnull final Object id ); @Nonnull @Override Collection<ComponentInfo> findAllComponentsByType( @Nonnull final String type ); @Nonnull @Override Collection<String> findAllComponentTypes(); @Nonnull @Override Collection<ObservableValueInfo> findAllTopLevelObservableValues(); @Nonnull @Override Collection<ObserverInfo> findAllTopLevelObservers(); @Nonnull @Override Collection<ComputableValueInfo> findAllTopLevelComputableValues(); @Nonnull @Override Collection<TaskInfo> findAllTopLevelTasks(); @Nonnull @Override ComponentInfo asComponentInfo( @Nonnull final Component component ); @Nonnull @Override ObserverInfo asObserverInfo( @Nonnull final Observer observer ); @Nonnull @Override ObservableValueInfo asObservableValueInfo( @Nonnull final ObservableValue<T> observableValue ); @Nonnull @Override ComputableValueInfo asComputableValueInfo( @Nonnull final ComputableValue<T> computableValue ); @Nonnull @Override TaskInfo asTaskInfo( @Nonnull final Task task ); }### Answer: @Test public void findAllTopLevelObservables() { final ArezContext context = Arez.context(); final ObservableValue<String> observableValue = context.observable(); final Spy spy = context.getSpy(); final Collection<ObservableValueInfo> values = spy.findAllTopLevelObservableValues(); assertEquals( values.size(), 1 ); assertEquals( values.iterator().next().getName(), observableValue.getName() ); assertUnmodifiable( values ); }
### Question: SpyImpl implements Spy { @Nonnull @Override public Collection<ComputableValueInfo> findAllTopLevelComputableValues() { return ComputableValueInfoImpl.asUnmodifiableInfos( getContext().getTopLevelComputableValues().values() ); } SpyImpl( @Nullable final ArezContext context ); @Override void addSpyEventHandler( @Nonnull final SpyEventHandler handler ); @Override void removeSpyEventHandler( @Nonnull final SpyEventHandler handler ); @Override void reportSpyEvent( @Nonnull final Object event ); @Override boolean willPropagateSpyEvents(); @Override boolean isTransactionActive(); @Nonnull @Override TransactionInfo getTransaction(); @Nullable @Override ComponentInfo findComponent( @Nonnull final String type, @Nonnull final Object id ); @Nonnull @Override Collection<ComponentInfo> findAllComponentsByType( @Nonnull final String type ); @Nonnull @Override Collection<String> findAllComponentTypes(); @Nonnull @Override Collection<ObservableValueInfo> findAllTopLevelObservableValues(); @Nonnull @Override Collection<ObserverInfo> findAllTopLevelObservers(); @Nonnull @Override Collection<ComputableValueInfo> findAllTopLevelComputableValues(); @Nonnull @Override Collection<TaskInfo> findAllTopLevelTasks(); @Nonnull @Override ComponentInfo asComponentInfo( @Nonnull final Component component ); @Nonnull @Override ObserverInfo asObserverInfo( @Nonnull final Observer observer ); @Nonnull @Override ObservableValueInfo asObservableValueInfo( @Nonnull final ObservableValue<T> observableValue ); @Nonnull @Override ComputableValueInfo asComputableValueInfo( @Nonnull final ComputableValue<T> computableValue ); @Nonnull @Override TaskInfo asTaskInfo( @Nonnull final Task task ); }### Answer: @Test public void findAllTopLevelComputableValues() { final ArezContext context = Arez.context(); final ComputableValue<String> computableValue = context.computable( () -> "" ); final Spy spy = context.getSpy(); final Collection<ComputableValueInfo> values = spy.findAllTopLevelComputableValues(); assertEquals( values.size(), 1 ); assertEquals( values.iterator().next().getName(), computableValue.getName() ); assertUnmodifiable( values ); assertEquals( spy.findAllTopLevelObservers().size(), 0 ); assertEquals( spy.findAllTopLevelObservableValues().size(), 0 ); }
### Question: SpyImpl implements Spy { @Nonnull @Override public Collection<ObserverInfo> findAllTopLevelObservers() { return ObserverInfoImpl.asUnmodifiableInfos( getContext().getTopLevelObservers().values() ); } SpyImpl( @Nullable final ArezContext context ); @Override void addSpyEventHandler( @Nonnull final SpyEventHandler handler ); @Override void removeSpyEventHandler( @Nonnull final SpyEventHandler handler ); @Override void reportSpyEvent( @Nonnull final Object event ); @Override boolean willPropagateSpyEvents(); @Override boolean isTransactionActive(); @Nonnull @Override TransactionInfo getTransaction(); @Nullable @Override ComponentInfo findComponent( @Nonnull final String type, @Nonnull final Object id ); @Nonnull @Override Collection<ComponentInfo> findAllComponentsByType( @Nonnull final String type ); @Nonnull @Override Collection<String> findAllComponentTypes(); @Nonnull @Override Collection<ObservableValueInfo> findAllTopLevelObservableValues(); @Nonnull @Override Collection<ObserverInfo> findAllTopLevelObservers(); @Nonnull @Override Collection<ComputableValueInfo> findAllTopLevelComputableValues(); @Nonnull @Override Collection<TaskInfo> findAllTopLevelTasks(); @Nonnull @Override ComponentInfo asComponentInfo( @Nonnull final Component component ); @Nonnull @Override ObserverInfo asObserverInfo( @Nonnull final Observer observer ); @Nonnull @Override ObservableValueInfo asObservableValueInfo( @Nonnull final ObservableValue<T> observableValue ); @Nonnull @Override ComputableValueInfo asComputableValueInfo( @Nonnull final ComputableValue<T> computableValue ); @Nonnull @Override TaskInfo asTaskInfo( @Nonnull final Task task ); }### Answer: @Test public void findAllTopLevelObservers() { final ArezContext context = Arez.context(); final Observer observer = context.observer( AbstractTest::observeADependency ); final Spy spy = context.getSpy(); final Collection<ObserverInfo> values = spy.findAllTopLevelObservers(); assertEquals( values.size(), 1 ); assertEquals( values.iterator().next().getName(), observer.getName() ); assertUnmodifiable( values ); }
### Question: SpyImpl implements Spy { @Nonnull @Override public <T> ObservableValueInfo asObservableValueInfo( @Nonnull final ObservableValue<T> observableValue ) { return observableValue.asInfo(); } SpyImpl( @Nullable final ArezContext context ); @Override void addSpyEventHandler( @Nonnull final SpyEventHandler handler ); @Override void removeSpyEventHandler( @Nonnull final SpyEventHandler handler ); @Override void reportSpyEvent( @Nonnull final Object event ); @Override boolean willPropagateSpyEvents(); @Override boolean isTransactionActive(); @Nonnull @Override TransactionInfo getTransaction(); @Nullable @Override ComponentInfo findComponent( @Nonnull final String type, @Nonnull final Object id ); @Nonnull @Override Collection<ComponentInfo> findAllComponentsByType( @Nonnull final String type ); @Nonnull @Override Collection<String> findAllComponentTypes(); @Nonnull @Override Collection<ObservableValueInfo> findAllTopLevelObservableValues(); @Nonnull @Override Collection<ObserverInfo> findAllTopLevelObservers(); @Nonnull @Override Collection<ComputableValueInfo> findAllTopLevelComputableValues(); @Nonnull @Override Collection<TaskInfo> findAllTopLevelTasks(); @Nonnull @Override ComponentInfo asComponentInfo( @Nonnull final Component component ); @Nonnull @Override ObserverInfo asObserverInfo( @Nonnull final Observer observer ); @Nonnull @Override ObservableValueInfo asObservableValueInfo( @Nonnull final ObservableValue<T> observableValue ); @Nonnull @Override ComputableValueInfo asComputableValueInfo( @Nonnull final ComputableValue<T> computableValue ); @Nonnull @Override TaskInfo asTaskInfo( @Nonnull final Task task ); }### Answer: @Test public void observable_getValue_noAccessor() { final ArezContext context = Arez.context(); final Spy spy = context.getSpy(); final ObservableValue<Integer> observableValue = context.observable(); assertInvariantFailure( () -> context.action( () -> spy.asObservableValueInfo( observableValue ).getValue() ), "Arez-0112: Spy.getValue invoked on ObservableValue named '" + observableValue.getName() + "' but ObservableValue has no property accessor." ); } @Test public void asObservableInfo() { final ArezContext context = Arez.context(); final ObservableValue<Object> observableValue = context.observable( ValueUtil.randomString() ); final ObservableValueInfo info = context.getSpy().asObservableValueInfo( observableValue ); assertEquals( info.getName(), observableValue.getName() ); }
### Question: SpyImpl implements Spy { @Nonnull @Override public ComponentInfo asComponentInfo( @Nonnull final Component component ) { return component.asInfo(); } SpyImpl( @Nullable final ArezContext context ); @Override void addSpyEventHandler( @Nonnull final SpyEventHandler handler ); @Override void removeSpyEventHandler( @Nonnull final SpyEventHandler handler ); @Override void reportSpyEvent( @Nonnull final Object event ); @Override boolean willPropagateSpyEvents(); @Override boolean isTransactionActive(); @Nonnull @Override TransactionInfo getTransaction(); @Nullable @Override ComponentInfo findComponent( @Nonnull final String type, @Nonnull final Object id ); @Nonnull @Override Collection<ComponentInfo> findAllComponentsByType( @Nonnull final String type ); @Nonnull @Override Collection<String> findAllComponentTypes(); @Nonnull @Override Collection<ObservableValueInfo> findAllTopLevelObservableValues(); @Nonnull @Override Collection<ObserverInfo> findAllTopLevelObservers(); @Nonnull @Override Collection<ComputableValueInfo> findAllTopLevelComputableValues(); @Nonnull @Override Collection<TaskInfo> findAllTopLevelTasks(); @Nonnull @Override ComponentInfo asComponentInfo( @Nonnull final Component component ); @Nonnull @Override ObserverInfo asObserverInfo( @Nonnull final Observer observer ); @Nonnull @Override ObservableValueInfo asObservableValueInfo( @Nonnull final ObservableValue<T> observableValue ); @Nonnull @Override ComputableValueInfo asComputableValueInfo( @Nonnull final ComputableValue<T> computableValue ); @Nonnull @Override TaskInfo asTaskInfo( @Nonnull final Task task ); }### Answer: @Test public void asComponentInfo() { final ArezContext context = Arez.context(); final Component component = context.component( ValueUtil.randomString(), ValueUtil.randomString() ); final ComponentInfo info = context.getSpy().asComponentInfo( component ); assertEquals( info.getName(), component.getName() ); }
### Question: SpyImpl implements Spy { @Nonnull @Override public ObserverInfo asObserverInfo( @Nonnull final Observer observer ) { return observer.asInfo(); } SpyImpl( @Nullable final ArezContext context ); @Override void addSpyEventHandler( @Nonnull final SpyEventHandler handler ); @Override void removeSpyEventHandler( @Nonnull final SpyEventHandler handler ); @Override void reportSpyEvent( @Nonnull final Object event ); @Override boolean willPropagateSpyEvents(); @Override boolean isTransactionActive(); @Nonnull @Override TransactionInfo getTransaction(); @Nullable @Override ComponentInfo findComponent( @Nonnull final String type, @Nonnull final Object id ); @Nonnull @Override Collection<ComponentInfo> findAllComponentsByType( @Nonnull final String type ); @Nonnull @Override Collection<String> findAllComponentTypes(); @Nonnull @Override Collection<ObservableValueInfo> findAllTopLevelObservableValues(); @Nonnull @Override Collection<ObserverInfo> findAllTopLevelObservers(); @Nonnull @Override Collection<ComputableValueInfo> findAllTopLevelComputableValues(); @Nonnull @Override Collection<TaskInfo> findAllTopLevelTasks(); @Nonnull @Override ComponentInfo asComponentInfo( @Nonnull final Component component ); @Nonnull @Override ObserverInfo asObserverInfo( @Nonnull final Observer observer ); @Nonnull @Override ObservableValueInfo asObservableValueInfo( @Nonnull final ObservableValue<T> observableValue ); @Nonnull @Override ComputableValueInfo asComputableValueInfo( @Nonnull final ComputableValue<T> computableValue ); @Nonnull @Override TaskInfo asTaskInfo( @Nonnull final Task task ); }### Answer: @Test public void asObserverInfo() { final ArezContext context = Arez.context(); final Observer observer = context.observer( AbstractTest::observeADependency ); final ObserverInfo info = context.getSpy().asObserverInfo( observer ); assertEquals( info.getName(), observer.getName() ); }
### Question: SpyImpl implements Spy { @Nonnull @Override public TaskInfo asTaskInfo( @Nonnull final Task task ) { return task.asInfo(); } SpyImpl( @Nullable final ArezContext context ); @Override void addSpyEventHandler( @Nonnull final SpyEventHandler handler ); @Override void removeSpyEventHandler( @Nonnull final SpyEventHandler handler ); @Override void reportSpyEvent( @Nonnull final Object event ); @Override boolean willPropagateSpyEvents(); @Override boolean isTransactionActive(); @Nonnull @Override TransactionInfo getTransaction(); @Nullable @Override ComponentInfo findComponent( @Nonnull final String type, @Nonnull final Object id ); @Nonnull @Override Collection<ComponentInfo> findAllComponentsByType( @Nonnull final String type ); @Nonnull @Override Collection<String> findAllComponentTypes(); @Nonnull @Override Collection<ObservableValueInfo> findAllTopLevelObservableValues(); @Nonnull @Override Collection<ObserverInfo> findAllTopLevelObservers(); @Nonnull @Override Collection<ComputableValueInfo> findAllTopLevelComputableValues(); @Nonnull @Override Collection<TaskInfo> findAllTopLevelTasks(); @Nonnull @Override ComponentInfo asComponentInfo( @Nonnull final Component component ); @Nonnull @Override ObserverInfo asObserverInfo( @Nonnull final Observer observer ); @Nonnull @Override ObservableValueInfo asObservableValueInfo( @Nonnull final ObservableValue<T> observableValue ); @Nonnull @Override ComputableValueInfo asComputableValueInfo( @Nonnull final ComputableValue<T> computableValue ); @Nonnull @Override TaskInfo asTaskInfo( @Nonnull final Task task ); }### Answer: @Test public void asTaskInfo() { final ArezContext context = Arez.context(); final Task task = context.task( ValueUtil::randomString ); final TaskInfo info = context.getSpy().asTaskInfo( task ); assertEquals( info.getName(), task.getName() ); }
### Question: SpyImpl implements Spy { @Nonnull @Override public <T> ComputableValueInfo asComputableValueInfo( @Nonnull final ComputableValue<T> computableValue ) { return computableValue.asInfo(); } SpyImpl( @Nullable final ArezContext context ); @Override void addSpyEventHandler( @Nonnull final SpyEventHandler handler ); @Override void removeSpyEventHandler( @Nonnull final SpyEventHandler handler ); @Override void reportSpyEvent( @Nonnull final Object event ); @Override boolean willPropagateSpyEvents(); @Override boolean isTransactionActive(); @Nonnull @Override TransactionInfo getTransaction(); @Nullable @Override ComponentInfo findComponent( @Nonnull final String type, @Nonnull final Object id ); @Nonnull @Override Collection<ComponentInfo> findAllComponentsByType( @Nonnull final String type ); @Nonnull @Override Collection<String> findAllComponentTypes(); @Nonnull @Override Collection<ObservableValueInfo> findAllTopLevelObservableValues(); @Nonnull @Override Collection<ObserverInfo> findAllTopLevelObservers(); @Nonnull @Override Collection<ComputableValueInfo> findAllTopLevelComputableValues(); @Nonnull @Override Collection<TaskInfo> findAllTopLevelTasks(); @Nonnull @Override ComponentInfo asComponentInfo( @Nonnull final Component component ); @Nonnull @Override ObserverInfo asObserverInfo( @Nonnull final Observer observer ); @Nonnull @Override ObservableValueInfo asObservableValueInfo( @Nonnull final ObservableValue<T> observableValue ); @Nonnull @Override ComputableValueInfo asComputableValueInfo( @Nonnull final ComputableValue<T> computableValue ); @Nonnull @Override TaskInfo asTaskInfo( @Nonnull final Task task ); }### Answer: @Test public void asComputableValueInfo() { final ArezContext context = Arez.context(); final ComputableValue<String> computableValue = context.computable( () -> "" ); final ComputableValueInfo info = context.getSpy().asComputableValueInfo( computableValue ); assertEquals( info.getName(), computableValue.getName() ); }
### Question: ObserverErrorHandlerSupport implements ObserverErrorHandler { void addObserverErrorHandler( @Nonnull final ObserverErrorHandler handler ) { if ( Arez.shouldCheckApiInvariants() ) { apiInvariant( () -> !_handlers.contains( handler ), () -> "Arez-0096: Attempting to add handler " + handler + " that is already in " + "the list of error handlers." ); } _handlers.add( Objects.requireNonNull( handler ) ); } @Override void onObserverError( @Nonnull final Observer observer, @Nonnull final ObserverError error, @Nullable final Throwable throwable ); }### Answer: @Test public void addObserverErrorHandler_alreadyExists() { final ObserverErrorHandlerSupport support = new ObserverErrorHandlerSupport(); final ObserverErrorHandler handler = ( observerArg, errorArg, throwableArg ) -> { }; support.addObserverErrorHandler( handler ); assertInvariantFailure( () -> support.addObserverErrorHandler( handler ), "Arez-0096: Attempting to add handler " + handler + " that is already in " + "the list of error handlers." ); }
### Question: ComputableValueInfoImpl implements ComputableValueInfo { @Nonnull @Override public List<ObservableValueInfo> getDependencies() { if ( _computableValue.isComputing() ) { final Transaction transaction = getTransactionComputing(); final List<ObservableValue<?>> observableValues = transaction.getObservableValues(); if ( null == observableValues ) { return Collections.emptyList(); } else { final List<ObservableValue<?>> list = observableValues.stream().distinct().collect( Collectors.toList() ); return ObservableValueInfoImpl.asUnmodifiableInfos( list ); } } else { return ObservableValueInfoImpl.asUnmodifiableInfos( _computableValue.getObserver().getDependencies() ); } } ComputableValueInfoImpl( @Nonnull final ComputableValue<?> computableValue ); @Nonnull @Override String getName(); @Override boolean isComputing(); @Nonnull @Override Priority getPriority(); @Override boolean isActive(); @Nonnull @Override List<ObservableValueInfo> getDependencies(); @Nonnull @Override List<ObserverInfo> getObservers(); @Nullable @Override ComponentInfo getComponent(); @OmitSymbol( unless = "arez.enable_property_introspection" ) @Nullable @Override Object getValue(); @Override boolean isDisposed(); @Override String toString(); @Override boolean equals( final Object o ); @Override int hashCode(); }### Answer: @Test public void getDependencies() { final ArezContext context = Arez.context(); final ComputableValue<String> computableValue = context.computable( () -> "" ); final ComputableValueInfo info = computableValue.asInfo(); assertEquals( info.getDependencies().size(), 0 ); final ObservableValue<?> observableValue = context.observable(); observableValue.getObservers().add( computableValue.getObserver() ); computableValue.getObserver().getDependencies().add( observableValue ); final List<ObservableValueInfo> dependencies = info.getDependencies(); assertEquals( dependencies.size(), 1 ); assertEquals( dependencies.iterator().next().getName(), observableValue.getName() ); assertUnmodifiable( dependencies ); }
### Question: ObserverErrorHandlerSupport implements ObserverErrorHandler { void removeObserverErrorHandler( @Nonnull final ObserverErrorHandler handler ) { if ( Arez.shouldCheckApiInvariants() ) { apiInvariant( () -> _handlers.contains( handler ), () -> "Arez-0097: Attempting to remove handler " + handler + " that is not in " + "the list of error handlers." ); } _handlers.remove( Objects.requireNonNull( handler ) ); } @Override void onObserverError( @Nonnull final Observer observer, @Nonnull final ObserverError error, @Nullable final Throwable throwable ); }### Answer: @Test public void removeObserverErrorHandler_noExists() { final ObserverErrorHandlerSupport support = new ObserverErrorHandlerSupport(); final ObserverErrorHandler handler = ( observerArg, errorArg, throwableArg ) -> { }; assertInvariantFailure( () -> support.removeObserverErrorHandler( handler ), "Arez-0097: Attempting to remove handler " + handler + " that is not in " + "the list of error handlers." ); }
### Question: Task extends Node { public void schedule() { if ( isIdle() ) { queueTask(); } getContext().triggerScheduler(); } Task( @Nullable final ArezContext context, @Nullable final String name, @Nonnull final SafeProcedure work, final int flags ); void schedule(); @Override void dispose(); @Override boolean isDisposed(); }### Answer: @Test public void schedule() { final AtomicInteger callCount = new AtomicInteger(); final Task task = Arez.context().task( callCount::incrementAndGet ); assertEquals( callCount.get(), 1 ); assertTrue( task.isIdle() ); task.schedule(); assertEquals( callCount.get(), 2 ); }
### Question: Task extends Node { void markAsQueued() { if ( Arez.shouldCheckInvariants() ) { invariant( this::isIdle, () -> "Arez-0128: Attempting to queue task named '" + getName() + "' when task is not idle." ); } _flags = Flags.setState( _flags, Flags.STATE_QUEUED ); } Task( @Nullable final ArezContext context, @Nullable final String name, @Nonnull final SafeProcedure work, final int flags ); void schedule(); @Override void dispose(); @Override boolean isDisposed(); }### Answer: @Test public void markAsQueued_alreadyScheduled() { final Task task = new Task( Arez.context(), "X", ValueUtil::randomString, 0 ); task.markAsQueued(); assertInvariantFailure( task::markAsQueued, "Arez-0128: Attempting to queue task named 'X' when task is not idle." ); }
### Question: Task extends Node { Task( @Nullable final ArezContext context, @Nullable final String name, @Nonnull final SafeProcedure work, final int flags ) { super( context, name ); if ( Arez.shouldCheckApiInvariants() ) { apiInvariant( () -> ( ~Flags.CONFIG_FLAGS_MASK & flags ) == 0, () -> "Arez-0224: Task named '" + name + "' passed invalid flags: " + ( ~Flags.CONFIG_FLAGS_MASK & flags ) ); } _work = Objects.requireNonNull( work ); _flags = flags \| Flags.STATE_IDLE \| Flags.runType( flags ) \| Flags.priority( flags ); if ( Arez.areRegistriesEnabled() && 0 == ( _flags & Flags.NO_REGISTER_TASK ) ) { getContext().registerTask( this ); } } Task( @Nullable final ArezContext context, @Nullable final String name, @Nonnull final SafeProcedure work, final int flags ); void schedule(); @Override void dispose(); @Override boolean isDisposed(); }### Answer: @Test public void asInfo_spyDisabled() { ArezTestUtil.disableSpies(); final Task task = Arez.context().task( ValueUtil::randomString ); assertInvariantFailure( task::asInfo, "Arez-0130: Task.asInfo() invoked but Arez.areSpiesEnabled() returned false." ); }
### Question: Task extends Node { @Nonnull Priority getPriority() { return Priority.values()[ getPriorityIndex() ]; } Task( @Nullable final ArezContext context, @Nullable final String name, @Nonnull final SafeProcedure work, final int flags ); void schedule(); @Override void dispose(); @Override boolean isDisposed(); }### Answer: @Test public void getPriority() { assertEquals( Task.Flags.getPriorityIndex( Task.Flags.PRIORITY_HIGHEST \| Task.Flags.STATE_QUEUED ), 0 ); assertEquals( Task.Flags.getPriorityIndex( Task.Flags.PRIORITY_HIGH \| Task.Flags.STATE_QUEUED ), 1 ); assertEquals( Task.Flags.getPriorityIndex( Task.Flags.PRIORITY_NORMAL \| Task.Flags.STATE_QUEUED ), 2 ); assertEquals( Task.Flags.getPriorityIndex( Task.Flags.PRIORITY_LOW \| Task.Flags.STATE_QUEUED ), 3 ); assertEquals( Task.Flags.getPriorityIndex( Task.Flags.PRIORITY_LOWEST \| Task.Flags.STATE_QUEUED ), 4 ); }
### Question: ActionFlags { static boolean isVerifyActionRuleValid( final int flags ) { return VERIFY_ACTION_REQUIRED == ( flags & VERIFY_ACTION_MASK ) \|\| NO_VERIFY_ACTION_REQUIRED == ( flags & VERIFY_ACTION_MASK ); } private ActionFlags(); static final int READ_ONLY; static final int READ_WRITE; static final int NO_REPORT_RESULT; static final int REQUIRE_NEW_TRANSACTION; static final int VERIFY_ACTION_REQUIRED; static final int NO_VERIFY_ACTION_REQUIRED; }### Answer: @Test public void isVerifyActionRuleValid() { assertTrue( ActionFlags.isVerifyActionRuleValid( ActionFlags.VERIFY_ACTION_REQUIRED ) ); assertTrue( ActionFlags.isVerifyActionRuleValid( ActionFlags.NO_VERIFY_ACTION_REQUIRED ) ); assertFalse( ActionFlags.isVerifyActionRuleValid( 0 ) ); assertFalse( ActionFlags.isVerifyActionRuleValid( ActionFlags.VERIFY_ACTION_REQUIRED \| ActionFlags.NO_VERIFY_ACTION_REQUIRED ) ); }
### Question: ActionFlags { static int verifyActionRule( final int flags ) { return Arez.shouldCheckApiInvariants() ? 0 != ( flags & VERIFY_ACTION_MASK ) ? 0 : VERIFY_ACTION_REQUIRED : 0; } private ActionFlags(); static final int READ_ONLY; static final int READ_WRITE; static final int NO_REPORT_RESULT; static final int REQUIRE_NEW_TRANSACTION; static final int VERIFY_ACTION_REQUIRED; static final int NO_VERIFY_ACTION_REQUIRED; }### Answer: @Test public void verifyActionRule() { assertEquals( ActionFlags.verifyActionRule( ActionFlags.VERIFY_ACTION_REQUIRED ), 0 ); assertEquals( ActionFlags.verifyActionRule( ActionFlags.NO_VERIFY_ACTION_REQUIRED ), 0 ); assertEquals( ActionFlags.verifyActionRule( 0 ), ActionFlags.VERIFY_ACTION_REQUIRED ); assertEquals( ActionFlags.verifyActionRule( ActionFlags.REQUIRE_NEW_TRANSACTION ), ActionFlags.VERIFY_ACTION_REQUIRED ); }
### Question: Transaction { long getStartedAt() { if ( Arez.shouldCheckInvariants() ) { invariant( Arez::areSpiesEnabled, () -> "Arez-0134: Transaction.getStartedAt() invoked when Arez.areSpiesEnabled() is false" ); } return _startedAt; } Transaction( @Nullable final ArezContext context, @Nullable final Transaction previous, @Nullable final String name, final boolean mutation, @Nullable final Observer tracker, final boolean zoneActivated ); @Nonnull @Override String toString(); }### Answer: @Test public void construction_whenSpyDisabled() { ArezTestUtil.disableSpies(); final Transaction transaction = new Transaction( Arez.context(), null, ValueUtil.randomString(), false, null, false ); ArezTestUtil.enableSpies(); assertEquals( transaction.getStartedAt(), 0 ); }
### Question: Transaction { static Transaction begin( @Nonnull final ArezContext context, @Nullable final String name, final boolean mutation, @Nullable final Observer tracker ) { if ( Arez.shouldCheckApiInvariants() && Arez.shouldEnforceTransactionType() ) { if ( null != c_transaction ) { final boolean inComputableTransaction = null != tracker && tracker.isComputableValue(); apiInvariant( () -> !c_transaction.isComputableValueTracker() \|\| inComputableTransaction, () -> "Arez-0186: Attempting to create transaction named '" + name + "' " + "nested in ComputableValue transaction named '" + c_transaction.getName() + "'. " + "ComputableValues must not invoke actions or observe methods as " + "they should derive values from other computeds and observables." ); apiInvariant( () -> !mutation \|\| c_transaction.isMutation(), () -> "Arez-0119: Attempting to create READ_WRITE transaction named '" + name + "' but it is " + "nested in transaction named '" + c_transaction.getName() + "' with mode " + "READ_ONLY which is not equal to READ_WRITE." ); apiInvariant( () -> c_transaction.getContext() != context \|\| inComputableTransaction \|\| null == tracker, () -> "Arez-0171: Attempting to create a tracking transaction named '" + name + "' for " + "the observer named '" + Objects.requireNonNull( tracker ).getName() + "' but the " + "transaction is not a top-level transaction when this is required. This may be a result " + "of nesting a observe() call inside an action or another observer function." ); } } if ( Arez.shouldCheckInvariants() ) { if ( !Arez.areZonesEnabled() && null != c_transaction ) { invariant( () -> c_transaction.getContext() == context, () -> "Arez-0120: Zones are not enabled but the transaction named '" + name + "' is " + "nested in a transaction named '" + c_transaction.getName() + "' from a " + "different context." ); } } boolean zoneActivated = false; if ( Arez.areZonesEnabled() ) { final Zone zone = context.getZone(); if ( Arez.currentZone() != zone ) { Arez.activateZone( zone ); zoneActivated = true; } } c_transaction = new Transaction( Arez.areZonesEnabled() ? context : null, c_transaction, name, mutation, tracker, zoneActivated ); context.disableScheduler(); c_transaction.begin(); if ( context.willPropagateSpyEvents() ) { assert null != name; final ObserverInfo trackerInfo = null != tracker ? tracker.asInfo() : null; context.getSpy().reportSpyEvent( new TransactionStartEvent( name, c_transaction.isMutation(), trackerInfo ) ); } return c_transaction; } Transaction( @Nullable final ArezContext context, @Nullable final Transaction previous, @Nullable final String name, final boolean mutation, @Nullable final Observer tracker, final boolean zoneActivated ); @Nonnull @Override String toString(); }### Answer: @Test public void begin() { final ArezContext context = Arez.context(); final Observer tracker = context.computable( () -> "" ).getObserver(); final Transaction transaction = new Transaction( context, null, ValueUtil.randomString(), false, tracker, false ); Transaction.setTransaction( transaction ); assertEquals( tracker.getState(), Observer.Flags.STATE_INACTIVE ); transaction.begin(); assertEquals( tracker.getState(), Observer.Flags.STATE_UP_TO_DATE ); }
### Question: Transaction { static void commit( @Nonnull final Transaction transaction ) { if ( Arez.shouldCheckInvariants() ) { invariant( () -> null != c_transaction, () -> "Arez-0122: Attempting to commit transaction named '" + transaction.getName() + "' but no transaction is active." ); assert null != c_transaction; invariant( () -> c_transaction == transaction, () -> "Arez-0123: Attempting to commit transaction named '" + transaction.getName() + "' but this does not match existing transaction named '" + c_transaction.getName() + "'." ); } assert null != c_transaction; try { c_transaction.commit(); if ( c_transaction.getContext().willPropagateSpyEvents() ) { final String name = c_transaction.getName(); final boolean mutation = !Arez.shouldEnforceTransactionType() \|\| c_transaction.isMutation(); final Observer tracker = c_transaction.getTracker(); final ObserverInfo trackerInfo = null != tracker ? tracker.asInfo() : null; final long duration = System.currentTimeMillis() - c_transaction.getStartedAt(); c_transaction .getContext() .getSpy() .reportSpyEvent( new TransactionCompleteEvent( name, mutation, trackerInfo, (int) duration ) ); } } finally { final Transaction previousInSameContext = Arez.areZonesEnabled() ? c_transaction.getPreviousInSameContext() : c_transaction.getPrevious(); if ( null == previousInSameContext ) { c_transaction.getContext().enableScheduler(); } c_transaction = c_transaction.getPrevious(); if ( Arez.areZonesEnabled() && transaction._zoneActivated ) { final Zone currentZone = transaction.getContext().getZone(); assert currentZone == Arez.currentZone(); Arez.deactivateZone( currentZone ); } } } Transaction( @Nullable final ArezContext context, @Nullable final Transaction previous, @Nullable final String name, final boolean mutation, @Nullable final Observer tracker, final boolean zoneActivated ); @Nonnull @Override String toString(); }### Answer: @Test public void commit() { final ArezContext context = Arez.context(); final ComputableValue<String> computableValue = context.computable( () -> "" ); final Observer tracker = computableValue.getObserver(); ensureDerivationHasObserver( tracker ); final Transaction transaction = new Transaction( context, null, ValueUtil.randomString(), false, tracker, false ); Transaction.setTransaction( transaction ); tracker.setState( Observer.Flags.STATE_UP_TO_DATE ); final ObservableValue<?> observableValue1 = context.observable(); final Observer derivation = context.computable( () -> "" ).getObserver(); derivation.setState( Observer.Flags.STATE_UP_TO_DATE ); final ObservableValue<?> observableValue2 = derivation.getComputableValue().getObservableValue(); observableValue2.markAsPendingDeactivation(); transaction.queueForDeactivation( observableValue2 ); assertNotNull( transaction.getPendingDeactivations() ); assertEquals( transaction.getPendingDeactivations().size(), 1 ); assertTrue( observableValue2.isActive() ); assertTrue( observableValue2.isPendingDeactivation() ); transaction.safeGetObservables().add( observableValue1 ); final List<ObservableValue<?>> dependencies = tracker.getDependencies(); transaction.commit(); assertEquals( tracker.getState(), Observer.Flags.STATE_UP_TO_DATE ); assertNotSame( tracker.getDependencies(), dependencies ); assertEquals( tracker.getDependencies().size(), 1 ); assertTrue( tracker.getDependencies().contains( observableValue1 ) ); assertEquals( observableValue1.getWorkState(), ObservableValue.NOT_IN_CURRENT_TRACKING ); assertFalse( observableValue2.isPendingDeactivation() ); assertFalse( observableValue2.isActive() ); assertEquals( observableValue2.getObserver(), derivation ); assertEquals( derivation.getState(), Observer.Flags.STATE_INACTIVE ); }
### Question: ComputableValueInfoImpl implements ComputableValueInfo { @Nullable @Override public ComponentInfo getComponent() { if ( Arez.shouldCheckInvariants() ) { invariant( Arez::areNativeComponentsEnabled, () -> "Arez-0109: Spy.getComponent invoked when Arez.areNativeComponentsEnabled() returns false." ); } final Component component = _computableValue.getComponent(); return null == component ? null : component.asInfo(); } ComputableValueInfoImpl( @Nonnull final ComputableValue<?> computableValue ); @Nonnull @Override String getName(); @Override boolean isComputing(); @Nonnull @Override Priority getPriority(); @Override boolean isActive(); @Nonnull @Override List<ObservableValueInfo> getDependencies(); @Nonnull @Override List<ObserverInfo> getObservers(); @Nullable @Override ComponentInfo getComponent(); @OmitSymbol( unless = "arez.enable_property_introspection" ) @Nullable @Override Object getValue(); @Override boolean isDisposed(); @Override String toString(); @Override boolean equals( final Object o ); @Override int hashCode(); }### Answer: @Test public void getComponent_ComputableValue_nativeComponentsDisabled() { ArezTestUtil.disableNativeComponents(); final ArezContext context = Arez.context(); final ComputableValue<Object> computableValue = context.computable( () -> "" ); assertInvariantFailure( () -> computableValue.asInfo().getComponent(), "Arez-0109: Spy.getComponent invoked when Arez.areNativeComponentsEnabled() returns false." ); }
### Question: Transaction { void beginTracking() { if ( null != _tracker ) { if ( Arez.shouldCheckInvariants() ) { _tracker.invariantDependenciesBackLink( "Pre beginTracking" ); } if ( !_tracker.isDisposing() ) { _tracker.setState( Observer.Flags.STATE_UP_TO_DATE ); } _tracker.markDependenciesLeastStaleObserverAsUpToDate(); } } Transaction( @Nullable final ArezContext context, @Nullable final Transaction previous, @Nullable final String name, final boolean mutation, @Nullable final Observer tracker, final boolean zoneActivated ); @Nonnull @Override String toString(); }### Answer: @Test public void beginTracking() { final ArezContext context = Arez.context(); final Observer tracker = context.computable( () -> "" ).getObserver(); final Transaction transaction = new Transaction( context, null, ValueUtil.randomString(), false, tracker, false ); Transaction.setTransaction( transaction ); ensureDerivationHasObserver( tracker ); tracker.setState( Observer.Flags.STATE_STALE ); assertEquals( tracker.getState(), Observer.Flags.STATE_STALE ); final ObservableValue<?> observableValue = context.observable(); observableValue.setLeastStaleObserverState( Observer.Flags.STATE_STALE ); tracker.getDependencies().add( observableValue ); observableValue.rawAddObserver( tracker ); transaction.beginTracking(); assertEquals( tracker.getState(), Observer.Flags.STATE_UP_TO_DATE ); assertEquals( observableValue.getLeastStaleObserverState(), Observer.Flags.STATE_UP_TO_DATE ); }

Subsets and Splits

No community queries yet

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