Spies (emaze-dysfunctional 5.1 API)

java.lang.Object
- net.emaze.dysfunctional.Spies

```
public abstract class Spies
extends Object
```
spy, spy1st, spy2nd, spy3rd, spyRes, monitor.

Author:

rferranti

Constructor Summary

Constructors
Constructor and Description

Spies()

Constructors
Constructor and Description
`Spies()`

Method Summary

Methods
Modifier and Type	Method and Description
`static <T> Action<T>`	`monitor(Action<T> action, AtomicLong calls)` Monitors calls to an action.
`static <T1,T2> BinaryAction<T1,T2>`	`monitor(BinaryAction<T1,T2> action, AtomicLong calls)` Monitors calls to a binary action.
`static <R,T1,T2> BinaryDelegate<R,T1,T2>`	`monitor(BinaryDelegate<R,T1,T2> delegate, AtomicLong calls)` Monitors calls to a binary delegate.
`static <T1,T2> BinaryPredicate<T1,T2>`	`monitor(BinaryPredicate<T1,T2> predicate, AtomicLong calls)` Monitors calls to a binary predicate
`static <R,T> Delegate<R,T>`	`monitor(Delegate<R,T> delegate, AtomicLong calls)` Monitors calls to a delegate.
`static <T> Predicate<T>`	`monitor(Predicate<T> predicate, AtomicLong calls)` Monitors calls to a predicate.
`static Proposition`	`monitor(Proposition proposition, AtomicLong calls)` Monitors calls to a proposition.
`static <R> Provider<R>`	`monitor(Provider<R> provider, AtomicLong calls)` Monitors calls to a provider.
`static Runnable`	`monitor(Runnable runnable, AtomicLong calls)` Monitors calls to a runnable.
`static <T1,T2,T3> TernaryAction<T1,T2,T3>`	`monitor(TernaryAction<T1,T2,T3> action, AtomicLong calls)` Monitors calls to a ternary action.
`static <R,T1,T2,T3> TernaryDelegate<R,T1,T2,T3>`	`monitor(TernaryDelegate<R,T1,T2,T3> delegate, AtomicLong calls)` Monitors calls to a ternary delegate.
`static <T1,T2,T3> TernaryPredicate<T1,T2,T3>`	`monitor(TernaryPredicate<T1,T2,T3> predicate, AtomicLong calls)` Monitors calls to a ternary predicate.
`static <T> Action<T>`	`spy(Action<T> action, Box<T> param)` Proxies an action spying for parameter.
`static <T1,T2> BinaryAction<T1,T2>`	`spy(BinaryAction<T1,T2> action, Box<T1> param1, Box<T2> param2)` Proxies a binary action spying for parameters.
`static <R,T1,T2> BinaryDelegate<R,T1,T2>`	`spy(BinaryDelegate<R,T1,T2> delegate, Box<R> result, Box<T1> param1, Box<T2> param2)` Proxies a binary delegate spying for result and parameters.
`static <T1,T2> BinaryPredicate<T1,T2>`	`spy(BinaryPredicate<T1,T2> predicate, Box<Boolean> result, Box<T1> param1, Box<T2> param2)` Proxies a binary predicate spying for result and parameters.
`static <R,T> Delegate<R,T>`	`spy(Delegate<R,T> delegate, Box<R> result, Box<T> param)` Proxies a delegate spying for result and parameter.
`static <T> Predicate<T>`	`spy(Predicate<T> predicate, Box<Boolean> result, Box<T> param)` Proxies a predicate spying for result and parameter.
`static Proposition`	`spy(Proposition proposition, Box<Boolean> result)` Proxies a proposition, spying for result.
`static <R> Provider<R>`	`spy(Provider<R> provider, Box<R> result)` Proxies a provider, spying for result.
`static <T1,T2,T3> TernaryAction<T1,T2,T3>`	`spy(TernaryAction<T1,T2,T3> action, Box<T1> param1, Box<T2> param2, Box<T3> param3)` Proxies a ternary action spying for parameters.
`static <R,T1,T2,T3> TernaryDelegate<R,T1,T2,T3>`	`spy(TernaryDelegate<R,T1,T2,T3> delegate, Box<R> result, Box<T1> param1, Box<T2> param2, Box<T3> param3)` Proxies a ternary delegate spying for result and parameters.
`static <T1,T2,T3> TernaryPredicate<T1,T2,T3>`	`spy(TernaryPredicate<T1,T2,T3> predicate, Box<Boolean> result, Box<T1> param1, Box<T2> param2, Box<T3> param3)` Proxies a ternary predicate spying for result and parameters.
`static <T> Action<T>`	`spy1st(Action<T> action, Box<T> param)` Proxies a binary action spying for first parameter.
`static <T1,T2> BinaryAction<T1,T2>`	`spy1st(BinaryAction<T1,T2> action, Box<T1> param1)` Proxies a binary action spying for first parameter.
`static <R,T1,T2> BinaryDelegate<R,T1,T2>`	`spy1st(BinaryDelegate<R,T1,T2> delegate, Box<T1> param1)` Proxies a binary delegate spying for first parameter.
`static <T1,T2> BinaryPredicate<T1,T2>`	`spy1st(BinaryPredicate<T1,T2> predicate, Box<T1> param1)` Proxies a binary predicate spying for first parameter
`static <R,T> Delegate<R,T>`	`spy1st(Delegate<R,T> delegate, Box<T> param)` Proxies a delegate spying for parameter.
`static <T> Predicate<T>`	`spy1st(Predicate<T> predicate, Box<T> param)` Proxies a predicate spying for parameter.
`static <T1,T2,T3> TernaryAction<T1,T2,T3>`	`spy1st(TernaryAction<T1,T2,T3> action, Box<T1> param1)` Proxies a ternary action spying for first parameter.
`static <R,T1,T2,T3> TernaryDelegate<R,T1,T2,T3>`	`spy1st(TernaryDelegate<R,T1,T2,T3> delegate, Box<T1> param1)` Proxies a ternary delegate spying for first parameter.
`static <T1,T2,T3> TernaryPredicate<T1,T2,T3>`	`spy1st(TernaryPredicate<T1,T2,T3> predicate, Box<T1> param1)` Proxies a ternary predicate spying for first parameter.
`static <T1,T2> BinaryAction<T1,T2>`	`spy2nd(BinaryAction<T1,T2> action, Box<T2> param2)` Proxies a binary action spying for second parameter.
`static <R,T1,T2> BinaryDelegate<R,T1,T2>`	`spy2nd(BinaryDelegate<R,T1,T2> delegate, Box<T2> param2)` Proxies a binary delegate spying for second parameter.
`static <T1,T2> BinaryPredicate<T1,T2>`	`spy2nd(BinaryPredicate<T1,T2> predicate, Box<T2> param2)` Proxies a binary predicate spying for second parameter.
`static <T1,T2,T3> TernaryAction<T1,T2,T3>`	`spy2nd(TernaryAction<T1,T2,T3> action, Box<T2> param2)` Proxies a ternary action spying for second parameter.
`static <R,T1,T2,T3> TernaryDelegate<R,T1,T2,T3>`	`spy2nd(TernaryDelegate<R,T1,T2,T3> delegate, Box<T2> param2)` Proxies a ternary delegate spying for second parameter
`static <T1,T2,T3> TernaryPredicate<T1,T2,T3>`	`spy2nd(TernaryPredicate<T1,T2,T3> predicate, Box<T2> param2)` Proxies a ternary predicate spying for second parameter.
`static <T1,T2,T3> TernaryAction<T1,T2,T3>`	`spy3rd(TernaryAction<T1,T2,T3> action, Box<T3> param3)` Proxies a ternary action spying for third parameter.
`static <R,T1,T2,T3> TernaryDelegate<R,T1,T2,T3>`	`spy3rd(TernaryDelegate<R,T1,T2,T3> delegate, Box<T3> param3)` Proxies a ternary delegate spying for third parameter.
`static <T1,T2,T3> TernaryPredicate<T1,T2,T3>`	`spy3rd(TernaryPredicate<T1,T2,T3> predicate, Box<T3> param3)` Proxies a ternary predicate spying for third parameter.
`static <R,T1,T2> BinaryDelegate<R,T1,T2>`	`spyRes(BinaryDelegate<R,T1,T2> delegate, Box<R> result)` Proxies a binary delegate spying for result.
`static <T1,T2> BinaryPredicate<T1,T2>`	`spyRes(BinaryPredicate<T1,T2> predicate, Box<Boolean> result)` Proxies a binary predicate spying for result.
`static <R,T> Delegate<R,T>`	`spyRes(Delegate<R,T> delegate, Box<R> result)` Proxies a delegate spying for result.
`static <T> Predicate<T>`	`spyRes(Predicate<T> predicate, Box<Boolean> result)` Proxies a predicate spying for result.
`static <R,T1,T2,T3> TernaryDelegate<R,T1,T2,T3>`	`spyRes(TernaryDelegate<R,T1,T2,T3> delegate, Box<R> result)` Proxies a ternary delegate spying for result.
`static <T1,T2,T3> TernaryPredicate<T1,T2,T3>`	`spyRes(TernaryPredicate<T1,T2,T3> predicate, Box<Boolean> result)` Proxies a ternary predicate spying for result.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - Spies
```
public Spies()
```
- Method Detail
  - spy
