Datasets:

Minata
/

1024src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Files and versions Community

Split (2)

train · 269k rows

method2testcases stringlengths 118 6.63k
### Question: Transaction { void observe( @Nonnull final ObservableValue<?> observableValue ) { if ( Arez.shouldCheckInvariants() ) { markTransactionAsUsed(); invariant( observableValue::isNotDisposed, () -> "Arez-0142: Invoked observe on transaction named '" + getName() + "' for observableValue " + "named '" + observableValue.getName() + "' where the observableValue is disposed." ); } if ( null != _tracker ) { if ( Arez.shouldCheckInvariants() ) { invariant( () -> !observableValue.isComputableValue() \|\| _tracker != observableValue.getObserver(), () -> "Arez-0143: Invoked observe on transaction named '" + getName() + "' for " + "observableValue named '" + observableValue.getName() + "' where the " + "observableValue is owned by the tracker." ); observableValue.invariantOwner(); } final int id = getId(); if ( observableValue.getLastTrackerTransactionId() != id ) { observableValue.setLastTrackerTransactionId( id ); safeGetObservables().add( observableValue ); } } } Transaction( @Nullable final ArezContext context, @Nullable final Transaction previous, @Nullable final String name, final boolean mutation, @Nullable final Observer tracker, final boolean zoneActivated ); @Nonnull @Override String toString(); }### Answer: @Test public void observe() { final ArezContext context = Arez.context(); final Observer tracker = context.computable( () -> "" ).getObserver(); final Transaction transaction = new Transaction( context, null, ValueUtil.randomString(), false, tracker, false ); Transaction.setTransaction( transaction ); transaction.beginTracking(); final ObservableValue<?> observableValue = context.observable(); assertEquals( tracker.getDependencies().size(), 0 ); assertEquals( observableValue.getObservers().size(), 0 ); assertNull( transaction.getObservableValues() ); assertNotEquals( transaction.getId(), observableValue.getLastTrackerTransactionId() ); assertFalse( transaction.hasTransactionUseOccured() ); transaction.observe( observableValue ); assertEquals( tracker.getDependencies().size(), 0 ); assertEquals( observableValue.getObservers().size(), 0 ); assertEquals( transaction.getId(), observableValue.getLastTrackerTransactionId() ); assertNotNull( transaction.getObservableValues() ); assertTrue( transaction.getObservableValues().contains( observableValue ) ); assertEquals( transaction.getObservableValues().size(), 1 ); assertTrue( transaction.hasTransactionUseOccured() ); }
### Question: Transaction { @Nonnull String getName() { if ( Arez.shouldCheckInvariants() ) { invariant( Arez::areNamesEnabled, () -> "Arez-0133: Transaction.getName() invoked when Arez.areNamesEnabled() is false" ); } assert null != _name; return _name; } Transaction( @Nullable final ArezContext context, @Nullable final Transaction previous, @Nullable final String name, final boolean mutation, @Nullable final Observer tracker, final boolean zoneActivated ); @Nonnull @Override String toString(); }### Answer: @Test public void processPendingDeactivations_calledOnNonRootTransaction() { final ArezContext context = Arez.context(); final Transaction transaction1 = new Transaction( context, null, ValueUtil.randomString(), false, null, false ); final Transaction transaction2 = new Transaction( context, transaction1, ValueUtil.randomString(), false, null, false ); assertInvariantFailure( transaction2::processPendingDeactivations, "Arez-0138: Invoked processPendingDeactivations on transaction named '" + transaction2.getName() + "' which is not the root transaction." ); } @Test public void getPreviousInSameContext_zonesNotEnabled() { ArezTestUtil.disableZones(); final Transaction transaction = new Transaction( null, null, ValueUtil.randomString(), false, null, false ); assertInvariantFailure( transaction::getPreviousInSameContext, "Arez-0137: Attempted to invoke getPreviousInSameContext() on transaction named '" + transaction.getName() + "' when zones are not enabled." ); }
### Question: Transaction { void verifyWriteAllowed( @Nonnull final ObservableValue<?> observableValue ) { if ( Arez.shouldEnforceTransactionType() && Arez.shouldCheckInvariants() ) { if ( isComputableValueTracker() ) { invariant( () -> observableValue.isComputableValue() && observableValue.getObserver() == _tracker, () -> "Arez-0153: Transaction named '" + getName() + "' attempted to change" + " ObservableValue named '" + observableValue.getName() + "' and the transaction mode is " + "READ_WRITE_OWNED but the ObservableValue has not been created by the transaction." ); } else if ( !isMutation() ) { fail( () -> "Arez-0152: Transaction named '" + getName() + "' attempted to change ObservableValue named '" + observableValue.getName() + "' but the transaction mode is READ_ONLY." ); } } } Transaction( @Nullable final ArezContext context, @Nullable final Transaction previous, @Nullable final String name, final boolean mutation, @Nullable final Observer tracker, final boolean zoneActivated ); @Nonnull @Override String toString(); }### Answer: @Test public void verifyWriteAllowed_withReadOnlyTransaction_enforceTransactionType_set_to_false() { ArezTestUtil.noEnforceTransactionType(); final ArezContext context = Arez.context(); final Transaction transaction = new Transaction( context, null, ValueUtil.randomString(), false, null, false ); final ObservableValue<?> observableValue = context.observable(); transaction.verifyWriteAllowed( observableValue ); } @Test public void verifyWriteAllowed_withReadWriteTransaction() { final ArezContext context = Arez.context(); final Transaction transaction = new Transaction( context, null, ValueUtil.randomString(), true, null, false ); final ObservableValue<?> observableValue = context.observable(); transaction.verifyWriteAllowed( observableValue ); }
### Question: Transaction { void reportChangeConfirmed( @Nonnull final ObservableValue<?> observableValue ) { if ( Arez.shouldCheckInvariants() ) { invariant( observableValue::isNotDisposed, () -> "Arez-0149: Invoked reportChangeConfirmed on transaction named '" + getName() + "' for ObservableValue named '" + observableValue.getName() + "' where the ObservableValue is disposed." ); invariant( observableValue::isComputableValue, () -> "Arez-0150: Transaction named '" + getName() + "' has attempted to mark " + "ObservableValue named '" + observableValue.getName() + "' as potentially changed " + "but ObservableValue is not a derived value." ); observableValue.invariantLeastStaleObserverState(); } verifyWriteAllowed( observableValue ); if ( observableValue.hasObservers() && Observer.Flags.STATE_STALE != observableValue.getLeastStaleObserverState() ) { observableValue.setLeastStaleObserverState( Observer.Flags.STATE_STALE ); for ( final Observer observer : observableValue.getObservers() ) { if ( Observer.Flags.STATE_POSSIBLY_STALE == observer.getState() ) { observer.setState( Observer.Flags.STATE_STALE ); } else if ( Observer.Flags.STATE_UP_TO_DATE == observer.getState() ) { if ( Arez.shouldCheckInvariants() && !observer.isComputableValue() && !( observableValue.isComputableValue() && observer.getTask().getPriorityIndex() <= observableValue.getObserver().getTask().getPriorityIndex() ) ) { invariantObserverIsTracker( observableValue, observer ); } observableValue.setLeastStaleObserverState( Observer.Flags.STATE_UP_TO_DATE ); } } } if ( Arez.shouldCheckInvariants() ) { observableValue.invariantLeastStaleObserverState(); } } Transaction( @Nullable final ArezContext context, @Nullable final Transaction previous, @Nullable final String name, final boolean mutation, @Nullable final Observer tracker, final boolean zoneActivated ); @Nonnull @Override String toString(); }### Answer: @Test public void reportChangeConfirmed_singleUpToDateObserver() { final ArezContext context = Arez.context(); final Observer calculator = context.computable( () -> "" ).getObserver(); setCurrentTransaction( calculator ); calculator.setState( Observer.Flags.STATE_UP_TO_DATE ); final ObservableValue<?> observableValue = calculator.getComputableValue().getObservableValue(); observableValue.setLeastStaleObserverState( Observer.Flags.STATE_UP_TO_DATE ); calculator.getDependencies().add( observableValue ); observableValue.getObservers().add( calculator ); context.getTransaction().reportChangeConfirmed( observableValue ); assertEquals( observableValue.getLeastStaleObserverState(), Observer.Flags.STATE_UP_TO_DATE ); assertEquals( calculator.getState(), Observer.Flags.STATE_UP_TO_DATE ); }
### Question: Transaction { @Nonnull static Transaction current() { if ( Arez.shouldCheckInvariants() ) { invariant( () -> null != c_transaction, () -> "Arez-0117: Attempting to get current transaction but no transaction is active." ); } assert null != c_transaction; return c_transaction; } Transaction( @Nullable final ArezContext context, @Nullable final Transaction previous, @Nullable final String name, final boolean mutation, @Nullable final Observer tracker, final boolean zoneActivated ); @Nonnull @Override String toString(); }### Answer: @Test public void current() { final ArezContext context = Arez.context(); final Transaction transaction = new Transaction( context, null, ValueUtil.randomString(), false, null, false ); transaction.begin(); Transaction.setTransaction( transaction ); assertEquals( Transaction.current(), transaction ); }
### Question: Transaction { static boolean isTransactionActive( @Nonnull final ArezContext context ) { return null != c_transaction && ( !Arez.areZonesEnabled() \|\| c_transaction.getContext() == context ); } Transaction( @Nullable final ArezContext context, @Nullable final Transaction previous, @Nullable final String name, final boolean mutation, @Nullable final Observer tracker, final boolean zoneActivated ); @Nonnull @Override String toString(); }### Answer: @Test public void isTransactionActive() { final ArezContext context = Arez.context(); final Transaction transaction = new Transaction( context, null, ValueUtil.randomString(), false, null, false ); transaction.begin(); assertFalse( Transaction.isTransactionActive( context ) ); Transaction.setTransaction( transaction ); assertTrue( Transaction.isTransactionActive( context ) ); }
### Question: Transaction { void reportDispose( @Nonnull final Disposable disposable ) { if ( Arez.shouldCheckInvariants() ) { invariant( disposable::isNotDisposed, () -> "Arez-0176: Invoked reportDispose on transaction named '" + getName() + "' where the element is disposed." ); invariant( () -> !Arez.shouldEnforceTransactionType() \|\| isMutation(), () -> "Arez-0177: Invoked reportDispose on transaction named '" + getName() + "' but the transaction mode is not READ_WRITE but is READ_ONLY." ); } } Transaction( @Nullable final ArezContext context, @Nullable final Transaction previous, @Nullable final String name, final boolean mutation, @Nullable final Observer tracker, final boolean zoneActivated ); @Nonnull @Override String toString(); }### Answer: @Test public void reportDispose() { final Transaction transaction = new Transaction( Arez.context(), null, ValueUtil.randomString(), true, null, false ); final MyDisposable node = new MyDisposable(); transaction.reportDispose( node ); node.dispose(); assertInvariantFailure( () -> transaction.reportDispose( node ), "Arez-0176: Invoked reportDispose on transaction named '" + transaction.getName() + "' where the element is disposed." ); }
### Question: ComputableValueInfoImpl implements ComputableValueInfo { @Override public boolean isActive() { return _computableValue.getObserver().isActive(); } ComputableValueInfoImpl( @Nonnull final ComputableValue<?> computableValue ); @Nonnull @Override String getName(); @Override boolean isComputing(); @Nonnull @Override Priority getPriority(); @Override boolean isActive(); @Nonnull @Override List<ObservableValueInfo> getDependencies(); @Nonnull @Override List<ObserverInfo> getObservers(); @Nullable @Override ComponentInfo getComponent(); @OmitSymbol( unless = "arez.enable_property_introspection" ) @Nullable @Override Object getValue(); @Override boolean isDisposed(); @Override String toString(); @Override boolean equals( final Object o ); @Override int hashCode(); }### Answer: @Test public void isActive() { final ArezContext context = Arez.context(); final Spy spy = context.getSpy(); final ComputableValue<String> computableValue = context.computable( () -> "" ); assertFalse( spy.asComputableValueInfo( computableValue ).isActive() ); setupReadOnlyTransaction( context ); computableValue.getObserver().setState( Observer.Flags.STATE_UP_TO_DATE ); assertTrue( spy.asComputableValueInfo( computableValue ).isActive() ); }
### Question: Arez { @Nonnull public static ArezContext context() { return areZonesEnabled() ? ZoneHolder.context() : ArezContextHolder.context(); } private Arez(); @OmitSymbol static boolean areZonesEnabled(); @OmitSymbol static boolean areNamesEnabled(); @OmitSymbol static boolean isVerifyEnabled(); @OmitSymbol static boolean areSpiesEnabled(); @OmitSymbol static boolean areReferencesEnabled(); @OmitSymbol static boolean areCollectionsPropertiesUnmodifiable(); @OmitSymbol static boolean arePropertyIntrospectorsEnabled(); @OmitSymbol static boolean areRegistriesEnabled(); @OmitSymbol static boolean areNativeComponentsEnabled(); @OmitSymbol static boolean areObserverErrorHandlersEnabled(); @OmitSymbol static boolean isTaskInterceptorEnabled(); @OmitSymbol static boolean shouldCheckInvariants(); @OmitSymbol static boolean shouldCheckApiInvariants(); @OmitSymbol static boolean purgeTasksWhenRunawayDetected(); @Nonnull static ArezContext context(); @OmitSymbol( unless = "arez.enable_zones" ) @Nonnull static Zone createZone(); }### Answer: @Test public void context_when_zones_disabled() { ArezTestUtil.disableZones(); final ArezContext context1 = Arez.context(); assertNotNull( context1 ); final ArezContext context2 = Arez.context(); assertSame( context1, context2 ); }
### Question: Arez { @OmitSymbol( unless = "arez.enable_zones" ) static void activateZone( @Nonnull final Zone zone ) { ZoneHolder.activateZone( zone ); } private Arez(); @OmitSymbol static boolean areZonesEnabled(); @OmitSymbol static boolean areNamesEnabled(); @OmitSymbol static boolean isVerifyEnabled(); @OmitSymbol static boolean areSpiesEnabled(); @OmitSymbol static boolean areReferencesEnabled(); @OmitSymbol static boolean areCollectionsPropertiesUnmodifiable(); @OmitSymbol static boolean arePropertyIntrospectorsEnabled(); @OmitSymbol static boolean areRegistriesEnabled(); @OmitSymbol static boolean areNativeComponentsEnabled(); @OmitSymbol static boolean areObserverErrorHandlersEnabled(); @OmitSymbol static boolean isTaskInterceptorEnabled(); @OmitSymbol static boolean shouldCheckInvariants(); @OmitSymbol static boolean shouldCheckApiInvariants(); @OmitSymbol static boolean purgeTasksWhenRunawayDetected(); @Nonnull static ArezContext context(); @OmitSymbol( unless = "arez.enable_zones" ) @Nonnull static Zone createZone(); }### Answer: @Test public void activateZone_whenZonesNotEnabled() { ArezTestUtil.disableZones(); assertInvariantFailure( () -> Arez.activateZone( new Zone() ), "Arez-0002: Invoked Arez.activateZone() but zones are not enabled." ); }
### Question: Arez { @OmitSymbol( unless = "arez.enable_zones" ) static void deactivateZone( @Nonnull final Zone zone ) { ZoneHolder.deactivateZone( zone ); } private Arez(); @OmitSymbol static boolean areZonesEnabled(); @OmitSymbol static boolean areNamesEnabled(); @OmitSymbol static boolean isVerifyEnabled(); @OmitSymbol static boolean areSpiesEnabled(); @OmitSymbol static boolean areReferencesEnabled(); @OmitSymbol static boolean areCollectionsPropertiesUnmodifiable(); @OmitSymbol static boolean arePropertyIntrospectorsEnabled(); @OmitSymbol static boolean areRegistriesEnabled(); @OmitSymbol static boolean areNativeComponentsEnabled(); @OmitSymbol static boolean areObserverErrorHandlersEnabled(); @OmitSymbol static boolean isTaskInterceptorEnabled(); @OmitSymbol static boolean shouldCheckInvariants(); @OmitSymbol static boolean shouldCheckApiInvariants(); @OmitSymbol static boolean purgeTasksWhenRunawayDetected(); @Nonnull static ArezContext context(); @OmitSymbol( unless = "arez.enable_zones" ) @Nonnull static Zone createZone(); }### Answer: @Test public void deactivateZone_whenZonesNotEnabled() { ArezTestUtil.disableZones(); assertInvariantFailure( () -> Arez.deactivateZone( new Zone() ), "Arez-0003: Invoked Arez.deactivateZone() but zones are not enabled." ); } @Test public void deactivateZone_whenNotActive() { ArezTestUtil.enableZones(); assertInvariantFailure( () -> Arez.deactivateZone( new Zone() ), "Arez-0004: Attempted to deactivate zone that is not active." ); }
### Question: TransactionInfoImpl implements TransactionInfo { @Nonnull @Override public String getName() { return getTransaction().getName(); } TransactionInfoImpl( @Nonnull final Transaction transaction ); @Nonnull @Override String getName(); @Override boolean isReadOnly(); @Nullable @Override TransactionInfo getParent(); @Override boolean isTracking(); @Nonnull @Override ObserverInfo getTracker(); }### Answer: @Test public void getTracker_whenNoTracker() { final ArezContext context = Arez.context(); final Transaction transaction = new Transaction( context, null, ValueUtil.randomString(), true, null, false ); final TransactionInfo info = transaction.asInfo(); assertInvariantFailure( info::getTracker, "Invoked getTracker on TransactionInfo named '" + transaction.getName() + "' but no tracker exists." ); }
### Question: TaskInfoImpl implements TaskInfo { @Override public int hashCode() { return _task.hashCode(); } TaskInfoImpl( @Nonnull final Task task ); @Nonnull @Override String getName(); @Override boolean isIdle(); @Override boolean isScheduled(); @Nonnull @Override Priority getPriority(); @Override boolean isDisposed(); @Override String toString(); @Override boolean equals( final Object o ); @Override int hashCode(); }### Answer: @Test public void equalsAndHashCode() { final ArezContext context = Arez.context(); final Task task1 = context.task( ValueUtil::randomString ); final Task task2 = context.task( ValueUtil::randomString ); final TaskInfo info1a = task1.asInfo(); final TaskInfo info1b = new TaskInfoImpl( task1 ); final TaskInfo info2 = task2.asInfo(); assertNotEquals( "", info1a ); assertEquals( info1a, info1a ); assertEquals( info1a, info1b ); assertNotEquals( info1a, info2 ); assertEquals( info1b, info1a ); assertEquals( info1b, info1b ); assertNotEquals( info1b, info2 ); assertNotEquals( info2, info1a ); assertNotEquals( info2, info1b ); assertEquals( info2, info2 ); assertEquals( info1a.hashCode(), task1.hashCode() ); assertEquals( info1a.hashCode(), info1b.hashCode() ); assertEquals( info2.hashCode(), task2.hashCode() ); }
### Question: ObservableValueInfoImpl implements ObservableValueInfo { @Override public ComputableValueInfo asComputableValue() { return _observableValue.getObserver().getComputableValue().asInfo(); } ObservableValueInfoImpl( @Nonnull final ObservableValue<?> observableValue ); @Nonnull @Override String getName(); @Override boolean isComputableValue(); @Override ComputableValueInfo asComputableValue(); @Nonnull @Override List<ObserverInfo> getObservers(); @Nullable @Override ComponentInfo getComponent(); @Override boolean hasAccessor(); @Nullable @Override Object getValue(); @Override boolean hasMutator(); @SuppressWarnings( { "unchecked", "rawtypes" } ) @Override void setValue( @Nullable final Object value ); @Override boolean isDisposed(); @Override String toString(); @Override boolean equals( final Object o ); @Override int hashCode(); }### Answer: @Test public void asComputableValue() { final ArezContext context = Arez.context(); final String name = ValueUtil.randomString(); final ComputableValue<String> computableValue = context.computable( name, () -> "" ); final ObservableValue<String> observableValue = computableValue.getObservableValue(); final ObservableValueInfo info = observableValue.asInfo(); assertEquals( info.getName(), name ); assertTrue( info.isComputableValue() ); assertEquals( info.asComputableValue().getName(), computableValue.getName() ); }
### Question: ObservableValueInfoImpl implements ObservableValueInfo { @Override public int hashCode() { return _observableValue.hashCode(); } ObservableValueInfoImpl( @Nonnull final ObservableValue<?> observableValue ); @Nonnull @Override String getName(); @Override boolean isComputableValue(); @Override ComputableValueInfo asComputableValue(); @Nonnull @Override List<ObserverInfo> getObservers(); @Nullable @Override ComponentInfo getComponent(); @Override boolean hasAccessor(); @Nullable @Override Object getValue(); @Override boolean hasMutator(); @SuppressWarnings( { "unchecked", "rawtypes" } ) @Override void setValue( @Nullable final Object value ); @Override boolean isDisposed(); @Override String toString(); @Override boolean equals( final Object o ); @Override int hashCode(); }### Answer: @SuppressWarnings( "EqualsWithItself" ) @Test public void equalsAndHashCode() { final ArezContext context = Arez.context(); final ObservableValue<Object> observableValue1 = context.observable(); final ObservableValue<Object> observableValue2 = context.observable(); final ObservableValueInfo info1a = observableValue1.asInfo(); final ObservableValueInfo info1b = new ObservableValueInfoImpl( observableValue1 ); final ObservableValueInfo info2 = observableValue2.asInfo(); assertNotEquals( info1a, "" ); assertEquals( info1a, info1a ); assertEquals( info1b, info1a ); assertNotEquals( info2, info1a ); assertEquals( info1a, info1b ); assertEquals( info1b, info1b ); assertNotEquals( info2, info1b ); assertNotEquals( info1a, info2 ); assertNotEquals( info1b, info2 ); assertEquals( info2, info2 ); assertEquals( info1a.hashCode(), observableValue1.hashCode() ); assertEquals( info1a.hashCode(), info1b.hashCode() ); assertEquals( info2.hashCode(), observableValue2.hashCode() ); }
### Question: ObservableValueInfoImpl implements ObservableValueInfo { @Override public boolean isComputableValue() { return _observableValue.isComputableValue(); } ObservableValueInfoImpl( @Nonnull final ObservableValue<?> observableValue ); @Nonnull @Override String getName(); @Override boolean isComputableValue(); @Override ComputableValueInfo asComputableValue(); @Nonnull @Override List<ObserverInfo> getObservers(); @Nullable @Override ComponentInfo getComponent(); @Override boolean hasAccessor(); @Nullable @Override Object getValue(); @Override boolean hasMutator(); @SuppressWarnings( { "unchecked", "rawtypes" } ) @Override void setValue( @Nullable final Object value ); @Override boolean isDisposed(); @Override String toString(); @Override boolean equals( final Object o ); @Override int hashCode(); }### Answer: @Test public void isComputableValue() { final ArezContext context = Arez.context(); final Spy spy = context.getSpy(); assertTrue( spy.asObservableValueInfo( context.computable( () -> "" ).getObservableValue() ).isComputableValue() ); assertFalse( spy.asObservableValueInfo( context.observable() ).isComputableValue() ); }
### Question: ObservableValueInfoImpl implements ObservableValueInfo { @Nullable @Override public ComponentInfo getComponent() { if ( Arez.shouldCheckInvariants() ) { invariant( Arez::areNativeComponentsEnabled, () -> "Arez-0107: Spy.getComponent invoked when Arez.areNativeComponentsEnabled() returns false." ); } final Component component = _observableValue.getComponent(); return null == component ? null : component.asInfo(); } ObservableValueInfoImpl( @Nonnull final ObservableValue<?> observableValue ); @Nonnull @Override String getName(); @Override boolean isComputableValue(); @Override ComputableValueInfo asComputableValue(); @Nonnull @Override List<ObserverInfo> getObservers(); @Nullable @Override ComponentInfo getComponent(); @Override boolean hasAccessor(); @Nullable @Override Object getValue(); @Override boolean hasMutator(); @SuppressWarnings( { "unchecked", "rawtypes" } ) @Override void setValue( @Nullable final Object value ); @Override boolean isDisposed(); @Override String toString(); @Override boolean equals( final Object o ); @Override int hashCode(); }### Answer: @Test public void getComponent_Observable_nativeComponentsDisabled() { ArezTestUtil.disableNativeComponents(); final ArezContext context = Arez.context(); final ObservableValue<Object> value = context.observable(); assertInvariantFailure( () -> value.asInfo().getComponent(), "Arez-0107: Spy.getComponent invoked when Arez.areNativeComponentsEnabled() returns false." ); }
### Question: ComputableValueInfoImpl implements ComputableValueInfo { @Nonnull @Override public List<ObserverInfo> getObservers() { return ObserverInfoImpl.asUnmodifiableInfos( _computableValue.getObservableValue().getObservers() ); } ComputableValueInfoImpl( @Nonnull final ComputableValue<?> computableValue ); @Nonnull @Override String getName(); @Override boolean isComputing(); @Nonnull @Override Priority getPriority(); @Override boolean isActive(); @Nonnull @Override List<ObservableValueInfo> getDependencies(); @Nonnull @Override List<ObserverInfo> getObservers(); @Nullable @Override ComponentInfo getComponent(); @OmitSymbol( unless = "arez.enable_property_introspection" ) @Nullable @Override Object getValue(); @Override boolean isDisposed(); @Override String toString(); @Override boolean equals( final Object o ); @Override int hashCode(); }### Answer: @Test public void getObservers() { final ArezContext context = Arez.context(); final Spy spy = context.getSpy(); final ComputableValue<?> computableValue = context.computable( () -> "" ); assertEquals( spy.asComputableValueInfo( computableValue ).getObservers().size(), 0 ); final Observer observer = context.observer( new CountAndObserveProcedure() ); observer.getDependencies().add( computableValue.getObservableValue() ); computableValue.getObservableValue().getObservers().add( observer ); assertEquals( spy.asComputableValueInfo( computableValue ).getObservers().size(), 1 ); assertEquals( computableValue.getObservableValue().getObservers().size(), 1 ); assertUnmodifiable( spy.asComputableValueInfo( computableValue ).getObservers() ); }
### Question: SpyEventHandlerSupport { void removeSpyEventHandler( @Nonnull final SpyEventHandler handler ) { if ( Arez.shouldCheckApiInvariants() ) { apiInvariant( () -> _spyEventHandlers.contains( handler ), () -> "Arez-0103: Attempting to remove handler " + handler + " that is not " + "in the list of spy handlers." ); } _spyEventHandlers.remove( Objects.requireNonNull( handler ) ); } }### Answer: @Test public void removeSpyEventHandler_noExists() { final SpyEventHandlerSupport support = new SpyEventHandlerSupport(); final SpyEventHandler handler = new TestSpyEventHandler( Arez.context() ); assertInvariantFailure( () -> support.removeSpyEventHandler( handler ), "Arez-0103: Attempting to remove handler " + handler + " that is not in the list of spy handlers." ); }
### Question: ObservableValueInfoImpl implements ObservableValueInfo { @Nullable @Override public Object getValue() throws Throwable { if ( Arez.shouldCheckInvariants() ) { invariant( Arez::arePropertyIntrospectorsEnabled, () -> "Arez-0111: Spy.getValue invoked when Arez.arePropertyIntrospectorsEnabled() returns false." ); } final PropertyAccessor<?> accessor = _observableValue.getAccessor(); if ( Arez.shouldCheckApiInvariants() ) { apiInvariant( () -> null != accessor, () -> "Arez-0112: Spy.getValue invoked on ObservableValue named '" + _observableValue.getName() + "' but ObservableValue has no property accessor." ); } assert null != accessor; return accessor.get(); } ObservableValueInfoImpl( @Nonnull final ObservableValue<?> observableValue ); @Nonnull @Override String getName(); @Override boolean isComputableValue(); @Override ComputableValueInfo asComputableValue(); @Nonnull @Override List<ObserverInfo> getObservers(); @Nullable @Override ComponentInfo getComponent(); @Override boolean hasAccessor(); @Nullable @Override Object getValue(); @Override boolean hasMutator(); @SuppressWarnings( { "unchecked", "rawtypes" } ) @Override void setValue( @Nullable final Object value ); @Override boolean isDisposed(); @Override String toString(); @Override boolean equals( final Object o ); @Override int hashCode(); }### Answer: @Test public void observable_getValue_introspectorsDisabled() { ArezTestUtil.disablePropertyIntrospectors(); final ArezContext context = Arez.context(); final ObservableValue<Integer> computableValue1 = context.observable(); assertInvariantFailure( () -> context.action( () -> computableValue1.asInfo().getValue() ), "Arez-0111: Spy.getValue invoked when Arez.arePropertyIntrospectorsEnabled() returns false." ); }
### Question: ObservableValueInfoImpl implements ObservableValueInfo { @Override public boolean hasAccessor() { if ( Arez.shouldCheckInvariants() ) { invariant( Arez::arePropertyIntrospectorsEnabled, () -> "Arez-0110: Spy.hasAccessor invoked when Arez.arePropertyIntrospectorsEnabled() returns false." ); } return null != _observableValue.getAccessor(); } ObservableValueInfoImpl( @Nonnull final ObservableValue<?> observableValue ); @Nonnull @Override String getName(); @Override boolean isComputableValue(); @Override ComputableValueInfo asComputableValue(); @Nonnull @Override List<ObserverInfo> getObservers(); @Nullable @Override ComponentInfo getComponent(); @Override boolean hasAccessor(); @Nullable @Override Object getValue(); @Override boolean hasMutator(); @SuppressWarnings( { "unchecked", "rawtypes" } ) @Override void setValue( @Nullable final Object value ); @Override boolean isDisposed(); @Override String toString(); @Override boolean equals( final Object o ); @Override int hashCode(); }### Answer: @Test public void observable_hasAccessor_introspectorsDisabled() { ArezTestUtil.disablePropertyIntrospectors(); final ArezContext context = Arez.context(); final ObservableValue<Integer> observableValue = context.observable(); assertInvariantFailure( () -> context.action( () -> observableValue.asInfo().hasAccessor() ), "Arez-0110: Spy.hasAccessor invoked when Arez.arePropertyIntrospectorsEnabled() returns false." ); }
### Question: ObservableValueInfoImpl implements ObservableValueInfo { @Override public boolean hasMutator() { if ( Arez.shouldCheckInvariants() ) { invariant( Arez::arePropertyIntrospectorsEnabled, () -> "Arez-0113: Spy.hasMutator invoked when Arez.arePropertyIntrospectorsEnabled() returns false." ); } return null != _observableValue.getMutator(); } ObservableValueInfoImpl( @Nonnull final ObservableValue<?> observableValue ); @Nonnull @Override String getName(); @Override boolean isComputableValue(); @Override ComputableValueInfo asComputableValue(); @Nonnull @Override List<ObserverInfo> getObservers(); @Nullable @Override ComponentInfo getComponent(); @Override boolean hasAccessor(); @Nullable @Override Object getValue(); @Override boolean hasMutator(); @SuppressWarnings( { "unchecked", "rawtypes" } ) @Override void setValue( @Nullable final Object value ); @Override boolean isDisposed(); @Override String toString(); @Override boolean equals( final Object o ); @Override int hashCode(); }### Answer: @Test public void observable_hasMutator_introspectorsDisabled() { ArezTestUtil.disablePropertyIntrospectors(); final ArezContext context = Arez.context(); final ObservableValue<Integer> observableValue = context.observable(); assertInvariantFailure( () -> context.action( () -> observableValue.asInfo().hasMutator() ), "Arez-0113: Spy.hasMutator invoked when Arez.arePropertyIntrospectorsEnabled() returns false." ); }
### Question: ObservableValueInfoImpl implements ObservableValueInfo { @SuppressWarnings( { "unchecked", "rawtypes" } ) @Override public void setValue( @Nullable final Object value ) throws Throwable { if ( Arez.shouldCheckInvariants() ) { invariant( Arez::arePropertyIntrospectorsEnabled, () -> "Arez-0114: Spy.setValue invoked when Arez.arePropertyIntrospectorsEnabled() returns false." ); } final PropertyMutator mutator = _observableValue.getMutator(); if ( Arez.shouldCheckApiInvariants() ) { apiInvariant( () -> null != mutator, () -> "Arez-0115: Spy.setValue invoked on ObservableValue named '" + _observableValue.getName() + "' but ObservableValue has no property mutator." ); } assert null != mutator; mutator.set( value ); } ObservableValueInfoImpl( @Nonnull final ObservableValue<?> observableValue ); @Nonnull @Override String getName(); @Override boolean isComputableValue(); @Override ComputableValueInfo asComputableValue(); @Nonnull @Override List<ObserverInfo> getObservers(); @Nullable @Override ComponentInfo getComponent(); @Override boolean hasAccessor(); @Nullable @Override Object getValue(); @Override boolean hasMutator(); @SuppressWarnings( { "unchecked", "rawtypes" } ) @Override void setValue( @Nullable final Object value ); @Override boolean isDisposed(); @Override String toString(); @Override boolean equals( final Object o ); @Override int hashCode(); }### Answer: @Test public void observable_setValue_introspectorsDisabled() { ArezTestUtil.disablePropertyIntrospectors(); final ArezContext context = Arez.context(); final ObservableValue<Integer> observableValue = context.observable(); assertInvariantFailure( () -> context.action( () -> observableValue.asInfo().setValue( 44 ) ), "Arez-0114: Spy.setValue invoked when Arez.arePropertyIntrospectorsEnabled() returns false." ); }
### Question: ComputableValue extends Node { @Nonnull Observer getObserver() { return _observer; } ComputableValue( @Nullable final ArezContext context, @Nullable final Component component, @Nullable final String name, @Nonnull final SafeFunction<T> function, @Nullable final Procedure onActivate, @Nullable final Procedure onDeactivate, final int flags ); T get(); void reportPossiblyChanged(); @Override void dispose(); @Override boolean isDisposed(); @Nonnull Disposable keepAlive(); }### Answer: @Test public void highPriorityComputableValue() { final ComputableValue<String> computableValue = Arez.context().computable( () -> "", ComputableValue.Flags.PRIORITY_HIGH ); assertEquals( computableValue.getObserver().getTask().getPriority(), Priority.HIGH ); }
### Question: ComputableValue extends Node { T computeValue() { if ( Arez.shouldCheckInvariants() ) { _computing = true; } try { return _function.call(); } finally { if ( Arez.shouldCheckInvariants() ) { _computing = false; } } } ComputableValue( @Nullable final ArezContext context, @Nullable final Component component, @Nullable final String name, @Nonnull final SafeFunction<T> function, @Nullable final Procedure onActivate, @Nullable final Procedure onDeactivate, final int flags ); T get(); void reportPossiblyChanged(); @Override void dispose(); @Override boolean isDisposed(); @Nonnull Disposable keepAlive(); }### Answer: @Test public void computeValue() { final ArezContext context = Arez.context(); final AtomicReference<String> value = new AtomicReference<>(); final AtomicReference<ComputableValue<String>> ref = new AtomicReference<>(); value.set( "" ); final SafeFunction<String> function = () -> { observeADependency(); assertTrue( ref.get().isComputing() ); return value.get(); }; final ComputableValue<String> computableValue = context.computable( function ); ref.set( computableValue ); setCurrentTransaction( computableValue.getObserver() ); assertEquals( computableValue.computeValue(), "" ); value.set( "XXX" ); assertEquals( computableValue.computeValue(), "XXX" ); }
### Question: ComputableValue extends Node { void compute() { final T oldValue = _value; try { final T newValue = computeValue(); if ( !Objects.equals( oldValue, newValue ) ) { _value = newValue; _error = null; getObservableValue().reportChangeConfirmed(); } if ( Arez.shouldCheckApiInvariants() ) { if ( getObserver().areArezDependenciesRequired() ) { final List<ObservableValue<?>> observableValues = Transaction.current().getObservableValues(); apiInvariant( () -> null != observableValues && !observableValues.isEmpty(), () -> "Arez-0173: ComputableValue named '" + getName() + "' completed compute but is not " + "observing any properties. As a result compute will never be rescheduled. " + "This is not a ComputableValue candidate." ); } } } catch ( final Exception e ) { if ( null == _error ) { _value = null; _error = e; getObservableValue().reportChangeConfirmed(); } throw e; } } ComputableValue( @Nullable final ArezContext context, @Nullable final Component component, @Nullable final String name, @Nonnull final SafeFunction<T> function, @Nullable final Procedure onActivate, @Nullable final Procedure onDeactivate, final int flags ); T get(); void reportPossiblyChanged(); @Override void dispose(); @Override boolean isDisposed(); @Nonnull Disposable keepAlive(); }### Answer: @Test public void compute() { final ArezContext context = Arez.context(); final String name = ValueUtil.randomString(); final AtomicReference<String> value = new AtomicReference<>(); final String value1 = ValueUtil.randomString(); final String value2 = ValueUtil.randomString(); final SafeFunction<String> function = () -> { observeADependency(); return value.get(); }; final ComputableValue<String> computableValue = context.computable( name, function ); final Observer observer = context.observer( new CountAndObserveProcedure() ); setCurrentTransaction( computableValue.getObserver() ); observer.setState( Observer.Flags.STATE_POSSIBLY_STALE ); computableValue.getObservableValue().rawAddObserver( observer ); observer.getDependencies().add( computableValue.getObservableValue() ); computableValue.getObservableValue().setLeastStaleObserverState( Observer.Flags.STATE_POSSIBLY_STALE ); computableValue.setValue( value1 ); value.set( value2 ); setCurrentTransaction( computableValue.getObserver() ); computableValue.compute(); assertEquals( computableValue.getValue(), value2 ); assertNull( computableValue.getError() ); assertEquals( observer.getState(), Observer.Flags.STATE_STALE ); }
### Question: ComputableValue extends Node { @Override public void dispose() { if ( isNotDisposed() ) { if ( Arez.shouldCheckInvariants() ) { getContext().safeAction( Arez.areNamesEnabled() ? getName() + ".dispose" : null, () -> getContext().getTransaction().reportDispose( this ), ActionFlags.NO_VERIFY_ACTION_REQUIRED ); } _disposed = true; _value = null; _error = null; if ( willPropagateSpyEvents() ) { reportSpyEvent( new ComputableValueDisposeEvent( asInfo() ) ); } if ( null != _component ) { _component.removeComputableValue( this ); } else if ( Arez.areRegistriesEnabled() ) { getContext().deregisterComputableValue( this ); } _observableValue.dispose(); if ( !_observer.isDisposing() ) { _observer.dispose(); } } } ComputableValue( @Nullable final ArezContext context, @Nullable final Component component, @Nullable final String name, @Nonnull final SafeFunction<T> function, @Nullable final Procedure onActivate, @Nullable final Procedure onDeactivate, final int flags ); T get(); void reportPossiblyChanged(); @Override void dispose(); @Override boolean isDisposed(); @Nonnull Disposable keepAlive(); }### Answer: @Test public void dispose() { final ArezContext context = Arez.context(); final ComputableValue<String> computableValue = context.computable( () -> "" ); final Observer observer = computableValue.getObserver(); setCurrentTransaction( observer ); observer.setState( Observer.Flags.STATE_UP_TO_DATE ); assertFalse( observer.isDisposed() ); Transaction.setTransaction( null ); computableValue.dispose(); assertTrue( observer.isDisposed() ); assertEquals( observer.getState(), Observer.Flags.STATE_DISPOSED ); }
### Question: ComputableValueInfoImpl implements ComputableValueInfo { @OmitSymbol( unless = "arez.enable_property_introspection" ) @Nullable @Override public Object getValue() throws Throwable { if ( Arez.shouldCheckInvariants() ) { invariant( Arez::arePropertyIntrospectorsEnabled, () -> "Arez-0116: Spy.getValue invoked when Arez.arePropertyIntrospectorsEnabled() returns false." ); } final PropertyAccessor<?> accessor = _computableValue.getObservableValue().getAccessor(); assert null != accessor; return accessor.get(); } ComputableValueInfoImpl( @Nonnull final ComputableValue<?> computableValue ); @Nonnull @Override String getName(); @Override boolean isComputing(); @Nonnull @Override Priority getPriority(); @Override boolean isActive(); @Nonnull @Override List<ObservableValueInfo> getDependencies(); @Nonnull @Override List<ObserverInfo> getObservers(); @Nullable @Override ComponentInfo getComponent(); @OmitSymbol( unless = "arez.enable_property_introspection" ) @Nullable @Override Object getValue(); @Override boolean isDisposed(); @Override String toString(); @Override boolean equals( final Object o ); @Override int hashCode(); }### Answer: @Test public void computableValue_introspection_noObservers() throws Throwable { final ArezContext context = Arez.context(); final ComputableValue<String> computableValue1 = context.computable( () -> { observeADependency(); return "42"; } ); assertNull( computableValue1.asInfo().getValue() ); } @Test public void computableValue_introspection() throws Throwable { final ArezContext context = Arez.context(); final SafeFunction<String> function = () -> { observeADependency(); return "42"; }; final ComputableValue<String> computableValue1 = context.computable( function ); context.observer( computableValue1::get ); assertEquals( computableValue1.asInfo().getValue(), "42" ); } @Test public void computableValue_getValue_introspectorsDisabled() { ArezTestUtil.disablePropertyIntrospectors(); final ArezContext context = Arez.context(); final ComputableValue<Integer> computableValue1 = context.computable( () -> 42 ); assertInvariantFailure( () -> context.action( () -> computableValue1.asInfo().getValue() ), "Arez-0116: Spy.getValue invoked when Arez.arePropertyIntrospectorsEnabled() returns false." ); }
### Question: ComputableValue extends Node { @SuppressWarnings( "ConstantConditions" ) @OmitSymbol( unless = "arez.enable_spies" ) @Nonnull ComputableValueInfo asInfo() { if ( Arez.shouldCheckInvariants() ) { invariant( Arez::areSpiesEnabled, () -> "Arez-0195: ComputableValue.asInfo() invoked but Arez.areSpiesEnabled() returned false." ); } if ( Arez.areSpiesEnabled() && null == _info ) { _info = new ComputableValueInfoImpl( this ); } return Arez.areSpiesEnabled() ? _info : null; } ComputableValue( @Nullable final ArezContext context, @Nullable final Component component, @Nullable final String name, @Nonnull final SafeFunction<T> function, @Nullable final Procedure onActivate, @Nullable final Procedure onDeactivate, final int flags ); T get(); void reportPossiblyChanged(); @Override void dispose(); @Override boolean isDisposed(); @Nonnull Disposable keepAlive(); }### Answer: @Test public void asInfo() { final ArezContext context = Arez.context(); final SafeFunction<String> function = () -> { observeADependency(); return ""; }; final ComputableValue<String> computableValue = context.computable( function ); final ComputableValueInfo info = computableValue.asInfo(); assertEquals( info.getName(), computableValue.getName() ); }
### Question: ComputableValue extends Node { void incrementKeepAliveRefCount() { keepAliveInvariants(); _keepAliveRefCount++; if ( 1 == _keepAliveRefCount ) { final ObservableValue<T> observableValue = getObservableValue(); if ( !observableValue.isActive() ) { final ArezContext context = getContext(); if ( context.isTransactionActive() ) { get(); } else { context.scheduleReaction( getObserver() ); context.triggerScheduler(); } } } } ComputableValue( @Nullable final ArezContext context, @Nullable final Component component, @Nullable final String name, @Nonnull final SafeFunction<T> function, @Nullable final Procedure onActivate, @Nullable final Procedure onDeactivate, final int flags ); T get(); void reportPossiblyChanged(); @Override void dispose(); @Override boolean isDisposed(); @Nonnull Disposable keepAlive(); }### Answer: @Test public void incrementKeepAliveRefCount() { final ArezContext context = Arez.context(); final ObservableValue<Object> observable = context.observable(); final AtomicInteger calls = new AtomicInteger(); final SafeFunction<String> function = () -> { observable.reportObserved(); calls.incrementAndGet(); return ""; }; final ComputableValue<String> computableValue = context.computable( function ); assertFalse( computableValue.getObserver().isActive() ); assertEquals( computableValue.getKeepAliveRefCount(), 0 ); final TestSpyEventHandler handler = TestSpyEventHandler.subscribe(); assertEquals( calls.get(), 0 ); computableValue.incrementKeepAliveRefCount(); assertEquals( calls.get(), 1 ); assertTrue( computableValue.getObserver().isActive() ); assertEquals( computableValue.getKeepAliveRefCount(), 1 ); handler.assertEventCount( 6 ); handler.assertNextEvent( ObserveScheduleEvent.class ); handler.assertNextEvent( ComputeStartEvent.class ); handler.assertNextEvent( TransactionStartEvent.class ); handler.assertNextEvent( ObservableValueChangeEvent.class ); handler.assertNextEvent( TransactionCompleteEvent.class ); handler.assertNextEvent( ComputeCompleteEvent.class ); handler.reset(); computableValue.incrementKeepAliveRefCount(); handler.assertEventCount( 0 ); assertEquals( calls.get(), 1 ); assertTrue( computableValue.getObserver().isActive() ); assertEquals( computableValue.getKeepAliveRefCount(), 2 ); }
### Question: ComputableValue extends Node { @OmitSymbol void setKeepAliveRefCount( final int keepAliveRefCount ) { _keepAliveRefCount = keepAliveRefCount; } ComputableValue( @Nullable final ArezContext context, @Nullable final Component component, @Nullable final String name, @Nonnull final SafeFunction<T> function, @Nullable final Procedure onActivate, @Nullable final Procedure onDeactivate, final int flags ); T get(); void reportPossiblyChanged(); @Override void dispose(); @Override boolean isDisposed(); @Nonnull Disposable keepAlive(); }### Answer: @Test public void incrementKeepAliveRefCount_badInitialRefCount() { final ArezContext context = Arez.context(); final ObservableValue<Object> observable = context.observable(); final SafeFunction<String> function = () -> { observable.reportObserved(); return ""; }; final ComputableValue<String> computableValue = context.computable( function ); final int keepAliveRefCount = -Math.abs( ValueUtil.randomInt() ); computableValue.setKeepAliveRefCount( keepAliveRefCount ); assertInvariantFailure( computableValue::incrementKeepAliveRefCount, "Arez-0165: KeepAliveRefCount on ComputableValue named 'ComputableValue@2' " + "has an invalid value " + keepAliveRefCount ); }
### Question: ComputableValue extends Node { void decrementKeepAliveRefCount() { _keepAliveRefCount--; keepAliveInvariants(); if ( 0 == _keepAliveRefCount ) { final ObservableValue<T> observableValue = getObservableValue(); final ArezContext context = getContext(); if ( context.isTransactionActive() ) { if ( !observableValue.isPendingDeactivation() ) { context.getTransaction().queueForDeactivation( observableValue ); } } else { getContext().safeAction( Arez.areNamesEnabled() ? getName() + ".deactivate" : null, observableValue::deactivate, ActionFlags.NO_VERIFY_ACTION_REQUIRED ); } } } ComputableValue( @Nullable final ArezContext context, @Nullable final Component component, @Nullable final String name, @Nonnull final SafeFunction<T> function, @Nullable final Procedure onActivate, @Nullable final Procedure onDeactivate, final int flags ); T get(); void reportPossiblyChanged(); @Override void dispose(); @Override boolean isDisposed(); @Nonnull Disposable keepAlive(); }### Answer: @Test public void decrementKeepAliveRefCount() { final ArezContext context = Arez.context(); final ObservableValue<Object> observable = context.observable(); final AtomicInteger calls = new AtomicInteger(); final SafeFunction<String> function = () -> { observable.reportObserved(); calls.incrementAndGet(); return ""; }; final ComputableValue<String> computableValue = context.computable( function ); assertFalse( computableValue.getObserver().isActive() ); assertEquals( computableValue.getKeepAliveRefCount(), 0 ); assertEquals( calls.get(), 0 ); computableValue.incrementKeepAliveRefCount(); assertEquals( calls.get(), 1 ); assertTrue( computableValue.getObserver().isActive() ); assertEquals( computableValue.getKeepAliveRefCount(), 1 ); final TestSpyEventHandler handler = TestSpyEventHandler.subscribe(); computableValue.decrementKeepAliveRefCount(); assertEquals( calls.get(), 1 ); assertFalse( computableValue.getObserver().isActive() ); assertEquals( computableValue.getKeepAliveRefCount(), 0 ); handler.assertEventCount( 4 ); handler.assertNextEvent( ActionStartEvent.class ); handler.assertNextEvent( TransactionStartEvent.class ); handler.assertNextEvent( TransactionCompleteEvent.class ); handler.assertNextEvent( ActionCompleteEvent.class ); }
### Question: ArezProcessor extends AbstractStandardProcessor { @Nonnull @Override protected String getOptionPrefix() { return "arez"; } @Override boolean process( @Nonnull final Set<? extends TypeElement> annotations, @Nonnull final RoundEnvironment env ); }### Answer: @Test public void unresolvedComponent() { final JavaFileObject source1 = fixture( "unresolved/com/example/component/UnresolvedComponent.java" ); final List<JavaFileObject> inputs = Collections.singletonList( source1 ); assertFailedCompileResource( inputs, "ArezProcessor unable to process com.example.component.UnresolvedComponent because not all of its dependencies could be resolved. Check for compilation errors or a circular dependency with generated code." ); assert_().about( JavaSourcesSubjectFactory.javaSources() ). that( inputs ). withCompilerOptions( "-Xlint:all,-processing", "-implicit:none", "-A" + getOptionPrefix() + ".defer.errors=false", "-A" + getOptionPrefix() + ".defer.unresolved=false" ). processedWith( processor(), additionalProcessors() ). compilesWithoutWarnings(); }
### Question: ComputableValueInfoImpl implements ComputableValueInfo { @Override public int hashCode() { return _computableValue.hashCode(); } ComputableValueInfoImpl( @Nonnull final ComputableValue<?> computableValue ); @Nonnull @Override String getName(); @Override boolean isComputing(); @Nonnull @Override Priority getPriority(); @Override boolean isActive(); @Nonnull @Override List<ObservableValueInfo> getDependencies(); @Nonnull @Override List<ObserverInfo> getObservers(); @Nullable @Override ComponentInfo getComponent(); @OmitSymbol( unless = "arez.enable_property_introspection" ) @Nullable @Override Object getValue(); @Override boolean isDisposed(); @Override String toString(); @Override boolean equals( final Object o ); @Override int hashCode(); }### Answer: @SuppressWarnings( "EqualsWithItself" ) @Test public void equalsAndHashCode() { final ArezContext context = Arez.context(); final ComputableValue<Object> computableValue1 = context.computable( () -> "1" ); final ComputableValue<Object> computableValue2 = context.computable( () -> "2" ); final ComputableValueInfo info1a = computableValue1.asInfo(); final ComputableValueInfo info1b = new ComputableValueInfoImpl( computableValue1 ); final ComputableValueInfo info2 = computableValue2.asInfo(); assertNotEquals( info1a, "" ); assertEquals( info1a, info1a ); assertEquals( info1b, info1a ); assertNotEquals( info2, info1a ); assertEquals( info1a, info1b ); assertEquals( info1b, info1b ); assertNotEquals( info2, info1b ); assertNotEquals( info1a, info2 ); assertNotEquals( info1b, info2 ); assertEquals( info2, info2 ); assertEquals( info1a.hashCode(), computableValue1.hashCode() ); assertEquals( info1a.hashCode(), info1b.hashCode() ); assertEquals( info2.hashCode(), computableValue2.hashCode() ); }
### Question: AggregateLocator implements Locator { @Nonnull Disposable registerLocator( @Nonnull final Locator locator ) { if ( Arez.shouldCheckApiInvariants() ) { apiInvariant( () -> !_locators.contains( locator ), () -> "Arez-0189: Attempting to register locator " + locator + " when the " + "Locator is already present." ); } _locators.add( locator ); return new LocatorEntry( locator ); } @Nullable @Override T findById( @Nonnull final Class<T> type, @Nonnull final Object id ); }### Answer: @Test public void registerLookup_duplicate() { final TypeBasedLocator locator1 = new TypeBasedLocator(); final AggregateLocator locator = new AggregateLocator(); locator.registerLocator( locator1 ); assertInvariantFailure( () -> locator.registerLocator( locator1 ), "Arez-0189: Attempting to register locator " + locator1 + " when the Locator is already present." ); }
### Question: ComponentInfoImpl implements ComponentInfo { @Override public int hashCode() { return _component.hashCode(); } ComponentInfoImpl( @Nonnull final Component component ); @Nonnull @Override String getType(); @Nonnull @Override Object getId(); @Nonnull @Override String getName(); @Override List<ObservableValueInfo> getObservableValues(); @Override List<ObserverInfo> getObservers(); @Override List<ComputableValueInfo> getComputableValues(); @Override boolean isDisposed(); @Override String toString(); @Override boolean equals( final Object o ); @Override int hashCode(); }### Answer: @Test public void equalsAndHashCode() { final ArezContext context = Arez.context(); final Component component1 = context.component( ValueUtil.randomString(), ValueUtil.randomString() ); final Component component2 = context.component( ValueUtil.randomString(), ValueUtil.randomString() ); final ComponentInfo info1a = component1.asInfo(); final ComponentInfo info1b = new ComponentInfoImpl( component1 ); final ComponentInfo info2 = component2.asInfo(); assertNotEquals( info1a, "" ); assertEquals( info1a, info1a ); assertEquals( info1b, info1a ); assertNotEquals( info2, info1a ); assertEquals( info1a, info1b ); assertEquals( info1b, info1b ); assertNotEquals( info2, info1b ); assertNotEquals( info1a, info2 ); assertNotEquals( info1b, info2 ); assertEquals( info2, info2 ); assertEquals( info1a.hashCode(), component1.hashCode() ); assertEquals( info1a.hashCode(), info1b.hashCode() ); assertEquals( info2.hashCode(), component2.hashCode() ); }
### Question: TaskQueue { void queueTask( @Nonnull final Task task ) { queueTask( task.getPriorityIndex(), task ); } @SuppressWarnings( { "unchecked", "rawtypes", "RedundantSuppression" } ) TaskQueue( final int priorityCount, final int initialCapacity ); }### Answer: @Test public void queueTask_badPriority() { final TaskQueue queue = new TaskQueue( 3, 10 ); final ArezContext context = Arez.context(); assertInvariantFailure( () -> queue.queueTask( -1, context.task( "A", ValueUtil::randomString ) ), "Arez-0215: Attempting to queue task named 'A' but passed an invalid priority -1." ); assertInvariantFailure( () -> queue.queueTask( 77, context.task( "B", ValueUtil::randomString ) ), "Arez-0215: Attempting to queue task named 'B' but passed an invalid priority 77." ); } @Test public void queueTask_direct_alreadyQueued() { final TaskQueue queue = new TaskQueue( 3, 10 ); final ArezContext context = Arez.context(); final Task task = context.task( "A", ValueUtil::randomString, Task.Flags.RUN_LATER ); task.markAsIdle(); queue.queueTask( 0, task ); task.markAsIdle(); assertInvariantFailure( () -> queue.queueTask( 2, task ), "Arez-0099: Attempting to queue task named 'A' when task is already queued." ); } @Test public void queueTask_alreadyQueued() { final TaskQueue queue = new TaskQueue( 3, 10 ); final ArezContext context = Arez.context(); final Task task = context.task( "A", ValueUtil::randomString, Task.Flags.RUN_LATER ); assertInvariantFailure( () -> queue.queueTask( task ), "Arez-0128: Attempting to queue task named 'A' when task is not idle." ); }
### Question: TaskQueue { @Nonnull Collection<Task> clear() { final List<Task> tasks = new ArrayList<>(); for ( int i = 0; i < _buffers.length; i++ ) { final CircularBuffer<Task> buffer = _buffers[ i ]; Task task; while ( null != ( task = buffer.pop() ) ) { tasks.add( task ); task.markAsIdle(); } } return tasks; } @SuppressWarnings( { "unchecked", "rawtypes", "RedundantSuppression" } ) TaskQueue( final int priorityCount, final int initialCapacity ); }### Answer: @Test public void clear() { final ArezContext context = Arez.context(); final TaskQueue queue = context.getTaskQueue(); context.task( "A", ValueUtil::randomString, Task.Flags.RUN_LATER \| Task.Flags.PRIORITY_HIGHEST ); context.task( "B", ValueUtil::randomString, Task.Flags.RUN_LATER \| Task.Flags.PRIORITY_HIGH ); context.task( "C", ValueUtil::randomString, Task.Flags.RUN_LATER \| Task.Flags.PRIORITY_LOWEST ); context.task( "D", ValueUtil::randomString, Task.Flags.RUN_LATER \| Task.Flags.PRIORITY_LOWEST ); context.task( "E", ValueUtil::randomString, Task.Flags.RUN_LATER \| Task.Flags.PRIORITY_NORMAL ); context.task( "F", ValueUtil::randomString, Task.Flags.RUN_LATER \| Task.Flags.PRIORITY_HIGH ); assertEquals( queue.getQueueSize(), 6 ); final Collection<Task> tasks = queue.clear(); assertEquals( queue.getQueueSize(), 0 ); assertEquals( tasks.stream().map( Task::getName ).collect( Collectors.joining( "," ) ), "A,B,F,E,C,D" ); }
### Question: ArezUtil { @Nonnull @OmitSymbol( unless = "arez.enable_names" ) static String safeGetString( @Nonnull final Supplier<String> message ) { try { return message.get(); } catch ( final Throwable t ) { return "Exception generated whilst attempting to get supplied message.\n" + throwableToString( t ); } } private ArezUtil(); }### Answer: @Test public void safeGetString() { assertEquals( ArezUtil.safeGetString( () -> "My String" ), "My String" ); } @Test public void safeGetString_generatesError() { final String text = ArezUtil.safeGetString( () -> { throw new RuntimeException( "X" ); } ); assertTrue( text.startsWith( "Exception generated whilst attempting to get supplied message.\n" + "java.lang.RuntimeException: X\n" ) ); }
### Question: ObservableValue extends Node { @Override public void dispose() { if ( isNotDisposed() ) { getContext().safeAction( Arez.areNamesEnabled() ? getName() + ".dispose" : null, this::performDispose ); if ( isComputableValue() ) { getObserver().dispose(); } else { if ( willPropagateSpyEvents() ) { reportSpyEvent( new ObservableValueDisposeEvent( asInfo() ) ); } if ( null != _component ) { _component.removeObservableValue( this ); } else if ( Arez.areRegistriesEnabled() ) { getContext().deregisterObservableValue( this ); } } } } ObservableValue( @Nullable final ArezContext context, @Nullable final Component component, @Nullable final String name, @Nullable final Observer observer, @Nullable final PropertyAccessor<T> accessor, @Nullable final PropertyMutator<T> mutator ); @Override void dispose(); @Override boolean isDisposed(); void reportObserved(); void reportObservedIfTrackingTransactionActive(); @OmitSymbol( unless = "arez.check_invariants" ) void preReportChanged(); void reportChanged(); }### Answer: @Test public void dispose() { final ArezContext context = Arez.context(); final ObservableValue<?> observableValue = context.observable(); final Observer observer = context.observer( new CountAndObserveProcedure() ); setCurrentTransaction( newReadWriteObserver( context ) ); observableValue.setLeastStaleObserverState( Observer.Flags.STATE_UP_TO_DATE ); observer.setState( Observer.Flags.STATE_UP_TO_DATE ); observableValue.getObservers().add( observer ); observer.getDependencies().add( observableValue ); Transaction.setTransaction( null ); assertFalse( observableValue.isDisposed() ); final int currentNextTransactionId = context.currentNextTransactionId(); context.pauseScheduler(); observableValue.dispose(); assertEquals( context.currentNextTransactionId(), currentNextTransactionId + 1 ); assertTrue( observableValue.isDisposed() ); assertEquals( observableValue.getWorkState(), ObservableValue.DISPOSED ); assertEquals( observer.getState(), Observer.Flags.STATE_STALE ); }
### Question: ObservableValue extends Node { void addObserver( @Nonnull final Observer observer ) { if ( Arez.shouldCheckInvariants() ) { invariant( () -> getContext().isTransactionActive(), () -> "Arez-0065: Attempt to invoke addObserver on ObservableValue named '" + getName() + "' when there is no active transaction." ); invariantObserversLinked(); invariant( () -> !hasObserver( observer ), () -> "Arez-0066: Attempting to add observer named '" + observer.getName() + "' to ObservableValue " + "named '" + getName() + "' when observer is already observing ObservableValue." ); invariant( this::isNotDisposed, () -> "Arez-0067: Attempting to add observer named '" + observer.getName() + "' to " + "ObservableValue named '" + getName() + "' when ObservableValue is disposed." ); invariant( observer::isNotDisposed, () -> "Arez-0068: Attempting to add observer named '" + observer.getName() + "' to ObservableValue " + "named '" + getName() + "' when observer is disposed." ); invariant( () -> !isComputableValue() \|\| observer.canObserveLowerPriorityDependencies() \|\| observer.getTask().getPriority().ordinal() >= getObserver().getTask().getPriority().ordinal(), () -> "Arez-0183: Attempting to add observer named '" + observer.getName() + "' to ObservableValue " + "named '" + getName() + "' where the observer is scheduled at a " + observer.getTask().getPriority() + " priority but the ObservableValue's owner is scheduled " + "at a " + getObserver().getTask().getPriority() + " priority." ); invariant( () -> getContext().getTransaction().getTracker() == observer, () -> "Arez-0203: Attempting to add observer named '" + observer.getName() + "' to ObservableValue " + "named '" + getName() + "' but the observer is not the tracker in transaction named '" + getContext().getTransaction().getName() + "'." ); } rawAddObserver( observer ); } ObservableValue( @Nullable final ArezContext context, @Nullable final Component component, @Nullable final String name, @Nullable final Observer observer, @Nullable final PropertyAccessor<T> accessor, @Nullable final PropertyMutator<T> mutator ); @Override void dispose(); @Override boolean isDisposed(); void reportObserved(); void reportObservedIfTrackingTransactionActive(); @OmitSymbol( unless = "arez.check_invariants" ) void preReportChanged(); void reportChanged(); }### Answer: @Test public void addObserver() { final ArezContext context = Arez.context(); final Observer observer = context.observer( new CountAndObserveProcedure() ); setCurrentTransaction( observer ); final ObservableValue<?> observableValue = context.observable(); assertEquals( observableValue.getObservers().size(), 0 ); assertFalse( observableValue.hasObservers() ); assertEquals( observableValue.getLeastStaleObserverState(), Observer.Flags.STATE_UP_TO_DATE ); observableValue.addObserver( observer ); assertEquals( observableValue.getObservers().size(), 1 ); assertTrue( observableValue.hasObservers() ); assertTrue( observableValue.hasObserver( observer ) ); assertEquals( observableValue.getLeastStaleObserverState(), Observer.Flags.STATE_UP_TO_DATE ); observableValue.invariantLeastStaleObserverState(); } @Test public void addObserver_whenObserverIsNotTrackerAssociatedWithTransaction() { final ArezContext context = Arez.context(); final Observer observer = context.observer( new CountAndObserveProcedure() ); final ObservableValue<?> observableValue = context.observable(); context.safeAction( () -> { assertInvariantFailure( () -> observableValue.addObserver( observer ), "Arez-0203: Attempting to add observer named '" + observer.getName() + "' to " + "ObservableValue named '" + observableValue.getName() + "' but the observer is not the " + "tracker in transaction named '" + context.getTransaction().getName() + "'." ); }, ActionFlags.NO_VERIFY_ACTION_REQUIRED ); }
### Question: ObservableValue extends Node { void removeObserver( @Nonnull final Observer observer ) { if ( Arez.shouldCheckInvariants() ) { invariant( () -> getContext().isTransactionActive(), () -> "Arez-0069: Attempt to invoke removeObserver on ObservableValue named '" + getName() + "' " + "when there is no active transaction." ); invariantObserversLinked(); invariant( () -> hasObserver( observer ), () -> "Arez-0070: Attempting to remove observer named '" + observer.getName() + "' from " + "ObservableValue named '" + getName() + "' when observer is not observing ObservableValue." ); } final List<Observer> observers = getObservers(); observers.remove( observer ); if ( canDeactivateNow() ) { queueForDeactivation(); } if ( Arez.shouldCheckInvariants() ) { invariantObserversLinked(); } } ObservableValue( @Nullable final ArezContext context, @Nullable final Component component, @Nullable final String name, @Nullable final Observer observer, @Nullable final PropertyAccessor<T> accessor, @Nullable final PropertyMutator<T> mutator ); @Override void dispose(); @Override boolean isDisposed(); void reportObserved(); void reportObservedIfTrackingTransactionActive(); @OmitSymbol( unless = "arez.check_invariants" ) void preReportChanged(); void reportChanged(); }### Answer: @Test public void removeObserver() { final ArezContext context = Arez.context(); final Observer observer = context.observer( new CountAndObserveProcedure() ); setCurrentTransaction( observer ); final ObservableValue<?> observableValue = context.observable(); assertEquals( observableValue.getObservers().size(), 0 ); assertFalse( observableValue.hasObservers() ); observer.setState( Observer.Flags.STATE_UP_TO_DATE ); observableValue.setLeastStaleObserverState( Observer.Flags.STATE_UP_TO_DATE ); observableValue.getObservers().add( observer ); observer.getDependencies().add( observableValue ); assertEquals( observableValue.getObservers().size(), 1 ); assertTrue( observableValue.hasObservers() ); assertTrue( observableValue.hasObserver( observer ) ); assertEquals( observableValue.getLeastStaleObserverState(), Observer.Flags.STATE_UP_TO_DATE ); observableValue.removeObserver( observer ); assertEquals( observableValue.getObservers().size(), 0 ); assertFalse( observableValue.hasObservers() ); assertFalse( observableValue.hasObserver( observer ) ); assertEquals( observableValue.getLeastStaleObserverState(), Observer.Flags.STATE_UP_TO_DATE ); }
### Question: ObservableValue extends Node { void setLeastStaleObserverState( final int leastStaleObserverState ) { if ( Arez.shouldCheckInvariants() ) { invariant( () -> getContext().isTransactionActive(), () -> "Arez-0074: Attempt to invoke setLeastStaleObserverState on ObservableValue named '" + getName() + "' when there is no active transaction." ); invariant( () -> Observer.Flags.isActive( leastStaleObserverState ), () -> "Arez-0075: Attempt to invoke setLeastStaleObserverState on ObservableValue named '" + getName() + "' with invalid value " + Observer.Flags.getStateName( leastStaleObserverState ) + "." ); } _leastStaleObserverState = leastStaleObserverState; } ObservableValue( @Nullable final ArezContext context, @Nullable final Component component, @Nullable final String name, @Nullable final Observer observer, @Nullable final PropertyAccessor<T> accessor, @Nullable final PropertyMutator<T> mutator ); @Override void dispose(); @Override boolean isDisposed(); void reportObserved(); void reportObservedIfTrackingTransactionActive(); @OmitSymbol( unless = "arez.check_invariants" ) void preReportChanged(); void reportChanged(); }### Answer: @Test public void setLeastStaleObserverState() { final ArezContext context = Arez.context(); final Observer observer = context.observer( new CountAndObserveProcedure() ); final ObservableValue<?> observableValue = context.observable(); setCurrentTransaction( observer ); assertEquals( observableValue.getLeastStaleObserverState(), Observer.Flags.STATE_UP_TO_DATE ); observableValue.setLeastStaleObserverState( Observer.Flags.STATE_UP_TO_DATE ); assertEquals( observableValue.getLeastStaleObserverState(), Observer.Flags.STATE_UP_TO_DATE ); }
### Question: ObservableValue extends Node { @Nonnull Observer getObserver() { assert null != _observer; return _observer; } ObservableValue( @Nullable final ArezContext context, @Nullable final Component component, @Nullable final String name, @Nullable final Observer observer, @Nullable final PropertyAccessor<T> accessor, @Nullable final PropertyMutator<T> mutator ); @Override void dispose(); @Override boolean isDisposed(); void reportObserved(); void reportObservedIfTrackingTransactionActive(); @OmitSymbol( unless = "arez.check_invariants" ) void preReportChanged(); void reportChanged(); }### Answer: @Test public void invariantOwner_badObservableLink() { ArezTestUtil.disableRegistries(); final ArezContext context = Arez.context(); setupReadOnlyTransaction( context ); final Observer observer = context.computable( () -> "" ).getObserver(); final ObservableValue<?> observableValue = new ObservableValue<>( context, null, observer.getName(), observer, null, null ); assertInvariantFailure( observableValue::invariantOwner, "Arez-0076: ObservableValue named '" + observableValue.getName() + "' has owner " + "specified but owner does not link to ObservableValue as derived value." ); }
### Question: ObservableValue extends Node { void invariantObserversLinked() { if ( Arez.shouldCheckInvariants() ) { getObservers().forEach( observer -> invariant( () -> observer.getDependencies().contains( this ), () -> "Arez-0077: ObservableValue named '" + getName() + "' has observer " + "named '" + observer.getName() + "' which does not contain " + "ObservableValue as dependency." ) ); } } ObservableValue( @Nullable final ArezContext context, @Nullable final Component component, @Nullable final String name, @Nullable final Observer observer, @Nullable final PropertyAccessor<T> accessor, @Nullable final PropertyMutator<T> mutator ); @Override void dispose(); @Override boolean isDisposed(); void reportObserved(); void reportObservedIfTrackingTransactionActive(); @OmitSymbol( unless = "arez.check_invariants" ) void preReportChanged(); void reportChanged(); }### Answer: @Test public void invariantObserversLinked() { final Observer observer1 = Arez.context().observer( new CountAndObserveProcedure() ); final Observer observer2 = Arez.context().observer( new CountAndObserveProcedure() ); final Observer observer3 = Arez.context().observer( new CountAndObserveProcedure() ); setupReadWriteTransaction(); observer1.setState( Observer.Flags.STATE_UP_TO_DATE ); observer2.setState( Observer.Flags.STATE_POSSIBLY_STALE ); observer3.setState( Observer.Flags.STATE_STALE ); final ObservableValue<?> observableValue = Arez.context().observable(); observer1.getDependencies().add( observableValue ); observer2.getDependencies().add( observableValue ); observableValue.rawAddObserver( observer1 ); observableValue.rawAddObserver( observer2 ); observableValue.rawAddObserver( observer3 ); observableValue.setLeastStaleObserverState( Observer.Flags.STATE_UP_TO_DATE ); assertInvariantFailure( observableValue::invariantObserversLinked, "Arez-0077: ObservableValue named '" + observableValue.getName() + "' has observer named '" + observer3.getName() + "' which does not contain ObservableValue as dependency." ); observer3.getDependencies().add( observableValue ); observableValue.invariantObserversLinked(); }
### Question: ObservableValue extends Node { void queueForDeactivation() { if ( Arez.shouldCheckInvariants() ) { invariant( () -> getContext().isTransactionActive(), () -> "Arez-0071: Attempt to invoke queueForDeactivation on ObservableValue named '" + getName() + "' when there is no active transaction." ); invariant( this::canDeactivateNow, () -> "Arez-0072: Attempted to invoke queueForDeactivation() on ObservableValue named '" + getName() + "' but ObservableValue is not able to be deactivated." ); invariant( () -> !hasObservers(), () -> "Arez-0073: Attempted to invoke queueForDeactivation() on ObservableValue named '" + getName() + "' but ObservableValue has observers." ); } if ( !isPendingDeactivation() ) { getContext().getTransaction().queueForDeactivation( this ); } } ObservableValue( @Nullable final ArezContext context, @Nullable final Component component, @Nullable final String name, @Nullable final Observer observer, @Nullable final PropertyAccessor<T> accessor, @Nullable final PropertyMutator<T> mutator ); @Override void dispose(); @Override boolean isDisposed(); void reportObserved(); void reportObservedIfTrackingTransactionActive(); @OmitSymbol( unless = "arez.check_invariants" ) void preReportChanged(); void reportChanged(); }### Answer: @Test public void queueForDeactivation() { final ArezContext context = Arez.context(); setupReadOnlyTransaction( context ); final ComputableValue<String> computableValue = context.computable( () -> "" ); final Observer observer = computableValue.getObserver(); final ObservableValue<?> observableValue = computableValue.getObservableValue(); observer.setState( Observer.Flags.STATE_UP_TO_DATE ); assertFalse( observableValue.isPendingDeactivation() ); observableValue.queueForDeactivation(); assertTrue( observableValue.isPendingDeactivation() ); final List<ObservableValue<?>> pendingDeactivations = context.getTransaction().getPendingDeactivations(); assertNotNull( pendingDeactivations ); assertEquals( pendingDeactivations.size(), 1 ); assertTrue( pendingDeactivations.contains( observableValue ) ); }
### Question: ObservableValue extends Node { boolean isPendingDeactivation() { return _pendingDeactivation; } ObservableValue( @Nullable final ArezContext context, @Nullable final Component component, @Nullable final String name, @Nullable final Observer observer, @Nullable final PropertyAccessor<T> accessor, @Nullable final PropertyMutator<T> mutator ); @Override void dispose(); @Override boolean isDisposed(); void reportObserved(); void reportObservedIfTrackingTransactionActive(); @OmitSymbol( unless = "arez.check_invariants" ) void preReportChanged(); void reportChanged(); }### Answer: @Test public void queueForDeactivation_observableIsNotAbleToBeDeactivated() { final ArezContext context = Arez.context(); setupReadOnlyTransaction( context ); final ObservableValue<?> observableValue = context.observable(); assertFalse( observableValue.isPendingDeactivation() ); assertInvariantFailure( observableValue::queueForDeactivation, "Arez-0072: Attempted to invoke queueForDeactivation() on ObservableValue named '" + observableValue.getName() + "' but ObservableValue is not able to be deactivated." ); }
### Question: ObservableValue extends Node { void resetPendingDeactivation() { _pendingDeactivation = false; } ObservableValue( @Nullable final ArezContext context, @Nullable final Component component, @Nullable final String name, @Nullable final Observer observer, @Nullable final PropertyAccessor<T> accessor, @Nullable final PropertyMutator<T> mutator ); @Override void dispose(); @Override boolean isDisposed(); void reportObserved(); void reportObservedIfTrackingTransactionActive(); @OmitSymbol( unless = "arez.check_invariants" ) void preReportChanged(); void reportChanged(); }### Answer: @Test public void resetPendingDeactivation() { final ArezContext context = Arez.context(); setupReadOnlyTransaction( context ); final ComputableValue<String> computableValue = context.computable( () -> "" ); final Observer observer = computableValue.getObserver(); final ObservableValue<?> observableValue = computableValue.getObservableValue(); observer.setState( Observer.Flags.STATE_UP_TO_DATE ); observableValue.markAsPendingDeactivation(); assertTrue( observableValue.isPendingDeactivation() ); observableValue.resetPendingDeactivation(); assertFalse( observableValue.isPendingDeactivation() ); }
### Question: ObservableValue extends Node { boolean canDeactivate() { return isComputableValue() && !getObserver().isKeepAlive(); } ObservableValue( @Nullable final ArezContext context, @Nullable final Component component, @Nullable final String name, @Nullable final Observer observer, @Nullable final PropertyAccessor<T> accessor, @Nullable final PropertyMutator<T> mutator ); @Override void dispose(); @Override boolean isDisposed(); void reportObserved(); void reportObservedIfTrackingTransactionActive(); @OmitSymbol( unless = "arez.check_invariants" ) void preReportChanged(); void reportChanged(); }### Answer: @Test public void canDeactivate() { final ArezContext context = Arez.context(); final Observer randomObserver = context.observer( new CountAndObserveProcedure() ); setCurrentTransaction( randomObserver ); final ComputableValue<String> computableValue = context.computable( () -> "" ); final Observer observer = computableValue.getObserver(); final ObservableValue<?> observableValue = computableValue.getObservableValue(); observer.setState( Observer.Flags.STATE_UP_TO_DATE ); assertTrue( observableValue.canDeactivate() ); assertTrue( observableValue.canDeactivateNow() ); observableValue.addObserver( randomObserver ); randomObserver.getDependencies().add( observableValue ); assertTrue( observableValue.canDeactivate() ); assertFalse( observableValue.canDeactivateNow() ); observableValue.removeObserver( randomObserver ); randomObserver.getDependencies().remove( observableValue ); assertTrue( observableValue.canDeactivate() ); assertTrue( observableValue.canDeactivateNow() ); final Disposable keepAliveLock = computableValue.keepAlive(); assertTrue( observableValue.canDeactivate() ); assertFalse( observableValue.canDeactivateNow() ); keepAliveLock.dispose(); assertTrue( observableValue.canDeactivate() ); assertTrue( observableValue.canDeactivateNow() ); }
### Question: ObservableValue extends Node { void deactivate() { if ( Arez.shouldCheckInvariants() ) { invariant( () -> getContext().isTransactionActive(), () -> "Arez-0060: Attempt to invoke deactivate on ObservableValue named '" + getName() + "' when there is no active transaction." ); invariant( this::canDeactivate, () -> "Arez-0061: Invoked deactivate on ObservableValue named '" + getName() + "' but " + "ObservableValue can not be deactivated. Either owner is null or the associated " + "ComputableValue has keepAlive enabled." ); } assert null != _observer; if ( _observer.isActive() ) { final boolean shouldPropagateDeactivateEvent = willPropagateSpyEvents() && !getObservers().isEmpty(); _observer.setState( Observer.Flags.STATE_INACTIVE ); if ( willPropagateSpyEvents() && shouldPropagateDeactivateEvent ) { reportSpyEvent( new ComputableValueDeactivateEvent( _observer.getComputableValue().asInfo() ) ); } } } ObservableValue( @Nullable final ArezContext context, @Nullable final Component component, @Nullable final String name, @Nullable final Observer observer, @Nullable final PropertyAccessor<T> accessor, @Nullable final PropertyMutator<T> mutator ); @Override void dispose(); @Override boolean isDisposed(); void reportObserved(); void reportObservedIfTrackingTransactionActive(); @OmitSymbol( unless = "arez.check_invariants" ) void preReportChanged(); void reportChanged(); }### Answer: @Test public void deactivate() { final ArezContext context = Arez.context(); setupReadOnlyTransaction( context ); final ComputableValue<String> computableValue = context.computable( () -> "" ); final Observer observer = computableValue.getObserver(); observer.setState( Observer.Flags.STATE_UP_TO_DATE ); final ObservableValue<?> observableValue = computableValue.getObservableValue(); assertEquals( observer.getState(), Observer.Flags.STATE_UP_TO_DATE ); observableValue.deactivate(); assertEquals( observer.getState(), Observer.Flags.STATE_INACTIVE ); }
### Question: ObservableValue extends Node { void activate() { if ( Arez.shouldCheckInvariants() ) { invariant( () -> getContext().isTransactionActive(), () -> "Arez-0062: Attempt to invoke activate on ObservableValue named '" + getName() + "' when there is no active transaction." ); invariant( () -> null != _observer, () -> "Arez-0063: Invoked activate on ObservableValue named '" + getName() + "' when owner is null." ); assert null != _observer; invariant( _observer::isInactive, () -> "Arez-0064: Invoked activate on ObservableValue named '" + getName() + "' when " + "ObservableValue is already active." ); } assert null != _observer; _observer.setState( Observer.Flags.STATE_UP_TO_DATE ); if ( willPropagateSpyEvents() ) { reportSpyEvent( new ComputableValueActivateEvent( _observer.getComputableValue().asInfo() ) ); } } ObservableValue( @Nullable final ArezContext context, @Nullable final Component component, @Nullable final String name, @Nullable final Observer observer, @Nullable final PropertyAccessor<T> accessor, @Nullable final PropertyMutator<T> mutator ); @Override void dispose(); @Override boolean isDisposed(); void reportObserved(); void reportObservedIfTrackingTransactionActive(); @OmitSymbol( unless = "arez.check_invariants" ) void preReportChanged(); void reportChanged(); }### Answer: @Test public void activate() { final ArezContext context = Arez.context(); setupReadOnlyTransaction( context ); final ComputableValue<String> computableValue = context.computable( () -> "" ); final Observer observer = computableValue.getObserver(); observer.setState( Observer.Flags.STATE_INACTIVE ); final ObservableValue<?> observableValue = computableValue.getObservableValue(); assertEquals( observer.getState(), Observer.Flags.STATE_INACTIVE ); observableValue.activate(); assertEquals( observer.getState(), Observer.Flags.STATE_UP_TO_DATE ); }
### Question: ObservableValue extends Node { public void reportObserved() { getContext().getTransaction().observe( this ); } ObservableValue( @Nullable final ArezContext context, @Nullable final Component component, @Nullable final String name, @Nullable final Observer observer, @Nullable final PropertyAccessor<T> accessor, @Nullable final PropertyMutator<T> mutator ); @Override void dispose(); @Override boolean isDisposed(); void reportObserved(); void reportObservedIfTrackingTransactionActive(); @OmitSymbol( unless = "arez.check_invariants" ) void preReportChanged(); void reportChanged(); }### Answer: @Test public void reportObserved() { final ArezContext context = Arez.context(); setupReadOnlyTransaction( context ); final ObservableValue<?> observableValue = context.observable(); assertNotEquals( observableValue.getLastTrackerTransactionId(), context.getTransaction().getId() ); assertEquals( context.getTransaction().safeGetObservables().size(), 0 ); observableValue.reportObserved(); assertEquals( observableValue.getLastTrackerTransactionId(), context.getTransaction().getId() ); assertEquals( context.getTransaction().safeGetObservables().size(), 1 ); assertTrue( context.getTransaction().safeGetObservables().contains( observableValue ) ); }
### Question: ObservableValue extends Node { public void reportObservedIfTrackingTransactionActive() { if ( getContext().isTrackingTransactionActive() ) { reportObserved(); } } ObservableValue( @Nullable final ArezContext context, @Nullable final Component component, @Nullable final String name, @Nullable final Observer observer, @Nullable final PropertyAccessor<T> accessor, @Nullable final PropertyMutator<T> mutator ); @Override void dispose(); @Override boolean isDisposed(); void reportObserved(); void reportObservedIfTrackingTransactionActive(); @OmitSymbol( unless = "arez.check_invariants" ) void preReportChanged(); void reportChanged(); }### Answer: @Test public void reportObservedIfTrackingTransactionActive() { final ArezContext context = Arez.context(); final ObservableValue<?> observableValue = context.observable(); observableValue.reportObservedIfTrackingTransactionActive(); context.safeAction( observableValue::reportObservedIfTrackingTransactionActive, ActionFlags.NO_VERIFY_ACTION_REQUIRED ); assertThrows( () -> context.safeAction( observableValue::reportObservedIfTrackingTransactionActive ) ); final Observer observer = context.observer( observableValue::reportObservedIfTrackingTransactionActive ); assertTrue( observer.getDependencies().contains( observableValue ) ); }
### Question: ObservableValue extends Node { @OmitSymbol( unless = "arez.check_invariants" ) public void preReportChanged() { if ( Arez.shouldCheckInvariants() ) { getContext().getTransaction().preReportChanged( this ); } } ObservableValue( @Nullable final ArezContext context, @Nullable final Component component, @Nullable final String name, @Nullable final Observer observer, @Nullable final PropertyAccessor<T> accessor, @Nullable final PropertyMutator<T> mutator ); @Override void dispose(); @Override boolean isDisposed(); void reportObserved(); void reportObservedIfTrackingTransactionActive(); @OmitSymbol( unless = "arez.check_invariants" ) void preReportChanged(); void reportChanged(); }### Answer: @Test public void preReportChanged() { final ArezContext context = Arez.context(); final Observer observer = newReadWriteObserver( context ); setCurrentTransaction( observer ); final ObservableValue<?> observableValue = context.observable(); observableValue.preReportChanged(); }
### Question: ObservableValue extends Node { void setWorkState( final int workState ) { _workState = workState; } ObservableValue( @Nullable final ArezContext context, @Nullable final Component component, @Nullable final String name, @Nullable final Observer observer, @Nullable final PropertyAccessor<T> accessor, @Nullable final PropertyMutator<T> mutator ); @Override void dispose(); @Override boolean isDisposed(); void reportObserved(); void reportObservedIfTrackingTransactionActive(); @OmitSymbol( unless = "arez.check_invariants" ) void preReportChanged(); void reportChanged(); }### Answer: @Test public void preReportChanged_onDisposedObservable() { final ArezContext context = Arez.context(); setCurrentTransaction( newReadWriteObserver( context ) ); final ObservableValue<?> observableValue = context.observable(); observableValue.setWorkState( ObservableValue.DISPOSED ); assertInvariantFailure( observableValue::preReportChanged, "Arez-0144: Invoked reportChanged on transaction named '" + Transaction.current().getName() + "' for ObservableValue named '" + observableValue.getName() + "' where the ObservableValue is disposed." ); }
### Question: ObservableValue extends Node { public void reportChanged() { if ( willPropagateSpyEvents() ) { reportSpyEvent( new ObservableValueChangeEvent( asInfo(), getObservableValue() ) ); } getContext().getTransaction().reportChanged( this ); } ObservableValue( @Nullable final ArezContext context, @Nullable final Component component, @Nullable final String name, @Nullable final Observer observer, @Nullable final PropertyAccessor<T> accessor, @Nullable final PropertyMutator<T> mutator ); @Override void dispose(); @Override boolean isDisposed(); void reportObserved(); void reportObservedIfTrackingTransactionActive(); @OmitSymbol( unless = "arez.check_invariants" ) void preReportChanged(); void reportChanged(); }### Answer: @Test public void reportChanged() { final ArezContext context = Arez.context(); final Observer observer = newReadWriteObserver( context ); setCurrentTransaction( observer ); observer.setState( Observer.Flags.STATE_UP_TO_DATE ); final ObservableValue<?> observableValue = context.observable(); observableValue.setLeastStaleObserverState( Observer.Flags.STATE_UP_TO_DATE ); observableValue.addObserver( observer ); observer.getDependencies().add( observableValue ); assertNotEquals( observableValue.getLastTrackerTransactionId(), context.getTransaction().getId() ); assertEquals( context.getTransaction().safeGetObservables().size(), 0 ); observableValue.reportChanged(); assertEquals( observer.getState(), Observer.Flags.STATE_STALE ); }
### Question: ObservableValue extends Node { void reportPossiblyChanged() { getContext().getTransaction().reportPossiblyChanged( this ); } ObservableValue( @Nullable final ArezContext context, @Nullable final Component component, @Nullable final String name, @Nullable final Observer observer, @Nullable final PropertyAccessor<T> accessor, @Nullable final PropertyMutator<T> mutator ); @Override void dispose(); @Override boolean isDisposed(); void reportObserved(); void reportObservedIfTrackingTransactionActive(); @OmitSymbol( unless = "arez.check_invariants" ) void preReportChanged(); void reportChanged(); }### Answer: @Test public void reportPossiblyChanged() { final ArezContext context = Arez.context(); final Observer observer = newReadWriteObserver( context ); setCurrentTransaction( observer ); observer.setState( Observer.Flags.STATE_UP_TO_DATE ); final ComputableValue<String> computableValue = context.computable( () -> "" ); final Observer derivation = computableValue.getObserver(); final ObservableValue<?> observableValue = computableValue.getObservableValue(); derivation.setState( Observer.Flags.STATE_UP_TO_DATE ); observableValue.setLeastStaleObserverState( Observer.Flags.STATE_UP_TO_DATE ); observableValue.addObserver( observer ); observer.getDependencies().add( observableValue ); assertNotEquals( observableValue.getLastTrackerTransactionId(), context.getTransaction().getId() ); assertEquals( context.getTransaction().safeGetObservables().size(), 0 ); observableValue.reportPossiblyChanged(); assertEquals( observer.getState(), Observer.Flags.STATE_POSSIBLY_STALE ); }
### Question: ObservableValue extends Node { void reportChangeConfirmed() { if ( willPropagateSpyEvents() ) { reportSpyEvent( new ObservableValueChangeEvent( asInfo(), getObservableValue() ) ); } getContext().getTransaction().reportChangeConfirmed( this ); } ObservableValue( @Nullable final ArezContext context, @Nullable final Component component, @Nullable final String name, @Nullable final Observer observer, @Nullable final PropertyAccessor<T> accessor, @Nullable final PropertyMutator<T> mutator ); @Override void dispose(); @Override boolean isDisposed(); void reportObserved(); void reportObservedIfTrackingTransactionActive(); @OmitSymbol( unless = "arez.check_invariants" ) void preReportChanged(); void reportChanged(); }### Answer: @Test public void reportChangeConfirmed() { final ArezContext context = Arez.context(); final Observer observer = newReadWriteObserver( context ); setCurrentTransaction( observer ); observer.setState( Observer.Flags.STATE_POSSIBLY_STALE ); final ComputableValue<String> computableValue = context.computable( () -> "" ); final Observer derivation = computableValue.getObserver(); final ObservableValue<?> observableValue = computableValue.getObservableValue(); derivation.setState( Observer.Flags.STATE_UP_TO_DATE ); observableValue.setLeastStaleObserverState( Observer.Flags.STATE_POSSIBLY_STALE ); observableValue.addObserver( observer ); observer.getDependencies().add( observableValue ); assertNotEquals( observableValue.getLastTrackerTransactionId(), context.getTransaction().getId() ); assertEquals( context.getTransaction().safeGetObservables().size(), 0 ); observableValue.reportChangeConfirmed(); assertEquals( observer.getState(), Observer.Flags.STATE_STALE ); }
### Question: ArezUtil { @Nonnull @OmitSymbol( unless = "arez.enable_names" ) static String throwableToString( @Nonnull final Throwable throwable ) { final StringBuilder sb = new StringBuilder(); Throwable t = throwable; while ( null != t ) { addCausedByPrefix( sb ); sb.append( t.toString() ); for ( final StackTraceElement element : t.getStackTrace() ) { sb.append( "\n at " ).append( element ); } t = t.getCause(); } return sb.toString(); } private ArezUtil(); }### Answer: @Test public void throwableToString() { final String text = ArezUtil.throwableToString( new RuntimeException( "X" ) ); assertTrue( text.startsWith( "java.lang.RuntimeException: X\n" ) ); } @Test public void throwableToString_with_NestedThrowable() { final RuntimeException exception = new RuntimeException( "X", new IOException( "Y" ) ); final String text = ArezUtil.throwableToString( exception ); assertTrue( text.startsWith( "java.lang.RuntimeException: X\n" ) ); assertTrue( text.contains( "\nCaused by: java.io.IOException: Y\n" ) ); }
### Question: ObservableValue extends Node { @SuppressWarnings( "ConstantConditions" ) @OmitSymbol( unless = "arez.enable_spies" ) @Nonnull ObservableValueInfo asInfo() { if ( Arez.shouldCheckInvariants() ) { invariant( Arez::areSpiesEnabled, () -> "Arez-0196: ObservableValue.asInfo() invoked but Arez.areSpiesEnabled() returned false." ); } if ( Arez.areSpiesEnabled() && null == _info ) { _info = new ObservableValueInfoImpl( this ); } return Arez.areSpiesEnabled() ? _info : null; } ObservableValue( @Nullable final ArezContext context, @Nullable final Component component, @Nullable final String name, @Nullable final Observer observer, @Nullable final PropertyAccessor<T> accessor, @Nullable final PropertyMutator<T> mutator ); @Override void dispose(); @Override boolean isDisposed(); void reportObserved(); void reportObservedIfTrackingTransactionActive(); @OmitSymbol( unless = "arez.check_invariants" ) void preReportChanged(); void reportChanged(); }### Answer: @Test public void asInfo() { final ObservableValue<String> observableValue = Arez.context().observable(); final ObservableValueInfo info = observableValue.asInfo(); assertEquals( info.getName(), observableValue.getName() ); }
### Question: Component implements Disposable { @Nonnull public Object getId() { return _id; } Component( @Nullable final ArezContext context, @Nonnull final String type, @Nonnull final Object id, @Nullable final String name, @Nullable final SafeProcedure preDispose, @Nullable final SafeProcedure postDispose ); @Nonnull String getType(); @Nonnull Object getId(); @Nonnull String getName(); @Override void dispose(); @Override boolean isDisposed(); @Nonnull @Override String toString(); boolean isComplete(); void complete(); }### Answer: @Test public void basicOperationIntegerId() { final Integer id = ValueUtil.randomInt(); final Component component = new Component( Arez.context(), ValueUtil.randomString(), id, ValueUtil.randomString(), null, null ); assertEquals( component.getId(), id ); }
### Question: Component implements Disposable { public void complete() { if ( !_complete ) { _complete = true; if ( Arez.areSpiesEnabled() && getContext().getSpy().willPropagateSpyEvents() ) { final ComponentInfo component = getContext().getSpy().asComponentInfo( this ); getContext().getSpy().reportSpyEvent( new ComponentCreateCompleteEvent( component ) ); } } } Component( @Nullable final ArezContext context, @Nonnull final String type, @Nonnull final Object id, @Nullable final String name, @Nullable final SafeProcedure preDispose, @Nullable final SafeProcedure postDispose ); @Nonnull String getType(); @Nonnull Object getId(); @Nonnull String getName(); @Override void dispose(); @Override boolean isDisposed(); @Nonnull @Override String toString(); boolean isComplete(); void complete(); }### Answer: @Test public void complete() { final ArezContext context = Arez.context(); final String name = ValueUtil.randomString(); final Component component = context.component( ValueUtil.randomString(), ValueUtil.randomString(), name ); final ObservableValue<?> observableValue1 = context.observable(); final ComputableValue<?> computableValue1 = context.computable( () -> "" ); final Observer observer1 = context.observer( AbstractTest::observeADependency ); component.addObservableValue( observableValue1 ); component.addComputableValue( computableValue1 ); component.addObserver( observer1 ); assertFalse( component.isComplete() ); component.complete(); assertTrue( component.isComplete() ); assertEquals( component.getObservableValues().size(), 1 ); assertEquals( component.getComputableValues().size(), 1 ); assertEquals( component.getObservers().size(), 1 ); }
### Question: Component implements Disposable { @Override public void dispose() { if ( !_disposed ) { _disposed = true; if ( Arez.areSpiesEnabled() && getContext().getSpy().willPropagateSpyEvents() ) { final ComponentInfo info = getContext().getSpy().asComponentInfo( this ); getContext().getSpy().reportSpyEvent( new ComponentDisposeStartEvent( info ) ); } getContext().safeAction( Arez.areNamesEnabled() ? getName() + ".dispose" : null, () -> { if ( null != _preDispose ) { _preDispose.call(); } getContext().deregisterComponent( this ); new ArrayList<>( _observers ).forEach( o -> Disposable.dispose( o ) ); new ArrayList<>( _computableValues ).forEach( v -> Disposable.dispose( v ) ); new ArrayList<>( _observableValues ).forEach( o -> Disposable.dispose( o ) ); if ( null != _postDispose ) { _postDispose.call(); } }, ActionFlags.NO_VERIFY_ACTION_REQUIRED ); if ( Arez.areSpiesEnabled() && getContext().getSpy().willPropagateSpyEvents() ) { final ComponentInfo info = getContext().getSpy().asComponentInfo( this ); getContext().getSpy().reportSpyEvent( new ComponentDisposeCompleteEvent( info ) ); } } } Component( @Nullable final ArezContext context, @Nonnull final String type, @Nonnull final Object id, @Nullable final String name, @Nullable final SafeProcedure preDispose, @Nullable final SafeProcedure postDispose ); @Nonnull String getType(); @Nonnull Object getId(); @Nonnull String getName(); @Override void dispose(); @Override boolean isDisposed(); @Nonnull @Override String toString(); boolean isComplete(); void complete(); }### Answer: @Test public void dispose() { final ArezContext context = Arez.context(); final String name = ValueUtil.randomString(); final Component component = context.component( ValueUtil.randomString(), ValueUtil.randomString(), name ); final ObservableValue<?> observableValue1 = context.observable( component, ValueUtil.randomString(), null, null ); final ObservableValue<?> observableValue2 = context.observable( component, ValueUtil.randomString(), null, null ); final ComputableValue<?> computableValue1 = context.computable( component, ValueUtil.randomString(), () -> "", null, null ); final ComputableValue<?> computableValue2 = context.computable( component, ValueUtil.randomString(), () -> "", null, null ); final Procedure action = AbstractTest::observeADependency; final Observer observer1 = context.observer( component, null, action, Observer.Flags.RUN_LATER ); final Observer observer2 = context.observer( component, null, action, Observer.Flags.RUN_LATER ); assertEquals( component.getObservableValues().size(), 2 ); assertEquals( component.getComputableValues().size(), 2 ); assertEquals( component.getObservers().size(), 2 ); assertFalse( Disposable.isDisposed( component ) ); assertFalse( Disposable.isDisposed( observableValue1 ) ); assertFalse( Disposable.isDisposed( observableValue2 ) ); assertFalse( Disposable.isDisposed( observer1 ) ); assertFalse( Disposable.isDisposed( observer2 ) ); assertFalse( Disposable.isDisposed( computableValue1 ) ); assertFalse( Disposable.isDisposed( computableValue2 ) ); assertTrue( context.isComponentPresent( component.getType(), component.getId() ) ); component.dispose(); assertFalse( context.isComponentPresent( component.getType(), component.getId() ) ); assertEquals( component.getObservableValues().size(), 0 ); assertEquals( component.getComputableValues().size(), 0 ); assertEquals( component.getObservers().size(), 0 ); assertTrue( Disposable.isDisposed( component ) ); assertTrue( Disposable.isDisposed( observableValue1 ) ); assertTrue( Disposable.isDisposed( observableValue2 ) ); assertTrue( Disposable.isDisposed( observer1 ) ); assertTrue( Disposable.isDisposed( observer2 ) ); assertTrue( Disposable.isDisposed( computableValue1 ) ); assertTrue( Disposable.isDisposed( computableValue2 ) ); }
### Question: Component implements Disposable { @SuppressWarnings( "ConstantConditions" ) @OmitSymbol( unless = "arez.enable_spies" ) @Nonnull ComponentInfo asInfo() { if ( Arez.shouldCheckInvariants() ) { invariant( Arez::areSpiesEnabled, () -> "Arez-0194: Component.asInfo() invoked but Arez.areSpiesEnabled() returned false." ); } if ( Arez.areSpiesEnabled() && null == _info ) { _info = new ComponentInfoImpl( this ); } return Arez.areSpiesEnabled() ? _info : null; } Component( @Nullable final ArezContext context, @Nonnull final String type, @Nonnull final Object id, @Nullable final String name, @Nullable final SafeProcedure preDispose, @Nullable final SafeProcedure postDispose ); @Nonnull String getType(); @Nonnull Object getId(); @Nonnull String getName(); @Override void dispose(); @Override boolean isDisposed(); @Nonnull @Override String toString(); boolean isComplete(); void complete(); }### Answer: @Test public void asInfo() { final ArezContext context = Arez.context(); final Component component = context.component( ValueUtil.randomString(), ValueUtil.randomString(), ValueUtil.randomString() ); final ComponentInfo info = component.asInfo(); assertEquals( info.getId(), component.getId() ); assertEquals( info.getName(), component.getName() ); assertEquals( info.getType(), component.getType() ); }
### Question: Component implements Disposable { Component( @Nullable final ArezContext context, @Nonnull final String type, @Nonnull final Object id, @Nullable final String name, @Nullable final SafeProcedure preDispose, @Nullable final SafeProcedure postDispose ) { if ( Arez.shouldCheckApiInvariants() ) { apiInvariant( () -> Arez.areNamesEnabled() \|\| null == name, () -> "Arez-0037: Component passed a name '" + name + "' but Arez.areNamesEnabled() is false" ); invariant( () -> Arez.areZonesEnabled() \|\| null == context, () -> "Arez-0175: Component passed a context but Arez.areZonesEnabled() is false" ); } _context = Arez.areZonesEnabled() ? Objects.requireNonNull( context ) : null; _type = Objects.requireNonNull( type ); _id = Objects.requireNonNull( id ); _name = Arez.areNamesEnabled() ? Objects.requireNonNull( name ) : null; _preDispose = preDispose; _postDispose = postDispose; } Component( @Nullable final ArezContext context, @Nonnull final String type, @Nonnull final Object id, @Nullable final String name, @Nullable final SafeProcedure preDispose, @Nullable final SafeProcedure postDispose ); @Nonnull String getType(); @Nonnull Object getId(); @Nonnull String getName(); @Override void dispose(); @Override boolean isDisposed(); @Nonnull @Override String toString(); boolean isComplete(); void complete(); }### Answer: @Test public void asInfo_spyDisabled() { ArezTestUtil.disableSpies(); final ArezContext context = Arez.context(); final Component component = context.component( ValueUtil.randomString(), ValueUtil.randomString(), ValueUtil.randomString() ); assertInvariantFailure( component::asInfo, "Arez-0194: Component.asInfo() invoked but Arez.areSpiesEnabled() returned false." ); }
### Question: Observer extends Node { void invariantDependenciesBackLink( @Nonnull final String context ) { if ( Arez.shouldCheckInvariants() ) { getDependencies().forEach( observable -> invariant( () -> observable.getObservers().contains( this ), () -> "Arez-0090: " + context + ": Observer named '" + getName() + "' has ObservableValue dependency named '" + observable.getName() + "' which does not contain the observer in the list of " + "observers." ) ); invariantComputableValueObserverState(); } } Observer( @Nonnull final ComputableValue<?> computableValue, final int flags ); Observer( @Nullable final ArezContext context, @Nullable final Component component, @Nullable final String name, @Nullable final Procedure observe, @Nullable final Procedure onDepsChange, final int flags ); private Observer( @Nullable final ArezContext context, @Nullable final Component component, @Nullable final String name, @Nullable final ComputableValue<?> computableValue, @Nullable final Procedure observe, @Nullable final Procedure onDepsChange, final int flags ); @Override void dispose(); @Override boolean isDisposed(); void reportStale(); void schedule(); }### Answer: @Test public void invariantDependenciesBackLink() { final Observer observer = Arez.context().observer( new CountAndObserveProcedure() ); setCurrentTransaction( observer ); final ObservableValue<?> observableValue = Arez.context().observable(); observer.getDependencies().add( observableValue ); assertInvariantFailure( () -> observer.invariantDependenciesBackLink( "TEST1" ), "Arez-0090: TEST1: Observer named '" + observer.getName() + "' has ObservableValue " + "dependency named '" + observableValue.getName() + "' which does not contain the observer in " + "the list of observers." ); observableValue.addObserver( observer ); observer.invariantDependenciesBackLink( "TEST2" ); }
### Question: Observer extends Node { void invariantDependenciesNotDisposed() { if ( Arez.shouldCheckInvariants() ) { getDependencies().forEach( observable -> invariant( observable::isNotDisposed, () -> "Arez-0091: Observer named '" + getName() + "' has " + "ObservableValue dependency named '" + observable.getName() + "' which is disposed." ) ); invariantComputableValueObserverState(); } } Observer( @Nonnull final ComputableValue<?> computableValue, final int flags ); Observer( @Nullable final ArezContext context, @Nullable final Component component, @Nullable final String name, @Nullable final Procedure observe, @Nullable final Procedure onDepsChange, final int flags ); private Observer( @Nullable final ArezContext context, @Nullable final Component component, @Nullable final String name, @Nullable final ComputableValue<?> computableValue, @Nullable final Procedure observe, @Nullable final Procedure onDepsChange, final int flags ); @Override void dispose(); @Override boolean isDisposed(); void reportStale(); void schedule(); }### Answer: @Test public void invariantDependenciesNotDisposed() { final Observer observer = Arez.context().observer( new CountAndObserveProcedure() ); setCurrentTransaction( observer ); final ObservableValue<?> observableValue = Arez.context().observable(); observer.getDependencies().add( observableValue ); observableValue.addObserver( observer ); observableValue.setWorkState( ObservableValue.DISPOSED ); assertInvariantFailure( observer::invariantDependenciesNotDisposed, "Arez-0091: Observer named '" + observer.getName() + "' has ObservableValue dependency named '" + observableValue.getName() + "' which is disposed." ); observableValue.setWorkState( 0 ); observer.invariantDependenciesNotDisposed(); }
### Question: Observer extends Node { void invariantDependenciesUnique( @Nonnull final String context ) { if ( Arez.shouldCheckInvariants() ) { invariant( () -> getDependencies().size() == new HashSet<>( getDependencies() ).size(), () -> "Arez-0089: " + context + ": The set of dependencies in observer named '" + getName() + "' is not unique. Current list: '" + getDependencies().stream().map( Node::getName ).collect( Collectors.toList() ) + "'." ); } } Observer( @Nonnull final ComputableValue<?> computableValue, final int flags ); Observer( @Nullable final ArezContext context, @Nullable final Component component, @Nullable final String name, @Nullable final Procedure observe, @Nullable final Procedure onDepsChange, final int flags ); private Observer( @Nullable final ArezContext context, @Nullable final Component component, @Nullable final String name, @Nullable final ComputableValue<?> computableValue, @Nullable final Procedure observe, @Nullable final Procedure onDepsChange, final int flags ); @Override void dispose(); @Override boolean isDisposed(); void reportStale(); void schedule(); }### Answer: @Test public void invariantDependenciesUnique() { final ArezContext context = Arez.context(); final ObservableValue<Object> observable = context.observable(); final Observer observer = context.observer( observable::reportObserved ); observer.invariantDependenciesUnique( "TEST1" ); observer.getDependencies().add( observable ); assertInvariantFailure( () -> observer.invariantDependenciesUnique( "TEST2" ), "Arez-0089: TEST2: The set of dependencies in observer named '" + observer.getName() + "' is not unique. Current list: '[" + observable.getName() + ", " + observable.getName() + "]'." ); }
### Question: Observer extends Node { void invariantState() { if ( Arez.shouldCheckInvariants() ) { if ( isInactive() && !isDisposing() ) { invariant( () -> getDependencies().isEmpty(), () -> "Arez-0092: Observer named '" + getName() + "' is inactive but still has dependencies: " + getDependencies().stream().map( Node::getName ).collect( Collectors.toList() ) + "." ); } if ( null != _computableValue && _computableValue.isNotDisposed() ) { final ObservableValue<?> observable = _computableValue.getObservableValue(); invariant( () -> Objects.equals( observable.isComputableValue() ? observable.getObserver() : null, this ), () -> "Arez-0093: Observer named '" + getName() + "' is associated with an ObservableValue that " + "does not link back to observer." ); } } } Observer( @Nonnull final ComputableValue<?> computableValue, final int flags ); Observer( @Nullable final ArezContext context, @Nullable final Component component, @Nullable final String name, @Nullable final Procedure observe, @Nullable final Procedure onDepsChange, final int flags ); private Observer( @Nullable final ArezContext context, @Nullable final Component component, @Nullable final String name, @Nullable final ComputableValue<?> computableValue, @Nullable final Procedure observe, @Nullable final Procedure onDepsChange, final int flags ); @Override void dispose(); @Override boolean isDisposed(); void reportStale(); void schedule(); }### Answer: @Test public void invariantState() { final ArezContext context = Arez.context(); final ObservableValue<Object> observable = context.observable(); final Observer observer = context.observer( new CountingProcedure(), Observer.Flags.RUN_LATER ); observer.invariantState(); observer.getDependencies().add( observable ); assertInvariantFailure( observer::invariantState, "Arez-0092: Observer named '" + observer.getName() + "' is inactive " + "but still has dependencies: [" + observable.getName() + "]." ); }
### Question: Observer extends Node { void replaceDependencies( @Nonnull final List<ObservableValue<?>> dependencies ) { if ( Arez.shouldCheckInvariants() ) { invariantDependenciesUnique( "Pre replaceDependencies" ); } _dependencies = Objects.requireNonNull( dependencies ); if ( Arez.shouldCheckInvariants() ) { invariantDependenciesUnique( "Post replaceDependencies" ); invariantDependenciesBackLink( "Post replaceDependencies" ); invariantDependenciesNotDisposed(); } } Observer( @Nonnull final ComputableValue<?> computableValue, final int flags ); Observer( @Nullable final ArezContext context, @Nullable final Component component, @Nullable final String name, @Nullable final Procedure observe, @Nullable final Procedure onDepsChange, final int flags ); private Observer( @Nullable final ArezContext context, @Nullable final Component component, @Nullable final String name, @Nullable final ComputableValue<?> computableValue, @Nullable final Procedure observe, @Nullable final Procedure onDepsChange, final int flags ); @Override void dispose(); @Override boolean isDisposed(); void reportStale(); void schedule(); }### Answer: @Test public void replaceDependencies() { final ArezContext context = Arez.context(); final ObservableValue<Object> observable = context.observable(); final Observer observer = context.observer( new CountingProcedure(), Observer.Flags.AREZ_OR_NO_DEPENDENCIES ); final List<ObservableValue<?>> originalDependencies = observer.getDependencies(); assertTrue( originalDependencies.isEmpty() ); context.safeAction( () -> { final List<ObservableValue<?>> newDependencies = new ArrayList<>(); newDependencies.add( observable ); observable.rawAddObserver( observer ); observer.replaceDependencies( newDependencies ); assertEquals( observer.getDependencies().size(), 1 ); assertNotSame( observer.getDependencies(), originalDependencies ); assertTrue( observer.getDependencies().contains( observable ) ); }, ActionFlags.NO_VERIFY_ACTION_REQUIRED ); }
### Question: Observer extends Node { void clearDependencies() { getDependencies().forEach( dependency -> { dependency.removeObserver( this ); if ( !dependency.hasObservers() ) { dependency.setLeastStaleObserverState( Flags.STATE_UP_TO_DATE ); } } ); getDependencies().clear(); } Observer( @Nonnull final ComputableValue<?> computableValue, final int flags ); Observer( @Nullable final ArezContext context, @Nullable final Component component, @Nullable final String name, @Nullable final Procedure observe, @Nullable final Procedure onDepsChange, final int flags ); private Observer( @Nullable final ArezContext context, @Nullable final Component component, @Nullable final String name, @Nullable final ComputableValue<?> computableValue, @Nullable final Procedure observe, @Nullable final Procedure onDepsChange, final int flags ); @Override void dispose(); @Override boolean isDisposed(); void reportStale(); void schedule(); }### Answer: @Test public void clearDependencies() { final ArezContext context = Arez.context(); final ObservableValue<?> observableValue1 = context.observable(); final ObservableValue<?> observableValue2 = context.observable(); final Observer observer = context.observer( () -> { observableValue1.reportObserved(); observableValue2.reportObserved(); } ); assertEquals( observer.getDependencies().size(), 2 ); assertEquals( observableValue1.getObservers().size(), 1 ); assertEquals( observableValue2.getObservers().size(), 1 ); context.safeAction( observer::clearDependencies, ActionFlags.NO_VERIFY_ACTION_REQUIRED ); assertEquals( observer.getDependencies().size(), 0 ); assertEquals( observableValue1.getObservers().size(), 0 ); assertEquals( observableValue2.getObservers().size(), 0 ); }
### Question: Observer extends Node { void scheduleReaction() { if ( isNotDisposed() ) { if ( Arez.shouldCheckInvariants() ) { invariant( this::isActive, () -> "Arez-0088: Observer named '" + getName() + "' is not active but an attempt has been made " + "to schedule observer." ); } if ( !getTask().isQueued() ) { getContext().scheduleReaction( this ); } } } Observer( @Nonnull final ComputableValue<?> computableValue, final int flags ); Observer( @Nullable final ArezContext context, @Nullable final Component component, @Nullable final String name, @Nullable final Procedure observe, @Nullable final Procedure onDepsChange, final int flags ); private Observer( @Nullable final ArezContext context, @Nullable final Component component, @Nullable final String name, @Nullable final ComputableValue<?> computableValue, @Nullable final Procedure observe, @Nullable final Procedure onDepsChange, final int flags ); @Override void dispose(); @Override boolean isDisposed(); void reportStale(); void schedule(); }### Answer: @Test public void scheduleReaction() { final Observer observer = Arez.context().observer( new CountAndObserveProcedure() ); setupReadWriteTransaction(); observer.setState( Observer.Flags.STATE_UP_TO_DATE ); assertFalse( observer.getTask().isQueued() ); observer.scheduleReaction(); final ArezContext context = Arez.context(); assertTrue( observer.getTask().isQueued() ); assertEquals( context.getTaskQueue().getOrderedTasks().count(), 1L ); assertTrue( context.getTaskQueue().getOrderedTasks().anyMatch( o -> o == observer.getTask() ) ); observer.scheduleReaction(); assertTrue( observer.getTask().isQueued() ); assertEquals( context.getTaskQueue().getOrderedTasks().count(), 1L ); assertTrue( context.getTaskQueue().getOrderedTasks().anyMatch( o -> o == observer.getTask() ) ); }
### Question: Observer extends Node { @Override public void dispose() { if ( isNotDisposedOrDisposing() ) { getContext().safeAction( Arez.areNamesEnabled() ? getName() + ".dispose" : null, this::performDispose, ActionFlags.NO_VERIFY_ACTION_REQUIRED ); if ( !isComputableValue() ) { if ( willPropagateSpyEvents() ) { reportSpyEvent( new ObserverDisposeEvent( asInfo() ) ); } if ( null != _component ) { _component.removeObserver( this ); } else if ( Arez.areRegistriesEnabled() ) { getContext().deregisterObserver( this ); } } if ( null != _computableValue ) { _computableValue.dispose(); } _task.dispose(); markAsDisposed(); } } Observer( @Nonnull final ComputableValue<?> computableValue, final int flags ); Observer( @Nullable final ArezContext context, @Nullable final Component component, @Nullable final String name, @Nullable final Procedure observe, @Nullable final Procedure onDepsChange, final int flags ); private Observer( @Nullable final ArezContext context, @Nullable final Component component, @Nullable final String name, @Nullable final ComputableValue<?> computableValue, @Nullable final Procedure observe, @Nullable final Procedure onDepsChange, final int flags ); @Override void dispose(); @Override boolean isDisposed(); void reportStale(); void schedule(); }### Answer: @Test public void dispose() { final Observer observer = Arez.context().observer( new CountAndObserveProcedure() ); setCurrentTransaction( observer ); observer.setState( Observer.Flags.STATE_UP_TO_DATE ); Transaction.setTransaction( null ); assertEquals( observer.getState(), Observer.Flags.STATE_UP_TO_DATE ); assertTrue( observer.isNotDisposed() ); assertFalse( observer.isDisposed() ); assertFalse( observer.getTask().isDisposed() ); observer.dispose(); assertEquals( observer.getState(), Observer.Flags.STATE_DISPOSED ); assertFalse( observer.isNotDisposed() ); assertTrue( observer.isDisposed() ); assertTrue( observer.getTask().isDisposed() ); final ArezContext context = Arez.context(); final int currentNextTransactionId = context.currentNextTransactionId(); observer.dispose(); assertEquals( context.currentNextTransactionId(), currentNextTransactionId ); }
### Question: Observer extends Node { void markDependenciesLeastStaleObserverAsUpToDate() { for ( final ObservableValue<?> dependency : getDependencies() ) { dependency.setLeastStaleObserverState( Flags.STATE_UP_TO_DATE ); } } Observer( @Nonnull final ComputableValue<?> computableValue, final int flags ); Observer( @Nullable final ArezContext context, @Nullable final Component component, @Nullable final String name, @Nullable final Procedure observe, @Nullable final Procedure onDepsChange, final int flags ); private Observer( @Nullable final ArezContext context, @Nullable final Component component, @Nullable final String name, @Nullable final ComputableValue<?> computableValue, @Nullable final Procedure observe, @Nullable final Procedure onDepsChange, final int flags ); @Override void dispose(); @Override boolean isDisposed(); void reportStale(); void schedule(); }### Answer: @Test public void markDependenciesLeastStaleObserverAsUpToDate() { final Observer observer = Arez.context().observer( new CountAndObserveProcedure() ); final ObservableValue<?> observableValue1 = Arez.context().observable(); final ObservableValue<?> observableValue2 = Arez.context().observable(); final ObservableValue<?> observableValue3 = Arez.context().observable(); observer.getDependencies().add( observableValue1 ); observer.getDependencies().add( observableValue2 ); observer.getDependencies().add( observableValue3 ); setCurrentTransaction( observer ); observableValue1.addObserver( observer ); observableValue2.addObserver( observer ); observableValue3.addObserver( observer ); observableValue1.setLeastStaleObserverState( Observer.Flags.STATE_UP_TO_DATE ); observableValue2.setLeastStaleObserverState( Observer.Flags.STATE_POSSIBLY_STALE ); observableValue3.setLeastStaleObserverState( Observer.Flags.STATE_STALE ); observer.markDependenciesLeastStaleObserverAsUpToDate(); assertEquals( observableValue1.getLeastStaleObserverState(), Observer.Flags.STATE_UP_TO_DATE ); assertEquals( observableValue2.getLeastStaleObserverState(), Observer.Flags.STATE_UP_TO_DATE ); assertEquals( observableValue3.getLeastStaleObserverState(), Observer.Flags.STATE_UP_TO_DATE ); }
### Question: Observer extends Node { void invokeReaction() { if ( isNotDisposed() ) { final long start; if ( willPropagateSpyEvents() ) { start = System.currentTimeMillis(); if ( isComputableValue() ) { reportSpyEvent( new ComputeStartEvent( getComputableValue().asInfo() ) ); } else { reportSpyEvent( new ObserveStartEvent( asInfo() ) ); } } else { start = 0; } Throwable error = null; try { if ( Flags.STATE_UP_TO_DATE != getState() ) { if ( shouldExecuteObserveNext() ) { executeOnDepsChangeNextIfPresent(); runObserveFunction(); } else { assert null != _onDepsChange; _onDepsChange.call(); } } else if ( shouldExecuteObserveNext() ) { executeOnDepsChangeNextIfPresent(); } } catch ( final Throwable t ) { error = t; getContext().reportObserverError( this, ObserverError.REACTION_ERROR, t ); } if ( willPropagateSpyEvents() ) { final long duration = System.currentTimeMillis() - start; if ( isComputableValue() ) { final ComputableValue<?> computableValue = getComputableValue(); reportSpyEvent( new ComputeCompleteEvent( computableValue.asInfo(), noReportResults() ? null : computableValue.getValue(), computableValue.getError(), (int) duration ) ); } else { reportSpyEvent( new ObserveCompleteEvent( asInfo(), error, (int) duration ) ); } } } } Observer( @Nonnull final ComputableValue<?> computableValue, final int flags ); Observer( @Nullable final ArezContext context, @Nullable final Component component, @Nullable final String name, @Nullable final Procedure observe, @Nullable final Procedure onDepsChange, final int flags ); private Observer( @Nullable final ArezContext context, @Nullable final Component component, @Nullable final String name, @Nullable final ComputableValue<?> computableValue, @Nullable final Procedure observe, @Nullable final Procedure onDepsChange, final int flags ); @Override void dispose(); @Override boolean isDisposed(); void reportStale(); void schedule(); }### Answer: @Test public void invokeReaction() { ignoreObserverErrors(); final ArezContext context = Arez.context(); final AtomicInteger errorCount = new AtomicInteger(); context.addObserverErrorHandler( ( observer, error, throwable ) -> errorCount.incrementAndGet() ); final CountAndObserveProcedure observed = new CountAndObserveProcedure(); final Observer observer = new Observer( context, null, ValueUtil.randomString(), observed, null, 0 ); observer.invokeReaction(); assertEquals( observed.getCallCount(), 1 ); assertEquals( errorCount.get(), 0 ); }
### Question: Observer extends Node { Observer( @Nonnull final ComputableValue<?> computableValue, final int flags ) { this( Arez.areZonesEnabled() ? computableValue.getContext() : null, null, Arez.areNamesEnabled() ? computableValue.getName() : null, computableValue, computableValue::compute, null, flags \| ( Flags.KEEPALIVE == Flags.getScheduleType( flags ) ? 0 : Flags.DEACTIVATE_ON_UNOBSERVE ) \| Task.Flags.runType( flags, Flags.KEEPALIVE == Flags.getScheduleType( flags ) ? Task.Flags.RUN_NOW : Task.Flags.RUN_LATER ) \| ( Arez.shouldEnforceTransactionType() ? Flags.READ_ONLY : 0 ) \| Flags.NESTED_ACTIONS_DISALLOWED \| Flags.dependencyType( flags ) ); } Observer( @Nonnull final ComputableValue<?> computableValue, final int flags ); Observer( @Nullable final ArezContext context, @Nullable final Component component, @Nullable final String name, @Nullable final Procedure observe, @Nullable final Procedure onDepsChange, final int flags ); private Observer( @Nullable final ArezContext context, @Nullable final Component component, @Nullable final String name, @Nullable final ComputableValue<?> computableValue, @Nullable final Procedure observe, @Nullable final Procedure onDepsChange, final int flags ); @Override void dispose(); @Override boolean isDisposed(); void reportStale(); void schedule(); }### Answer: @Test public void invokeReaction_reactionGeneratesError() { ignoreObserverErrors(); final AtomicInteger errorCount = new AtomicInteger(); final RuntimeException exception = new RuntimeException( "X" ); final ArezContext context = Arez.context(); context.addObserverErrorHandler( ( observer, error, throwable ) -> { errorCount.incrementAndGet(); assertEquals( error, ObserverError.REACTION_ERROR ); assertEquals( throwable, exception ); } ); final CountingProcedure observed = new CountingProcedure() { @Override public void call() throws Throwable { super.call(); throw exception; } }; final Observer observer = context.observer( observed, Observer.Flags.RUN_LATER ); final TestSpyEventHandler handler = TestSpyEventHandler.subscribe(); context.triggerScheduler(); assertEquals( observed.getCallCount(), 1 ); assertEquals( errorCount.get(), 1 ); handler.assertEventCount( 7 ); handler.assertNextEvent( ObserveStartEvent.class, e -> assertEquals( e.getObserver().getName(), observer.getName() ) ); handler.assertNextEvent( ActionStartEvent.class ); handler.assertNextEvent( TransactionStartEvent.class ); handler.assertNextEvent( TransactionCompleteEvent.class ); handler.assertNextEvent( ActionCompleteEvent.class ); handler.assertNextEvent( ObserverErrorEvent.class, e -> { assertEquals( e.getObserver().getName(), observer.getName() ); assertEquals( e.getError(), ObserverError.REACTION_ERROR ); assertEquals( e.getThrowable(), exception ); } ); handler.assertNextEvent( ObserveCompleteEvent.class, e -> { assertEquals( e.getObserver().getName(), observer.getName() ); assertEquals( e.getThrowable(), exception ); assertTrue( e.getDuration() >= 0 ); } ); }
### Question: Observer extends Node { @SuppressWarnings( "ConstantConditions" ) @OmitSymbol( unless = "arez.enable_spies" ) @Nonnull ObserverInfo asInfo() { if ( Arez.shouldCheckInvariants() ) { invariant( Arez::areSpiesEnabled, () -> "Arez-0197: Observer.asInfo() invoked but Arez.areSpiesEnabled() returned false." ); } if ( Arez.areSpiesEnabled() && null == _info ) { _info = new ObserverInfoImpl( getContext().getSpy(), this ); } return Arez.areSpiesEnabled() ? _info : null; } Observer( @Nonnull final ComputableValue<?> computableValue, final int flags ); Observer( @Nullable final ArezContext context, @Nullable final Component component, @Nullable final String name, @Nullable final Procedure observe, @Nullable final Procedure onDepsChange, final int flags ); private Observer( @Nullable final ArezContext context, @Nullable final Component component, @Nullable final String name, @Nullable final ComputableValue<?> computableValue, @Nullable final Procedure observe, @Nullable final Procedure onDepsChange, final int flags ); @Override void dispose(); @Override boolean isDisposed(); void reportStale(); void schedule(); }### Answer: @Test public void asInfo() { final Observer observer = Arez.context().tracker( ValueUtil::randomString ); final ObserverInfo info = observer.asInfo(); assertEquals( info.getName(), observer.getName() ); }
### Question: Observer extends Node { public void reportStale() { if ( Arez.shouldCheckApiInvariants() ) { apiInvariant( this::areExternalDependenciesAllowed, () -> "Arez-0199: Observer.reportStale() invoked on observer named '" + getName() + "' but the observer has not specified AREZ_OR_EXTERNAL_DEPENDENCIES flag." ); apiInvariant( () -> getContext().isTransactionActive(), () -> "Arez-0200: Observer.reportStale() invoked on observer named '" + getName() + "' when there is no active transaction." ); apiInvariant( () -> getContext().getTransaction().isMutation(), () -> "Arez-0201: Observer.reportStale() invoked on observer named '" + getName() + "' when the active transaction '" + getContext().getTransaction().getName() + "' is READ_ONLY rather than READ_WRITE." ); getContext().getTransaction().markTransactionAsUsed(); } setState( Flags.STATE_STALE ); } Observer( @Nonnull final ComputableValue<?> computableValue, final int flags ); Observer( @Nullable final ArezContext context, @Nullable final Component component, @Nullable final String name, @Nullable final Procedure observe, @Nullable final Procedure onDepsChange, final int flags ); private Observer( @Nullable final ArezContext context, @Nullable final Component component, @Nullable final String name, @Nullable final ComputableValue<?> computableValue, @Nullable final Procedure observe, @Nullable final Procedure onDepsChange, final int flags ); @Override void dispose(); @Override boolean isDisposed(); void reportStale(); void schedule(); }### Answer: @Test public void reportStale() { final ArezContext context = Arez.context(); final Observer observer = new Observer( context, null, ValueUtil.randomString(), new CountingProcedure(), new CountingProcedure(), Observer.Flags.AREZ_OR_EXTERNAL_DEPENDENCIES ); context.triggerScheduler(); assertEquals( observer.getState(), Observer.Flags.STATE_UP_TO_DATE ); assertFalse( observer.getTask().isQueued() ); context.safeAction( () -> { observer.reportStale(); assertTrue( observer.getTask().isQueued() ); assertEquals( observer.getState(), Observer.Flags.STATE_STALE ); assertEquals( context.getTaskQueue().getOrderedTasks().count(), 1L ); assertTrue( context.getTaskQueue().getOrderedTasks().anyMatch( o -> o == observer.getTask() ) ); } ); }
### Question: ObserverInfoImpl implements ObserverInfo { @Override public boolean isScheduled() { return _observer.getTask().isQueued(); } ObserverInfoImpl( @Nonnull final Spy spy, @Nonnull final Observer observer ); @Nonnull @Override String getName(); @Override boolean isActive(); @Override boolean isRunning(); @Override boolean isScheduled(); @Override boolean isComputableValue(); @Override boolean isReadOnly(); @Nonnull @Override Priority getPriority(); @Nonnull @Override ComputableValueInfo asComputableValue(); @Nonnull @Override List<ObservableValueInfo> getDependencies(); @Nullable @Override ComponentInfo getComponent(); @Override boolean isDisposed(); @Override String toString(); @Override boolean equals( final Object o ); @Override int hashCode(); }### Answer: @Test public void isScheduled() { final ArezContext context = Arez.context(); final Spy spy = context.getSpy(); final Observer observer = context.observer( new CountAndObserveProcedure() ); final ObserverInfo info = spy.asObserverInfo( observer ); assertFalse( info.isScheduled() ); observer.getTask().markAsQueued(); assertTrue( info.isScheduled() ); }
### Question: Observer extends Node { public void schedule() { if ( Arez.shouldCheckApiInvariants() ) { apiInvariant( this::supportsManualSchedule, () -> "Arez-0202: Observer.schedule() invoked on observer named '" + getName() + "' but supportsManualSchedule() returns false." ); } if ( Arez.shouldEnforceTransactionType() && getContext().isTransactionActive() && Arez.shouldCheckInvariants() ) { getContext().getTransaction().markTransactionAsUsed(); } executeObserveNextIfPresent(); scheduleReaction(); getContext().triggerScheduler(); } Observer( @Nonnull final ComputableValue<?> computableValue, final int flags ); Observer( @Nullable final ArezContext context, @Nullable final Component component, @Nullable final String name, @Nullable final Procedure observe, @Nullable final Procedure onDepsChange, final int flags ); private Observer( @Nullable final ArezContext context, @Nullable final Component component, @Nullable final String name, @Nullable final ComputableValue<?> computableValue, @Nullable final Procedure observe, @Nullable final Procedure onDepsChange, final int flags ); @Override void dispose(); @Override boolean isDisposed(); void reportStale(); void schedule(); }### Answer: @Test public void schedule() { final ArezContext context = Arez.context(); final CountAndObserveProcedure observed = new CountAndObserveProcedure(); final CountingProcedure onDepsChange = new CountingProcedure(); final Observer observer = new Observer( context, null, ValueUtil.randomString(), observed, onDepsChange, Observer.Flags.RUN_LATER ); context.safeAction( () -> { observer.setState( Observer.Flags.STATE_STALE ); context.getTaskQueue().clear(); }, ActionFlags.NO_VERIFY_ACTION_REQUIRED ); assertFalse( observer.getTask().isQueued() ); assertEquals( observed.getCallCount(), 0 ); assertEquals( onDepsChange.getCallCount(), 0 ); final SchedulerLock schedulerLock = context.pauseScheduler(); observer.schedule(); assertTrue( observer.getTask().isQueued() ); assertEquals( context.getTaskQueue().getOrderedTasks().count(), 1L ); assertTrue( context.getTaskQueue().getOrderedTasks().anyMatch( o -> o == observer.getTask() ) ); schedulerLock.dispose(); assertFalse( observer.getTask().isQueued() ); assertEquals( observed.getCallCount(), 1 ); assertEquals( onDepsChange.getCallCount(), 0 ); }
### Question: Observer extends Node { boolean isActive() { return Flags.isActive( _flags ); } Observer( @Nonnull final ComputableValue<?> computableValue, final int flags ); Observer( @Nullable final ArezContext context, @Nullable final Component component, @Nullable final String name, @Nullable final Procedure observe, @Nullable final Procedure onDepsChange, final int flags ); private Observer( @Nullable final ArezContext context, @Nullable final Component component, @Nullable final String name, @Nullable final ComputableValue<?> computableValue, @Nullable final Procedure observe, @Nullable final Procedure onDepsChange, final int flags ); @Override void dispose(); @Override boolean isDisposed(); void reportStale(); void schedule(); }### Answer: @Test public void Flags_isActive() { assertFalse( Observer.Flags.isActive( Observer.Flags.STATE_DISPOSED ) ); assertFalse( Observer.Flags.isActive( Observer.Flags.STATE_DISPOSING ) ); assertFalse( Observer.Flags.isActive( Observer.Flags.STATE_INACTIVE ) ); assertTrue( Observer.Flags.isActive( Observer.Flags.STATE_UP_TO_DATE ) ); assertTrue( Observer.Flags.isActive( Observer.Flags.STATE_POSSIBLY_STALE ) ); assertTrue( Observer.Flags.isActive( Observer.Flags.STATE_STALE ) ); }
### Question: Observer extends Node { int getState() { return Flags.getState( _flags ); } Observer( @Nonnull final ComputableValue<?> computableValue, final int flags ); Observer( @Nullable final ArezContext context, @Nullable final Component component, @Nullable final String name, @Nullable final Procedure observe, @Nullable final Procedure onDepsChange, final int flags ); private Observer( @Nullable final ArezContext context, @Nullable final Component component, @Nullable final String name, @Nullable final ComputableValue<?> computableValue, @Nullable final Procedure observe, @Nullable final Procedure onDepsChange, final int flags ); @Override void dispose(); @Override boolean isDisposed(); void reportStale(); void schedule(); }### Answer: @Test public void Flags_getState() { assertEquals( Observer.Flags.getState( Observer.Flags.PRIORITY_NORMAL \| Observer.Flags.STATE_DISPOSED ), Observer.Flags.STATE_DISPOSED ); assertEquals( Observer.Flags.getState( Observer.Flags.PRIORITY_NORMAL \| Observer.Flags.STATE_DISPOSING ), Observer.Flags.STATE_DISPOSING ); assertEquals( Observer.Flags.getState( Observer.Flags.PRIORITY_NORMAL \| Observer.Flags.STATE_INACTIVE ), Observer.Flags.STATE_INACTIVE ); assertEquals( Observer.Flags.getState( Observer.Flags.PRIORITY_NORMAL \| Observer.Flags.STATE_UP_TO_DATE ), Observer.Flags.STATE_UP_TO_DATE ); assertEquals( Observer.Flags.getState( Observer.Flags.PRIORITY_NORMAL \| Observer.Flags.STATE_POSSIBLY_STALE ), Observer.Flags.STATE_POSSIBLY_STALE ); assertEquals( Observer.Flags.getState( Observer.Flags.PRIORITY_NORMAL \| Observer.Flags.STATE_STALE ), Observer.Flags.STATE_STALE ); }
### Question: Observer extends Node { int getLeastStaleObserverState() { return Flags.getLeastStaleObserverState( _flags ); } Observer( @Nonnull final ComputableValue<?> computableValue, final int flags ); Observer( @Nullable final ArezContext context, @Nullable final Component component, @Nullable final String name, @Nullable final Procedure observe, @Nullable final Procedure onDepsChange, final int flags ); private Observer( @Nullable final ArezContext context, @Nullable final Component component, @Nullable final String name, @Nullable final ComputableValue<?> computableValue, @Nullable final Procedure observe, @Nullable final Procedure onDepsChange, final int flags ); @Override void dispose(); @Override boolean isDisposed(); void reportStale(); void schedule(); }### Answer: @Test public void Flags_getLeastStaleObserverState() { assertEquals( Observer.Flags.getLeastStaleObserverState( Observer.Flags.PRIORITY_NORMAL \| Observer.Flags.STATE_DISPOSED ), Observer.Flags.STATE_UP_TO_DATE ); assertEquals( Observer.Flags.getLeastStaleObserverState( Observer.Flags.PRIORITY_NORMAL \| Observer.Flags.STATE_DISPOSING ), Observer.Flags.STATE_UP_TO_DATE ); assertEquals( Observer.Flags.getLeastStaleObserverState( Observer.Flags.PRIORITY_NORMAL \| Observer.Flags.STATE_INACTIVE ), Observer.Flags.STATE_UP_TO_DATE ); assertEquals( Observer.Flags.getLeastStaleObserverState( Observer.Flags.PRIORITY_NORMAL \| Observer.Flags.STATE_UP_TO_DATE ), Observer.Flags.STATE_UP_TO_DATE ); assertEquals( Observer.Flags.getLeastStaleObserverState( Observer.Flags.PRIORITY_NORMAL \| Observer.Flags.STATE_POSSIBLY_STALE ), Observer.Flags.STATE_POSSIBLY_STALE ); assertEquals( Observer.Flags.getLeastStaleObserverState( Observer.Flags.PRIORITY_NORMAL \| Observer.Flags.STATE_STALE ), Observer.Flags.STATE_STALE ); }
### Question: ArezLogger { static void log( @Nonnull final String message, @Nullable final Throwable throwable ) { c_logger.log( message, throwable ); } private ArezLogger(); }### Answer: @Test public void log() { final String message1 = ValueUtil.randomString(); final String message2 = ValueUtil.randomString(); ArezLogger.log( message1, null ); final Throwable throwable = new Throwable(); ArezLogger.log( message2, throwable ); final List<TestLogger.LogEntry> entries = getTestLogger().getEntries(); assertEquals( entries.size(), 2 ); final TestLogger.LogEntry entry1 = entries.get( 0 ); assertEquals( entry1.getMessage(), message1 ); assertNull( entry1.getThrowable() ); final TestLogger.LogEntry entry2 = entries.get( 1 ); assertEquals( entry2.getMessage(), message2 ); assertEquals( entry2.getThrowable(), throwable ); }
### Question: NoSuchEntityException extends NoResultException { @Override public String toString() { if ( Arez.areNamesEnabled() ) { return "NoSuchEntityException[id=" + _id + ']'; } else { return super.toString(); } } NoSuchEntityException( @Nonnull final Object id ); @Nonnull Object getId(); @Override String toString(); }### Answer: @Test public void toString_NamesDisabled() { ArezTestUtil.disableNames(); final NoSuchEntityException exception = new NoSuchEntityException( 23 ); assertEquals( exception.toString(), "arez.component.NoSuchEntityException" ); }
### Question: TypeBasedLocator implements Locator { public <T> void registerLookup( @Nonnull final Class<T> type, @Nonnull final Function<Object, T> findByIdFunction ) { if ( Arez.shouldCheckApiInvariants() ) { apiInvariant( () -> !_findByIdFunctions.containsKey( type ), () -> "Arez-0188: Attempting to register lookup function for type " + type + " when a function for type already exists." ); } _findByIdFunctions.put( type, findByIdFunction ); } void registerLookup( @Nonnull final Class<T> type, @Nonnull final Function<Object, T> findByIdFunction ); @Nullable @Override @SuppressWarnings( "unchecked" ) T findById( @Nonnull final Class<T> type, @Nonnull final Object id ); }### Answer: @Test public void registerLookup_duplicate() { final TypeBasedLocator locator = new TypeBasedLocator(); locator.registerLookup( A.class, i -> new A() ); assertInvariantFailure( () -> locator.registerLookup( A.class, i -> new A() ), "Arez-0188: Attempting to register lookup function for type class arez.component.TypeBasedLocatorTest$A when a function for type already exists." ); }
### Question: CollectionsUtil { @Nonnull public static <T> Collection<T> wrap( @Nonnull final Collection<T> collection ) { return Arez.areCollectionsPropertiesUnmodifiable() ? Collections.unmodifiableCollection( collection ) : collection; } private CollectionsUtil(); @Nonnull static Collection<T> wrap( @Nonnull final Collection<T> collection ); @Nonnull static Set<T> wrap( @Nonnull final Set<T> set ); @Nonnull static Map<K, V> wrap( @Nonnull final Map<K, V> map ); @Nonnull static List<T> wrap( @Nonnull final List<T> list ); @Nonnull static List<T> asList( @Nonnull final Stream<T> stream ); }### Answer: @Test public void wrap_when_areRepositoryResultsModifiable_isTrue() { final ArrayList<MyEntity> input = new ArrayList<>(); final MyEntity entity = new MyEntity(); input.add( entity ); final List<MyEntity> output = CollectionsUtil.wrap( input ); assertNotSame( output, input ); assertUnmodifiable( output, MyEntity::new ); assertEquals( output.size(), 1 ); assertEquals( output.get( 0 ), entity ); } @Test public void wrap_List_when_areRepositoryResultsModifiable_isFalse() { final List<MyEntity> input = new ArrayList<>(); final MyEntity entity = new MyEntity(); input.add( entity ); ArezTestUtil.makeCollectionPropertiesModifiable(); final Collection<MyEntity> output = CollectionsUtil.wrap( input ); assertCollectionModifiableVariant( input, entity, output ); } @Test public void wrap_Set_when_areRepositoryResultsModifiable_isFalse() { final Set<MyEntity> input = new HashSet<>(); final MyEntity entity = new MyEntity(); input.add( entity ); ArezTestUtil.makeCollectionPropertiesModifiable(); final Collection<MyEntity> output = CollectionsUtil.wrap( input ); assertCollectionModifiableVariant( input, entity, output ); } @Test public void wrap_Collection_when_areRepositoryResultsModifiable_isFalse() { final Collection<MyEntity> input = new HashSet<>(); final MyEntity entity = new MyEntity(); input.add( entity ); ArezTestUtil.makeCollectionPropertiesModifiable(); final Collection<MyEntity> output = CollectionsUtil.wrap( input ); assertCollectionModifiableVariant( input, entity, output ); } @Test public void wrap_Map_when_areRepositoryResultsModifiable_isFalse() { final Map<String, MyEntity> input = new HashMap<>(); final MyEntity entity = new MyEntity(); input.put( ValueUtil.randomString(), entity ); ArezTestUtil.makeCollectionPropertiesModifiable(); final Map<String, MyEntity> output = CollectionsUtil.wrap( input ); assertSame( output, input ); assertEquals( output.size(), 1 ); assertEquals( output.values().iterator().next(), entity ); }
### Question: ObserverInfoImpl implements ObserverInfo { @Override public boolean isRunning() { return _spy.isTransactionActive() && null != getTrackerTransaction(); } ObserverInfoImpl( @Nonnull final Spy spy, @Nonnull final Observer observer ); @Nonnull @Override String getName(); @Override boolean isActive(); @Override boolean isRunning(); @Override boolean isScheduled(); @Override boolean isComputableValue(); @Override boolean isReadOnly(); @Nonnull @Override Priority getPriority(); @Nonnull @Override ComputableValueInfo asComputableValue(); @Nonnull @Override List<ObservableValueInfo> getDependencies(); @Nullable @Override ComponentInfo getComponent(); @Override boolean isDisposed(); @Override String toString(); @Override boolean equals( final Object o ); @Override int hashCode(); }### Answer: @Test public void isRunning() { final ArezContext context = Arez.context(); final AtomicInteger callCount = new AtomicInteger(); final AtomicReference<ObserverInfo> ref = new AtomicReference<>(); final Observer observer = context.observer( () -> { assertTrue( ref.get().isRunning() ); callCount.incrementAndGet(); observeADependency(); }, Observer.Flags.RUN_LATER ); final ObserverInfo info = context.getSpy().asObserverInfo( observer ); ref.set( info ); assertFalse( info.isRunning() ); assertEquals( callCount.get(), 0 ); context.triggerScheduler(); assertEquals( callCount.get(), 1 ); }
### Question: CollectionsUtil { @Nonnull public static <T> List<T> asList( @Nonnull final Stream<T> stream ) { return wrap( stream.collect( Collectors.toList() ) ); } private CollectionsUtil(); @Nonnull static Collection<T> wrap( @Nonnull final Collection<T> collection ); @Nonnull static Set<T> wrap( @Nonnull final Set<T> set ); @Nonnull static Map<K, V> wrap( @Nonnull final Map<K, V> map ); @Nonnull static List<T> wrap( @Nonnull final List<T> list ); @Nonnull static List<T> asList( @Nonnull final Stream<T> stream ); }### Answer: @Test public void asList() { final ArrayList<MyEntity> input = new ArrayList<>(); final MyEntity entity = new MyEntity(); input.add( entity ); final List<MyEntity> output = CollectionsUtil.asList( input.stream() ); assertUnmodifiable( output, MyEntity::new ); assertEquals( output.size(), 1 ); assertEquals( output.get( 0 ), entity ); }
### Question: MemoizeCache implements Disposable { @SuppressWarnings( "unchecked" ) void disposeComputableValue( @Nonnull final Object... args ) { if ( Arez.shouldCheckInvariants() ) { invariant( () -> args.length == _argCount, () -> "Arez-0163: MemoizeCache.disposeComputableValue called with " + args.length + " argument(s) but expected " + _argCount + " argument(s)." ); } if ( _disposed ) { return; } final Stack<Map<Object, ?>> stack = new Stack<>(); stack.push( _cache ); final int size = args.length - 1; for ( int i = 0; i < size; i++ ) { stack.push( (Map<Object, ?>) stack.peek().get( args[ i ] ) ); } final ComputableValue<T> computableValue = (ComputableValue<T>) stack.peek().remove( args[ size ] ); if ( Arez.shouldCheckInvariants() ) { invariant( () -> null != computableValue, () -> "Arez-0193: MemoizeCache.disposeComputableValue called with args " + Arrays.asList( args ) + " but unable to locate corresponding ComputableValue." ); } assert null != computableValue; getContext().task( Arez.areNamesEnabled() ? computableValue.getName() + ".dispose" : null, computableValue::dispose, Task.Flags.PRIORITY_HIGHEST \| Task.Flags.DISPOSE_ON_COMPLETE \| Task.Flags.NO_WRAP_TASK ); while ( stack.size() > 1 ) { final Map<Object, ?> map = stack.pop(); if ( map.isEmpty() ) { stack.peek().remove( args[ stack.size() - 1 ] ); } else { return; } } } MemoizeCache( @Nullable final ArezContext context, @Nullable final Component component, @Nullable final String name, @Nonnull final Function<T> function, final int argCount ); MemoizeCache( @Nullable final ArezContext context, @Nullable final Component component, @Nullable final String name, @Nonnull final Function<T> function, final int argCount, @MagicConstant( flagsFromClass = ComputableValue.Flags.class ) final int flags ); T get( @Nonnull final Object... args ); @Override boolean isDisposed(); @Override void dispose(); @SuppressWarnings( "unchecked" ) @Nonnull ComputableValue<T> getComputableValue( @Nonnull final Object... args ); }### Answer: @Test public void disposeComputableValue_passedBadArgCounts() { final MemoizeCache<String> cache = new MemoizeCache<>( null, null, ValueUtil.randomString(), args -> args[ 0 ] + "." + args[ 1 ], 2 ); assertInvariantFailure( () -> cache.disposeComputableValue( "a" ), "Arez-0163: MemoizeCache.disposeComputableValue called with 1 argument(s) but expected 2 argument(s)." ); } @Test public void disposeComputableValue_noComputableValueCachedForArgs() { final MemoizeCache<String> cache = new MemoizeCache<>( null, null, ValueUtil.randomString(), args -> args[ 0 ] + "." + args[ 1 ], 1 ); assertInvariantFailure( () -> cache.disposeComputableValue( "a" ), "Arez-0193: MemoizeCache.disposeComputableValue called with args [a] but unable to locate corresponding ComputableValue." ); }
### Question: MemoizeCache implements Disposable { public T get( @Nonnull final Object... args ) { if ( Arez.shouldCheckApiInvariants() ) { apiInvariant( this::isNotDisposed, () -> "Arez-0161: MemoizeCache named '" + _name + "' had get() invoked when disposed." ); } return getComputableValue( args ).get(); } MemoizeCache( @Nullable final ArezContext context, @Nullable final Component component, @Nullable final String name, @Nonnull final Function<T> function, final int argCount ); MemoizeCache( @Nullable final ArezContext context, @Nullable final Component component, @Nullable final String name, @Nonnull final Function<T> function, final int argCount, @MagicConstant( flagsFromClass = ComputableValue.Flags.class ) final int flags ); T get( @Nonnull final Object... args ); @Override boolean isDisposed(); @Override void dispose(); @SuppressWarnings( "unchecked" ) @Nonnull ComputableValue<T> getComputableValue( @Nonnull final Object... args ); }### Answer: @Test public void get_passedBadArgCounts() { final MemoizeCache<String> cache = new MemoizeCache<>( null, null, ValueUtil.randomString(), args -> args[ 0 ] + "." + args[ 1 ], 2 ); assertInvariantFailure( () -> cache.get( "a" ), "Arez-0162: MemoizeCache.getComputableValue called with 1 arguments but expected 2 arguments." ); }
### Question: ComponentKernel implements Disposable, ComponentObservable { @Override public boolean observe() { if ( Arez.shouldCheckApiInvariants() ) { apiInvariant( () -> null != _disposeOnDeactivate \|\| null != _componentObservable, () -> "Arez-0221: ComponentKernel.observe() invoked on component named '" + getName() + "' but observing is not enabled for component." ); } if ( null != _disposeOnDeactivate ) { return isNotDisposed() ? _disposeOnDeactivate.get() : false; } else { return observe0(); } } ComponentKernel( @Nullable final ArezContext context, @Nullable final String name, final int id, @Nullable final Component component, @Nullable final SafeProcedure preDisposeCallback, @Nullable final SafeProcedure disposeCallback, @Nullable final SafeProcedure postDisposeCallback, final boolean notifyOnDispose, final boolean isComponentObservable, final boolean disposeOnDeactivate ); @Override boolean observe(); @Override void dispose(); @Override boolean isDisposed(); void notifyOnDisposeListeners(); boolean hasBeenInitialized(); boolean hasBeenConstructed(); boolean hasBeenCompleted(); boolean isConstructed(); boolean isComplete(); boolean isReady(); boolean isDisposing(); boolean isActive(); @Nonnull String describeState(); void componentConstructed(); void componentComplete(); void componentReady(); @Nonnull ArezContext getContext(); void safeSetObservable( @Nullable final String name, @Nonnull final SafeProcedure setter ); void setObservable( @Nullable final String name, @Nonnull final Procedure setter ); @Nonnull String getName(); int getId(); @OmitSymbol( unless = "arez.enable_native_components" ) @Nonnull Component getComponent(); void addOnDisposeListener( @Nonnull final Object key, @Nonnull final SafeProcedure action ); void removeOnDisposeListener( @Nonnull final Object key ); @Nonnull @Override String toString(); }### Answer: @Test public void observe() { ArezTestUtil.disableNativeComponents(); final ArezContext context = Arez.context(); final String name = ValueUtil.randomString(); final ComponentKernel kernel = new ComponentKernel( context, name, 0, null, null, null, null, false, true, false ); kernel.componentConstructed(); kernel.componentReady(); assertTrue( context.safeAction( (SafeFunction<Boolean>) kernel::observe ) ); final AtomicInteger disposedCallCount = new AtomicInteger(); final AtomicInteger notDisposedCallCount = new AtomicInteger(); context.observer( () -> { context.observable().reportObserved(); if ( kernel.isDisposed() ) { disposedCallCount.incrementAndGet(); assertFalse( kernel.observe() ); } else { notDisposedCallCount.incrementAndGet(); assertTrue( kernel.observe() ); } } ); assertEquals( notDisposedCallCount.get(), 1 ); assertEquals( disposedCallCount.get(), 0 ); Disposable.dispose( kernel ); assertFalse( context.safeAction( (SafeFunction<Boolean>) kernel::observe, ActionFlags.NO_VERIFY_ACTION_REQUIRED ) ); assertEquals( notDisposedCallCount.get(), 1 ); assertEquals( disposedCallCount.get(), 1 ); }
### Question: ComponentKernel implements Disposable, ComponentObservable { public void addOnDisposeListener( @Nonnull final Object key, @Nonnull final SafeProcedure action ) { assert null != _onDisposeListeners; if ( Arez.shouldCheckApiInvariants() ) { invariant( this::isNotDisposed, () -> "Arez-0170: Attempting to add OnDispose listener but ComponentKernel has been disposed." ); invariant( () -> !_onDisposeListeners.containsKey( key ), () -> "Arez-0166: Attempting to add OnDispose listener with key '" + key + "' but a listener with that key already exists." ); } _onDisposeListeners.put( key, action ); } ComponentKernel( @Nullable final ArezContext context, @Nullable final String name, final int id, @Nullable final Component component, @Nullable final SafeProcedure preDisposeCallback, @Nullable final SafeProcedure disposeCallback, @Nullable final SafeProcedure postDisposeCallback, final boolean notifyOnDispose, final boolean isComponentObservable, final boolean disposeOnDeactivate ); @Override boolean observe(); @Override void dispose(); @Override boolean isDisposed(); void notifyOnDisposeListeners(); boolean hasBeenInitialized(); boolean hasBeenConstructed(); boolean hasBeenCompleted(); boolean isConstructed(); boolean isComplete(); boolean isReady(); boolean isDisposing(); boolean isActive(); @Nonnull String describeState(); void componentConstructed(); void componentComplete(); void componentReady(); @Nonnull ArezContext getContext(); void safeSetObservable( @Nullable final String name, @Nonnull final SafeProcedure setter ); void setObservable( @Nullable final String name, @Nonnull final Procedure setter ); @Nonnull String getName(); int getId(); @OmitSymbol( unless = "arez.enable_native_components" ) @Nonnull Component getComponent(); void addOnDisposeListener( @Nonnull final Object key, @Nonnull final SafeProcedure action ); void removeOnDisposeListener( @Nonnull final Object key ); @Nonnull @Override String toString(); }### Answer: @Test public void addOnDisposeListener() { final ArezContext context = Arez.context(); final ComponentKernel kernel = new ComponentKernel( context, "MyType", 1, context.component( "MyType", 1 ), null, null, null, true, false, false ); final String key = ValueUtil.randomString(); final AtomicInteger callCount = new AtomicInteger(); assertEquals( kernel.getOnDisposeListeners().size(), 0 ); assertEquals( callCount.get(), 0 ); kernel.addOnDisposeListener( key, callCount::incrementAndGet ); assertEquals( kernel.getOnDisposeListeners().size(), 1 ); assertEquals( callCount.get(), 0 ); kernel.getOnDisposeListeners().get( key ).call(); assertEquals( kernel.getOnDisposeListeners().size(), 1 ); assertEquals( callCount.get(), 1 ); } @Test public void addOnDisposeListener_duplicate() { final ArezContext context = Arez.context(); final ComponentKernel kernel = new ComponentKernel( context, "MyType", 1, context.component( "MyType", 1 ), null, null, null, true, false, false ); final String key = ValueUtil.randomString(); final AtomicInteger callCount = new AtomicInteger(); kernel.addOnDisposeListener( key, callCount::incrementAndGet ); assertInvariantFailure( () -> kernel.addOnDisposeListener( key, callCount::incrementAndGet ), "Arez-0166: Attempting to add OnDispose listener with key '" + key + "' but a listener with that key already exists." ); }
### Question: ObserverInfoImpl implements ObserverInfo { @Override public boolean isReadOnly() { return Arez.shouldEnforceTransactionType() && !_observer.isMutation(); } ObserverInfoImpl( @Nonnull final Spy spy, @Nonnull final Observer observer ); @Nonnull @Override String getName(); @Override boolean isActive(); @Override boolean isRunning(); @Override boolean isScheduled(); @Override boolean isComputableValue(); @Override boolean isReadOnly(); @Nonnull @Override Priority getPriority(); @Nonnull @Override ComputableValueInfo asComputableValue(); @Nonnull @Override List<ObservableValueInfo> getDependencies(); @Nullable @Override ComponentInfo getComponent(); @Override boolean isDisposed(); @Override String toString(); @Override boolean equals( final Object o ); @Override int hashCode(); }### Answer: @Test public void isReadOnly_on_READ_WRITE_observer() { final ArezContext context = Arez.context(); final ObservableValue<Object> observableValue = context.observable(); final Observer observer = context.observer( observableValue::reportObserved, Observer.Flags.READ_WRITE ); assertFalse( observer.asInfo().isReadOnly() ); }
### Question: ComponentKernel implements Disposable, ComponentObservable { public void removeOnDisposeListener( @Nonnull final Object key ) { assert null != _onDisposeListeners; final SafeProcedure removed = _onDisposeListeners.remove( key ); if ( Arez.shouldCheckApiInvariants() ) { invariant( () -> null != removed, () -> "Arez-0167: Attempting to remove OnDispose listener with key '" + key + "' but no such listener exists." ); } } ComponentKernel( @Nullable final ArezContext context, @Nullable final String name, final int id, @Nullable final Component component, @Nullable final SafeProcedure preDisposeCallback, @Nullable final SafeProcedure disposeCallback, @Nullable final SafeProcedure postDisposeCallback, final boolean notifyOnDispose, final boolean isComponentObservable, final boolean disposeOnDeactivate ); @Override boolean observe(); @Override void dispose(); @Override boolean isDisposed(); void notifyOnDisposeListeners(); boolean hasBeenInitialized(); boolean hasBeenConstructed(); boolean hasBeenCompleted(); boolean isConstructed(); boolean isComplete(); boolean isReady(); boolean isDisposing(); boolean isActive(); @Nonnull String describeState(); void componentConstructed(); void componentComplete(); void componentReady(); @Nonnull ArezContext getContext(); void safeSetObservable( @Nullable final String name, @Nonnull final SafeProcedure setter ); void setObservable( @Nullable final String name, @Nonnull final Procedure setter ); @Nonnull String getName(); int getId(); @OmitSymbol( unless = "arez.enable_native_components" ) @Nonnull Component getComponent(); void addOnDisposeListener( @Nonnull final Object key, @Nonnull final SafeProcedure action ); void removeOnDisposeListener( @Nonnull final Object key ); @Nonnull @Override String toString(); }### Answer: @Test public void removeOnDisposeListener() { final ArezContext context = Arez.context(); final ComponentKernel kernel = new ComponentKernel( context, "MyType", 1, context.component( "MyType", 1 ), null, null, null, true, false, false ); final String key = ValueUtil.randomString(); final AtomicInteger callCount = new AtomicInteger(); assertEquals( kernel.getOnDisposeListeners().size(), 0 ); kernel.addOnDisposeListener( key, callCount::incrementAndGet ); assertEquals( kernel.getOnDisposeListeners().size(), 1 ); kernel.removeOnDisposeListener( key ); assertEquals( kernel.getOnDisposeListeners().size(), 0 ); } @Test public void removeOnDisposeListener_notPresent() { final ArezContext context = Arez.context(); final ComponentKernel kernel = new ComponentKernel( context, "MyType", 1, context.component( "MyType", 1 ), null, null, null, true, false, false ); final String key = ValueUtil.randomString(); assertInvariantFailure( () -> kernel.removeOnDisposeListener( key ), "Arez-0167: Attempting to remove OnDispose listener with key '" + key + "' but no such listener exists." ); }
### Question: ComponentKernel implements Disposable, ComponentObservable { @Override public void dispose() { if ( isNotDisposed() ) { _state = COMPONENT_DISPOSING; if ( Arez.areNativeComponentsEnabled() ) { assert null != _component; _component.dispose(); } else { getContext().safeAction( Arez.areNamesEnabled() ? getName() + ".dispose" : null, this::performDispose, ActionFlags.NO_VERIFY_ACTION_REQUIRED ); } if ( Arez.shouldCheckApiInvariants() ) { _state = COMPONENT_DISPOSED; } } } ComponentKernel( @Nullable final ArezContext context, @Nullable final String name, final int id, @Nullable final Component component, @Nullable final SafeProcedure preDisposeCallback, @Nullable final SafeProcedure disposeCallback, @Nullable final SafeProcedure postDisposeCallback, final boolean notifyOnDispose, final boolean isComponentObservable, final boolean disposeOnDeactivate ); @Override boolean observe(); @Override void dispose(); @Override boolean isDisposed(); void notifyOnDisposeListeners(); boolean hasBeenInitialized(); boolean hasBeenConstructed(); boolean hasBeenCompleted(); boolean isConstructed(); boolean isComplete(); boolean isReady(); boolean isDisposing(); boolean isActive(); @Nonnull String describeState(); void componentConstructed(); void componentComplete(); void componentReady(); @Nonnull ArezContext getContext(); void safeSetObservable( @Nullable final String name, @Nonnull final SafeProcedure setter ); void setObservable( @Nullable final String name, @Nonnull final Procedure setter ); @Nonnull String getName(); int getId(); @OmitSymbol( unless = "arez.enable_native_components" ) @Nonnull Component getComponent(); void addOnDisposeListener( @Nonnull final Object key, @Nonnull final SafeProcedure action ); void removeOnDisposeListener( @Nonnull final Object key ); @Nonnull @Override String toString(); }### Answer: @Test public void dispose() { final ArezContext context = Arez.context(); final AtomicReference<ComponentKernel> ref = new AtomicReference<>(); final ComponentKernel kernel = new ComponentKernel( context, "MyType", 1, context.component( "MyType", 1, "MyType@1", () -> ref.get().notifyOnDisposeListeners() ), null, null, null, true, false, false ); ref.set( kernel ); final String key = ValueUtil.randomString(); final AtomicInteger callCount = new AtomicInteger(); assertEquals( callCount.get(), 0 ); kernel.addOnDisposeListener( key, callCount::incrementAndGet ); assertEquals( callCount.get(), 0 ); kernel.dispose(); assertEquals( callCount.get(), 1 ); }
### Question: ObserverInfoImpl implements ObserverInfo { @Nonnull @Override public List<ObservableValueInfo> getDependencies() { final Transaction transaction = _spy.isTransactionActive() ? getTrackerTransaction() : null; if ( null != transaction ) { final List<ObservableValue<?>> observableValues = transaction.getObservableValues(); if ( null == observableValues ) { return Collections.emptyList(); } else { final List<ObservableValue<?>> list = observableValues.stream().distinct().collect( Collectors.toList() ); return ObservableValueInfoImpl.asUnmodifiableInfos( list ); } } else { return ObservableValueInfoImpl.asUnmodifiableInfos( _observer.getDependencies() ); } } ObserverInfoImpl( @Nonnull final Spy spy, @Nonnull final Observer observer ); @Nonnull @Override String getName(); @Override boolean isActive(); @Override boolean isRunning(); @Override boolean isScheduled(); @Override boolean isComputableValue(); @Override boolean isReadOnly(); @Nonnull @Override Priority getPriority(); @Nonnull @Override ComputableValueInfo asComputableValue(); @Nonnull @Override List<ObservableValueInfo> getDependencies(); @Nullable @Override ComponentInfo getComponent(); @Override boolean isDisposed(); @Override String toString(); @Override boolean equals( final Object o ); @Override int hashCode(); }### Answer: @Test public void getDependencies() { final ArezContext context = Arez.context(); final Spy spy = context.getSpy(); final ObservableValue<Object> observable = context.observable(); final Observer observer = context.observer( observable::reportObserved ); final List<ObservableValueInfo> dependencies = spy.asObserverInfo( observer ).getDependencies(); assertEquals( dependencies.size(), 1 ); assertEquals( dependencies.get( 0 ).getName(), observable.getName() ); assertUnmodifiable( dependencies ); }
### Question: JMoveWriter implements RefactoringsWriter { @Override public void writeRefactoringsInTextForm(List<RefactoringTextRepresentation> refactorings, Path refactoringsPath) throws IOException { Files.write(refactoringsPath, getRefactoringsInJMoveFormat(refactorings)); } @Override String getName(); @Override void write(List<MoveMethodRefactoring> refactorings, Path refactoringsPath); @Override void write(List<MoveMethodRefactoring> refactorings, OutputStream outputStream); @Override void writeRefactoringsInTextForm(List<RefactoringTextRepresentation> refactorings, Path refactoringsPath); @Override void writeRefactoringsInTextForm(List<RefactoringTextRepresentation> refactorings, OutputStream outputStream); }### Answer: @Test public void writeToFile() throws IOException { Path fileToWrite = Files.createTempFile(null, null); fileToWrite.toFile().deleteOnExit(); RefactoringsWriters.getJMoveWriter().writeRefactoringsInTextForm(REFACTORINGS_TO_WRITE, fileToWrite); checkWrittenRefactorings(fileToWrite.toFile()); } @Test public void writeToOutputStream() throws IOException { Path fileToWrite = Files.createTempFile(null, null); fileToWrite.toFile().deleteOnExit(); RefactoringsWriters.getJMoveWriter().writeRefactoringsInTextForm(REFACTORINGS_TO_WRITE, new FileOutputStream(fileToWrite.toFile())); checkWrittenRefactorings(fileToWrite.toFile()); }
### Question: InputSessionValidator { public void validate(Iterable<String> input) { List<EventLine> errorSession = new ArrayList<>(); List<EventLine> validSession = new ArrayList<>(); for (String line : input) { if (line.trim().isEmpty()) continue; String[] fields = line.split("\t", -1); if (!isFormattedCorrectly(fields)) { errorSession.add(new EventLine(line)); continue; } String payload = fields[7]; if (isCorrectPayload(payload)) { validSession.add(new EventLine(payload)); } else { errorSession.add(new EventLine(payload)); } } result.addErrorSession(errorSession); result.addValidSession(validSession); } InputSessionValidator(org.jetbrains.research.groups.ml_methods.refactoring.validation.SessionValidationResult result); void validate(Iterable<String> input); static void main(String args[]); }### Answer: @Test public void testCorrect2() throws IOException { List<String> entries = loadLogs(LOGS_PATH + "correctTest2.txt"); validator.validate(entries); assertEquals(1, result.validLines().size()); assertEquals(0, result.errorLines().size()); } @Test public void testCorrect3() throws IOException { List<String> entries = loadLogs(LOGS_PATH + "correctTest3.txt"); validator.validate(entries); assertEquals(1, result.validLines().size()); assertEquals(0, result.errorLines().size()); } @Test public void testIncorrectTimestamp() throws IOException { List<String> entries = loadLogs(LOGS_PATH + "incorrectTest1.txt"); validator.validate(entries); assertEquals(0, result.validLines().size()); assertEquals(1, result.errorLines().size()); } @Test public void testIncorrectUsedId() throws IOException { List<String> entries = loadLogs(LOGS_PATH + "incorrectTest2.txt"); validator.validate(entries); assertEquals(0, result.validLines().size()); assertEquals(1, result.errorLines().size()); } @Test public void testIncorrectSessionId() throws IOException { List<String> entries = loadLogs(LOGS_PATH + "incorrectTest3.txt"); validator.validate(entries); assertEquals(0, result.validLines().size()); assertEquals(1, result.errorLines().size()); } @Test public void testBothEmpty() throws IOException { List<String> entries = loadLogs(LOGS_PATH + "incorrectTest4.txt"); validator.validate(entries); assertEquals(0, result.validLines().size()); assertEquals(1, result.errorLines().size()); } @Test public void testRejectedMissing() throws IOException { List<String> entries = loadLogs(LOGS_PATH + "incorrectTest5.txt"); validator.validate(entries); assertEquals(0, result.validLines().size()); assertEquals(1, result.errorLines().size()); } @Test public void testIncorrectJsonInPayload() throws IOException { List<String> entries = loadLogs(LOGS_PATH + "incorrectTest6.txt"); validator.validate(entries); assertEquals(0, result.validLines().size()); assertEquals(1, result.errorLines().size()); } @Test public void testEmptyPayload() throws IOException { List<String> entries = loadLogs(LOGS_PATH + "incorrectTest7.txt"); validator.validate(entries); assertEquals(0, result.validLines().size()); assertEquals(1, result.errorLines().size()); } @Test public void testCorrect1() throws IOException { List<String> entries = loadLogs(LOGS_PATH + "correctTest1.txt"); validator.validate(entries); assertEquals(1, result.validLines().size()); assertEquals(0, result.errorLines().size()); }
### Question: JBWriter implements RefactoringsWriter { @Override public void writeRefactoringsInTextForm(List<RefactoringTextRepresentation> refactorings, Path refactoringsPath) throws IOException { Files.write(refactoringsPath, Collections.singleton(JSON_CONVERTER.toJson(refactorings))); } @Override void write(List<MoveMethodRefactoring> refactorings, Path refactoringsPath); @Override void write(List<MoveMethodRefactoring> refactorings, OutputStream outputStream); @Override void writeRefactoringsInTextForm(List<RefactoringTextRepresentation> refactorings, Path refactoringsPath); @Override void writeRefactoringsInTextForm(List<RefactoringTextRepresentation> refactorings, OutputStream outputStream); @Override String getName(); }### Answer: @Test public void writeToFile() throws IOException { Path fileToWrite = Files.createTempFile(null, null); fileToWrite.toFile().deleteOnExit(); RefactoringsWriters.getJBWriter().writeRefactoringsInTextForm(REFACTORINGS_TO_WRITE, fileToWrite); checkWrittenRefactorings(fileToWrite.toFile()); } @Test public void writeToOutputStream() throws IOException { Path fileToWrite = Files.createTempFile(null, null); fileToWrite.toFile().deleteOnExit(); RefactoringsWriters.getJBWriter().writeRefactoringsInTextForm(REFACTORINGS_TO_WRITE, new FileOutputStream(fileToWrite.toFile())); checkWrittenRefactorings(fileToWrite.toFile()); }

Subsets and Splits

No community queries yet

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