Datasets:

Minata
/

src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Files and versions Community

Split (2)

train · 323k rows

src_fm_fc_ms_ff stringlengths 43 86.8k	target stringlengths 20 276k
ArezContext { @OmitSymbol( unless = "arez.enable_task_interceptor" ) public void setTaskInterceptor( @Nullable final TaskInterceptor taskInterceptor ) { if ( Arez.shouldCheckInvariants() ) { invariant( Arez::isTaskInterceptorEnabled, () -> "Arez-0039: setTaskInterceptor() invoked but Arez.isTaskInterceptorEnabled() returns false." ); } _taskInterceptor = taskInterceptor; } ArezContext( @Nullable final Zone zone ); @OmitSymbol( unless = "arez.enable_native_components" ) boolean isComponentPresent( @Nonnull final String type, @Nonnull final Object id ); @OmitSymbol( unless = "arez.enable_native_components" ) @Nonnull Component component( @Nonnull final String type, @Nonnull final Object id ); @OmitSymbol( unless = "arez.enable_native_components" ) @Nonnull Component component( @Nonnull final String type, @Nonnull final Object id, @Nullable final String name ); @OmitSymbol( unless = "arez.enable_native_components" ) @Nonnull Component component( @Nonnull final String type, @Nonnull final Object id, @Nullable final String name, @Nullable final SafeProcedure preDispose ); @OmitSymbol( unless = "arez.enable_native_components" ) @Nonnull Component component( @Nonnull final String type, @Nonnull final Object id, @Nullable final String name, @Nullable final SafeProcedure preDispose, @Nullable final SafeProcedure postDispose ); @Nonnull ComputableValue<T> computable( @Nonnull final SafeFunction<T> function ); @Nonnull ComputableValue<T> computable( @Nonnull final SafeFunction<T> function, @MagicConstant( flagsFromClass = ComputableValue.Flags.class ) final int flags ); @Nonnull ComputableValue<T> computable( @Nullable final String name, @Nonnull final SafeFunction<T> function ); @Nonnull ComputableValue<T> computable( @Nullable final String name, @Nonnull final SafeFunction<T> function, @MagicConstant( flagsFromClass = ComputableValue.Flags.class ) final int flags ); @Nonnull ComputableValue<T> computable( @Nullable final Component component, @Nullable final String name, @Nonnull final SafeFunction<T> function ); @Nonnull ComputableValue<T> computable( @Nullable final Component component, @Nullable final String name, @Nonnull final SafeFunction<T> function, @MagicConstant( flagsFromClass = ComputableValue.Flags.class ) final int flags ); @Nonnull ComputableValue<T> computable( @Nullable final Component component, @Nullable final String name, @Nonnull final SafeFunction<T> function, @Nullable final Procedure onActivate, @Nullable final Procedure onDeactivate ); @Nonnull ComputableValue<T> computable( @Nullable final String name, @Nonnull final SafeFunction<T> function, @Nullable final Procedure onActivate, @Nullable final Procedure onDeactivate ); @Nonnull ComputableValue<T> computable( @Nullable final String name, @Nonnull final SafeFunction<T> function, @Nullable final Procedure onActivate, @Nullable final Procedure onDeactivate, @MagicConstant( flagsFromClass = ComputableValue.Flags.class ) final int flags ); @Nonnull ComputableValue<T> computable( @Nullable final Component component, @Nullable final String name, @Nonnull final SafeFunction<T> function, @Nullable final Procedure onActivate, @Nullable final Procedure onDeactivate, @MagicConstant( flagsFromClass = ComputableValue.Flags.class ) final int flags ); @Nonnull Observer observer( @Nonnull final Procedure observe ); @Nonnull Observer observer( @Nonnull final Procedure observe, @MagicConstant( flagsFromClass = Observer.Flags.class ) final int flags ); @Nonnull Observer observer( @Nullable final String name, @Nonnull final Procedure observe ); @Nonnull Observer observer( @Nullable final String name, @Nonnull final Procedure observe, @MagicConstant( flagsFromClass = Observer.Flags.class ) final int flags ); @Nonnull Observer observer( @Nullable final Component component, @Nullable final String name, @Nonnull final Procedure observe ); @Nonnull Observer observer( @Nullable final Component component, @Nullable final String name, @Nonnull final Procedure observe, @MagicConstant( flagsFromClass = Observer.Flags.class ) final int flags ); @Nonnull Observer observer( @Nullable final Component component, @Nullable final String name, @Nullable final Procedure observe, @Nullable final Procedure onDepsChange ); @Nonnull Observer observer( @Nullable final Procedure observe, @Nullable final Procedure onDepsChange ); @Nonnull Observer observer( @Nullable final Procedure observe, @Nullable final Procedure onDepsChange, @MagicConstant( flagsFromClass = Observer.Flags.class ) final int flags ); @Nonnull Observer observer( @Nullable final String name, @Nullable final Procedure observe, @Nullable final Procedure onDepsChange ); @Nonnull Observer observer( @Nullable final String name, @Nullable final Procedure observe, @Nullable final Procedure onDepsChange, @MagicConstant( flagsFromClass = Observer.Flags.class ) final int flags ); @Nonnull Observer observer( @Nullable final Component component, @Nullable final String name, @Nullable final Procedure observe, @Nullable final Procedure onDepsChange, @MagicConstant( flagsFromClass = Observer.Flags.class ) final int flags ); @Nonnull Observer tracker( @Nonnull final Procedure onDepsChange ); @Nonnull Observer tracker( @Nonnull final Procedure onDepsChange, @MagicConstant( flagsFromClass = Observer.Flags.class ) final int flags ); @Nonnull Observer tracker( @Nullable final String name, @Nonnull final Procedure onDepsChange ); @Nonnull Observer tracker( @Nullable final String name, @Nonnull final Procedure onDepsChange, @MagicConstant( flagsFromClass = Observer.Flags.class ) final int flags ); @Nonnull Observer tracker( @Nullable final Component component, @Nullable final String name, @Nonnull final Procedure onDepsChange ); @Nonnull Observer tracker( @Nullable final Component component, @Nullable final String name, @Nonnull final Procedure onDepsChange, @MagicConstant( flagsFromClass = Observer.Flags.class ) final int flags ); @Nonnull ObservableValue<T> observable(); @Nonnull ObservableValue<T> observable( @Nullable final String name ); @Nonnull ObservableValue<T> observable( @Nullable final String name, @Nullable final PropertyAccessor<T> accessor, @Nullable final PropertyMutator<T> mutator ); @Nonnull ObservableValue<T> observable( @Nullable final Component component, @Nullable final String name ); @Nonnull ObservableValue<T> observable( @Nullable final Component component, @Nullable final String name, @Nullable final PropertyAccessor<T> accessor ); @Nonnull ObservableValue<T> observable( @Nullable final Component component, @Nullable final String name, @Nullable final PropertyAccessor<T> accessor, @Nullable final PropertyMutator<T> mutator ); @Nonnull Task task( @Nonnull final SafeProcedure work ); @Nonnull Task task( @Nullable final String name, @Nonnull final SafeProcedure work ); @Nonnull Task task( @Nonnull final SafeProcedure work, @MagicConstant( flagsFromClass = Task.Flags.class ) final int flags ); @Nonnull Task task( @Nullable final String name, @Nonnull final SafeProcedure work, @MagicConstant( flagsFromClass = Task.Flags.class ) final int flags ); boolean isSchedulerActive(); boolean isTransactionActive(); boolean isTrackingTransactionActive(); boolean isReadWriteTransactionActive(); boolean isReadOnlyTransactionActive(); boolean isSchedulerPaused(); @Nonnull SchedulerLock pauseScheduler(); @OmitSymbol( unless = "arez.enable_task_interceptor" ) void setTaskInterceptor( @Nullable final TaskInterceptor taskInterceptor ); void triggerScheduler(); T action( @Nonnull final Function<T> executable ); T action( @Nonnull final Function<T> executable, @MagicConstant( flagsFromClass = ActionFlags.class ) final int flags ); T action( @Nullable final String name, @Nonnull final Function<T> executable ); T action( @Nullable final String name, @Nonnull final Function<T> executable, @MagicConstant( flagsFromClass = ActionFlags.class ) final int flags ); T action( @Nullable final String name, @Nonnull final Function<T> executable, @MagicConstant( flagsFromClass = ActionFlags.class ) final int flags, @Nullable final Object[] parameters ); T observe( @Nonnull final Observer observer, @Nonnull final Function<T> observe ); T observe( @Nonnull final Observer observer, @Nonnull final Function<T> observe, @Nullable final Object[] parameters ); T safeAction( @Nonnull final SafeFunction<T> executable ); T safeAction( @Nonnull final SafeFunction<T> executable, @MagicConstant( flagsFromClass = ActionFlags.class ) final int flags ); T safeAction( @Nullable final String name, @Nonnull final SafeFunction<T> executable ); T safeAction( @Nullable final String name, @Nonnull final SafeFunction<T> executable, @MagicConstant( flagsFromClass = ActionFlags.class ) final int flags ); T safeAction( @Nullable final String name, @Nonnull final SafeFunction<T> executable, @MagicConstant( flagsFromClass = ActionFlags.class ) final int flags, @Nullable final Object[] parameters ); T safeObserve( @Nonnull final Observer observer, @Nonnull final SafeFunction<T> observe ); T safeObserve( @Nonnull final Observer observer, @Nonnull final SafeFunction<T> observe, @Nullable final Object[] parameters ); void action( @Nonnull final Procedure executable ); void action( @Nonnull final Procedure executable, @MagicConstant( flagsFromClass = ActionFlags.class ) final int flags ); void action( @Nullable final String name, @Nonnull final Procedure executable ); void action( @Nullable final String name, @Nonnull final Procedure executable, @MagicConstant( flagsFromClass = ActionFlags.class ) final int flags ); void action( @Nullable final String name, @Nonnull final Procedure executable, @MagicConstant( flagsFromClass = ActionFlags.class ) final int flags, @Nullable final Object[] parameters ); void observe( @Nonnull final Observer observer, @Nonnull final Procedure observe ); void observe( @Nonnull final Observer observer, @Nonnull final Procedure observe, @Nullable final Object[] parameters ); void safeAction( @Nonnull final SafeProcedure executable ); void safeAction( @Nonnull final SafeProcedure executable, @MagicConstant( flagsFromClass = ActionFlags.class ) final int flags ); void safeAction( @Nullable final String name, @Nonnull final SafeProcedure executable ); void safeAction( @Nullable final String name, @Nonnull final SafeProcedure executable, @MagicConstant( flagsFromClass = ActionFlags.class ) final int flags ); void safeAction( @Nullable final String name, @Nonnull final SafeProcedure executable, @MagicConstant( flagsFromClass = ActionFlags.class ) final int flags, @Nullable final Object[] parameters ); void safeObserve( @Nonnull final Observer observer, @Nonnull final SafeProcedure observe ); void safeObserve( @Nonnull final Observer observer, @Nonnull final SafeProcedure observe, @Nullable final Object[] parameters ); @OmitSymbol( unless = "arez.enable_references" ) @Nonnull Disposable registerLocator( @Nonnull final Locator locator ); @OmitSymbol( unless = "arez.enable_references" ) @Nonnull Locator locator(); @OmitSymbol( unless = "arez.enable_observer_error_handlers" ) void addObserverErrorHandler( @Nonnull final ObserverErrorHandler handler ); @OmitSymbol( unless = "arez.enable_observer_error_handlers" ) void removeObserverErrorHandler( @Nonnull final ObserverErrorHandler handler ); @Nonnull Spy getSpy(); }	@Test public void setTaskInterceptor_whenTaskInterceptorDisabled() { ArezTestUtil.disableTaskInterceptor(); final ArezContext context = Arez.context(); assertInvariantFailure( () -> context.setTaskInterceptor( SafeProcedure::call ), "Arez-0039: setTaskInterceptor() invoked but Arez.isTaskInterceptorEnabled() returns false." ); }
RoundBasedTaskExecutor { boolean runNextTask() { if ( 0 == _remainingTasksInCurrentRound ) { final int pendingTaskCount = getPendingTaskCount(); if ( 0 == pendingTaskCount ) { _currentRound = 0; return false; } else if ( _currentRound + 1 > _maxRounds ) { _currentRound = 0; onRunawayTasksDetected(); return false; } else { _currentRound = _currentRound + 1; _remainingTasksInCurrentRound = pendingTaskCount; } } _remainingTasksInCurrentRound--; final Task task = _taskQueue.dequeueTask(); assert null != task; task.executeTask(); return true; } RoundBasedTaskExecutor( @Nonnull final TaskQueue taskQueue, final int maxRounds ); }	@Test public void runNextTask() { final ArezContext context = Arez.context(); final TaskQueue taskQueue = context.getTaskQueue(); final RoundBasedTaskExecutor executor = new RoundBasedTaskExecutor( taskQueue, 2 ); final AtomicInteger task1CallCount = new AtomicInteger(); final AtomicInteger task2CallCount = new AtomicInteger(); final AtomicInteger task3CallCount = new AtomicInteger(); final Task task1 = context.task( "A", task1CallCount::incrementAndGet, Task.Flags.RUN_LATER ); final Task task2 = context.task( "B", task2CallCount::incrementAndGet, Task.Flags.RUN_LATER ); context.task( "C", task3CallCount::incrementAndGet, Task.Flags.RUN_LATER ); assertEquals( executor.getMaxRounds(), 2 ); assertFalse( executor.areTasksExecuting() ); assertEquals( executor.getCurrentRound(), 0 ); assertEquals( executor.getRemainingTasksInCurrentRound(), 0 ); assertEquals( taskQueue.getQueueSize(), 3 ); assertEquals( task1CallCount.get(), 0 ); assertEquals( task2CallCount.get(), 0 ); assertEquals( task3CallCount.get(), 0 ); assertTrue( executor.runNextTask() ); assertTrue( executor.areTasksExecuting() ); assertEquals( executor.getCurrentRound(), 1 ); assertEquals( executor.getRemainingTasksInCurrentRound(), 2 ); assertEquals( taskQueue.getQueueSize(), 2 ); assertEquals( task1CallCount.get(), 1 ); assertEquals( task2CallCount.get(), 0 ); assertEquals( task3CallCount.get(), 0 ); assertTrue( executor.runNextTask() ); assertTrue( executor.areTasksExecuting() ); assertEquals( executor.getCurrentRound(), 1 ); assertEquals( executor.getRemainingTasksInCurrentRound(), 1 ); assertEquals( taskQueue.getQueueSize(), 1 ); assertEquals( task1CallCount.get(), 1 ); assertEquals( task2CallCount.get(), 1 ); assertEquals( task3CallCount.get(), 0 ); task1.queueTask(); task2.queueTask(); assertEquals( taskQueue.getQueueSize(), 3 ); assertTrue( executor.runNextTask() ); assertTrue( executor.areTasksExecuting() ); assertEquals( executor.getCurrentRound(), 1 ); assertEquals( executor.getRemainingTasksInCurrentRound(), 0 ); assertEquals( taskQueue.getQueueSize(), 2 ); assertEquals( task1CallCount.get(), 1 ); assertEquals( task2CallCount.get(), 1 ); assertEquals( task3CallCount.get(), 1 ); assertTrue( executor.runNextTask() ); assertTrue( executor.areTasksExecuting() ); assertEquals( executor.getCurrentRound(), 2 ); assertEquals( executor.getRemainingTasksInCurrentRound(), 1 ); assertEquals( taskQueue.getQueueSize(), 1 ); assertEquals( task1CallCount.get(), 2 ); assertEquals( task2CallCount.get(), 1 ); assertEquals( task3CallCount.get(), 1 ); assertTrue( executor.runNextTask() ); assertTrue( executor.areTasksExecuting() ); assertEquals( executor.getCurrentRound(), 2 ); assertEquals( executor.getRemainingTasksInCurrentRound(), 0 ); assertEquals( taskQueue.getQueueSize(), 0 ); assertEquals( task1CallCount.get(), 2 ); assertEquals( task2CallCount.get(), 2 ); assertEquals( task3CallCount.get(), 1 ); assertFalse( executor.runNextTask() ); assertFalse( executor.areTasksExecuting() ); }
RoundBasedTaskExecutor { void runTasks() { while ( true ) { if ( !runNextTask() ) { break; } } } RoundBasedTaskExecutor( @Nonnull final TaskQueue taskQueue, final int maxRounds ); }	@Test public void runTasks() { final ArezContext context = Arez.context(); final TaskQueue taskQueue = context.getTaskQueue(); final RoundBasedTaskExecutor executor = new RoundBasedTaskExecutor( taskQueue, 2 ); final AtomicInteger task1CallCount = new AtomicInteger(); final AtomicInteger task2CallCount = new AtomicInteger(); final AtomicInteger task3CallCount = new AtomicInteger(); context.task( "A", task1CallCount::incrementAndGet, Task.Flags.RUN_LATER ); context.task( "B", task2CallCount::incrementAndGet, Task.Flags.RUN_LATER ); context.task( "C", task3CallCount::incrementAndGet, Task.Flags.RUN_LATER ); assertEquals( executor.getMaxRounds(), 2 ); assertEquals( executor.getCurrentRound(), 0 ); assertEquals( executor.getRemainingTasksInCurrentRound(), 0 ); assertEquals( taskQueue.getQueueSize(), 3 ); assertEquals( task1CallCount.get(), 0 ); assertEquals( task2CallCount.get(), 0 ); assertEquals( task3CallCount.get(), 0 ); assertFalse( executor.areTasksExecuting() ); executor.runTasks(); assertFalse( executor.areTasksExecuting() ); assertEquals( task1CallCount.get(), 1 ); assertEquals( task2CallCount.get(), 1 ); assertEquals( task3CallCount.get(), 1 ); assertEquals( executor.getCurrentRound(), 0 ); assertEquals( executor.getRemainingTasksInCurrentRound(), 0 ); assertEquals( taskQueue.getQueueSize(), 0 ); assertFalse( executor.runNextTask() ); }
SpyImpl implements Spy { @Override public boolean isTransactionActive() { return getContext().isTransactionActive(); } SpyImpl( @Nullable final ArezContext context ); @Override void addSpyEventHandler( @Nonnull final SpyEventHandler handler ); @Override void removeSpyEventHandler( @Nonnull final SpyEventHandler handler ); @Override void reportSpyEvent( @Nonnull final Object event ); @Override boolean willPropagateSpyEvents(); @Override boolean isTransactionActive(); @Nonnull @Override TransactionInfo getTransaction(); @Nullable @Override ComponentInfo findComponent( @Nonnull final String type, @Nonnull final Object id ); @Nonnull @Override Collection<ComponentInfo> findAllComponentsByType( @Nonnull final String type ); @Nonnull @Override Collection<String> findAllComponentTypes(); @Nonnull @Override Collection<ObservableValueInfo> findAllTopLevelObservableValues(); @Nonnull @Override Collection<ObserverInfo> findAllTopLevelObservers(); @Nonnull @Override Collection<ComputableValueInfo> findAllTopLevelComputableValues(); @Nonnull @Override Collection<TaskInfo> findAllTopLevelTasks(); @Nonnull @Override ComponentInfo asComponentInfo( @Nonnull final Component component ); @Nonnull @Override ObserverInfo asObserverInfo( @Nonnull final Observer observer ); @Nonnull @Override ObservableValueInfo asObservableValueInfo( @Nonnull final ObservableValue<T> observableValue ); @Nonnull @Override ComputableValueInfo asComputableValueInfo( @Nonnull final ComputableValue<T> computableValue ); @Nonnull @Override TaskInfo asTaskInfo( @Nonnull final Task task ); }	@Test public void isTransactionActive() { final ArezContext context = Arez.context(); final Spy spy = context.getSpy(); assertFalse( spy.isTransactionActive() ); setupReadOnlyTransaction( context ); assertTrue( spy.isTransactionActive() ); }
SpyImpl implements Spy { @Nonnull @Override public TransactionInfo getTransaction() { if ( Arez.shouldCheckApiInvariants() ) { apiInvariant( this::isTransactionActive, () -> "Arez-0105: Spy.getTransaction() invoked but no transaction active." ); } return getContext().getTransaction().asInfo(); } SpyImpl( @Nullable final ArezContext context ); @Override void addSpyEventHandler( @Nonnull final SpyEventHandler handler ); @Override void removeSpyEventHandler( @Nonnull final SpyEventHandler handler ); @Override void reportSpyEvent( @Nonnull final Object event ); @Override boolean willPropagateSpyEvents(); @Override boolean isTransactionActive(); @Nonnull @Override TransactionInfo getTransaction(); @Nullable @Override ComponentInfo findComponent( @Nonnull final String type, @Nonnull final Object id ); @Nonnull @Override Collection<ComponentInfo> findAllComponentsByType( @Nonnull final String type ); @Nonnull @Override Collection<String> findAllComponentTypes(); @Nonnull @Override Collection<ObservableValueInfo> findAllTopLevelObservableValues(); @Nonnull @Override Collection<ObserverInfo> findAllTopLevelObservers(); @Nonnull @Override Collection<ComputableValueInfo> findAllTopLevelComputableValues(); @Nonnull @Override Collection<TaskInfo> findAllTopLevelTasks(); @Nonnull @Override ComponentInfo asComponentInfo( @Nonnull final Component component ); @Nonnull @Override ObserverInfo asObserverInfo( @Nonnull final Observer observer ); @Nonnull @Override ObservableValueInfo asObservableValueInfo( @Nonnull final ObservableValue<T> observableValue ); @Nonnull @Override ComputableValueInfo asComputableValueInfo( @Nonnull final ComputableValue<T> computableValue ); @Nonnull @Override TaskInfo asTaskInfo( @Nonnull final Task task ); }	@Test public void getTransaction() { final ArezContext context = Arez.context(); final Spy spy = context.getSpy(); final String name = ValueUtil.randomString(); context.safeAction( name, () -> { observeADependency(); assertEquals( spy.getTransaction().getName(), name ); } ); }
SpyImpl implements Spy { @Nullable @Override public ComponentInfo findComponent( @Nonnull final String type, @Nonnull final Object id ) { final Component component = getContext().findComponent( type, id ); return null != component ? component.asInfo() : null; } SpyImpl( @Nullable final ArezContext context ); @Override void addSpyEventHandler( @Nonnull final SpyEventHandler handler ); @Override void removeSpyEventHandler( @Nonnull final SpyEventHandler handler ); @Override void reportSpyEvent( @Nonnull final Object event ); @Override boolean willPropagateSpyEvents(); @Override boolean isTransactionActive(); @Nonnull @Override TransactionInfo getTransaction(); @Nullable @Override ComponentInfo findComponent( @Nonnull final String type, @Nonnull final Object id ); @Nonnull @Override Collection<ComponentInfo> findAllComponentsByType( @Nonnull final String type ); @Nonnull @Override Collection<String> findAllComponentTypes(); @Nonnull @Override Collection<ObservableValueInfo> findAllTopLevelObservableValues(); @Nonnull @Override Collection<ObserverInfo> findAllTopLevelObservers(); @Nonnull @Override Collection<ComputableValueInfo> findAllTopLevelComputableValues(); @Nonnull @Override Collection<TaskInfo> findAllTopLevelTasks(); @Nonnull @Override ComponentInfo asComponentInfo( @Nonnull final Component component ); @Nonnull @Override ObserverInfo asObserverInfo( @Nonnull final Observer observer ); @Nonnull @Override ObservableValueInfo asObservableValueInfo( @Nonnull final ObservableValue<T> observableValue ); @Nonnull @Override ComputableValueInfo asComputableValueInfo( @Nonnull final ComputableValue<T> computableValue ); @Nonnull @Override TaskInfo asTaskInfo( @Nonnull final Task task ); }	@Test public void findComponent_nativeComponentsDisabled() { ArezTestUtil.disableNativeComponents(); final ArezContext context = Arez.context(); final Spy spy = context.getSpy(); final String type = ValueUtil.randomString(); final String id = ValueUtil.randomString(); assertInvariantFailure( () -> spy.findComponent( type, id ), "Arez-0010: ArezContext.findComponent() invoked when Arez.areNativeComponentsEnabled() returns false." ); }
SpyImpl implements Spy { @Nonnull @Override public Collection<ComponentInfo> findAllComponentsByType( @Nonnull final String type ) { final List<ComponentInfo> infos = getContext().findAllComponentsByType( type ).stream(). map( Component::asInfo ). collect( Collectors.toList() ); return Collections.unmodifiableCollection( infos ); } SpyImpl( @Nullable final ArezContext context ); @Override void addSpyEventHandler( @Nonnull final SpyEventHandler handler ); @Override void removeSpyEventHandler( @Nonnull final SpyEventHandler handler ); @Override void reportSpyEvent( @Nonnull final Object event ); @Override boolean willPropagateSpyEvents(); @Override boolean isTransactionActive(); @Nonnull @Override TransactionInfo getTransaction(); @Nullable @Override ComponentInfo findComponent( @Nonnull final String type, @Nonnull final Object id ); @Nonnull @Override Collection<ComponentInfo> findAllComponentsByType( @Nonnull final String type ); @Nonnull @Override Collection<String> findAllComponentTypes(); @Nonnull @Override Collection<ObservableValueInfo> findAllTopLevelObservableValues(); @Nonnull @Override Collection<ObserverInfo> findAllTopLevelObservers(); @Nonnull @Override Collection<ComputableValueInfo> findAllTopLevelComputableValues(); @Nonnull @Override Collection<TaskInfo> findAllTopLevelTasks(); @Nonnull @Override ComponentInfo asComponentInfo( @Nonnull final Component component ); @Nonnull @Override ObserverInfo asObserverInfo( @Nonnull final Observer observer ); @Nonnull @Override ObservableValueInfo asObservableValueInfo( @Nonnull final ObservableValue<T> observableValue ); @Nonnull @Override ComputableValueInfo asComputableValueInfo( @Nonnull final ComputableValue<T> computableValue ); @Nonnull @Override TaskInfo asTaskInfo( @Nonnull final Task task ); }	@Test public void findAllComponentsByType_nativeComponentsDisabled() { ArezTestUtil.disableNativeComponents(); final ArezContext context = Arez.context(); final Spy spy = context.getSpy(); final String type = ValueUtil.randomString(); assertInvariantFailure( () -> spy.findAllComponentsByType( type ), "Arez-0011: ArezContext.findAllComponentsByType() invoked when Arez.areNativeComponentsEnabled() returns false." ); }
SpyImpl implements Spy { @Nonnull @Override public Collection<TaskInfo> findAllTopLevelTasks() { return TaskInfoImpl.asUnmodifiableInfos( getContext().getTopLevelTasks().values() ); } SpyImpl( @Nullable final ArezContext context ); @Override void addSpyEventHandler( @Nonnull final SpyEventHandler handler ); @Override void removeSpyEventHandler( @Nonnull final SpyEventHandler handler ); @Override void reportSpyEvent( @Nonnull final Object event ); @Override boolean willPropagateSpyEvents(); @Override boolean isTransactionActive(); @Nonnull @Override TransactionInfo getTransaction(); @Nullable @Override ComponentInfo findComponent( @Nonnull final String type, @Nonnull final Object id ); @Nonnull @Override Collection<ComponentInfo> findAllComponentsByType( @Nonnull final String type ); @Nonnull @Override Collection<String> findAllComponentTypes(); @Nonnull @Override Collection<ObservableValueInfo> findAllTopLevelObservableValues(); @Nonnull @Override Collection<ObserverInfo> findAllTopLevelObservers(); @Nonnull @Override Collection<ComputableValueInfo> findAllTopLevelComputableValues(); @Nonnull @Override Collection<TaskInfo> findAllTopLevelTasks(); @Nonnull @Override ComponentInfo asComponentInfo( @Nonnull final Component component ); @Nonnull @Override ObserverInfo asObserverInfo( @Nonnull final Observer observer ); @Nonnull @Override ObservableValueInfo asObservableValueInfo( @Nonnull final ObservableValue<T> observableValue ); @Nonnull @Override ComputableValueInfo asComputableValueInfo( @Nonnull final ComputableValue<T> computableValue ); @Nonnull @Override TaskInfo asTaskInfo( @Nonnull final Task task ); }	@Test public void findAllTopLevelTasks() { final ArezContext context = Arez.context(); final Task task = context.task( ValueUtil::randomString ); final Spy spy = context.getSpy(); final Collection<TaskInfo> values = spy.findAllTopLevelTasks(); assertEquals( values.size(), 1 ); assertEquals( values.iterator().next().getName(), task.getName() ); assertUnmodifiable( values ); }
ComputableValueInfoImpl implements ComputableValueInfo { @Nonnull @Override public String getName() { return _computableValue.getName(); } ComputableValueInfoImpl( @Nonnull final ComputableValue<?> computableValue ); @Nonnull @Override String getName(); @Override boolean isComputing(); @Nonnull @Override Priority getPriority(); @Override boolean isActive(); @Nonnull @Override List<ObservableValueInfo> getDependencies(); @Nonnull @Override List<ObserverInfo> getObservers(); @Nullable @Override ComponentInfo getComponent(); @OmitSymbol( unless = "arez.enable_property_introspection" ) @Nullable @Override Object getValue(); @Override boolean isDisposed(); @Override String toString(); @Override boolean equals( final Object o ); @Override int hashCode(); }	@Test public void getTransactionComputing_missingTracker() { final ArezContext context = Arez.context(); final ComputableValue<String> computableValue = context.computable( () -> "" ); computableValue.setComputing( true ); final ComputableValueInfoImpl info = (ComputableValueInfoImpl) computableValue.asInfo(); setupReadOnlyTransaction( context ); assertInvariantFailure( info::getTransactionComputing, "Arez-0106: ComputableValue named '" + computableValue.getName() + "' is marked as " + "computing but unable to locate transaction responsible for computing ComputableValue" ); }
SpyImpl implements Spy { @Nonnull @Override public Collection<ObservableValueInfo> findAllTopLevelObservableValues() { return ObservableValueInfoImpl.asUnmodifiableInfos( getContext().getTopLevelObservables().values() ); } SpyImpl( @Nullable final ArezContext context ); @Override void addSpyEventHandler( @Nonnull final SpyEventHandler handler ); @Override void removeSpyEventHandler( @Nonnull final SpyEventHandler handler ); @Override void reportSpyEvent( @Nonnull final Object event ); @Override boolean willPropagateSpyEvents(); @Override boolean isTransactionActive(); @Nonnull @Override TransactionInfo getTransaction(); @Nullable @Override ComponentInfo findComponent( @Nonnull final String type, @Nonnull final Object id ); @Nonnull @Override Collection<ComponentInfo> findAllComponentsByType( @Nonnull final String type ); @Nonnull @Override Collection<String> findAllComponentTypes(); @Nonnull @Override Collection<ObservableValueInfo> findAllTopLevelObservableValues(); @Nonnull @Override Collection<ObserverInfo> findAllTopLevelObservers(); @Nonnull @Override Collection<ComputableValueInfo> findAllTopLevelComputableValues(); @Nonnull @Override Collection<TaskInfo> findAllTopLevelTasks(); @Nonnull @Override ComponentInfo asComponentInfo( @Nonnull final Component component ); @Nonnull @Override ObserverInfo asObserverInfo( @Nonnull final Observer observer ); @Nonnull @Override ObservableValueInfo asObservableValueInfo( @Nonnull final ObservableValue<T> observableValue ); @Nonnull @Override ComputableValueInfo asComputableValueInfo( @Nonnull final ComputableValue<T> computableValue ); @Nonnull @Override TaskInfo asTaskInfo( @Nonnull final Task task ); }	@Test public void findAllTopLevelObservables() { final ArezContext context = Arez.context(); final ObservableValue<String> observableValue = context.observable(); final Spy spy = context.getSpy(); final Collection<ObservableValueInfo> values = spy.findAllTopLevelObservableValues(); assertEquals( values.size(), 1 ); assertEquals( values.iterator().next().getName(), observableValue.getName() ); assertUnmodifiable( values ); }
SpyImpl implements Spy { @Nonnull @Override public Collection<ComputableValueInfo> findAllTopLevelComputableValues() { return ComputableValueInfoImpl.asUnmodifiableInfos( getContext().getTopLevelComputableValues().values() ); } SpyImpl( @Nullable final ArezContext context ); @Override void addSpyEventHandler( @Nonnull final SpyEventHandler handler ); @Override void removeSpyEventHandler( @Nonnull final SpyEventHandler handler ); @Override void reportSpyEvent( @Nonnull final Object event ); @Override boolean willPropagateSpyEvents(); @Override boolean isTransactionActive(); @Nonnull @Override TransactionInfo getTransaction(); @Nullable @Override ComponentInfo findComponent( @Nonnull final String type, @Nonnull final Object id ); @Nonnull @Override Collection<ComponentInfo> findAllComponentsByType( @Nonnull final String type ); @Nonnull @Override Collection<String> findAllComponentTypes(); @Nonnull @Override Collection<ObservableValueInfo> findAllTopLevelObservableValues(); @Nonnull @Override Collection<ObserverInfo> findAllTopLevelObservers(); @Nonnull @Override Collection<ComputableValueInfo> findAllTopLevelComputableValues(); @Nonnull @Override Collection<TaskInfo> findAllTopLevelTasks(); @Nonnull @Override ComponentInfo asComponentInfo( @Nonnull final Component component ); @Nonnull @Override ObserverInfo asObserverInfo( @Nonnull final Observer observer ); @Nonnull @Override ObservableValueInfo asObservableValueInfo( @Nonnull final ObservableValue<T> observableValue ); @Nonnull @Override ComputableValueInfo asComputableValueInfo( @Nonnull final ComputableValue<T> computableValue ); @Nonnull @Override TaskInfo asTaskInfo( @Nonnull final Task task ); }	@Test public void findAllTopLevelComputableValues() { final ArezContext context = Arez.context(); final ComputableValue<String> computableValue = context.computable( () -> "" ); final Spy spy = context.getSpy(); final Collection<ComputableValueInfo> values = spy.findAllTopLevelComputableValues(); assertEquals( values.size(), 1 ); assertEquals( values.iterator().next().getName(), computableValue.getName() ); assertUnmodifiable( values ); assertEquals( spy.findAllTopLevelObservers().size(), 0 ); assertEquals( spy.findAllTopLevelObservableValues().size(), 0 ); }
SpyImpl implements Spy { @Nonnull @Override public Collection<ObserverInfo> findAllTopLevelObservers() { return ObserverInfoImpl.asUnmodifiableInfos( getContext().getTopLevelObservers().values() ); } SpyImpl( @Nullable final ArezContext context ); @Override void addSpyEventHandler( @Nonnull final SpyEventHandler handler ); @Override void removeSpyEventHandler( @Nonnull final SpyEventHandler handler ); @Override void reportSpyEvent( @Nonnull final Object event ); @Override boolean willPropagateSpyEvents(); @Override boolean isTransactionActive(); @Nonnull @Override TransactionInfo getTransaction(); @Nullable @Override ComponentInfo findComponent( @Nonnull final String type, @Nonnull final Object id ); @Nonnull @Override Collection<ComponentInfo> findAllComponentsByType( @Nonnull final String type ); @Nonnull @Override Collection<String> findAllComponentTypes(); @Nonnull @Override Collection<ObservableValueInfo> findAllTopLevelObservableValues(); @Nonnull @Override Collection<ObserverInfo> findAllTopLevelObservers(); @Nonnull @Override Collection<ComputableValueInfo> findAllTopLevelComputableValues(); @Nonnull @Override Collection<TaskInfo> findAllTopLevelTasks(); @Nonnull @Override ComponentInfo asComponentInfo( @Nonnull final Component component ); @Nonnull @Override ObserverInfo asObserverInfo( @Nonnull final Observer observer ); @Nonnull @Override ObservableValueInfo asObservableValueInfo( @Nonnull final ObservableValue<T> observableValue ); @Nonnull @Override ComputableValueInfo asComputableValueInfo( @Nonnull final ComputableValue<T> computableValue ); @Nonnull @Override TaskInfo asTaskInfo( @Nonnull final Task task ); }	@Test public void findAllTopLevelObservers() { final ArezContext context = Arez.context(); final Observer observer = context.observer( AbstractTest::observeADependency ); final Spy spy = context.getSpy(); final Collection<ObserverInfo> values = spy.findAllTopLevelObservers(); assertEquals( values.size(), 1 ); assertEquals( values.iterator().next().getName(), observer.getName() ); assertUnmodifiable( values ); }
SpyImpl implements Spy { @Nonnull @Override public <T> ObservableValueInfo asObservableValueInfo( @Nonnull final ObservableValue<T> observableValue ) { return observableValue.asInfo(); } SpyImpl( @Nullable final ArezContext context ); @Override void addSpyEventHandler( @Nonnull final SpyEventHandler handler ); @Override void removeSpyEventHandler( @Nonnull final SpyEventHandler handler ); @Override void reportSpyEvent( @Nonnull final Object event ); @Override boolean willPropagateSpyEvents(); @Override boolean isTransactionActive(); @Nonnull @Override TransactionInfo getTransaction(); @Nullable @Override ComponentInfo findComponent( @Nonnull final String type, @Nonnull final Object id ); @Nonnull @Override Collection<ComponentInfo> findAllComponentsByType( @Nonnull final String type ); @Nonnull @Override Collection<String> findAllComponentTypes(); @Nonnull @Override Collection<ObservableValueInfo> findAllTopLevelObservableValues(); @Nonnull @Override Collection<ObserverInfo> findAllTopLevelObservers(); @Nonnull @Override Collection<ComputableValueInfo> findAllTopLevelComputableValues(); @Nonnull @Override Collection<TaskInfo> findAllTopLevelTasks(); @Nonnull @Override ComponentInfo asComponentInfo( @Nonnull final Component component ); @Nonnull @Override ObserverInfo asObserverInfo( @Nonnull final Observer observer ); @Nonnull @Override ObservableValueInfo asObservableValueInfo( @Nonnull final ObservableValue<T> observableValue ); @Nonnull @Override ComputableValueInfo asComputableValueInfo( @Nonnull final ComputableValue<T> computableValue ); @Nonnull @Override TaskInfo asTaskInfo( @Nonnull final Task task ); }	@Test public void observable_getValue_noAccessor() { final ArezContext context = Arez.context(); final Spy spy = context.getSpy(); final ObservableValue<Integer> observableValue = context.observable(); assertInvariantFailure( () -> context.action( () -> spy.asObservableValueInfo( observableValue ).getValue() ), "Arez-0112: Spy.getValue invoked on ObservableValue named '" + observableValue.getName() + "' but ObservableValue has no property accessor." ); } @Test public void asObservableInfo() { final ArezContext context = Arez.context(); final ObservableValue<Object> observableValue = context.observable( ValueUtil.randomString() ); final ObservableValueInfo info = context.getSpy().asObservableValueInfo( observableValue ); assertEquals( info.getName(), observableValue.getName() ); }
SpyImpl implements Spy { @Nonnull @Override public ComponentInfo asComponentInfo( @Nonnull final Component component ) { return component.asInfo(); } SpyImpl( @Nullable final ArezContext context ); @Override void addSpyEventHandler( @Nonnull final SpyEventHandler handler ); @Override void removeSpyEventHandler( @Nonnull final SpyEventHandler handler ); @Override void reportSpyEvent( @Nonnull final Object event ); @Override boolean willPropagateSpyEvents(); @Override boolean isTransactionActive(); @Nonnull @Override TransactionInfo getTransaction(); @Nullable @Override ComponentInfo findComponent( @Nonnull final String type, @Nonnull final Object id ); @Nonnull @Override Collection<ComponentInfo> findAllComponentsByType( @Nonnull final String type ); @Nonnull @Override Collection<String> findAllComponentTypes(); @Nonnull @Override Collection<ObservableValueInfo> findAllTopLevelObservableValues(); @Nonnull @Override Collection<ObserverInfo> findAllTopLevelObservers(); @Nonnull @Override Collection<ComputableValueInfo> findAllTopLevelComputableValues(); @Nonnull @Override Collection<TaskInfo> findAllTopLevelTasks(); @Nonnull @Override ComponentInfo asComponentInfo( @Nonnull final Component component ); @Nonnull @Override ObserverInfo asObserverInfo( @Nonnull final Observer observer ); @Nonnull @Override ObservableValueInfo asObservableValueInfo( @Nonnull final ObservableValue<T> observableValue ); @Nonnull @Override ComputableValueInfo asComputableValueInfo( @Nonnull final ComputableValue<T> computableValue ); @Nonnull @Override TaskInfo asTaskInfo( @Nonnull final Task task ); }	@Test public void asComponentInfo() { final ArezContext context = Arez.context(); final Component component = context.component( ValueUtil.randomString(), ValueUtil.randomString() ); final ComponentInfo info = context.getSpy().asComponentInfo( component ); assertEquals( info.getName(), component.getName() ); }
SpyImpl implements Spy { @Nonnull @Override public ObserverInfo asObserverInfo( @Nonnull final Observer observer ) { return observer.asInfo(); } SpyImpl( @Nullable final ArezContext context ); @Override void addSpyEventHandler( @Nonnull final SpyEventHandler handler ); @Override void removeSpyEventHandler( @Nonnull final SpyEventHandler handler ); @Override void reportSpyEvent( @Nonnull final Object event ); @Override boolean willPropagateSpyEvents(); @Override boolean isTransactionActive(); @Nonnull @Override TransactionInfo getTransaction(); @Nullable @Override ComponentInfo findComponent( @Nonnull final String type, @Nonnull final Object id ); @Nonnull @Override Collection<ComponentInfo> findAllComponentsByType( @Nonnull final String type ); @Nonnull @Override Collection<String> findAllComponentTypes(); @Nonnull @Override Collection<ObservableValueInfo> findAllTopLevelObservableValues(); @Nonnull @Override Collection<ObserverInfo> findAllTopLevelObservers(); @Nonnull @Override Collection<ComputableValueInfo> findAllTopLevelComputableValues(); @Nonnull @Override Collection<TaskInfo> findAllTopLevelTasks(); @Nonnull @Override ComponentInfo asComponentInfo( @Nonnull final Component component ); @Nonnull @Override ObserverInfo asObserverInfo( @Nonnull final Observer observer ); @Nonnull @Override ObservableValueInfo asObservableValueInfo( @Nonnull final ObservableValue<T> observableValue ); @Nonnull @Override ComputableValueInfo asComputableValueInfo( @Nonnull final ComputableValue<T> computableValue ); @Nonnull @Override TaskInfo asTaskInfo( @Nonnull final Task task ); }	@Test public void asObserverInfo() { final ArezContext context = Arez.context(); final Observer observer = context.observer( AbstractTest::observeADependency ); final ObserverInfo info = context.getSpy().asObserverInfo( observer ); assertEquals( info.getName(), observer.getName() ); }
SpyImpl implements Spy { @Nonnull @Override public TaskInfo asTaskInfo( @Nonnull final Task task ) { return task.asInfo(); } SpyImpl( @Nullable final ArezContext context ); @Override void addSpyEventHandler( @Nonnull final SpyEventHandler handler ); @Override void removeSpyEventHandler( @Nonnull final SpyEventHandler handler ); @Override void reportSpyEvent( @Nonnull final Object event ); @Override boolean willPropagateSpyEvents(); @Override boolean isTransactionActive(); @Nonnull @Override TransactionInfo getTransaction(); @Nullable @Override ComponentInfo findComponent( @Nonnull final String type, @Nonnull final Object id ); @Nonnull @Override Collection<ComponentInfo> findAllComponentsByType( @Nonnull final String type ); @Nonnull @Override Collection<String> findAllComponentTypes(); @Nonnull @Override Collection<ObservableValueInfo> findAllTopLevelObservableValues(); @Nonnull @Override Collection<ObserverInfo> findAllTopLevelObservers(); @Nonnull @Override Collection<ComputableValueInfo> findAllTopLevelComputableValues(); @Nonnull @Override Collection<TaskInfo> findAllTopLevelTasks(); @Nonnull @Override ComponentInfo asComponentInfo( @Nonnull final Component component ); @Nonnull @Override ObserverInfo asObserverInfo( @Nonnull final Observer observer ); @Nonnull @Override ObservableValueInfo asObservableValueInfo( @Nonnull final ObservableValue<T> observableValue ); @Nonnull @Override ComputableValueInfo asComputableValueInfo( @Nonnull final ComputableValue<T> computableValue ); @Nonnull @Override TaskInfo asTaskInfo( @Nonnull final Task task ); }	@Test public void asTaskInfo() { final ArezContext context = Arez.context(); final Task task = context.task( ValueUtil::randomString ); final TaskInfo info = context.getSpy().asTaskInfo( task ); assertEquals( info.getName(), task.getName() ); }
SpyImpl implements Spy { @Nonnull @Override public <T> ComputableValueInfo asComputableValueInfo( @Nonnull final ComputableValue<T> computableValue ) { return computableValue.asInfo(); } SpyImpl( @Nullable final ArezContext context ); @Override void addSpyEventHandler( @Nonnull final SpyEventHandler handler ); @Override void removeSpyEventHandler( @Nonnull final SpyEventHandler handler ); @Override void reportSpyEvent( @Nonnull final Object event ); @Override boolean willPropagateSpyEvents(); @Override boolean isTransactionActive(); @Nonnull @Override TransactionInfo getTransaction(); @Nullable @Override ComponentInfo findComponent( @Nonnull final String type, @Nonnull final Object id ); @Nonnull @Override Collection<ComponentInfo> findAllComponentsByType( @Nonnull final String type ); @Nonnull @Override Collection<String> findAllComponentTypes(); @Nonnull @Override Collection<ObservableValueInfo> findAllTopLevelObservableValues(); @Nonnull @Override Collection<ObserverInfo> findAllTopLevelObservers(); @Nonnull @Override Collection<ComputableValueInfo> findAllTopLevelComputableValues(); @Nonnull @Override Collection<TaskInfo> findAllTopLevelTasks(); @Nonnull @Override ComponentInfo asComponentInfo( @Nonnull final Component component ); @Nonnull @Override ObserverInfo asObserverInfo( @Nonnull final Observer observer ); @Nonnull @Override ObservableValueInfo asObservableValueInfo( @Nonnull final ObservableValue<T> observableValue ); @Nonnull @Override ComputableValueInfo asComputableValueInfo( @Nonnull final ComputableValue<T> computableValue ); @Nonnull @Override TaskInfo asTaskInfo( @Nonnull final Task task ); }	@Test public void asComputableValueInfo() { final ArezContext context = Arez.context(); final ComputableValue<String> computableValue = context.computable( () -> "" ); final ComputableValueInfo info = context.getSpy().asComputableValueInfo( computableValue ); assertEquals( info.getName(), computableValue.getName() ); }
ObserverErrorHandlerSupport implements ObserverErrorHandler { void addObserverErrorHandler( @Nonnull final ObserverErrorHandler handler ) { if ( Arez.shouldCheckApiInvariants() ) { apiInvariant( () -> !_handlers.contains( handler ), () -> "Arez-0096: Attempting to add handler " + handler + " that is already in " + "the list of error handlers." ); } _handlers.add( Objects.requireNonNull( handler ) ); } @Override void onObserverError( @Nonnull final Observer observer, @Nonnull final ObserverError error, @Nullable final Throwable throwable ); }	@Test public void addObserverErrorHandler_alreadyExists() { final ObserverErrorHandlerSupport support = new ObserverErrorHandlerSupport(); final ObserverErrorHandler handler = ( observerArg, errorArg, throwableArg ) -> { }; support.addObserverErrorHandler( handler ); assertInvariantFailure( () -> support.addObserverErrorHandler( handler ), "Arez-0096: Attempting to add handler " + handler + " that is already in " + "the list of error handlers." ); }
ComputableValueInfoImpl implements ComputableValueInfo { @Nonnull @Override public List<ObservableValueInfo> getDependencies() { if ( _computableValue.isComputing() ) { final Transaction transaction = getTransactionComputing(); final List<ObservableValue<?>> observableValues = transaction.getObservableValues(); if ( null == observableValues ) { return Collections.emptyList(); } else { final List<ObservableValue<?>> list = observableValues.stream().distinct().collect( Collectors.toList() ); return ObservableValueInfoImpl.asUnmodifiableInfos( list ); } } else { return ObservableValueInfoImpl.asUnmodifiableInfos( _computableValue.getObserver().getDependencies() ); } } ComputableValueInfoImpl( @Nonnull final ComputableValue<?> computableValue ); @Nonnull @Override String getName(); @Override boolean isComputing(); @Nonnull @Override Priority getPriority(); @Override boolean isActive(); @Nonnull @Override List<ObservableValueInfo> getDependencies(); @Nonnull @Override List<ObserverInfo> getObservers(); @Nullable @Override ComponentInfo getComponent(); @OmitSymbol( unless = "arez.enable_property_introspection" ) @Nullable @Override Object getValue(); @Override boolean isDisposed(); @Override String toString(); @Override boolean equals( final Object o ); @Override int hashCode(); }	@Test public void getDependencies() { final ArezContext context = Arez.context(); final ComputableValue<String> computableValue = context.computable( () -> "" ); final ComputableValueInfo info = computableValue.asInfo(); assertEquals( info.getDependencies().size(), 0 ); final ObservableValue<?> observableValue = context.observable(); observableValue.getObservers().add( computableValue.getObserver() ); computableValue.getObserver().getDependencies().add( observableValue ); final List<ObservableValueInfo> dependencies = info.getDependencies(); assertEquals( dependencies.size(), 1 ); assertEquals( dependencies.iterator().next().getName(), observableValue.getName() ); assertUnmodifiable( dependencies ); }
ObserverErrorHandlerSupport implements ObserverErrorHandler { void removeObserverErrorHandler( @Nonnull final ObserverErrorHandler handler ) { if ( Arez.shouldCheckApiInvariants() ) { apiInvariant( () -> _handlers.contains( handler ), () -> "Arez-0097: Attempting to remove handler " + handler + " that is not in " + "the list of error handlers." ); } _handlers.remove( Objects.requireNonNull( handler ) ); } @Override void onObserverError( @Nonnull final Observer observer, @Nonnull final ObserverError error, @Nullable final Throwable throwable ); }	@Test public void removeObserverErrorHandler_noExists() { final ObserverErrorHandlerSupport support = new ObserverErrorHandlerSupport(); final ObserverErrorHandler handler = ( observerArg, errorArg, throwableArg ) -> { }; assertInvariantFailure( () -> support.removeObserverErrorHandler( handler ), "Arez-0097: Attempting to remove handler " + handler + " that is not in " + "the list of error handlers." ); }
Task extends Node { public void schedule() { if ( isIdle() ) { queueTask(); } getContext().triggerScheduler(); } Task( @Nullable final ArezContext context, @Nullable final String name, @Nonnull final SafeProcedure work, final int flags ); void schedule(); @Override void dispose(); @Override boolean isDisposed(); }	@Test public void schedule() { final AtomicInteger callCount = new AtomicInteger(); final Task task = Arez.context().task( callCount::incrementAndGet ); assertEquals( callCount.get(), 1 ); assertTrue( task.isIdle() ); task.schedule(); assertEquals( callCount.get(), 2 ); }
Task extends Node { void markAsQueued() { if ( Arez.shouldCheckInvariants() ) { invariant( this::isIdle, () -> "Arez-0128: Attempting to queue task named '" + getName() + "' when task is not idle." ); } _flags = Flags.setState( _flags, Flags.STATE_QUEUED ); } Task( @Nullable final ArezContext context, @Nullable final String name, @Nonnull final SafeProcedure work, final int flags ); void schedule(); @Override void dispose(); @Override boolean isDisposed(); }	@Test public void markAsQueued_alreadyScheduled() { final Task task = new Task( Arez.context(), "X", ValueUtil::randomString, 0 ); task.markAsQueued(); assertInvariantFailure( task::markAsQueued, "Arez-0128: Attempting to queue task named 'X' when task is not idle." ); }
Task extends Node { Task( @Nullable final ArezContext context, @Nullable final String name, @Nonnull final SafeProcedure work, final int flags ) { super( context, name ); if ( Arez.shouldCheckApiInvariants() ) { apiInvariant( () -> ( ~Flags.CONFIG_FLAGS_MASK & flags ) == 0, () -> "Arez-0224: Task named '" + name + "' passed invalid flags: " + ( ~Flags.CONFIG_FLAGS_MASK & flags ) ); } _work = Objects.requireNonNull( work ); _flags = flags \| Flags.STATE_IDLE \| Flags.runType( flags ) \| Flags.priority( flags ); if ( Arez.areRegistriesEnabled() && 0 == ( _flags & Flags.NO_REGISTER_TASK ) ) { getContext().registerTask( this ); } } Task( @Nullable final ArezContext context, @Nullable final String name, @Nonnull final SafeProcedure work, final int flags ); void schedule(); @Override void dispose(); @Override boolean isDisposed(); }	@Test public void asInfo_spyDisabled() { ArezTestUtil.disableSpies(); final Task task = Arez.context().task( ValueUtil::randomString ); assertInvariantFailure( task::asInfo, "Arez-0130: Task.asInfo() invoked but Arez.areSpiesEnabled() returned false." ); }
Task extends Node { @Nonnull Priority getPriority() { return Priority.values()[ getPriorityIndex() ]; } Task( @Nullable final ArezContext context, @Nullable final String name, @Nonnull final SafeProcedure work, final int flags ); void schedule(); @Override void dispose(); @Override boolean isDisposed(); }	@Test public void getPriority() { assertEquals( Task.Flags.getPriorityIndex( Task.Flags.PRIORITY_HIGHEST \| Task.Flags.STATE_QUEUED ), 0 ); assertEquals( Task.Flags.getPriorityIndex( Task.Flags.PRIORITY_HIGH \| Task.Flags.STATE_QUEUED ), 1 ); assertEquals( Task.Flags.getPriorityIndex( Task.Flags.PRIORITY_NORMAL \| Task.Flags.STATE_QUEUED ), 2 ); assertEquals( Task.Flags.getPriorityIndex( Task.Flags.PRIORITY_LOW \| Task.Flags.STATE_QUEUED ), 3 ); assertEquals( Task.Flags.getPriorityIndex( Task.Flags.PRIORITY_LOWEST \| Task.Flags.STATE_QUEUED ), 4 ); }
ActionFlags { static boolean isVerifyActionRuleValid( final int flags ) { return VERIFY_ACTION_REQUIRED == ( flags & VERIFY_ACTION_MASK ) \|\| NO_VERIFY_ACTION_REQUIRED == ( flags & VERIFY_ACTION_MASK ); } private ActionFlags(); static final int READ_ONLY; static final int READ_WRITE; static final int NO_REPORT_RESULT; static final int REQUIRE_NEW_TRANSACTION; static final int VERIFY_ACTION_REQUIRED; static final int NO_VERIFY_ACTION_REQUIRED; }	@Test public void isVerifyActionRuleValid() { assertTrue( ActionFlags.isVerifyActionRuleValid( ActionFlags.VERIFY_ACTION_REQUIRED ) ); assertTrue( ActionFlags.isVerifyActionRuleValid( ActionFlags.NO_VERIFY_ACTION_REQUIRED ) ); assertFalse( ActionFlags.isVerifyActionRuleValid( 0 ) ); assertFalse( ActionFlags.isVerifyActionRuleValid( ActionFlags.VERIFY_ACTION_REQUIRED \| ActionFlags.NO_VERIFY_ACTION_REQUIRED ) ); }
ActionFlags { static int verifyActionRule( final int flags ) { return Arez.shouldCheckApiInvariants() ? 0 != ( flags & VERIFY_ACTION_MASK ) ? 0 : VERIFY_ACTION_REQUIRED : 0; } private ActionFlags(); static final int READ_ONLY; static final int READ_WRITE; static final int NO_REPORT_RESULT; static final int REQUIRE_NEW_TRANSACTION; static final int VERIFY_ACTION_REQUIRED; static final int NO_VERIFY_ACTION_REQUIRED; }	@Test public void verifyActionRule() { assertEquals( ActionFlags.verifyActionRule( ActionFlags.VERIFY_ACTION_REQUIRED ), 0 ); assertEquals( ActionFlags.verifyActionRule( ActionFlags.NO_VERIFY_ACTION_REQUIRED ), 0 ); assertEquals( ActionFlags.verifyActionRule( 0 ), ActionFlags.VERIFY_ACTION_REQUIRED ); assertEquals( ActionFlags.verifyActionRule( ActionFlags.REQUIRE_NEW_TRANSACTION ), ActionFlags.VERIFY_ACTION_REQUIRED ); }
Transaction { long getStartedAt() { if ( Arez.shouldCheckInvariants() ) { invariant( Arez::areSpiesEnabled, () -> "Arez-0134: Transaction.getStartedAt() invoked when Arez.areSpiesEnabled() is false" ); } return _startedAt; } Transaction( @Nullable final ArezContext context, @Nullable final Transaction previous, @Nullable final String name, final boolean mutation, @Nullable final Observer tracker, final boolean zoneActivated ); @Nonnull @Override String toString(); }	@Test public void construction_whenSpyDisabled() { ArezTestUtil.disableSpies(); final Transaction transaction = new Transaction( Arez.context(), null, ValueUtil.randomString(), false, null, false ); ArezTestUtil.enableSpies(); assertEquals( transaction.getStartedAt(), 0 ); }
Transaction { static Transaction begin( @Nonnull final ArezContext context, @Nullable final String name, final boolean mutation, @Nullable final Observer tracker ) { if ( Arez.shouldCheckApiInvariants() && Arez.shouldEnforceTransactionType() ) { if ( null != c_transaction ) { final boolean inComputableTransaction = null != tracker && tracker.isComputableValue(); apiInvariant( () -> !c_transaction.isComputableValueTracker() \|\| inComputableTransaction, () -> "Arez-0186: Attempting to create transaction named '" + name + "' " + "nested in ComputableValue transaction named '" + c_transaction.getName() + "'. " + "ComputableValues must not invoke actions or observe methods as " + "they should derive values from other computeds and observables." ); apiInvariant( () -> !mutation \|\| c_transaction.isMutation(), () -> "Arez-0119: Attempting to create READ_WRITE transaction named '" + name + "' but it is " + "nested in transaction named '" + c_transaction.getName() + "' with mode " + "READ_ONLY which is not equal to READ_WRITE." ); apiInvariant( () -> c_transaction.getContext() != context \|\| inComputableTransaction \|\| null == tracker, () -> "Arez-0171: Attempting to create a tracking transaction named '" + name + "' for " + "the observer named '" + Objects.requireNonNull( tracker ).getName() + "' but the " + "transaction is not a top-level transaction when this is required. This may be a result " + "of nesting a observe() call inside an action or another observer function." ); } } if ( Arez.shouldCheckInvariants() ) { if ( !Arez.areZonesEnabled() && null != c_transaction ) { invariant( () -> c_transaction.getContext() == context, () -> "Arez-0120: Zones are not enabled but the transaction named '" + name + "' is " + "nested in a transaction named '" + c_transaction.getName() + "' from a " + "different context." ); } } boolean zoneActivated = false; if ( Arez.areZonesEnabled() ) { final Zone zone = context.getZone(); if ( Arez.currentZone() != zone ) { Arez.activateZone( zone ); zoneActivated = true; } } c_transaction = new Transaction( Arez.areZonesEnabled() ? context : null, c_transaction, name, mutation, tracker, zoneActivated ); context.disableScheduler(); c_transaction.begin(); if ( context.willPropagateSpyEvents() ) { assert null != name; final ObserverInfo trackerInfo = null != tracker ? tracker.asInfo() : null; context.getSpy().reportSpyEvent( new TransactionStartEvent( name, c_transaction.isMutation(), trackerInfo ) ); } return c_transaction; } Transaction( @Nullable final ArezContext context, @Nullable final Transaction previous, @Nullable final String name, final boolean mutation, @Nullable final Observer tracker, final boolean zoneActivated ); @Nonnull @Override String toString(); }	@Test public void begin() { final ArezContext context = Arez.context(); final Observer tracker = context.computable( () -> "" ).getObserver(); final Transaction transaction = new Transaction( context, null, ValueUtil.randomString(), false, tracker, false ); Transaction.setTransaction( transaction ); assertEquals( tracker.getState(), Observer.Flags.STATE_INACTIVE ); transaction.begin(); assertEquals( tracker.getState(), Observer.Flags.STATE_UP_TO_DATE ); }
Transaction { static void commit( @Nonnull final Transaction transaction ) { if ( Arez.shouldCheckInvariants() ) { invariant( () -> null != c_transaction, () -> "Arez-0122: Attempting to commit transaction named '" + transaction.getName() + "' but no transaction is active." ); assert null != c_transaction; invariant( () -> c_transaction == transaction, () -> "Arez-0123: Attempting to commit transaction named '" + transaction.getName() + "' but this does not match existing transaction named '" + c_transaction.getName() + "'." ); } assert null != c_transaction; try { c_transaction.commit(); if ( c_transaction.getContext().willPropagateSpyEvents() ) { final String name = c_transaction.getName(); final boolean mutation = !Arez.shouldEnforceTransactionType() \|\| c_transaction.isMutation(); final Observer tracker = c_transaction.getTracker(); final ObserverInfo trackerInfo = null != tracker ? tracker.asInfo() : null; final long duration = System.currentTimeMillis() - c_transaction.getStartedAt(); c_transaction .getContext() .getSpy() .reportSpyEvent( new TransactionCompleteEvent( name, mutation, trackerInfo, (int) duration ) ); } } finally { final Transaction previousInSameContext = Arez.areZonesEnabled() ? c_transaction.getPreviousInSameContext() : c_transaction.getPrevious(); if ( null == previousInSameContext ) { c_transaction.getContext().enableScheduler(); } c_transaction = c_transaction.getPrevious(); if ( Arez.areZonesEnabled() && transaction._zoneActivated ) { final Zone currentZone = transaction.getContext().getZone(); assert currentZone == Arez.currentZone(); Arez.deactivateZone( currentZone ); } } } Transaction( @Nullable final ArezContext context, @Nullable final Transaction previous, @Nullable final String name, final boolean mutation, @Nullable final Observer tracker, final boolean zoneActivated ); @Nonnull @Override String toString(); }	@Test public void commit() { final ArezContext context = Arez.context(); final ComputableValue<String> computableValue = context.computable( () -> "" ); final Observer tracker = computableValue.getObserver(); ensureDerivationHasObserver( tracker ); final Transaction transaction = new Transaction( context, null, ValueUtil.randomString(), false, tracker, false ); Transaction.setTransaction( transaction ); tracker.setState( Observer.Flags.STATE_UP_TO_DATE ); final ObservableValue<?> observableValue1 = context.observable(); final Observer derivation = context.computable( () -> "" ).getObserver(); derivation.setState( Observer.Flags.STATE_UP_TO_DATE ); final ObservableValue<?> observableValue2 = derivation.getComputableValue().getObservableValue(); observableValue2.markAsPendingDeactivation(); transaction.queueForDeactivation( observableValue2 ); assertNotNull( transaction.getPendingDeactivations() ); assertEquals( transaction.getPendingDeactivations().size(), 1 ); assertTrue( observableValue2.isActive() ); assertTrue( observableValue2.isPendingDeactivation() ); transaction.safeGetObservables().add( observableValue1 ); final List<ObservableValue<?>> dependencies = tracker.getDependencies(); transaction.commit(); assertEquals( tracker.getState(), Observer.Flags.STATE_UP_TO_DATE ); assertNotSame( tracker.getDependencies(), dependencies ); assertEquals( tracker.getDependencies().size(), 1 ); assertTrue( tracker.getDependencies().contains( observableValue1 ) ); assertEquals( observableValue1.getWorkState(), ObservableValue.NOT_IN_CURRENT_TRACKING ); assertFalse( observableValue2.isPendingDeactivation() ); assertFalse( observableValue2.isActive() ); assertEquals( observableValue2.getObserver(), derivation ); assertEquals( derivation.getState(), Observer.Flags.STATE_INACTIVE ); }
ComputableValueInfoImpl implements ComputableValueInfo { @Nullable @Override public ComponentInfo getComponent() { if ( Arez.shouldCheckInvariants() ) { invariant( Arez::areNativeComponentsEnabled, () -> "Arez-0109: Spy.getComponent invoked when Arez.areNativeComponentsEnabled() returns false." ); } final Component component = _computableValue.getComponent(); return null == component ? null : component.asInfo(); } ComputableValueInfoImpl( @Nonnull final ComputableValue<?> computableValue ); @Nonnull @Override String getName(); @Override boolean isComputing(); @Nonnull @Override Priority getPriority(); @Override boolean isActive(); @Nonnull @Override List<ObservableValueInfo> getDependencies(); @Nonnull @Override List<ObserverInfo> getObservers(); @Nullable @Override ComponentInfo getComponent(); @OmitSymbol( unless = "arez.enable_property_introspection" ) @Nullable @Override Object getValue(); @Override boolean isDisposed(); @Override String toString(); @Override boolean equals( final Object o ); @Override int hashCode(); }	@Test public void getComponent_ComputableValue_nativeComponentsDisabled() { ArezTestUtil.disableNativeComponents(); final ArezContext context = Arez.context(); final ComputableValue<Object> computableValue = context.computable( () -> "" ); assertInvariantFailure( () -> computableValue.asInfo().getComponent(), "Arez-0109: Spy.getComponent invoked when Arez.areNativeComponentsEnabled() returns false." ); }
Transaction { void beginTracking() { if ( null != _tracker ) { if ( Arez.shouldCheckInvariants() ) { _tracker.invariantDependenciesBackLink( "Pre beginTracking" ); } if ( !_tracker.isDisposing() ) { _tracker.setState( Observer.Flags.STATE_UP_TO_DATE ); } _tracker.markDependenciesLeastStaleObserverAsUpToDate(); } } Transaction( @Nullable final ArezContext context, @Nullable final Transaction previous, @Nullable final String name, final boolean mutation, @Nullable final Observer tracker, final boolean zoneActivated ); @Nonnull @Override String toString(); }	@Test public void beginTracking() { final ArezContext context = Arez.context(); final Observer tracker = context.computable( () -> "" ).getObserver(); final Transaction transaction = new Transaction( context, null, ValueUtil.randomString(), false, tracker, false ); Transaction.setTransaction( transaction ); ensureDerivationHasObserver( tracker ); tracker.setState( Observer.Flags.STATE_STALE ); assertEquals( tracker.getState(), Observer.Flags.STATE_STALE ); final ObservableValue<?> observableValue = context.observable(); observableValue.setLeastStaleObserverState( Observer.Flags.STATE_STALE ); tracker.getDependencies().add( observableValue ); observableValue.rawAddObserver( tracker ); transaction.beginTracking(); assertEquals( tracker.getState(), Observer.Flags.STATE_UP_TO_DATE ); assertEquals( observableValue.getLeastStaleObserverState(), Observer.Flags.STATE_UP_TO_DATE ); }
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(); }	@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() ); }
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(); }	@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." ); }
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(); }	@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 ); }
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(); }	@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 ); }
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(); }	@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 ); }
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(); }	@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 ) ); }
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(); }	@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." ); }
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(); }	@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() ); }
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(); }	@Test public void context_when_zones_disabled() { ArezTestUtil.disableZones(); final ArezContext context1 = Arez.context(); assertNotNull( context1 ); final ArezContext context2 = Arez.context(); assertSame( context1, context2 ); }
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(); }	@Test public void activateZone_whenZonesNotEnabled() { ArezTestUtil.disableZones(); assertInvariantFailure( () -> Arez.activateZone( new Zone() ), "Arez-0002: Invoked Arez.activateZone() but zones are not enabled." ); }
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(); }	@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." ); }
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(); }	@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." ); }
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(); }	@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() ); }
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(); }	@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() ); }
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(); }	@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() ); }
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(); }	@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() ); }
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(); }	@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." ); }
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(); }	@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() ); }
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 ) ); } }	@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." ); }
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(); }	@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." ); }
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(); }	@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." ); }
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(); }	@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." ); }
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(); }	@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." ); }
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(); }	@Test public void highPriorityComputableValue() { final ComputableValue<String> computableValue = Arez.context().computable( () -> "", ComputableValue.Flags.PRIORITY_HIGH ); assertEquals( computableValue.getObserver().getTask().getPriority(), Priority.HIGH ); }
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(); }	@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" ); }
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(); }	@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 ); }
ComputableValue extends Node { public T get() { if ( Arez.shouldCheckApiInvariants() ) { apiInvariant( () -> !_computing, () -> "Arez-0049: Detected a cycle deriving ComputableValue named '" + getName() + "'." ); apiInvariant( _observer::isNotDisposed, () -> "Arez-0050: ComputableValue named '" + getName() + "' accessed after it has been disposed." ); } if ( _readOutsideTransaction ) { getObservableValue().reportObservedIfTrackingTransactionActive(); } else { getObservableValue().reportObserved(); } if ( _observer.shouldCompute() ) { if ( _readOutsideTransaction && !getContext().isTrackingTransactionActive() ) { return getContext().rawCompute( this, () -> { _observer.invokeReaction(); return returnResult(); } ); } else { _observer.invokeReaction(); } } return returnResult(); } 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(); }	@Test public void compute_noDependencies() { ignoreObserverErrors(); final ArezContext context = Arez.context(); final ComputableValue<String> computableValue = context.computable( "XYZ", ValueUtil::randomString, ComputableValue.Flags.KEEPALIVE \| ComputableValue.Flags.RUN_LATER ); assertInvariantFailure( () -> Arez.context().safeAction( computableValue::get ), "Arez-0173: ComputableValue named 'XYZ' completed compute but is not observing any properties. As a result compute will never be rescheduled. This is not a ComputableValue candidate." ); assertEquals( getObserverErrors().size(), 1 ); assertEquals( getObserverErrors().get( 0 ), "Observer: XYZ Error: REACTION_ERROR java.lang.IllegalStateException: Arez-0173: ComputableValue named 'XYZ' completed compute but is not observing any properties. As a result compute will never be rescheduled. This is not a ComputableValue candidate." ); } @Test public void reportPossiblyChanged_observerUpToDate() { final ArezContext context = Arez.context(); final AtomicInteger computedCallCount = new AtomicInteger(); final AtomicInteger autorunCallCount = new AtomicInteger(); final AtomicInteger result = new AtomicInteger(); final AtomicReference<String> expected = new AtomicReference<>(); final ObservableValue<Object> observableValue = context.observable(); final SafeFunction<String> function = () -> { observableValue.reportObserved(); computedCallCount.incrementAndGet(); return String.valueOf( result.get() ); }; final ComputableValue<String> computableValue = context.computable( function, ComputableValue.Flags.AREZ_OR_EXTERNAL_DEPENDENCIES ); assertEquals( autorunCallCount.get(), 0 ); assertEquals( computedCallCount.get(), 0 ); expected.set( "0" ); context.observer( () -> { autorunCallCount.incrementAndGet(); assertEquals( computableValue.get(), expected.get() ); } ); assertEquals( autorunCallCount.get(), 1 ); assertEquals( computedCallCount.get(), 1 ); context.safeAction( computableValue::reportPossiblyChanged ); assertEquals( autorunCallCount.get(), 1 ); assertEquals( computedCallCount.get(), 2 ); result.set( 23 ); expected.set( "23" ); assertEquals( computedCallCount.get(), 2 ); context.safeAction( computableValue::reportPossiblyChanged ); assertEquals( autorunCallCount.get(), 2 ); assertEquals( computedCallCount.get(), 3 ); context.safeAction( observableValue::reportChanged ); assertEquals( autorunCallCount.get(), 2 ); assertEquals( computedCallCount.get(), 4 ); } @Test public void reportPossiblyChanged_readOnlyTransaction() { final ArezContext context = Arez.context(); final AtomicInteger computedCallCount = new AtomicInteger(); final AtomicInteger autorunCallCount = new AtomicInteger(); final ObservableValue<Object> observableValue = context.observable(); final SafeFunction<String> function = () -> { observableValue.reportObserved(); computedCallCount.incrementAndGet(); return ""; }; final ComputableValue<String> computableValue = context.computable( function, ComputableValue.Flags.AREZ_OR_EXTERNAL_DEPENDENCIES ); assertEquals( autorunCallCount.get(), 0 ); assertEquals( computedCallCount.get(), 0 ); context.observer( () -> { autorunCallCount.incrementAndGet(); computableValue.get(); } ); assertEquals( autorunCallCount.get(), 1 ); assertEquals( computedCallCount.get(), 1 ); assertInvariantFailure( () -> context.safeAction( computableValue::reportPossiblyChanged, ActionFlags.READ_ONLY ), "Arez-0152: Transaction named 'Action@4' attempted to change ObservableValue named '" + computableValue.getName() + "' but the transaction mode is READ_ONLY." ); assertEquals( autorunCallCount.get(), 1 ); assertEquals( computedCallCount.get(), 1 ); }
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(); }	@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 ); }
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(); }	@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." ); }
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(); }	@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() ); }
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(); }	@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 ); }
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(); }	@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 ); }
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(); }	@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 ); }
ComputableValue extends Node { @Nonnull public Disposable keepAlive() { if ( Arez.shouldCheckApiInvariants() ) { apiInvariant( () -> !getObserver().isKeepAlive(), () -> "Arez-0223: ComputableValue.keepAlive() was invoked on computable value named '" + getName() + "' but invoking this method when the computable value has been configured " + "with the KEEPALIVE flag is invalid as the computable is always activated." ); } incrementKeepAliveRefCount(); return new Disposable() { private boolean _disposed; @Override public void dispose() { if ( !_disposed ) { _disposed = true; decrementKeepAliveRefCount(); } } @Override public boolean isDisposed() { return _disposed; } }; } 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(); }	@Test public void keepAlive() { 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 ); final TestSpyEventHandler handler = TestSpyEventHandler.subscribe(); final Disposable keepAliveLock1 = computableValue.keepAlive(); assertTrue( computableValue.getObserver().isActive() ); assertEquals( computableValue.getKeepAliveRefCount(), 1 ); assertEquals( calls.get(), 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(); final Disposable keepAliveLock2 = computableValue.keepAlive(); assertTrue( computableValue.getObserver().isActive() ); assertEquals( computableValue.getKeepAliveRefCount(), 2 ); assertEquals( calls.get(), 1 ); assertFalse( keepAliveLock1.isDisposed() ); assertFalse( keepAliveLock2.isDisposed() ); handler.assertEventCount( 0 ); keepAliveLock1.dispose(); assertTrue( computableValue.getObserver().isActive() ); assertEquals( computableValue.getKeepAliveRefCount(), 1 ); assertEquals( calls.get(), 1 ); assertTrue( keepAliveLock1.isDisposed() ); assertFalse( keepAliveLock2.isDisposed() ); handler.assertEventCount( 0 ); keepAliveLock1.dispose(); assertTrue( computableValue.getObserver().isActive() ); assertEquals( computableValue.getKeepAliveRefCount(), 1 ); assertEquals( calls.get(), 1 ); assertTrue( keepAliveLock1.isDisposed() ); assertFalse( keepAliveLock2.isDisposed() ); handler.assertEventCount( 0 ); keepAliveLock2.dispose(); assertFalse( computableValue.getObserver().isActive() ); assertEquals( computableValue.getKeepAliveRefCount(), 0 ); assertTrue( keepAliveLock1.isDisposed() ); assertTrue( keepAliveLock2.isDisposed() ); assertEquals( calls.get(), 1 ); handler.assertEventCount( 4 ); handler.assertNextEvent( ActionStartEvent.class ); handler.assertNextEvent( TransactionStartEvent.class ); handler.assertNextEvent( TransactionCompleteEvent.class ); handler.assertNextEvent( ActionCompleteEvent.class ); handler.reset(); keepAliveLock2.dispose(); assertFalse( computableValue.getObserver().isActive() ); assertEquals( computableValue.getKeepAliveRefCount(), 0 ); assertTrue( keepAliveLock1.isDisposed() ); assertTrue( keepAliveLock2.isDisposed() ); assertEquals( calls.get(), 1 ); handler.assertEventCount( 0 ); }
ArezProcessor extends AbstractStandardProcessor { @Nonnull @Override protected String getOptionPrefix() { return "arez"; } @Override boolean process( @Nonnull final Set<? extends TypeElement> annotations, @Nonnull final RoundEnvironment env ); }	@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(); }
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(); }	@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() ); }
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 ); }	@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." ); }
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(); }	@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() ); }
TaskQueue { void queueTask( @Nonnull final Task task ) { queueTask( task.getPriorityIndex(), task ); } @SuppressWarnings( { "unchecked", "rawtypes", "RedundantSuppression" } ) TaskQueue( final int priorityCount, final int initialCapacity ); }	@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." ); }
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 ); }	@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" ); }
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(); }	@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" ) ); }
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(); }	@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 ); }
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(); }	@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 ); }
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(); }	@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 ); }
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(); }	@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 ); }
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(); }	@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." ); }
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(); }	@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(); }
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(); }	@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 ) ); }
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(); }	@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." ); }
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(); }	@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() ); }
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(); }	@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() ); }
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(); }	@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 ); }
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(); }	@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 ); }
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(); }	@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 ) ); }
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(); }	@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 ) ); }
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(); }	@Test public void preReportChanged() { final ArezContext context = Arez.context(); final Observer observer = newReadWriteObserver( context ); setCurrentTransaction( observer ); final ObservableValue<?> observableValue = context.observable(); observableValue.preReportChanged(); }
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(); }	@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." ); }
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(); }	@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 ); }
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(); }	@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 ); }
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(); }	@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 ); }
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(); }	@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" ) ); }
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(); }	@Test public void asInfo() { final ObservableValue<String> observableValue = Arez.context().observable(); final ObservableValueInfo info = observableValue.asInfo(); assertEquals( info.getName(), observableValue.getName() ); }
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(); }	@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 ); }
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(); }	@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 ); }
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(); }	@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 ) ); }
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(); }	@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() ); }
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(); }	@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." ); }
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(); }	@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" ); }
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(); }	@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(); }

Subsets and Splits

No community queries yet

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