```
public static Proposition spy(Proposition proposition,
              Box<Boolean> result)
```
    Proxies a proposition, spying for result.
    
    Parameters:
    proposition - the proposition to be spied
    result - a box that will be containing spied result
    
    Returns:
    the proxied proposition
  - spy
```
public static <R> Provider<R> spy(Provider<R> provider,
                  Box<R> result)
```
    Proxies a provider, spying for result.
    
    Type Parameters:
    R - the provider result type
    Parameters:
    provider - the provider to be spied
    result - a box that will be containing spied result
    
    Returns:
    the proxied provider
  - spy
```
public static <R,T> Delegate<R,T> spy(Delegate<R,T> delegate,
                      Box<R> result,
                      Box<T> param)
```
    Proxies a delegate spying for result and parameter.
    
    Type Parameters:
    R - the delegate result type
    T - the delegate parameter type
    Parameters:
    delegate - the delegate to be spied
    result - a box that will be containing spied result
    param - a box that will be containing spied param
    
    Returns:
    the proxied delegate
  - spy
```
public static <R,T1,T2> BinaryDelegate<R,T1,T2> spy(BinaryDelegate<R,T1,T2> delegate,
                                    Box<R> result,
                                    Box<T1> param1,
                                    Box<T2> param2)
```
    Proxies a binary delegate spying for result and parameters.
    
    Type Parameters:
    R - the delegate result type
    T1 - the delegate first parameter type
    T2 - the delegate second parameter type
    Parameters:
    delegate - the delegate to be spied
    result - a box that will be containing spied result
    param1 - a box that will be containing the first spied parameter
    param2 - a box that will be containing the second spied parameter
    
    Returns:
    the proxied delegate
  - spy
