Changeset 336

Timestamp:

12/20/11 13:37:14 (12 years ago)

Author:

sherbold

Message:

• made de.ugoe.cs.eventbench.data.Event and ReplayableEvent? more robust against incorrect usage, with focus on incorrect subclassing. Especially unexpected null values are now handled more reliably.

Location:

trunk/EventBenchCore/src/de/ugoe/cs/eventbench/data

Files:

• Event.java (modified) (2 diffs)
• ReplayableEvent.java (modified) (7 diffs)

trunk/EventBenchCore/src/de/ugoe/cs/eventbench/data/Event.java

@@ -96 +96 @@
                 if (other instanceof Event<?>) {
                         Event<?> otherEvent = (Event<?>) other;
-                        if (target != null) {
-                                return type.equals(otherEvent.type)
-                                                && target.equals(otherEvent.target);
+                        if (otherEvent.canEqual(this)) {
+                                if (type != null && target != null) {
+                                        return type.equals(otherEvent.type)
+                                                        && target.equals(otherEvent.target);
+                                } else if (type != null && target == null) {
+                                        return type.equals(otherEvent.type)
+                                                        && otherEvent.target == null;
+                                } else if (type == null && target != null) {
+                                        return otherEvent.type == null
+                                                        && target.equals(otherEvent.target);
+                                } else {
+                                        return otherEvent.type == null && otherEvent.target == null;
+                                }
                         } else {
-                                return type.equals(otherEvent.type)
-                                                && otherEvent.target == null;
+                                return false;
                         }
                 } else {
                         return false;
                 }
+        }
+
+        public boolean canEqual(Object other) {
+                return (other instanceof Event<?>);
         }
 
@@ -216 +229 @@
                 int multiplier = 17;
                 int hash = 42;
-                hash = multiplier * hash + type.hashCode();
+                if (type != null) {
+                        hash = multiplier * hash + type.hashCode();
+                }
                 if (target != null) {
                         hash = multiplier * hash + target.hashCode();

trunk/EventBenchCore/src/de/ugoe/cs/eventbench/data/ReplayableEvent.java

@@ -1 +1 @@
 package de.ugoe.cs.eventbench.data;
 
+import java.security.InvalidParameterException;
 import java.util.LinkedList;
 import java.util.List;
@@ -73 +74 @@
          * @param replayable
          *            element that is added to the sequence
+         * @throws InvalidParameterException
+         *             thrown is replayable is null
          */
         public void addReplayEvent(T replayable) {
+                if (replayable == null) {
+                        throw new InvalidParameterException("replayble must not be null");
+                }
                 replayEvents.add(replayable);
         }
@@ -85 +91 @@
          * @param generatedReplaySeq
          *            {@link List} that is added to the sequence
+         * @throws InvalidParameterException
+         *             thrown if generatedReplaySeq is null
          */
         public void addReplaySequence(List<T> generatedReplaySeq) {
+                if (generatedReplaySeq == null) {
+                        throw new InvalidParameterException(
+                                        "generatedReplaySeq must not be null");
+                }
                 replayEvents.addAll(generatedReplaySeq);
         }
@@ -149 +161 @@
         }
 
-        /* (non-Javadoc)
+        /*
+         * (non-Javadoc)
+         * 
          * @see de.ugoe.cs.eventbench.data.Event#equals(java.lang.Object)
          */
@@ -159 +173 @@
                 if (other instanceof ReplayableEvent<?>) {
                         ReplayableEvent<?> otherEvent = (ReplayableEvent<?>) other;
-                        return super.equals(otherEvent)
-                                        && replayEvents.equals(otherEvent.replayEvents)
-                                        && replayValid == otherEvent.replayValid;
+                        if (replayEvents != null) {
+                                return super.equals(otherEvent)
+                                                && replayEvents.equals(otherEvent.replayEvents)
+                                                && replayValid == otherEvent.replayValid;
+                        } else {
+                                return super.equals(otherEvent)
+                                                && otherEvent.replayEvents == null
+                                                && replayValid == otherEvent.replayValid;
+                        }
 
                 } else {
@@ -168 +188 @@
         }
         
-        /* (non-Javadoc)
+        @Override
+        public boolean canEqual(Object other) {
+                return (other instanceof ReplayableEvent<?>);
+        }
+
+        /*
+         * (non-Javadoc)
+         * 
          * @see de.ugoe.cs.eventbench.data.Event#hashCode()
          */
@@ -175 +202 @@
                 int multiplier = 17;
                 int hash = super.hashCode();
-                hash = multiplier * hash + replayEvents.hashCode();
+                if (replayEvents != null) {
+                        hash = multiplier * hash + replayEvents.hashCode();
+                }
                 hash = multiplier * hash + (replayValid ? 1 : 0);