          {:name "elasticell"
           :os debian/os
           :db (db "latest")
+          :pd   #{"n5" "n6" "n1" "localhost"}
           :client (client nil)
-          :nemesis (nemesis/partition-random-halves)
-          :model  (elasticell-register)
-          :checker (checker/compose
-                     {
-                      :perf     (checker/perf)
-                      :indep (independent/checker
-                               (checker/compose
-                                 {:timeline (timeline/html)
-                                  :linear   (checker/linearizable)}))})
-          :generator (->> (independent/concurrent-generator
-                            1
-                            (range)
-                            (fn [k]
-                              (->> (gen/mix [r w])
-                                   (gen/stagger 1/100)
-                                   (gen/limit 500))))
-                          (gen/nemesis
-                            (gen/seq (cycle [(gen/sleep 4)
-                                             {:type :info, :f :start}
-                                             (gen/sleep 4)
-                                             {:type :info, :f :stop}])))
-                          (gen/time-limit (:time-limit opts)))}
-         opts))
+                :nemesis (
+            nemesis/compose {
+            ;(nemesis/partition-majorities-ring)				;Every node can see a majority, but no node sees the *same* majority
+                    ;(nemesis/partition-random-halves)
+            {:start :start :stop :stop} (nemesis/partition-halves) 		;first partion is smaller
+            ;(nemesis/clock-scrambler 1)		;
+            {:paused :start :resumed :stop} (nemesis/hammer-time :redis-server)}	;pause and resume the proccess named redis-server
+            )
+                :model  (elasticell-register)
+                :checker (checker/compose
+                          {
+                            :perf     (checker/perf)
+                            :indep (independent/checker
+                                    (checker/compose
+                                      {:timeline (timeline/html)
+                                        :linear   (checker/linearizable)}))})
+                :generator (->> (independent/concurrent-generator
+                                  1
+                                  (range)		     ;generated key range from 0 to 1
+                                  (fn [k]
+                                    (gen/concat
+                                      (->> (gen/mix [hset hget])
+                                          (gen/stagger 1/100) ;average time interval between 2 client operation
+                                          (gen/limit 160)     ;total operations of a single independent key
+                                      )
+                                      ;(gen/sleep 1)	     ;sleep 1 seconds after a single independent key operation; comment it if you don't want to pause the operation
+                                      (gen/once {:type :invoke, :f :final})
+                                    )
+                                  )
+                                )
+                                (gen/nemesis
+                                  (gen/concat
+                                      (gen/start-stop 1 6) ;start network partition 1 seconds after previous nemesis stop, resume at 3 seconds later
+                                      ;(nemesis-gen) 
+                                  )
+                                ;(gen/seq (cycle 
+                                ;	  [(gen/sleep 1)   ;generate a nemesis loops until time limit
+                                                  ;           {:type :info, :f :start}
+                                ;	   (gen/sleep 2)
+                                ;	      {:type :info, :f :paused}
+                                ;	   (gen/sleep 3)
+                                ;	      {:type :info, :f :resumed}
+                                                  ;        (gen/sleep 4)
+                                                  ;           {:type :info, :f :stop}
+                                ;	  ]))
+                                )
+                                (gen/time-limit (:time-limit opts)))}
+          opts))
 
 (defn -main
   "Handles command line arguments. Can either run a test, or a web server for

  [conn]
  (reify client/Client
    (setup! [_ test node]
      ;(client (wcar* (car/flushall))
      (client (wcar* (car/set "start" ""))
    ))

    (invoke! [this test op]
      (let [[k v] (:value op)

  [s]
  (when s (Long/parseLong s)))

(def server1-conn {:pool {:max-total 8} :spec {:host "n9" :port 6379 :timeout-ms 3000}})	;time out shreshold for the client connection or read ops
(defmacro wcar* [& body] `(car/wcar server1-conn ~@body))

(defn client