```
public static <R,T1,T2,T3> TernaryDelegate<R,T1,T2,T3> spy(TernaryDelegate<R,T1,T2,T3> delegate,
                                           Box<R> result,
                                           Box<T1> param1,
                                           Box<T2> param2,
                                           Box<T3> param3)
```
    Proxies a ternary delegate spying for result and parameters.
    
    Type Parameters:
    R - the delegate result type
    T1 - the delegate first parameter type
    T2 - the delegate second parameter type
    T3 - the delegate third parameter type
    Parameters:
    delegate - the delegate to be spied
    result - a box that will be containing spied result
    param1 - a box that will be containing the first spied parameter
    param2 - a box that will be containing the second spied parameter
    param3 - a box that will be containing the third spied parameter
    
    Returns:
    the proxied delegate
  - spy
```
public static <T> Predicate<T> spy(Predicate<T> predicate,
                   Box<Boolean> result,
                   Box<T> param)
```
    Proxies a predicate spying for result and parameter.
    
    Type Parameters:
    T - the predicate parameter type
    Parameters:
    predicate - the predicateto be spied
    result - a box that will be containing spied result
    param - a box that will be containing the spied parameter
    
    Returns:
    the proxied predicate
  - spy
```
public static <T1,T2> BinaryPredicate<T1,T2> spy(BinaryPredicate<T1,T2> predicate,
                                 Box<Boolean> result,
                                 Box<T1> param1,
                                 Box<T2> param2)
```
    Proxies a binary predicate spying for result and parameters.
    
    Type Parameters:
    T1 - the predicate first parameter type
    T2 - the predicate second parameter type
    Parameters:
    predicate - the predicate to be spied
    result - a box that will be containing spied result
    param1 - a box that will be containing the first spied parameter
    param2 - a box that will be containing the second spied parameter
    
    Returns:
    the proxied predicate
  - spy
