src_fm_fc_ms_ff
stringlengths 43
86.8k
| target
stringlengths 20
276k
|
|---|---|
DebtDetailPresenter implements DebtDetailContract.Presenter, LoaderManager.LoaderCallbacks<PersonDebt> { @Override public void deletePayment(@NonNull Payment payment) { checkNotNull(payment); EspressoIdlingResource.increment(); mDebtsRepository.deletePayment(payment); mDebtDetailView.showPaymentDeleted(); refreshPayments(); } @Inject DebtDetailPresenter(@NonNull String debtId,
@NonNull PersonDebtsRepository debtsRepository,
@NonNull DebtDetailContract.View view,
@NonNull LoaderManager loaderManager,
@NonNull DebtLoader loader); @Override void start(); @Override void stop(); @Override void addPartialPayment(@NonNull Payment payment); @Override void editPayment(@NonNull Payment payment, @NonNull Debt debt); @Override void deletePersonDebt(@NonNull PersonDebt personDebt); @Override void deletePayment(@NonNull Payment payment); @Override void refreshPayments(); @Override Loader<PersonDebt> onCreateLoader(int id, Bundle args); @Override void onLoadFinished(Loader<PersonDebt> loader, PersonDebt personDebt); @Override void onLoaderReset(Loader<PersonDebt> loader); } | @Test public void shouldBeAbleToDeletePayment() { Payment payment = TestUtil.createAndGetADebtPayment1(mDebt.getId()); when(mRepository.getPersonDebt(anyString(), anyInt())).thenReturn(mPersonDebt); mDebtDetailPresenter.deletePayment(payment); verify(mRepository).deletePayment(eq(payment)); verify(mView).showPersonDebt(eq(mPersonDebt)); } |
ConfigPropertySource extends PropertySource<Object> { @Override public Object getProperty(String name) { return containsProperty(name) ? config.getAnyRef(name) : null; } ConfigPropertySource(Config config, String name); @Override boolean containsProperty(String name); @Override Object getProperty(String name); } | @Test public void getRequiredProperty_resolve_stringProperty() throws Exception { ctx.refresh(); String value = ctx.getEnvironment().getProperty("foo"); assertEquals("bar", value); assertEquals(Integer.valueOf(1), ctx.getEnvironment().getProperty("number", Integer.class)); } |
RelationResolver extends AbstractResolver<Relation> { @SuppressWarnings("unchecked") public Class<? extends Concept> getTargetEntityClass(final Class<? extends Relation> clazz) { if (TARGETS_CACHE.containsKey(checkNotNull(clazz))) { return (Class<? extends Concept>) TARGETS_CACHE.get(clazz); } @SuppressWarnings("unchecked") final Optional<Class<? extends Concept>> targetClazz = (Optional<Class<? extends Concept>>) ReflectionGenericsResolver.getParameterTypeFromClass( clazz, Relation.class, Relation.TARGET_PARAMETER_POSITION ); if ( ! targetClazz.isPresent()) { throw new KasperException("Unable to find target concept type for relation " + clazz.getClass()); } TARGETS_CACHE.put(clazz, targetClazz.get()); return targetClazz.get(); } RelationResolver(); RelationResolver(final ConceptResolver conceptResolver); @Override String getTypeName(); @Override @SuppressWarnings("unchecked") Optional<Class<? extends Domain>> getDomainClass(final Class<? extends Relation> clazz); String getVerb(final Class<? extends Relation> clazz); @Override String getLabel(final Class<? extends Relation> clazz); @Override String getDescription(Class<? extends Relation> clazz); @SuppressWarnings("unchecked") Class<? extends Concept> getSourceEntityClass(final Class<? extends Relation> clazz); @SuppressWarnings("unchecked") Class<? extends Concept> getTargetEntityClass(final Class<? extends Relation> clazz); boolean isBidirectional(final Class<? extends Relation> clazz); Optional<String> biDirectionalVerb(final Class<? extends Relation> clazz); void setConceptResolver(final ConceptResolver conceptResolver); } | @Test public void testGetTargetWithInvalidRelation() { final RelationResolver resolver = new RelationResolver(); try { final Class<? extends Concept> conceptClass = resolver.getTargetEntityClass(TestRelation.class); fail(); } catch (final KasperException e) { } }
@Test public void testGetTargetWithValidRelation() { final RelationResolver resolver = new RelationResolver(); final Class<? extends Concept> conceptClass = resolver.getTargetEntityClass(TestRelation2.class); assertEquals(TestRootConceptTarget.class, conceptClass); } |
EventResolver extends AbstractResolver<Event> { @Override @SuppressWarnings("unchecked") public Optional<Class<? extends Domain>> getDomainClass(final Class<? extends Event> clazz) { if (DOMAINS_CACHE.containsKey(checkNotNull(clazz))) { return Optional.<Class<? extends Domain>>of(DOMAINS_CACHE.get(clazz)); } final Optional<Class<? extends Domain>> domainClazz; if (DomainEvent.class.isAssignableFrom(clazz)) { domainClazz = (Optional<Class<? extends Domain>>) ReflectionGenericsResolver.getParameterTypeFromClass( clazz, DomainEvent.class, DomainEvent.DOMAIN_PARAMETER_POSITION ); if ( ! domainClazz.isPresent()) { throw new KasperException("Unable to find domain type for domain event " + clazz.getClass()); } } else if (null == domainResolver) { domainClazz = Optional.absent(); } else { domainClazz = domainResolver.getDomainClassOf(clazz); } if (domainClazz.isPresent()) { DOMAINS_CACHE.put(clazz, domainClazz.get()); } return domainClazz; } @Override String getTypeName(); @Override @SuppressWarnings("unchecked") Optional<Class<? extends Domain>> getDomainClass(final Class<? extends Event> clazz); @Override String getLabel(final Class<? extends Event> clazz); @Override String getDescription(final Class<? extends Event> eventClazz); String getAction(final Class<? extends Event> eventClazz); } | @Test public void testGetDomainFromDomainEvent() { final EventResolver resolver = new EventResolver(); final Optional<Class<? extends Domain>> domain = resolver.getDomainClass(TestDomainEvent.class); assertTrue(domain.isPresent()); assertEquals(TestDomain.class, domain.get()); }
@Test public void testGetDomainFromGenericDomainEvent() { final EventResolver resolver = new EventResolver(); try { final Optional<Class<? extends Domain>> domain = resolver.getDomainClass(TestGenericDomainEvent.class); fail(); } catch (final KasperException e) { } }
@Test public void testGetDomainFromEvent() { final EventResolver resolver = new EventResolver(); final Optional<Class<? extends Domain>> domain = resolver.getDomainClass(TestEvent.class); assertFalse(domain.isPresent()); } |
EntityResolver extends AbstractResolver<Entity> { public List<Class<? extends Concept>> getComponentConcepts(final Class<? extends AggregateRoot> conceptClazz) { final List<Class<? extends Concept>> linkedConcepts = Lists.newArrayList(); for (final Field field : checkNotNull(conceptClazz).getDeclaredFields()) { if (LinkedConcept.class.isAssignableFrom(field.getType())) { @SuppressWarnings("unchecked") final Optional<Class<? extends Concept>> linkedConceptClazz = (Optional<Class<? extends Concept>>) ReflectionGenericsResolver.getParameterTypeFromClass( field, LinkedConcept.class, LinkedConcept.CONCEPT_PARAMETER_POSITION ); if ( ! linkedConceptClazz.isPresent()) { throw new KasperException(String.format( "Unable to find concept type for linked field %s in concept %s", field.getName(), conceptClazz.getClass().getSimpleName() )); } linkedConcepts.add(linkedConceptClazz.get()); } } return linkedConcepts; } EntityResolver(); EntityResolver(final ConceptResolver conceptResolver, final RelationResolver relationResolver); @Override String getTypeName(); @Override @SuppressWarnings("unchecked") Optional<Class<? extends Domain>> getDomainClass(final Class<? extends Entity> clazz); @Override @SuppressWarnings("unchecked") String getDescription(final Class<? extends Entity> clazz); @Override @SuppressWarnings("unchecked") String getLabel(final Class<? extends Entity> clazz); void setConceptResolver(final ConceptResolver conceptResolver); void setRelationResolver(final RelationResolver relationResolver); @SuppressWarnings("unchecked") Collection<Class<? extends Event>> getListenedSourceEvents(final Class<? extends Entity> clazz); List<Class<? extends Concept>> getComponentConcepts(final Class<? extends AggregateRoot> conceptClazz); } | @Test public void testGetComponentConcepts() { final EntityResolver resolver = new EntityResolver(); final List<Class<? extends Concept>> links = resolver.getComponentConcepts(TestConcept.class); assertEquals(1, links.size()); assertEquals(TestConcept2.class, links.get(0)); } |
QueryHandlerResolver extends AbstractResolver<QueryHandler> { @Override @SuppressWarnings("unchecked") public Optional<Class<? extends Domain>> getDomainClass(final Class<? extends QueryHandler> clazz) { if (DOMAINS_CACHE.containsKey(checkNotNull(clazz))) { return Optional.<Class<? extends Domain>>of(DOMAINS_CACHE.get(clazz)); } final XKasperQueryHandler annotation = clazz.getAnnotation(XKasperQueryHandler.class); if (null != annotation) { final Class<? extends Domain> domain = annotation.domain(); DOMAINS_CACHE.put(clazz, domain); return Optional.<Class<? extends Domain>>of(domain); } return Optional.absent(); } QueryHandlerResolver(); QueryHandlerResolver(final DomainResolver domainResolver); @Override String getTypeName(); @Override @SuppressWarnings("unchecked") Optional<Class<? extends Domain>> getDomainClass(final Class<? extends QueryHandler> clazz); String getDescription(Class<? extends QueryHandler> clazz); @Override String getLabel(final Class<? extends QueryHandler> clazz); @SuppressWarnings("unchecked") Class<? extends Query> getQueryClass(final Class<? extends QueryHandler> clazz); @SuppressWarnings("unchecked") Class<? extends QueryResult> getQueryResultClass(final Class<? extends QueryHandler> clazz); } | @Test public void testGetDomainWithDecoratedQueryHandler() { final QueryHandlerResolver resolver = new QueryHandlerResolver(); final Optional<Class<? extends Domain>> domain = resolver.getDomainClass(TestQueryHandler.class); assertTrue(domain.isPresent()); assertEquals(TestDomain.class, domain.get()); }
@Test public void testGetDomainWithNonDecoratedQueryHandler() { final QueryHandlerResolver resolver = new QueryHandlerResolver(); final Optional<Class<? extends Domain>> domain = resolver.getDomainClass(TestQueryHandler2.class); assertFalse(domain.isPresent()); } |
QueryHandlerResolver extends AbstractResolver<QueryHandler> { @SuppressWarnings("unchecked") public Class<? extends Query> getQueryClass(final Class<? extends QueryHandler> clazz) { if (QUERY_CACHE.containsKey(checkNotNull(clazz))) { return QUERY_CACHE.get(clazz); } @SuppressWarnings("unchecked") final Optional<Class<? extends Query>> queryClazz = (Optional<Class<? extends Query>>) ReflectionGenericsResolver.getParameterTypeFromClass( clazz, QueryHandler.class, QueryHandler.PARAMETER_QUERY_POSITION ); if ( ! queryClazz.isPresent()) { throw new KasperException("Unable to find query type for query handler " + clazz.getClass()); } QUERY_CACHE.put(clazz, queryClazz.get()); return queryClazz.get(); } QueryHandlerResolver(); QueryHandlerResolver(final DomainResolver domainResolver); @Override String getTypeName(); @Override @SuppressWarnings("unchecked") Optional<Class<? extends Domain>> getDomainClass(final Class<? extends QueryHandler> clazz); String getDescription(Class<? extends QueryHandler> clazz); @Override String getLabel(final Class<? extends QueryHandler> clazz); @SuppressWarnings("unchecked") Class<? extends Query> getQueryClass(final Class<? extends QueryHandler> clazz); @SuppressWarnings("unchecked") Class<? extends QueryResult> getQueryResultClass(final Class<? extends QueryHandler> clazz); } | @Test public void testGetQueryFromValidService() { final QueryHandlerResolver resolver = new QueryHandlerResolver(); final Class<? extends Query> query = resolver.getQueryClass(TestQueryHandler3.class); assertEquals(TestQuery.class, query); }
@Test public void testGetQueryFromInvalidHandler() { final QueryHandlerResolver resolver = new QueryHandlerResolver(); try { resolver.getQueryClass(TestQueryHandler.class); fail(); } catch (final KasperException e) { } } |
QueryHandlerResolver extends AbstractResolver<QueryHandler> { @SuppressWarnings("unchecked") public Class<? extends QueryResult> getQueryResultClass(final Class<? extends QueryHandler> clazz) { if (RESULT_CACHE.containsKey(checkNotNull(clazz))) { return RESULT_CACHE.get(clazz); } @SuppressWarnings("unchecked") final Optional<Class<? extends QueryResult>> queryResultClazz = (Optional<Class<? extends QueryResult>>) ReflectionGenericsResolver.getParameterTypeFromClass( clazz, QueryHandler.class, QueryHandler.PARAMETER_RESULT_POSITION ); if ( ! queryResultClazz.isPresent()) { throw new KasperException("Unable to find query result type for query handler " + clazz.getClass()); } RESULT_CACHE.put(clazz, queryResultClazz.get()); return queryResultClazz.get(); } QueryHandlerResolver(); QueryHandlerResolver(final DomainResolver domainResolver); @Override String getTypeName(); @Override @SuppressWarnings("unchecked") Optional<Class<? extends Domain>> getDomainClass(final Class<? extends QueryHandler> clazz); String getDescription(Class<? extends QueryHandler> clazz); @Override String getLabel(final Class<? extends QueryHandler> clazz); @SuppressWarnings("unchecked") Class<? extends Query> getQueryClass(final Class<? extends QueryHandler> clazz); @SuppressWarnings("unchecked") Class<? extends QueryResult> getQueryResultClass(final Class<? extends QueryHandler> clazz); } | @Test public void testGetQueryResultFromValidHandler() { final QueryHandlerResolver resolver = new QueryHandlerResolver(); final Class<? extends QueryResult> queryResult = resolver.getQueryResultClass(TestQueryHandler3.class); assertEquals(TestQueryResult.class, queryResult); }
@Test public void testGetQueryResultFromInvalidHandler() { final QueryHandlerResolver resolver = new QueryHandlerResolver(); try { resolver.getQueryResultClass(TestQueryHandler.class); fail(); } catch (final KasperException e) { } } |
AbstractKasperID implements KasperID { @Override public boolean equals(final Object otherId) { if (this == checkNotNull(otherId)) { return true; } if (KasperID.class.isAssignableFrom(otherId.getClass())) { final KasperID other = (KasperID) otherId; return this.toString().equals(other.toString()); } return this.id.equals(otherId); } protected AbstractKasperID(); protected AbstractKasperID(final T id); @Override boolean equals(final Object otherId); @Override int hashCode(); @Override T getId(); @Override String toString(); } | @Test public void testID() { final TestID id1 = new TestID(INT_ID_A); final TestID id2 = new TestID(INT_ID_A); final TestID id3 = new TestID(INT_ID_B); assertTrue(id1.equals(id1)); assertTrue(id1.equals(id2)); assertTrue(id1.equals(INT_ID_A)); assertFalse(id1.equals(id3)); assertFalse(id1.equals(INT_ID_B)); } |
EventListenerResolver extends AbstractResolver<EventListener> { @Override @SuppressWarnings("unchecked") public Optional<Class<? extends Domain>> getDomainClass(final Class<? extends EventListener> clazz) { if (DOMAINS_CACHE.containsKey(checkNotNull(clazz))) { return Optional.<Class<? extends Domain>>of(DOMAINS_CACHE.get(clazz)); } final XKasperEventListener eventAnnotation = clazz.getAnnotation(XKasperEventListener.class); if (null != eventAnnotation) { final Class<? extends Domain> domain = eventAnnotation.domain(); DOMAINS_CACHE.put(clazz, domain); return Optional.<Class<? extends Domain>>of(domain); } return Optional.absent(); } @Override String getTypeName(); @Override @SuppressWarnings("unchecked") Optional<Class<? extends Domain>> getDomainClass(final Class<? extends EventListener> clazz); @Override String getLabel(final Class<? extends EventListener> clazz); @Override String getDescription(final Class<? extends EventListener> clazz); Class<? extends Event> getEventClass(final Class<? extends EventListener> clazz); @Override void clearCache(); } | @Test public void testGetDomainFromEventListener() { final EventListenerResolver resolver = new EventListenerResolver(); final Optional<Class<? extends Domain>> domain = resolver.getDomainClass(TestEventListener.class); assertTrue(domain.isPresent()); assertEquals(TestDomain.class, domain.get()); } |
EventListenerResolver extends AbstractResolver<EventListener> { public Class<? extends Event> getEventClass(final Class<? extends EventListener> clazz) { if (cacheEvents.containsKey(checkNotNull(clazz))) { return cacheEvents.get(clazz); } final Optional<Class<? extends Event>> eventClazz = (Optional<Class<? extends Event>>) ReflectionGenericsResolver.getParameterTypeFromClass( clazz, EventListener.class, EventListener.EVENT_PARAMETER_POSITION ); if ( ! eventClazz.isPresent()) { throw new KasperException("Unable to find event type for listener " + clazz.getClass()); } cacheEvents.put(clazz, eventClazz.get()); return eventClazz.get(); } @Override String getTypeName(); @Override @SuppressWarnings("unchecked") Optional<Class<? extends Domain>> getDomainClass(final Class<? extends EventListener> clazz); @Override String getLabel(final Class<? extends EventListener> clazz); @Override String getDescription(final Class<? extends EventListener> clazz); Class<? extends Event> getEventClass(final Class<? extends EventListener> clazz); @Override void clearCache(); } | @Test public void testGetEventFromValidHandler() { final EventListenerResolver resolver = new EventListenerResolver(); final Class<? extends Event> command = resolver.getEventClass(TestEventListener2.class); assertEquals(TestEvent.class, command); }
@Test public void testGetEventFromInvalidHandler() { final EventListenerResolver resolver = new EventListenerResolver(); try { resolver.getEventClass(TestEventListener.class); fail(); } catch (final KasperException e) { } } |
QueryResultResolver extends AbstractResolver<QueryResult> { @Override @SuppressWarnings("unchecked") public Optional<Class<? extends Domain>> getDomainClass(final Class<? extends QueryResult> clazz) { if (DOMAINS_CACHE.containsKey(checkNotNull(clazz))) { return Optional.<Class<? extends Domain>>of(DOMAINS_CACHE.get(clazz)); } Optional<Class<? extends Domain>> result = Optional.absent(); if (null != queryHandlersLocator) { final Collection<QueryHandler> queryHandlers = this.queryHandlersLocator.getHandlersFromQueryResultClass(clazz); for (final QueryHandler queryHandler : queryHandlers) { final Optional<Class<? extends Domain>> domain = this.queryHandlerResolver.getDomainClass(queryHandler.getClass()); if (domain.isPresent()) { if (result.isPresent()) { throw new KasperException("More than one domain found"); } result = domain; } } } else { result = domainResolver.getDomainClassOf(clazz); } if (result.isPresent()) { DOMAINS_CACHE.put(clazz, result.get()); } return result; } @Override String getTypeName(); @SuppressWarnings("unchecked") Class<? extends QueryResult> getElementClass(final Class<? extends CollectionQueryResult> clazz); @Override @SuppressWarnings("unchecked") Optional<Class<? extends Domain>> getDomainClass(final Class<? extends QueryResult> clazz); @Override String getDescription(final Class<? extends QueryResult> clazz); @Override String getLabel(final Class<? extends QueryResult> clazz); void setQueryHandlersLocator(final QueryHandlersLocator queryHandlersLocator); void setQueryHandlerResolver(final QueryHandlerResolver queryHandlerResolver); } | @Test public void testGetDomain() { final QueryHandler queryHandler = mock(QueryHandler.class); when( queryHandlersLocator.getHandlersFromQueryResultClass(TestQueryResult.class) ) .thenReturn(Collections.singletonList(queryHandler) ); when( queryHandlerResolver.getDomainClass(queryHandler.getClass()) ) .thenReturn(Optional.<Class<? extends Domain>>of(TestDomain.class)); final Optional<Class<? extends Domain>> domain = resolver.getDomainClass(TestQueryResult.class); assertTrue(domain.isPresent()); assertEquals(TestDomain.class, domain.get()); verify(queryHandlersLocator, times(1)).getHandlersFromQueryResultClass(TestQueryResult.class); verifyNoMoreInteractions(queryHandlersLocator); verify(queryHandlerResolver, times(1)).getDomainClass(queryHandler.getClass()); verifyNoMoreInteractions(queryHandlerResolver); } |
QueryResultResolver extends AbstractResolver<QueryResult> { @SuppressWarnings("unchecked") public Class<? extends QueryResult> getElementClass(final Class<? extends CollectionQueryResult> clazz) { if (cacheElements.containsKey(clazz)) { return cacheElements.get(clazz); } @SuppressWarnings("unchecked") final Optional<Class<? extends QueryResult>> elementClass = (Optional<Class<? extends QueryResult>>) ReflectionGenericsResolver.getParameterTypeFromClass( clazz, CollectionQueryResult.class, CollectionQueryResult.PARAMETER_RESULT_POSITION ); if ( ! elementClass.isPresent()) { throw new KasperException("Unable to find command type for handler " + clazz.getClass()); } cacheElements.put(clazz, elementClass.get()); return elementClass.get(); } @Override String getTypeName(); @SuppressWarnings("unchecked") Class<? extends QueryResult> getElementClass(final Class<? extends CollectionQueryResult> clazz); @Override @SuppressWarnings("unchecked") Optional<Class<? extends Domain>> getDomainClass(final Class<? extends QueryResult> clazz); @Override String getDescription(final Class<? extends QueryResult> clazz); @Override String getLabel(final Class<? extends QueryResult> clazz); void setQueryHandlersLocator(final QueryHandlersLocator queryHandlersLocator); void setQueryHandlerResolver(final QueryHandlerResolver queryHandlerResolver); } | @Test(expected = KasperException.class) public void getElementClass_fromQueryResult_throwException() { resolver.getElementClass(UnknownCollectionQueryResult.class); }
@Test public void getElementClass_fromCollectionQueryResult_returnElementClass() { final Class<? extends QueryResult> elementClass = resolver.getElementClass(TestCollectionQueryResult.class); assertNotNull(elementClass); assertEquals(TestQueryResult.class, elementClass); } |
ConceptResolver extends AbstractResolver<Concept> { @SuppressWarnings("unchecked") @Override public Optional<Class<? extends Domain>> getDomainClass(final Class<? extends Concept> clazz) { if (DOMAINS_CACHE.containsKey(checkNotNull(clazz))) { return Optional.<Class<? extends Domain>>of(DOMAINS_CACHE.get(clazz)); } final XKasperConcept conceptAnnotation = clazz.getAnnotation(XKasperConcept.class); if (null != conceptAnnotation) { final Class<? extends Domain> domain = conceptAnnotation.domain(); DOMAINS_CACHE.put(clazz, domain); return Optional.<Class<? extends Domain>>of(domain); } return Optional.absent(); } @Override String getTypeName(); @SuppressWarnings("unchecked") @Override Optional<Class<? extends Domain>> getDomainClass(final Class<? extends Concept> clazz); @Override String getDescription(Class<? extends Concept> conceptClazz); @Override String getLabel(Class<? extends Concept> conceptClazz); } | @Test public void testGetDomainWithDecoratedConcept() { final ConceptResolver resolver = new ConceptResolver(); final Optional<Class<? extends Domain>> domain = resolver.getDomainClass(TestConcept.class); assertTrue(domain.isPresent()); assertEquals(TestDomain.class, domain.get()); }
@Test public void testGetDomainWithNonDecoratedConcept() { final ConceptResolver resolver = new ConceptResolver(); final Optional<Class<? extends Domain>> domain = resolver.getDomainClass(TestConcept2.class); assertFalse(domain.isPresent()); } |
CommandHandlerResolver extends AbstractResolver<CommandHandler> { @Override @SuppressWarnings("unchecked") public Optional<Class<? extends Domain>> getDomainClass(final Class<? extends CommandHandler> clazz) { if (DOMAINS_CACHE.containsKey(checkNotNull(clazz))) { return Optional.<Class<? extends Domain>>of(DOMAINS_CACHE.get(clazz)); } final XKasperCommandHandler handlerAnnotation = clazz.getAnnotation(XKasperCommandHandler.class); if (null != handlerAnnotation) { final Class<? extends Domain> domain = handlerAnnotation.domain(); DOMAINS_CACHE.put(clazz, domain); return Optional.<Class<? extends Domain>>of(domain); } return Optional.absent(); } @Override String getTypeName(); @Override @SuppressWarnings("unchecked") Optional<Class<? extends Domain>> getDomainClass(final Class<? extends CommandHandler> clazz); @Override String getDescription(Class<? extends CommandHandler> handlerClazz); @Override String getLabel(final Class<? extends CommandHandler> clazz); @SuppressWarnings("unchecked") Class<? extends Command> getCommandClass(final Class<? extends CommandHandler> clazz); @SuppressWarnings("unchecked") // @javax.annotation.Nullable Optional<Class<? extends CommandHandler>> getHandlerClass(final Class<? extends Command> commandClass); @Override void clearCache(); } | @Test public void testGetDomainFromCommandHandler() { final CommandHandlerResolver resolver = new CommandHandlerResolver(); final Optional<Class<? extends Domain>> domain = resolver.getDomainClass(TestCommandHandler.class); assertTrue(domain.isPresent()); assertEquals(TestDomain.class, domain.get()); } |
AbstractKasperID implements KasperID { @Override public int hashCode() { return this.id.hashCode(); } protected AbstractKasperID(); protected AbstractKasperID(final T id); @Override boolean equals(final Object otherId); @Override int hashCode(); @Override T getId(); @Override String toString(); } | @Test public void testHashCode() { final TestID id1 = new TestID(INT_ID_A); final TestID id2 = new TestID(INT_ID_A); final TestID id3 = new TestID(INT_ID_B); assertEquals(id1.hashCode(), id1.hashCode()); assertEquals(id1.hashCode(), id2.hashCode()); assertNotSame(id1.hashCode(), id3.hashCode()); } |
CommandHandlerResolver extends AbstractResolver<CommandHandler> { @SuppressWarnings("unchecked") public Class<? extends Command> getCommandClass(final Class<? extends CommandHandler> clazz) { if (cacheCommands.containsKey(checkNotNull(clazz))) { return cacheCommands.get(clazz); } @SuppressWarnings("unchecked") final Optional<Class<? extends Command>> commandClazz = (Optional<Class<? extends Command>>) ReflectionGenericsResolver.getParameterTypeFromClass( clazz, CommandHandler.class, CommandHandler.COMMAND_PARAMETER_POSITION ); if ( ! commandClazz.isPresent()) { throw new KasperException("Unable to find command type for handler " + clazz.getClass()); } putCommandClass(clazz, commandClazz); return commandClazz.get(); } @Override String getTypeName(); @Override @SuppressWarnings("unchecked") Optional<Class<? extends Domain>> getDomainClass(final Class<? extends CommandHandler> clazz); @Override String getDescription(Class<? extends CommandHandler> handlerClazz); @Override String getLabel(final Class<? extends CommandHandler> clazz); @SuppressWarnings("unchecked") Class<? extends Command> getCommandClass(final Class<? extends CommandHandler> clazz); @SuppressWarnings("unchecked") // @javax.annotation.Nullable Optional<Class<? extends CommandHandler>> getHandlerClass(final Class<? extends Command> commandClass); @Override void clearCache(); } | @Test public void testGetCommandFromValidHandler() { final CommandHandlerResolver resolver = new CommandHandlerResolver(); final Class<? extends Command> command = resolver.getCommandClass(TestCommandHandler2.class); assertEquals(TestCommand.class, command); }
@Test public void testGetCommandFromInvalidHandler() { final CommandHandlerResolver resolver = new CommandHandlerResolver(); try { resolver.getCommandClass(TestCommandHandler.class); fail(); } catch (final KasperException e) { } } |
QueryAttributesKeyGenerator implements QueryCacheKeyGenerator<Q> { final Set<String> retainMissingNames(final Set<String> expectedFieldNames, final Set<Field> discoveredFields) { final Set<String> discoveredNames = Sets.newHashSet( Iterables.transform( discoveredFields, new Function<Field, String>() { @Override public String apply(Field input) { return input.getName(); } } ) ); return Sets.filter( expectedFieldNames, new Predicate<String>() { @Override public boolean apply(final String input) { return ! discoveredNames.contains(input); } } ); } @Override Serializable computeKey(final Optional<ID> user, final Q query, final String... fields); } | @Test public void testSetDifference() throws NoSuchFieldException { final Set<String> missingNames; missingNames = keyGenerator.retainMissingNames( Sets.newHashSet("str", "integer"), Sets.newHashSet(SomeQuery.class.getDeclaredField("str")) ); assertIterableEquals(Lists.newArrayList("integer"), missingNames); } |
InterceptorChain { @SafeVarargs public static <I, O> InterceptorChain<I, O> makeChain(final Interceptor<I, O>...chain) { return makeChain(Lists.newArrayList(checkNotNull(chain))); } InterceptorChain(); @SuppressWarnings("unchecked") // TAIL is generic InterceptorChain(final Interceptor<INPUT, OUTPUT> actor); InterceptorChain(final Interceptor<INPUT, OUTPUT> actor, final InterceptorChain<INPUT, OUTPUT> next); @SuppressWarnings("unchecked") static InterceptorChain<I, O> tail(); @SafeVarargs static InterceptorChain<I, O> makeChain(final Interceptor<I, O>...chain); static InterceptorChain<I, O> makeChain(final Iterable<? extends Interceptor<I, O>> chain); @SuppressWarnings("unchecked") // TAIL is generic static InterceptorChain<I, O> makeChain(final Iterator<? extends Interceptor<I, O>> chain); OUTPUT next(final INPUT input, final Context context); Optional<Interceptor<INPUT, OUTPUT>> last(); InterceptorChain<INPUT, OUTPUT> withPrevious(final Interceptor<INPUT, OUTPUT> previous); InterceptorChain<INPUT, OUTPUT> withNextChain(final InterceptorChain<INPUT, OUTPUT> chain); @VisibleForTesting
final Optional<Interceptor<INPUT, OUTPUT>> actor; @VisibleForTesting
final Optional<InterceptorChain<INPUT, OUTPUT>> next; } | @Test public void testIteratorToChain() { final DummyInterceptor d1 = new DummyInterceptor(); final DummyInterceptor d2 = new DummyInterceptor(); final Iterable<DummyInterceptor> chain = Lists.newArrayList(null, d1, null, d2, null); final InterceptorChain<Query, QueryResult> actualChain = InterceptorChain.makeChain(chain); InterceptorChain<Query, QueryResult> elt = actualChain; for (final DummyInterceptor e : Lists.newArrayList(d1, d2)) { assertEquals(e, elt.actor.get()); elt = actualChain.next.get(); } } |
InterceptorChain { public Optional<Interceptor<INPUT, OUTPUT>> last() { if (next.isPresent() && next.get().actor.isPresent()) { return next.get().last(); } else { return actor; } } InterceptorChain(); @SuppressWarnings("unchecked") // TAIL is generic InterceptorChain(final Interceptor<INPUT, OUTPUT> actor); InterceptorChain(final Interceptor<INPUT, OUTPUT> actor, final InterceptorChain<INPUT, OUTPUT> next); @SuppressWarnings("unchecked") static InterceptorChain<I, O> tail(); @SafeVarargs static InterceptorChain<I, O> makeChain(final Interceptor<I, O>...chain); static InterceptorChain<I, O> makeChain(final Iterable<? extends Interceptor<I, O>> chain); @SuppressWarnings("unchecked") // TAIL is generic static InterceptorChain<I, O> makeChain(final Iterator<? extends Interceptor<I, O>> chain); OUTPUT next(final INPUT input, final Context context); Optional<Interceptor<INPUT, OUTPUT>> last(); InterceptorChain<INPUT, OUTPUT> withPrevious(final Interceptor<INPUT, OUTPUT> previous); InterceptorChain<INPUT, OUTPUT> withNextChain(final InterceptorChain<INPUT, OUTPUT> chain); @VisibleForTesting
final Optional<Interceptor<INPUT, OUTPUT>> actor; @VisibleForTesting
final Optional<InterceptorChain<INPUT, OUTPUT>> next; } | @Test public void last_fromEmptyChain_shouldReturnAbsent(){ final InterceptorChain<Query, QueryResult> chain = new InterceptorChain<>(); final Optional<Interceptor<Query,QueryResult>> optionalLastInterceptor = chain.last(); assertFalse(optionalLastInterceptor.isPresent()); } |
KasperDocResource implements Resource { private static Optional<AbstractDomainElement> get(final DocumentedDomain documentedDomain, final DocumentedElementType type, final String name) { for (final AbstractDomainElement documentedDomainElement : get(documentedDomain, type)) { if (documentedDomainElement.getName().equals(name)) { return Optional.of(documentedDomainElement); } } return Optional.absent(); } KasperDocResource(final DocumentedPlatform documentedPlatform); @GET @Path("domains") @Produces(MediaType.APPLICATION_JSON) RetMap getDomains(); @GET @Path("domain/{domainName}") @Produces(MediaType.APPLICATION_JSON) Object getDomain(@PathParam("domainName") final String domainName); @GET @Path("domain/{domainName}/{type}") @Produces(MediaType.APPLICATION_JSON) Object getEntities(@PathParam("domainName") final String domainName,
@PathParam("type") final String type); @GET @Path("domain/{domainName}/{type}/{entityName}") @Produces(MediaType.APPLICATION_JSON) Object getEntity(@PathParam("domainName") final String domainName,
@PathParam("type") final String type,
@PathParam("entityName") final String entityName); static final Function<DocumentedDomain,LightDocumentedDomain> LIGHTER; } | @Test public void test() throws IOException, JSONException, URISyntaxException { final Predicate<String> filter = new FilterBuilder().include(".*\\.json"); final Reflections reflections = new Reflections( new ConfigurationBuilder() .filterInputsBy(filter) .setScanners(new ResourcesScanner()) .setUrls(Arrays.asList(ClasspathHelper.forClass(this.getClass()))) ); final Set<String> resolved = reflections.getResources(Pattern.compile(".*")); boolean failed = false; for (final String jsonFilename : resolved) { LOGGER.info("** Test response file " + jsonFilename); final String json = getJson(jsonFilename); final String path = jsonFilename .replaceAll("json/", "") .replaceAll("-", "/") .replaceAll("\\.json", ""); final WebResource webResource = resource(); final String responseMsg = webResource.path("/" + path).get(String.class); try { assertJsonEquals(responseMsg, json); } catch (final JSONException e) { LOGGER.info("\t--> ERROR"); throw e; } catch (final AssertionError e) { if ( ! UPDATE_TESTS) { LOGGER.debug("*** RETURNED RESULT :"); LOGGER.debug(new JSONObject(responseMsg).toString(2)); LOGGER.info("\t--> ERROR"); failed = true; } } if (UPDATE_TESTS) { final URL url = ClassLoader.getSystemResource(jsonFilename); final String filename = url.getFile().replaceAll("target/test-classes", "src/test/resources"); LOGGER.info("\t--> SAVE to " + filename); final File file = new File(filename); final FileOutputStream fos = new FileOutputStream(file); fos.write(new JSONObject(responseMsg).toString(2).getBytes(Charsets.UTF_8)); fos.close(); } LOGGER.info("\t--> OK"); } if (failed) { fail(); } } |
ObjectMapperProvider { public ObjectWriter objectWriter() { return mapper.writer(); } ObjectMapperProvider(); static ObjectMapperProvider defaults(); ObjectWriter objectWriter(); ObjectReader objectReader(); ObjectMapper mapper(); static final ObjectMapperProvider INSTANCE; } | @Test public void queryResponseSuccessRoundTrip() throws IOException { final QueryResponse<SomeResult> expected = new QueryResponse<SomeResult>(new SomeResult("foo")); final String json = ObjectMapperProvider.INSTANCE.objectWriter().writeValueAsString( expected ); final QueryResponse<SomeResult> actual = objectReader.readValue( objectReader.getFactory().createParser(json), new TypeReference<QueryResponse<SomeResult>>() {} ); assertTrue(actual.isOK()); assertNull(actual.getReason()); assertEquals(expected.getResult().getStr(), actual.getResult().getStr()); }
@Test public void queryResponseErrorRoundTrip() throws IOException { final QueryResponse expected = QueryResponse.error(new KasperReason("CODE", "aCode", "aMessage")); final String json = ObjectMapperProvider.INSTANCE.objectWriter().writeValueAsString( expected ); @SuppressWarnings("unchecked") final QueryResponse actual = objectReader.readValue( objectReader.getFactory().createParser(json), QueryResponse.class ); assertFalse(actual.isOK()); assertEquals(expected.getReason().getReasonCode(), actual.getReason().getReasonCode()); assertEquals( expected.getReason().getMessages().size(), actual.getReason().getMessages().size() ); for (int i = 0; i < expected.getReason().getMessages().size(); i++) { assertEquals( expected.getReason().getMessages().toArray()[i], actual.getReason().getMessages().toArray()[i] ); } }
@Test public void deserializeErrorCommandResponseWithSingleKasperReason() throws IOException { final KasperReason expectedError = new KasperReason(CoreReasonCode.UNKNOWN_REASON, "some error"); final CommandResponse expectedResponse = CommandResponse.error(expectedError); final String json = ObjectMapperProvider.INSTANCE.objectWriter().writeValueAsString( expectedResponse ); final CommandResponse actualResponse = objectReader.readValue( objectReader.getFactory().createParser(json), CommandResponse.class ); assertEquals(expectedResponse.getStatus(), actualResponse.getStatus()); assertEquals(expectedError.getCode(), actualResponse.getReason().getCode()); assertEquals( expectedError.getMessages().toArray()[0], actualResponse.getReason().getMessages().toArray()[0] ); }
@Test public void deserializeErrorCommandResponseWithMultipleKasperReason() throws IOException { final KasperReason expectedError = new KasperReason(CoreReasonCode.CONFLICT, "too late...", "some error"); final CommandResponse expectedResponse = CommandResponse.error(expectedError); final String json = ObjectMapperProvider.INSTANCE.objectWriter().writeValueAsString( expectedResponse ); final CommandResponse actualResponse = objectReader.readValue( objectReader.getFactory().createParser(json), CommandResponse.class ); assertEquals(expectedResponse.getStatus(), actualResponse.getStatus()); assertEquals( expectedError.getMessages().size(), actualResponse.getReason().getMessages().size() ); assertEquals(expectedError.getCode(), actualResponse.getReason().getCode()); for (int i = 0; i < expectedError.getMessages().size(); i++) { assertEquals( expectedError.getMessages().toArray()[i], actualResponse.getReason().getMessages().toArray()[i] ); } } |
RepositoryResolver extends AbstractResolver<Repository> { @Override @SuppressWarnings("unchecked") public Optional<Class<? extends Domain>> getDomainClass(final Class<? extends Repository> clazz) { if (DOMAINS_CACHE.containsKey(checkNotNull(clazz))) { return Optional.<Class<? extends Domain>>of(DOMAINS_CACHE.get(clazz)); } final Class<? extends AggregateRoot> agr = this.getStoredEntityClass(clazz); final Optional<Class<? extends Domain>> domain = this.entityResolver.getDomainClass(agr); if (domain.isPresent()) { DOMAINS_CACHE.put(clazz, domain.get()); return domain; } return Optional.absent(); } RepositoryResolver(); RepositoryResolver(final EntityResolver entityResolver); @Override String getTypeName(); @Override @SuppressWarnings("unchecked") Optional<Class<? extends Domain>> getDomainClass(final Class<? extends Repository> clazz); @Override String getDescription(final Class<? extends Repository> clazz); @Override String getLabel(final Class<? extends Repository> clazz); @SuppressWarnings("unchecked") Class<? extends AggregateRoot> getStoredEntityClass(final Class<? extends Repository> clazz); void setEntityResolver(final EntityResolver entityResolver); } | @Test public void testGetDomainFromGenericRepository() { final RepositoryResolver resolver = new RepositoryResolver(); try { resolver.getDomainClass(TestGenericRepository.class); fail(); } catch (final KasperException e) { } } |
ObjectMapperProvider { public ObjectMapper mapper() { return mapper; } ObjectMapperProvider(); static ObjectMapperProvider defaults(); ObjectWriter objectWriter(); ObjectReader objectReader(); ObjectMapper mapper(); static final ObjectMapperProvider INSTANCE; } | @Test public void serializeDateTimeToISO8601() throws IOException { final DateTime dateTime = new DateTime(2013, 8, 6, 7, 35, 0, 123, DateTimeZone.UTC); final String actual = ObjectMapperProvider.INSTANCE.mapper().writeValueAsString(dateTime); assertEquals("\"2013-08-06T07:35:00.123Z\"", actual); }
@Test public void deserializeISO8601DateToDateTime() throws IOException { final String jsonIso8601 = "\"2013-08-06T07:35:00.123Z\""; final DateTime actual = ObjectMapperProvider.INSTANCE.mapper().readValue( jsonIso8601, DateTime.class ); final DateTime expectedDateTime = new DateTime(2013, 8, 6, 7, 35, 0, 123, DateTimeZone.UTC); assertEquals(expectedDateTime, actual); }
@Test public void serDeserDateTime() throws IOException { final ObjectMapper mapper = ObjectMapperProvider.INSTANCE.mapper(); final DateTime expectedDate = DateTime.now(); final String json = mapper.writeValueAsString(expectedDate); final DateTime actualDate = mapper.reader(DateTime.class).readValue(json); assertTrue(expectedDate.isEqual(actualDate)); }
@Test public void serializeMoneyToISO4217() throws IOException { final Money money = Money.of(CurrencyUnit.EUR, new BigDecimal("19.99")); final String actual = ObjectMapperProvider.INSTANCE.mapper().writeValueAsString(money); assertEquals("\"EUR 19.99\"", actual); }
@Test public void deserializeISO4217ToMoney() throws IOException { final String moneyIso4217 = "\"EUR 19.99\""; final Money actual = ObjectMapperProvider.INSTANCE.mapper().readValue(moneyIso4217, Money.class); final Money expected = Money.of(CurrencyUnit.EUR, new BigDecimal("19.99")); assertEquals(expected, actual); }
@Test(expected = JsonMappingException.class) public void deserializeNumberToMoney_fails() throws IOException { final String number = "19"; final Money actual = ObjectMapperProvider.INSTANCE.mapper().readValue(number, Money.class); }
@Test public void serializeImmutableClass() throws Exception { final ImmutableQuery immutableObject = new ImmutableQuery("foobar", 42); String json = ObjectMapperProvider.INSTANCE.mapper().writeValueAsString(immutableObject); assertEquals("{\"name\":\"foobar\",\"value\":42}", json); }
@Test public void deserializeImmutableClass() throws Exception { final ObjectMapper mapper = ObjectMapperProvider.INSTANCE.mapper(); ImmutableQuery actual = mapper.readValue("{\"name\":\"foobar\",\"value\":42}", ImmutableQuery.class); assertNotNull(actual); assertEquals("foobar", actual.getName()); assertEquals((Integer)42, actual.getValue()); } |
DomainResolver implements Resolver<Domain> { @Override @SuppressWarnings("unchecked") public Optional<Class<? extends Domain>> getDomainClass(final Class<? extends Domain> clazz) { return Optional.<Class<? extends Domain>>of(checkNotNull(clazz)); } @Override String getTypeName(); @Override String getLabel(final Class<? extends Domain> clazz); @Override String getDescription(final Class<? extends Domain> clazz); String getPrefix(final Class<? extends Domain> clazz); @Override @SuppressWarnings("unchecked") Optional<Class<? extends Domain>> getDomainClass(final Class<? extends Domain> clazz); @SuppressWarnings("unchecked") Optional<Class<? extends Domain>> getDomainClassOf(final Class<?> clazz); @Override @SuppressWarnings("unchecked") String getDomainLabel(final Class<? extends Domain> clazz); void setDomainHelper(final DomainHelper domainHelper); @Override void clearCache(); String getDomainOwner(Class<? extends Domain> clazz); @Override boolean isPublic(final Class<? extends Domain> clazz); @Override boolean isDeprecated(final Class<? extends Domain> clazz); @Override Optional<List<String>> getAliases(final Class<? extends Domain> clazz); } | @Test public void testGetDomain() { final DomainResolver domainResolver = new DomainResolver(); final Optional<Class<? extends Domain>> domain = domainResolver.getDomainClass(TestDomain.class); assertTrue(domain.isPresent()); assertEquals(TestDomain.class, domain.get()); } |
RelationResolver extends AbstractResolver<Relation> { @Override @SuppressWarnings("unchecked") public Optional<Class<? extends Domain>> getDomainClass(final Class<? extends Relation> clazz) { if (DOMAINS_CACHE.containsKey(checkNotNull(clazz))) { return Optional.<Class<? extends Domain>>of(DOMAINS_CACHE.get(clazz)); } final XKasperRelation relationAnnotation = clazz.getAnnotation(XKasperRelation.class); if (null != relationAnnotation) { final Class<? extends Domain> domain = relationAnnotation.domain(); DOMAINS_CACHE.put(clazz, domain); return Optional.<Class<? extends Domain>>of(domain); } return Optional.absent(); } RelationResolver(); RelationResolver(final ConceptResolver conceptResolver); @Override String getTypeName(); @Override @SuppressWarnings("unchecked") Optional<Class<? extends Domain>> getDomainClass(final Class<? extends Relation> clazz); String getVerb(final Class<? extends Relation> clazz); @Override String getLabel(final Class<? extends Relation> clazz); @Override String getDescription(Class<? extends Relation> clazz); @SuppressWarnings("unchecked") Class<? extends Concept> getSourceEntityClass(final Class<? extends Relation> clazz); @SuppressWarnings("unchecked") Class<? extends Concept> getTargetEntityClass(final Class<? extends Relation> clazz); boolean isBidirectional(final Class<? extends Relation> clazz); Optional<String> biDirectionalVerb(final Class<? extends Relation> clazz); void setConceptResolver(final ConceptResolver conceptResolver); } | @Test public void testGetDomainWithDecoratedRelation() { final RelationResolver resolver = new RelationResolver(); final Optional<Class<? extends Domain>> domain = resolver.getDomainClass(TestRelation.class); assertTrue(domain.isPresent()); assertEquals(TestDomain.class, domain.get()); }
@Test public void testGetDomainWithNonDecoratedRelation() { final RelationResolver resolver = new RelationResolver(); final Optional<Class<? extends Domain>> domain = resolver.getDomainClass(TestRelation2.class); assertFalse(domain.isPresent()); } |
RelationResolver extends AbstractResolver<Relation> { @SuppressWarnings("unchecked") public Class<? extends Concept> getSourceEntityClass(final Class<? extends Relation> clazz) { if (SOURCES_CACHE.containsKey(checkNotNull(clazz))) { return (Class<? extends Concept>) SOURCES_CACHE.get(clazz); } @SuppressWarnings("unchecked") final Optional<Class<? extends Concept>> sourceClazz = (Optional<Class<? extends Concept>>) ReflectionGenericsResolver.getParameterTypeFromClass( clazz, Relation.class, Relation.SOURCE_PARAMETER_POSITION ); if ( ! sourceClazz.isPresent()) { throw new KasperException("Unable to find source concept type for relation " + clazz.getClass()); } SOURCES_CACHE.put(clazz, sourceClazz.get()); return sourceClazz.get(); } RelationResolver(); RelationResolver(final ConceptResolver conceptResolver); @Override String getTypeName(); @Override @SuppressWarnings("unchecked") Optional<Class<? extends Domain>> getDomainClass(final Class<? extends Relation> clazz); String getVerb(final Class<? extends Relation> clazz); @Override String getLabel(final Class<? extends Relation> clazz); @Override String getDescription(Class<? extends Relation> clazz); @SuppressWarnings("unchecked") Class<? extends Concept> getSourceEntityClass(final Class<? extends Relation> clazz); @SuppressWarnings("unchecked") Class<? extends Concept> getTargetEntityClass(final Class<? extends Relation> clazz); boolean isBidirectional(final Class<? extends Relation> clazz); Optional<String> biDirectionalVerb(final Class<? extends Relation> clazz); void setConceptResolver(final ConceptResolver conceptResolver); } | @Test public void testGetSourceWithValidRelation() { final RelationResolver resolver = new RelationResolver(); final Class<? extends Concept> conceptClass = resolver.getSourceEntityClass(TestRelation2.class); assertEquals(TestRootConceptSource.class, conceptClass); }
@Test public void testGetSourceWithInvalidRelation() { final RelationResolver resolver = new RelationResolver(); try { final Class<? extends Concept> conceptClass = resolver.getSourceEntityClass(TestRelation.class); fail(); } catch (final KasperException e) { } } |
ASTGenerator { public ASTJb generateAST() { ASTJb ast = new ASTJb(); BlockNode rootNode = this.useBlockProduction(); ast.setRootNode(rootNode); return ast; } ASTGenerator(List<TargetGrammar.Reduction> reductions); ASTJb generateAST(); } | @Test public void testSimpleDeclaration(){ List<Token> tList=new LinkedList<>(); Token l_token=new TokenJb(TokenType.LONG_SYMBOL, "long"); tList.add(l_token); Token id_token=new TokenJb(TokenType.ID, "i"); tList.add(id_token); Token sem_token=new TokenJb(TokenType.SEMICOLON,";"); tList.add(sem_token); TargetGrammar.SourceCode sc = syn.new SourceCode(tList); List<Reduction> res= syn.derivateDFLeftToRight(sc); instance=new ASTGenerator(res); AST ast=instance.generateAST(); BlockNode bn=ast.getRootNode(); assertTrue("must be empty",bn.getStatementList().isEmpty()); assertTrue("must contain one",bn.getDeclarationList().size()==1); List<Token> expected=new LinkedList<Token>(); expected.add(l_token); expected.add(id_token); expected.add(sem_token); assertTrue("must hold",bn.coverage().equals(bn.getDeclarationList().get(0).coverage())); assertEquals(expected, bn.coverage()); assertEquals(expected, bn.coverage()); }
@Test public void testM2CondProgramModified() { List<Token> tList = new LinkedList<>(); tList.add(new TokenJb(TokenType.COMMENT, "returns 5")); tList.add(new TokenJb(TokenType.COMMENT, "prints nothing")); tList.add(new TokenJb(TokenType.BOOL_SYMBOL, "bool")); tList.add(new TokenJb(TokenType.ID, "b")); tList.add(new TokenJb(TokenType.SEMICOLON, ";")); tList.add(new TokenJb(TokenType.BOOL_SYMBOL, "bool")); tList.add(new TokenJb(TokenType.ID, "c")); tList.add(new TokenJb(TokenType.SEMICOLON, ";")); tList.add(new TokenJb(TokenType.LONG_SYMBOL, "long")); tList.add(new TokenJb(TokenType.ID, "l")); tList.add(new TokenJb(TokenType.SEMICOLON, ";")); tList.add(new TokenJb(TokenType.STRING_SYMBOL, "string")); tList.add(new TokenJb(TokenType.ID, "str")); tList.add(new TokenJb(TokenType.SEMICOLON, ";")); tList.add(new TokenJb(TokenType.ID, "a")); tList.add(new TokenJb(TokenType.ASSIGNOP, "=")); tList.add(new TokenJb(TokenType.TRUE, "true")); tList.add(new TokenJb(TokenType.SEMICOLON, ";")); tList.add(new TokenJb(TokenType.ID, "b")); tList.add(new TokenJb(TokenType.ASSIGNOP, "=")); tList.add(new NumTokenJb(TokenType.FALSE, "false")); tList.add(new TokenJb(TokenType.SEMICOLON, ";")); tList.add(new TokenJb(TokenType.ID, "c")); tList.add(new TokenJb(TokenType.ASSIGNOP, "=")); tList.add(new NumTokenJb(TokenType.NUM, "4")); tList.add(new TokenJb(TokenType.SEMICOLON, ";")); tList.add(new TokenJb(TokenType.ID, "str")); tList.add(new TokenJb(TokenType.ASSIGNOP, "=")); tList.add(new TokenJb(TokenType.STRING, "bla")); tList.add(new TokenJb(TokenType.SEMICOLON, ";")); tList.add(new TokenJb(IF,"if")); tList.add(new TokenJb(LEFT_PARAN,"(")); tList.add(new TokenJb(ID,"b")); tList.add(new TokenJb(RIGHT_PARAN,")")); tList.add(new TokenJb(IF,"if")); tList.add(new TokenJb(LEFT_PARAN,"(")); tList.add(new TokenJb(ID,"c")); tList.add(new TokenJb(OR,"||")); tList.add(new TokenJb(NOT,"!")); tList.add(new TokenJb(ID,"b")); tList.add(new TokenJb(RIGHT_PARAN,")")); tList.add(new TokenJb(PRINT,"print")); tList.add(new TokenJb(ID,"bla")); tList.add(new TokenJb(SEMICOLON,";")); tList.add(new TokenJb(ELSE,"else")); tList.add(new TokenJb(ID ,"l")); tList.add(new TokenJb(ASSIGNOP,"=")); tList.add(new NumTokenJb(NUM,"5")); tList.add(new TokenJb(SEMICOLON,";")); tList.add(new TokenJb(TokenType.RETURN,"return")); tList.add(new TokenJb(TokenType.ID,"l")); tList.add(new TokenJb(TokenType.SEMICOLON,";")); TargetGrammar.SourceCode sc = syn.new SourceCode(tList); List<Reduction> res = syn.derivateDFLeftToRight(sc); ASTGenerator astgen=new ASTGenerator(res); ASTJb ast=astgen.generateAST(); }
@Test(expected=WordNotInLanguageGrammarException.class) public void testM2Print() { List<Token> tList = new LinkedList<>(); tList.add(new TokenJb(TokenType.COMMENT, "return 0")); tList.add(new TokenJb(TokenType.COMMENT, "prints :")); tList.add(new TokenJb(TokenType.COMMENT, "true")); tList.add(new TokenJb(TokenType.COMMENT, "18121313223")); tList.add(new TokenJb(TokenType.COMMENT, "2.323e-99")); tList.add(new TokenJb(TokenType.COMMENT, "jagAErEttString\"")); tList.add(new TokenJb(TokenType.LONG_SYMBOL, "long")); tList.add(new TokenJb(TokenType.ID, "l")); tList.add(new TokenJb(TokenType.SEMICOLON, ";")); tList.add(new TokenJb(TokenType.DOUBLE_SYMBOL, "double")); tList.add(new TokenJb(TokenType.ID, "d")); tList.add(new TokenJb(TokenType.SEMICOLON, ";")); tList.add(new TokenJb(TokenType.STRING_SYMBOL, "string")); tList.add(new TokenJb(TokenType.ID, "s")); tList.add(new TokenJb(TokenType.SEMICOLON, ";")); tList.add(new TokenJb(TokenType.BOOL_SYMBOL, "bool")); tList.add(new TokenJb(TokenType.ID, "b")); tList.add(new TokenJb(TokenType.SEMICOLON, ";")); tList.add(new TokenJb(TokenType.ID, "a")); tList.add(new TokenJb(TokenType.ASSIGNOP, "=")); tList.add(new TokenJb(TokenType.TRUE, "true")); tList.add(new TokenJb(TokenType.SEMICOLON, ";")); tList.add(new TokenJb(TokenType.ID, "l")); tList.add(new TokenJb(TokenType.ASSIGNOP, "=")); tList.add(new NumTokenJb(TokenType.NUM, "18121313223")); tList.add(new TokenJb(TokenType.SEMICOLON, ";")); tList.add(new TokenJb(TokenType.ID, "d")); tList.add(new TokenJb(TokenType.ASSIGNOP, "=")); tList.add(new RealTokenJb(TokenType.REAL, "-23.23e-100")); tList.add(new TokenJb(TokenType.SEMICOLON, ";")); tList.add(new TokenJb(TokenType.ID, "s")); tList.add(new TokenJb(TokenType.ASSIGNOP, "=")); tList.add(new TokenJb(TokenType.STRING, "jagAErEttString\"\n")); tList.add(new TokenJb(TokenType.SEMICOLON, ";")); tList.add(new TokenJb(PRINT,"print")); tList.add(new TokenJb(ID,"b")); tList.add(new TokenJb(SEMICOLON,";")); tList.add(new TokenJb(PRINT,"print")); tList.add(new TokenJb(STRING,"\"\n\"")); tList.add(new TokenJb(SEMICOLON,";")); tList.add(new TokenJb(PRINT,"print")); tList.add(new TokenJb(ID,"l")); tList.add(new TokenJb(SEMICOLON,";")); tList.add(new TokenJb(PRINT,"print")); tList.add(new TokenJb(STRING,"\"\n\"")); tList.add(new TokenJb(SEMICOLON,";")); tList.add(new TokenJb(PRINT,"print")); tList.add(new TokenJb(ID,"b")); tList.add(new TokenJb(SEMICOLON,";")); tList.add(new TokenJb(PRINT,"print")); tList.add(new TokenJb(STRING,"\"\n\"")); tList.add(new TokenJb(SEMICOLON,";")); tList.add(new TokenJb(PRINT,"print")); tList.add(new TokenJb(ID,"d")); tList.add(new TokenJb(SEMICOLON,";")); tList.add(new TokenJb(PRINT,"print")); tList.add(new TokenJb(STRING,"\"\n\"")); tList.add(new TokenJb(SEMICOLON,";")); tList.add(new TokenJb(PRINT,"print")); tList.add(new TokenJb(ID,"d")); tList.add(new TokenJb(SEMICOLON,";")); tList.add(new TokenJb(TokenType.RETURN,"return")); tList.add(new TokenJb(TokenType.SEMICOLON,";")); TargetGrammar.SourceCode sc = syn.new SourceCode(tList); List<Reduction> res = syn.derivateDFLeftToRight(sc); ASTGenerator astgen=new ASTGenerator(res); ASTJb ast=astgen.generateAST(); }
@Test public void testM2PrintModified() { List<Token> tList = new LinkedList<>(); tList.add(new TokenJb(TokenType.COMMENT, "return 0")); tList.add(new TokenJb(TokenType.COMMENT, "prints :")); tList.add(new TokenJb(TokenType.COMMENT, "true")); tList.add(new TokenJb(TokenType.COMMENT, "18121313223")); tList.add(new TokenJb(TokenType.COMMENT, "2.323e-99")); tList.add(new TokenJb(TokenType.COMMENT, "jagAErEttString\"")); tList.add(new TokenJb(TokenType.STRING_SYMBOL, "string")); tList.add(new TokenJb(TokenType.ID, "linebreak")); tList.add(new TokenJb(TokenType.SEMICOLON, ";")); tList.add(new TokenJb(TokenType.LONG_SYMBOL, "long")); tList.add(new TokenJb(TokenType.ID, "l")); tList.add(new TokenJb(TokenType.SEMICOLON, ";")); tList.add(new TokenJb(TokenType.DOUBLE_SYMBOL, "double")); tList.add(new TokenJb(TokenType.ID, "d")); tList.add(new TokenJb(TokenType.SEMICOLON, ";")); tList.add(new TokenJb(TokenType.STRING_SYMBOL, "string")); tList.add(new TokenJb(TokenType.ID, "s")); tList.add(new TokenJb(TokenType.SEMICOLON, ";")); tList.add(new TokenJb(TokenType.BOOL_SYMBOL, "bool")); tList.add(new TokenJb(TokenType.ID, "b")); tList.add(new TokenJb(TokenType.SEMICOLON, ";")); tList.add(new TokenJb(TokenType.ID, "linebreak")); tList.add(new TokenJb(TokenType.ASSIGNOP, "=")); tList.add(new TokenJb(TokenType.TRUE, "\"\n\"")); tList.add(new TokenJb(TokenType.SEMICOLON, ";")); tList.add(new TokenJb(TokenType.ID, "a")); tList.add(new TokenJb(TokenType.ASSIGNOP, "=")); tList.add(new TokenJb(TokenType.TRUE, "true")); tList.add(new TokenJb(TokenType.SEMICOLON, ";")); tList.add(new TokenJb(TokenType.ID, "l")); tList.add(new TokenJb(TokenType.ASSIGNOP, "=")); tList.add(new NumTokenJb(TokenType.NUM, "18121313223")); tList.add(new TokenJb(TokenType.SEMICOLON, ";")); tList.add(new TokenJb(TokenType.ID, "d")); tList.add(new TokenJb(TokenType.ASSIGNOP, "=")); tList.add(new RealTokenJb(TokenType.REAL, "-23.23e-100")); tList.add(new TokenJb(TokenType.SEMICOLON, ";")); tList.add(new TokenJb(TokenType.ID, "s")); tList.add(new TokenJb(TokenType.ASSIGNOP, "=")); tList.add(new TokenJb(TokenType.STRING, "jagAErEttString\"\n")); tList.add(new TokenJb(TokenType.SEMICOLON, ";")); tList.add(new TokenJb(PRINT,"print")); tList.add(new TokenJb(ID,"b")); tList.add(new TokenJb(SEMICOLON,";")); tList.add(new TokenJb(PRINT,"print")); tList.add(new TokenJb(ID,"linebreak")); tList.add(new TokenJb(SEMICOLON,";")); tList.add(new TokenJb(PRINT,"print")); tList.add(new TokenJb(ID,"l")); tList.add(new TokenJb(SEMICOLON,";")); tList.add(new TokenJb(PRINT,"print")); tList.add(new TokenJb(ID,"linebreak")); tList.add(new TokenJb(SEMICOLON,";")); tList.add(new TokenJb(PRINT,"print")); tList.add(new TokenJb(ID,"b")); tList.add(new TokenJb(SEMICOLON,";")); tList.add(new TokenJb(PRINT,"print")); tList.add(new TokenJb(ID,"linebreak")); tList.add(new TokenJb(SEMICOLON,";")); tList.add(new TokenJb(PRINT,"print")); tList.add(new TokenJb(ID,"d")); tList.add(new TokenJb(SEMICOLON,";")); tList.add(new TokenJb(PRINT,"print")); tList.add(new TokenJb(ID,"linebreak")); tList.add(new TokenJb(SEMICOLON,";")); tList.add(new TokenJb(PRINT,"print")); tList.add(new TokenJb(ID,"d")); tList.add(new TokenJb(SEMICOLON,";")); tList.add(new TokenJb(TokenType.RETURN,"return")); tList.add(new TokenJb(TokenType.SEMICOLON,";")); TargetGrammar.SourceCode sc = syn.new SourceCode(tList); List<Reduction> res = syn.derivateDFLeftToRight(sc); ASTGenerator astgen=new ASTGenerator(res); ASTJb ast=astgen.generateAST(); }
@Test public void testSimpleDoubleDeclaration(){ List<Token> tList=new LinkedList<>(); tList.add(new TokenJb(TokenType.LONG_SYMBOL, "long")); tList.add(new TokenJb(TokenType.ID, "i")); tList.add(new TokenJb(TokenType.SEMICOLON,";")); tList.add(new TokenJb(TokenType.LONG_SYMBOL, "long")); tList.add(new TokenJb(TokenType.ID, "j")); tList.add(new TokenJb(TokenType.SEMICOLON,";")); TargetGrammar.SourceCode sc = syn.new SourceCode(tList); List<Reduction> res= syn.derivateDFLeftToRight(sc); instance=new ASTGenerator(res); AST ast=instance.generateAST(); }
@Test public void testSimpleDoubleInvalidDeclaration(){ List<Token> tList=new LinkedList<>(); tList.add(new TokenJb(TokenType.LONG_SYMBOL, "long")); tList.add(new TokenJb(TokenType.ID, "i")); tList.add(new TokenJb(TokenType.SEMICOLON,";")); tList.add(new TokenJb(TokenType.LONG_SYMBOL, "long")); tList.add(new TokenJb(TokenType.ID, "i")); tList.add(new TokenJb(TokenType.SEMICOLON,";")); TargetGrammar.SourceCode sc = syn.new SourceCode(tList); List<Reduction> res= syn.derivateDFLeftToRight(sc); instance=new ASTGenerator(res); AST ast=instance.generateAST(); }
@Test public void testSimpleStatement(){ List<Token> tList=new LinkedList<>(); tList.add(new TokenJb(TokenType.ID, "i")); tList.add(new TokenJb(TokenType.ASSIGNOP, "=")); tList.add(new RealTokenJb(TokenType.REAL,"2.0")); tList.add(new TokenJb(TokenType.SEMICOLON,";")); TargetGrammar.SourceCode sc = syn.new SourceCode(tList); List<Reduction> res= syn.derivateDFLeftToRight(sc); instance=new ASTGenerator(res); AST ast=instance.generateAST(); }
@Test public void testSimpleProgram(){ List<Token> tList=new LinkedList<>(); tList.add(new TokenJb(TokenType.LONG_SYMBOL, "long")); tList.add(new TokenJb(TokenType.ID, "i")); tList.add(new TokenJb(TokenType.SEMICOLON,";")); tList.add(new TokenJb(TokenType.ID, "i")); tList.add(new TokenJb(TokenType.ASSIGNOP, "=")); tList.add(new RealTokenJb(TokenType.REAL,"2.0")); tList.add(new TokenJb(TokenType.SEMICOLON,";")); TargetGrammar.SourceCode sc = syn.new SourceCode(tList); List<Reduction> res= syn.derivateDFLeftToRight(sc); instance=new ASTGenerator(res); AST ast=instance.generateAST(); }
@Test public void testLessSimpleProgram(){ List<Token> tList=new LinkedList<>(); tList.add(new TokenJb(TokenType.LONG_SYMBOL, "long")); tList.add(new TokenJb(TokenType.ID, "i")); tList.add(new TokenJb(TokenType.SEMICOLON,";")); tList.add(new TokenJb(TokenType.ID, "i")); tList.add(new TokenJb(TokenType.ASSIGNOP, "=")); tList.add(new RealTokenJb(TokenType.REAL,"2.0")); tList.add(new TokenJb(TokenType.DIVIDE,"/")); tList.add(new NumTokenJb(TokenType.NUM,"2")); tList.add(new TokenJb(TokenType.SEMICOLON,";")); TargetGrammar.SourceCode sc = syn.new SourceCode(tList); List<Reduction> res= syn.derivateDFLeftToRight(sc); instance=new ASTGenerator(res); AST ast=instance.generateAST(); }
@Test public void testComplexProgram(){ List<Token> tList = new LinkedList<>(); tList.add(new TokenJb(TokenType.LONG_SYMBOL, "long")); tList.add(new TokenJb(TokenType.ID, "i")); tList.add(new TokenJb(TokenType.SEMICOLON, ";")); tList.add(new TokenJb(TokenType.LONG_SYMBOL, "long")); tList.add(new TokenJb(TokenType.ID, "j")); tList.add(new TokenJb(TokenType.SEMICOLON, ";")); tList.add(new TokenJb(TokenType.ID, "i")); tList.add(new TokenJb(TokenType.ASSIGNOP, "=")); tList.add(new TokenJb(TokenType.LEFT_PARAN, "(")); tList.add(new NumTokenJb(TokenType.NUM, "2")); tList.add(new TokenJb(TokenType.PLUS, "+")); tList.add(new NumTokenJb(TokenType.NUM, "2")); tList.add(new TokenJb(TokenType.RIGHT_PARAN, ")")); tList.add(new TokenJb(TokenType.SEMICOLON, ";")); tList.add(new TokenJb(TokenType.ID, "j")); tList.add(new TokenJb(TokenType.ASSIGNOP, "=")); tList.add(new NumTokenJb(TokenType.NUM, "2")); tList.add(new TokenJb(TokenType.SEMICOLON, ";")); tList.add(new TokenJb(TokenType.RETURN, "return")); tList.add(new TokenJb(TokenType.ID, "j")); tList.add(new TokenJb(TokenType.SEMICOLON, ";")); TargetGrammar.SourceCode sc = syn.new SourceCode(tList); List<Reduction> res= syn.derivateDFLeftToRight(sc); instance=new ASTGenerator(res); AST ast=instance.generateAST(); }
@Test public void testComplexProgramSymbolTable(){ List<Token> tList = new LinkedList<>(); tList.add(new TokenJb(TokenType.LONG_SYMBOL, "long")); tList.add(new TokenJb(TokenType.ID, "i")); tList.add(new TokenJb(TokenType.SEMICOLON, ";")); tList.add(new TokenJb(TokenType.LONG_SYMBOL, "long")); tList.add(new TokenJb(TokenType.ID, "j")); tList.add(new TokenJb(TokenType.SEMICOLON, ";")); tList.add(new TokenJb(TokenType.ID, "i")); tList.add(new TokenJb(TokenType.ASSIGNOP, "=")); tList.add(new TokenJb(TokenType.LEFT_PARAN, "(")); tList.add(new NumTokenJb(TokenType.NUM, "2")); tList.add(new TokenJb(TokenType.PLUS, "+")); tList.add(new NumTokenJb(TokenType.NUM, "2")); tList.add(new TokenJb(TokenType.RIGHT_PARAN, ")")); tList.add(new TokenJb(TokenType.SEMICOLON, ";")); tList.add(new TokenJb(TokenType.ID, "j")); tList.add(new TokenJb(TokenType.ASSIGNOP, "=")); tList.add(new NumTokenJb(TokenType.NUM, "2")); tList.add(new TokenJb(TokenType.SEMICOLON, ";")); tList.add(new TokenJb(TokenType.RETURN, "return")); tList.add(new TokenJb(TokenType.ID, "j")); tList.add(new TokenJb(TokenType.SEMICOLON, ";")); TargetGrammar.SourceCode sc = syn.new SourceCode(tList); List<Reduction> res= syn.derivateDFLeftToRight(sc); instance=new ASTGenerator(res); AST ast=instance.generateAST(); SymbolTable table=ast.getRootNode().getSymbolTable(); assertTrue("should be declared",table.isDeclared("i")); assertTrue("should be declared",table.isDeclared("j")); assertFalse("should be not declared",table.isDeclared("ij")); assertEquals("should be the same",Kind.LONG,table.lookupType("i").getKind()); assertEquals("should be the same",Kind.LONG,table.lookupType("j").getKind()); assertNull("should not exist",table.lookupType("ij")); BlockNode root=ast.getRootNode(); assertEquals(21,root.coverage().size()); assertEquals(3,root.getDeclarationList().get(0).coverage().size()); assertEquals(8,root.getStatementList().get(0).coverage().size()); }
@Test public void testM2AddProgram() { List<Token> tList = new LinkedList<>(); tList.add(new TokenJb(TokenType.COMMENT, "returns 10")); tList.add(new TokenJb(TokenType.COMMENT, "prints nothing")); tList.add(new TokenJb(TokenType.LONG_SYMBOL, "long")); tList.add(new TokenJb(TokenType.ID, "a")); tList.add(new TokenJb(TokenType.SEMICOLON, ";")); tList.add(new TokenJb(TokenType.LONG_SYMBOL, "long")); tList.add(new TokenJb(TokenType.ID, "b")); tList.add(new TokenJb(TokenType.SEMICOLON, ";")); tList.add(new TokenJb(TokenType.LONG_SYMBOL, "long")); tList.add(new TokenJb(TokenType.ID, "c")); tList.add(new TokenJb(TokenType.SEMICOLON, ";")); tList.add(new TokenJb(TokenType.ID, "a")); tList.add(new TokenJb(TokenType.ASSIGNOP, "=")); tList.add(new NumTokenJb(TokenType.NUM, "4")); tList.add(new TokenJb(TokenType.SEMICOLON, ";")); tList.add(new TokenJb(TokenType.ID, "b")); tList.add(new TokenJb(TokenType.ASSIGNOP, "=")); tList.add(new NumTokenJb(TokenType.NUM, "3")); tList.add(new TokenJb(TokenType.SEMICOLON, ";")); tList.add(new TokenJb(TokenType.ID, "c")); tList.add(new TokenJb(TokenType.ASSIGNOP, "=")); tList.add(new NumTokenJb(TokenType.NUM, "2")); tList.add(new TokenJb(TokenType.SEMICOLON, ";")); tList.add(new TokenJb(TokenType.ID, "a")); tList.add(new TokenJb(TokenType.ASSIGNOP, "=")); tList.add(new TokenJb(TokenType.ID,"b")); tList.add(new TokenJb(TokenType.ASSIGNOP, "=")); tList.add(new NumTokenJb(TokenType.NUM, "4")); tList.add(new TokenJb(TokenType.SEMICOLON, ";")); tList.add(new TokenJb(TokenType.ID, "c")); tList.add(new TokenJb(TokenType.ASSIGNOP, "=")); tList.add(new TokenJb(TokenType.ID,"a")); tList.add(new TokenJb(TokenType.PLUS, "+")); tList.add(new TokenJb(TokenType.ID,"b")); tList.add(new TokenJb(TokenType.PLUS, "+")); tList.add(new TokenJb(TokenType.ID,"c")); tList.add(new TokenJb(TokenType.SEMICOLON, ";")); tList.add(new TokenJb(TokenType.RETURN,"return")); tList.add(new TokenJb(TokenType.ID,"c")); tList.add(new TokenJb(TokenType.SEMICOLON,";")); TargetGrammar.SourceCode sc = syn.new SourceCode(tList); List<Reduction> res = syn.derivateDFLeftToRight(sc); ASTGenerator astgen=new ASTGenerator(res); ASTJb ast=astgen.generateAST(); }
@Test(expected=WordNotInLanguageGrammarException.class) public void testM2CondProgram() { List<Token> tList = new LinkedList<>(); tList.add(new TokenJb(TokenType.COMMENT, "returns 5")); tList.add(new TokenJb(TokenType.COMMENT, "prints nothing")); tList.add(new TokenJb(TokenType.BOOL_SYMBOL, "bool")); tList.add(new TokenJb(TokenType.ID, "b")); tList.add(new TokenJb(TokenType.SEMICOLON, ";")); tList.add(new TokenJb(TokenType.BOOL_SYMBOL, "bool")); tList.add(new TokenJb(TokenType.ID, "c")); tList.add(new TokenJb(TokenType.SEMICOLON, ";")); tList.add(new TokenJb(TokenType.LONG_SYMBOL, "long")); tList.add(new TokenJb(TokenType.ID, "l")); tList.add(new TokenJb(TokenType.SEMICOLON, ";")); tList.add(new TokenJb(TokenType.ID, "b")); tList.add(new TokenJb(TokenType.ASSIGNOP, "=")); tList.add(new TokenJb(TokenType.TRUE, "true")); tList.add(new TokenJb(TokenType.SEMICOLON, ";")); tList.add(new TokenJb(TokenType.ID, "c")); tList.add(new TokenJb(TokenType.ASSIGNOP, "=")); tList.add(new TokenJb(TokenType.FALSE, "false")); tList.add(new TokenJb(TokenType.SEMICOLON, ";")); tList.add(new TokenJb(TokenType.ID, "c")); tList.add(new TokenJb(TokenType.ASSIGNOP, "=")); tList.add(new NumTokenJb(TokenType.NUM, "4")); tList.add(new TokenJb(TokenType.SEMICOLON, ";")); tList.add(new TokenJb(IF,"if")); tList.add(new TokenJb(LEFT_PARAN,"(")); tList.add(new TokenJb(ID,"b")); tList.add(new TokenJb(RIGHT_PARAN,")")); tList.add(new TokenJb(IF,"if")); tList.add(new TokenJb(LEFT_PARAN,"(")); tList.add(new TokenJb(ID,"c")); tList.add(new TokenJb(OR,"||")); tList.add(new TokenJb(NOT,"!")); tList.add(new TokenJb(ID,"b")); tList.add(new TokenJb(RIGHT_PARAN,")")); tList.add(new TokenJb(PRINT,"print")); tList.add(new TokenJb(STRING,"\"bla\"")); tList.add(new TokenJb(SEMICOLON,";")); tList.add(new TokenJb(ELSE,"else")); tList.add(new TokenJb(ID ,"l")); tList.add(new TokenJb(ASSIGNOP,"5")); tList.add(new NumTokenJb(NUM,"5")); tList.add(new TokenJb(TokenType.RETURN,"return")); tList.add(new TokenJb(TokenType.ID,"l")); tList.add(new TokenJb(TokenType.SEMICOLON,";")); TargetGrammar.SourceCode sc = syn.new SourceCode(tList); List<Reduction> res = syn.derivateDFLeftToRight(sc); ASTGenerator astgen=new ASTGenerator(res); ASTJb ast=astgen.generateAST(); } |
SLRAutomaton { public int getNStates() { return states.size(); } SLRAutomaton(Grammar<T, NT> referenceGrammar); void setAmbiguityPolicy(AMBIGUITY_POLICY policy); List<Production<T, NT>> getDerivationASsSequence(
Word<T, NT> word_total); int getNStates(); } | @Test public void testAutomaton(){ SLRAutomaton<SimpleT, SimpleNT> automaton=new SLRAutomaton<>(g1); assertEquals("should have exact this number of states",13,automaton.getNStates()); } |
SLRAutomaton { public List<Production<T, NT>> getDerivationASsSequence( Word<T, NT> word_total) { Stack<State> state_stack = new Stack<>(); Stack<Symbol> symbol_stack = new Stack<>(); state_stack.push(initialState); symbol_stack.push(g.word_end); List<Production<T, NT>> productions = new LinkedList<>(); Queue<T> word = new ArrayDeque<>(word_total); word.add(g.word_end); while (!state_stack.isEmpty()) { State state = state_stack.peek(); if (state.isStateAccepting()) break; Symbol a = word.peek(); if (g.isTerminal(a)) { T t = (T) a; State nextStateTrans = state.transition.get(t); Set<Production> nextProdFollow = possibleReductionsInState(t, state); if (nextStateTrans != null && !nextProdFollow.isEmpty() || nextStateTrans == null && nextProdFollow.isEmpty() || nextProdFollow.size() > 1) { if (nextStateTrans == null && nextProdFollow.isEmpty()){ logger.warn( "behaviour not defined, policy set to DIE. next state by shift: {}, next states by follow: {}", nextStateTrans, nextProdFollow); logger.warn("current terminal: {}", a); logger.warn("productions so far: {}", productions); logger.warn("state stack {}", state_stack); logger.warn("symbol stack {}", symbol_stack); logger.warn("word actual {}", word); logger.warn("word complete {}", word_total); logger.warn("states:"); throw new WordNotInLanguageGrammarException( (swp_compiler_ss13.javabite.parser.targetgrammar.Terminal) t); } if (policy == AMBIGUITY_POLICY.DIE) { logger.warn( "behaviour not defined, policy set to DIE. next state by shift: {}, next states by follow: {}", nextStateTrans, nextProdFollow); logger.warn("current terminal: {}", a); logger.warn("productions so far: {}", productions); logger.warn("state stack {}", state_stack); logger.warn("symbol stack {}", symbol_stack); logger.warn("word actual {}", word); logger.warn("word complete {}", word_total); logger.warn("states:"); if (nextStateTrans != null && !nextProdFollow.isEmpty()) { if (t instanceof swp_compiler_ss13.javabite.parser.targetgrammar.Terminal) { throw new AmbiguityInDerivationGrammarException( (swp_compiler_ss13.javabite.parser.targetgrammar.Terminal) t); } else logger.warn("Dont know how to react..."); } else if (nextStateTrans == null && nextProdFollow.isEmpty()) { if (t instanceof swp_compiler_ss13.javabite.parser.targetgrammar.Terminal) { throw new WordNotInLanguageGrammarException( (swp_compiler_ss13.javabite.parser.targetgrammar.Terminal) t); } else logger.warn("Dont know how to react..."); } else if (nextProdFollow.size() > 1) { if (t instanceof swp_compiler_ss13.javabite.parser.targetgrammar.Terminal) { throw new AmbiguityInDerivationGrammarException( (swp_compiler_ss13.javabite.parser.targetgrammar.Terminal) t); } else logger.warn("Dont know how to react..."); } else { throw new RuntimeException( "Enexptected state reached"); } } else if (policy==AMBIGUITY_POLICY.PREFER_REDUCE){ if (nextProdFollow.size()==1){ nextStateTrans=null; } else{ logger.error("policy PREFER_REDUCE is not applicable, because multiple or none (exact :{}) reductions are possible",nextProdFollow.size()); if (nextProdFollow.size()>1) throw new AmbiguityInDerivationGrammarException( (swp_compiler_ss13.javabite.parser.targetgrammar.Terminal) t); } } else if (policy==AMBIGUITY_POLICY.PREFER_SHIFT){ logger.info("policy PREFER_SHIFT is applicable and used"); nextProdFollow=null; } else{ throw new RuntimeException("Invalid Policy"); } } if (nextStateTrans != null) { word.poll(); symbol_stack.push(a); state_stack.push(nextStateTrans); } else { Production todo = nextProdFollow.iterator().next(); List<Symbol> original_right_side = new LinkedList<>(); for (int i = todo.right.size() - 1; i >= 0; i--) { state_stack.pop(); original_right_side.add(symbol_stack.pop()); } Collections.reverse(original_right_side); State stateBeforeProduction = state_stack.peek(); State nextState = stateBeforeProduction.transition .get(todo.left); state_stack.push(nextState); symbol_stack.push(todo.left); todo.right = original_right_side; productions.add(todo); } } } return productions; } SLRAutomaton(Grammar<T, NT> referenceGrammar); void setAmbiguityPolicy(AMBIGUITY_POLICY policy); List<Production<T, NT>> getDerivationASsSequence(
Word<T, NT> word_total); int getNStates(); } | @Test public void testDerivationSequenceSimple(){ SLRAutomaton<SimpleT, SimpleNT> automaton=new SLRAutomaton<>(g1); Word<SimpleT,SimpleNT> original=new Word<SimpleT,SimpleNT>(g1, listTok(T_ID)); List<Production<SimpleT,SimpleNT>> productions=automaton.getDerivationASsSequence(original); Collections.reverse(productions); Word<SimpleT,SimpleNT> derivated=Word.getWordFromRightMostDerivation(g1, productions); assertEquals("must be the same",original,derivated); }
@Test public void testDerivationSequenceComplex(){ SLRAutomaton<SimpleT, SimpleNT> automaton=new SLRAutomaton<>(g1); Word<SimpleT,SimpleNT> original=new Word<SimpleT,SimpleNT>(g1, listTok(T_ID,T_MUL,T_ID)); List<Production<SimpleT,SimpleNT>> productions=automaton.getDerivationASsSequence(original); Collections.reverse(productions); Word<SimpleT,SimpleNT> derivated=Word.getWordFromRightMostDerivation(g1, productions); assertEquals("must be the same",original,derivated); }
@Test public void testDerivationSequenceVeryComplex(){ SLRAutomaton<SimpleT, SimpleNT> automaton=new SLRAutomaton<>(g1); Word<SimpleT,SimpleNT> original=new Word<SimpleT,SimpleNT>(g1, listTok(T_ID,T_MUL,T_ID,T_ADD,T_ID,T_MUL,T_OPEN,T_ID,T_ADD,T_ID,T_CLOSE,T_ADD,T_ID)); List<Production<SimpleT,SimpleNT>> productions=automaton.getDerivationASsSequence(original); Collections.reverse(productions); Word<SimpleT,SimpleNT> derivated=Word.getWordFromRightMostDerivation(g1, productions); assertEquals("must be the same",original,derivated); }
@Test public void testDerivationSequenceSimpleBrace(){ SLRAutomaton<SimpleT, SimpleNT> automaton=new SLRAutomaton<>(g1); Word<SimpleT,SimpleNT> original=new Word<SimpleT,SimpleNT>(g1, listTok(T_OPEN,T_ID,T_CLOSE)); List<Production<SimpleT,SimpleNT>> productions=automaton.getDerivationASsSequence(original); Collections.reverse(productions); Word<SimpleT,SimpleNT> derivated=Word.getWordFromRightMostDerivation(g1, productions); assertEquals("must be the same",original,derivated); }
@Test public void testDerivationSequenceSimpleBraceLeftMul(){ SLRAutomaton<SimpleT, SimpleNT> automaton=new SLRAutomaton<>(g1); Word<SimpleT,SimpleNT> original=new Word<SimpleT,SimpleNT>(g1, listTok(T_ID,T_MUL,T_OPEN,T_ID,T_CLOSE)); List<Production<SimpleT,SimpleNT>> productions=automaton.getDerivationASsSequence(original); Collections.reverse(productions); Word<SimpleT,SimpleNT> derivated=Word.getWordFromRightMostDerivation(g1, productions); assertEquals("must be the same",original,derivated); }
@Test public void testDerivationSequenceSimpleBraceRightMul(){ SLRAutomaton<SimpleT, SimpleNT> automaton=new SLRAutomaton<>(g1); Word<SimpleT,SimpleNT> original=new Word<SimpleT,SimpleNT>(g1, listTok(T_OPEN,T_ID,T_CLOSE,T_MUL,T_ID)); List<Production<SimpleT,SimpleNT>> productions=automaton.getDerivationASsSequence(original); Collections.reverse(productions); Word<SimpleT,SimpleNT> derivated=Word.getWordFromRightMostDerivation(g1, productions); assertEquals("must be the same",original,derivated); }
@Test public void testDerivationSequenceSimpleBraceRightDouble(){ SLRAutomaton<SimpleT, SimpleNT> automaton=new SLRAutomaton<>(g1); Word<SimpleT,SimpleNT> original=new Word<SimpleT,SimpleNT>(g1, listTok(T_OPEN,T_OPEN,T_ID,T_CLOSE,T_CLOSE)); List<Production<SimpleT,SimpleNT>> productions=automaton.getDerivationASsSequence(original); Collections.reverse(productions); Word<SimpleT,SimpleNT> derivated=Word.getWordFromRightMostDerivation(g1, productions); assertEquals("must be the same",original,derivated); }
@Test public void testDerivationEpsilon(){ SLRAutomaton<SimpleT, SimpleNT> automaton=new SLRAutomaton<>(g2); Word<SimpleT,SimpleNT> original=new Word<SimpleT,SimpleNT>(g2, listTok()); List<Production<SimpleT,SimpleNT>> productions=automaton.getDerivationASsSequence(original); Collections.reverse(productions); Word<SimpleT,SimpleNT> derivated=Word.getWordFromRightMostDerivation(g2, productions); assertEquals("must be the same",original,derivated); }
@Test public void testDerivationEpsilonOneProd(){ SLRAutomaton<SimpleT, SimpleNT> automaton=new SLRAutomaton<>(g2); Word<SimpleT,SimpleNT> original=new Word<SimpleT,SimpleNT>(g2, listTok(T_MUL)); List<Production<SimpleT,SimpleNT>> productions=automaton.getDerivationASsSequence(original); Collections.reverse(productions); Word<SimpleT,SimpleNT> derivated=Word.getWordFromRightMostDerivation(g2, productions); assertEquals("must be the same",original,derivated); }
@Test public void testDerivationEpsilonMultipleProd(){ SLRAutomaton<SimpleT, SimpleNT> automaton=new SLRAutomaton<>(g2); Word<SimpleT,SimpleNT> original=new Word<SimpleT,SimpleNT>(g2, listTok(T_MUL,T_MUL,T_MUL,T_MUL,T_MUL,T_MUL,T_MUL)); List<Production<SimpleT,SimpleNT>> productions=automaton.getDerivationASsSequence(original); Collections.reverse(productions); Word<SimpleT,SimpleNT> derivated=Word.getWordFromRightMostDerivation(g2, productions); assertEquals("must be the same",original,derivated); } |
CastingAst2CodeConverter extends AbstractAst2CodeConverter { protected IdentifierData cast(Type goalType, IdentifierData oldId) throws IntermediateCodeGeneratorException { if (oldId.getIdentifier().startsWith("#")) { IdentifierData tmpId = icg.generateTempIdentifier(oldId.getType()); icg.addQuadruple(QuadrupleFactoryJb.generateAssignment(tmpId, oldId)); oldId = tmpId; } IdentifierData newId = icg.generateTempIdentifier(goalType); icg.addQuadruple(QuadrupleFactoryJb.generateCast(newId, oldId)); return newId; } } | @Test public void testCastLongToDouble() { try { when(converter.icg.generateTempIdentifier(any(DoubleType.class))) .thenReturn(new IdentifierData("tmp", new DoubleType())); converter.cast(new DoubleType(), new IdentifierData("test", new LongType())); verify(converter.icg).addQuadruple( new QuadrupleJb(Operator.LONG_TO_DOUBLE, "test", Quadruple.EmptyArgument, "tmp")); } catch (IntermediateCodeGeneratorException e) { fail(); } }
@Test public void testCastDoubleToLong() { try { when(converter.icg.generateTempIdentifier(any(LongType.class))) .thenReturn(new IdentifierData("tmp", new LongType())); converter.cast(new LongType(), new IdentifierData("test", new DoubleType())); verify(converter.icg).addQuadruple( new QuadrupleJb(Operator.DOUBLE_TO_LONG, "test", Quadruple.EmptyArgument, "tmp")); } catch (IntermediateCodeGeneratorException e) { fail(); } }
@Test public void testCastLongToString() { try { when(converter.icg.generateTempIdentifier(any(StringType.class))) .thenReturn(new IdentifierData("tmp", new StringType(0l))); converter.cast(new StringType(0l), new IdentifierData("test", new LongType())); verify(converter.icg).addQuadruple( new QuadrupleJb(Operator.LONG_TO_STRING, "test", Quadruple.EmptyArgument, "tmp")); } catch (IntermediateCodeGeneratorException e) { fail(); } }
@Test public void testCastLongToBooleanFails() { try { when(converter.icg.generateTempIdentifier(any(BooleanType.class))) .thenReturn(new IdentifierData("tmp", new BooleanType())); converter.cast(new BooleanType(), new IdentifierData("test", new LongType())); fail(); } catch (IntermediateCodeGeneratorException e) { } }
@Test public void testCastLongToArrayFails() { try { when(converter.icg.generateTempIdentifier(any(ArrayType.class))) .thenReturn( new IdentifierData("tmp", new ArrayType( new LongType(), 0))); converter.cast(new ArrayType(new LongType(), 0), new IdentifierData("test", new LongType())); fail(); } catch (IntermediateCodeGeneratorException e) { } }
@Test public void testCastLongToStructFails() { try { when(converter.icg.generateTempIdentifier(any(StructType.class))) .thenReturn( new IdentifierData("tmp", new StructType( new Member[] { new Member("", new LongType()) }))); converter.cast(new StructType( new Member[] { new Member("", new LongType()) }), new IdentifierData("test", new LongType())); fail(); } catch (IntermediateCodeGeneratorException e) { } }
@Test public void testCastDoubleToString() { try { when(converter.icg.generateTempIdentifier(any(StringType.class))) .thenReturn(new IdentifierData("tmp", new StringType(0l))); converter.cast(new StringType(0l), new IdentifierData("test", new DoubleType())); verify(converter.icg).addQuadruple( new QuadrupleJb(Operator.DOUBLE_TO_STRING, "test", Quadruple.EmptyArgument, "tmp")); } catch (IntermediateCodeGeneratorException e) { fail(); } }
@Test public void testCastDoubleToBooleanFails() { try { when(converter.icg.generateTempIdentifier(any(BooleanType.class))) .thenReturn(new IdentifierData("tmp", new BooleanType())); converter.cast(new BooleanType(), new IdentifierData("test", new DoubleType())); fail(); } catch (IntermediateCodeGeneratorException e) { } }
@Test public void testCastDoubleToArrayFails() { try { when(converter.icg.generateTempIdentifier(any(ArrayType.class))) .thenReturn( new IdentifierData("tmp", new ArrayType( new LongType(), 0))); converter.cast(new ArrayType(new LongType(), 0), new IdentifierData("test", new DoubleType())); fail(); } catch (IntermediateCodeGeneratorException e) { } }
@Test public void testCastDoubleToStructFails() { try { when(converter.icg.generateTempIdentifier(any(StructType.class))) .thenReturn( new IdentifierData("tmp", new StructType( new Member[] { new Member("", new DoubleType()) }))); converter.cast(new StructType( new Member[] { new Member("", new LongType()) }), new IdentifierData("test", new DoubleType())); fail(); } catch (IntermediateCodeGeneratorException e) { } }
@Test public void testCastBooleanToLongFails() { try { when(converter.icg.generateTempIdentifier(any(LongType.class))) .thenReturn(new IdentifierData("tmp", new LongType())); converter.cast(new LongType(), new IdentifierData("test", new BooleanType())); fail(); } catch (IntermediateCodeGeneratorException e) { } }
@Test public void testCastBooleanToDoubleFails() { try { when(converter.icg.generateTempIdentifier(any(DoubleType.class))) .thenReturn(new IdentifierData("tmp", new DoubleType())); converter.cast(new DoubleType(), new IdentifierData("test", new BooleanType())); fail(); } catch (IntermediateCodeGeneratorException e) { } }
@Test public void testCastBooleanToString() { try { when(converter.icg.generateTempIdentifier(any(StringType.class))) .thenReturn(new IdentifierData("tmp", new StringType(0l))); converter.cast(new StringType(0l), new IdentifierData("test", new BooleanType())); verify(converter.icg).addQuadruple( new QuadrupleJb(Operator.BOOLEAN_TO_STRING, "test", Quadruple.EmptyArgument, "tmp")); } catch (IntermediateCodeGeneratorException e) { fail(); } }
@Test public void testCastBooleanToStructFails() { try { when(converter.icg.generateTempIdentifier(any(StructType.class))) .thenReturn( new IdentifierData("tmp", new StructType( new Member[] { new Member("", new BooleanType()) }))); converter.cast(new StructType( new Member[] { new Member("", new LongType()) }), new IdentifierData("test", new BooleanType())); fail(); } catch (IntermediateCodeGeneratorException e) { } }
@Test public void testCastBooleanToArrayFails() { try { when(converter.icg.generateTempIdentifier(any(ArrayType.class))) .thenReturn( new IdentifierData("tmp", new ArrayType( new LongType(), 0))); converter.cast(new ArrayType(new LongType(), 0), new IdentifierData("test", new BooleanType())); fail(); } catch (IntermediateCodeGeneratorException e) { } }
@Test public void testCastStringToLongFails(){ try{ when(converter.icg.generateTempIdentifier(any(LongType.class))) .thenReturn(new IdentifierData("tmp", new LongType())); converter.cast(new LongType(), new IdentifierData("test", new StringType(0l))); }catch (IntermediateCodeGeneratorException e){ } }
@Test public void testCastStringToDoubleFails(){ try { when(converter.icg.generateTempIdentifier(any(DoubleType.class))) .thenReturn( new IdentifierData("tmp", new DoubleType())); converter.cast(new DoubleType(), new IdentifierData("test", new StringType(0l))); fail(); } catch (IntermediateCodeGeneratorException e) { } }
@Test public void testCastStringToBooleanFails() { try { when(converter.icg.generateTempIdentifier(any(BooleanType.class))) .thenReturn(new IdentifierData("tmp", new BooleanType())); converter.cast(new BooleanType(), new IdentifierData("test", new StringType(0l))); fail(); } catch (IntermediateCodeGeneratorException e) { } }
@Test public void testCastStringToStructFails(){ try { when(converter.icg.generateTempIdentifier(any(StructType.class))) .thenReturn( new IdentifierData("tmp", new StructType( new Member[] { new Member("", new StringType(0l)) }))); converter.cast(new StructType( new Member[] { new Member("", new LongType()) }), new IdentifierData("test", new StringType(0l))); fail(); } catch (IntermediateCodeGeneratorException e) { } }
@Test public void testCastStringToArrayFails(){ try { when(converter.icg.generateTempIdentifier(any(ArrayType.class))) .thenReturn( new IdentifierData("tmp", new ArrayType( new LongType(), 0))); converter.cast(new ArrayType(new LongType(), 0), new IdentifierData("test", new StringType(0l))); fail(); } catch (IntermediateCodeGeneratorException e) { } }
@Test public void testCastStructToLongFails(){ try{ when(converter.icg.generateTempIdentifier(any(LongType.class))) .thenReturn(new IdentifierData("tmp", new LongType())); converter.cast(new LongType(), new IdentifierData("test", new StructType( new Member[] { new Member("", new LongType()) }))); }catch (IntermediateCodeGeneratorException e){ } }
@Test public void testCastStructToDoubleFails(){ try{ when(converter.icg.generateTempIdentifier(any(DoubleType.class))) .thenReturn(new IdentifierData("tmp", new DoubleType())); converter.cast(new LongType(), new IdentifierData("test", new StructType( new Member[] { new Member("", new LongType()) }))); }catch (IntermediateCodeGeneratorException e){ } }
@Test public void testCastStructToStringFails(){ try { when(converter.icg.generateTempIdentifier(any(StringType.class))) .thenReturn(new IdentifierData("tmp", new StringType(0l))); converter.cast(new StringType(0l), new IdentifierData("test", new StructType( new Member[] { new Member("", new LongType()) }))); fail(); } catch (IntermediateCodeGeneratorException e) { } }
@Test public void testCastCastStructToBooleanFails(){ try { when(converter.icg.generateTempIdentifier(any(BooleanType.class))) .thenReturn(new IdentifierData("tmp", new BooleanType())); converter.cast(new StringType(0l), new IdentifierData("test", new StructType( new Member[] { new Member("", new LongType()) }))); fail(); } catch (IntermediateCodeGeneratorException e) { } }
@Test public void testCastCastStructToArrayFails(){ try { when(converter.icg.generateTempIdentifier(any(ArrayType.class))) .thenReturn(new IdentifierData("tmp", new ArrayType(new LongType(), 0))); converter.cast(new StringType(0l), new IdentifierData("test", new StructType( new Member[] { new Member("", new LongType()) }))); fail(); } catch (IntermediateCodeGeneratorException e) { } }
@Test public void testCastArrayToLongFails(){ try{ when(converter.icg.generateTempIdentifier(any(LongType.class))) .thenReturn(new IdentifierData("tmp", new LongType())); converter.cast(new LongType(), new IdentifierData("test", new ArrayType(new LongType(), 0))); fail(); }catch (IntermediateCodeGeneratorException e){ } }
@Test public void testCastArrayToDoubleFails(){ try { when(converter.icg.generateTempIdentifier(any(DoubleType.class))) .thenReturn( new IdentifierData("tmp", new DoubleType())); converter.cast(new DoubleType(), new IdentifierData("test", new ArrayType(new LongType(), 0))); fail(); } catch (IntermediateCodeGeneratorException e) { } }
@Test public void testCastArrayToBoolean(){ try { when(converter.icg.generateTempIdentifier(any(BooleanType.class))) .thenReturn(new IdentifierData("tmp", new BooleanType())); converter.cast(new BooleanType(), new IdentifierData("test", new ArrayType(new LongType(), 0))); fail(); } catch (IntermediateCodeGeneratorException e) { } }
@Test public void testCastArrayToString(){ try { when(converter.icg.generateTempIdentifier(any(StringType.class))) .thenReturn(new IdentifierData("tmp", new StringType(0l))); converter.cast(new StringType(0l), new IdentifierData("test", new ArrayType(new LongType(), 0))); fail(); } catch (IntermediateCodeGeneratorException e) { } }
@Test public void testCastArrayToStruct(){ try { when(converter.icg.generateTempIdentifier(any(StructType.class))) .thenReturn( new IdentifierData("tmp", new StructType( new Member[] { new Member("", new BooleanType()) }))); converter.cast(new StructType( new Member[] { new Member("", new LongType()) }), new IdentifierData("test", new ArrayType(new LongType(), 0))); fail(); } catch (IntermediateCodeGeneratorException e) { } } |
JavabiteConfig extends Properties { public Set<ConfigCategory> getConfigCategories() { Set<ConfigCategory> categories = new HashSet<>(); for (String key : this.stringPropertyNames()) { if (key.contains(".")) { categories.add(new ConfigCategory(key.substring(0, key.indexOf(".")))); } else { categories.add(new ConfigCategory("")); } } return categories; } JavabiteConfig(); JavabiteConfig(String path); static JavabiteConfig getDefaultConfig(); void configurationChanges(); static void registerConfigurable(Configurable config); @Override synchronized Object setProperty(String key, String value); @Override String getProperty(String key, String defaultValue); String getProperty(String key, Integer color); String getProperty(String key, List<String> validValues); void writeConfig(); Set<ConfigCategory> getConfigCategories(); Set<ConfigKey> getConfigKeys(ConfigCategory category); Set<ConfigKey> getConfigKeys(String categoryName); final static JavabiteConfig SINGLETON; } | @Test public void testGetConfigCategories() { Set<ConfigCategory> categories = config.getConfigCategories(); assertEquals(3, categories.size()); Iterator<ConfigCategory> it = categories.iterator(); ConfigCategory cc = it.next(); assertEquals("syntaxHighlighting", cc.getName()); assertEquals("Syntax Highlighting", cc.toString()); cc = it.next(); assertEquals("compiler", cc.getName()); assertEquals("Compiler", cc.toString()); cc = it.next(); assertEquals("", cc.getName()); assertEquals("Misc", cc.toString()); } |
JavabiteConfig extends Properties { public Set<ConfigKey> getConfigKeys(ConfigCategory category) { return getConfigKeys(category.getName()); } JavabiteConfig(); JavabiteConfig(String path); static JavabiteConfig getDefaultConfig(); void configurationChanges(); static void registerConfigurable(Configurable config); @Override synchronized Object setProperty(String key, String value); @Override String getProperty(String key, String defaultValue); String getProperty(String key, Integer color); String getProperty(String key, List<String> validValues); void writeConfig(); Set<ConfigCategory> getConfigCategories(); Set<ConfigKey> getConfigKeys(ConfigCategory category); Set<ConfigKey> getConfigKeys(String categoryName); final static JavabiteConfig SINGLETON; } | @Test public void testGetConfigKeys() { Set<ConfigKey> keys = config.getConfigKeys("syntaxHighlighting"); assertEquals(2, keys.size()); Iterator<ConfigKey> it = keys.iterator(); ConfigKey ck = it.next(); assertEquals("syntaxHighlighting.string", ck.getName()); assertEquals("String", ck.toString()); ck = it.next(); assertEquals("syntaxHighlighting.num", ck.getName()); assertEquals("Num", ck.toString()); keys = config.getConfigKeys("compiler"); assertEquals(2, keys.size()); it = keys.iterator(); ck = it.next(); assertEquals("compiler.lexer", ck.getName()); assertEquals("Lexer", ck.toString()); ck = it.next(); assertEquals("compiler.parser", ck.getName()); assertEquals("Parser", ck.toString()); keys = config.getConfigKeys(""); assertEquals(1, keys.size()); it = keys.iterator(); ck = it.next(); assertEquals("other", ck.getName()); assertEquals("Other", ck.toString()); } |
HtmlReportWriter implements ReportWriter { @Override public String write(Report report) { try (final StringWriter writer = new StringWriter()) { reportTemplate.process(report, writer); return writer.toString(); } catch (TemplateException e) { throw new RuntimeException("Error populating default report HTML template '"+ reportTemplate.getName() +"': " + e.getMessage(), e); } catch (IOException e) { throw new RuntimeException("Error writing HTML template to string: " + e.getMessage(), e); } } HtmlReportWriter(); @Override String write(Report report); @Override boolean write(Report report, String reportFile); boolean write(Report report, String reportFile, String freeMarkerTemplate); } | @Test public void testWriteToString() { final String htmlReport = reportWriter.write(report); Assert.assertTrue(true); } |
CollectionManagementService { protected void checkAndInstallConfiguration(String configName) throws IOException { this.checkAndInstallConfiguration(configName, false); } CollectionManagementService(List<String> zkHosts); CollectionManagementService(List<String> zkHost, String ... repositories); protected CollectionManagementService(String ... repositories); void createCollection(String collectionName, String configName, int numOfShards, int numOfReplicas); void createCollection(String collectionName, String configName, int numOfShards, int numOfReplicas, Boolean autoAddReplicas); boolean collectionExists(String collectionName); void updateCollection(String collectionName, String configName); void updateCollection(String collectionName, String configName, Integer numOfShards, Integer numOfReplicas, Boolean autoAddReplicas); Long getVersionAndInstallIfNecessary(String dependency); } | @Test public void checkAndInstallConfigurationTest() throws IOException { String configName = "com.rbmhtechnology.vind:backend-solr:1.1.2"; service.checkAndInstallConfiguration(configName); assertTrue(service.configurationIsDeployed(configName)); } |
CollectionManagementService { protected List<String> listRuntimeDependencies(String collectionName) throws IOException, SolrServerException { logger.debug("Checking runtime-dependencies for collection {}", collectionName); ModifiableSolrParams params = new ModifiableSolrParams().set("file",RUNTIME_LIB_FILE_NAME); SolrRequest request = new QueryRequest(params); request.setPath("/admin/file"); request.setResponseParser(new InputStreamResponseParser("json")); try (CloudSolrClient client = createCloudSolrClient()) { final NamedList o = client.request(request, collectionName); final LineIterator it = IOUtils.lineIterator((InputStream) o.get("stream"), "utf-8"); final List<String> returnValues = Streams.stream(it).collect(Collectors.toList()); if (returnValues.size() == 1 && returnValues.get(0).startsWith("{\"responseHeader\":{\"status\":404")) { logger.warn("Release does not yet contain rumtimelib configuration file. Runtimelibs have to be installed manually."); return Collections.emptyList(); } return returnValues; } } CollectionManagementService(List<String> zkHosts); CollectionManagementService(List<String> zkHost, String ... repositories); protected CollectionManagementService(String ... repositories); void createCollection(String collectionName, String configName, int numOfShards, int numOfReplicas); void createCollection(String collectionName, String configName, int numOfShards, int numOfReplicas, Boolean autoAddReplicas); boolean collectionExists(String collectionName); void updateCollection(String collectionName, String configName); void updateCollection(String collectionName, String configName, Integer numOfShards, Integer numOfReplicas, Boolean autoAddReplicas); Long getVersionAndInstallIfNecessary(String dependency); } | @Test public void listRuntimeDependenciesTest() throws IOException, SolrServerException { List<String> runtimeDependencies = service.listRuntimeDependencies("my-collection"); assertThat(runtimeDependencies, contains("org.apache.solr:solr-cell:6.1.0", "com.rbmhtechnology.solr.test:test-jar:1.0")); } |
CollectionManagementService { public Long getVersionAndInstallIfNecessary(String dependency) { try (CloudSolrClient client = createCloudSolrClient()) { SolrQuery query = new SolrQuery("blobName:"+Utils.toBlobName(dependency)); query.setSort("version", SolrQuery.ORDER.desc); QueryResponse response = client.query(".system",query); if(response.getResults().getNumFound() > 0) { return Long.valueOf(response.getResults().get(0).get("version").toString()); } else { Path configDirectory = Files.createTempDirectory(Utils.normalizeFileName(dependency)); Path jarFile = Utils.downloadToTempDir(configDirectory, repositories, dependency); return uploadRuntimeLib(dependency, jarFile); } } catch (SolrServerException | IOException e) { logger.warn("Cannot load runtime dependeny " + dependency + ". This may cause runtime issues."); return -1L; } } CollectionManagementService(List<String> zkHosts); CollectionManagementService(List<String> zkHost, String ... repositories); protected CollectionManagementService(String ... repositories); void createCollection(String collectionName, String configName, int numOfShards, int numOfReplicas); void createCollection(String collectionName, String configName, int numOfShards, int numOfReplicas, Boolean autoAddReplicas); boolean collectionExists(String collectionName); void updateCollection(String collectionName, String configName); void updateCollection(String collectionName, String configName, Integer numOfShards, Integer numOfReplicas, Boolean autoAddReplicas); Long getVersionAndInstallIfNecessary(String dependency); } | @Test public void getVersionAndInstallIfNecessaryTest() { Long version = service.getVersionAndInstallIfNecessary("com.rbmhtechnology.solr.test:test-jar:1.0"); assertEquals(1L, version, 0); }
@Test public void getVersionAndInstallIfNecessaryTest2() { Long version = service.getVersionAndInstallIfNecessary("org.apache.solr:solr-cell:6.1.0"); assertEquals(1L, version, 0); } |
CollectionManagementService { protected Map<String,Long> checkAndInstallRuntimeDependencies(String collectionName) { List<String> dependencies = Collections.emptyList(); try { dependencies = listRuntimeDependencies(collectionName); } catch (SolrServerException | IOException e) { logger.warn("Cannot get runtime dependencies from configuration for collection " + collectionName); } Map<String,Long> runtimeLibVersions = new HashMap<>(); for(String dependency : dependencies) { long version = getVersionAndInstallIfNecessary(dependency); if(version > -1) { runtimeLibVersions.put(Utils.toBlobName(dependency), version); } } return runtimeLibVersions; } CollectionManagementService(List<String> zkHosts); CollectionManagementService(List<String> zkHost, String ... repositories); protected CollectionManagementService(String ... repositories); void createCollection(String collectionName, String configName, int numOfShards, int numOfReplicas); void createCollection(String collectionName, String configName, int numOfShards, int numOfReplicas, Boolean autoAddReplicas); boolean collectionExists(String collectionName); void updateCollection(String collectionName, String configName); void updateCollection(String collectionName, String configName, Integer numOfShards, Integer numOfReplicas, Boolean autoAddReplicas); Long getVersionAndInstallIfNecessary(String dependency); } | @Test public void checkAndInstallRuntimeDependenciesTest() { Map<String,Long> dependencies = service.checkAndInstallRuntimeDependencies("my-collection"); assertThat(dependencies, hasEntry("org.apache.solr_solr-cell_6.1.0", 1L)); assertThat(dependencies, hasEntry("com.rbmhtechnology.solr.test_test-jar_1.0",1L)); } |
CollectionManagementService { protected void addOrUpdateRuntimeDependencies(Map<String, Long> runtimeDependencies, String collectionName) { logger.info("Adding runtime-dependencies for {}", collectionName); for(String blobName : runtimeDependencies.keySet()) { RuntimeLibRequest request = new RuntimeLibRequest(RuntimeLibRequestType.add, blobName, runtimeDependencies.get(blobName)); try (CloudSolrClient client = createCloudSolrClient()) { client.request(request, collectionName); logger.debug("Added {} (v{})", request.blobName, request.version); } catch (SolrServerException | IOException e) { logger.warn("Cannot add runtime dependency {} (v{}) to collection {}", blobName, runtimeDependencies.get(blobName), collectionName); logger.info("Try to update dependency"); request.setType(RuntimeLibRequestType.update); try (CloudSolrClient client = createCloudSolrClient()) { client.request(request, collectionName); } catch (SolrServerException | IOException e1) { logger.warn("Cannot update runtime dependency {} (v{}) to collection {}", blobName, runtimeDependencies.get(blobName), collectionName); } } } } CollectionManagementService(List<String> zkHosts); CollectionManagementService(List<String> zkHost, String ... repositories); protected CollectionManagementService(String ... repositories); void createCollection(String collectionName, String configName, int numOfShards, int numOfReplicas); void createCollection(String collectionName, String configName, int numOfShards, int numOfReplicas, Boolean autoAddReplicas); boolean collectionExists(String collectionName); void updateCollection(String collectionName, String configName); void updateCollection(String collectionName, String configName, Integer numOfShards, Integer numOfReplicas, Boolean autoAddReplicas); Long getVersionAndInstallIfNecessary(String dependency); } | @Test public void addOrUpdateRuntimeDependenciesTest() { service.addOrUpdateRuntimeDependencies(Collections.singletonMap("com.rbmhtechnology.solr.test_test-jar_1.0",1L),"my-collection"); } |
SolrSearchServer extends SmartSearchServerBase { @Override public boolean execute(Update update,DocumentFactory factory) { final boolean isUpdatable = factory.isUpdatable() && factory.getFields().values().stream() .allMatch( descriptor -> descriptor.isUpdate()); if (isUpdatable) { final SolrInputDocument sdoc = getSolrUpdateDocument(update, factory.getType()); try { if (solrClientLogger.isTraceEnabled()) { solrClientLogger.debug(">>> add({}): {}", update.getId(), sdoc); } else { solrClientLogger.debug(">>> add({})", update.getId()); } SolrInputDocument finalDoc = sdoc; log.debug("Atomic Update - Get version of original document [{}].",update.getId()); final SolrDocument updatedDoc = solrClient.getById(update.getId()); if (updatedDoc == null){ throw new SearchServerException("Can not execute solr partial update for non existing document for update id " + update.getId()); } final Object version = updatedDoc.getFieldValue("_version_"); if (Objects.nonNull(version)) { finalDoc.setField("_version_", version); } else { log.warn("Error updating document [{}]: " + "Atomic updates in nested documents are not supported by Solr", updatedDoc.get(ID)); return false; } log.debug("Atomic Update - Get nested documents of [{}].",update.getId()); final NamedList<Object> paramList = new NamedList<>(); paramList.add(CommonParams.Q, "!( _id_:"+ update.getId()+")&(_root_:"+ update.getId()+")"); final QueryResponse query = solrClient.query(paramList.toSolrParams(), REQUEST_METHOD); if (CollectionUtils.isNotEmpty(query.getResults())) { log.debug("Update document [{}]: doc has {} nested documents, changing from partial update to full index.", finalDoc.getFieldValue(SolrUtils.Fieldname.ID), query.getResults().size()); final List<SolrInputDocument> childDocs = query.getResults().stream() .map(nestedDoc -> SolrUtils.toSolrInputDocument(nestedDoc)) .collect(Collectors.toList()); finalDoc = this.getUpdatedSolrDocument(sdoc, updatedDoc, childDocs); } try { log.debug("Atomic Update - Updating document [{}]: current version [{}]", finalDoc.getFieldValue(SolrUtils.Fieldname.ID), version); final UpdateResponse response = solrClient.add(finalDoc); log.debug("Atomic Update - Solr update time: query time [{}] - elapsed time [{}]", response.getQTime(), response.getQTime()); return true; } catch (HttpSolrClient.RemoteSolrException e) { log.warn("Error updating document [{}]: [{}]", finalDoc.getFieldValue(ID),e.getMessage(), e); return false; } } catch (SolrServerException | IOException e) { log.error("Unable to perform solr partial update on document with id [{}]", update.getId(), e); throw new SearchServerException("Can not execute solr partial update.", e); } } else { Exception e = new SearchServerException("It is not safe to execute solr partial update: Document contains non stored fields"); log.error("Unable to perform solr partial update on document with id [{}]", update.getId(), e); throw new RuntimeException("Can not execute solr partial update.", e); } } SolrSearchServer(); SolrSearchServer(SolrClient client); protected SolrSearchServer(SolrClient client, boolean check); @Override Object getBackend(); @Override StatusResult getBackendStatus(); @Override IndexResult index(Document ... docs); @Override IndexResult index(List<Document> docs); @Override IndexResult indexWithin(Document doc, int withinMs); @Override IndexResult indexWithin(List<Document> doc, int withinMs); @Override void commit(boolean optimize); @Override DeleteResult delete(Document doc); @Override DeleteResult deleteWithin(Document doc, int withinMs); @Override String getRawQuery(FulltextSearch search, DocumentFactory factory); @Override String getRawQuery(FulltextSearch search, Class<T> c); @Override boolean execute(Update update,DocumentFactory factory); @Override DeleteResult execute(Delete delete, DocumentFactory factory); @Override SuggestionResult execute(ExecutableSuggestionSearch search, Class<T> c); @Override SuggestionResult execute(ExecutableSuggestionSearch search, DocumentFactory assets); @Override SuggestionResult execute(ExecutableSuggestionSearch search, DocumentFactory assets,DocumentFactory childFactory); @Override String getRawQuery(ExecutableSuggestionSearch search, DocumentFactory factory); @Override String getRawQuery(ExecutableSuggestionSearch search, DocumentFactory factory, DocumentFactory childFactory); @Override String getRawQuery(ExecutableSuggestionSearch search, Class<T> c); @Override BeanGetResult<T> execute(RealTimeGet search, Class<T> c); @Override GetResult execute(RealTimeGet search, DocumentFactory assets); @Override InverseSearchResult execute(InverseSearch inverseSearch, DocumentFactory factory); @Override IndexResult addInverseSearchQuery(InverseSearchQuery query); @Override void clearIndex(); @Override void close(); @Override Class<? extends ServiceProvider> getServiceProviderClass(); static final String SOLR_WILDCARD; static final String SUGGESTION_DF_FIELD; static SolrRequest.METHOD REQUEST_METHOD; } | @Test public void testSearch() throws Exception { final DocumentFactoryBuilder docFactoryBuilder = new DocumentFactoryBuilder("asset"); FieldDescriptor descriptor = new FieldDescriptorBuilder().setFacet(true).buildTextField("text"); docFactoryBuilder.addField(descriptor); DocumentFactory documents = docFactoryBuilder.build(); server.execute(Search.fulltext("hello world").filter(eq("text", "123")).sort("id", Sort.Direction.Desc),documents); ArgumentCaptor<SolrQuery> argument = ArgumentCaptor.forClass(SolrQuery.class); verify(solrClient).query(argument.capture(), any(SolrRequest.METHOD.class)); SolrQuery query = argument.getValue(); assertEquals("hello world", query.getQuery()); assertEquals(2, query.getFilterQueries().length); assertThat(Arrays.asList(query.getFilterQueries()),containsInAnyOrder("_type_:asset","dynamic_single_facet_string_text:\"123\"")); assertEquals("id Desc", query.getSortField()); } |
SolrSearchServer extends SmartSearchServerBase { @Override public IndexResult index(Document ... docs) { Asserts.notNull(docs,"Document to index should not be null."); Asserts.check(docs.length > 0, "Should be at least one document to index."); return indexMultipleDocuments(Arrays.asList(docs), -1); } SolrSearchServer(); SolrSearchServer(SolrClient client); protected SolrSearchServer(SolrClient client, boolean check); @Override Object getBackend(); @Override StatusResult getBackendStatus(); @Override IndexResult index(Document ... docs); @Override IndexResult index(List<Document> docs); @Override IndexResult indexWithin(Document doc, int withinMs); @Override IndexResult indexWithin(List<Document> doc, int withinMs); @Override void commit(boolean optimize); @Override DeleteResult delete(Document doc); @Override DeleteResult deleteWithin(Document doc, int withinMs); @Override String getRawQuery(FulltextSearch search, DocumentFactory factory); @Override String getRawQuery(FulltextSearch search, Class<T> c); @Override boolean execute(Update update,DocumentFactory factory); @Override DeleteResult execute(Delete delete, DocumentFactory factory); @Override SuggestionResult execute(ExecutableSuggestionSearch search, Class<T> c); @Override SuggestionResult execute(ExecutableSuggestionSearch search, DocumentFactory assets); @Override SuggestionResult execute(ExecutableSuggestionSearch search, DocumentFactory assets,DocumentFactory childFactory); @Override String getRawQuery(ExecutableSuggestionSearch search, DocumentFactory factory); @Override String getRawQuery(ExecutableSuggestionSearch search, DocumentFactory factory, DocumentFactory childFactory); @Override String getRawQuery(ExecutableSuggestionSearch search, Class<T> c); @Override BeanGetResult<T> execute(RealTimeGet search, Class<T> c); @Override GetResult execute(RealTimeGet search, DocumentFactory assets); @Override InverseSearchResult execute(InverseSearch inverseSearch, DocumentFactory factory); @Override IndexResult addInverseSearchQuery(InverseSearchQuery query); @Override void clearIndex(); @Override void close(); @Override Class<? extends ServiceProvider> getServiceProviderClass(); static final String SOLR_WILDCARD; static final String SUGGESTION_DF_FIELD; static SolrRequest.METHOD REQUEST_METHOD; } | @Test public void testIndex() throws Exception { FieldDescriptor<String> title = new FieldDescriptorBuilder<>().setFullText(true).buildTextField("title"); SingleValueFieldDescriptor.DateFieldDescriptor<ZonedDateTime> created = new FieldDescriptorBuilder<>().setFacet(true).buildDateField("created"); MultiValueFieldDescriptor.NumericFieldDescriptor<Integer> category = new FieldDescriptorBuilder<>().setFacet(true).buildMultivaluedNumericField("category", Integer.class); final DocumentFactoryBuilder docFactoryBuilder = new DocumentFactoryBuilder("asset"); DocumentFactory documents = docFactoryBuilder.addField(title).addField(created).addField(category).build(); final ZonedDateTime creationDate = ZonedDateTime.of(2016, 1, 1, 0, 0, 0, 0, ZoneId.systemDefault()); Document d1 = documents.createDoc("1") .setValue(title, "Hello World") .setValue(created, creationDate) .setValues(category, Arrays.asList(1, 2)); Document d2 = documents.createDoc("2") .setValue(title, "Hello Austria") .setValue(created, creationDate) .setValue(category, 4); server.index(d1); ArgumentCaptor<ArrayList<SolrInputDocument>> argument = ArgumentCaptor.forClass((Class)ArrayList.class); verify(solrClient).add(argument.capture()); ArrayList<SolrInputDocument> docs = argument.getValue(); SolrInputDocument doc = docs.get(0); assertThat(doc.get(SolrUtils.Fieldname.ID), solrInputField(SolrUtils.Fieldname.ID, "1")); assertThat(doc.get(SolrUtils.Fieldname.TYPE), solrInputField(SolrUtils.Fieldname.TYPE, "asset")); assertThat(doc.get("dynamic_multi_int_category"), solrInputField("dynamic_multi_int_category", Matchers.containsInAnyOrder(1,2))); assertThat(doc.get("dynamic_single_string_title"), solrInputField("dynamic_single_string_title", "Hello World")); assertThat(doc.get("dynamic_single_date_created"), solrInputField("dynamic_single_date_created", Date.from(creationDate.toInstant()))); server.commit(); SearchResult result = server.execute(Search .fulltext("hello") .filter(or(category.between(3, 5), created.before(ZonedDateTime.now()))) , documents); } |
ChildrenFilterSerializer { public String serialize(Filter filter){ final Filter normalizedFilter = normalize(filter); if (AndFilter.class.isAssignableFrom(normalizedFilter.getClass())) return serialize((AndFilter)normalizedFilter); else if (OrFilter.class.isAssignableFrom(normalizedFilter.getClass())) return serialize((OrFilter)normalizedFilter); else if (isHierarchicalFilter(normalizedFilter)) { final String parentFilter = new SolrFilterSerializer(parentFactory, strict).serialize(normalizedFilter,searchContext); return parentFilter; } else { final String childFilter = new SolrFilterSerializer(childFactory, strict).serialize(normalizedFilter,searchContext); return String.format(CHILD_QUERY_TEMPLATE, TYPE, parentFactory.getType(), String.format(TYPE_FILTER, TYPE, childFactory.getType()), childFilter); } } ChildrenFilterSerializer(DocumentFactory parentFactory, DocumentFactory childFactory, String searchContext, boolean strict, boolean childrenSearch); String serialize(Filter filter); } | @Test @Ignore public void testFilterSerialization() { final ChildrenFilterSerializer serializer = new ChildrenFilterSerializer(parent, child, null, false, true); final Filter.DescriptorFilter<String> parentFilter = new Filter.DescriptorFilter<>(parent_value, "p_v", Scope.Facet); final Filter.DescriptorFilter<String> sharedFilter = new Filter.DescriptorFilter<>(shared_value, "s_v", Scope.Facet); final Filter.DescriptorFilter<String> childrenFilter = new Filter.DescriptorFilter<>(child_value, "c_v", Scope.Facet); final AndFilter andFilter = new AndFilter(parentFilter, sharedFilter); String serializedFilter = serializer.serialize(andFilter); assertEquals("_type_:parent AND dynamic_single_stored_facet_string_parent_value:\"p_v\" AND {!parent which='_type_:parent' v='_type_:child AND dynamic_single_stored_facet_string_shared_value:\"s_v\"'}",serializedFilter); serializedFilter = serializer.serialize(new AndFilter(new OrFilter(childrenFilter, andFilter),not(childrenFilter))); assertEquals("({!parent which='_type_:parent' v='_type_:child AND NOT(dynamic_single_stored_facet_string_child_value:\"c_v\") AND dynamic_single_stored_facet_string_child_value:\"c_v\"'} ) OR (_type_:parent AND dynamic_single_stored_facet_string_parent_value:\"p_v\" AND {!parent which='_type_:parent' v='_type_:child AND NOT(dynamic_single_stored_facet_string_child_value:\"c_v\") AND dynamic_single_stored_facet_string_shared_value:\"s_v\"'} )",serializedFilter); } |
ChildrenFilterSerializer { private Filter normalize(AndFilter filter){ final Set<Filter> normalizedFilters = filter.getChildren().stream() .map(this::normalize) .collect(Collectors.toSet()); final Set<Filter> normalizedChildren = normalizedFilters.stream() .filter(f -> !f.getType().equals(filter.getType()) && !f.getType().equals("OrFilter")) .collect(Collectors.toSet()); normalizedFilters.stream(). filter(f -> f.getType().equals(filter.getType())) .forEach( af -> normalizedChildren.addAll(((AndFilter)af).getChildren())); final Set<Filter> orChildren = normalizedFilters.stream(). filter(f -> f.getType().equals("OrFilter")) .map( of -> normalize((OrFilter) of)) .collect(Collectors.toSet()); final Filter orFilterPivot = orChildren.stream() .findFirst() .orElse(null); if(Objects.nonNull(orFilterPivot)) { orChildren.remove(orFilterPivot); final Set<Filter> andResultFilters= ((OrFilter) orFilterPivot).getChildren().stream() .map( f-> AndFilter.fromSet(Sets.union( normalizedChildren, Sets.newHashSet(f)))) .map( af -> AndFilter.fromSet(Sets.union( orChildren, Sets.newHashSet(af)))) .collect(Collectors.toSet()); final Set<Filter> andResultNormalizedFilters = andResultFilters.stream() .map(f -> normalize(f)) .collect(Collectors.toSet()); if(CollectionUtils.isNotEmpty(andResultNormalizedFilters)) { return OrFilter.fromSet(andResultNormalizedFilters); } } if(CollectionUtils.isNotEmpty(orChildren)) { return OrFilter.fromSet(orChildren); } return AndFilter.fromSet(normalizedChildren); } ChildrenFilterSerializer(DocumentFactory parentFactory, DocumentFactory childFactory, String searchContext, boolean strict, boolean childrenSearch); String serialize(Filter filter); } | @Test public void testNormalization() { final ChildrenFilterSerializer serializer = new ChildrenFilterSerializer(parent, child, null, false, false); Filter parentValueFilter = new OrFilter(eq(parent_value,"value1"), eq(parent_value,"value2")); Filter sharedValueFilter = new OrFilter(new OrFilter(eq(shared_value,"shared1"), eq(shared_value,"shared2")), eq(shared_value,"shared3")); Filter mainFilter = new AndFilter(parentValueFilter, sharedValueFilter); Filter normalizedFilter = serializer.normalize(mainFilter); assertEquals("OrFilter",normalizedFilter.getType()); assertEquals(6,((OrFilter)normalizedFilter).getChildren().size()); Filter parentChildrenValueFilter = new AndFilter(eq(shared_value,"shared4"), eq(child_value,"child1")); mainFilter = new AndFilter(new AndFilter(parentValueFilter, sharedValueFilter), parentChildrenValueFilter); normalizedFilter = serializer.normalize(mainFilter); assertEquals("OrFilter",normalizedFilter.getType()); assertEquals(6,((OrFilter)normalizedFilter).getChildren().size()); parentChildrenValueFilter = new AndFilter(eq(shared_value,"shared1"), eq(child_value,"child1")); sharedValueFilter = new OrFilter(new OrFilter(parentChildrenValueFilter, eq(shared_value,"shared2")), eq(shared_value,"shared3")); mainFilter = new AndFilter(parentValueFilter, sharedValueFilter); normalizedFilter = serializer.normalize(mainFilter); assertEquals("OrFilter",normalizedFilter.getType()); assertEquals(6,((OrFilter)normalizedFilter).getChildren().size()); parentChildrenValueFilter = new AndFilter(eq(shared_value,"shared1"), eq(child_value,"child1")); sharedValueFilter = new OrFilter(new OrFilter(parentChildrenValueFilter, eq(shared_value,"shared2")), eq(shared_value,"shared3")); mainFilter = new OrFilter(new AndFilter(eq(parent_value,"value1"), eq(parent_value,"value2")), sharedValueFilter); normalizedFilter = serializer.normalize(mainFilter); assertEquals("OrFilter",normalizedFilter.getType()); assertEquals(4,((OrFilter)normalizedFilter).getChildren().size()); } |
JsonReportWriter implements ReportWriter { @Override public String write(Report report) { try { return mapper.writeValueAsString(report); } catch (JsonProcessingException e) { log.error("Error writing report as Json string: {}", e.getMessage(), e); return null; } } JsonReportWriter(); @Override String write(Report report); @Override boolean write(Report report, String reportFile); } | @Test public void testWriteToString() { final String jsonReport = reportWriter.write(report); Assert.assertTrue(true); } |
FacetMapper { public static <T> Facet stringQuery2FacetMapper(FieldDescriptor<T> field,String facetName, Map<String,String> query) { final String stringQuery = query.values().iterator().next(); Class<T> type = field.getType(); if (ComplexFieldDescriptor.class.isAssignableFrom(field.getClass())) { type = ((ComplexFieldDescriptor)field).getFacetType(); } if (query.size() == 1 && !intervalDateFacetMatcher(stringQuery) && !INTERVAL_NUMERIC_FACET.matcher(stringQuery).matches()) { return queryFacetMapper(facetName,field.getName(), stringQuery); } else { if (Date.class.isAssignableFrom(type) || ZonedDateTime.class.isAssignableFrom(type)) { Interval.DateMathInterval[] intervals = query.keySet().stream() .map(key -> intervalDateFacetMapper(key, query.get(key))) .toArray(Interval.DateMathInterval[]::new); if (SingleValueFieldDescriptor.DateFieldDescriptor.class.isAssignableFrom(field.getClass())) { return Facets.interval(facetName, (SingleValueFieldDescriptor.DateFieldDescriptor) field, intervals); } else if (SingleValueFieldDescriptor.UtilDateFieldDescriptor.class.isAssignableFrom(field.getClass())) { return Facets.interval(facetName, (SingleValueFieldDescriptor.UtilDateFieldDescriptor) field, intervals); } else if (MultiValueFieldDescriptor.DateFieldDescriptor.class.isAssignableFrom(field.getClass())) { return Facets.interval(facetName, (MultiValueFieldDescriptor.DateFieldDescriptor) field, intervals); } else if (MultiValueFieldDescriptor.UtilDateFieldDescriptor.class.isAssignableFrom(field.getClass())) { return Facets.interval(facetName, (MultiValueFieldDescriptor.UtilDateFieldDescriptor) field, intervals); }if (MultiValuedComplexField.UtilDateComplexField.class.isAssignableFrom(field.getClass())) { return Facets.interval(facetName, (MultiValuedComplexField.UtilDateComplexField) field, intervals); }if (SingleValuedComplexField.UtilDateComplexField.class.isAssignableFrom(field.getClass())) { return Facets.interval(facetName, (SingleValuedComplexField.UtilDateComplexField) field, intervals); }if (MultiValuedComplexField.DateComplexField.class.isAssignableFrom(field.getClass())) { return Facets.interval(facetName, (MultiValuedComplexField.DateComplexField) field, intervals); }if (SingleValuedComplexField.DateComplexField.class.isAssignableFrom(field.getClass())) { return Facets.interval(facetName, (SingleValuedComplexField.DateComplexField) field, intervals); } else { throw new RuntimeException("Invalid interval query string definition: '"+query+"'"); } } else if (Number.class.isAssignableFrom(type)){ Interval.NumericInterval[] intervals = query.keySet().stream() .map(key -> intervalNumericFacetMapper(key, (FieldDescriptor<Number>) field, query.get(key))) .toArray(Interval.NumericInterval[]::new); return Facets.interval(facetName,(FieldDescriptor<Number>)field,intervals); } else { throw new RuntimeException("Invalid facet query string definition: '"+query+"'"); } } } static Facet stringQuery2FacetMapper(FieldDescriptor<T> field,String facetName, Map<String,String> query); static Interval<DateMathExpression> intervalDateFacetMapper(String name, String query); static Interval intervalNumericFacetMapper(String name, FieldDescriptor<T> field, String query); static Facet queryFacetMapper(String name, String fieldName, String query); static final String SOLR_MATH_UNITS_GROUP; static final String SOLR_ROOT_UNITS_GROUP; } | @Test public void test() throws SyntaxError { HashMap<String, String> dateIntervals = new HashMap<>(); dateIntervals.put("after","[NOW+23DAYS/DAY TO *]"); dateIntervals.put("before","[* TO NOW+23DAYS/DAY]"); HashMap<String, String> numberIntervals = new HashMap<>(); numberIntervals.put("bigger","[23 TO *]"); numberIntervals.put("smaller","[* TO 22]"); SingleValueFieldDescriptor.UtilDateFieldDescriptor<Date> testDateField = new FieldDescriptorBuilder().buildUtilDateField("test1"); FieldDescriptor<Float> testNumericField = new FieldDescriptorBuilder().buildNumericField("numericTest", Float.class); Assert.assertTrue(FacetMapper.stringQuery2FacetMapper(testDateField, "dateFacet",dateIntervals).getName().equals("dateFacet")); Assert.assertTrue(FacetMapper.stringQuery2FacetMapper(testNumericField, "numericFacet", numberIntervals).getName().equals("numericFacet")); Assert.assertTrue(true); }
@Test public void testComplexField() throws SyntaxError { HashMap<String, String> dateIntervals = new HashMap<>(); dateIntervals.put("after","[NOW+23DAYS/DAY TO *]"); dateIntervals.put("before","[* TO NOW+23DAYS/DAY]"); HashMap<String, String> numberIntervals = new HashMap<>(); numberIntervals.put("bigger","[23 TO *]"); numberIntervals.put("smaller","[* TO 22]"); SingleValuedComplexField.UtilDateComplexField<Taxonomy,Date,Date> complexDateField = new ComplexFieldDescriptorBuilder<Taxonomy,Date,Date>() .setFacet(true, tax -> Arrays.asList(tax.getDate())) .buildUtilDateComplexField("complexDateTax", Taxonomy.class, Date.class, Date.class); SingleValuedComplexField.NumericComplexField<Taxonomy,Number,Number> complexNumberField = new ComplexFieldDescriptorBuilder<Taxonomy,Number,Number>() .setFacet(true, tax -> Arrays.asList(tax.getTerm())) .buildNumericComplexField("complexNumberTax", Taxonomy.class, Number.class, Number.class); Assert.assertTrue(FacetMapper.stringQuery2FacetMapper(complexDateField, "dateFacet",dateIntervals).getName().equals("dateFacet")); Assert.assertTrue(FacetMapper.stringQuery2FacetMapper(complexNumberField, "numericFacet", numberIntervals).getName().equals("numericFacet")); Assert.assertTrue(true); } |
RESTMetadataProvider implements MetadataProvider { @Override public Document getDocument(Document document, DocumentFactory factory) throws IOException { HttpMethod request = new GetMethod(baseURL); request.addRequestHeader("Authorization", String.format("Bearer %s", bearerToken)); request.setPath(path + document.getId()); int status = client.executeMethod(request); if(status == 200) { JsonNode json = mapper.readValue(request.getResponseBody(), JsonNode.class); for(FieldDescriptor descriptor : factory.listFields()) { try { Object value = getValue(json, descriptor); if(value != null) { document.setValue(descriptor, value); } else LOG.warn("No data found for id {}", document.getId()); } catch (IOException e) { LOG.warn("Cannot use data for id {}: {}", document.getId(), e.getMessage()); } } return document; } else throw new IOException(request.getStatusText()); } RESTMetadataProvider(String baseURL,
String tnt,
String app,
String ws,
String fs,
String type,
String bearerToken); RESTMetadataProvider(String baseURL,
String tnt,
String app,
String ws,
String fs,
String type,
String username,
String password); @Override Collection<Document> getDocuments(Collection<Document> documents, DocumentFactory factory); @Override Document getDocument(Document document, DocumentFactory factory); @Override Document getDocumentById(String id, DocumentFactory factory); @Override Collection<Document> getDocumentsByIds(Collection<String> ids, DocumentFactory factory); @Override T getObject(String id, Class<T> t); @Override Collection<T> getObjects(Collection<String> ids, Class<T> t); @Override T getObject(T o); @Override Collection<T> getObjects(Collection<T> os); static final String ID; } | @Test @Ignore public void testGetDocument() throws Exception { MetadataProvider p = new RESTMetadataProvider( "https: "rbmh", "admin", "global", "1315204862832-1123067022", "asset", "user", "passw" ); Asset a = p.getObject("1359078847993-766700833",Asset.class); Assert.assertEquals("Sean Pettit - Portrait", a.getTitle()); Asset a2 = p.getObject(new Asset("1359078847993-766700833")); Assert.assertEquals("Sean Pettit - Portrait", a2.getTitle()); } |
ElasticWriter extends MonitoringWriter { @Override public void log(MonitoringEntry log) { logger.debug("Indexing log entry: {}", log.toJson()); elasticClient.put(log.toJson()); } ElasticWriter(String elasticHost, String elasticPort, String elasticIndex); @Override void log(MonitoringEntry log); } | @Test @Ignore public void logTest(){ final ElasticWriter elasticWriter = new ElasticWriter("localhost", "9200", "logindex"); elasticWriter.log(new FullTextEntry()); } |
DocumentFactory { public Document createDoc(String id) { return new DocumentImpl(id, this.type); } protected DocumentFactory(String type,boolean updatable, Map<String, FieldDescriptor<?>> fields); protected DocumentFactory(String type,boolean updatable, Map<String, FieldDescriptor<?>> fields, Map<String, FieldDescriptor<?>> inverseSearchMetaFields); Collection<FieldDescriptor<?>> listFields(); boolean hasField(String name); FieldDescriptor getField(String name); FieldDescriptor getInverseSearchMetaField(String name); Map<String, FieldDescriptor<?>> getFields(); Map<String, FieldDescriptor<?>> getInverseSearchMetaFields(); Document createDoc(String id); String getType(); boolean isUpdatable(); InverseSearchQuery createInverseSearchQuery(String id, Filter query); @Override String toString(); static final String ID; static final String TYPE; } | @Test public void setValuesTest() { Document doc = factory.createDoc("idTest"); doc.setValues("multipleStringField","1","2","3"); Collection<Object> values = new ArrayList<>(); values.add("4"); values.add("5"); doc.setValues("multipleStringField", values); Collection<Object> invalidValues = new ArrayList<>(); invalidValues.add("6"); invalidValues.add(7); exception.expect(IllegalArgumentException.class); doc.setValues("multipleStringField", invalidValues); doc.setValues("multipleStringField",1); }
@Test public void addValueTest() { Document doc = factory.createDoc("idTest"); doc.addValue("multipleStringField", "0"); doc.addValue("multipleStringField", "4"); exception.expect(IllegalArgumentException.class); doc.addValue("singleStringField", "5"); doc.addValue("multipleStringField", 4); }
@Test public void removeValueTest() { Document doc = factory.createDoc("idTest"); doc.setValues("multipleStringField","1","2","3"); doc.removeValue("multipleStringField","1"); exception.expect(IllegalArgumentException.class); doc.removeValue("multipleStringField",1); }
@Test public void getValueTest() { Document doc = factory.createDoc("idTest"); doc.setValues("multipleStringField","1","2","3"); doc.setValue("singleStringField", "4"); Assert.assertEquals("get single value", doc.getValue("singleStringField"),"4"); exception.expect(IllegalArgumentException.class); doc.getValue("imaginaryField"); } |
ElasticSearchServer extends SmartSearchServerBase { @Override public IndexResult index(Document... docs) { Asserts.notNull(docs,"Document to index should not be null."); Asserts.check(docs.length > 0, "Should be at least one document to index."); return indexMultipleDocuments(Arrays.asList(docs), -1); } ElasticSearchServer(); ElasticSearchServer(ElasticVindClient client); protected ElasticSearchServer(ElasticVindClient client, boolean check); @Override Object getBackend(); @Override StatusResult getBackendStatus(); @Override IndexResult index(Document... docs); @Override IndexResult index(List<Document> docs); @Override IndexResult indexWithin(Document doc, int withinMs); @Override IndexResult indexWithin(List<Document> docs, int withinMs); @Override DeleteResult delete(Document doc); @Override DeleteResult deleteWithin(Document doc, int withinMs); @Override boolean execute(Update update, DocumentFactory factory); @Override DeleteResult execute(Delete delete, DocumentFactory factory); @Override void commit(boolean optimize); @Override String getRawQuery(FulltextSearch search, DocumentFactory factory); @Override String getRawQuery(FulltextSearch search, Class<T> c); @Override SuggestionResult execute(ExecutableSuggestionSearch search, Class<T> c); @Override SuggestionResult execute(ExecutableSuggestionSearch search, DocumentFactory factory); @Override SuggestionResult execute(ExecutableSuggestionSearch search, DocumentFactory assets, DocumentFactory childFactory); @Override String getRawQuery(ExecutableSuggestionSearch search, DocumentFactory factory); @Override String getRawQuery(ExecutableSuggestionSearch search, DocumentFactory factory, DocumentFactory childFactory); @Override String getRawQuery(ExecutableSuggestionSearch search, Class<T> c); @Override BeanGetResult<T> execute(RealTimeGet search, Class<T> c); @Override GetResult execute(RealTimeGet search, DocumentFactory assets); @Override InverseSearchResult execute(InverseSearch inverseSearch, DocumentFactory documentFactory); @Override IndexResult addInverseSearchQuery(InverseSearchQuery query); @Override void clearIndex(); @Override void close(); @Override Class<? extends ServiceProvider> getServiceProviderClass(); } | @Test public void indexTest(){ server.clearIndex(); final DocumentFactoryBuilder docFactoryBuilder = new DocumentFactoryBuilder("TestDoc"); final FieldDescriptor descriptor = new FieldDescriptorBuilder().setFacet(true).buildTextField("title"); docFactoryBuilder.addField(descriptor); final DocumentFactory documents = docFactoryBuilder.build(); final Document doc1 = documents.createDoc("AA-2X3451") .setValue(descriptor, "The last ascent of man"); final Document doc2 = documents.createDoc("AA-2X6891") .setValue(descriptor, "Dawn of humanity: the COVID-19 chronicles"); final IndexResult indexResult = server.index(doc1,doc2); assertNotNull(indexResult); } |
ElasticSearchServer extends SmartSearchServerBase { @Override public DeleteResult delete(Document doc) { return deleteWithin(doc, -1); } ElasticSearchServer(); ElasticSearchServer(ElasticVindClient client); protected ElasticSearchServer(ElasticVindClient client, boolean check); @Override Object getBackend(); @Override StatusResult getBackendStatus(); @Override IndexResult index(Document... docs); @Override IndexResult index(List<Document> docs); @Override IndexResult indexWithin(Document doc, int withinMs); @Override IndexResult indexWithin(List<Document> docs, int withinMs); @Override DeleteResult delete(Document doc); @Override DeleteResult deleteWithin(Document doc, int withinMs); @Override boolean execute(Update update, DocumentFactory factory); @Override DeleteResult execute(Delete delete, DocumentFactory factory); @Override void commit(boolean optimize); @Override String getRawQuery(FulltextSearch search, DocumentFactory factory); @Override String getRawQuery(FulltextSearch search, Class<T> c); @Override SuggestionResult execute(ExecutableSuggestionSearch search, Class<T> c); @Override SuggestionResult execute(ExecutableSuggestionSearch search, DocumentFactory factory); @Override SuggestionResult execute(ExecutableSuggestionSearch search, DocumentFactory assets, DocumentFactory childFactory); @Override String getRawQuery(ExecutableSuggestionSearch search, DocumentFactory factory); @Override String getRawQuery(ExecutableSuggestionSearch search, DocumentFactory factory, DocumentFactory childFactory); @Override String getRawQuery(ExecutableSuggestionSearch search, Class<T> c); @Override BeanGetResult<T> execute(RealTimeGet search, Class<T> c); @Override GetResult execute(RealTimeGet search, DocumentFactory assets); @Override InverseSearchResult execute(InverseSearch inverseSearch, DocumentFactory documentFactory); @Override IndexResult addInverseSearchQuery(InverseSearchQuery query); @Override void clearIndex(); @Override void close(); @Override Class<? extends ServiceProvider> getServiceProviderClass(); } | @Test public void deleteTest(){ server.clearIndex(); final DocumentFactoryBuilder docFactoryBuilder = new DocumentFactoryBuilder("TestDoc"); final SingleValueFieldDescriptor.TextFieldDescriptor<String> descriptor = new FieldDescriptorBuilder() .setFacet(true) .setFullText(true) .buildTextField("title"); docFactoryBuilder.addField(descriptor); final DocumentFactory documents = docFactoryBuilder.build(); final Document doc1 = documents.createDoc("AA-2X3451") .setValue(descriptor, "The last ascent of man"); final Document doc2 = documents.createDoc("AA-2X6891") .setValue(descriptor, "Dawn of humanity: the COVID-19 chronicles"); server.index(doc1,doc2); DeleteResult result = server.execute(new Delete(descriptor.equals("The last ascent of man")), documents); assertNotNull(result); SearchResult searchResult = server.execute(Search.fulltext(), documents); assertNotNull(searchResult); assertEquals(1, searchResult.getNumOfResults()); result = server.delete(doc2); assertNotNull(result); searchResult = server.execute(Search.fulltext(), documents); assertNotNull(searchResult); assertEquals(0, searchResult.getNumOfResults()); } |
CollectionManagementService { protected boolean configurationIsDeployed(String configName) throws IOException { logger.debug("Checking if config '{}' is present", configName); ConfigSetAdminRequest.List list = new ConfigSetAdminRequest.List(); try (CloudSolrClient client = createCloudSolrClient()) { final ConfigSetAdminResponse.List configList = list.process(client); final List<String> configSets = configList.getConfigSets(); return configSets.contains(configName); } catch (SolrServerException | IOException e) { throw new IOException("Cannot list config sets", e); } } CollectionManagementService(List<String> zkHosts); CollectionManagementService(List<String> zkHost, String ... repositories); protected CollectionManagementService(String ... repositories); void createCollection(String collectionName, String configName, int numOfShards, int numOfReplicas); void createCollection(String collectionName, String configName, int numOfShards, int numOfReplicas, Boolean autoAddReplicas); boolean collectionExists(String collectionName); void updateCollection(String collectionName, String configName); void updateCollection(String collectionName, String configName, Integer numOfShards, Integer numOfReplicas, Boolean autoAddReplicas); Long getVersionAndInstallIfNecessary(String dependency); } | @Test public void configurationIsDeployedTest() throws IOException { assertTrue(service.configurationIsDeployed("com.rbmhtechnology.solr.test:test-config:1.0")); assertFalse(service.configurationIsDeployed("com.rbmhtechnology.solr.test:wrong-config:1.0")); } |
MacroContext implements MacroValueProvider { public MacroContext(final String names_and_values) throws Exception { pushMacros(names_and_values); } MacroContext(final String names_and_values); void pushMacros(final String names_and_values); void popMacros(); @Override String getValue(final String name); String resolveMacros(final String text); @Override String toString(); } | @Test public void testMacroContext() throws Exception { final MacroContext context = new MacroContext("A=a1, B=b1"); assertThat(context.getValue("A"), equalTo("a1")); assertThat(context.getValue("B"), equalTo("b1")); context.pushMacros("A=a2"); assertThat(context.getValue("A"), equalTo("a2")); assertThat(context.getValue("B"), equalTo("b1")); context.pushMacros("B=b2"); assertThat(context.getValue("A"), equalTo("a2")); assertThat(context.getValue("B"), equalTo("b2")); context.popMacros(); assertThat(context.getValue("A"), equalTo("a2")); assertThat(context.getValue("B"), equalTo("b1")); context.popMacros(); assertThat(context.getValue("A"), equalTo("a1")); assertThat(context.getValue("B"), equalTo("b1")); } |
ConfigPv implements Comparable<ConfigPv> { @Override public String toString() { return new StringBuffer() .append("PV name=").append(pvName) .append(", readback PV name=").append(readbackPvName) .append(", readOnly=").append(readOnly) .toString(); } @Override boolean equals(Object other); @Override int hashCode(); @Override String toString(); @Override int compareTo(ConfigPv other); } | @Test public void testToString() { assertNotNull(ConfigPv.builder().build().toString()); assertNotNull(ConfigPv.builder().readbackPvName("a").build().toString()); assertNotNull(ConfigPv.builder().readbackPvName("").build().toString()); } |
ConfigPv implements Comparable<ConfigPv> { @Override public int compareTo(ConfigPv other) { return pvName.compareTo(other.getPvName()); } @Override boolean equals(Object other); @Override int hashCode(); @Override String toString(); @Override int compareTo(ConfigPv other); } | @Test public void testCompareTo(){ ConfigPv configPV1 = ConfigPv.builder().pvName("a").readbackPvName("b").readOnly(true).build(); ConfigPv configPV2 = ConfigPv.builder().pvName("a").readbackPvName("b").readOnly(true).build(); ConfigPv configPV3 = ConfigPv.builder().pvName("b").readbackPvName("b").readOnly(true).build(); assertTrue(configPV1.compareTo(configPV2) == 0); assertTrue(configPV1.compareTo(configPV3) < 0); assertTrue(configPV3.compareTo(configPV1) > 0); } |
SnapshotItem { @Override public String toString() { return new StringBuffer() .append("value=") .append(value != null ? value.toString() : "READ FAILED") .append(", config pv=").append(configPv.toString()) .append(readbackValue != null ? (", readback pv=" + readbackValue.toString()) : (", readback pv=READ_FAILED")) .toString(); } @Override String toString(); } | @Test public void testToString() { SnapshotItem item = SnapshotItem.builder() .configPv(ConfigPv.builder().pvName("pvname").build()) .build(); assertNotNull(item.toString()); item.setValue(VType.toVType(1)); assertNotNull(item.toString()); item.setReadbackValue(VType.toVType(1.1)); assertNotNull(item.toString()); assertFalse(item.toString().contains("READ FAILED")); } |
SafeMultiply { public static Number multiply(Number a, Number b) throws UnsupportedOperationException { if (a instanceof Double && b instanceof Double) { return multiply((Double) a, (Double) b); } else if (a instanceof Float && b instanceof Float) { return multiply((Float) a, (Float) b); } else if (a instanceof ULong && b instanceof ULong) { return multiply((ULong) a, (ULong) b); } else if (a instanceof Long && b instanceof Long) { return multiply((Long) a, (Long) b); } else if (a instanceof UInteger && b instanceof UInteger) { return multiply((UInteger) a, (UInteger) b); } else if (a instanceof Integer && b instanceof Integer) { return multiply((Integer) a, (Integer) b); } else if (a instanceof UShort && b instanceof UShort) { return multiply((UShort) a, (UShort) b); } else if (a instanceof Short && b instanceof Short) { return multiply((Short) a, (Short) b); } else if (a instanceof UByte && b instanceof UByte) { return multiply((UByte) a, (UByte) b); } else if (a instanceof Byte && b instanceof Byte) { return multiply((Byte) a, (Byte) b); } if (!a.getClass().equals(b.getClass())) { throw new UnsupportedOperationException("Multiplication between different types is allowed only when second argument is Double!"); } else { throw new UnsupportedOperationException("Provided Number extension " + a.getClass() + " is unsupported!"); } } static Number multiply(Number a, Number b); static Number multiply(Number a, Double b); static VNumber multiply(VNumber number, VNumber multiplier); static VNumber multiply(VNumber number, VDouble multiplier); static VNumber multiply(VNumber number, Double multiplier); static VNumberArray multiply(VNumberArray numberArray, Double multiplier); } | @Test public void TestMultiplyDouble() { assertEquals(0d, SafeMultiply.multiply(3d, 0d)); assertEquals(18d, SafeMultiply.multiply(3d, 6d)); assertEquals(-18d, SafeMultiply.multiply(-3d, 6d)); assertEquals(18d, SafeMultiply.multiply(-3d, -6d)); assertEquals(Double.MAX_VALUE, SafeMultiply.multiply(Double.MAX_VALUE, 6d)); assertEquals(-Double.MAX_VALUE, SafeMultiply.multiply(-Double.MAX_VALUE, 6d)); }
@Test public void TestMultiplyFloat() { assertEquals(0f, SafeMultiply.multiply(3f, 0f)); assertEquals(18f, SafeMultiply.multiply(3f, 6f)); assertEquals(-18f, SafeMultiply.multiply(-3f, 6f)); assertEquals(18f, SafeMultiply.multiply(-3f, -6f)); assertEquals(Float.MAX_VALUE, SafeMultiply.multiply(Float.MAX_VALUE, 6f)); assertEquals(-Float.MAX_VALUE, SafeMultiply.multiply(-Float.MAX_VALUE, 6f)); }
@Test public void TestMultiplyULong() { final BigInteger ULONG_MAX = BigInteger.valueOf(9223372036854775807L).multiply(BigInteger.valueOf(2)).add(BigInteger.valueOf(1)); assertEquals(ULong.valueOf(0), SafeMultiply.multiply(ULong.valueOf(3), ULong.valueOf(0))); assertEquals(ULong.valueOf(18), SafeMultiply.multiply(ULong.valueOf(3), ULong.valueOf(6))); assertEquals(ULong.valueOf(ULONG_MAX.longValue()), SafeMultiply.multiply(ULong.valueOf(Long.MAX_VALUE), ULong.valueOf(6))); }
@Test public void TestMultiplyLong() { assertEquals(0L, SafeMultiply.multiply(3L, 0L)); assertEquals(18L, SafeMultiply.multiply(3L, 6L)); assertEquals(-18L, SafeMultiply.multiply(-3L, 6L)); assertEquals(18L, SafeMultiply.multiply(-3L, -6L)); assertEquals(Long.MAX_VALUE, SafeMultiply.multiply(Long.MAX_VALUE, 6L)); assertEquals(Long.MIN_VALUE, SafeMultiply.multiply(Long.MIN_VALUE, 6L)); }
@Test public void TestMultiplyUInteger() { final long UINT_MAX = 4294967295L; assertEquals(UInteger.valueOf(0), SafeMultiply.multiply(UInteger.valueOf(3), UInteger.valueOf(0))); assertEquals(UInteger.valueOf(18), SafeMultiply.multiply(UInteger.valueOf(3), UInteger.valueOf(6))); assertEquals(UInteger.valueOf((int) UINT_MAX), SafeMultiply.multiply(UInteger.valueOf(Integer.MAX_VALUE), UInteger.valueOf(6))); }
@Test public void TestMultiplyInteger() { assertEquals(0, SafeMultiply.multiply(3, 0)); assertEquals(18, SafeMultiply.multiply(3, 6)); assertEquals(-18, SafeMultiply.multiply(-3, 6)); assertEquals(18, SafeMultiply.multiply(-3, -6)); assertEquals(Integer.MAX_VALUE, SafeMultiply.multiply(Integer.MAX_VALUE, 6)); assertEquals(Integer.MIN_VALUE, SafeMultiply.multiply(Integer.MIN_VALUE, 6)); }
@Test public void TestMultiplyUShort() { final int USHORT_MAX = 65535; assertEquals(UShort.valueOf(Short.parseShort("0")), SafeMultiply.multiply(UShort.valueOf(Short.parseShort("3")), UShort.valueOf(Short.parseShort("0")))); assertEquals(UShort.valueOf(Short.parseShort("18")), SafeMultiply.multiply(UShort.valueOf(Short.parseShort("3")), UShort.valueOf(Short.parseShort("6")))); assertEquals(UShort.valueOf((short) USHORT_MAX), SafeMultiply.multiply(UShort.valueOf(Short.MAX_VALUE), UShort.valueOf(Short.parseShort("6")))); }
@Test public void TestMultiplyShort() { assertEquals(Short.valueOf("0"), SafeMultiply.multiply(Short.valueOf("3"), Short.valueOf("0"))); assertEquals(Short.valueOf("18"), SafeMultiply.multiply(Short.valueOf("3"), Short.valueOf("6"))); assertEquals(Short.valueOf("-18"), SafeMultiply.multiply(Short.valueOf("-3"), Short.valueOf("6"))); assertEquals(Short.valueOf("18"), SafeMultiply.multiply(Short.valueOf("-3"), Short.valueOf("-6"))); assertEquals(Short.MAX_VALUE, SafeMultiply.multiply(Short.MAX_VALUE, Short.valueOf("6"))); assertEquals(Short.MIN_VALUE, SafeMultiply.multiply(Short.MIN_VALUE, Short.valueOf("6"))); }
@Test public void TestMultiplyUByte() { final int UBYTE_MAX = 255; assertEquals(UByte.valueOf(Byte.parseByte("0")), SafeMultiply.multiply(UByte.valueOf(Byte.parseByte("3")), UByte.valueOf(Byte.parseByte("0")))); assertEquals(UByte.valueOf(Byte.parseByte("18")), SafeMultiply.multiply(UByte.valueOf(Byte.parseByte("3")), UByte.valueOf(Byte.parseByte("6")))); assertEquals(UByte.valueOf((byte) UBYTE_MAX), SafeMultiply.multiply(UByte.valueOf(Byte.MAX_VALUE), UByte.valueOf(Byte.parseByte("6")))); }
@Test public void TestMultiplyByte() { assertEquals(Byte.valueOf("0"), SafeMultiply.multiply(Byte.valueOf("3"), Byte.valueOf("0"))); assertEquals(Byte.valueOf("18"), SafeMultiply.multiply(Byte.valueOf("3"), Byte.valueOf("6"))); assertEquals(Byte.valueOf("-18"), SafeMultiply.multiply(Byte.valueOf("-3"), Byte.valueOf("6"))); assertEquals(Byte.valueOf("18"), SafeMultiply.multiply(Byte.valueOf("-3"), Byte.valueOf("-6"))); assertEquals(Byte.MAX_VALUE, SafeMultiply.multiply(Byte.MAX_VALUE, Byte.valueOf("6"))); assertEquals(Byte.MIN_VALUE, SafeMultiply.multiply(Byte.MIN_VALUE, Byte.valueOf("6"))); }
@Test public void TestMultiplyWithDouble() { assertEquals(18d, SafeMultiply.multiply(6d, 3d)); assertEquals(-18d, SafeMultiply.multiply(6d, -3d)); assertEquals(-18d, SafeMultiply.multiply(-6d, 3d)); assertEquals(18f, SafeMultiply.multiply(6f, 3d)); assertEquals(-18f, SafeMultiply.multiply(6f, -3d)); assertEquals(-18f, SafeMultiply.multiply(-6f, 3d)); assertEquals(ULong.valueOf(0), SafeMultiply.multiply(ULong.valueOf(0), 3d)); assertEquals(ULong.valueOf(18), SafeMultiply.multiply(ULong.valueOf(6), 3d)); assertEquals(18L, SafeMultiply.multiply(6L, 3d)); assertEquals(-18L, SafeMultiply.multiply(6L, -3d)); assertEquals(-18L, SafeMultiply.multiply(-6L, 3d)); assertEquals(UInteger.valueOf(0), SafeMultiply.multiply(UInteger.valueOf(0), 3d)); assertEquals(UInteger.valueOf(18), SafeMultiply.multiply(UInteger.valueOf(6), 3d)); assertEquals(18, SafeMultiply.multiply(6, 3d)); assertEquals(-18, SafeMultiply.multiply(6, -3d)); assertEquals(-18, SafeMultiply.multiply(-6, 3d)); assertEquals(UShort.valueOf(Short.parseShort("0")), SafeMultiply.multiply(UShort.valueOf(Short.parseShort("0")), 3d)); assertEquals(UShort.valueOf(Short.parseShort("18")), SafeMultiply.multiply(UShort.valueOf(Short.parseShort("6")), 3d)); assertEquals(Short.parseShort("18"), SafeMultiply.multiply(Short.parseShort("6"), 3d)); assertEquals(Short.parseShort("-18"), SafeMultiply.multiply(Short.parseShort("6"), -3d)); assertEquals(Short.parseShort("-18"), SafeMultiply.multiply(Short.parseShort("-6"), 3d)); assertEquals(UByte.valueOf(Byte.parseByte("0")), SafeMultiply.multiply(UByte.valueOf(Byte.parseByte("0")), 3d)); assertEquals(UByte.valueOf(Byte.parseByte("18")), SafeMultiply.multiply(UByte.valueOf(Byte.parseByte("6")), 3d)); assertEquals(Byte.parseByte("18"), SafeMultiply.multiply(Byte.parseByte("6"), 3d)); assertEquals(Byte.parseByte("-18"), SafeMultiply.multiply(Byte.parseByte("6"), -3d)); assertEquals(Byte.parseByte("-18"), SafeMultiply.multiply(Byte.parseByte("-6"), 3d)); }
@Test public void TestMultiplyVDouble() { VDouble goodResult_1 = VDouble.of(Double.valueOf(0), alarm_1, time_1, display_1); VDouble goodResult_2 = VDouble.of(Double.valueOf(18), alarm_1, time_1, display_1); VDouble goodResult_3 = VDouble.of(Double.valueOf(-18), alarm_1, time_1, display_1); VDouble number_1 = VDouble.of(Double.valueOf(3), alarm_1, time_1, display_1); VDouble number_2 = VDouble.of(Double.valueOf(-3), alarm_1, time_1, display_1); VDouble multiplier_1 = VDouble.of(Double.valueOf(0), alarm_2, time_2, display_2); VDouble multiplier_2 = VDouble.of(Double.valueOf(6), alarm_2, time_2, display_2); VDouble multiplier_3 = VDouble.of(Double.valueOf(-6), alarm_2, time_2, display_2); VDouble posMax = VDouble.of(Double.MAX_VALUE, alarm_1, time_1, display_1); VDouble negMax = VDouble.of(-Double.MAX_VALUE, alarm_1, time_1, display_1); VNumber result = SafeMultiply.multiply(number_1, multiplier_1); assertTrue(Utilities.areVTypesIdentical(goodResult_1, result, true)); result = SafeMultiply.multiply(multiplier_1, number_1); assertFalse(Utilities.areVTypesIdentical(goodResult_1, result, true)); assertTrue(Utilities.areVTypesIdentical(goodResult_1, result, false)); result = SafeMultiply.multiply(number_1, multiplier_2); assertTrue(Utilities.areVTypesIdentical(goodResult_2, result, true)); result = SafeMultiply.multiply(multiplier_2, number_1); assertFalse(Utilities.areVTypesIdentical(goodResult_2, result, true)); assertTrue(Utilities.areVTypesIdentical(goodResult_2, result, false)); result = SafeMultiply.multiply(number_2, multiplier_3); assertTrue(Utilities.areVTypesIdentical(goodResult_2, result, true)); result = SafeMultiply.multiply(multiplier_3, number_2); assertFalse(Utilities.areVTypesIdentical(goodResult_2, result, true)); assertTrue(Utilities.areVTypesIdentical(goodResult_2, result, false)); result = SafeMultiply.multiply(number_2, multiplier_2); assertTrue(Utilities.areVTypesIdentical(goodResult_3, result, true)); result = SafeMultiply.multiply(multiplier_2, number_2); assertFalse(Utilities.areVTypesIdentical(goodResult_3, result, true)); assertTrue(Utilities.areVTypesIdentical(goodResult_3, result, false)); result = SafeMultiply.multiply(posMax, multiplier_2); assertTrue(Utilities.areVTypesIdentical(posMax, result, true)); result = SafeMultiply.multiply(multiplier_2, posMax); assertFalse(Utilities.areVTypesIdentical(posMax, result, true)); assertTrue(Utilities.areVTypesIdentical(posMax, result, false)); result = SafeMultiply.multiply(negMax, multiplier_2); assertTrue(Utilities.areVTypesIdentical(negMax, result, true)); result = SafeMultiply.multiply(multiplier_2, negMax); assertFalse(Utilities.areVTypesIdentical(negMax, result, true)); assertTrue(Utilities.areVTypesIdentical(negMax, result, false)); }
@Test public void TestMultiplyVFloat() { VFloat goodResult_1 = VFloat.of(Float.valueOf(0), alarm_1, time_1, display_1); VFloat goodResult_2 = VFloat.of(Float.valueOf(18), alarm_1, time_1, display_1); VFloat goodResult_3 = VFloat.of(Float.valueOf(-18), alarm_1, time_1, display_1); VFloat number_1 = VFloat.of(Float.valueOf(3), alarm_1, time_1, display_1); VFloat number_2 = VFloat.of(Float.valueOf(-3), alarm_1, time_1, display_1); VFloat multiplier_1 = VFloat.of(Float.valueOf(0), alarm_2, time_2, display_2); VFloat multiplier_2 = VFloat.of(Float.valueOf(6), alarm_2, time_2, display_2); VFloat multiplier_3 = VFloat.of(Float.valueOf(-6), alarm_2, time_2, display_2); VFloat posMax = VFloat.of(Float.MAX_VALUE, alarm_1, time_1, display_1); VFloat negMax = VFloat.of(-Float.MAX_VALUE, alarm_1, time_1, display_1); VNumber result = SafeMultiply.multiply(number_1, multiplier_1); assertTrue(Utilities.areVTypesIdentical(goodResult_1, result, true)); result = SafeMultiply.multiply(multiplier_1, number_1); assertFalse(Utilities.areVTypesIdentical(goodResult_1, result, true)); assertTrue(Utilities.areVTypesIdentical(goodResult_1, result, false)); result = SafeMultiply.multiply(number_1, multiplier_2); assertTrue(Utilities.areVTypesIdentical(goodResult_2, result, true)); result = SafeMultiply.multiply(multiplier_2, number_1); assertFalse(Utilities.areVTypesIdentical(goodResult_2, result, true)); assertTrue(Utilities.areVTypesIdentical(goodResult_2, result, false)); result = SafeMultiply.multiply(number_2, multiplier_3); assertTrue(Utilities.areVTypesIdentical(goodResult_2, result, true)); result = SafeMultiply.multiply(multiplier_3, number_2); assertFalse(Utilities.areVTypesIdentical(goodResult_2, result, true)); assertTrue(Utilities.areVTypesIdentical(goodResult_2, result, false)); result = SafeMultiply.multiply(number_2, multiplier_2); assertTrue(Utilities.areVTypesIdentical(goodResult_3, result, true)); result = SafeMultiply.multiply(multiplier_2, number_2); assertFalse(Utilities.areVTypesIdentical(goodResult_3, result, true)); assertTrue(Utilities.areVTypesIdentical(goodResult_3, result, false)); result = SafeMultiply.multiply(posMax, multiplier_2); assertTrue(Utilities.areVTypesIdentical(posMax, result, true)); result = SafeMultiply.multiply(multiplier_2, posMax); assertFalse(Utilities.areVTypesIdentical(posMax, result, true)); assertTrue(Utilities.areVTypesIdentical(posMax, result, false)); result = SafeMultiply.multiply(negMax, multiplier_2); assertTrue(Utilities.areVTypesIdentical(negMax, result, true)); result = SafeMultiply.multiply(multiplier_2, negMax); assertFalse(Utilities.areVTypesIdentical(negMax, result, true)); assertTrue(Utilities.areVTypesIdentical(negMax, result, false)); }
@Test public void TestMultiplyVULong() { final BigInteger ULONG_MAX = BigInteger.valueOf(9223372036854775807L).multiply(BigInteger.valueOf(2)).add(BigInteger.valueOf(1)); VULong goodResult_1 = VULong.of(ULong.valueOf(0), alarm_1, time_1, display_1); VULong goodResult_2 = VULong.of(ULong.valueOf(18), alarm_1, time_1, display_1); VULong number = VULong.of(ULong.valueOf(3), alarm_1, time_1, display_1); VULong multiplier_1 = VULong.of(ULong.valueOf(0), alarm_2, time_2, display_2); VULong multiplier_2 = VULong.of(ULong.valueOf(6), alarm_2, time_2, display_2); VULong maxValue = VULong.of(ULONG_MAX, alarm_1, time_1, display_1); VNumber result = SafeMultiply.multiply(number, multiplier_1); assertTrue(Utilities.areVTypesIdentical(goodResult_1, result, true)); result = SafeMultiply.multiply(multiplier_1, number); assertFalse(Utilities.areVTypesIdentical(goodResult_1, result, true)); assertTrue(Utilities.areVTypesIdentical(goodResult_1, result, false)); result = SafeMultiply.multiply(number, multiplier_2); assertTrue(Utilities.areVTypesIdentical(goodResult_2, result, true)); result = SafeMultiply.multiply(multiplier_2, number); assertFalse(Utilities.areVTypesIdentical(goodResult_2, result, true)); assertTrue(Utilities.areVTypesIdentical(goodResult_2, result, false)); result = SafeMultiply.multiply(maxValue, multiplier_2); assertTrue(Utilities.areVTypesIdentical(maxValue, result, true)); result = SafeMultiply.multiply(multiplier_2, maxValue); assertFalse(Utilities.areVTypesIdentical(maxValue, result, true)); assertTrue(Utilities.areVTypesIdentical(maxValue, result, false)); }
@Test public void TestMultiplyVLong() { VLong goodResult_1 = VLong.of(Long.valueOf(0), alarm_1, time_1, display_1); VLong goodResult_2 = VLong.of(Long.valueOf(18), alarm_1, time_1, display_1); VLong goodResult_3 = VLong.of(Long.valueOf(-18), alarm_1, time_1, display_1); VLong number_1 = VLong.of(Long.valueOf(3), alarm_1, time_1, display_1); VLong number_2 = VLong.of(Long.valueOf(-3), alarm_1, time_1, display_1); VLong multiplier_1 = VLong.of(Long.valueOf(0), alarm_2, time_2, display_2); VLong multiplier_2 = VLong.of(Long.valueOf(6), alarm_2, time_2, display_2); VLong multiplier_3 = VLong.of(Long.valueOf(-6), alarm_2, time_2, display_2); VLong posMax = VLong.of(Long.MAX_VALUE, alarm_1, time_1, display_1); VLong negMax = VLong.of(Long.MIN_VALUE, alarm_1, time_1, display_1); VNumber result = SafeMultiply.multiply(number_1, multiplier_1); assertTrue(Utilities.areVTypesIdentical(goodResult_1, result, true)); result = SafeMultiply.multiply(multiplier_1, number_1); assertFalse(Utilities.areVTypesIdentical(goodResult_1, result, true)); assertTrue(Utilities.areVTypesIdentical(goodResult_1, result, false)); result = SafeMultiply.multiply(number_1, multiplier_2); assertTrue(Utilities.areVTypesIdentical(goodResult_2, result, true)); result = SafeMultiply.multiply(multiplier_2, number_1); assertFalse(Utilities.areVTypesIdentical(goodResult_2, result, true)); assertTrue(Utilities.areVTypesIdentical(goodResult_2, result, false)); result = SafeMultiply.multiply(number_2, multiplier_3); assertTrue(Utilities.areVTypesIdentical(goodResult_2, result, true)); result = SafeMultiply.multiply(multiplier_3, number_2); assertFalse(Utilities.areVTypesIdentical(goodResult_2, result, true)); assertTrue(Utilities.areVTypesIdentical(goodResult_2, result, false)); result = SafeMultiply.multiply(number_2, multiplier_2); assertTrue(Utilities.areVTypesIdentical(goodResult_3, result, true)); result = SafeMultiply.multiply(multiplier_2, number_2); assertFalse(Utilities.areVTypesIdentical(goodResult_3, result, true)); assertTrue(Utilities.areVTypesIdentical(goodResult_3, result, false)); result = SafeMultiply.multiply(posMax, multiplier_2); assertTrue(Utilities.areVTypesIdentical(posMax, result, true)); result = SafeMultiply.multiply(multiplier_2, posMax); assertFalse(Utilities.areVTypesIdentical(posMax, result, true)); assertTrue(Utilities.areVTypesIdentical(posMax, result, false)); result = SafeMultiply.multiply(negMax, multiplier_2); assertTrue(Utilities.areVTypesIdentical(negMax, result, true)); result = SafeMultiply.multiply(multiplier_2, negMax); assertFalse(Utilities.areVTypesIdentical(negMax, result, true)); assertTrue(Utilities.areVTypesIdentical(negMax, result, false)); }
@Test public void TestMultiplyVUInt() { final long UINT_MAX = 4294967295L; VUInt goodResult_1 = VUInt.of(UInteger.valueOf(0), alarm_1, time_1, display_1); VUInt goodResult_2 = VUInt.of(UInteger.valueOf(18), alarm_1, time_1, display_1); VUInt number = VUInt.of(UInteger.valueOf(3), alarm_1, time_1, display_1); VUInt multiplier_1 = VUInt.of(UInteger.valueOf(0), alarm_2, time_2, display_2); VUInt multiplier_2 = VUInt.of(UInteger.valueOf(6), alarm_2, time_2, display_2); VUInt maxValue = VUInt.of(UINT_MAX, alarm_1, time_1, display_1); VNumber result = SafeMultiply.multiply(number, multiplier_1); assertTrue(Utilities.areVTypesIdentical(goodResult_1, result, true)); result = SafeMultiply.multiply(multiplier_1, number); assertFalse(Utilities.areVTypesIdentical(goodResult_1, result, true)); assertTrue(Utilities.areVTypesIdentical(goodResult_1, result, false)); result = SafeMultiply.multiply(number, multiplier_2); assertTrue(Utilities.areVTypesIdentical(goodResult_2, result, true)); result = SafeMultiply.multiply(multiplier_2, number); assertFalse(Utilities.areVTypesIdentical(goodResult_2, result, true)); assertTrue(Utilities.areVTypesIdentical(goodResult_2, result, false)); result = SafeMultiply.multiply(maxValue, multiplier_2); assertTrue(Utilities.areVTypesIdentical(maxValue, result, true)); result = SafeMultiply.multiply(multiplier_2, maxValue); assertFalse(Utilities.areVTypesIdentical(maxValue, result, true)); assertTrue(Utilities.areVTypesIdentical(maxValue, result, false)); }
@Test public void TestMultiplyVInt() { VInt goodResult_1 = VInt.of(0, alarm_1, time_1, display_1); VInt goodResult_2 = VInt.of(18, alarm_1, time_1, display_1); VInt goodResult_3 = VInt.of(-18, alarm_1, time_1, display_1); VInt number_1 = VInt.of(3, alarm_1, time_1, display_1); VInt number_2 = VInt.of(-3, alarm_1, time_1, display_1); VInt multiplier_1 = VInt.of(0, alarm_2, time_2, display_2); VInt multiplier_2 = VInt.of(6, alarm_2, time_2, display_2); VInt multiplier_3 = VInt.of(-6, alarm_2, time_2, display_2); VInt posMax = VInt.of(Integer.MAX_VALUE, alarm_1, time_1, display_1); VInt negMax = VInt.of(Integer.MIN_VALUE, alarm_1, time_1, display_1); VNumber result = SafeMultiply.multiply(number_1, multiplier_1); assertTrue(Utilities.areVTypesIdentical(goodResult_1, result, true)); result = SafeMultiply.multiply(multiplier_1, number_1); assertFalse(Utilities.areVTypesIdentical(goodResult_1, result, true)); assertTrue(Utilities.areVTypesIdentical(goodResult_1, result, false)); result = SafeMultiply.multiply(number_1, multiplier_2); assertTrue(Utilities.areVTypesIdentical(goodResult_2, result, true)); result = SafeMultiply.multiply(multiplier_2, number_1); assertFalse(Utilities.areVTypesIdentical(goodResult_2, result, true)); assertTrue(Utilities.areVTypesIdentical(goodResult_2, result, false)); result = SafeMultiply.multiply(number_2, multiplier_3); assertTrue(Utilities.areVTypesIdentical(goodResult_2, result, true)); result = SafeMultiply.multiply(multiplier_3, number_2); assertFalse(Utilities.areVTypesIdentical(goodResult_2, result, true)); assertTrue(Utilities.areVTypesIdentical(goodResult_2, result, false)); result = SafeMultiply.multiply(number_2, multiplier_2); assertTrue(Utilities.areVTypesIdentical(goodResult_3, result, true)); result = SafeMultiply.multiply(multiplier_2, number_2); assertFalse(Utilities.areVTypesIdentical(goodResult_3, result, true)); assertTrue(Utilities.areVTypesIdentical(goodResult_3, result, false)); result = SafeMultiply.multiply(posMax, multiplier_2); assertTrue(Utilities.areVTypesIdentical(posMax, result, true)); result = SafeMultiply.multiply(multiplier_2, posMax); assertFalse(Utilities.areVTypesIdentical(posMax, result, true)); assertTrue(Utilities.areVTypesIdentical(posMax, result, false)); result = SafeMultiply.multiply(negMax, multiplier_2); assertTrue(Utilities.areVTypesIdentical(negMax, result, true)); result = SafeMultiply.multiply(multiplier_2, negMax); assertFalse(Utilities.areVTypesIdentical(negMax, result, true)); assertTrue(Utilities.areVTypesIdentical(negMax, result, false)); }
@Test public void TestMultiplyVUShort() { final int USHORT_MAX = 65535; VUShort goodResult_1 = VUShort.of(UShort.valueOf(Short.parseShort("0")), alarm_1, time_1, display_1); VUShort goodResult_2 = VUShort.of(UShort.valueOf(Short.parseShort("18")), alarm_1, time_1, display_1); VUShort number = VUShort.of(UShort.valueOf(Short.parseShort("3")), alarm_1, time_1, display_1); VUShort multiplier_1 = VUShort.of(UShort.valueOf(Short.parseShort("0")), alarm_2, time_2, display_2); VUShort multiplier_2 = VUShort.of(UShort.valueOf(Short.parseShort("6")), alarm_2, time_2, display_2); VUShort maxValue = VUShort.of(USHORT_MAX, alarm_1, time_1, display_1); VNumber result = SafeMultiply.multiply(number, multiplier_1); assertTrue(Utilities.areVTypesIdentical(goodResult_1, result, true)); result = SafeMultiply.multiply(multiplier_1, number); assertFalse(Utilities.areVTypesIdentical(goodResult_1, result, true)); assertTrue(Utilities.areVTypesIdentical(goodResult_1, result, false)); result = SafeMultiply.multiply(number, multiplier_2); assertTrue(Utilities.areVTypesIdentical(goodResult_2, result, true)); result = SafeMultiply.multiply(multiplier_2, number); assertFalse(Utilities.areVTypesIdentical(goodResult_2, result, true)); assertTrue(Utilities.areVTypesIdentical(goodResult_2, result, false)); result = SafeMultiply.multiply(maxValue, multiplier_2); assertTrue(Utilities.areVTypesIdentical(maxValue, result, true)); result = SafeMultiply.multiply(multiplier_2, maxValue); assertFalse(Utilities.areVTypesIdentical(maxValue, result, true)); assertTrue(Utilities.areVTypesIdentical(maxValue, result, false)); }
@Test public void TestMultiplyVShort() { VShort goodResult_1 = VShort.of(Short.valueOf("0"), alarm_1, time_1, display_1); VShort goodResult_2 = VShort.of(Short.valueOf("18"), alarm_1, time_1, display_1); VShort goodResult_3 = VShort.of(Short.valueOf("-18"), alarm_1, time_1, display_1); VShort number_1 = VShort.of(Short.valueOf("3"), alarm_1, time_1, display_1); VShort number_2 = VShort.of(Short.valueOf("-3"), alarm_1, time_1, display_1); VShort multiplier_1 = VShort.of(Short.valueOf("0"), alarm_2, time_2, display_2); VShort multiplier_2 = VShort.of(Short.valueOf("6"), alarm_2, time_2, display_2); VShort multiplier_3 = VShort.of(Short.valueOf("-6"), alarm_2, time_2, display_2); VShort posMax = VShort.of(Short.MAX_VALUE, alarm_1, time_1, display_1); VShort negMax = VShort.of(Short.MIN_VALUE, alarm_1, time_1, display_1); VNumber result = SafeMultiply.multiply(number_1, multiplier_1); assertTrue(Utilities.areVTypesIdentical(goodResult_1, result, true)); result = SafeMultiply.multiply(multiplier_1, number_1); assertFalse(Utilities.areVTypesIdentical(goodResult_1, result, true)); assertTrue(Utilities.areVTypesIdentical(goodResult_1, result, false)); result = SafeMultiply.multiply(number_1, multiplier_2); assertTrue(Utilities.areVTypesIdentical(goodResult_2, result, true)); result = SafeMultiply.multiply(multiplier_2, number_1); assertFalse(Utilities.areVTypesIdentical(goodResult_2, result, true)); assertTrue(Utilities.areVTypesIdentical(goodResult_2, result, false)); result = SafeMultiply.multiply(number_2, multiplier_3); assertTrue(Utilities.areVTypesIdentical(goodResult_2, result, true)); result = SafeMultiply.multiply(multiplier_3, number_2); assertFalse(Utilities.areVTypesIdentical(goodResult_2, result, true)); assertTrue(Utilities.areVTypesIdentical(goodResult_2, result, false)); result = SafeMultiply.multiply(number_2, multiplier_2); assertTrue(Utilities.areVTypesIdentical(goodResult_3, result, true)); result = SafeMultiply.multiply(multiplier_2, number_2); assertFalse(Utilities.areVTypesIdentical(goodResult_3, result, true)); assertTrue(Utilities.areVTypesIdentical(goodResult_3, result, false)); result = SafeMultiply.multiply(posMax, multiplier_2); assertTrue(Utilities.areVTypesIdentical(posMax, result, true)); result = SafeMultiply.multiply(multiplier_2, posMax); assertFalse(Utilities.areVTypesIdentical(posMax, result, true)); assertTrue(Utilities.areVTypesIdentical(posMax, result, false)); result = SafeMultiply.multiply(negMax, multiplier_2); assertTrue(Utilities.areVTypesIdentical(negMax, result, true)); result = SafeMultiply.multiply(multiplier_2, negMax); assertFalse(Utilities.areVTypesIdentical(negMax, result, true)); assertTrue(Utilities.areVTypesIdentical(negMax, result, false)); }
@Test public void TestMultiplyVUByte() { final int UBYTE_MAX = 255; VUByte goodResult_1 = VUByte.of(UByte.valueOf(Byte.parseByte("0")), alarm_1, time_1, display_1); VUByte goodResult_2 = VUByte.of(UByte.valueOf(Byte.parseByte("18")), alarm_1, time_1, display_1); VUByte number = VUByte.of(UByte.valueOf(Byte.parseByte("3")), alarm_1, time_1, display_1); VUByte multiplier_1 = VUByte.of(UByte.valueOf(Byte.parseByte("0")), alarm_2, time_2, display_2); VUByte multiplier_2 = VUByte.of(UByte.valueOf(Byte.parseByte("6")), alarm_2, time_2, display_2); VUByte maxValue = VUByte.of(UBYTE_MAX, alarm_1, time_1, display_1); VNumber result = SafeMultiply.multiply(number, multiplier_1); assertTrue(Utilities.areVTypesIdentical(goodResult_1, result, true)); result = SafeMultiply.multiply(multiplier_1, number); assertFalse(Utilities.areVTypesIdentical(goodResult_1, result, true)); assertTrue(Utilities.areVTypesIdentical(goodResult_1, result, false)); result = SafeMultiply.multiply(number, multiplier_2); assertTrue(Utilities.areVTypesIdentical(goodResult_2, result, true)); result = SafeMultiply.multiply(multiplier_2, number); assertFalse(Utilities.areVTypesIdentical(goodResult_2, result, true)); assertTrue(Utilities.areVTypesIdentical(goodResult_2, result, false)); result = SafeMultiply.multiply(maxValue, multiplier_2); assertTrue(Utilities.areVTypesIdentical(maxValue, result, true)); result = SafeMultiply.multiply(multiplier_2, maxValue); assertFalse(Utilities.areVTypesIdentical(maxValue, result, true)); assertTrue(Utilities.areVTypesIdentical(maxValue, result, false)); }
@Test public void TestMultiplyVByte() { VByte goodResult_1 = VByte.of(Byte.valueOf("0"), alarm_1, time_1, display_1); VByte goodResult_2 = VByte.of(Byte.valueOf("18"), alarm_1, time_1, display_1); VByte goodResult_3 = VByte.of(Byte.valueOf("-18"), alarm_1, time_1, display_1); VByte number_1 = VByte.of(Byte.valueOf("3"), alarm_1, time_1, display_1); VByte number_2 = VByte.of(Byte.valueOf("-3"), alarm_1, time_1, display_1); VByte multiplier_1 = VByte.of(Byte.valueOf("0"), alarm_2, time_2, display_2); VByte multiplier_2 = VByte.of(Byte.valueOf("6"), alarm_2, time_2, display_2); VByte multiplier_3 = VByte.of(Byte.valueOf("-6"), alarm_2, time_2, display_2); VByte posMax = VByte.of(Byte.MAX_VALUE, alarm_1, time_1, display_1); VByte negMax = VByte.of(Byte.MIN_VALUE, alarm_1, time_1, display_1); VNumber result = SafeMultiply.multiply(number_1, multiplier_1); assertTrue(Utilities.areVTypesIdentical(goodResult_1, result, true)); result = SafeMultiply.multiply(multiplier_1, number_1); assertFalse(Utilities.areVTypesIdentical(goodResult_1, result, true)); assertTrue(Utilities.areVTypesIdentical(goodResult_1, result, false)); result = SafeMultiply.multiply(number_1, multiplier_2); assertTrue(Utilities.areVTypesIdentical(goodResult_2, result, true)); result = SafeMultiply.multiply(multiplier_2, number_1); assertFalse(Utilities.areVTypesIdentical(goodResult_2, result, true)); assertTrue(Utilities.areVTypesIdentical(goodResult_2, result, false)); result = SafeMultiply.multiply(number_2, multiplier_3); assertTrue(Utilities.areVTypesIdentical(goodResult_2, result, true)); result = SafeMultiply.multiply(multiplier_3, number_2); assertFalse(Utilities.areVTypesIdentical(goodResult_2, result, true)); assertTrue(Utilities.areVTypesIdentical(goodResult_2, result, false)); result = SafeMultiply.multiply(number_2, multiplier_2); assertTrue(Utilities.areVTypesIdentical(goodResult_3, result, true)); result = SafeMultiply.multiply(multiplier_2, number_2); assertFalse(Utilities.areVTypesIdentical(goodResult_3, result, true)); assertTrue(Utilities.areVTypesIdentical(goodResult_3, result, false)); result = SafeMultiply.multiply(posMax, multiplier_2); assertTrue(Utilities.areVTypesIdentical(posMax, result, true)); result = SafeMultiply.multiply(multiplier_2, posMax); assertFalse(Utilities.areVTypesIdentical(posMax, result, true)); assertTrue(Utilities.areVTypesIdentical(posMax, result, false)); result = SafeMultiply.multiply(negMax, multiplier_2); assertTrue(Utilities.areVTypesIdentical(negMax, result, true)); result = SafeMultiply.multiply(multiplier_2, negMax); assertFalse(Utilities.areVTypesIdentical(negMax, result, true)); assertTrue(Utilities.areVTypesIdentical(negMax, result, false)); }
@Test public void TestVDoubleArray() { final double multiplier = 2d; final List<Double> list = Arrays.asList(0.1d, 2.3d, 4.5d, 6.7d); ListDouble listDouble = new ListDouble() { @Override public double getDouble(int i) { return list.get(i); } @Override public int size() { return list.size(); } }; VDoubleArray doubleArray = VDoubleArray.of(listDouble, alarm_1, time_1, display_1); VNumberArray multipliedDoubleArray = SafeMultiply.multiply(doubleArray, multiplier); for (int index = 0; index < list.size(); index++) { assertTrue(Double.compare((Double) SafeMultiply.multiply(list.get(index), multiplier), multipliedDoubleArray.getData().getDouble(index)) == 0); } System.out.println("multiplier: " + multiplier); System.out.println(" Original: " + doubleArray); System.out.println("Multiplied: " + SafeMultiply.multiply(doubleArray, multiplier)); }
@Test public void TestVFloatArray() { final double multiplier = 2d; final List<Float> list = Arrays.asList(0.1f, 2.3f, 4.5f, 6.7f); ListFloat listFloat = new ListFloat() { @Override public float getFloat(int i) { return list.get(i); } @Override public int size() { return list.size(); } }; VFloatArray floatArray = VFloatArray.of(listFloat, alarm_1, time_1, display_1); VNumberArray multipliedFloatArray = SafeMultiply.multiply(floatArray, multiplier); for (int index = 0; index < list.size(); index++) { assertTrue(Float.compare((Float) SafeMultiply.multiply(list.get(index), multiplier), multipliedFloatArray.getData().getFloat(index)) == 0); } System.out.println("multiplier: " + multiplier); System.out.println(" Original: " + floatArray); System.out.println("Multiplied: " + SafeMultiply.multiply(floatArray, multiplier)); }
@Test public void TestVULongArray() { final double multiplier = 2d; final List<ULong> list = Arrays.asList(ULong.valueOf(0L), ULong.valueOf(1L), ULong.valueOf(2L), ULong.valueOf(3L)); ListULong listULong = new ListULong() { @Override public long getLong(int i) { return list.get(i).longValue(); } @Override public int size() { return list.size(); } }; VULongArray ulongArray = VULongArray.of(listULong, alarm_1, time_1, display_1); VNumberArray multipliedULongArray = SafeMultiply.multiply(ulongArray, multiplier); for (int index = 0; index < list.size(); index++) { assertTrue(Long.compareUnsigned(SafeMultiply.multiply(list.get(index), multiplier).longValue(), multipliedULongArray.getData().getLong(index)) == 0); } System.out.println("multiplier: " + multiplier); System.out.println(" Original: " + ulongArray); System.out.println("Multiplied: " + SafeMultiply.multiply(ulongArray, multiplier)); }
@Test public void TestVLongArray() { final double multiplier = 2d; final List<Long> list = Arrays.asList(0L, 1L, 2L, 3L); ListLong listLong = new ListLong() { @Override public long getLong(int i) { return list.get(i); } @Override public int size() { return list.size(); } }; VLongArray longArray = VLongArray.of(listLong, alarm_1, time_1, display_1); VNumberArray multipliedLongArray = SafeMultiply.multiply(longArray, multiplier); for (int index = 0; index < list.size(); index++) { assertTrue(Long.compareUnsigned(SafeMultiply.multiply(list.get(index), multiplier).longValue(), multipliedLongArray.getData().getLong(index)) == 0); } System.out.println("multiplier: " + multiplier); System.out.println(" Original: " + longArray); System.out.println("Multiplied: " + SafeMultiply.multiply(longArray, multiplier)); }
@Test public void TestVUIntegerArray() { final double multiplier = 2d; final List<UInteger> list = Arrays.asList(UInteger.valueOf(0), UInteger.valueOf(1), UInteger.valueOf(2), UInteger.valueOf(3)); ListUInteger listUInteger = new ListUInteger() { @Override public int getInt(int i) { return list.get(i).intValue(); } @Override public int size() { return list.size(); } }; VUIntArray integerArray = VUIntArray.of(listUInteger, alarm_1, time_1, display_1); VNumberArray multipliedUIntegerArray = SafeMultiply.multiply(integerArray, multiplier); for (int index = 0; index < list.size(); index++) { assertTrue(Integer.compareUnsigned(SafeMultiply.multiply(list.get(index), multiplier).intValue(), multipliedUIntegerArray.getData().getInt(index)) == 0); } System.out.println("multiplier: " + multiplier); System.out.println(" Original: " + integerArray); System.out.println("Multiplied: " + SafeMultiply.multiply(integerArray, multiplier)); }
@Test public void TestVIntegerArray() { final double multiplier = 2d; final List<Integer> list = Arrays.asList(0, 1, 2, 3); ListInteger listInteger = new ListInteger() { @Override public int getInt(int i) { return list.get(i); } @Override public int size() { return list.size(); } }; VIntArray intArray = VIntArray.of(listInteger, alarm_1, time_1, display_1); VNumberArray multipliedIntegerArray = SafeMultiply.multiply(intArray, multiplier); for (int index = 0; index < list.size(); index++) { assertTrue(Integer.compareUnsigned(SafeMultiply.multiply(list.get(index), multiplier).intValue(), multipliedIntegerArray.getData().getInt(index)) == 0); } System.out.println("multiplier: " + multiplier); System.out.println(" Original: " + intArray); System.out.println("Multiplied: " + SafeMultiply.multiply(intArray, multiplier)); }
@Test public void TestVUShortArray() { final double multiplier = 2d; final List<UShort> list = Arrays.asList(UShort.valueOf(Short.parseShort("0")), UShort.valueOf(Short.parseShort("1")), UShort.valueOf(Short.parseShort("2")), UShort.valueOf(Short.parseShort("3"))); ListUShort listUShort = new ListUShort() { @Override public short getShort(int i) { return list.get(i).shortValue(); } @Override public int size() { return list.size(); } }; VUShortArray shortArray = VUShortArray.of(listUShort, alarm_1, time_1, display_1); VNumberArray multipliedUShortArray = SafeMultiply.multiply(shortArray, multiplier); for (int index = 0; index < list.size(); index++) { assertTrue(Short.compareUnsigned(SafeMultiply.multiply(list.get(index), multiplier).shortValue(), multipliedUShortArray.getData().getShort(index)) == 0); } System.out.println("multiplier: " + multiplier); System.out.println(" Original: " + shortArray); System.out.println("Multiplied: " + SafeMultiply.multiply(shortArray, multiplier)); }
@Test public void TestVShortArray() { final double multiplier = 2d; final List<Short> list = Arrays.asList(Short.parseShort("0"), Short.parseShort("1"), Short.parseShort("2"), Short.parseShort("3")); ListShort listShort = new ListShort() { @Override public short getShort(int i) { return list.get(i); } @Override public int size() { return list.size(); } }; VShortArray shortArray = VShortArray.of(listShort, alarm_1, time_1, display_1); VNumberArray multipliedShortArray = SafeMultiply.multiply(shortArray, multiplier); for (int index = 0; index < list.size(); index++) { assertTrue(Short.compareUnsigned(SafeMultiply.multiply(list.get(index), multiplier).shortValue(), multipliedShortArray.getData().getShort(index)) == 0); } System.out.println("multiplier: " + multiplier); System.out.println(" Original: " + shortArray); System.out.println("Multiplied: " + SafeMultiply.multiply(shortArray, multiplier)); }
@Test public void TestVUByteArray() { final double multiplier = 2d; final List<UByte> list = Arrays.asList(UByte.valueOf(Byte.parseByte("0")), UByte.valueOf(Byte.parseByte("1")), UByte.valueOf(Byte.parseByte("2")), UByte.valueOf(Byte.parseByte("3"))); ListUByte listUByte = new ListUByte() { @Override public byte getByte(int i) { return list.get(i).byteValue(); } @Override public int size() { return list.size(); } }; VUByteArray byteArray = VUByteArray.of(listUByte, alarm_1, time_1, display_1); VNumberArray multipliedUByteArray = SafeMultiply.multiply(byteArray, multiplier); for (int index = 0; index < list.size(); index++) { assertTrue(Byte.compareUnsigned(SafeMultiply.multiply(list.get(index), multiplier).byteValue(), multipliedUByteArray.getData().getByte(index)) == 0); } System.out.println("multiplier: " + multiplier); System.out.println(" Original: " + byteArray); System.out.println("Multiplied: " + SafeMultiply.multiply(byteArray, multiplier)); }
@Test public void TestVByteArray() { final double multiplier = 2d; final List<Byte> list = Arrays.asList(Byte.parseByte("0"), Byte.parseByte("1"), Byte.parseByte("2"), Byte.parseByte("3")); ListByte listByte = new ListByte() { @Override public byte getByte(int i) { return list.get(i); } @Override public int size() { return list.size(); } }; VByteArray byteArray = VByteArray.of(listByte, alarm_1, time_1, display_1); VNumberArray multipliedByteArray = SafeMultiply.multiply(byteArray, multiplier); for (int index = 0; index < list.size(); index++) { assertTrue(Byte.compareUnsigned(SafeMultiply.multiply(list.get(index), multiplier).byteValue(), multipliedByteArray.getData().getByte(index)) == 0); } System.out.println("multiplier: " + multiplier); System.out.println(" Original: " + byteArray); System.out.println("Multiplied: " + SafeMultiply.multiply(byteArray, multiplier)); } |
Services implements IServices { @Override @Transactional public void deleteNode(String nodeId) { logger.info("Deleting node id={}", nodeId); nodeDAO.deleteNode(nodeId); } @Override Node getParentNode(String uniqueNodeId); @Override List<Node> getSnapshots(String configUniqueId); @Override Node getSnapshot(String snapshotUniqueId); @Override Node createNode(String parentsUniqueId, Node node); @Override @Transactional Node moveNode(String nodeId, String targetNodeId, String userName); @Override @Transactional void deleteNode(String nodeId); @Override @Transactional Node updateConfiguration(Node configToUpdate, List<ConfigPv> configPvs); @Override Node updateNode(Node nodeToUpdate); @Override Node updateNode(Node nodeToUpdate, boolean customTimeForMigration); @Override Node getNode(String nodeId); @Override List<Node> getChildNodes(String nodeUniqueId); @Override Node getRootNode(); @Override List<ConfigPv> getConfigPvs(String configUniqueId); @Override List<SnapshotItem> getSnapshotItems(String snapshotUniqueId); @Override Node saveSnapshot(String configUniqueId, List<SnapshotItem> snapshotItems, String snapshotName,
String userName, String comment); @Override List<Tag> getTags(String snapshotUniqueId); @Override List<Tag> getAllTags(); @Override List<Node> getFromPath(String path); @Override String getFullPath(String uniqueNodeId); } | @Test public void testDeleteConfiguration() { services.deleteNode("a"); verify(nodeDAO, atLeast(1)).deleteNode("a"); reset(nodeDAO); }
@Test public void testDeleteFolder() { services.deleteNode("a"); verify(nodeDAO, atLeast(1)).deleteNode("a"); reset(nodeDAO); } |
Services implements IServices { @Override @Transactional public Node moveNode(String nodeId, String targetNodeId, String userName) { logger.info("Moving node id {} to raget node id {}", nodeId, targetNodeId); return nodeDAO.moveNode(nodeId, targetNodeId, userName); } @Override Node getParentNode(String uniqueNodeId); @Override List<Node> getSnapshots(String configUniqueId); @Override Node getSnapshot(String snapshotUniqueId); @Override Node createNode(String parentsUniqueId, Node node); @Override @Transactional Node moveNode(String nodeId, String targetNodeId, String userName); @Override @Transactional void deleteNode(String nodeId); @Override @Transactional Node updateConfiguration(Node configToUpdate, List<ConfigPv> configPvs); @Override Node updateNode(Node nodeToUpdate); @Override Node updateNode(Node nodeToUpdate, boolean customTimeForMigration); @Override Node getNode(String nodeId); @Override List<Node> getChildNodes(String nodeUniqueId); @Override Node getRootNode(); @Override List<ConfigPv> getConfigPvs(String configUniqueId); @Override List<SnapshotItem> getSnapshotItems(String snapshotUniqueId); @Override Node saveSnapshot(String configUniqueId, List<SnapshotItem> snapshotItems, String snapshotName,
String userName, String comment); @Override List<Tag> getTags(String snapshotUniqueId); @Override List<Tag> getAllTags(); @Override List<Node> getFromPath(String path); @Override String getFullPath(String uniqueNodeId); } | @Test public void testMoveNode() { services.moveNode("a", "b", "username"); verify(nodeDAO, atLeast(1)).moveNode("a", "b", "username"); reset(nodeDAO); } |
PathWrangler { public PathWrangler(final String removals) { for (String remove : removals.split(",")) this.removals.add(Pattern.compile(remove)); } PathWrangler(final String removals); String wrangle(String path); } | @Test public void testPathWrangler() { final PathWrangler wrangler = new PathWrangler("phoebus\\.app/Content/.*,phoebus\\.app/,phoebus-[^/]+/,product-[^/]+/,jdk/.*"); assertThat(wrangler.wrangle("phoebus-0.0.1/doc/applications.html"), equalTo("doc/applications.html")); assertThat(wrangler.wrangle("product-sns-0.0.1/lib/somelib.jar"), equalTo("lib/somelib.jar")); assertThat(wrangler.wrangle("product-sns-0.0.1/doc/phoebus/app/display/editor/doc/html/generated/org/csstudio/display/builder/model/DisplayModel.html"), equalTo("doc/phoebus/app/display/editor/doc/html/generated/org/csstudio/display/builder/model/DisplayModel.html")); assertThat(wrangler.wrangle("jdk/bin/java"), equalTo("")); assertThat(wrangler.wrangle("phoebus.app/product-sns-0.0.1/lib/somelib.jar"), equalTo("lib/somelib.jar")); assertThat(wrangler.wrangle("phoebus.app/jdk/bin/java"), equalTo("")); assertThat(wrangler.wrangle("phoebus.app/Content/Whateer/Else"), equalTo("")); } |
PVPool { public static Collection<String> getSupportedPrefixes() { return factories.keySet(); } private PVPool(); static Collection<String> getSupportedPrefixes(); static PV getPV(final String name); static void releasePV(final PV pv); static Collection<ReferencedEntry<PV>> getPVReferences(); static final String DEFAULT; final static String SEPARATOR; } | @Test public void listPrefixes() { final Collection<String> prefs = PVPool.getSupportedPrefixes(); System.out.println("Prefixes: " + prefs); assertThat(prefs, hasItem("ca")); assertThat(prefs, hasItem("sim")); } |
IndexNameHelper { public String getIndexName(Instant time) { if (dateSpanValue < 1) return baseIndexName; if (null != time && (null == spanEnd || time.isAfter(spanEnd))) { setDateSpanStartAndEnd(time); currentDateSpan = parseCurrentDateSpan(); } return baseIndexName + "_" + currentDateSpan; } IndexNameHelper(final String baseIndexName, final String dateSpanUnit, final Integer dateSpanValue); String getIndexName(Instant time); Instant getCurrentDateSpanStart(); Instant getCurrentDateSpanEnd(); } | @Test public void dateSpanValueZero() throws Exception { IndexNameHelper inh = new IndexNameHelper("test_index", "y", 0); String indexName = inh.getIndexName(Instant.now()); assertEquals("test_index", indexName); }
@Test public void dateSpanValueLessThanZero() throws Exception { IndexNameHelper inh = new IndexNameHelper("test_index", "y", -5); String indexName = inh.getIndexName(Instant.now()); assertEquals("test_index", indexName); } |
FileExtensionUtil { public static File enforceFileExtension(final File file, final String desiredExtension) { final String path = file.getPath(); final int sep = path.lastIndexOf('.'); if (sep < 0){ return new File(path + "." + desiredExtension); } final String ext = path.substring(sep + 1); if (! ext.equals(desiredExtension)){ return new File(path.substring(0, sep) + "." + desiredExtension); } return file; } static File enforceFileExtension(final File file, final String desiredExtension); } | @Test public void testFile() throws Exception { File bob = new File("/some/path/file.bob"); File file = FileExtensionUtil.enforceFileExtension(new File("/some/path/file"), "bob"); assertThat(file, equalTo(bob)); file = FileExtensionUtil.enforceFileExtension(new File("/some/path/file.abc"), "bob"); assertThat(file, equalTo(bob)); file = FileExtensionUtil.enforceFileExtension(new File("/some/path/file.bob"), "bob"); assertThat(file, equalTo(bob)); } |
TimeDuration { public static Duration ofSeconds(double sec) { return Duration.ofNanos((long) (sec * NANOSEC_IN_SEC)); } private TimeDuration(); static Duration createDuration(long sec, int nanoSec); static Duration ofDays(double day); static Duration ofHours(double hour); static Duration ofMinutes(double min); static Duration ofSeconds(double sec); static Duration ofHertz(double hz); static int dividedBy(Duration dividendDuration, Duration divisorDuration); static double toSecondsDouble(Duration duration); static String toSecondString(Duration duration); } | @Test public void sec1() { Duration duration = TimeDuration.ofSeconds(1.0); assertThat(duration.getNano(), equalTo(0)); assertThat(duration.getSeconds(), equalTo(1L)); }
@Test public void sec2() { Duration duration = TimeDuration.ofSeconds(0.123456789); assertThat(duration.getNano(), equalTo(123456789)); assertThat(duration.getSeconds(), equalTo(0L)); }
@Test public void sec3() { Duration duration = TimeDuration.ofSeconds(-1.23456789); assertThat(duration.getNano(), equalTo(765432110)); assertThat(duration.getSeconds(), equalTo(-2L)); }
@Test public void plus1() { Duration duration = Duration.ofMillis(800); assertThat(duration.plus(Duration.ofMillis(300)), equalTo(TimeDuration.ofSeconds(1.1))); }
@Test public void plus2() { Duration duration = Duration.ofMillis(-100); assertThat(duration.plus(Duration.ofMillis(300)), equalTo(TimeDuration.ofSeconds(0.2))); }
@Test public void plus3() { Duration duration = Duration.ofMillis(100); assertThat(duration.plus(Duration.ofMillis(-200)), equalTo(TimeDuration.ofSeconds(-0.1))); }
@Test public void plus4() { Duration duration = TimeDuration.ofSeconds(1.250); assertThat(duration.plus(TimeDuration.ofSeconds(1.250)), equalTo(TimeDuration.ofSeconds(2.5))); }
@Test public void plus5() { Duration duration = TimeDuration.ofSeconds(10.250); assertThat(duration.plus(TimeDuration.ofSeconds(-1.750)), equalTo(TimeDuration.ofSeconds(8.5))); }
@Test public void minus1() { Duration duration = Duration.ofMillis(800); assertThat(duration.minus(Duration.ofMillis(300)), equalTo(TimeDuration.ofSeconds(0.5))); }
@Test public void minus2() { Duration duration = Duration.ofMillis(800); assertThat(duration.minus(Duration.ofMillis(-300)), equalTo(TimeDuration.ofSeconds(1.1))); }
@Test public void minus3() { Duration duration = Duration.ofMillis(1300); assertThat(duration.minus(Duration.ofMillis(800)), equalTo(TimeDuration.ofSeconds(0.5))); }
@Test public void minus4() { Duration duration = Duration.ofMillis(800); assertThat(duration.minus(Duration.ofMillis(1300)), equalTo(TimeDuration.ofSeconds(-0.5))); }
@Test public void minus5() { Duration duration = TimeDuration.ofSeconds(10.250); assertThat(duration.minus(Duration.ofMillis(1750)), equalTo(TimeDuration.ofSeconds(8.5))); }
@Test public void multipliedBy1() { Duration duration = Duration.ofMillis(300); assertThat(duration.multipliedBy(5), equalTo(TimeDuration.ofSeconds(1.5))); }
@Test public void multipliedBy2() { Duration duration = TimeDuration.ofSeconds(10.500); assertThat(duration.multipliedBy(5), equalTo(TimeDuration.ofSeconds(52.5))); }
@Test public void multipliedBy3() { Duration duration = TimeDuration.ofSeconds(10.500); assertThat(duration.multipliedBy(-5), equalTo(TimeDuration.ofSeconds(-52.5))); }
@Test public void toNanosLong1() { Duration duration = TimeDuration.ofSeconds(1.5); assertThat(duration.toNanos(), equalTo(1500000000L)); }
@Test public void isPositive1() { Duration duration = TimeDuration.ofSeconds(0); assertThat(!duration.isNegative(), equalTo(true)); }
@Test public void isPositive2() { Duration duration = TimeDuration.ofSeconds(1.3); assertThat(!duration.isNegative(), equalTo(true)); }
@Test public void isPositive3() { Duration duration = TimeDuration.ofSeconds(0.5); assertThat(!duration.isNegative(), equalTo(true)); }
@Test public void isPositive4() { Duration duration = TimeDuration.ofSeconds(5.0); assertThat(!duration.isNegative(), equalTo(true)); }
@Test public void isPositive5() { Duration duration = TimeDuration.ofSeconds(-0.5); assertThat(!duration.isNegative(), equalTo(false)); }
@Test public void isPositive6() { Duration duration = TimeDuration.ofSeconds(-5.5); assertThat(!duration.isNegative(), equalTo(false)); }
@Test public void isNegative1() { Duration duration = TimeDuration.ofSeconds(0); assertThat(duration.isNegative(), equalTo(false)); }
@Test public void isNegative2() { Duration duration = TimeDuration.ofSeconds(1.3); assertThat(duration.isNegative(), equalTo(false)); }
@Test public void isNegative3() { Duration duration = TimeDuration.ofSeconds(0.5); assertThat(duration.isNegative(), equalTo(false)); }
@Test public void isNegative4() { Duration duration = TimeDuration.ofSeconds(5.0); assertThat(duration.isNegative(), equalTo(false)); }
@Test public void isNegative5() { Duration duration = TimeDuration.ofSeconds(-0.5); assertThat(duration.isNegative(), equalTo(true)); }
@Test public void isNegative6() { Duration duration = TimeDuration.ofSeconds(-5.5); assertThat(duration.isNegative(), equalTo(true)); } |
Services implements IServices { @Override public Node updateNode(Node nodeToUpdate) { return updateNode(nodeToUpdate, false); } @Override Node getParentNode(String uniqueNodeId); @Override List<Node> getSnapshots(String configUniqueId); @Override Node getSnapshot(String snapshotUniqueId); @Override Node createNode(String parentsUniqueId, Node node); @Override @Transactional Node moveNode(String nodeId, String targetNodeId, String userName); @Override @Transactional void deleteNode(String nodeId); @Override @Transactional Node updateConfiguration(Node configToUpdate, List<ConfigPv> configPvs); @Override Node updateNode(Node nodeToUpdate); @Override Node updateNode(Node nodeToUpdate, boolean customTimeForMigration); @Override Node getNode(String nodeId); @Override List<Node> getChildNodes(String nodeUniqueId); @Override Node getRootNode(); @Override List<ConfigPv> getConfigPvs(String configUniqueId); @Override List<SnapshotItem> getSnapshotItems(String snapshotUniqueId); @Override Node saveSnapshot(String configUniqueId, List<SnapshotItem> snapshotItems, String snapshotName,
String userName, String comment); @Override List<Tag> getTags(String snapshotUniqueId); @Override List<Tag> getAllTags(); @Override List<Node> getFromPath(String path); @Override String getFullPath(String uniqueNodeId); } | @Test public void testUpdateNode() { Node node = Node.builder().build(); services.updateNode(node); verify(nodeDAO, atLeast(1)).updateNode(node, false); reset(nodeDAO); } |
TimeDuration { public static Duration ofMinutes(double min) { return Duration.ofNanos((long) (min * 60 * NANOSEC_IN_SEC)); } private TimeDuration(); static Duration createDuration(long sec, int nanoSec); static Duration ofDays(double day); static Duration ofHours(double hour); static Duration ofMinutes(double min); static Duration ofSeconds(double sec); static Duration ofHertz(double hz); static int dividedBy(Duration dividendDuration, Duration divisorDuration); static double toSecondsDouble(Duration duration); static String toSecondString(Duration duration); } | @Test public void min1() { Duration duration = TimeDuration.ofMinutes(1.0); assertThat(duration.getNano(), equalTo(0)); assertThat(duration.getSeconds(), equalTo(60L)); }
@Test public void min2() { Duration duration = TimeDuration.ofMinutes(0.123456789); assertThat(duration.getNano(), equalTo(407407340)); assertThat(duration.getSeconds(), equalTo(7L)); }
@Test public void min3() { Duration duration = TimeDuration.ofMinutes(-1.23456789); assertThat(duration.getNano(), equalTo(925926601)); assertThat(duration.getSeconds(), equalTo(-75L)); } |
TimeDuration { public static Duration ofHours(double hour) { return Duration.ofNanos((long) (hour * 60 * 60 * NANOSEC_IN_SEC)); } private TimeDuration(); static Duration createDuration(long sec, int nanoSec); static Duration ofDays(double day); static Duration ofHours(double hour); static Duration ofMinutes(double min); static Duration ofSeconds(double sec); static Duration ofHertz(double hz); static int dividedBy(Duration dividendDuration, Duration divisorDuration); static double toSecondsDouble(Duration duration); static String toSecondString(Duration duration); } | @Test public void hour1() { Duration duration = TimeDuration.ofHours(1.0); assertThat(duration.getNano(), equalTo(0)); assertThat(duration.getSeconds(), equalTo(3600L)); }
@Test public void hour2() { Duration duration = TimeDuration.ofHours(0.123456789); assertThat(duration.getNano(), equalTo(444440399)); assertThat(duration.getSeconds(), equalTo(444L)); }
@Test public void hour3() { Duration duration = TimeDuration.ofHours(-1.23456789); assertThat(duration.getNano(), equalTo(555596001)); assertThat(duration.getSeconds(), equalTo(-4445L)); } |
TimeDuration { public static Duration ofHertz(double hz) { if (hz <= 0.0) { throw new IllegalArgumentException("Frequency has to be greater than 0.0"); } return Duration.ofNanos((long) (1000000000.0 / hz)); } private TimeDuration(); static Duration createDuration(long sec, int nanoSec); static Duration ofDays(double day); static Duration ofHours(double hour); static Duration ofMinutes(double min); static Duration ofSeconds(double sec); static Duration ofHertz(double hz); static int dividedBy(Duration dividendDuration, Duration divisorDuration); static double toSecondsDouble(Duration duration); static String toSecondString(Duration duration); } | @Test public void hz1() { Duration duration = TimeDuration.ofHertz(1.0); assertThat(duration.getNano(), equalTo(0)); assertThat(duration.getSeconds(), equalTo(1L)); }
@Test public void hz2() { Duration duration = TimeDuration.ofHertz(100.0); assertThat(duration.getNano(), equalTo(10000000)); assertThat(duration.getSeconds(), equalTo(0L)); }
@Test public void hz3() { Duration duration = TimeDuration.ofHertz(0.123456789); assertThat(duration.getNano(), equalTo(100000073)); assertThat(duration.getSeconds(), equalTo(8L)); } |
Services implements IServices { @Override @Transactional public Node updateConfiguration(Node configToUpdate, List<ConfigPv> configPvs) { logger.info("Updating configuration unique id: {}", configToUpdate.getUniqueId()); return nodeDAO.updateConfiguration(configToUpdate, configPvs); } @Override Node getParentNode(String uniqueNodeId); @Override List<Node> getSnapshots(String configUniqueId); @Override Node getSnapshot(String snapshotUniqueId); @Override Node createNode(String parentsUniqueId, Node node); @Override @Transactional Node moveNode(String nodeId, String targetNodeId, String userName); @Override @Transactional void deleteNode(String nodeId); @Override @Transactional Node updateConfiguration(Node configToUpdate, List<ConfigPv> configPvs); @Override Node updateNode(Node nodeToUpdate); @Override Node updateNode(Node nodeToUpdate, boolean customTimeForMigration); @Override Node getNode(String nodeId); @Override List<Node> getChildNodes(String nodeUniqueId); @Override Node getRootNode(); @Override List<ConfigPv> getConfigPvs(String configUniqueId); @Override List<SnapshotItem> getSnapshotItems(String snapshotUniqueId); @Override Node saveSnapshot(String configUniqueId, List<SnapshotItem> snapshotItems, String snapshotName,
String userName, String comment); @Override List<Tag> getTags(String snapshotUniqueId); @Override List<Tag> getAllTags(); @Override List<Node> getFromPath(String path); @Override String getFullPath(String uniqueNodeId); } | @Test public void testUpdateConfiguration() { when(nodeDAO.updateConfiguration(config1, configPvList)).thenReturn(config1); assertNotNull(services.updateConfiguration(config1, configPvList)); } |
Services implements IServices { @Override public List<SnapshotItem> getSnapshotItems(String snapshotUniqueId) { logger.info("Getting snapshot items for snapshot id {}", snapshotUniqueId); return nodeDAO.getSnapshotItems(snapshotUniqueId); } @Override Node getParentNode(String uniqueNodeId); @Override List<Node> getSnapshots(String configUniqueId); @Override Node getSnapshot(String snapshotUniqueId); @Override Node createNode(String parentsUniqueId, Node node); @Override @Transactional Node moveNode(String nodeId, String targetNodeId, String userName); @Override @Transactional void deleteNode(String nodeId); @Override @Transactional Node updateConfiguration(Node configToUpdate, List<ConfigPv> configPvs); @Override Node updateNode(Node nodeToUpdate); @Override Node updateNode(Node nodeToUpdate, boolean customTimeForMigration); @Override Node getNode(String nodeId); @Override List<Node> getChildNodes(String nodeUniqueId); @Override Node getRootNode(); @Override List<ConfigPv> getConfigPvs(String configUniqueId); @Override List<SnapshotItem> getSnapshotItems(String snapshotUniqueId); @Override Node saveSnapshot(String configUniqueId, List<SnapshotItem> snapshotItems, String snapshotName,
String userName, String comment); @Override List<Tag> getTags(String snapshotUniqueId); @Override List<Tag> getAllTags(); @Override List<Node> getFromPath(String path); @Override String getFullPath(String uniqueNodeId); } | @Test public void testGetSnapshotItems() { when(nodeDAO.getSnapshotItems("a")).thenReturn(Collections.emptyList()); assertNotNull(services.getSnapshotItems("a")); } |
TimeDuration { public static String toSecondString(Duration duration){ return duration.getSeconds() + "." + format.format(duration.getNano()); } private TimeDuration(); static Duration createDuration(long sec, int nanoSec); static Duration ofDays(double day); static Duration ofHours(double hour); static Duration ofMinutes(double min); static Duration ofSeconds(double sec); static Duration ofHertz(double hz); static int dividedBy(Duration dividendDuration, Duration divisorDuration); static double toSecondsDouble(Duration duration); static String toSecondString(Duration duration); } | @Test public void toString1() { Duration duration = Duration.ofMillis(10); assertThat(TimeDuration.toSecondString(duration), equalTo("0.010000000")); } |
Services implements IServices { @Override public Node getParentNode(String uniqueNodeId) { return nodeDAO.getParentNode(uniqueNodeId); } @Override Node getParentNode(String uniqueNodeId); @Override List<Node> getSnapshots(String configUniqueId); @Override Node getSnapshot(String snapshotUniqueId); @Override Node createNode(String parentsUniqueId, Node node); @Override @Transactional Node moveNode(String nodeId, String targetNodeId, String userName); @Override @Transactional void deleteNode(String nodeId); @Override @Transactional Node updateConfiguration(Node configToUpdate, List<ConfigPv> configPvs); @Override Node updateNode(Node nodeToUpdate); @Override Node updateNode(Node nodeToUpdate, boolean customTimeForMigration); @Override Node getNode(String nodeId); @Override List<Node> getChildNodes(String nodeUniqueId); @Override Node getRootNode(); @Override List<ConfigPv> getConfigPvs(String configUniqueId); @Override List<SnapshotItem> getSnapshotItems(String snapshotUniqueId); @Override Node saveSnapshot(String configUniqueId, List<SnapshotItem> snapshotItems, String snapshotName,
String userName, String comment); @Override List<Tag> getTags(String snapshotUniqueId); @Override List<Tag> getAllTags(); @Override List<Node> getFromPath(String path); @Override String getFullPath(String uniqueNodeId); } | @Test public void testgetParentNode() { Node parentNode = Node.builder().name("a").uniqueId("u").build(); when(nodeDAO.getParentNode("u")).thenReturn(parentNode); assertNotNull(services.getParentNode("u")); } |
TimeInterval { public static TimeInterval between(Instant start, Instant end) { return new TimeInterval(start, end); } private TimeInterval(Instant start, Instant end); boolean contains(Instant instant); static TimeInterval between(Instant start, Instant end); TimeInterval minus(Duration duration); static TimeInterval around(Duration duration, Instant reference); static TimeInterval after(Duration duration, Instant reference); static TimeInterval before(Duration duration, Instant reference); Instant getStart(); Instant getEnd(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); } | @Test public void equals1() { TimeInterval interval = TimeInterval.between(Instant.ofEpochSecond(0, 0), Instant.ofEpochSecond(3600, 0)); assertThat(interval, equalTo(TimeInterval.between(Instant.ofEpochSecond(0, 0), Instant.ofEpochSecond(3600, 0)))); }
@Test public void equals2() { TimeInterval interval = TimeInterval.between(Instant.ofEpochSecond(0, 1), Instant.ofEpochSecond(3600, 0)); assertThat(interval, not(equalTo(TimeInterval.between(Instant.ofEpochSecond(0, 0), Instant.ofEpochSecond(3600, 0))))); }
@Test public void equals3() { TimeInterval interval = TimeInterval.between(Instant.ofEpochSecond(0, 0), Instant.ofEpochSecond(3600, 1)); assertThat(interval, not(equalTo(TimeInterval.between(Instant.ofEpochSecond(0, 0), Instant.ofEpochSecond(3600, 0))))); }
@Test public void equals4() { TimeInterval interval = TimeInterval.between(Instant.ofEpochSecond(0, 0), null); assertThat(interval, equalTo(TimeInterval.between(Instant.ofEpochSecond(0, 0), null))); }
@Test public void equals5() { TimeInterval interval = TimeInterval.between(null, Instant.ofEpochSecond(0, 0)); assertThat(interval, equalTo(TimeInterval.between(null, Instant.ofEpochSecond(0, 0)))); } |
Services implements IServices { @Override public List<Node> getChildNodes(String nodeUniqueId) { logger.info("Getting child nodes for node unique id={}", nodeUniqueId); return nodeDAO.getChildNodes(nodeUniqueId); } @Override Node getParentNode(String uniqueNodeId); @Override List<Node> getSnapshots(String configUniqueId); @Override Node getSnapshot(String snapshotUniqueId); @Override Node createNode(String parentsUniqueId, Node node); @Override @Transactional Node moveNode(String nodeId, String targetNodeId, String userName); @Override @Transactional void deleteNode(String nodeId); @Override @Transactional Node updateConfiguration(Node configToUpdate, List<ConfigPv> configPvs); @Override Node updateNode(Node nodeToUpdate); @Override Node updateNode(Node nodeToUpdate, boolean customTimeForMigration); @Override Node getNode(String nodeId); @Override List<Node> getChildNodes(String nodeUniqueId); @Override Node getRootNode(); @Override List<ConfigPv> getConfigPvs(String configUniqueId); @Override List<SnapshotItem> getSnapshotItems(String snapshotUniqueId); @Override Node saveSnapshot(String configUniqueId, List<SnapshotItem> snapshotItems, String snapshotName,
String userName, String comment); @Override List<Tag> getTags(String snapshotUniqueId); @Override List<Tag> getAllTags(); @Override List<Node> getFromPath(String path); @Override String getFullPath(String uniqueNodeId); } | @Test public void testGetChildNodes() { when(nodeDAO.getChildNodes("a")).thenReturn(Arrays.asList(Node.builder().build())); assertNotNull(services.getChildNodes("a")); } |
TimeParser { @Deprecated public static Instant getInstant(String time) { if (time.equalsIgnoreCase(NOW)) { return Instant.now(); } else { Matcher nUnitsAgoMatcher = timeQuantityUnitsPattern.matcher(time); while (nUnitsAgoMatcher.find()) { return Instant.now().minus(parseDuration(nUnitsAgoMatcher.group(1))); } DateTimeFormatter formatter = DateTimeFormatter.ISO_DATE_TIME; return LocalDateTime.parse(time, formatter).atZone(TimeZone.getDefault().toZoneId()).toInstant(); } } @Deprecated static Instant getInstant(String time); @Deprecated static TimeInterval getTimeInterval(String time); @Deprecated static Duration parseDuration(String string); static TemporalAmount parseTemporalAmount(final String string); static String format(final TemporalAmount amount); static Object parseInstantOrTemporalAmount(final String text); static final String NOW; } | @Test public void getNow() { Instant ts = TimeParser.getInstant("now"); assertTrue("Failed to obtain Timestamp corresponding to now ", ts != null && ts instanceof Instant); } |
TimeParser { @Deprecated public static Duration parseDuration(String string) { int quantity = 0; String unit = ""; Matcher timeQunatityUnitsMatcher = durationTimeQunatityUnitsPattern.matcher(string); Map<ChronoUnit, Integer> timeQuantities = new HashMap<>(); while (timeQunatityUnitsMatcher.find()) { quantity = "".equals(timeQunatityUnitsMatcher.group(1)) ? 1 : Integer.valueOf(timeQunatityUnitsMatcher.group(1)); unit = timeQunatityUnitsMatcher.group(2).toLowerCase(); switch (unit) { case "ms": case "milli": timeQuantities.put(MILLIS, quantity); break; case "s": case "sec": case "secs": timeQuantities.put(SECONDS, quantity); break; case "m": case "min": case "mins": timeQuantities.put(MINUTES, quantity); break; case "h": case "hour": case "hours": timeQuantities.put(HOURS, quantity); break; case "d": case "day": case "days": timeQuantities.put(DAYS, quantity); break; default: break; } } Duration duration = Duration.ofSeconds(0); for (Entry<ChronoUnit, Integer> entry : timeQuantities.entrySet()) { duration = duration.plus(entry.getValue(), entry.getKey()); } return duration; } @Deprecated static Instant getInstant(String time); @Deprecated static TimeInterval getTimeInterval(String time); @Deprecated static Duration parseDuration(String string); static TemporalAmount parseTemporalAmount(final String string); static String format(final TemporalAmount amount); static Object parseInstantOrTemporalAmount(final String text); static final String NOW; } | @Test public void getDuration() { Duration lastMin = TimeParser.parseDuration("1 min"); assertEquals("Failed to get Duration for last min", Duration.ofSeconds(60), lastMin); Duration lastHour = TimeParser.parseDuration("1 hour"); assertEquals("Failed to get Duration for last hour", Duration.ofHours(1), lastHour); TemporalAmount last5Min = TimeParser.parseDuration(" 5 mins"); assertEquals("Failed to get Duration for last 5 mins", Duration.ofMinutes(5), last5Min); TemporalAmount last5Hour = TimeParser.parseDuration(" 5 hours"); assertEquals("Failed to get Duration for last 5 hours", Duration.ofHours(5), last5Hour); Duration last5Day = TimeParser.parseDuration(" 5 days"); assertEquals("Failed to get Duration for last 5 days", 60 * 60 * 24 * 5, last5Day.getSeconds()); }
@Test public void parseCompositeTimeString() { TemporalAmount last5Mins30Secs = TimeParser.parseDuration("5 mins 30 secs"); assertEquals("Failed to get Duration for last 5 mins", Duration.ofMinutes(5).plusSeconds(30), last5Mins30Secs); TemporalAmount last3Hours5Mins30Secs = TimeParser.parseDuration("3 hours 5 mins 30 secs"); assertEquals("Failed to get Duration for last 5 mins", Duration.ofHours(3).plusMinutes(5).plusSeconds(30), last3Hours5Mins30Secs); }
@Test public void testParseDuration() { TemporalAmount amount = TimeParser.parseDuration("3 days"); final long seconds = LocalDateTime.ofEpochSecond(0, 0, ZoneOffset.UTC).plus(amount).toEpochSecond(ZoneOffset.UTC); assertEquals(3*24*60*60, seconds); } |
TimeParser { public static TemporalAmount parseTemporalAmount(final String string) { if (NOW.equalsIgnoreCase(string)) return Duration.ZERO; final Matcher timeQuantityUnitsMatcher = timeQuantityUnitsPattern.matcher(string); final Map<ChronoUnit, Integer> timeQuantities = new HashMap<>(); boolean use_period = false; while (timeQuantityUnitsMatcher.find()) { final double quantity = "".equals(timeQuantityUnitsMatcher.group(1)) ? 1.0 : Double.valueOf(timeQuantityUnitsMatcher.group(1)); final int full = (int) quantity; final double fraction = quantity - full; final String unit = timeQuantityUnitsMatcher.group(2).toLowerCase(); if (unit.startsWith("y")) { timeQuantities.put(YEARS, full); if (fraction > 0) { final int next = (int) (fraction * 12 + 0.5); timeQuantities.compute(MONTHS, (u, prev) -> prev == null ? next : prev + next); } use_period = true; } else if (unit.startsWith("mo")) { timeQuantities.compute(MONTHS, (u, prev) -> prev == null ? full : prev + full); if (fraction > 0) { final int next = (int) (fraction * 4*7 + 0.5); timeQuantities.compute(DAYS, (u, prev) -> prev == null ? next : prev + next); } use_period = true; } else if (unit.startsWith("w")) { timeQuantities.compute(WEEKS, (u, prev) -> prev == null ? full : prev + full); if (fraction > 0) { final int next = (int) (fraction * 7 + 0.5); timeQuantities.compute(DAYS, (u, prev) -> prev == null ? next : prev + next); } use_period = true; } else if (unit.startsWith("mi")) { timeQuantities.compute(MINUTES, (u, prev) -> prev == null ? full : prev + full); if (fraction > 0) { final int next = (int) (fraction * 60 + 0.5); timeQuantities.compute(SECONDS, (u, prev) -> prev == null ? next : prev + next); } } else if (unit.startsWith("h")) { timeQuantities.compute(HOURS, (u, prev) -> prev == null ? full : prev + full); if (fraction > 0) { final int next = (int) (fraction * 60 + 0.5); timeQuantities.compute(MINUTES, (u, prev) -> prev == null ? next : prev + next); } } else if (unit.startsWith("d")) { timeQuantities.compute(DAYS, (u, prev) -> prev == null ? full : prev + full); if (fraction > 0) { final int next = (int) (fraction * 24 + 0.5); timeQuantities.compute(HOURS, (u, prev) -> prev == null ? next : prev + next); } } else if (unit.startsWith("s")) { timeQuantities.compute(SECONDS, (u, prev) -> prev == null ? full : prev + full); if (fraction > 0) { final int next = (int) (fraction * 1000 + 0.5); timeQuantities.compute(MILLIS, (u, prev) -> prev == null ? next : prev + next); } } else if (unit.startsWith("mi") || unit.equals("ms")) timeQuantities.compute(MILLIS, (u, prev) -> prev == null ? full : prev + full); } if (use_period) { Period result = Period.ZERO; if (timeQuantities.containsKey(YEARS)) result = result.plusYears(timeQuantities.get(YEARS)); if (timeQuantities.containsKey(WEEKS)) result = result.plusDays(7*timeQuantities.get(WEEKS)); if (timeQuantities.containsKey(MONTHS)) result = result.plusMonths(timeQuantities.get(MONTHS)); if (timeQuantities.containsKey(DAYS)) result = result.plusDays(timeQuantities.get(DAYS)); return result; } else { Duration result = Duration.ofSeconds(0); for (Entry<ChronoUnit, Integer> entry : timeQuantities.entrySet()) result = result.plus(entry.getValue(), entry.getKey()); return result; } } @Deprecated static Instant getInstant(String time); @Deprecated static TimeInterval getTimeInterval(String time); @Deprecated static Duration parseDuration(String string); static TemporalAmount parseTemporalAmount(final String string); static String format(final TemporalAmount amount); static Object parseInstantOrTemporalAmount(final String text); static final String NOW; } | @Test public void parse() { Instant now = Instant.now(); TimeRelativeInterval interval = TimeRelativeInterval.of(TimeParser.parseTemporalAmount("1 min"), now); assertEquals(now.minusSeconds(60), interval.toAbsoluteInterval().getStart()); assertEquals(now, interval.toAbsoluteInterval().getEnd()); }
@Test public void parseRelativeInterval() { TimeRelativeInterval interval = TimeRelativeInterval.of(TimeParser.parseTemporalAmount("1 month"), LocalDateTime .parse("2011-02-01T00:00:00", DateTimeFormatter.ISO_LOCAL_DATE_TIME).toInstant(ZoneOffset.UTC)); TimeInterval jan = interval.toAbsoluteInterval(); assertEquals(31L, Duration.between(jan.getStart(), jan.getEnd()).toDays()); TimeInterval feb = TimeRelativeInterval .of(TimeParser.parseTemporalAmount("1 month"), LocalDateTime .parse("2011-03-01T00:00:00", DateTimeFormatter.ISO_LOCAL_DATE_TIME).toInstant(ZoneOffset.UTC)) .toAbsoluteInterval(); assertEquals(28L, Duration.between(feb.getStart(), feb.getEnd()).toDays()); TimeInterval leapFeb = TimeRelativeInterval .of(TimeParser.parseTemporalAmount("1 month"), LocalDateTime .parse("2012-03-01T00:00:00", DateTimeFormatter.ISO_LOCAL_DATE_TIME).toInstant(ZoneOffset.UTC)) .toAbsoluteInterval(); assertEquals(29L, Duration.between(leapFeb.getStart(), leapFeb.getEnd()).toDays()); }
@Test public void testParseTemporalAmount() { TemporalAmount amount = TimeParser.parseTemporalAmount("3 days"); long seconds = LocalDateTime.ofEpochSecond(0, 0, ZoneOffset.UTC).plus(amount).toEpochSecond(ZoneOffset.UTC); assertEquals(3*24*60*60, seconds); amount = TimeParser.parseTemporalAmount("3 days 20 mins 10 sec"); seconds = LocalDateTime.ofEpochSecond(0, 0, ZoneOffset.UTC).plus(amount).toEpochSecond(ZoneOffset.UTC); assertEquals(3*24*60*60 + 20*60 + 10, seconds); amount = TimeParser.parseTemporalAmount("now"); seconds = LocalDateTime.ofEpochSecond(0, 0, ZoneOffset.UTC).plus(amount).toEpochSecond(ZoneOffset.UTC); assertEquals(0, seconds); amount = TimeParser.parseTemporalAmount("1 month 1 weeks 3 days 20 mins 10 sec"); assertEquals(amount, Period.of(0, 1, 10)); amount = TimeParser.parseTemporalAmount("1 month 1 day"); assertEquals(amount, Period.of(0, 1, 1)); amount = TimeParser.parseTemporalAmount("1 mo"); assertEquals(amount, Period.of(0, 1, 0)); amount = TimeParser.parseTemporalAmount("month"); assertEquals(amount, Period.of(0, 1, 0)); amount = TimeParser.parseTemporalAmount("60 days"); assertEquals(amount, Duration.ofDays(60)); } |
Services implements IServices { @Override public Node getRootNode() { return nodeDAO.getRootNode(); } @Override Node getParentNode(String uniqueNodeId); @Override List<Node> getSnapshots(String configUniqueId); @Override Node getSnapshot(String snapshotUniqueId); @Override Node createNode(String parentsUniqueId, Node node); @Override @Transactional Node moveNode(String nodeId, String targetNodeId, String userName); @Override @Transactional void deleteNode(String nodeId); @Override @Transactional Node updateConfiguration(Node configToUpdate, List<ConfigPv> configPvs); @Override Node updateNode(Node nodeToUpdate); @Override Node updateNode(Node nodeToUpdate, boolean customTimeForMigration); @Override Node getNode(String nodeId); @Override List<Node> getChildNodes(String nodeUniqueId); @Override Node getRootNode(); @Override List<ConfigPv> getConfigPvs(String configUniqueId); @Override List<SnapshotItem> getSnapshotItems(String snapshotUniqueId); @Override Node saveSnapshot(String configUniqueId, List<SnapshotItem> snapshotItems, String snapshotName,
String userName, String comment); @Override List<Tag> getTags(String snapshotUniqueId); @Override List<Tag> getAllTags(); @Override List<Node> getFromPath(String path); @Override String getFullPath(String uniqueNodeId); } | @Test public void testGetRootNode() { when(nodeDAO.getRootNode()).thenReturn(Node.builder().build()); assertNotNull(services.getRootNode()); } |
TimeParser { public static String format(final TemporalAmount amount) { final StringBuilder buf = new StringBuilder(); if (amount instanceof Period) { final Period period = (Period) amount; if (period.isZero()) return NOW; if (period.getYears() == 1) buf.append("1 year "); else if (period.getYears() > 1) buf.append(period.getYears()).append(" years "); if (period.getMonths() == 1) buf.append("1 month "); else if (period.getMonths() > 0) buf.append(period.getMonths()).append(" months "); if (period.getDays() == 1) buf.append("1 day"); else if (period.getDays() > 0) buf.append(period.getDays()).append(" days"); } else { long secs = ((Duration) amount).getSeconds(); if (secs == 0) return NOW; int p = (int) (secs / (24*60*60)); if (p > 0) { if (p == 1) buf.append("1 day "); else buf.append(p).append(" days "); secs -= p * (24*60*60); } p = (int) (secs / (60*60)); if (p > 0) { if (p == 1) buf.append("1 hour "); else buf.append(p).append(" hours "); secs -= p * (60*60); } p = (int) (secs / (60)); if (p > 0) { if (p == 1) buf.append("1 minute "); else buf.append(p).append(" minutes "); secs -= p * (60); } if (secs > 0) if (secs == 1) buf.append("1 second "); else buf.append(secs).append(" seconds "); final int ms = ((Duration)amount).getNano() / 1000000; if (ms > 0) buf.append(ms).append(" ms"); } return buf.toString().trim(); } @Deprecated static Instant getInstant(String time); @Deprecated static TimeInterval getTimeInterval(String time); @Deprecated static Duration parseDuration(String string); static TemporalAmount parseTemporalAmount(final String string); static String format(final TemporalAmount amount); static Object parseInstantOrTemporalAmount(final String text); static final String NOW; } | @Test public void testFormatTemporalAmount() { String text = TimeParser.format(Duration.ofHours(2)); assertEquals("2 hours", text); text = TimeParser.format(Period.of(1, 2, 3)); assertEquals("1 year 2 months 3 days", text); text = TimeParser.format(Duration.ofSeconds(2*24*60*60 + 1*60*60 + 10, 123000000L)); assertEquals("2 days 1 hour 10 seconds 123 ms", text); text = TimeParser.format(Duration.ofSeconds(0)); assertEquals("now", text); text = TimeParser.format(Period.ZERO); assertEquals("now", text); } |
CommandExecutor implements Callable<Integer> { public static List<String> splitCmd(final String cmd) { final List<String> items = new ArrayList<>(); final int len = cmd.length(); int i = 0; final StringBuilder line = new StringBuilder(); while (i < len) { char c = cmd.charAt(i); if (c == ' ' || c == '\t') { items.add(line.toString()); line.delete(0, line.length()); do ++i; while (i < len && (cmd.charAt(i) == ' ' || cmd.charAt(i) == '\t')); } else if (c == '"') { ++i; while (i < len && cmd.charAt(i) != '"') line.append(cmd.charAt(i++)); if (i < len && cmd.charAt(i) == '"') ++i; } else { line.append(c); ++i; } } if (line.length() > 0) items.add(line.toString()); return items; } CommandExecutor(final String cmd, final File directory); static List<String> splitCmd(final String cmd); @Override Integer call(); boolean isActive(); @Override String toString(); } | @Test public void testCommandSplit() throws Exception { List<String> cmd = CommandExecutor.splitCmd("path/cmd"); System.out.println(cmd); assertThat(cmd, equalTo(Arrays.asList("path/cmd"))); cmd = CommandExecutor.splitCmd("path/cmd arg1"); System.out.println(cmd); assertThat(cmd, equalTo(Arrays.asList("path/cmd", "arg1"))); cmd = CommandExecutor.splitCmd("path/cmd arg1 arg2"); System.out.println(cmd); assertThat(cmd, equalTo(Arrays.asList("path/cmd", "arg1", "arg2"))); cmd = CommandExecutor.splitCmd("path/cmd \"one arg\""); System.out.println(cmd); assertThat(cmd, equalTo(Arrays.asList("path/cmd", "one arg"))); cmd = CommandExecutor.splitCmd("path/cmd \"one arg\" arg2 arg3"); System.out.println(cmd); assertThat(cmd, equalTo(Arrays.asList("path/cmd", "one arg", "arg2", "arg3"))); } |
CommandExecutor implements Callable<Integer> { @Override public Integer call() throws Exception { String cmd = process_builder.command().get(0); final int sep = cmd.lastIndexOf('/'); if (sep >= 0) cmd = cmd.substring(sep+1); process = process_builder.start(); final Thread stdout = new LogWriter(process.getInputStream(), cmd, Level.INFO); final Thread stderr = new LogWriter(process.getErrorStream(), cmd, Level.WARNING); stdout.start(); stderr.start(); if (process.waitFor(WAIT_SECONDS, TimeUnit.SECONDS)) { stderr.join(); stdout.join(); final int status = process.exitValue(); if (status != 0) logger.log(Level.WARNING, "Command {0} exited with status {1}", new Object[] { process_builder.command(), status }); return status; } return null; } CommandExecutor(final String cmd, final File directory); static List<String> splitCmd(final String cmd); @Override Integer call(); boolean isActive(); @Override String toString(); } | @Test public void testShortCommand() throws Exception { if (is_windows) return; final String cmd = "./cmd_short.sh \"With one arg\" another_arg"; final Integer status = new CommandExecutor(cmd, examples_dir).call(); final String log = getLoggedMessages(); assertThat(log, containsString("Example warning")); assertThat(log, containsString("2 arguments")); assertThat(log, containsString("Finished OK")); assertThat(status, equalTo(0)); }
@Test public void testErrorCommand() throws Exception { if (is_windows) return; final Integer status = new CommandExecutor("cmds/cmd_short.sh", examples_dir.getParentFile()).call(); final String log = getLoggedMessages(); assertThat(log, containsString("Wrong directory")); assertThat(log, containsString("exited with status 2")); assertThat(status, equalTo(2)); } |
ResourceParser { public static URI createResourceURI(final String resource) throws Exception { try { final URI uri = URI.create(resource); if (uri.getScheme() != null) return uri; else { final Path fileResource = Paths.get(resource); return fileResource.toUri(); } } catch (Throwable ex) { try { return new File(resource).toURI(); } catch (Exception file_ex) { throw new Exception("Cannot create URI for '" + resource + "'", ex); } } } static URI createResourceURI(final String resource); static File getFile(final URI resource); static URI getURI(final File file); static InputStream getContent(final URI resource); static List<String> parsePVs(final URI resource); static String getAppName(final URI resource); static String getTargetName(final URI resource); static Stream<Map.Entry<String, String>> getQueryItemStream(final URI resource); static Map<String, List<String>> parseQueryArgs(final URI resource); static String encode(final String text); static final String PV_SCHEMA; } | @Test public void checkWebToURI() throws Exception { URI uri = createResourceURI("http: System.out.println(uri); assertThat(uri.getScheme(), equalTo("http")); assertThat(uri.getHost(), equalTo("some.site")); assertThat(uri.getPath(), equalTo("/file/path")); } |
SimProposal extends Proposal { public SimProposal(final String name, final String... arguments) { super(name); this.arguments = arguments; } SimProposal(final String name, final String... arguments); @Override String getDescription(); @Override List<MatchSegment> getMatch(final String text); } | @Test public void testSimProposal() { Proposal proposal = new SimProposal("sim: assertThat(proposal.getDescription(), equalTo("sim: assertThat(proposal.apply("sine"), equalTo("sim: assertThat(proposal.apply("sim: equalTo("sim: assertThat(proposal.apply("sin(-10, 10, 2)"), equalTo("sim: assertThat(proposal.apply("sin(-10, 10, 2"), equalTo("sim: proposal = new SimProposal("sim: assertThat(proposal.getDescription(), equalTo("sim: assertThat(proposal.apply("sin(-10,10, 0.1, 2 )"), equalTo("sim: } |
SimProposal extends Proposal { @Override public List<MatchSegment> getMatch(final String text) { final List<String> split = splitNameAndParameters(text); if (split.isEmpty()) return List.of(); final List<MatchSegment> segs = new ArrayList<>(split.size()); final String noparm_text = split.get(0); final int match = value.indexOf(noparm_text); if (match < 0) segs.add(MatchSegment.normal(value)); else { if (match > 0) segs.add(MatchSegment.normal(value.substring(0, match))); segs.add(MatchSegment.match(noparm_text)); final int rest = match + noparm_text.length(); if (value.length() > rest) segs.add(MatchSegment.normal(value.substring(rest))); } final int common = Math.min(split.size()-1, arguments.length); int parm; for (parm = 0; parm < common; ++parm) { final String another = parm < arguments.length-1 ? "," : ")"; if (parm == 0) segs.add(MatchSegment.match("(" + split.get(parm+1) + another, "(" + arguments[parm] + another)); else segs.add(MatchSegment.match(split.get(parm+1) + another, arguments[parm] + another)); } final StringBuilder buf = new StringBuilder(); if (parm < arguments.length) { if (parm == 0) buf.append('('); for (; parm<arguments.length; ++parm) { buf.append(arguments[parm]); if (parm < arguments.length-1) buf.append(", "); } buf.append(')'); } if (buf.length() > 0) segs.add(MatchSegment.comment(buf.toString())); return segs; } SimProposal(final String name, final String... arguments); @Override String getDescription(); @Override List<MatchSegment> getMatch(final String text); } | @Test public void testMatch() { Proposal proposal = new SimProposal("sim: List<MatchSegment> match = proposal.getMatch("sine"); assertThat(match, equalTo(List.of(MatchSegment.normal("sim: MatchSegment.match("sine"), MatchSegment.comment("(min, max, update_seconds)")))); match = proposal.getMatch("sim: assertThat(match, equalTo(List.of(MatchSegment.match("sim: MatchSegment.comment("(min, max, update_seconds)")))); match = proposal.getMatch("sine(2, 4,"); System.out.println("sine(2, 4,"); for (MatchSegment m : match) System.out.println(m); assertThat(match, equalTo(List.of(MatchSegment.normal("sim: MatchSegment.match("sine"), MatchSegment.match("(2,", "(min,"), MatchSegment.match(" 4,", "max,"), MatchSegment.comment("update_seconds)")))); match = proposal.getMatch("sim: System.out.println("sim: for (MatchSegment m : match) System.out.println(m); assertThat(match, equalTo(List.of(MatchSegment.match("sim: MatchSegment.match("(-10,", "(min,"), MatchSegment.match(" 10,", "max,"), MatchSegment.match(" 2)", "update_seconds)")))); } |
History implements ProposalProvider { public History() { this(10); } History(); History(final int max_size); @Override String getName(); synchronized void add(final Proposal proposal); @Override synchronized List<Proposal> lookup(String text); } | @Test public void testHistory() { final History history = new History(); List<Proposal> proposals = history.lookup("test"); assertThat(proposals.size(), equalTo(0)); history.add(new Proposal("Test1")); history.add(new Proposal("Other")); history.add(new Proposal("Test2")); proposals = history.lookup("test"); assertThat(getValues(proposals), hasItems("Test1", "Test2")); assertThat(getValues(proposals), equalTo(List.of("Test2", "Test1"))); proposals = history.lookup("ther"); assertThat(getValues(proposals), equalTo(List.of("Other"))); assertThat(proposals.get(0).apply("ther"), equalTo("Other")); } |
FormulaFunctionProposal extends Proposal { @Override public List<MatchSegment> getMatch(final String text) { final int match = text.indexOf(function.getName()); if (match < 0) return List.of(MatchSegment.normal(getDescription())); final List<MatchSegment> segs = new ArrayList<>(); if (match > 0) segs.add(MatchSegment.normal(text.substring(0, match))); segs.add(MatchSegment.match(function.getName())); final int len = text.length(); int pos = match + function.getName().length(); if (pos < len && text.charAt(pos) == '(') { if (function.isVarArgs()) { int end = SimProposal.findClosingParenthesis(text, pos); if (end < len) { segs.add(MatchSegment.match(text.substring(pos, end+1))); pos = end+1; } else { segs.add(MatchSegment.match(text.substring(pos, end))); segs.add(MatchSegment.comment(")")); pos = end; } } else { segs.add(MatchSegment.match("(")); ++pos; int end = SimProposal.nextSep(text, pos); for (int i=0; i<function.getArguments().size(); ++i) { if (i > 0) segs.add(MatchSegment.normal(",")); if (pos > 0) { if (end > pos) { segs.add(MatchSegment.match(text.substring(pos, end), function.getArguments().get(i))); if (text.charAt(end) == ')') { segs.add(MatchSegment.match(")")); pos = end + 1; break; } else { pos = end + 1; end = SimProposal.nextSep(text, pos); } } else { segs.add(MatchSegment.comment(text.substring(pos), function.getArguments().get(i))); pos = end = -1; } } else segs.add(MatchSegment.comment(function.getArguments().get(i))); } } } else { for (int i=0; i<function.getArguments().size(); ++i) { if (i == 0) segs.add(MatchSegment.comment("(")); else segs.add(MatchSegment.comment(",")); segs.add(MatchSegment.comment(function.getArguments().get(i))); } segs.add(MatchSegment.comment(")")); } if (pos >= 0 && pos < len) segs.add(MatchSegment.normal(text.substring(pos))); return segs; } FormulaFunctionProposal(final FormulaFunction function); @Override String getDescription(); @Override List<MatchSegment> getMatch(final String text); } | @Test public void testMatch() { Proposal proposal = new FormulaFunctionProposal(new Sin()); List<MatchSegment> match = proposal.getMatch("=sin("); assertThat(match, equalTo(List.of(MatchSegment.normal("="), MatchSegment.match("sin"), MatchSegment.match("("), MatchSegment.comment("", "angle")))); match = proposal.getMatch("=sin(2)"); assertThat(match, equalTo(List.of(MatchSegment.normal("="), MatchSegment.match("sin"), MatchSegment.match("("), MatchSegment.match("2", "angle"), MatchSegment.match(")")))); match = proposal.getMatch("=2 + sin(1-1) + 3"); assertThat(match, equalTo(List.of(MatchSegment.normal("=2 + "), MatchSegment.match("sin"), MatchSegment.match("("), MatchSegment.match("1-1", "angle"), MatchSegment.match(")"), MatchSegment.normal(" + 3")))); }
@Test public void testVarArg() { Proposal proposal = new FormulaFunctionProposal(new StringFunction()); List<MatchSegment> match = proposal.getMatch("=concat(a, b) + 2"); assertThat(match, equalTo(List.of(MatchSegment.normal("="), MatchSegment.match("concat"), MatchSegment.match("(a, b)"), MatchSegment.normal(" + 2")))); match = proposal.getMatch("=concat(a, b + 2"); assertThat(match, equalTo(List.of(MatchSegment.normal("="), MatchSegment.match("concat"), MatchSegment.match("(a, b + 2"), MatchSegment.comment(")")))); } |
Services implements IServices { @Override public List<ConfigPv> getConfigPvs(String configUniqueId) { logger.info("Getting config pvs config id id {}", configUniqueId); return nodeDAO.getConfigPvs(configUniqueId); } @Override Node getParentNode(String uniqueNodeId); @Override List<Node> getSnapshots(String configUniqueId); @Override Node getSnapshot(String snapshotUniqueId); @Override Node createNode(String parentsUniqueId, Node node); @Override @Transactional Node moveNode(String nodeId, String targetNodeId, String userName); @Override @Transactional void deleteNode(String nodeId); @Override @Transactional Node updateConfiguration(Node configToUpdate, List<ConfigPv> configPvs); @Override Node updateNode(Node nodeToUpdate); @Override Node updateNode(Node nodeToUpdate, boolean customTimeForMigration); @Override Node getNode(String nodeId); @Override List<Node> getChildNodes(String nodeUniqueId); @Override Node getRootNode(); @Override List<ConfigPv> getConfigPvs(String configUniqueId); @Override List<SnapshotItem> getSnapshotItems(String snapshotUniqueId); @Override Node saveSnapshot(String configUniqueId, List<SnapshotItem> snapshotItems, String snapshotName,
String userName, String comment); @Override List<Tag> getTags(String snapshotUniqueId); @Override List<Tag> getAllTags(); @Override List<Node> getFromPath(String path); @Override String getFullPath(String uniqueNodeId); } | @Test public void testGetConfigPvs() { when(nodeDAO.getConfigPvs("a")).thenReturn(Arrays.asList(ConfigPv.builder().build())); assertNotNull(services.getConfigPvs("a")); } |
ScanCommandImplTool { @SuppressWarnings("unchecked") public static <C extends ScanCommand> ScanCommandImpl<C> implement(final C command, final JythonSupport jython) throws Exception { for (ScanCommandImplFactory factory : factories) { ScanCommandImpl<?> impl = factory.createImplementation(command, jython); if (impl != null) return (ScanCommandImpl<C>)impl; } throw new Exception("Unknown command " + command.getClass().getName()); } @SuppressWarnings("unchecked") static ScanCommandImpl<C> implement(final C command, final JythonSupport jython); static List<ScanCommandImpl<?>> implement(final List<ScanCommand> commands, final JythonSupport jython); } | @Test public void testImplementation() throws Exception { final ScanCommand cmd = new CommentCommand("Test"); final ScanCommandImpl<ScanCommand> impl = ScanCommandImplTool.implement(cmd, null); System.out.println(impl); assertThat(impl, instanceOf(CommentCommandImpl.class)); } |
Proposal { public String apply(final String text) { final StringBuilder result = new StringBuilder(); final List<MatchSegment> match = getMatch(text); for (MatchSegment seg : match) if (seg.getType() != MatchSegment.Type.COMMENT) result.append(seg.getText()); return result.toString(); } Proposal(final String value); String getValue(); String getDescription(); List<MatchSegment> getMatch(final String text); String apply(final String text); @Override String toString(); } | @Test public void testPlainProposal() { Proposal proposal = new Proposal("Test1"); assertThat(proposal.apply("est"), equalTo("Test1")); assertThat(proposal.apply("anything"), equalTo("Test1")); } |
Proposal { public List<MatchSegment> getMatch(final String text) { final int match = value.indexOf(text); if (match < 0) return List.of(MatchSegment.normal(value)); else { final List<MatchSegment> segs = new ArrayList<>(); if (match > 0) segs.add(MatchSegment.normal(value.substring(0, match))); if (! text.isEmpty()) segs.add(MatchSegment.match(text)); final int rest = match + text.length(); if (value.length() > rest) segs.add(MatchSegment.normal(value.substring(rest))); return segs; } } Proposal(final String value); String getValue(); String getDescription(); List<MatchSegment> getMatch(final String text); String apply(final String text); @Override String toString(); } | @Test public void testMatch() { Proposal proposal = new Proposal("Test1"); List<MatchSegment> match = proposal.getMatch("es"); assertThat(match, equalTo(List.of(MatchSegment.normal("T"), MatchSegment.match("es"), MatchSegment.normal("t1")))); match = proposal.getMatch("Tes"); assertThat(match, equalTo(List.of(MatchSegment.match("Tes"), MatchSegment.normal("t1")))); } |
LocProposal extends Proposal { static List<String> splitNameTypeAndInitialValues(final String text) { final List<String> result = new ArrayList<>(); int sep = text.indexOf('<'); if (sep >= 0) { result.add(text.substring(0, sep).trim()); int pos = text.indexOf('>', sep+1); if (pos < 0) result.add(text.substring(sep+1).trim()); else { result.add(text.substring(sep+1, pos).trim()); sep = text.indexOf('(', pos); if (sep >= 0) addInitialValues(result, text.substring(sep+1)); } } else { sep = text.indexOf('('); if (sep >= 0) { result.add(text.substring(0, sep).trim()); result.add(null); addInitialValues(result, text.substring(sep+1)); } else { result.add(text.trim()); result.add(null); } } return result; } LocProposal(final String name, final String type, final String... initial_values); @Override String getDescription(); @Override List<MatchSegment> getMatch(final String text); } | @Test public void testArguments() { List<String> split = LocProposal.splitNameTypeAndInitialValues("loc: assertThat(split, equalTo(Arrays.asList("loc: split = LocProposal.splitNameTypeAndInitialValues("loc: assertThat(split, equalTo(Arrays.asList("loc: split = LocProposal.splitNameTypeAndInitialValues("loc: assertThat(split, equalTo(Arrays.asList("loc: split = LocProposal.splitNameTypeAndInitialValues("loc: assertThat(split, equalTo(Arrays.asList("loc: split = LocProposal.splitNameTypeAndInitialValues("loc: assertThat(split, equalTo(Arrays.asList("loc: } |
LocProposal extends Proposal { public LocProposal(final String name, final String type, final String... initial_values) { super(name); this.type = type; this.initial_values = initial_values; } LocProposal(final String name, final String type, final String... initial_values); @Override String getDescription(); @Override List<MatchSegment> getMatch(final String text); } | @Test public void testLocProposal() { Proposal proposal = new LocProposal("loc: assertThat(proposal.getDescription(), equalTo("loc: proposal = new LocProposal("loc: assertThat(proposal.getDescription(), equalTo("loc: proposal = new LocProposal("loc: assertThat(proposal.getDescription(), equalTo("loc: proposal = new LocProposal("loc: assertThat(proposal.getDescription(), equalTo("loc: } |
LocProposal extends Proposal { @Override public List<MatchSegment> getMatch(final String text) { if (! text.startsWith("loc")) return List.of(MatchSegment.normal(getDescription())); final List<String> split = splitNameTypeAndInitialValues(text); if (split.size() < 1) return List.of(); final List<MatchSegment> segs = new ArrayList<>(split.size()); String name = split.get(0).trim(); if (name.equals("loc: { segs.add(MatchSegment.match(name)); segs.add(MatchSegment.normal("name")); } else segs.addAll(super.getMatch(name)); if (split.get(1) == null) segs.add(MatchSegment.comment("<VType>")); else if (type.toLowerCase().indexOf(split.get(1).toLowerCase()) >= 0) segs.add(MatchSegment.match("<" + type + ">")); else segs.add(MatchSegment.normal("<" + type + ">")); final int common = Math.min(split.size()-2, initial_values.length); int parm; for (parm = 0; parm < common; ++parm) { final String another = parm < initial_values.length-1 ? "," : ")"; if (parm == 0) segs.add(MatchSegment.match("(" + split.get(parm+2) + another, "(" + initial_values[parm] + another)); else segs.add(MatchSegment.match(split.get(parm+2) + another, initial_values[parm] + another)); } final StringBuilder buf = new StringBuilder(); if (parm < initial_values.length) { if (parm == 0) buf.append('('); for (; parm<initial_values.length; ++parm) { buf.append(initial_values[parm]); if (parm < initial_values.length-1) buf.append(", "); } buf.append(')'); } if (buf.length() > 0) segs.add(MatchSegment.comment(buf.toString())); return segs; } LocProposal(final String name, final String type, final String... initial_values); @Override String getDescription(); @Override List<MatchSegment> getMatch(final String text); } | @Test public void testMatch() { Proposal proposal = new LocProposal("loc: List<MatchSegment> match = proposal.getMatch("loc: assertThat(match, equalTo(List.of( MatchSegment.match("loc: MatchSegment.comment("<VType>"), MatchSegment.comment("(initial value)")))); match = proposal.getMatch(""); assertThat(match, equalTo(List.of( MatchSegment.normal("loc: match = proposal.getMatch("loc: assertThat(match, equalTo(List.of( MatchSegment.match("loc: MatchSegment.normal("<Type>"), MatchSegment.comment("(initial value)")))); match = proposal.getMatch("loc: assertThat(match, equalTo(List.of( MatchSegment.match("loc: MatchSegment.comment("<VType>"), MatchSegment.match("(42)", "(initial value)")))); } |
PreferencesReader { static String replaceProperties(final String value) { if (value == null) return value; String result = value; Matcher matcher = PROP_PATTERN.matcher(value); while (matcher.find()) { final String prop_spec = matcher.group(); final String prop_name = prop_spec.substring(2, prop_spec.length()-1); final int start = matcher.start(); final int end = matcher.end(); String prop = System.getProperty(prop_name); if (prop == null) prop = System.getenv(prop_name); if (prop == null) { Logger.getLogger(PreferencesReader.class.getPackageName()) .log(Level.SEVERE, "Reading Preferences: Java system property or Environment variable'" + prop_spec + "' is not defined"); break; } else result = result.substring(0, start) + prop + result.substring(end); matcher = PROP_PATTERN.matcher(result); } return result; } PreferencesReader(final Class<?> package_class, final String preferences_properties_filename); Set<String> getKeys(final String regex); String get(final String key); boolean getBoolean(final String key); int getInt(final String key); double getDouble(final String key); } | @Test public void testProperties() { System.out.println(PreferencesReader.replaceProperties("Running on Java $(java.version) in $(java.home)")); System.out.println("Expect warning about undefined property"); assertThat(PreferencesReader.replaceProperties("$(VeryUnlikelyToExist)"), equalTo("$(VeryUnlikelyToExist)")); System.setProperty("test", "OK"); assertThat(PreferencesReader.replaceProperties("$(test)"), equalTo("OK")); assertThat(PreferencesReader.replaceProperties("This is $(test)"), equalTo("This is OK")); } |
UpdateThrottle { public UpdateThrottle(final long dormant_time, final TimeUnit unit, final Runnable update) { this(dormant_time, unit, update, TIMER); } UpdateThrottle(final long dormant_time, final TimeUnit unit, final Runnable update); UpdateThrottle(final long dormant_time, final TimeUnit unit, final Runnable update, final ScheduledExecutorService timer); void setDormantTime(final long dormant_time, final TimeUnit unit); void trigger(); void dispose(); static final ScheduledExecutorService TIMER; } | @Test(timeout=5000) public void testUpdateThrottle() throws Exception { final Runnable update = new Runnable() { @Override public void run() { System.out.println("<- Update!"); updates.incrementAndGet(); synchronized (this) { notifyAll(); } } }; final UpdateThrottle throttle = new UpdateThrottle(1L, TimeUnit.SECONDS, update); assertThat(updates.get(), equalTo(0)); System.out.println("-> Trigger.."); throttle.trigger(); Thread.sleep(100); assertThat(updates.get(), equalTo(1)); System.out.println("-> Trigger.."); throttle.trigger(); System.out.println("-> Trigger.."); throttle.trigger(); System.out.println("-> Trigger.."); throttle.trigger(); assertThat(updates.get(), equalTo(1)); TimeUnit.SECONDS.sleep(2); assertThat(updates.get(), equalTo(2)); throttle.setDormantTime(500, TimeUnit.MILLISECONDS); throttle.trigger(); TimeUnit.MILLISECONDS.sleep(100); assertThat(updates.get(), equalTo(3)); throttle.trigger(); TimeUnit.MILLISECONDS.sleep(100); assertThat(updates.get(), equalTo(3)); TimeUnit.MILLISECONDS.sleep(500); assertThat(updates.get(), equalTo(4)); } |
FormatOptionHandler { public static String format(final VType value, final FormatOption option, int precision, final boolean show_units) { precision = actualPrecision(value, precision); if (value == null) return "<null>"; if (value instanceof VNumber) { final VNumber number = (VNumber) value; final String text = formatNumber(number.getValue(), number.getDisplay(), option, precision); if (show_units && !number.getDisplay().getUnit().isEmpty()) return text + " " + number.getDisplay().getUnit(); return text; } else if (value instanceof VString) return ((VString)value).getValue(); else if (value instanceof VEnum) return formatEnum((VEnum) value, option); else if (value instanceof VBoolean) return formatBoolean((VBoolean)value); else if (value instanceof VNumberArray) { final VNumberArray array = (VNumberArray) value; if (option == FormatOption.STRING) return LongString.fromArray(array); final ListNumber data = array.getData(); if (data.size() <= 0) return "[]"; final StringBuilder buf = new StringBuilder("["); buf.append(formatNumber(data.getDouble(0), array.getDisplay(), option, precision)); final int show = Math.min(data.size(), Preferences.max_array_formatting); for (int i=1; i<show; ++i) { buf.append(", "); buf.append(formatNumber(data.getDouble(i), array.getDisplay(), option, precision)); } if (data.size() > show) buf.append(", ..."); buf.append("]"); if (show_units && !array.getDisplay().getUnit().isEmpty()) buf.append(" ").append(array.getDisplay().getUnit()); return buf.toString(); } else if (value instanceof VEnumArray) { final List<String> labels = ((VEnumArray)value).getDisplay().getChoices(); final StringBuilder buf = new StringBuilder("["); for (int i=0; i<labels.size(); ++i) { if (i > 0) buf.append(", "); buf.append(labels.get(i)); } buf.append("]"); return buf.toString(); } else if (value instanceof VStringArray) return StringList.join(((VStringArray)value).getData()); else if (value instanceof VImage) { final VImage image = (VImage) value; return "VImage(" + image.getWidth() + " x " + image.getHeight() + ")"; } else if (value instanceof VTable) return formatTable((VTable) value); return "<" + value.getClass().getName() + ">"; } static int actualPrecision(final VType value, int precision); static String format(final VType value, final FormatOption option,
int precision, final boolean show_units); static Object parse(final VType value, String text, final FormatOption format); } | @Test public void testNaNInf() throws Exception { VType number = VDouble.of(Double.NaN, Alarm.none(), Time.now(), display); String text = FormatOptionHandler.format(number, FormatOption.DEFAULT, -1, true); System.out.println(text); assertThat(text, equalTo("NaN V")); number = VDouble.of(Double.POSITIVE_INFINITY, Alarm.none(), Time.now(), display); text = FormatOptionHandler.format(number, FormatOption.DEFAULT, -1, true); System.out.println(text); assertThat(text, equalTo("Infinity V")); number = VDouble.of(Double.NEGATIVE_INFINITY, Alarm.none(), Time.now(), display); text = FormatOptionHandler.format(number, FormatOption.DEFAULT, -1, true); System.out.println(text); assertThat(text, equalTo("-Infinity V")); }
@Test public void testDecimal() throws Exception { VType number = VDouble.of(3.16, Alarm.none(), Time.now(), display); assertThat(fmt.format(3.16), equalTo("3.16")); String text = FormatOptionHandler.format(number, FormatOption.DEFAULT, -1, true); System.out.println(text); assertThat(text, equalTo("3.160 V")); text = FormatOptionHandler.format(number, FormatOption.DEFAULT, -1, false); System.out.println(text); assertThat(text, equalTo("3.160")); text = FormatOptionHandler.format(number, FormatOption.DECIMAL, 4, true); System.out.println(text); assertThat(text, equalTo("3.1600 V")); text = FormatOptionHandler.format(number, FormatOption.DECIMAL, 1, true); System.out.println(text); assertThat(text, equalTo("3.2 V")); text = FormatOptionHandler.format(number, FormatOption.DECIMAL, 4, true); System.out.println(text); assertThat(text, equalTo("3.1600 V")); }
@Test public void testEnum() throws Exception { final VEnum value = VEnum.of(1, EnumDisplay.of("One", "Two"), Alarm.none(), Time.now()); String text = FormatOptionHandler.format(value, FormatOption.DECIMAL, 4, true); System.out.println(text); assertThat(text, equalTo("1")); text = FormatOptionHandler.format(value, FormatOption.DEFAULT, -4, true); System.out.println(text); assertThat(text, equalTo("Two")); }
@Test public void testExponential() throws Exception { VType number = VDouble.of(3.16, Alarm.none(), Time.now(), display); String text = FormatOptionHandler.format(number, FormatOption.DEFAULT, -1, true); System.out.println(text); assertThat(text, equalTo("3.160 V")); text = FormatOptionHandler.format(number, FormatOption.EXPONENTIAL, 3, true); System.out.println(text); assertThat(text, equalTo("3.160E0 V")); text = FormatOptionHandler.format(number, FormatOption.EXPONENTIAL, 1, true); System.out.println(text); assertThat(text, equalTo("3.2E0 V")); }
@Test public void testEngineering() throws Exception { VType number = VDouble.of(0.0316, Alarm.none(), Time.now(), display); String text = FormatOptionHandler.format(number, FormatOption.ENGINEERING, 1, true); System.out.println(text); assertThat(text, equalTo("31.6E-3 V")); text = FormatOptionHandler.format(number, FormatOption.ENGINEERING, 3, false); System.out.println(text); assertThat(text, equalTo("31.600E-3")); text = FormatOptionHandler.format(number, FormatOption.ENGINEERING, 4, true); System.out.println(text); assertThat(text, equalTo("31.6000E-3 V")); number = VDouble.of(12345678.0, Alarm.none(), Time.now(), display); text = FormatOptionHandler.format(number, FormatOption.ENGINEERING, 2, true); System.out.println(text); assertThat(text, equalTo("12.35E6 V")); text = FormatOptionHandler.format(number, FormatOption.ENGINEERING, 3, true); System.out.println(text); assertThat(text, equalTo("12.346E6 V")); number = VDouble.of(3.14, Alarm.none(), Time.now(), display); text = FormatOptionHandler.format(number, FormatOption.ENGINEERING, 10, true); System.out.println(text); assertThat(text, equalTo("3.1400000000E0 V")); }
@Test public void testHexFormat() throws Exception { VType number = VDouble.of(65535.0, Alarm.none(), Time.now(), display); String text = FormatOptionHandler.format(number, FormatOption.HEX, 4, true); System.out.println(text); assertThat(text, equalTo("0xFFFF V")); text = FormatOptionHandler.format(number, FormatOption.HEX, 8, true); System.out.println(text); assertThat(text, equalTo("0x0000FFFF V")); text = FormatOptionHandler.format(number, FormatOption.HEX, 16, true); System.out.println(text); assertThat(text, equalTo("0x000000000000FFFF V")); }
@Test public void testString() throws Exception { VType value = VString.of("Test1", Alarm.none(), Time.now()); String text = FormatOptionHandler.format(value, FormatOption.DEFAULT, -1, true); System.out.println(text); assertThat(text, equalTo("Test1")); text = FormatOptionHandler.format(value, FormatOption.STRING, -1, true); System.out.println(text); assertThat(text, equalTo("Test1")); text = FormatOptionHandler.format(value, FormatOption.EXPONENTIAL, -1, true); System.out.println(text); assertThat(text, equalTo("Test1")); value = VDouble.of(65.0, Alarm.none(), Time.now(), display); text = FormatOptionHandler.format(value, FormatOption.STRING, -1, true); System.out.println(text); assertThat(text, equalTo("A V")); ListNumber data = ArrayInteger.of(72, 101, 108, 108, 111); value = VIntArray.of(data, Alarm.none(), Time.now(), display); System.out.println(value); text = FormatOptionHandler.format(value, FormatOption.STRING, -1, true); System.out.println(text); assertThat(text, equalTo("Hello")); data = ArrayInteger.of( 0x24, 0xE2, 0x82, 0xAC); value = VIntArray.of(data, Alarm.none(), Time.now(), display); System.out.println(value); text = FormatOptionHandler.format(value, FormatOption.STRING, -1, true); System.out.println(text); assertThat(text, equalTo("$€")); }
@Test public void testCompact() throws Exception { String text = FormatOptionHandler.format(VDouble.of(65.43, Alarm.none(), Time.now(), display), FormatOption.COMPACT, 2, true); System.out.println(text); assertThat(text, equalTo("65.43 V")); text = FormatOptionHandler.format(VDouble.of(0.00006543, Alarm.none(), Time.now(), display), FormatOption.COMPACT, 2, true); System.out.println(text); assertThat(text, equalTo("6.54E-5 V")); text = FormatOptionHandler.format(VDouble.of(65430000.0, Alarm.none(), Time.now(), display), FormatOption.COMPACT, 2, true); System.out.println(text); assertThat(text, equalTo("6.54E7 V")); }
@Test public void testBinary() throws Exception { String text = FormatOptionHandler.format(VLong.of(0b101010, Alarm.none(), Time.now(), display), FormatOption.BINARY, 10, true); System.out.println(text); assertThat(text, equalTo("0b0000101010 V")); text = FormatOptionHandler.format(VLong.of(0b101010, Alarm.none(), Time.now(), display), FormatOption.BINARY, 0, false); System.out.println(text); assertThat(text, equalTo("0b101010")); }
@Test public void testArray() throws Exception { final ListNumber data = ArrayDouble.of(1.0, 2.0, 3.0, 4.0); VType value = VNumberArray.of(data, Alarm.none(), Time.now(), display); System.out.println(value); String text = FormatOptionHandler.format(value, FormatOption.DEFAULT, 0, true); System.out.println(text); assertThat(text, equalTo("[1, 2, 3, 4] V")); text = FormatOptionHandler.format(value, FormatOption.DECIMAL, 2, true); System.out.println(text); assertThat(text, equalTo("[1.00, 2.00, 3.00, 4.00] V")); }
@Test public void testSexagesimalFormat() throws Exception { final VType sexaPositiveValue = VDouble.of(12.5824414, Alarm.none(), Time.now(), display), sexaNegativeValue = VDouble.of(-12.5824414, Alarm.none(), Time.now(), display), sexaRoundedValue = VDouble.of(12.9999999, Alarm.none(), Time.now(), display); assertThat(FormatOptionHandler.format(sexaPositiveValue, FormatOption.SEXAGESIMAL, 7, false), equalTo("12:34:56.789")); assertThat(FormatOptionHandler.format(sexaPositiveValue, FormatOption.SEXAGESIMAL, 2, false), equalTo("12:35")); assertThat(FormatOptionHandler.format(sexaPositiveValue, FormatOption.SEXAGESIMAL, 4, false), equalTo("12:34:57")); assertThat(FormatOptionHandler.format(sexaNegativeValue, FormatOption.SEXAGESIMAL, 7, false), equalTo("-12:34:56.789")); assertThat(FormatOptionHandler.format(sexaRoundedValue, FormatOption.SEXAGESIMAL, 7, false), equalTo("13:00:00.000")); assertThat(FormatOptionHandler.format(sexaRoundedValue, FormatOption.SEXAGESIMAL, 8, false), equalTo("12:59:59.9996")); assertThat(FormatOptionHandler.format(VDouble.of(2*Math.PI, Alarm.none(), Time.now(), display), FormatOption.SEXAGESIMAL_HMS, 7, false), equalTo("24:00:00.000")); assertThat(FormatOptionHandler.format(sexaPositiveValue, FormatOption.SEXAGESIMAL_HMS, 7, false), equalTo("48:03:40.989")); assertThat(FormatOptionHandler.format(sexaNegativeValue, FormatOption.SEXAGESIMAL_HMS, 7, false), equalTo("-48:03:40.989")); assertThat(FormatOptionHandler.format(VDouble.of(2*Math.PI, Alarm.none(), Time.now(), display), FormatOption.SEXAGESIMAL_DMS, 7, false), equalTo("360:00:00.000")); assertThat(FormatOptionHandler.format(sexaPositiveValue, FormatOption.SEXAGESIMAL_DMS, 7, false), equalTo("720:55:14.837")); assertThat(FormatOptionHandler.format(sexaNegativeValue, FormatOption.SEXAGESIMAL_DMS, 7, false), equalTo("-720:55:14.837")); assertThat(FormatOptionHandler.format(sexaRoundedValue, FormatOption.SEXAGESIMAL_DMS, 7, false), equalTo("744:50:42.461")); } |
Services implements IServices { @Override public Node saveSnapshot(String configUniqueId, List<SnapshotItem> snapshotItems, String snapshotName, String userName, String comment) { logger.info("Saving snapshot for config id {}", configUniqueId); logger.info("Snapshot name: {}, values:", snapshotName); for (SnapshotItem snapshotItem : snapshotItems) { logger.info(snapshotItem.toString()); } return nodeDAO.saveSnapshot(configUniqueId, snapshotItems, snapshotName, comment, userName); } @Override Node getParentNode(String uniqueNodeId); @Override List<Node> getSnapshots(String configUniqueId); @Override Node getSnapshot(String snapshotUniqueId); @Override Node createNode(String parentsUniqueId, Node node); @Override @Transactional Node moveNode(String nodeId, String targetNodeId, String userName); @Override @Transactional void deleteNode(String nodeId); @Override @Transactional Node updateConfiguration(Node configToUpdate, List<ConfigPv> configPvs); @Override Node updateNode(Node nodeToUpdate); @Override Node updateNode(Node nodeToUpdate, boolean customTimeForMigration); @Override Node getNode(String nodeId); @Override List<Node> getChildNodes(String nodeUniqueId); @Override Node getRootNode(); @Override List<ConfigPv> getConfigPvs(String configUniqueId); @Override List<SnapshotItem> getSnapshotItems(String snapshotUniqueId); @Override Node saveSnapshot(String configUniqueId, List<SnapshotItem> snapshotItems, String snapshotName,
String userName, String comment); @Override List<Tag> getTags(String snapshotUniqueId); @Override List<Tag> getAllTags(); @Override List<Node> getFromPath(String path); @Override String getFullPath(String uniqueNodeId); } | @Test public void testSaveSnapshot() { when(nodeDAO.saveSnapshot("a", Collections.emptyList(), "b", "c", "d")).thenReturn(Node.builder().nodeType(NodeType.SNAPSHOT).build()); assertNotNull(services.saveSnapshot("a", Collections.emptyList(), "b", "d", "c")); } |
FormatOptionHandler { public static Object parse(final VType value, String text, final FormatOption format) { try { switch (format) { case STRING: return text; case HEX: { text = text.trim(); final int sep = text.lastIndexOf(' '); if (sep > 0) text = text.substring(0, sep).trim(); text = text.toUpperCase(); if (text.startsWith("0X")) text = text.substring(2); return Long.parseLong(text, 16); } case BINARY: { text = text.trim(); final int sep = text.lastIndexOf(' '); if (sep > 0) text = text.substring(0, sep).trim(); text = text.toUpperCase(); if (text.startsWith("0B")) text = text.substring(2); return Long.parseLong(text, 2); } case SEXAGESIMAL: return SexagesimalFormat.parse(text); case SEXAGESIMAL_HMS: return SexagesimalFormat.parse(text) * Math.PI / 12.0; case SEXAGESIMAL_DMS: return SexagesimalFormat.parse(text) * Math.PI / 180.0; default: if (value instanceof VNumber) { text = text.trim(); final int sep = text.lastIndexOf(' '); if (sep > 0) text = text.substring(0, sep).trim(); if (text.startsWith("0x") || text.startsWith("0X")) { text = text.substring(2).toUpperCase(); return Long.parseLong(text, 16); } if (text.startsWith("0b") || text.startsWith("0B")) { text = text.substring(2); return Long.parseLong(text, 2); } if (value instanceof VDouble) return Double.parseDouble(text); return Long.parseLong(text); } if (value instanceof VEnum) { final List<String> labels = ((VEnum)value).getDisplay().getChoices(); text = text.trim(); for (int i=0; i<labels.size(); ++i) if (labels.get(i).equals(text)) return i; return text; } if (value instanceof VNumberArray) { text = text.trim(); if (text.startsWith("[")) text = text.substring(1); if (text.endsWith("]")) text = text.substring(0, text.length()-1); final String[] items = text.split(" *, *"); final double[] array = new double[items.length]; for (int i=0; i<array.length; ++i) array[i] = Double.parseDouble(items[i].trim()); return array; } if (value instanceof VStringArray) { final List<String> items = StringList.split(text); return items.toArray(new String[items.size()]); } } } catch (Throwable ex) { Logger.getLogger(FormatOptionHandler.class.getPackageName()) .log(Level.WARNING, "Error parsing value from '" + text + "', will use as is", ex); } return text; } static int actualPrecision(final VType value, int precision); static String format(final VType value, final FormatOption option,
int precision, final boolean show_units); static Object parse(final VType value, String text, final FormatOption format); } | @Test public void testHexParse() throws Exception { final VType number = VDouble.of(65535.0, Alarm.none(), Time.now(), display); Object parsed = FormatOptionHandler.parse(number, "0xFF", FormatOption.HEX); System.out.println(parsed); assertThat(parsed, instanceOf(Number.class)); assertThat(((Number)parsed).intValue(), equalTo(255)); parsed = FormatOptionHandler.parse(number, "0x7777", FormatOption.DEFAULT); System.out.println(parsed); assertThat(parsed, instanceOf(Number.class)); assertThat(((Number)parsed).intValue(), equalTo(30583)); parsed = FormatOptionHandler.parse(number, "0xFFFF", FormatOption.HEX); System.out.println(parsed); assertThat(parsed, instanceOf(Number.class)); assertThat(((Number)parsed).intValue(), equalTo(65535)); }
@Test public void testBinaryParse() throws Exception { final VType number = VLong.of(0b101010, Alarm.none(), Time.now(), display); Object parsed = FormatOptionHandler.parse(number, "0b0000101010", FormatOption.BINARY); System.out.println(parsed); assertThat(parsed, instanceOf(Number.class)); assertThat(((Number)parsed).intValue(), equalTo(42)); parsed = FormatOptionHandler.parse(number, "0b1111111111111111", FormatOption.DEFAULT); System.out.println(parsed); assertThat(parsed, instanceOf(Number.class)); assertThat(((Number)parsed).intValue(), equalTo(65535)); parsed = FormatOptionHandler.parse(number, "0000101010", FormatOption.BINARY); System.out.println(parsed); assertThat(parsed, instanceOf(Number.class)); assertThat(((Number)parsed).intValue(), equalTo(42)); }
@Test public void testSexagesimalParser() throws Exception { final VType number = VDouble.of(0.0, Alarm.none(), Time.now(), display); assertEquals(12.5824414, (Double)FormatOptionHandler.parse(number, "12:34:56.789", FormatOption.SEXAGESIMAL), 0.0000001); assertEquals(Math.PI, (Double)FormatOptionHandler.parse(number, "12:00:00.000", FormatOption.SEXAGESIMAL_HMS), 0.0000001); assertEquals(12.5824414, (Double)FormatOptionHandler.parse(number, "48:03:40.989", FormatOption.SEXAGESIMAL_HMS), 0.0000001); assertEquals(Math.PI, (Double)FormatOptionHandler.parse(number, "180:00:00.000", FormatOption.SEXAGESIMAL_DMS), 0.0000001); assertEquals(12.5824414, (Double)FormatOptionHandler.parse(number, "720:55:14.837", FormatOption.SEXAGESIMAL_DMS), 0.0000001); }
@Test public void testNumberParsing() throws Exception { VType value = VDouble.of(3.16, Alarm.none(), Time.now(), display); Object parsed = FormatOptionHandler.parse(value, "42.5 Socks", FormatOption.DEFAULT); assertThat(parsed, instanceOf(Number.class)); assertThat(((Number)parsed).doubleValue(), equalTo(42.5)); }
@Test public void testNumberArrayParsing() throws Exception { final ListNumber data = ArrayDouble.of(1.0, 2.0, 3.0, 4.0); final VType value = VNumberArray.of(data, Alarm.none(), Time.now(), display); Object parsed = FormatOptionHandler.parse(value, " [ 1, 2.5 , 3 ] ", FormatOption.DEFAULT); assertThat(parsed, instanceOf(double[].class)); final double[] numbers = (double[]) parsed; assertThat(numbers, equalTo(new double[] { 1.0, 2.5, 3.0 })); } |
Services implements IServices { @Override public List<Node> getFromPath(String path){ return nodeDAO.getFromPath(path); } @Override Node getParentNode(String uniqueNodeId); @Override List<Node> getSnapshots(String configUniqueId); @Override Node getSnapshot(String snapshotUniqueId); @Override Node createNode(String parentsUniqueId, Node node); @Override @Transactional Node moveNode(String nodeId, String targetNodeId, String userName); @Override @Transactional void deleteNode(String nodeId); @Override @Transactional Node updateConfiguration(Node configToUpdate, List<ConfigPv> configPvs); @Override Node updateNode(Node nodeToUpdate); @Override Node updateNode(Node nodeToUpdate, boolean customTimeForMigration); @Override Node getNode(String nodeId); @Override List<Node> getChildNodes(String nodeUniqueId); @Override Node getRootNode(); @Override List<ConfigPv> getConfigPvs(String configUniqueId); @Override List<SnapshotItem> getSnapshotItems(String snapshotUniqueId); @Override Node saveSnapshot(String configUniqueId, List<SnapshotItem> snapshotItems, String snapshotName,
String userName, String comment); @Override List<Tag> getTags(String snapshotUniqueId); @Override List<Tag> getAllTags(); @Override List<Node> getFromPath(String path); @Override String getFullPath(String uniqueNodeId); } | @Test public void testGetFromPath(){ Node node = Node.builder().name("SomeFolder").build(); when(nodeDAO.getFromPath("path")).thenReturn(Arrays.asList(node)); assertEquals("SomeFolder", services.getFromPath("path").get(0).getName()); } |
ArrayScalarDivisionFunction extends BaseArrayFunction { @Override public VType compute(VType... args) { if(VTypeHelper.isNumericArray(args[0]) && args[1] instanceof VNumber){ VNumberArray array1 = (VNumberArray)args[0]; VNumber factor = (VNumber) args[1]; return VNumberArray.of( ListMath.rescale(array1.getData(), 1d / factor.getValue().doubleValue(), 0), Alarm.none(), Time.now(), Display.none()); } else{ return DEFAULT_NAN_DOUBLE_ARRAY; } } @Override String getName(); @Override String getDescription(); @Override List<String> getArguments(); @Override VType compute(VType... args); } | @Test public void compute(){ ArrayScalarDivisionFunction arrayScalarDivisionFunction = new ArrayScalarDivisionFunction(); assertEquals("arrayDivScalar", arrayScalarDivisionFunction.getName()); assertEquals("array", arrayScalarDivisionFunction.getCategory()); VType array = VNumberArray.of(ArrayDouble.of(2.0, 10.0, 30.0), Alarm.of(AlarmSeverity.MAJOR, AlarmStatus.NONE, ""), Time.now(), Display.none()); VType factor = VDouble.of(2.0, Alarm.none(), Time.now(), Display.none()); VNumberArray result = (VNumberArray)arrayScalarDivisionFunction.compute(array, factor); assertEquals(3, result.getData().size()); assertEquals(1, result.getData().getInt(0)); assertEquals(5, result.getData().getInt(1)); assertEquals(15, result.getData().getInt(2)); result = (VNumberArray)arrayScalarDivisionFunction.compute(array, array); assertTrue(Double.valueOf(result.getData().getDouble(0)).equals(Double.NaN)); } |
ArrayMinFunction extends BaseArrayFunction { @Override public VType compute(VType... args) { if (VTypeHelper.isNumericArray(args[0])) { return VDouble.of(Arrays.stream(VTypeHelper.toDoubles(args[0])).summaryStatistics().getMin(), Alarm.none(), Time.now(), Display.none()); } else { return DEFAULT_NAN_DOUBLE_ARRAY; } } @Override String getName(); @Override String getDescription(); @Override List<String> getArguments(); @Override VType compute(VType... args); } | @Test public void compute() { ArrayMinFunction arrayMinFunction = new ArrayMinFunction(); assertEquals("arrayMin", arrayMinFunction.getName()); assertEquals("array", arrayMinFunction.getCategory()); VNumberArray doubleArray = VNumberArray.of(ArrayDouble.of(-1.0, 0, 1.0, 2.0, 3.0, 4.0, 5), Alarm.none(), Time.now(), Display.none()); VDouble min = (VDouble) arrayMinFunction.compute(doubleArray); assertEquals("arrayMin Failed to calculate min for double array", Double.valueOf(-1.0), min.getValue()); VNumberArray intArray = VNumberArray.of(ArrayInteger.of(-1, 0, 1, 2, 3, 4, 5), Alarm.none(), Time.now(), Display.none()); min = (VDouble) arrayMinFunction.compute(intArray); assertEquals("arrayMin Failed to calculate min for int array", Double.valueOf(-1), min.getValue()); } |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.