Changeset d503501


Ignore:
Timestamp:
Sep 21, 2011, 2:22:59 PM (7 years ago)
Author:
Michael Seifert <mseifert@…>
Branches:
master
Children:
5fa49a5
Parents:
aee5e85
Message:

Improved handling of invalid values in AbstractReplayStorage?;
Improved MemoryStorageTest?

Location:
core/src
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • core/src/main/java/de/erichseifert/warp/core/io/AbstractReplayStorage.java

    raee5e85 rd503501  
    4545        @Override
    4646        public void save(Replay replay) {
     47                if (replay == null) {
     48                        throw new NullPointerException("Null values cannot be stored in a replay storage.");
     49                }
    4750                ReplayDescriptor descriptor = replay.getDescriptor();
    4851                fireReplayAdded(descriptor);
     
    5255        public void delete(long id) {
    5356                ReplayDescriptor descriptorOld = load(id);
    54                 fireReplayRemoved(descriptorOld);
     57                if (descriptorOld != null) {
     58                        fireReplayRemoved(descriptorOld);
     59                }
    5560        }
    5661
  • core/src/main/java/de/erichseifert/warp/core/io/MemoryStorage.java

    raee5e85 rd503501  
    3939 */
    4040public class MemoryStorage extends AbstractReplayStorage {
    41         private final Map<Long, Replay> cache;
     41        private final Map<Long, Replay> data;
    4242
    4343        /**
     
    4545         */
    4646        public MemoryStorage() {
    47                 cache = new HashMap<Long, Replay>();
     47                data = new HashMap<Long, Replay>();
    4848        }
    4949
     
    5151        public Set<ReplayDescriptor> getDescriptors() {
    5252                Set<ReplayDescriptor> descriptors = new HashSet<ReplayDescriptor>();
    53                 for (Replay replay : cache.values()) {
     53                for (Replay replay : data.values()) {
    5454                        ReplayDescriptor descriptor = replay.getDescriptor();
    5555                        descriptors.add(descriptor);
     
    6060        @Override
    6161        public void save(Replay replay) {
    62                 cache.put(replay.getDescriptor().getId(), replay);
    6362                super.save(replay);
     63                data.put(replay.getDescriptor().getId(), replay);
    6464        }
    6565
    6666        @Override
    6767        public void delete(long id) {
    68                 cache.remove(id);
    6968                super.delete(id);
     69                data.remove(id);
    7070        }
    7171
    7272        @Override
    7373        public int size() {
    74                 return cache.size();
     74                return data.size();
    7575        }
    7676
    7777        @Override
    7878        public boolean contains(File replayFile) {
    79                 for (Map.Entry<Long, Replay> entry : cache.entrySet()) {
     79                for (Map.Entry<Long, Replay> entry : data.entrySet()) {
    8080                        Replay replay = entry.getValue();
    8181                        if (replay.getDescriptor().getFile().getAbsolutePath().equals(replayFile.getAbsolutePath())) {
     
    8989        public Statistics getStatistics() {
    9090                // TODO Auto-generated method stub
    91                 return null;
     91                throw new UnsupportedOperationException("This method has not been implemented yet.");
    9292        }
    9393
     
    9595        public Set<ReplayDescriptor> search(Map<String, Object> query, Map<String, Range> ranges, SearchMode mode) {
    9696                // TODO Auto-generated method stub
    97                 return null;
     97                throw new UnsupportedOperationException("This method has not been implemented yet.");
    9898        }
    9999
     
    101101        public Set<String> getIndexNames() {
    102102                // TODO Auto-generated method stub
    103                 return null;
     103                throw new UnsupportedOperationException("This method has not been implemented yet.");
    104104        }
    105105
     
    107107        public Replay getReplay(ReplayDescriptor descriptor) {
    108108                long id = descriptor.getId();
    109                 Replay replay = cache.get(id);
     109                Replay replay = data.get(id);
    110110                return replay;
    111111        }
     
    113113        @Override
    114114        public ReplayDescriptor load(long id) {
    115                 Replay replay = cache.get(id);
     115                Replay replay = data.get(id);
     116                if (replay == null) {
     117                        return null;
     118                }
    116119                return replay.getDescriptor();
    117120        }
     
    119122        @Override
    120123        public void clear() {
    121                 cache.clear();
     124                data.clear();
    122125        }
    123126
  • core/src/main/java/de/erichseifert/warp/core/io/ReplayStorage.java

    raee5e85 rd503501  
    4141        /**
    4242         * Returns the parsed replay which belongs to the specified id.
    43          * @param id ID of the unparsed replay files.
    44          * @return Descriptor of the parsed replay.
     43         * @param id ID of the unparsed replay files
     44         * @return Descriptor of the parsed replay or {@code null}
    4545         */
    4646        ReplayDescriptor load(long id);
    4747        /**
    4848         * Stores the specified replay.
    49          * @param replay Replay to be stored.
     49         * @param replay Replay to be stored
     50         * @throws NullPointerException if the replay is {@code null}
    5051         */
    5152        void save(Replay replay);
    5253        /**
    5354         * Removes the specified replay.
    54          * @param id Replay id.
     55         * Does nothing, if a replay with the specified id is not found.
     56         * @param id Replay id
    5557         */
    5658        void delete(long id);
     
    5860        /**
    5961         * Returns the replay with the specified descriptor.
    60          * @param descriptor Descriptor of the replay.
    61          * @return Replay.
     62         * @param descriptor Descriptor of the replay
     63         * @return Replay
    6264         */
    6365        Replay getReplay(ReplayDescriptor descriptor);
     
    6769         * The order of the retrieved descriptors depends on the implementation
    6870         * of the respective implementation.
    69          * @return ReplayDescriptors.
     71         * @return ReplayDescriptors
    7072         */
    7173        Set<ReplayDescriptor> getDescriptors();
     
    7375        /**
    7476         * Returns the number of stored elements.
    75          * @return Number of stored elements.
     77         * @return Number of stored elements
    7678         */
    7779        int size();
     
    7981        /**
    8082         * Returns the statistics class for the stored replays.
    81          * @return Statistics.
     83         * @return Statistics
    8284         */
    8385        Statistics getStatistics();
     
    8688         * Returns all descriptors whose replays match the specified queries
    8789         * and ranges applied in the specified search mode.
    88          * @param queries Map containing the index name to be searched and the value to be searched for.
    89          * @param ranges Map containing the index name and the range to delimit the search.
    90          * @param mode Search mode.
    91          * @return Replay descriptors.
     90         * @param queries Map containing the index name to be searched and the value to be searched for
     91         * @param ranges Map containing the index name and the range to delimit the search
     92         * @param mode Search mode
     93         * @return Replay descriptors
    9294         */
    9395        Set<ReplayDescriptor> search(Map<String, Object> queries, Map<String, Range> ranges, SearchMode mode);
     
    9597        /**
    9698         * Returns, whether the specified replay has already been stored or not.
    97          * @param replayFile File to the unparsed replay.
    98          * @return <code>true</code> if the replay already has been stored, <code>false</code> otherwise.
     99         * @param replayFile File to the unparsed replay
     100         * @return <code>true</code> if the replay already has been stored, <code>false</code> otherwise
    99101         */
    100102        boolean contains(File replayFile);
     
    102104        /**
    103105         * Adds the specified listener to the set of notified listeners.
    104          * @param listener Listener to be added.
     106         * @param listener Listener to be added
    105107         */
    106108        void addReplayDataChangeListener(ReplayStorageListener listener);
    107109        /**
    108110         * Removes the specified listener from the set of notified listeners.
    109          * @param listener Listener to be removed.
     111         * @param listener Listener to be removed
    110112         */
    111113        void removeReplayDataChangeListener(ReplayStorageListener listener);
     
    113115        /**
    114116         * Returns the names of all registered indices.
    115          * @return Names of indices.
     117         * @return Names of indices
    116118         */
    117119        Set<String> getIndexNames();
     
    125127        /**
    126128         * Returns the path where the replays are stored.
    127          * @return Storage path.
     129         * @return Storage path
    128130         */
    129131        String getStoragePath();
    130132        /**
    131133         * Sets the storage path to the specified value.
    132          * @param path Storage path.
     134         * @param path Storage path
    133135         * @throws IOException
    134136         */
  • core/src/test/java/de/erichseifert/warp/core/io/MemoryStorageTest.java

    raee5e85 rd503501  
    11package de.erichseifert.warp.core.io;
     2
     3import static org.junit.Assert.assertEquals;
     4import static org.junit.Assert.assertFalse;
     5import static org.junit.Assert.assertTrue;
     6import static org.junit.Assert.fail;
     7
     8import java.util.Collections;
     9import java.util.Set;
    210
    311import org.junit.BeforeClass;
    412import org.junit.Test;
    513
     14import de.erichseifert.warp.core.replay.Replay;
     15import de.erichseifert.warp.core.replay.ReplayDescriptor;
     16import de.erichseifert.warp.core.replay.ReplayStub;
     17
    618public class MemoryStorageTest {
    719        private static MemoryStorage storage;
     20        private static Replay replay;
    821
    922        @BeforeClass
    1023        public static void setUpBeforeClass() throws Exception {
    1124                storage = new MemoryStorage();
     25                replay = new ReplayStub();
     26        }
     27
     28        @Test
     29        public void testSize() {
     30                assertEquals(0, storage.size());
     31        }
     32
     33        @Test
     34        public void testMemoryStorage() {
     35                MemoryStorage s = new MemoryStorage();
     36                assertEquals(0, s.size());
     37                assertEquals(Collections.<ReplayDescriptor>emptySet(), s.getDescriptors());
    1238        }
    1339
    1440        @Test
    1541        public void testSave() {
    16                 //fail("Not yet implemented"); // TODO
    17         }
    18 
    19         @Test
    20         public void testDelete() {
    21                 //fail("Not yet implemented"); // TODO
    22         }
    23 
    24         @Test
    25         public void testMemoryStorage() {
    26                 //fail("Not yet implemented"); // TODO
     42                storage.save(replay);
     43                assertEquals(1, storage.size());
     44                assertTrue(storage.contains(replay.getDescriptor().getFile()));
     45                storage.save(replay);
     46                assertEquals(1, storage.size());
     47                assertTrue(storage.contains(replay.getDescriptor().getFile()));
     48                try {
     49                        storage.save(null);
     50                        fail("Replay storage must throw a NullPointerException, if the saved value is null.");
     51                } catch (NullPointerException e) {
     52                        assertEquals(1, storage.size());
     53                        assertTrue(storage.contains(replay.getDescriptor().getFile()));
     54                }
    2755        }
    2856
    2957        @Test
    3058        public void testGetDescriptors() {
    31                 //fail("Not yet implemented"); // TODO
    32         }
    33 
    34         @Test
    35         public void testSize() {
    36                 //fail("Not yet implemented"); // TODO
     59                Set<ReplayDescriptor> d = storage.getDescriptors();
     60                assertTrue(d.contains(replay));
     61                assertEquals(1, d.size());
    3762        }
    3863
    3964        @Test
    4065        public void testContains() {
    41                 //fail("Not yet implemented"); // TODO
     66                assertTrue(storage.contains(replay.getDescriptor().getFile()));
    4267        }
    4368
     
    5984        @Test
    6085        public void testGetReplay() {
    61                 //fail("Not yet implemented"); // TODO
     86                assertEquals(replay, storage.getReplay(replay.getDescriptor()));
    6287        }
    6388
     
    7398
    7499        @Test
     100        public void testDelete() {
     101                storage.delete(replay.getDescriptor().getId());
     102                assertEquals(0, storage.size());
     103                assertFalse(storage.contains(replay.getDescriptor().getFile()));
     104                storage.delete(replay.getDescriptor().getId());
     105        }
     106
     107        @Test
    75108        public void testGetStoragePath() {
    76109                //fail("Not yet implemented"); // TODO
  • core/src/test/java/de/erichseifert/warp/core/replay/ReplayTests.java

    raee5e85 rd503501  
    2727@RunWith(Suite.class)
    2828@Suite.SuiteClasses({
    29         DefaultReplayDescriptor.class,
     29        DefaultReplayDescriptorTest.class,
    3030        DefaultReplayTest.class
    3131})
Note: See TracChangeset for help on using the changeset viewer.