```
public static <T1,T2,T3> TernaryPredicate<T1,T2,T3> spy(TernaryPredicate<T1,T2,T3> predicate,
                                        Box<Boolean> result,
                                        Box<T1> param1,
                                        Box<T2> param2,
                                        Box<T3> param3)
```
    Proxies a ternary predicate spying for result and parameters.
    
    Type Parameters:
    T1 - the predicate first parameter type
    T2 - the predicate second parameter type
    T3 - the predicate third parameter type
    Parameters:
    predicate - the predicate to be spied
    result - a box that will be containing spied result
    param1 - a box that will be containing the first spied parameter
    param2 - a box that will be containing the second spied parameter
    param3 - a box that will be containing the third spied parameter
    
    Returns:
    the proxied predicate
  - spy
```
public static <T> Action<T> spy(Action<T> action,
                Box<T> param)
```
    Proxies an action spying for parameter.
    
    Type Parameters:
    T - the action parameter type
    Parameters:
    action - the action to be spied
    param - a box that will be containing the spied parameter
    
    Returns:
    the proxied action
  - spy
```
public static <T1,T2> BinaryAction<T1,T2> spy(BinaryAction<T1,T2> action,
                              Box<T1> param1,
                              Box<T2> param2)
```
    Proxies a binary action spying for parameters.
    
    Type Parameters:
    T1 - the action first parameter type
    T2 - the action second parameter type
    Parameters:
    action - the action that will be spied
    param1 - a box that will be containing the first spied parameter
    param2 - a box that will be containing the second spied parameter
    
    Returns:
    the proxied action
  - spy
```
public static <T1,T2,T3> TernaryAction<T1,T2,T3> spy(TernaryAction<T1,T2,T3> action,
                                     Box<T1> param1,
                                     Box<T2> param2,
                                     Box<T3> param3)
```
    Proxies a ternary action spying for parameters.
    
    Type Parameters:
    T1 - the action first parameter type
    T2 - the action second parameter type
    T3 - the action third parameter type
    Parameters:
    action - the action that will be spied
    param1 - a box that will be containing the first spied parameter
    param2 - a box that will be containing the second spied parameter
    param3 - a box that will be containing the third spied parameter
    
    Returns:
    the proxied action
  - spyRes
```
public static <R,T1,T2,T3> TernaryDelegate<R,T1,T2,T3> spyRes(TernaryDelegate<R,T1,T2,T3> delegate,
                                              Box<R> result)
```
    Proxies a ternary delegate spying for result.
    
    Type Parameters:
    R - the delegate result type
    T1 - the delegate first parameter type
    T2 - the delegate second parameter type
    T3 - the delegate third parameter type
    Parameters:
    delegate - the delegate that will be spied
    result - a box that will be containing spied result
    
    Returns:
    the proxied delegate
  - spy1st
```
public static <R,T1,T2,T3> TernaryDelegate<R,T1,T2,T3> spy1st(TernaryDelegate<R,T1,T2,T3> delegate,
                                              Box<T1> param1)
```
    Proxies a ternary delegate spying for first parameter.
    
    Type Parameters:
    R - the delegate result type
    T1 - the delegate first parameter type
    T2 - the delegate second parameter type
    T3 - the delegate third parameter type
    Parameters:
    delegate - the delegate that will be spied
    param1 - a box that will be containing the first spied parameter
    
    Returns:
    the proxied delegate
  - spy2nd
