ID | JavaSpaces Requirements | Section | Comments
1. | A write places a copy of an entry into the given JavaSpaces service. The Entry passed to the write is not affected by the operation. | 2.3 | write
2. | Each write operation places a new entry into the specified space, even if the same Entry object is used in more than one write. | 2.3 | write
3. | Each write invocation returns a Lease object that is lease milliseconds long. | 2.3 | write
4. | When the lease expires, the entry is removed from the space. | 2.3 | write
5. | You will get an IllegalArgumentException if the lease time requested is negative and not equal to Lease.ANY. | 2.3 | write
6. | If a write returns without throwing an exception, that entry is committed to the space, possibly within a transaction. | 2.3 | write
7. | If any other exception rather then RemoteException is thrown, the entry was not written into the space. | 2.3 | (?)*** write
8. | Writing an entry into a space might generate notifications to registered objects. | 2.3 | write, notify
9. | If a match is found by read, a reference to a copy of the matching entry is returned. | 2.4 | read
10. | If no match is found, null is returned. | 2.4 | read
11. | Passing a null reference for the template will match any entry. | 2.4 | read, readIfExists
12. | A readIfExists request will return a matching entry, or null if there is currently no matching entry in the space. | 2.4 | readIfExists
13. | If the only possible matches for the template have conflicting locks from one or more other transactions, the timeout value specifies how long the client is willing to wait for interfering transactions to settle before returning a values. | 2.4 | readIfExists, takeIfExists, transaction
14. | If at the end of that time no value can be returned that would not interfere with transactional state, null is returned. | 2.4 | readIfExists, takeIfExists, transaction
15. | A read request will wait until a matching entry is found or until transactions settle, whichever is longer, up to the timeout period. | 2.4 | read, transaction
16. | In both read methods, a timeout of NO_WAIT means to return immediately, with no waiting, which is equivalent to using a zero timeout. | 2.4 | readIfExists, read
17. | The take, takeIfExists requests perform exactly like the corresponding read requests, except that the matching entry is removed from the space.(related to IDs: 8, 9, 10, 11, 12, 13, 14, 15) | 2.5 | take, takeIfExists
18. | If a take returns a non-null value, the entry has been removed from the space, possibly within a transaction. | 2.5 | take, takeIfExists
19. | If any other exception is thrown rather then RemoteException or UnusableEntryException, the take did not occur, and no entry was removed from the space | 2.5 | (?)*** take
20. | A take is considered to be successful only if all enclosing transactions commit successfully. | 2.5 | take, takeIfExists, transaction
21. | Using the returned snapshot entry is equivalent to using the unmodified original entry in all operations on the same JavaSpaces service. | 2.6 | snapshot
22. | Modifications to the original entry will not affect the snapshot. | 2.6 | snapshot
23. | Using snapshot with any other JavaSpaces service will generate an IllegalArgumentException unless the other space can use it because of knowledge about the JavaSpaces service that generated the snapshot. | 2.6 | snapshot
24. | You can snapshot a null template. | 2.6 | snapshot
25. | A notify request's matching is done as it is for read. (9,10,11) | 2.7 | notify
26. | When matching entries arrive, the specified RemoteEventListener will eventually be notified by invoking listener's notify method. | 2.7 | notify
27. | You will get an IllegalArgumentException if the lease time requested is not Lease.ANY and is negative. | 2.7 | notify
28. | If the transaction parameter is null, the listener will be notified when matching entries are written either under a null transaction or when a transaction commits. | 2.7 | notify, transaction
29. | If an entry is written under a transaction and then taken under that same transaction before the transaction is committed, listeners registered under a null transaction will not be notified of that entry. | 2.7, 3.1 | notify, transaction, take, takeIfExists
30. | If the transaction parameter is not null, the listener will be notified of matching entries written under that transaction in addition to the notifications it would receive under a null transaction. | 2.7 | notify, transaction
31. | The request specified by a successful notify is as persistent as the entries of the space. They will be remembered as long as an un-taken entry would be, until the lease expires, or until any governing transaction completes, whichever is shorter. | 2.7 | notify, transaction
32. | An entry that is written under the non null transaction is not visible outside its transaction until the transaction successfully commits. | 3.1 | write, transaction
33. | If the entry is written and after that is taken within the non null transaction, the entry will never be visible outside the transaction and will not be added to the space when the transaction commits. | 3.1 | write, take, takeIfExists, transaction
34. | Entries written under a transaction that aborts are discarded. | 3.1 | write, transaction
35. | When read, an entry may be read in any other transaction to which the entry is visible, but cannot be taken in another transaction. | 3.1 | read, readIfExists, take, transaction
36. | When taken, an entry may not be read or taken by any other transaction. | 3.1 | take, takeIfExists, read, transaction
37. | When a transaction commits, any entries that were written under the transaction (and not taken) will cause appropriate notifications for registrations that were made under a null transaction. | 3.1 | write, notify, transaction

(?)*** - It is not obvious how to check this essential statement.