```
public static <R,T1,T2,T3> TernaryDelegate<R,T1,T2,T3> spy2nd(TernaryDelegate<R,T1,T2,T3> delegate,
                                              Box<T2> param2)
```
    Proxies a ternary delegate spying for second parameter
    
    Type Parameters:
    R - the delegate result type
    T1 - the delegate first parameter type
    T2 - the delegate second parameter type
    T3 - the delegate third parameter type
    Parameters:
    delegate - the delegate that will be spied
    param2 - a box that will be containing the second spied parameter
    
    Returns:
    the proxied delegate
  - spy3rd
```
public static <R,T1,T2,T3> TernaryDelegate<R,T1,T2,T3> spy3rd(TernaryDelegate<R,T1,T2,T3> delegate,
                                              Box<T3> param3)
```
    Proxies a ternary delegate spying for third parameter.
    
    Type Parameters:
    R - the delegate result type
    T1 - the delegate first parameter type
    T2 - the delegate second parameter type
    T3 - the delegate third parameter type
    Parameters:
    delegate - the delegate that will be spied
    param3 - a box that will be containing the third spied parameter
    
    Returns:
    the proxied delegate
  - spyRes
```
public static <R,T1,T2> BinaryDelegate<R,T1,T2> spyRes(BinaryDelegate<R,T1,T2> delegate,
                                       Box<R> result)
```
    Proxies a binary delegate spying for result.
    
    Type Parameters:
    R - the delegate result type
    T1 - the delegate first parameter type
    T2 - the delegate second parameter type
    Parameters:
    delegate - the delegate that will be spied
    result - a box that will be containing spied result
    
    Returns:
    the proxied delegate
  - spy1st
```
public static <R,T1,T2> BinaryDelegate<R,T1,T2> spy1st(BinaryDelegate<R,T1,T2> delegate,
                                       Box<T1> param1)
```
    Proxies a binary delegate spying for first parameter.
    
    Type Parameters:
    R - the delegate result type
    T1 - the delegate first parameter type
    T2 - the delegate second parameter type
    Parameters:
    delegate - the delegate that will be spied
    param1 - a box that will be containing the first spied parameter
    
    Returns:
    the proxied delegate
  - spy2nd
```
public static <R,T1,T2> BinaryDelegate<R,T1,T2> spy2nd(BinaryDelegate<R,T1,T2> delegate,
                                       Box<T2> param2)
```
    Proxies a binary delegate spying for second parameter.
    
    Type Parameters:
    R - the delegate result type
    T1 - the delegate first parameter type
    T2 - the delegate second parameter type
    Parameters:
    delegate - the delegate that will be spied
    param2 - a box that will be containing the second spied parameter
    
    Returns:
    the proxied delegate
  - spyRes
```
public static <R,T> Delegate<R,T> spyRes(Delegate<R,T> delegate,
                         Box<R> result)
```
    Proxies a delegate spying for result.
    
    Type Parameters:
    R - the delegate result type
    T - the delegate parameter type
    Parameters:
    delegate - the delegate that will be spied
    result - a box that will be containing spied result
    
    Returns:
    the proxied delegate
  - spy1st
```
public static <R,T> Delegate<R,T> spy1st(Delegate<R,T> delegate,
                         Box<T> param)
```
    Proxies a delegate spying for parameter.
    
    Type Parameters:
    R - the delegate result type
    T - the delegate parameter type
    Parameters:
    delegate - the delegate that will be spied
    param - a box that will be containing spied parameter
    
    Returns:
    the proxied delegate
  - spy1st
```
public static <T1,T2,T3> TernaryAction<T1,T2,T3> spy1st(TernaryAction<T1,T2,T3> action,
                                        Box<T1> param1)
```
    Proxies a ternary action spying for first parameter.
    
    Type Parameters:
    T1 - the action first parameter type
    T2 - the action second parameter type
    T3 - the action third parameter type
    Parameters:
    action - the action that will be spied
    param1 - a box that will be containing the first spied parameter
    
    Returns:
    the proxied action
  - spy2nd
```
public static <T1,T2,T3> TernaryAction<T1,T2,T3> spy2nd(TernaryAction<T1,T2,T3> action,
                                        Box<T2> param2)
```
    Proxies a ternary action spying for second parameter.
    
    Type Parameters:
    T1 - the action first parameter type
    T2 - the action second parameter type
    T3 - the action third parameter type
    Parameters:
    action - the action that will be spied
    param2 - a box that will be containing the second spied parameter
    
    Returns:
    the proxied action
  - spy3rd
```
public static <T1,T2,T3> TernaryAction<T1,T2,T3> spy3rd(TernaryAction<T1,T2,T3> action,
                                        Box<T3> param3)
```
    Proxies a ternary action spying for third parameter.
    
    Type Parameters:
    T1 - the action first parameter type
    T2 - the action second parameter type
    T3 - the action third parameter type
    Parameters:
    action - the action that will be spied
    param3 - a box that will be containing the third spied parameter
    
    Returns:
    the proxied action
  - spy1st
```
public static <T1,T2> BinaryAction<T1,T2> spy1st(BinaryAction<T1,T2> action,
                                 Box<T1> param1)
```
    Proxies a binary action spying for first parameter.
    
    Type Parameters:
    T1 - the action first parameter type
    T2 - the action second parameter type
    Parameters:
    action - the action that will be spied
    param1 - a box that will be containing the first spied parameter
    
    Returns:
    the proxied action
  - spy2nd
```
public static <T1,T2> BinaryAction<T1,T2> spy2nd(BinaryAction<T1,T2> action,
                                 Box<T2> param2)
```
    Proxies a binary action spying for second parameter.
    
    Type Parameters:
    T1 - the action first parameter type
    T2 - the action second parameter type
    Parameters:
    action - the action that will be spied
    param2 - a box that will be containing the second spied parameter
    
    Returns:
    the proxied action
  - spy1st
```
public static <T> Action<T> spy1st(Action<T> action,
                   Box<T> param)
```
    Proxies a binary action spying for first parameter.
    
    Type Parameters:
    T - the action parameter type
    Parameters:
    action - the action that will be spied
    param - a box that will be containing the spied parameter
    
    Returns:
    the proxied action
  - spyRes
```
public static <T1,T2,T3> TernaryPredicate<T1,T2,T3> spyRes(TernaryPredicate<T1,T2,T3> predicate,
                                           Box<Boolean> result)
```
    Proxies a ternary predicate spying for result.
    
    Type Parameters:
    T1 - the predicate first parameter type
    T2 - the predicate second parameter type
    T3 - the predicate third parameter type
    Parameters:
    predicate - the predicate that will be spied
    result - a box that will be containing spied result
    
    Returns:
    the proxied predicate
  - spy1st
```
public static <T1,T2,T3> TernaryPredicate<T1,T2,T3> spy1st(TernaryPredicate<T1,T2,T3> predicate,
                                           Box<T1> param1)
```
    Proxies a ternary predicate spying for first parameter.
    
    Type Parameters:
    T1 - the predicate first parameter type
    T2 - the predicate second parameter type
    T3 - the predicate third parameter type
    Parameters:
    predicate - the predicate that will be spied
    param1 - a box that will be containing the first spied parameter
    
    Returns:
    the proxied predicate
  - spy2nd
```
public static <T1,T2,T3> TernaryPredicate<T1,T2,T3> spy2nd(TernaryPredicate<T1,T2,T3> predicate,
                                           Box<T2> param2)
```
    Proxies a ternary predicate spying for second parameter.
    
    Type Parameters:
    T1 - the predicate first parameter type
    T2 - the predicate second parameter type
    T3 - the predicate third parameter type
    Parameters:
    predicate - the predicate that will be spied
    param2 - a box that will be containing the second spied parameter
    
    Returns:
    the proxied predicate
  - spy3rd
```
public static <T1,T2,T3> TernaryPredicate<T1,T2,T3> spy3rd(TernaryPredicate<T1,T2,T3> predicate,
                                           Box<T3> param3)
```
    Proxies a ternary predicate spying for third parameter.
    
    Type Parameters:
    T1 - the predicate first parameter type
    T2 - the predicate second parameter type
    T3 - the predicate third parameter type
    Parameters:
    predicate - the predicate that will be spied
    param3 - a box that will be containing the third spied parameter
    
    Returns:
    the proxied predicate
  - spyRes
```
public static <T1,T2> BinaryPredicate<T1,T2> spyRes(BinaryPredicate<T1,T2> predicate,
                                    Box<Boolean> result)
```
    Proxies a binary predicate spying for result.
    
    Type Parameters:
    T1 - the predicate first parameter type
    T2 - the predicate second parameter type
    Parameters:
    predicate - the predicate that will be spied
    result - a box that will be containing spied result
    
    Returns:
    the proxied predicate
  - spy1st
```
public static <T1,T2> BinaryPredicate<T1,T2> spy1st(BinaryPredicate<T1,T2> predicate,
                                    Box<T1> param1)
```
    Proxies a binary predicate spying for first parameter
    
    Type Parameters:
    T1 - the predicate first parameter type
    T2 - the predicate second parameter type
    Parameters:
    predicate - the predicate that will be spied
    param1 - a box that will be containing the first spied parameter
    
    Returns:
    the proxied predicate
  - spy2nd
```
public static <T1,T2> BinaryPredicate<T1,T2> spy2nd(BinaryPredicate<T1,T2> predicate,
                                    Box<T2> param2)
```
    Proxies a binary predicate spying for second parameter.
    
    Type Parameters:
    T1 - the predicate first parameter type
    T2 - the predicate second parameter type
    Parameters:
    predicate - the predicate that will be spied
    param2 - a box that will be containing the second spied parameter
    
    Returns:
    the proxied predicate
  - spyRes
```
public static <T> Predicate<T> spyRes(Predicate<T> predicate,
                      Box<Boolean> result)
```
    Proxies a predicate spying for result.
    
    Type Parameters:
    T - the predicate parameter type
    Parameters:
    predicate - the predicate that will be spied
    result - a box that will be containing spied result
    
    Returns:
    the proxied predicate
  - spy1st
```
public static <T> Predicate<T> spy1st(Predicate<T> predicate,
                      Box<T> param)
```
    Proxies a predicate spying for parameter.
    
    Type Parameters:
    T - the predicate parameter type
    Parameters:
    predicate - the predicate that will be spied
    param - a box that will be containing spied parameter
    
    Returns:
    the proxied predicate
  - monitor
```
public static <T> Action<T> monitor(Action<T> action,
                    AtomicLong calls)
```
    Monitors calls to an action.
    
    Type Parameters:
    T - the action parameter type
    Parameters:
    action - the action that will be monitored
    calls - a value holder accumulating calls
    
    Returns:
    the proxied action
  - monitor
```
public static <R,T> Delegate<R,T> monitor(Delegate<R,T> delegate,
                          AtomicLong calls)
```
    Monitors calls to a delegate.
    
    Type Parameters:
    R - the delegate result type
    T - the delegate parameter type
    Parameters:
    delegate - the delegate that will be monitored
    calls - a value holder accumulating calls
    
    Returns:
    the proxied delegate
  - monitor
```
public static <T> Predicate<T> monitor(Predicate<T> predicate,
                       AtomicLong calls)
```
    Monitors calls to a predicate.
    
    Type Parameters:
    T - the predicate parameter type
    Parameters:
    predicate - the predicate that will be monitored
    calls - a value holder accumulating calls
    
    Returns:
    the proxied predicate
  - monitor
```
public static Proposition monitor(Proposition proposition,
                  AtomicLong calls)
```
    Monitors calls to a proposition.
    
    Parameters:
    proposition - the proposition that will be monitored
    calls - a value holder accumulating calls
    
    Returns:
    the proxied proposition
  - monitor
```
public static <R> Provider<R> monitor(Provider<R> provider,
                      AtomicLong calls)
```
    Monitors calls to a provider.
    
    Type Parameters:
    R - the provider result type
    Parameters:
    provider - the provider that will be monitored
    calls - a value holder accumulating calls
    
    Returns:
    the proxied provider
  - monitor
```
public static Runnable monitor(Runnable runnable,
               AtomicLong calls)
```
    Monitors calls to a runnable.
    
    Parameters:
    runnable - the runnable that will be monitored
    calls - a value holder accumulating calls
    
    Returns:
    the proxied runnable
  - monitor
```
public static <T1,T2> BinaryAction<T1,T2> monitor(BinaryAction<T1,T2> action,
                                  AtomicLong calls)
```
    Monitors calls to a binary action.
    
    Type Parameters:
    T1 - the action first parameter type
    T2 - the action second parameter type
    Parameters:
    action - the action that will be monitored
    calls - a value holder accumulating calls
    
    Returns:
    the proxied action
  - monitor
```
public static <R,T1,T2> BinaryDelegate<R,T1,T2> monitor(BinaryDelegate<R,T1,T2> delegate,
                                        AtomicLong calls)
```
    Monitors calls to a binary delegate.
    
    Type Parameters:
    R - the delegate result type
    T1 - the delegate first parameter type
    T2 - the delegate second parameter type
    Parameters:
    delegate - the delegate that will be monitored
    calls - a value holder accumulating calls
    
    Returns:
    the proxied delegate
  - monitor
```
public static <T1,T2> BinaryPredicate<T1,T2> monitor(BinaryPredicate<T1,T2> predicate,
                                     AtomicLong calls)
```
    Monitors calls to a binary predicate
    
    Type Parameters:
    T1 - the predicate first parameter type
    T2 - the predicate second parameter type
    Parameters:
    predicate - the predicate that will be monitored
    calls - a value holder accumulating calls
    
    Returns:
    the proxied predicate
  - monitor
```
public static <T1,T2,T3> TernaryAction<T1,T2,T3> monitor(TernaryAction<T1,T2,T3> action,
                                         AtomicLong calls)
```
    Monitors calls to a ternary action.
    
    Type Parameters:
    T1 - the action first parameter type
    T2 - the action second parameter type
    T3 - the action third parameter type
    Parameters:
    action - the action that will be monitored
    calls - a value holder accumulating calls
    
    Returns:
    the proxied action
  - monitor
```
public static <R,T1,T2,T3> TernaryDelegate<R,T1,T2,T3> monitor(TernaryDelegate<R,T1,T2,T3> delegate,
                                               AtomicLong calls)
```
    Monitors calls to a ternary delegate.
    
    Type Parameters:
    R - the delegate result type
    T1 - the delegate first parameter type
    T2 - the delegate second parameter type
    T3 - the delegate third parameter type
    Parameters:
    delegate - the delegate that will be monitored
    calls - a value holder accumulating calls
    
    Returns:
    the proxied delegate
  - monitor
```
public static <T1,T2,T3> TernaryPredicate<T1,T2,T3> monitor(TernaryPredicate<T1,T2,T3> predicate,
                                            AtomicLong calls)
```
    Monitors calls to a ternary predicate.
    
    Type Parameters:
    T1 - the predicate first parameter type
    T2 - the predicate second parameter type
    T3 - the predicate third parameter type
    Parameters:
    predicate - the predicate that will be monitored
    calls - a value holder accumulating calls
    
    Returns:
    the proxied predicate

Class Spies

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

Spies

Method Detail

spy

spy

spy

spy

spy

spy

spy

spy

spy

spy

spy

spyRes

spy1st

spy2nd

spy3rd

spyRes

spy1st

spy2nd

spyRes

spy1st

spy1st

spy2nd

spy3rd

spy1st

spy2nd

spy1st

spyRes

spy1st

spy2nd

spy3rd

spyRes

spy1st

spy2nd

spyRes

spy1st

monitor

monitor

monitor

monitor

monitor

monitor

monitor

monitor

monitor

monitor

monitor

monitor