From 39058432570246a4c7d4cbe2e3575cfb0d30f678 Mon Sep 17 00:00:00 2001
From: Brian O'Connor <bocon13@gmail.com>
Date: Mon, 9 Sep 2013 19:21:56 -0700
Subject: [PATCH 01/30] accept command line args in baresshd.py

---
 examples/baresshd.py | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/examples/baresshd.py b/examples/baresshd.py
index a714edb..081a812 100755
--- a/examples/baresshd.py
+++ b/examples/baresshd.py
@@ -2,6 +2,7 @@
 
 "This example doesn't use OpenFlow, but attempts to run sshd in a namespace."
 
+import sys
 from mininet.node import Host
 from mininet.util import ensureRoot
 
@@ -27,6 +28,10 @@ f.write( 'Welcome to %s at %s\n' % ( h1.name, h1.IP() ) )
 f.close()
 
 print "*** Running sshd"
-h1.cmd( '/usr/sbin/sshd -o "Banner /tmp/%s.banner"' % h1.name )
+cmd = '/usr/sbin/sshd -o "Banner /tmp/%s.banner"' % h1.name
+# add arguments from the command line
+if len( sys.argv ) > 1:
+    cmd += ' ' + ' '.join( sys.argv[ 1: ] )
+h1.cmd( cmd )
 
 print "*** You may now ssh into", h1.name, "at", h1.IP()

From cfb6bf95a367d4984d101bc3a6c98bab96374db1 Mon Sep 17 00:00:00 2001
From: Brian O'Connor <bocon13@gmail.com>
Date: Mon, 9 Sep 2013 19:22:41 -0700
Subject: [PATCH 02/30] adding commandline args to UserSwitch in controlnet,
 examples of partial

---
 examples/controlnet.py | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/examples/controlnet.py b/examples/controlnet.py
index f9454c7..d5a8781 100755
--- a/examples/controlnet.py
+++ b/examples/controlnet.py
@@ -14,6 +14,8 @@ We also use a Mininet Facade to talk to both the
 control and data networks from a single CLI.
 """
 
+from functools import partial
+
 from mininet.net import Mininet
 from mininet.node import Controller, UserSwitch
 from mininet.cli import CLI
@@ -124,7 +126,8 @@ def run():
     info( '* Creating Data Network\n' )
     topo = TreeTopo( depth=2, fanout=2 )
     # UserSwitch so we can easily test failover
-    net = Mininet( topo=topo, switch=UserSwitch, controller=None )
+    sw = partial( UserSwitch, opts='--inactivity-probe=1 --max-backoff=1' )
+    net = Mininet( topo=topo, switch=sw, controller=None )
     info( '* Adding Controllers to Data Network\n' )
     for host in cnet.hosts:
         if isinstance(host, Controller):

From 220376b6e214e11ef8aa2cd98e9f4ebf22057ebc Mon Sep 17 00:00:00 2001
From: Brian O'Connor <bocon13@gmail.com>
Date: Mon, 9 Sep 2013 19:23:14 -0700
Subject: [PATCH 03/30] hwintf.py: allow intf to be specified in cmd line

---
 examples/hwintf.py | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/examples/hwintf.py b/examples/hwintf.py
index e5960d9..1e010fd 100755
--- a/examples/hwintf.py
+++ b/examples/hwintf.py
@@ -5,7 +5,7 @@ This example shows how to add an interface (for example a real
 hardware interface) to a network after the network is created.
 """
 
-import re
+import re, sys
 
 from mininet.cli import CLI
 from mininet.log import setLogLevel, info, error
@@ -28,7 +28,10 @@ def checkIntf( intf ):
 if __name__ == '__main__':
     setLogLevel( 'info' )
 
-    intfName = 'eth1'
+    # try to get hw intf from the command line; by default, use eth1
+    intfName = sys.argv[ 1 ] if len( sys.argv ) > 1 else 'eth1'
+    info( '*** Connecting to hw intf: %s' % intfName )
+
     info( '*** Checking', intfName, '\n' )
     checkIntf( intfName )
 

From b605cf74d287126857cd10803b444efaba8c1532 Mon Sep 17 00:00:00 2001
From: Brian O'Connor <bocon13@gmail.com>
Date: Mon, 9 Sep 2013 19:24:11 -0700
Subject: [PATCH 04/30] style in multitest

---
 examples/multitest.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/examples/multitest.py b/examples/multitest.py
index bcb40f7..b50acb2 100755
--- a/examples/multitest.py
+++ b/examples/multitest.py
@@ -22,7 +22,7 @@ if __name__ == '__main__':
     info( "*** Initializing Mininet and kernel modules\n" )
     OVSKernelSwitch.setup()
     info( "*** Creating network\n" )
-    network = Mininet( TreeTopo( depth=2, fanout=2 ), switch=OVSKernelSwitch)
+    network = Mininet( TreeTopo( depth=2, fanout=2 ), switch=OVSKernelSwitch )
     info( "*** Starting network\n" )
     network.start()
     info( "*** Running ping test\n" )

From 9a73dcad535845519ae0fb6c8ce0f69cb394c751 Mon Sep 17 00:00:00 2001
From: Brian O'Connor <bocon13@gmail.com>
Date: Mon, 9 Sep 2013 19:25:18 -0700
Subject: [PATCH 05/30] fixed print format in popenpoll

---
 examples/popenpoll.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/examples/popenpoll.py b/examples/popenpoll.py
index c581c27..33478ae 100755
--- a/examples/popenpoll.py
+++ b/examples/popenpoll.py
@@ -23,7 +23,7 @@ def pmonitorTest( N=3, seconds=10 ):
     endTime = time() + seconds
     for h, line in pmonitor( popens, timeoutms=500 ):
         if h:
-            print '%s: %s' % ( h.name, line ),
+            print '<%s>: %s' % ( h.name, line ),
         if time() >= endTime:
             for p in popens.values():
                 p.send_signal( SIGINT )

From 5a646a0d20c50d61d942c63745cc2b844c5135a2 Mon Sep 17 00:00:00 2001
From: Brian O'Connor <bocon13@gmail.com>
Date: Mon, 9 Sep 2013 19:27:02 -0700
Subject: [PATCH 06/30] sshd.py: allow sshd args to be passed via commandline

---
 examples/sshd.py | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/examples/sshd.py b/examples/sshd.py
index 2bedb9c..3c94359 100755
--- a/examples/sshd.py
+++ b/examples/sshd.py
@@ -16,6 +16,8 @@ demonstrates:
 - running server processes (sshd in this case) on hosts
 """
 
+import sys
+
 from mininet.net import Mininet
 from mininet.cli import CLI
 from mininet.log import lg
@@ -68,4 +70,6 @@ def sshd( network, cmd='/usr/sbin/sshd', opts='-D' ):
 if __name__ == '__main__':
     lg.setLogLevel( 'info')
     net = TreeNet( depth=1, fanout=4, switch=OVSKernelSwitch )
-    sshd( net )
+    # get sshd args from the command line; default: -D
+    opts = ' '.join( sys.argv[ 1: ] ) if len( sys.argv ) > 1 else '-D'
+    sshd( net, opts=opts )

From a46fae06872ef756f70d8f4a9e131c6b9e8c3264 Mon Sep 17 00:00:00 2001
From: Brian O'Connor <bocon13@gmail.com>
Date: Mon, 9 Sep 2013 19:28:12 -0700
Subject: [PATCH 07/30] adding first draft of tests for all examples, they need
 comments and clean up, some could be made more rebust

---
 examples/test/runner.py               |  10 +++
 examples/test/test_baresshd.py        |  60 ++++++++++++++
 examples/test/test_bind.py            |  59 ++++++++++++++
 examples/test/test_controllers.py     |  55 +++++++++++++
 examples/test/test_controlnet.py      |  51 ++++++++++++
 examples/test/test_cpu.py             |  36 ++++++++
 examples/test/test_emptynet.py        |  39 +++++++++
 examples/test/test_hwintf.py          | 113 ++++++++++++++++++++++++++
 examples/test/test_limit.py           |  38 +++++++++
 examples/test/test_linearbandwidth.py |  48 +++++++++++
 examples/test/test_multiping.py       |  48 +++++++++++
 examples/test/test_multipoll.py       |  40 +++++++++
 examples/test/test_multitest.py       |  32 ++++++++
 examples/test/test_nat.py             |  44 ++++++++++
 examples/test/test_popen.py           |  45 ++++++++++
 examples/test/test_scratchnet.py      |  29 +++++++
 examples/test/test_simpleperf.py      |  37 +++++++++
 examples/test/test_sshd.py            |  57 +++++++++++++
 examples/test/test_tree1024.py        |  37 +++++++++
 examples/test/test_treeping64.py      |  36 ++++++++
 20 files changed, 914 insertions(+)
 create mode 100644 examples/test/runner.py
 create mode 100755 examples/test/test_baresshd.py
 create mode 100755 examples/test/test_bind.py
 create mode 100755 examples/test/test_controllers.py
 create mode 100755 examples/test/test_controlnet.py
 create mode 100755 examples/test/test_cpu.py
 create mode 100755 examples/test/test_emptynet.py
 create mode 100755 examples/test/test_hwintf.py
 create mode 100755 examples/test/test_limit.py
 create mode 100755 examples/test/test_linearbandwidth.py
 create mode 100755 examples/test/test_multiping.py
 create mode 100755 examples/test/test_multipoll.py
 create mode 100755 examples/test/test_multitest.py
 create mode 100755 examples/test/test_nat.py
 create mode 100755 examples/test/test_popen.py
 create mode 100755 examples/test/test_scratchnet.py
 create mode 100755 examples/test/test_simpleperf.py
 create mode 100755 examples/test/test_sshd.py
 create mode 100755 examples/test/test_tree1024.py
 create mode 100755 examples/test/test_treeping64.py

diff --git a/examples/test/runner.py b/examples/test/runner.py
new file mode 100644
index 0000000..dfa2702
--- /dev/null
+++ b/examples/test/runner.py
@@ -0,0 +1,10 @@
+import glob
+import unittest
+
+test_file_strings = glob.glob('test_*.py')
+module_strings = [str[0:len(str)-3] for str in test_file_strings]
+print module_strings
+suites = [unittest.defaultTestLoader.loadTestsFromName(str) for str
+          in module_strings]
+testSuite = unittest.TestSuite(suites)
+text_runner = unittest.TextTestRunner().run(testSuite)
\ No newline at end of file
diff --git a/examples/test/test_baresshd.py b/examples/test/test_baresshd.py
new file mode 100755
index 0000000..d57436e
--- /dev/null
+++ b/examples/test/test_baresshd.py
@@ -0,0 +1,60 @@
+#!/usr/bin/env python
+
+"""TEST"""
+
+import unittest
+import pexpect
+from time import sleep
+from mininet.log import setLogLevel
+from mininet.clean import cleanup, sh
+
+class testBareSSHD( unittest.TestCase ):
+    "Test ping with single switch topology (common code)."
+
+    opts = [ '\(yes/no\)\?', 'Welcome to h1', 'refused', pexpect.EOF, pexpect.TIMEOUT ]
+
+    def connected( self ):
+        "check connected"
+        p = pexpect.spawn( 'ssh 10.0.0.1 -i /tmp/ssh/test_rsa ' )
+        while True:
+            index = p.expect( self.opts )
+            if index == 0:
+                p.sendline( 'yes' )
+            elif index == 1:
+                return True
+            else:
+                return False
+
+    def setUp( self ):
+        self.assertFalse( self.connected() )
+        # create public key pair for testing
+        sh( 'mkdir /tmp/ssh' )
+        sh( "ssh-keygen -t rsa -P '' -f /tmp/ssh/test_rsa" )
+        sh( 'cat /tmp/ssh/test_rsa.pub >> /tmp/ssh/authorized_keys' )
+        cmd = ( 'python -m mininet.examples.baresshd '
+                '-o AuthorizedKeysFile=/tmp/ssh/authorized_keys '
+                '-o StrictModes=no' )
+        sh( cmd )
+
+    def testSSH( self ):
+        result = False
+        # try to connect up to 3 times
+        for _ in range( 3 ):
+            result = self.connected()
+            if result:
+                break
+            else:
+                sleep( 1 )
+        self.assertTrue( result )
+
+    def tearDown( self ):
+        # kill the ssh process
+        sh( "ps aux | grep 'ssh.*Banner' | awk '{ print $2 }' | xargs kill" )
+        cleanup()
+        # remove public key pair
+        sh( 'rm -rf /tmp/ssh' )
+
+
+if __name__ == '__main__':
+    setLogLevel( 'warning' )
+    unittest.main()
diff --git a/examples/test/test_bind.py b/examples/test/test_bind.py
new file mode 100755
index 0000000..cc27ca9
--- /dev/null
+++ b/examples/test/test_bind.py
@@ -0,0 +1,59 @@
+#!/usr/bin/env python
+
+"""TEST"""
+
+import unittest
+import pexpect
+from time import sleep
+from mininet.log import setLogLevel
+from mininet.clean import cleanup, sh
+
+class testBind( unittest.TestCase ):
+    "Test ping with single switch topology (common code)."
+
+    prompt = 'mininet>'
+
+    def connected( self, ip ):
+        "check connected"
+        p = pexpect.spawn( 'ssh -i /tmp/ssh/test_rsa %s' % ip )
+        while True:
+            index = p.expect( self.opts )
+            if index == 0:
+                print p.match.group(0)
+                p.sendline( 'yes' )
+            elif index == 1:
+                return False
+            elif index == 2:
+                p.sendline( 'exit' )
+                p.wait()    
+                return True
+            else:
+                return False
+
+    def setUp( self ):
+        self.net = pexpect.spawn( 'python -m mininet.examples.bind' )
+        self.net.expect( "Private Directories: \[([\w\s,'/]+)\]" )
+        self.directories = []
+        # parse directories from mn output
+        for d in self.net.match.group(1).split(', '):
+            self.directories.append( d.strip("'") )
+        self.net.expect( self.prompt )
+        self.assertTrue( len( self.directories ) > 0 )
+
+    def testCreateFile( self ):
+        fileName = 'a.txt'
+        directory = self.directories[ 0 ]
+        self.net.sendline( 'h1 touch %s/%s; ls %s' % ( directory, fileName, directory ) )
+        index = self.net.expect( [ fileName, self.prompt ] )
+        self.assertTrue( index == 0 )
+
+    # TODO: need more tests
+
+    def tearDown( self ):
+        self.net.sendline( 'exit' )
+        self.net.wait()
+
+if __name__ == '__main__':
+    setLogLevel( 'warning' )
+    unittest.main()
+
diff --git a/examples/test/test_controllers.py b/examples/test/test_controllers.py
new file mode 100755
index 0000000..e178db5
--- /dev/null
+++ b/examples/test/test_controllers.py
@@ -0,0 +1,55 @@
+#!/usr/bin/env python
+
+"""TEST"""
+
+import unittest
+import pexpect
+#from time import sleep
+from mininet.log import setLogLevel
+#from mininet.net import Mininet
+#from mininet.node import CPULimitedHost
+#from mininet.link import TCLink
+
+#from mininet.examples.simpleperf import SingleSwitchTopo
+
+class testControllers( unittest.TestCase ):
+    "Test ping with single switch topology (common code)."
+
+    prompt = 'mininet>'
+
+    def connectedTest( self, name, cmap ):
+        p = pexpect.spawn( 'python -m %s' % name )
+        p.expect( self.prompt )
+        p.sendline( 'pingall' )
+        p.expect ( '(\d+)% dropped' )
+        percent = int( p.match.group( 1 ) ) if p.match else -1
+        self.assertEqual( percent, 0 ) # or this
+        p.expect( self.prompt )
+        for switch in cmap:
+            p.sendline( 'sh ovs-vsctl get-controller %s' % switch )
+            p.expect( 'tcp:([\d.:]+)')
+            actual = p.match.group(1)
+            expected = cmap[ switch ]
+            self.assertEqual( actual, expected)
+        p.expect( self.prompt )
+        p.sendline( 'exit' )
+        p.wait()
+        #TODO remove this
+        self.assertEqual( percent, 0 )
+
+    def testControllers( self ):
+        c0 = '127.0.0.1:6633'
+        c1 = '127.0.0.1:6634'
+        cmap = { 's1': c0, 's2': c1, 's3': c0 }
+        self.connectedTest( 'mininet.examples.controllers', cmap )
+
+    def testControllers2( self ):
+        c0 = '127.0.0.1:6633'
+        c1 = '127.0.0.1:6634'
+        cmap = { 's1': c0, 's2': c1 }
+        self.connectedTest( 'mininet.examples.controllers2', cmap )
+
+
+if __name__ == '__main__':
+    setLogLevel( 'warning' )
+    unittest.main()
diff --git a/examples/test/test_controlnet.py b/examples/test/test_controlnet.py
new file mode 100755
index 0000000..73ffa3e
--- /dev/null
+++ b/examples/test/test_controlnet.py
@@ -0,0 +1,51 @@
+#!/usr/bin/env python
+
+"""TEST"""
+
+import unittest
+import pexpect
+from mininet.log import setLogLevel
+#from mininet.net import Mininet
+#from mininet.node import CPULimitedHost
+#from mininet.link import TCLink
+
+#from mininet.examples.simpleperf import SingleSwitchTopo
+
+class testControlNet( unittest.TestCase ):
+    "Test ping with single switch topology (common code)."
+
+    prompt = 'mininet>'
+
+    def testPingall( self ):
+        p = pexpect.spawn( 'python -m mininet.examples.controlnet' )
+        p.expect( self.prompt )
+        p.sendline( 'pingall' )
+        p.expect ( '(\d+)% dropped' )
+        percent = int( p.match.group( 1 ) ) if p.match else -1
+        self.assertEqual( percent, 0 )
+        p.expect( self.prompt )
+        p.sendline( 'exit' )
+        p.wait()
+
+    def testFailover( self ):
+        count = 1
+        p = pexpect.spawn( 'python -m mininet.examples.controlnet' )
+        p.expect( self.prompt )
+        lp = pexpect.spawn( 'tail -f /tmp/s1-ofp.log' )
+        lp.expect( 'tcp:\d+\.\d+\.\d+\.(\d+):\d+: connected' )
+        ip = int( lp.match.group( 1 ) )
+        self.assertEqual( count, ip )
+        count += 1
+        for c in [ 'c0', 'c1' ]:
+            p.sendline( '%s ifconfig %s-eth0 down' % ( c, c) )
+            p.expect( self.prompt )
+            lp.expect( 'tcp:\d+\.\d+\.\d+\.(\d+):\d+: connected' )
+            ip = int( lp.match.group( 1 ) )
+            self.assertEqual( count, ip )
+            count += 1
+        p.sendline( 'exit' )
+        p.wait()
+
+if __name__ == '__main__':
+    setLogLevel( 'warning' )
+    unittest.main()
diff --git a/examples/test/test_cpu.py b/examples/test/test_cpu.py
new file mode 100755
index 0000000..a0598cf
--- /dev/null
+++ b/examples/test/test_cpu.py
@@ -0,0 +1,36 @@
+#!/usr/bin/env python
+
+"""TEST"""
+
+import unittest
+import pexpect
+from mininet.log import setLogLevel
+
+class testCPU( unittest.TestCase ):
+    "Test ping with single switch topology (common code)."
+
+    prompt = 'mininet>'
+
+    def testCPU( self ):
+        opts = [ '([a-z]+)\t([\d\.]+)%\t([\d\.]+)', pexpect.EOF ]
+        p = pexpect.spawn( 'python -m mininet.examples.cpu' )
+        scheds = []
+        while True:
+            index = p.expect( opts, timeout=600 )
+            if index == 0:
+                sched = p.match.group( 1 ) 
+                cpu = float( p.match.group( 2 ) )
+                bw = float( p.match.group( 3 ) )
+                if sched not in scheds:
+                    scheds.append( sched )
+                    previous_bw = 10 ** 4 # 10 GB/s
+                self.assertTrue( bw < previous_bw )
+                previous_bw = bw
+            else:
+                break
+
+        self.assertTrue( len( scheds ) > 0 )
+
+if __name__ == '__main__':
+    setLogLevel( 'warning' )
+    unittest.main()
diff --git a/examples/test/test_emptynet.py b/examples/test/test_emptynet.py
new file mode 100755
index 0000000..c571ecb
--- /dev/null
+++ b/examples/test/test_emptynet.py
@@ -0,0 +1,39 @@
+#!/usr/bin/env python
+
+"""TEST"""
+
+import unittest
+import pexpect
+#from time import sleep
+from mininet.log import setLogLevel
+#from mininet.net import Mininet
+#from mininet.node import CPULimitedHost
+#from mininet.link import TCLink
+
+#from mininet.examples.simpleperf import SingleSwitchTopo
+
+class testEmptyNet( unittest.TestCase ):
+    "Test ping with single switch topology (common code)."
+
+    prompt = 'mininet>'
+
+    def testEmptyNet( self ):
+        p = pexpect.spawn( 'python -m mininet.examples.emptynet' )
+        p.expect( self.prompt )
+        p.sendline( 'pingall' )
+        p.expect ( '(\d+)% dropped' )
+        percent = int( p.match.group( 1 ) ) if p.match else -1
+        self.assertEqual( percent, 0 ) # or this
+        p.expect( self.prompt )
+        p.sendline( 'iperf' )
+        p.expect( "Results: \['[\d.]+ .bits/sec', '[\d.]+ .bits/sec'\]" )
+        #TODO check the results? maybe we dont care
+        p.expect( self.prompt )
+        p.sendline( 'exit' )
+        p.wait()
+        #TODO remove this
+        self.assertEqual( percent, 0 )
+
+if __name__ == '__main__':
+    setLogLevel( 'warning' )
+    unittest.main()
diff --git a/examples/test/test_hwintf.py b/examples/test/test_hwintf.py
new file mode 100755
index 0000000..ec0ffdd
--- /dev/null
+++ b/examples/test/test_hwintf.py
@@ -0,0 +1,113 @@
+#!/usr/bin/env python
+
+"""TEST"""
+
+import unittest
+import pexpect
+import re
+from time import sleep
+from mininet.log import setLogLevel
+from mininet.net import Mininet
+from mininet.node import Node
+from mininet.link import Link, Intf
+
+class testHwintf( unittest.TestCase ):
+    "Test ping with single switch topology (common code)."
+
+    prompt = 'mininet>'
+
+    def _testE2E( self ):
+        results = [ "Results:", pexpect.EOF, pexpect.TIMEOUT ]
+        p = pexpect.spawn( 'python -m mininet.examples.simpleperf' )
+        index = p.expect( results, timeout=600 )
+        self.assertEqual( index, 0 )
+        p.wait()
+
+    def setUp( self ):
+        self.h3 = Node( 't0', ip='10.0.0.3/8' )
+        self.n0 = Node( 't1', inNamespace=False)
+        Link( self.h3, self.n0 )
+        self.h3.configDefault()
+
+    def testLocalPing( self ):
+        p = pexpect.spawn( 'python -m mininet.examples.hwintf %s' % self.n0.intf() )
+        p.expect( self.prompt )
+        p.sendline( 'pingall' )
+        p.expect ( '(\d+)% dropped' )
+        percent = int( p.match.group( 1 ) ) if p.match else -1
+        self.assertEqual( percent, 0 )
+        p.expect( self.prompt )
+        p.sendline( 'exit' )
+        p.wait()
+
+    def testExternalPing( self ):
+        expectStr = '(\d+) packets transmitted, (\d+) received'
+        p = pexpect.spawn( 'python -m mininet.examples.hwintf %s' % self.n0.intf() )
+        p.expect( self.prompt )
+
+        m = re.search( expectStr, self.h3.cmd( 'ping -v -c 1 10.0.0.1' ) )
+        tx = m.group( 1 )
+        rx = m.group( 2 )
+        self.assertEqual( tx, rx )
+
+        p.sendline( 'h1 ping -c 1 10.0.0.3')
+        p.expect( expectStr )
+        tx = p.match.group( 1 )
+        rx = p.match.group( 2 )
+        self.assertEqual( tx, rx )
+        p.expect( self.prompt )
+        p.sendline( 'exit' )
+        p.wait()
+
+    def tearDown( self ):
+        self.h3.terminate()
+        self.n0.terminate()
+
+
+            
+    ''' TAP garbage 
+     def testHwintf( self ):
+        ifname = 'br3'
+        #sudo ip tuntap add mode tap br0
+        #sudo ip tuntap del mode tap br0
+        #sudo ip link add name test0 type veth peer name test1
+        #sudo ip link del test0
+        t0 = Node( 't0', inNamespace=False, ip='10.0.0.3/8' )
+
+        t1 = Node( 't1', inNamespace=False)
+        #t0.cmd( 'ip tuntap add mode tap %s' % ifname )
+        #Intf( ifname, t0 )
+        print Link( t0, t1 )
+        t0.configDefault()
+
+        print t0.cmd( 'ifconfig' )
+        ifname =  t1.intf()
+
+
+        try:
+            foo = pexpect.spawn( 'wireshark' )
+            p = pexpect.spawn( 'python -m mininet.examples.hwintf %s' % ifname )
+            p.expect( self.prompt )
+            #t0.cmd( 'ip link set dev %s up' % ifname )
+            #t0.cmd( "bash -c 'echo 1 > /proc/sys/net/ipv4/ip_forward'" )
+            #t0.cmd( "bash -c 'echo 1 > /proc/sys/net/ipv4/conf/%s/proxy_arp'" % ifname)
+            #t0.cmd( 'arp -Ds 10.0.0.3 s1 pub' )
+
+            #p.sendline( 'x s1 wireshark' )
+            print t0.cmd( 'ifconfig %s' % ifname )
+            print t0.cmd( 'ip route' )
+            print t0.cmd( 'ping -v -c 1 10.0.0.3' )
+            print t0.cmd( 'ping -v -c 1 10.0.0.1' )
+
+            p.interact()
+            #p.wait()
+        finally:
+            #t0.cmd( 'ip tuntap del mode tap %s' % ifname )
+            t0.terminate()
+            t1.terminate()
+        #t0.configDefault()
+    '''
+
+if __name__ == '__main__':
+    setLogLevel( 'warning' )
+    unittest.main()
diff --git a/examples/test/test_limit.py b/examples/test/test_limit.py
new file mode 100755
index 0000000..2629d1f
--- /dev/null
+++ b/examples/test/test_limit.py
@@ -0,0 +1,38 @@
+#!/usr/bin/env python
+
+"""TEST"""
+
+import unittest
+import pexpect
+from mininet.log import setLogLevel
+
+class testLimit( unittest.TestCase ):
+    "Test ping with single switch topology (common code)."
+
+    def testLimit( self ):
+        opts = [ '\*\*\* Testing network ([\d\.]+) Mbps', 
+                 '\*\*\* Results: \[([\d\., ]+)\]', 
+                 pexpect.EOF ]
+        p = pexpect.spawn( 'python -m mininet.examples.limit' )
+        count = 0
+        bw = 0
+        tolerance = 1
+        while True:
+            index = p.expect( opts )
+            if index == 0:
+                bw = float( p.match.group( 1 ) )
+                count += 1
+            elif index == 1:
+                results = p.match.group( 1 )
+                for x in results.split(','):
+                    result = float( x )
+                    self.assertTrue( result < bw + tolerance )
+                    self.assertTrue( result > bw - tolerance)
+            else:
+                break
+
+        self.assertTrue( count > 0 )
+
+if __name__ == '__main__':
+    setLogLevel( 'warning' )
+    unittest.main()
diff --git a/examples/test/test_linearbandwidth.py b/examples/test/test_linearbandwidth.py
new file mode 100755
index 0000000..2a01edc
--- /dev/null
+++ b/examples/test/test_linearbandwidth.py
@@ -0,0 +1,48 @@
+#!/usr/bin/env python
+
+"""TEST"""
+
+import unittest
+import pexpect
+from mininet.log import setLogLevel
+#from mininet.net import Mininet
+#from mininet.node import CPULimitedHost
+#from mininet.link import TCLink
+
+#from mininet.examples.simpleperf import SingleSwitchTopo
+
+class testLinearBandwidth( unittest.TestCase ):
+    "Test ping with single switch topology (common code)."
+
+    prompt = 'mininet>'
+
+    def testLinearBandwidth( self ):
+        count = 0
+        tolerance = 0.5
+        opts = [ '\*\*\* Linear network results', '(\d+)\s+([\d\.]+) (.bits)', pexpect.EOF ]
+        p = pexpect.spawn( 'python -m mininet.examples.linearbandwidth' )
+        while True:
+            index = p.expect( opts, timeout=600 )
+            if index == 0:
+                previous_bw = 10 ** 10 # 10 Gbits
+                count += 1
+            elif index == 1:
+                n = int( p.match.group( 1 ) )
+                bw = float( p.match.group( 2 ) )
+                unit = p.match.group( 3 )
+                if unit[ 0 ] == 'K':
+                    bw *= 10 ** 3
+                elif unit[ 0 ] == 'M':
+                    bw *= 10 ** 6
+                elif unit[ 0 ] == 'G':
+                    bw *= 10 ** 9
+                self.assertTrue( bw < previous_bw )
+                previous_bw = bw
+            else:
+                break
+
+        self.assertTrue( count > 0 )
+
+if __name__ == '__main__':
+    setLogLevel( 'warning' )
+    unittest.main()
diff --git a/examples/test/test_multiping.py b/examples/test/test_multiping.py
new file mode 100755
index 0000000..1bd9f94
--- /dev/null
+++ b/examples/test/test_multiping.py
@@ -0,0 +1,48 @@
+#!/usr/bin/env python
+
+"""TEST"""
+
+import unittest
+import pexpect
+from collections import defaultdict
+from mininet.log import setLogLevel
+
+class testMultiPing( unittest.TestCase ):
+    "Test ping with single switch topology (common code)."
+
+    def testMultiPing( self ):
+        p = pexpect.spawn( 'python -m mininet.examples.multiping' )
+        opts = []
+        opts.append( "Host (h\d+) \(([\d.]+)\) will be pinging ips: ([\d. ]+)" )
+        opts.append( "(h\d+): ([\d.]+) -> ([\d.]+) \d packets transmitted, (\d) received" )
+        opts.append( pexpect.EOF )
+        pings = defaultdict( list )
+        while True:
+            index = p.expect( opts )
+            if index == 0:
+                name = p.match.group(1)
+                ip = p.match.group(2)
+                targets = p.match.group(3).split()
+                pings[ name ] += targets
+            elif index == 1:
+                name = p.match.group(1)
+                ip = p.match.group(2)
+                target = p.match.group(3)
+                received = int( p.match.group(4) )
+                if target == '10.0.0.200':
+                    self.assertEqual( received, 0 )
+                else:
+                    self.assertEqual( received, 1 )
+                try:
+                    pings[ name ].remove( target )
+                except:
+                    pass
+            else:
+                break
+        self.assertTrue( len(pings) > 0 )
+        for t in pings.values():
+            self.assertEqual( len( t ), 0 )
+
+if __name__ == '__main__':
+    setLogLevel( 'warning' )
+    unittest.main()
diff --git a/examples/test/test_multipoll.py b/examples/test/test_multipoll.py
new file mode 100755
index 0000000..5c13f34
--- /dev/null
+++ b/examples/test/test_multipoll.py
@@ -0,0 +1,40 @@
+#!/usr/bin/env python
+
+"""TEST"""
+
+import unittest
+import pexpect
+from collections import defaultdict
+from mininet.log import setLogLevel
+
+class testMultiPoll( unittest.TestCase ):
+    "Test ping with single switch topology (common code)."
+
+    def testMultiPoll( self ):
+        p = pexpect.spawn( 'python -m mininet.examples.multipoll' )
+        opts = []
+        opts.append( "\*\*\* (h\d) :" )
+        opts.append( "(h\d+): \d+ bytes from" )
+        opts.append( "Monitoring output for (\d+) seconds" )
+        opts.append( pexpect.EOF )
+        pings = {}
+        while True:
+            index = p.expect( opts )
+            if index == 0:
+                name = p.match.group( 1 )
+                pings[ name ] = 0
+            elif index == 1:
+                name = p.match.group( 1 )
+                pings[ name ] += 1
+            elif index == 2:
+                seconds = int( p.match.group( 1 ) )
+            else:
+                break
+        self.assertTrue( len(pings) > 0 )
+        # make sure we have received at least one ping per second
+        for count in pings.values():
+            self.assertTrue( count >= seconds )
+
+if __name__ == '__main__':
+    setLogLevel( 'warning' )
+    unittest.main()
diff --git a/examples/test/test_multitest.py b/examples/test/test_multitest.py
new file mode 100755
index 0000000..80887ef
--- /dev/null
+++ b/examples/test/test_multitest.py
@@ -0,0 +1,32 @@
+#!/usr/bin/env python
+
+"""TEST"""
+
+import unittest
+import pexpect
+from mininet.log import setLogLevel
+
+class testMultiTest( unittest.TestCase ):
+    "Test ping with single switch topology (common code)."
+
+    prompt = 'mininet>'
+
+    def testMultiTest( self ):
+        p = pexpect.spawn( 'python -m mininet.examples.multitest' )
+        p.expect( '(\d+)% dropped' )
+        dropped = int( p.match.group(1) )
+        self.assertEqual( dropped, 0 )
+        ifCount = 0
+        while True:
+            index = p.expect( [ 'h\d-eth0', self.prompt ] )
+            if index == 0:
+                ifCount += 1
+            elif index == 1:
+                p.sendline( 'exit' )
+                break
+        p.wait()
+        self.assertEqual( ifCount, 4 )
+
+if __name__ == '__main__':
+    setLogLevel( 'warning' )
+    unittest.main()
diff --git a/examples/test/test_nat.py b/examples/test/test_nat.py
new file mode 100755
index 0000000..8e2e8a2
--- /dev/null
+++ b/examples/test/test_nat.py
@@ -0,0 +1,44 @@
+#!/usr/bin/env python
+
+"""TEST"""
+
+import unittest
+import pexpect
+#from time import sleep
+from mininet.log import setLogLevel
+#from mininet.net import Mininet
+#from mininet.node import CPULimitedHost
+#from mininet.link import TCLink
+
+#from mininet.examples.simpleperf import SingleSwitchTopo
+
+class testNAT( unittest.TestCase ):
+    "Test ping with single switch topology (common code)."
+
+    prompt = 'mininet>'
+
+    # skip if 8.8.8.8 unreachable
+    def testNAT( self ):
+        p = pexpect.spawn( 'python -m mininet.examples.nat' )
+        p.expect( self.prompt )
+        p.sendline( 'h1 ping -c 1 8.8.8.8' )
+        p.expect ( '(\d+)% packet loss' )
+        percent = int( p.match.group( 1 ) ) if p.match else -1
+        p.expect( self.prompt )
+        p.sendline( 'exit' )
+        p.wait()
+        self.assertEqual( percent, 0 )
+    '''
+    def testTopo( self ):
+        topo = SingleSwitchTopo(n=4)
+        net = Mininet(topo=topo,
+                  host=CPULimitedHost, link=TCLink)
+        net.start()
+        h1, h4 = net.get('h1', 'h4')
+        h1.cmd( 'ping -c 1 %s' % h4.IP() )
+        net.stop()
+    '''
+
+if __name__ == '__main__':
+    setLogLevel( 'warning' )
+    unittest.main()
diff --git a/examples/test/test_popen.py b/examples/test/test_popen.py
new file mode 100755
index 0000000..f9b8ab3
--- /dev/null
+++ b/examples/test/test_popen.py
@@ -0,0 +1,45 @@
+#!/usr/bin/env python
+
+"""TEST"""
+
+import unittest
+import pexpect
+from collections import defaultdict
+from mininet.log import setLogLevel
+
+class testPopen( unittest.TestCase ):
+    "Test ping with single switch topology (common code)."
+
+    def pingTest( self, name ):
+        p = pexpect.spawn( 'python -m %s' % name )
+        opts = []
+        opts.append( "<(h\d+)>: PING " )
+        opts.append( "<(h\d+)>: (\d+) packets transmitted, (\d+) received" )
+        opts.append( pexpect.EOF )
+        pings = {}
+        while True:
+            index = p.expect( opts )
+            if index == 0:
+                name = p.match.group(1)
+                pings[ name ] = 0
+            elif index == 1:
+                name = p.match.group(1)
+                transmitted = p.match.group(2)
+                received = p.match.group(3)
+                self.assertEqual( received, transmitted )
+                pings[ name ] += 1
+            else:
+                break
+        self.assertTrue( len(pings) > 0 )
+        for count in pings.values():
+            self.assertEqual( count, 1 )
+
+    def testPopen( self ):
+        self.pingTest( 'mininet.examples.popen' )
+
+    def testPopenPoll( self ):
+        self.pingTest( 'mininet.examples.popenpoll')
+
+if __name__ == '__main__':
+    setLogLevel( 'warning' )
+    unittest.main()
diff --git a/examples/test/test_scratchnet.py b/examples/test/test_scratchnet.py
new file mode 100755
index 0000000..941aaba
--- /dev/null
+++ b/examples/test/test_scratchnet.py
@@ -0,0 +1,29 @@
+#!/usr/bin/env python
+
+"""TEST"""
+
+import unittest
+import pexpect
+from mininet.log import setLogLevel
+
+class testScratchNet( unittest.TestCase ):
+    "Test ping with single switch topology (common code)."
+
+    results = [ "1 packets transmitted, 1 received, 0% packet loss", pexpect.EOF ]
+
+    def pingTest( self, name ):
+        p = pexpect.spawn( 'python -m %s' % name )
+        index = p.expect( self.results )
+        self.assertEqual( index, 0 )
+
+
+    def testPingKernel( self ):
+        self.pingTest( 'mininet.examples.scratchnet' )
+
+
+    def testPingUser( self ):
+        self.pingTest( 'mininet.examples.scratchnetuser' )
+
+if __name__ == '__main__':
+    setLogLevel( 'warning' )
+    unittest.main()
diff --git a/examples/test/test_simpleperf.py b/examples/test/test_simpleperf.py
new file mode 100755
index 0000000..2e589d7
--- /dev/null
+++ b/examples/test/test_simpleperf.py
@@ -0,0 +1,37 @@
+#!/usr/bin/env python
+
+"""TEST"""
+
+import unittest
+import pexpect
+from time import sleep
+from mininet.log import setLogLevel
+from mininet.net import Mininet
+from mininet.node import CPULimitedHost
+from mininet.link import TCLink
+
+from mininet.examples.simpleperf import SingleSwitchTopo
+
+class testSimplePerf( unittest.TestCase ):
+    "Test ping with single switch topology (common code)."
+
+
+    def testE2E( self ):
+        results = [ "Results:", pexpect.EOF, pexpect.TIMEOUT ]
+        p = pexpect.spawn( 'python -m mininet.examples.simpleperf' )
+        index = p.expect( results, timeout=600 )
+        self.assertEqual( index, 0 )
+        p.wait()
+
+    def testTopo( self ):
+        topo = SingleSwitchTopo(n=4)
+        net = Mininet(topo=topo,
+                  host=CPULimitedHost, link=TCLink)
+        net.start()
+        h1, h4 = net.get('h1', 'h4')
+        h1.cmd( 'ping -c 1 %s' % h4.IP() )
+        net.stop()
+
+if __name__ == '__main__':
+    setLogLevel( 'warning' )
+    unittest.main()
diff --git a/examples/test/test_sshd.py b/examples/test/test_sshd.py
new file mode 100755
index 0000000..35fd632
--- /dev/null
+++ b/examples/test/test_sshd.py
@@ -0,0 +1,57 @@
+#!/usr/bin/env python
+
+"""TEST"""
+
+import unittest
+import pexpect
+from time import sleep
+from mininet.log import setLogLevel
+from mininet.clean import cleanup, sh
+
+class testBareSSHD( unittest.TestCase ):
+    "Test ping with single switch topology (common code)."
+
+    opts = [ '\(yes/no\)\?', 'refused', 'Welcome', pexpect.EOF, pexpect.TIMEOUT ]
+
+    def connected( self, ip ):
+        "check connected"
+        p = pexpect.spawn( 'ssh -i /tmp/ssh/test_rsa %s' % ip )
+        while True:
+            index = p.expect( self.opts )
+            if index == 0:
+                print p.match.group(0)
+                p.sendline( 'yes' )
+            elif index == 1:
+                return False
+            elif index == 2:
+                p.sendline( 'exit' )
+                p.wait()    
+                return True
+            else:
+                return False
+
+    def setUp( self ):
+        # create public key pair for testing
+        sh( 'mkdir /tmp/ssh' )
+        sh( "ssh-keygen -t rsa -P '' -f /tmp/ssh/test_rsa" )
+        sh( 'cat /tmp/ssh/test_rsa.pub >> /tmp/ssh/authorized_keys' )
+        cmd = ( 'python -m mininet.examples.sshd -D '
+                '-o AuthorizedKeysFile=/tmp/ssh/authorized_keys '
+                '-o StrictModes=no' )
+        self.net = pexpect.spawn( cmd )
+        self.net.expect( 'mininet>' )
+
+    def testSSH( self ):
+        for h in range( 1, 5 ):
+            self.assertTrue( self.connected( '10.0.0.%d' % h ) )
+
+    def tearDown( self ):
+        self.net.sendline( 'exit' )
+        self.net.wait()
+        # remove public key pair
+        sh( 'rm -rf /tmp/ssh' )
+
+if __name__ == '__main__':
+    setLogLevel( 'warning' )
+    unittest.main()
+
diff --git a/examples/test/test_tree1024.py b/examples/test/test_tree1024.py
new file mode 100755
index 0000000..adacb90
--- /dev/null
+++ b/examples/test/test_tree1024.py
@@ -0,0 +1,37 @@
+#!/usr/bin/env python
+
+"""TEST"""
+
+import unittest
+import pexpect
+#from time import sleep
+from mininet.log import setLogLevel
+#from mininet.net import Mininet
+#from mininet.node import CPULimitedHost
+#from mininet.link import TCLink
+
+#from mininet.examples.simpleperf import SingleSwitchTopo
+
+class testTree1024( unittest.TestCase ):
+    "Test ping with single switch topology (common code)."
+
+    prompt = 'mininet>'
+
+    def testTree1024( self ):
+        p = pexpect.spawn( 'python -m mininet.examples.tree1024' )
+        p.expect( self.prompt, timeout=6000 ) # it takes awhile to set up
+        p.sendline( 'h1 ping -c 1 h1024' )
+        p.expect ( '(\d+)% packet loss' )
+        percent = int( p.match.group( 1 ) ) if p.match else -1
+        #self.assertEqual( percent, 0 )
+        #p.expect( self.prompt )
+        #p.sendline( 'iperf' )
+        #p.expect( "Results: \['\d+ .bits/sec', '\d+ .bits/sec'\]" )
+        p.expect( self.prompt )
+        p.sendline( 'exit' )
+        p.wait()
+        self.assertEqual( percent, 0 )
+
+if __name__ == '__main__':
+    setLogLevel( 'warning' )
+    unittest.main()
diff --git a/examples/test/test_treeping64.py b/examples/test/test_treeping64.py
new file mode 100755
index 0000000..8328c35
--- /dev/null
+++ b/examples/test/test_treeping64.py
@@ -0,0 +1,36 @@
+#!/usr/bin/env python
+
+"""TEST"""
+
+import unittest
+import pexpect
+#from time import sleep
+from mininet.log import setLogLevel
+#from mininet.net import Mininet
+#from mininet.node import CPULimitedHost
+#from mininet.link import TCLink
+
+#from mininet.examples.simpleperf import SingleSwitchTopo
+
+class testTreePing64( unittest.TestCase ):
+    "Test ping with single switch topology (common code)."
+
+    prompt = 'mininet>'
+
+    def testTreePing64( self ):
+        p = pexpect.spawn( 'python -m mininet.examples.treeping64' )
+        p.expect( 'Tree network ping results:', timeout=6000 )
+        count = 0
+        while True:
+            index = p.expect( [ '(\d+)% packet loss', pexpect.EOF ] )
+            if index == 0:
+                percent = int( p.match.group( 1 ) ) if p.match else -1
+                self.assertEqual( percent, 0 )
+                count += 1
+            else:
+                break
+        self.assertTrue( count > 0 )
+
+if __name__ == '__main__':
+    setLogLevel( 'warning' )
+    unittest.main()

From 01c0ef001332fb89892cbbde573dca195f3380d3 Mon Sep 17 00:00:00 2001
From: Brian O'Connor <bocon13@gmail.com>
Date: Tue, 10 Sep 2013 14:07:46 -0700
Subject: [PATCH 08/30] added comments to test_baresshd.py

---
 examples/test/test_baresshd.py | 15 +++++++++------
 1 file changed, 9 insertions(+), 6 deletions(-)

diff --git a/examples/test/test_baresshd.py b/examples/test/test_baresshd.py
index d57436e..cec2c81 100755
--- a/examples/test/test_baresshd.py
+++ b/examples/test/test_baresshd.py
@@ -1,6 +1,8 @@
 #!/usr/bin/env python
 
-"""TEST"""
+"""
+Tests for baresshd.py
+"""
 
 import unittest
 import pexpect
@@ -9,13 +11,12 @@ from mininet.log import setLogLevel
 from mininet.clean import cleanup, sh
 
 class testBareSSHD( unittest.TestCase ):
-    "Test ping with single switch topology (common code)."
 
     opts = [ '\(yes/no\)\?', 'Welcome to h1', 'refused', pexpect.EOF, pexpect.TIMEOUT ]
 
     def connected( self ):
-        "check connected"
-        p = pexpect.spawn( 'ssh 10.0.0.1 -i /tmp/ssh/test_rsa ' )
+        "Log into ssh server, check banner, then exit"
+        p = pexpect.spawn( 'ssh 10.0.0.1 -i /tmp/ssh/test_rsa exit' )
         while True:
             index = p.expect( self.opts )
             if index == 0:
@@ -26,19 +27,22 @@ class testBareSSHD( unittest.TestCase ):
                 return False
 
     def setUp( self ):
+        # verify that sshd is not running
         self.assertFalse( self.connected() )
         # create public key pair for testing
         sh( 'mkdir /tmp/ssh' )
         sh( "ssh-keygen -t rsa -P '' -f /tmp/ssh/test_rsa" )
         sh( 'cat /tmp/ssh/test_rsa.pub >> /tmp/ssh/authorized_keys' )
+        # run example with custom sshd args
         cmd = ( 'python -m mininet.examples.baresshd '
                 '-o AuthorizedKeysFile=/tmp/ssh/authorized_keys '
                 '-o StrictModes=no' )
         sh( cmd )
 
     def testSSH( self ):
+        "Simple test to verify that we can ssh into h1"
         result = False
-        # try to connect up to 3 times
+        # try to connect up to 3 times; sshd can take a while to start
         for _ in range( 3 ):
             result = self.connected()
             if result:
@@ -54,7 +58,6 @@ class testBareSSHD( unittest.TestCase ):
         # remove public key pair
         sh( 'rm -rf /tmp/ssh' )
 
-
 if __name__ == '__main__':
     setLogLevel( 'warning' )
     unittest.main()

From 43f058df6db7d33f5cb52f35b941e89effff6aab Mon Sep 17 00:00:00 2001
From: Brian O'Connor <bocon13@gmail.com>
Date: Tue, 10 Sep 2013 14:31:15 -0700
Subject: [PATCH 09/30] cleaned up and commented test_bind.py; added one new
 test

---
 examples/test/test_bind.py | 56 ++++++++++++++++++++++----------------
 1 file changed, 32 insertions(+), 24 deletions(-)

diff --git a/examples/test/test_bind.py b/examples/test/test_bind.py
index cc27ca9..d8df0b3 100755
--- a/examples/test/test_bind.py
+++ b/examples/test/test_bind.py
@@ -1,35 +1,16 @@
 #!/usr/bin/env python
 
-"""TEST"""
+"""
+Tests for bind.py
+"""
 
 import unittest
 import pexpect
-from time import sleep
-from mininet.log import setLogLevel
-from mininet.clean import cleanup, sh
 
 class testBind( unittest.TestCase ):
-    "Test ping with single switch topology (common code)."
 
     prompt = 'mininet>'
 
-    def connected( self, ip ):
-        "check connected"
-        p = pexpect.spawn( 'ssh -i /tmp/ssh/test_rsa %s' % ip )
-        while True:
-            index = p.expect( self.opts )
-            if index == 0:
-                print p.match.group(0)
-                p.sendline( 'yes' )
-            elif index == 1:
-                return False
-            elif index == 2:
-                p.sendline( 'exit' )
-                p.wait()    
-                return True
-            else:
-                return False
-
     def setUp( self ):
         self.net = pexpect.spawn( 'python -m mininet.examples.bind' )
         self.net.expect( "Private Directories: \[([\w\s,'/]+)\]" )
@@ -41,11 +22,39 @@ class testBind( unittest.TestCase ):
         self.assertTrue( len( self.directories ) > 0 )
 
     def testCreateFile( self ):
+        "Create a file, a.txt, in the first private directory and verify"
         fileName = 'a.txt'
         directory = self.directories[ 0 ]
-        self.net.sendline( 'h1 touch %s/%s; ls %s' % ( directory, fileName, directory ) )
+        path = directory + '/' + fileName
+        self.net.sendline( 'h1 touch %s; ls %s' % ( path, directory ) )
         index = self.net.expect( [ fileName, self.prompt ] )
         self.assertTrue( index == 0 )
+        self.net.expect( self.prompt )
+        self.net.sendline( 'h1 rm %s' % path )
+        self.net.expect( self.prompt )
+
+    def testIsolation( self ):
+        "Create a file in two hosts and verify that contents are different"
+        fileName = 'b.txt'
+        directory = self.directories[ 0 ]
+        path = directory + '/' + fileName
+        contents = { 'h1' : '1', 'h2' : '2' }
+        # Verify file doesn't exist, then write private copy of file
+        for host in contents:
+            value = contents[ host ]
+            self.net.sendline( '%s cat %s' % ( host, path ) )
+            self.net.expect( 'No such file' )
+            self.net.expect( self.prompt )
+            self.net.sendline( '%s echo %s > %s' % ( host, value, path ) )
+            self.net.expect( self.prompt )
+        # Verify file contents
+        for host in contents:
+            value = contents[ host ]
+            self.net.sendline( '%s cat %s' % ( host, path ) )
+            self.net.expect( value )
+            self.net.expect( self.prompt )
+            self.net.sendline( '%s rm %s' % ( host, path ) )
+            self.net.expect( self.prompt )
 
     # TODO: need more tests
 
@@ -54,6 +63,5 @@ class testBind( unittest.TestCase ):
         self.net.wait()
 
 if __name__ == '__main__':
-    setLogLevel( 'warning' )
     unittest.main()
 

From e875c0de2660f132139c14ebe2a2f5932edf8350 Mon Sep 17 00:00:00 2001
From: Brian O'Connor <bocon13@gmail.com>
Date: Tue, 10 Sep 2013 14:34:50 -0700
Subject: [PATCH 10/30] minor test cleanup

---
 examples/test/test_baresshd.py | 2 --
 examples/test/test_bind.py     | 1 -
 2 files changed, 3 deletions(-)

diff --git a/examples/test/test_baresshd.py b/examples/test/test_baresshd.py
index cec2c81..b76fe20 100755
--- a/examples/test/test_baresshd.py
+++ b/examples/test/test_baresshd.py
@@ -7,7 +7,6 @@ Tests for baresshd.py
 import unittest
 import pexpect
 from time import sleep
-from mininet.log import setLogLevel
 from mininet.clean import cleanup, sh
 
 class testBareSSHD( unittest.TestCase ):
@@ -59,5 +58,4 @@ class testBareSSHD( unittest.TestCase ):
         sh( 'rm -rf /tmp/ssh' )
 
 if __name__ == '__main__':
-    setLogLevel( 'warning' )
     unittest.main()
diff --git a/examples/test/test_bind.py b/examples/test/test_bind.py
index d8df0b3..dcc9fbf 100755
--- a/examples/test/test_bind.py
+++ b/examples/test/test_bind.py
@@ -64,4 +64,3 @@ class testBind( unittest.TestCase ):
 
 if __name__ == '__main__':
     unittest.main()
-

From fba3fd81fa21877aed1eda9ee0e98655d96b404a Mon Sep 17 00:00:00 2001
From: Brian O'Connor <bocon13@gmail.com>
Date: Tue, 10 Sep 2013 14:37:01 -0700
Subject: [PATCH 11/30] cleaned up and commented test_controllers.py

---
 examples/test/test_controllers.py | 23 ++++++++---------------
 1 file changed, 8 insertions(+), 15 deletions(-)

diff --git a/examples/test/test_controllers.py b/examples/test/test_controllers.py
index e178db5..b9b93d9 100755
--- a/examples/test/test_controllers.py
+++ b/examples/test/test_controllers.py
@@ -1,41 +1,36 @@
 #!/usr/bin/env python
 
-"""TEST"""
+"""
+Tests for controllers.py and controllers2.py
+"""
 
 import unittest
 import pexpect
-#from time import sleep
-from mininet.log import setLogLevel
-#from mininet.net import Mininet
-#from mininet.node import CPULimitedHost
-#from mininet.link import TCLink
-
-#from mininet.examples.simpleperf import SingleSwitchTopo
 
 class testControllers( unittest.TestCase ):
-    "Test ping with single switch topology (common code)."
 
     prompt = 'mininet>'
 
     def connectedTest( self, name, cmap ):
+        "Verify that switches are connected to the controller specified by cmap"
         p = pexpect.spawn( 'python -m %s' % name )
         p.expect( self.prompt )
+        # but first a simple ping test
         p.sendline( 'pingall' )
         p.expect ( '(\d+)% dropped' )
         percent = int( p.match.group( 1 ) ) if p.match else -1
-        self.assertEqual( percent, 0 ) # or this
+        self.assertEqual( percent, 0 )
         p.expect( self.prompt )
+        # verify connected controller
         for switch in cmap:
             p.sendline( 'sh ovs-vsctl get-controller %s' % switch )
             p.expect( 'tcp:([\d.:]+)')
             actual = p.match.group(1)
             expected = cmap[ switch ]
-            self.assertEqual( actual, expected)
+            self.assertEqual( actual, expected )
         p.expect( self.prompt )
         p.sendline( 'exit' )
         p.wait()
-        #TODO remove this
-        self.assertEqual( percent, 0 )
 
     def testControllers( self ):
         c0 = '127.0.0.1:6633'
@@ -49,7 +44,5 @@ class testControllers( unittest.TestCase ):
         cmap = { 's1': c0, 's2': c1 }
         self.connectedTest( 'mininet.examples.controllers2', cmap )
 
-
 if __name__ == '__main__':
-    setLogLevel( 'warning' )
     unittest.main()

From b7e506341f94f6e098818c2fa0e127467c55046b Mon Sep 17 00:00:00 2001
From: Brian O'Connor <bocon13@gmail.com>
Date: Tue, 10 Sep 2013 14:45:19 -0700
Subject: [PATCH 12/30] cleaned up and commented test_controlnet.py

---
 examples/test/test_controlnet.py | 14 +++++---------
 1 file changed, 5 insertions(+), 9 deletions(-)

diff --git a/examples/test/test_controlnet.py b/examples/test/test_controlnet.py
index 73ffa3e..91631f2 100755
--- a/examples/test/test_controlnet.py
+++ b/examples/test/test_controlnet.py
@@ -1,22 +1,18 @@
 #!/usr/bin/env python
 
-"""TEST"""
+"""
+Test for controlnet.py
+"""
 
 import unittest
 import pexpect
-from mininet.log import setLogLevel
-#from mininet.net import Mininet
-#from mininet.node import CPULimitedHost
-#from mininet.link import TCLink
-
-#from mininet.examples.simpleperf import SingleSwitchTopo
 
 class testControlNet( unittest.TestCase ):
-    "Test ping with single switch topology (common code)."
 
     prompt = 'mininet>'
 
     def testPingall( self ):
+        "Simple pingall test that verifies 0% packet drop in data network"
         p = pexpect.spawn( 'python -m mininet.examples.controlnet' )
         p.expect( self.prompt )
         p.sendline( 'pingall' )
@@ -28,6 +24,7 @@ class testControlNet( unittest.TestCase ):
         p.wait()
 
     def testFailover( self ):
+        "Kill controllers and verity that switch, s1, fails over properly"
         count = 1
         p = pexpect.spawn( 'python -m mininet.examples.controlnet' )
         p.expect( self.prompt )
@@ -47,5 +44,4 @@ class testControlNet( unittest.TestCase ):
         p.wait()
 
 if __name__ == '__main__':
-    setLogLevel( 'warning' )
     unittest.main()

From 94abeeabb98c0c32e5aaf70896f58ee39edbdc10 Mon Sep 17 00:00:00 2001
From: Brian O'Connor <bocon13@gmail.com>
Date: Tue, 10 Sep 2013 14:54:02 -0700
Subject: [PATCH 13/30] cleaned up and commented test_cpu.py

---
 examples/test/test_cpu.py | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/examples/test/test_cpu.py b/examples/test/test_cpu.py
index a0598cf..dd35490 100755
--- a/examples/test/test_cpu.py
+++ b/examples/test/test_cpu.py
@@ -1,19 +1,20 @@
 #!/usr/bin/env python
 
-"""TEST"""
+"""
+Test for cpu.py
+"""
 
 import unittest
 import pexpect
-from mininet.log import setLogLevel
 
 class testCPU( unittest.TestCase ):
-    "Test ping with single switch topology (common code)."
 
     prompt = 'mininet>'
 
     def testCPU( self ):
-        opts = [ '([a-z]+)\t([\d\.]+)%\t([\d\.]+)', pexpect.EOF ]
+        "Verify that CPU utilization is monotonically decreasing for each scheduler"
         p = pexpect.spawn( 'python -m mininet.examples.cpu' )
+        opts = [ '([a-z]+)\t([\d\.]+)%\t([\d\.]+)', pexpect.EOF ]
         scheds = []
         while True:
             index = p.expect( opts, timeout=600 )
@@ -32,5 +33,4 @@ class testCPU( unittest.TestCase ):
         self.assertTrue( len( scheds ) > 0 )
 
 if __name__ == '__main__':
-    setLogLevel( 'warning' )
     unittest.main()

From 49fc496c122e2fe49272dddbf490d328a6641ae3 Mon Sep 17 00:00:00 2001
From: Brian O'Connor <bocon13@gmail.com>
Date: Tue, 10 Sep 2013 14:56:51 -0700
Subject: [PATCH 14/30] cleaned up and commented test_emptynet.py

---
 examples/test/test_emptynet.py | 21 +++++++--------------
 1 file changed, 7 insertions(+), 14 deletions(-)

diff --git a/examples/test/test_emptynet.py b/examples/test/test_emptynet.py
index c571ecb..0d4d01d 100755
--- a/examples/test/test_emptynet.py
+++ b/examples/test/test_emptynet.py
@@ -1,39 +1,32 @@
 #!/usr/bin/env python
 
-"""TEST"""
+"""
+Test for emptynet.py
+"""
 
 import unittest
 import pexpect
-#from time import sleep
-from mininet.log import setLogLevel
-#from mininet.net import Mininet
-#from mininet.node import CPULimitedHost
-#from mininet.link import TCLink
-
-#from mininet.examples.simpleperf import SingleSwitchTopo
 
 class testEmptyNet( unittest.TestCase ):
-    "Test ping with single switch topology (common code)."
 
     prompt = 'mininet>'
 
     def testEmptyNet( self ):
+        "Run simple CLI tests: pingall (verify 0% drop) and iperf (sanity)"
         p = pexpect.spawn( 'python -m mininet.examples.emptynet' )
         p.expect( self.prompt )
+        # pingall test
         p.sendline( 'pingall' )
         p.expect ( '(\d+)% dropped' )
         percent = int( p.match.group( 1 ) ) if p.match else -1
-        self.assertEqual( percent, 0 ) # or this
+        self.assertEqual( percent, 0 ) 
         p.expect( self.prompt )
+        # iperf test
         p.sendline( 'iperf' )
         p.expect( "Results: \['[\d.]+ .bits/sec', '[\d.]+ .bits/sec'\]" )
-        #TODO check the results? maybe we dont care
         p.expect( self.prompt )
         p.sendline( 'exit' )
         p.wait()
-        #TODO remove this
-        self.assertEqual( percent, 0 )
 
 if __name__ == '__main__':
-    setLogLevel( 'warning' )
     unittest.main()

From 91a06063b4c380d482146b3dcfbb4840ab8e6e99 Mon Sep 17 00:00:00 2001
From: Brian O'Connor <bocon13@gmail.com>
Date: Tue, 10 Sep 2013 15:24:27 -0700
Subject: [PATCH 15/30] cleaned up and commented test_hwintf.py

---
 examples/test/test_hwintf.py | 68 +++++-------------------------------
 1 file changed, 9 insertions(+), 59 deletions(-)

diff --git a/examples/test/test_hwintf.py b/examples/test/test_hwintf.py
index ec0ffdd..20d08d3 100755
--- a/examples/test/test_hwintf.py
+++ b/examples/test/test_hwintf.py
@@ -1,35 +1,29 @@
 #!/usr/bin/env python
 
-"""TEST"""
+"""
+Test for hwintf.py
+"""
 
 import unittest
 import pexpect
 import re
-from time import sleep
 from mininet.log import setLogLevel
 from mininet.net import Mininet
 from mininet.node import Node
 from mininet.link import Link, Intf
 
 class testHwintf( unittest.TestCase ):
-    "Test ping with single switch topology (common code)."
 
     prompt = 'mininet>'
 
-    def _testE2E( self ):
-        results = [ "Results:", pexpect.EOF, pexpect.TIMEOUT ]
-        p = pexpect.spawn( 'python -m mininet.examples.simpleperf' )
-        index = p.expect( results, timeout=600 )
-        self.assertEqual( index, 0 )
-        p.wait()
-
     def setUp( self ):
         self.h3 = Node( 't0', ip='10.0.0.3/8' )
-        self.n0 = Node( 't1', inNamespace=False)
+        self.n0 = Node( 't1', inNamespace=False )
         Link( self.h3, self.n0 )
         self.h3.configDefault()
 
     def testLocalPing( self ):
+        "Verify connectivity between virtual hosts using pingall"
         p = pexpect.spawn( 'python -m mininet.examples.hwintf %s' % self.n0.intf() )
         p.expect( self.prompt )
         p.sendline( 'pingall' )
@@ -41,15 +35,16 @@ class testHwintf( unittest.TestCase ):
         p.wait()
 
     def testExternalPing( self ):
-        expectStr = '(\d+) packets transmitted, (\d+) received'
+        "Verify connnectivity between virtual host and virtual-physical 'external' host "
         p = pexpect.spawn( 'python -m mininet.examples.hwintf %s' % self.n0.intf() )
         p.expect( self.prompt )
-
+        # test ping external to internal
+        expectStr = '(\d+) packets transmitted, (\d+) received'
         m = re.search( expectStr, self.h3.cmd( 'ping -v -c 1 10.0.0.1' ) )
         tx = m.group( 1 )
         rx = m.group( 2 )
         self.assertEqual( tx, rx )
-
+        # test ping internal to external
         p.sendline( 'h1 ping -c 1 10.0.0.3')
         p.expect( expectStr )
         tx = p.match.group( 1 )
@@ -63,51 +58,6 @@ class testHwintf( unittest.TestCase ):
         self.h3.terminate()
         self.n0.terminate()
 
-
-            
-    ''' TAP garbage 
-     def testHwintf( self ):
-        ifname = 'br3'
-        #sudo ip tuntap add mode tap br0
-        #sudo ip tuntap del mode tap br0
-        #sudo ip link add name test0 type veth peer name test1
-        #sudo ip link del test0
-        t0 = Node( 't0', inNamespace=False, ip='10.0.0.3/8' )
-
-        t1 = Node( 't1', inNamespace=False)
-        #t0.cmd( 'ip tuntap add mode tap %s' % ifname )
-        #Intf( ifname, t0 )
-        print Link( t0, t1 )
-        t0.configDefault()
-
-        print t0.cmd( 'ifconfig' )
-        ifname =  t1.intf()
-
-
-        try:
-            foo = pexpect.spawn( 'wireshark' )
-            p = pexpect.spawn( 'python -m mininet.examples.hwintf %s' % ifname )
-            p.expect( self.prompt )
-            #t0.cmd( 'ip link set dev %s up' % ifname )
-            #t0.cmd( "bash -c 'echo 1 > /proc/sys/net/ipv4/ip_forward'" )
-            #t0.cmd( "bash -c 'echo 1 > /proc/sys/net/ipv4/conf/%s/proxy_arp'" % ifname)
-            #t0.cmd( 'arp -Ds 10.0.0.3 s1 pub' )
-
-            #p.sendline( 'x s1 wireshark' )
-            print t0.cmd( 'ifconfig %s' % ifname )
-            print t0.cmd( 'ip route' )
-            print t0.cmd( 'ping -v -c 1 10.0.0.3' )
-            print t0.cmd( 'ping -v -c 1 10.0.0.1' )
-
-            p.interact()
-            #p.wait()
-        finally:
-            #t0.cmd( 'ip tuntap del mode tap %s' % ifname )
-            t0.terminate()
-            t1.terminate()
-        #t0.configDefault()
-    '''
-
 if __name__ == '__main__':
     setLogLevel( 'warning' )
     unittest.main()

From e6fe480a306a875d94609e04954c3cb04f0e0dd9 Mon Sep 17 00:00:00 2001
From: Brian O'Connor <bocon13@gmail.com>
Date: Tue, 10 Sep 2013 15:32:03 -0700
Subject: [PATCH 16/30] cleaned up and commented test_limit.py

---
 examples/test/test_limit.py | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/examples/test/test_limit.py b/examples/test/test_limit.py
index 2629d1f..ea5ce35 100755
--- a/examples/test/test_limit.py
+++ b/examples/test/test_limit.py
@@ -1,19 +1,20 @@
 #!/usr/bin/env python
 
-"""TEST"""
+"""
+Test for limit.py
+"""
 
 import unittest
 import pexpect
-from mininet.log import setLogLevel
 
 class testLimit( unittest.TestCase ):
-    "Test ping with single switch topology (common code)."
 
     def testLimit( self ):
+        "Verify that CPU limits are within a 1% tolerance of limit for each scheduler"
+        p = pexpect.spawn( 'python -m mininet.examples.limit' )
         opts = [ '\*\*\* Testing network ([\d\.]+) Mbps', 
                  '\*\*\* Results: \[([\d\., ]+)\]', 
                  pexpect.EOF ]
-        p = pexpect.spawn( 'python -m mininet.examples.limit' )
         count = 0
         bw = 0
         tolerance = 1
@@ -24,15 +25,14 @@ class testLimit( unittest.TestCase ):
                 count += 1
             elif index == 1:
                 results = p.match.group( 1 )
-                for x in results.split(','):
+                for x in results.split( ',' ):
                     result = float( x )
                     self.assertTrue( result < bw + tolerance )
-                    self.assertTrue( result > bw - tolerance)
+                    self.assertTrue( result > bw - tolerance )
             else:
                 break
 
         self.assertTrue( count > 0 )
 
 if __name__ == '__main__':
-    setLogLevel( 'warning' )
     unittest.main()

From 1d555e724b5380c905c412b6b0eb593950d19ccc Mon Sep 17 00:00:00 2001
From: Brian O'Connor <bocon13@gmail.com>
Date: Tue, 10 Sep 2013 15:38:32 -0700
Subject: [PATCH 17/30] cleaned up and commented test_linearbandwidth.py

---
 examples/test/test_linearbandwidth.py | 22 ++++++++--------------
 1 file changed, 8 insertions(+), 14 deletions(-)

diff --git a/examples/test/test_linearbandwidth.py b/examples/test/test_linearbandwidth.py
index 2a01edc..b6c47fd 100755
--- a/examples/test/test_linearbandwidth.py
+++ b/examples/test/test_linearbandwidth.py
@@ -1,26 +1,21 @@
 #!/usr/bin/env python
 
-"""TEST"""
+"""
+Test for linearbandwidth.py
+"""
 
 import unittest
 import pexpect
-from mininet.log import setLogLevel
-#from mininet.net import Mininet
-#from mininet.node import CPULimitedHost
-#from mininet.link import TCLink
-
-#from mininet.examples.simpleperf import SingleSwitchTopo
 
 class testLinearBandwidth( unittest.TestCase ):
-    "Test ping with single switch topology (common code)."
-
-    prompt = 'mininet>'
 
     def testLinearBandwidth( self ):
-        count = 0
-        tolerance = 0.5
-        opts = [ '\*\*\* Linear network results', '(\d+)\s+([\d\.]+) (.bits)', pexpect.EOF ]
+        "Verify that bandwidth is monotonically decreasing as # of hops increases"
         p = pexpect.spawn( 'python -m mininet.examples.linearbandwidth' )
+        count = 0
+        opts = [ '\*\*\* Linear network results', 
+                 '(\d+)\s+([\d\.]+) (.bits)', 
+                 pexpect.EOF ]
         while True:
             index = p.expect( opts, timeout=600 )
             if index == 0:
@@ -44,5 +39,4 @@ class testLinearBandwidth( unittest.TestCase ):
         self.assertTrue( count > 0 )
 
 if __name__ == '__main__':
-    setLogLevel( 'warning' )
     unittest.main()

From e6e1260bc236b5261ae67566ee3453093fbdf5d0 Mon Sep 17 00:00:00 2001
From: Brian O'Connor <bocon13@gmail.com>
Date: Tue, 10 Sep 2013 15:50:43 -0700
Subject: [PATCH 18/30] cleaned up and commented test_multiping.py

---
 examples/test/test_multiping.py | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/examples/test/test_multiping.py b/examples/test/test_multiping.py
index 1bd9f94..ff0571c 100755
--- a/examples/test/test_multiping.py
+++ b/examples/test/test_multiping.py
@@ -1,21 +1,22 @@
 #!/usr/bin/env python
 
-"""TEST"""
+"""
+Test for multiping.py
+"""
 
 import unittest
 import pexpect
 from collections import defaultdict
-from mininet.log import setLogLevel
 
 class testMultiPing( unittest.TestCase ):
-    "Test ping with single switch topology (common code)."
 
     def testMultiPing( self ):
+        """Verify that each target is pinged at least once, and 
+           that pings to 'real' targets are successful and unknown targets fail"""
         p = pexpect.spawn( 'python -m mininet.examples.multiping' )
-        opts = []
-        opts.append( "Host (h\d+) \(([\d.]+)\) will be pinging ips: ([\d. ]+)" )
-        opts.append( "(h\d+): ([\d.]+) -> ([\d.]+) \d packets transmitted, (\d) received" )
-        opts.append( pexpect.EOF )
+        opts = [ "Host (h\d+) \(([\d.]+)\) will be pinging ips: ([\d\. ]+)",
+                 "(h\d+): ([\d.]+) -> ([\d.]+) \d packets transmitted, (\d) received",
+                 pexpect.EOF ]
         pings = defaultdict( list )
         while True:
             index = p.expect( opts )
@@ -39,10 +40,9 @@ class testMultiPing( unittest.TestCase ):
                     pass
             else:
                 break
-        self.assertTrue( len(pings) > 0 )
+        self.assertTrue( len( pings ) > 0 )
         for t in pings.values():
             self.assertEqual( len( t ), 0 )
 
 if __name__ == '__main__':
-    setLogLevel( 'warning' )
     unittest.main()

From bc90a7958104b1f2823c82c5a832eeb222d0d7e5 Mon Sep 17 00:00:00 2001
From: Brian O'Connor <bocon13@gmail.com>
Date: Tue, 10 Sep 2013 15:56:27 -0700
Subject: [PATCH 19/30] cleaned up and commented test_multipoll.py

---
 examples/test/test_multipoll.py | 20 +++++++++-----------
 1 file changed, 9 insertions(+), 11 deletions(-)

diff --git a/examples/test/test_multipoll.py b/examples/test/test_multipoll.py
index 5c13f34..12321ea 100755
--- a/examples/test/test_multipoll.py
+++ b/examples/test/test_multipoll.py
@@ -1,22 +1,21 @@
 #!/usr/bin/env python
 
-"""TEST"""
+"""
+Test for multipoll.py
+"""
 
 import unittest
 import pexpect
-from collections import defaultdict
-from mininet.log import setLogLevel
 
 class testMultiPoll( unittest.TestCase ):
-    "Test ping with single switch topology (common code)."
 
     def testMultiPoll( self ):
+        "Verify that we receive one ping per second per host"
         p = pexpect.spawn( 'python -m mininet.examples.multipoll' )
-        opts = []
-        opts.append( "\*\*\* (h\d) :" )
-        opts.append( "(h\d+): \d+ bytes from" )
-        opts.append( "Monitoring output for (\d+) seconds" )
-        opts.append( pexpect.EOF )
+        opts = [ "\*\*\* (h\d) :" ,
+                 "(h\d+): \d+ bytes from",
+                 "Monitoring output for (\d+) seconds",
+                 pexpect.EOF ]
         pings = {}
         while True:
             index = p.expect( opts )
@@ -30,11 +29,10 @@ class testMultiPoll( unittest.TestCase ):
                 seconds = int( p.match.group( 1 ) )
             else:
                 break
-        self.assertTrue( len(pings) > 0 )
+        self.assertTrue( len( pings ) > 0 )
         # make sure we have received at least one ping per second
         for count in pings.values():
             self.assertTrue( count >= seconds )
 
 if __name__ == '__main__':
-    setLogLevel( 'warning' )
     unittest.main()

From cdd5210bb70300499e9cc9f94055a6253352a966 Mon Sep 17 00:00:00 2001
From: Brian O'Connor <bocon13@gmail.com>
Date: Tue, 10 Sep 2013 15:59:39 -0700
Subject: [PATCH 20/30] cleaned up and commented test_multitest.py

---
 examples/test/test_multitest.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/examples/test/test_multitest.py b/examples/test/test_multitest.py
index 80887ef..a2bb10b 100755
--- a/examples/test/test_multitest.py
+++ b/examples/test/test_multitest.py
@@ -1,17 +1,18 @@
 #!/usr/bin/env python
 
-"""TEST"""
+"""
+Test for multitest.py
+"""
 
 import unittest
 import pexpect
-from mininet.log import setLogLevel
 
 class testMultiTest( unittest.TestCase ):
-    "Test ping with single switch topology (common code)."
 
     prompt = 'mininet>'
 
     def testMultiTest( self ):
+        "Verify pingall (0% dropped) and hX-eth0 interface for each host (ifconfig)"
         p = pexpect.spawn( 'python -m mininet.examples.multitest' )
         p.expect( '(\d+)% dropped' )
         dropped = int( p.match.group(1) )
@@ -28,5 +29,4 @@ class testMultiTest( unittest.TestCase ):
         self.assertEqual( ifCount, 4 )
 
 if __name__ == '__main__':
-    setLogLevel( 'warning' )
     unittest.main()

From b9b1f2e7f06d2e80929a9d1df3301b6af4fc30bf Mon Sep 17 00:00:00 2001
From: Brian O'Connor <bocon13@gmail.com>
Date: Tue, 10 Sep 2013 16:10:23 -0700
Subject: [PATCH 21/30] cleaned up and commented test_nat.py; added check for
 connectivity before running test

---
 examples/test/test_multitest.py |  2 +-
 examples/test/test_nat.py       | 30 +++++++++---------------------
 2 files changed, 10 insertions(+), 22 deletions(-)

diff --git a/examples/test/test_multitest.py b/examples/test/test_multitest.py
index a2bb10b..09172c5 100755
--- a/examples/test/test_multitest.py
+++ b/examples/test/test_multitest.py
@@ -15,7 +15,7 @@ class testMultiTest( unittest.TestCase ):
         "Verify pingall (0% dropped) and hX-eth0 interface for each host (ifconfig)"
         p = pexpect.spawn( 'python -m mininet.examples.multitest' )
         p.expect( '(\d+)% dropped' )
-        dropped = int( p.match.group(1) )
+        dropped = int( p.match.group( 1 ) )
         self.assertEqual( dropped, 0 )
         ifCount = 0
         while True:
diff --git a/examples/test/test_nat.py b/examples/test/test_nat.py
index 8e2e8a2..8e49ed6 100755
--- a/examples/test/test_nat.py
+++ b/examples/test/test_nat.py
@@ -1,44 +1,32 @@
 #!/usr/bin/env python
 
-"""TEST"""
+"""
+Test for nat.py
+"""
 
 import unittest
 import pexpect
-#from time import sleep
-from mininet.log import setLogLevel
-#from mininet.net import Mininet
-#from mininet.node import CPULimitedHost
-#from mininet.link import TCLink
+from mininet.util import quietRun
 
-#from mininet.examples.simpleperf import SingleSwitchTopo
+destIP = '8.8.8.8' # Google DNS
 
 class testNAT( unittest.TestCase ):
-    "Test ping with single switch topology (common code)."
 
     prompt = 'mininet>'
 
-    # skip if 8.8.8.8 unreachable
+    @unittest.skipIf( '0 received' in quietRun( 'ping -c 1 %s' % destIP ), 
+                      'Destination IP is not reachable' )
     def testNAT( self ):
+        "Attempt to ping an IP on the Internet and verify 0% packet loss"
         p = pexpect.spawn( 'python -m mininet.examples.nat' )
         p.expect( self.prompt )
-        p.sendline( 'h1 ping -c 1 8.8.8.8' )
+        p.sendline( 'h1 ping -c 1 %s' % destIP )
         p.expect ( '(\d+)% packet loss' )
         percent = int( p.match.group( 1 ) ) if p.match else -1
         p.expect( self.prompt )
         p.sendline( 'exit' )
         p.wait()
         self.assertEqual( percent, 0 )
-    '''
-    def testTopo( self ):
-        topo = SingleSwitchTopo(n=4)
-        net = Mininet(topo=topo,
-                  host=CPULimitedHost, link=TCLink)
-        net.start()
-        h1, h4 = net.get('h1', 'h4')
-        h1.cmd( 'ping -c 1 %s' % h4.IP() )
-        net.stop()
-    '''
 
 if __name__ == '__main__':
-    setLogLevel( 'warning' )
     unittest.main()

From 213b7c57ee9170a800754195746dfab11e9e5dd5 Mon Sep 17 00:00:00 2001
From: Brian O'Connor <bocon13@gmail.com>
Date: Tue, 10 Sep 2013 16:17:56 -0700
Subject: [PATCH 22/30] cleaned up and commented test_popen.py

---
 examples/test/test_popen.py | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/examples/test/test_popen.py b/examples/test/test_popen.py
index f9b8ab3..c7f83f0 100755
--- a/examples/test/test_popen.py
+++ b/examples/test/test_popen.py
@@ -1,21 +1,20 @@
 #!/usr/bin/env python
 
-"""TEST"""
+"""
+Test for popen.py and popenpoll.py
+"""
 
 import unittest
 import pexpect
-from collections import defaultdict
-from mininet.log import setLogLevel
 
 class testPopen( unittest.TestCase ):
-    "Test ping with single switch topology (common code)."
 
     def pingTest( self, name ):
+        "Verify that there are no dropped packets for each host"
         p = pexpect.spawn( 'python -m %s' % name )
-        opts = []
-        opts.append( "<(h\d+)>: PING " )
-        opts.append( "<(h\d+)>: (\d+) packets transmitted, (\d+) received" )
-        opts.append( pexpect.EOF )
+        opts = [ "<(h\d+)>: PING ",
+                 "<(h\d+)>: (\d+) packets transmitted, (\d+) received",
+                 pexpect.EOF ]
         pings = {}
         while True:
             index = p.expect( opts )
@@ -26,11 +25,13 @@ class testPopen( unittest.TestCase ):
                 name = p.match.group(1)
                 transmitted = p.match.group(2)
                 received = p.match.group(3)
+                # verify no dropped packets
                 self.assertEqual( received, transmitted )
                 pings[ name ] += 1
             else:
                 break
         self.assertTrue( len(pings) > 0 )
+        # verify that each host has gotten results
         for count in pings.values():
             self.assertEqual( count, 1 )
 
@@ -38,8 +39,7 @@ class testPopen( unittest.TestCase ):
         self.pingTest( 'mininet.examples.popen' )
 
     def testPopenPoll( self ):
-        self.pingTest( 'mininet.examples.popenpoll')
+        self.pingTest( 'mininet.examples.popenpoll' )
 
 if __name__ == '__main__':
-    setLogLevel( 'warning' )
     unittest.main()

From d4993c0ba4c8232aa9d37903da1c95f4ab897330 Mon Sep 17 00:00:00 2001
From: Brian O'Connor <bocon13@gmail.com>
Date: Tue, 10 Sep 2013 16:20:44 -0700
Subject: [PATCH 23/30] cleaned up and commented test_scratchnet.py

---
 examples/test/test_scratchnet.py | 14 ++++++--------
 1 file changed, 6 insertions(+), 8 deletions(-)

diff --git a/examples/test/test_scratchnet.py b/examples/test/test_scratchnet.py
index 941aaba..31739b8 100755
--- a/examples/test/test_scratchnet.py
+++ b/examples/test/test_scratchnet.py
@@ -1,29 +1,27 @@
 #!/usr/bin/env python
 
-"""TEST"""
+"""
+Test for scratchnet.py
+"""
 
 import unittest
 import pexpect
-from mininet.log import setLogLevel
 
 class testScratchNet( unittest.TestCase ):
-    "Test ping with single switch topology (common code)."
 
-    results = [ "1 packets transmitted, 1 received, 0% packet loss", pexpect.EOF ]
+    opts = [ "1 packets transmitted, 1 received, 0% packet loss", pexpect.EOF ]
 
     def pingTest( self, name ):
+        "Verify that no ping packets were dropped"
         p = pexpect.spawn( 'python -m %s' % name )
-        index = p.expect( self.results )
+        index = p.expect( self.opts )
         self.assertEqual( index, 0 )
 
-
     def testPingKernel( self ):
         self.pingTest( 'mininet.examples.scratchnet' )
 
-
     def testPingUser( self ):
         self.pingTest( 'mininet.examples.scratchnetuser' )
 
 if __name__ == '__main__':
-    setLogLevel( 'warning' )
     unittest.main()

From 48c49c54e2299df27219987359e6ba58d92f30dd Mon Sep 17 00:00:00 2001
From: Brian O'Connor <bocon13@gmail.com>
Date: Tue, 10 Sep 2013 16:57:31 -0700
Subject: [PATCH 24/30] cleaned up and commented test_sshd.py

---
 examples/test/test_sshd.py | 21 ++++++++++++---------
 1 file changed, 12 insertions(+), 9 deletions(-)

diff --git a/examples/test/test_sshd.py b/examples/test/test_sshd.py
index 35fd632..9d4ef1f 100755
--- a/examples/test/test_sshd.py
+++ b/examples/test/test_sshd.py
@@ -1,21 +1,23 @@
 #!/usr/bin/env python
 
-"""TEST"""
+"""
+Test for sshd.py
+"""
 
 import unittest
 import pexpect
 from time import sleep
-from mininet.log import setLogLevel
-from mininet.clean import cleanup, sh
+from mininet.clean import sh
 
-class testBareSSHD( unittest.TestCase ):
-    "Test ping with single switch topology (common code)."
+class testSSHD( unittest.TestCase ):
 
-    opts = [ '\(yes/no\)\?', 'refused', 'Welcome', pexpect.EOF, pexpect.TIMEOUT ]
+    opts = [ '\(yes/no\)\?', 'refused', 'Welcome|\$|#', pexpect.EOF, pexpect.TIMEOUT ]
 
     def connected( self, ip ):
-        "check connected"
-        p = pexpect.spawn( 'ssh -i /tmp/ssh/test_rsa %s' % ip )
+        "Log into ssh server, check banner, then exit"
+        # Note: this test will fail if "Welcome" is not in the sshd banner 
+        # and '#'' or '$'' are not in the prompt
+        p = pexpect.spawn( 'ssh -i /tmp/ssh/test_rsa %s' % ip, timeout=10 )
         while True:
             index = p.expect( self.opts )
             if index == 0:
@@ -38,10 +40,12 @@ class testBareSSHD( unittest.TestCase ):
         cmd = ( 'python -m mininet.examples.sshd -D '
                 '-o AuthorizedKeysFile=/tmp/ssh/authorized_keys '
                 '-o StrictModes=no' )
+        # run example with custom sshd args
         self.net = pexpect.spawn( cmd )
         self.net.expect( 'mininet>' )
 
     def testSSH( self ):
+        "Verify that we can ssh into all hosts (h1 to h4)"
         for h in range( 1, 5 ):
             self.assertTrue( self.connected( '10.0.0.%d' % h ) )
 
@@ -52,6 +56,5 @@ class testBareSSHD( unittest.TestCase ):
         sh( 'rm -rf /tmp/ssh' )
 
 if __name__ == '__main__':
-    setLogLevel( 'warning' )
     unittest.main()
 

From 3577a6989d2bbb0e5c7664e693968267a63ac0a4 Mon Sep 17 00:00:00 2001
From: Brian O'Connor <bocon13@gmail.com>
Date: Tue, 10 Sep 2013 17:14:31 -0700
Subject: [PATCH 25/30] cleaned up and commented test_tree1024.py and
 test_treeping64.py

---
 examples/test/test_tree1024.py   | 18 ++++--------------
 examples/test/test_treeping64.py | 14 ++++----------
 2 files changed, 8 insertions(+), 24 deletions(-)

diff --git a/examples/test/test_tree1024.py b/examples/test/test_tree1024.py
index adacb90..2d180cb 100755
--- a/examples/test/test_tree1024.py
+++ b/examples/test/test_tree1024.py
@@ -1,37 +1,27 @@
 #!/usr/bin/env python
 
-"""TEST"""
+"""
+Test for tree1024.py
+"""
 
 import unittest
 import pexpect
-#from time import sleep
-from mininet.log import setLogLevel
-#from mininet.net import Mininet
-#from mininet.node import CPULimitedHost
-#from mininet.link import TCLink
-
-#from mininet.examples.simpleperf import SingleSwitchTopo
 
 class testTree1024( unittest.TestCase ):
-    "Test ping with single switch topology (common code)."
 
     prompt = 'mininet>'
 
     def testTree1024( self ):
+        "Run the example and do a simple ping test from h1 to h1024"
         p = pexpect.spawn( 'python -m mininet.examples.tree1024' )
         p.expect( self.prompt, timeout=6000 ) # it takes awhile to set up
         p.sendline( 'h1 ping -c 1 h1024' )
         p.expect ( '(\d+)% packet loss' )
         percent = int( p.match.group( 1 ) ) if p.match else -1
-        #self.assertEqual( percent, 0 )
-        #p.expect( self.prompt )
-        #p.sendline( 'iperf' )
-        #p.expect( "Results: \['\d+ .bits/sec', '\d+ .bits/sec'\]" )
         p.expect( self.prompt )
         p.sendline( 'exit' )
         p.wait()
         self.assertEqual( percent, 0 )
 
 if __name__ == '__main__':
-    setLogLevel( 'warning' )
     unittest.main()
diff --git a/examples/test/test_treeping64.py b/examples/test/test_treeping64.py
index 8328c35..8154314 100755
--- a/examples/test/test_treeping64.py
+++ b/examples/test/test_treeping64.py
@@ -1,23 +1,18 @@
 #!/usr/bin/env python
 
-"""TEST"""
+"""
+Test for treeping64.py
+"""
 
 import unittest
 import pexpect
-#from time import sleep
-from mininet.log import setLogLevel
-#from mininet.net import Mininet
-#from mininet.node import CPULimitedHost
-#from mininet.link import TCLink
-
-#from mininet.examples.simpleperf import SingleSwitchTopo
 
 class testTreePing64( unittest.TestCase ):
-    "Test ping with single switch topology (common code)."
 
     prompt = 'mininet>'
 
     def testTreePing64( self ):
+        "Run the example and verify ping results"
         p = pexpect.spawn( 'python -m mininet.examples.treeping64' )
         p.expect( 'Tree network ping results:', timeout=6000 )
         count = 0
@@ -32,5 +27,4 @@ class testTreePing64( unittest.TestCase ):
         self.assertTrue( count > 0 )
 
 if __name__ == '__main__':
-    setLogLevel( 'warning' )
     unittest.main()

From 24b38126ececb3d7fed101640f33b67709598e74 Mon Sep 17 00:00:00 2001
From: Brian O'Connor <bocon13@gmail.com>
Date: Tue, 10 Sep 2013 17:21:08 -0700
Subject: [PATCH 26/30] cleaned up and commented test_simpleperf.py

---
 examples/test/test_simpleperf.py | 38 ++++++++++++++++++++++----------
 1 file changed, 26 insertions(+), 12 deletions(-)

diff --git a/examples/test/test_simpleperf.py b/examples/test/test_simpleperf.py
index 2e589d7..319ebc5 100755
--- a/examples/test/test_simpleperf.py
+++ b/examples/test/test_simpleperf.py
@@ -1,10 +1,12 @@
 #!/usr/bin/env python
 
-"""TEST"""
+"""
+Test for simpleperf.py
+"""
 
 import unittest
 import pexpect
-from time import sleep
+import re
 from mininet.log import setLogLevel
 from mininet.net import Mininet
 from mininet.node import CPULimitedHost
@@ -13,24 +15,36 @@ from mininet.link import TCLink
 from mininet.examples.simpleperf import SingleSwitchTopo
 
 class testSimplePerf( unittest.TestCase ):
-    "Test ping with single switch topology (common code)."
-
 
     def testE2E( self ):
-        results = [ "Results:", pexpect.EOF, pexpect.TIMEOUT ]
+        "Run the example and verify ping and iperf results"
         p = pexpect.spawn( 'python -m mininet.examples.simpleperf' )
-        index = p.expect( results, timeout=600 )
-        self.assertEqual( index, 0 )
+        # check ping results
+        p.expect( "Results: (\d+)% dropped", timeout=120 )
+        loss = int( p.match.group( 1 ) )
+        self.assertTrue( loss > 0 and loss < 100 )
+        # check iperf results
+        p.expect( "Results: \['([\d\.]+) .bits/sec", timeout=480 )
+        bw = float( p.match.group( 1 ) )
+        self.assertTrue( bw > 0 )
         p.wait()
 
     def testTopo( self ):
-        topo = SingleSwitchTopo(n=4)
-        net = Mininet(topo=topo,
-                  host=CPULimitedHost, link=TCLink)
+        """Import SingleSwitchTopo from example and test connectivity between two hosts
+           Note: this test may fail very rarely because it is non-deterministic
+           i.e. links are configured with 10% packet loss, but if we get unlucky and 
+           none or all of the packets are dropped, the test will fail"""
+        topo = SingleSwitchTopo( n=4 )
+        net = Mininet( topo=topo, host=CPULimitedHost, link=TCLink )
         net.start()
-        h1, h4 = net.get('h1', 'h4')
-        h1.cmd( 'ping -c 1 %s' % h4.IP() )
+        h1, h4 = net.get( 'h1', 'h4' )
+        # have h1 ping h4 ten times
+        expectStr = '(\d+) packets transmitted, (\d+) received, (\d+)% packet loss'
+        output = h1.cmd( 'ping -c 10 %s' % h4.IP() )
+        m = re.search( expectStr, output )
+        loss = int( m.group( 3 ) )
         net.stop()
+        self.assertTrue( loss > 0 and loss < 100 )
 
 if __name__ == '__main__':
     setLogLevel( 'warning' )

From 1e9e781c127c280e20dc806b9d53c34ed1c43c0c Mon Sep 17 00:00:00 2001
From: Brian O'Connor <bocon13@gmail.com>
Date: Tue, 10 Sep 2013 18:15:28 -0700
Subject: [PATCH 27/30] changed 1% to 2% in test_limit.py

---
 examples/test/test_limit.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/examples/test/test_limit.py b/examples/test/test_limit.py
index ea5ce35..99a8c25 100755
--- a/examples/test/test_limit.py
+++ b/examples/test/test_limit.py
@@ -10,14 +10,14 @@ import pexpect
 class testLimit( unittest.TestCase ):
 
     def testLimit( self ):
-        "Verify that CPU limits are within a 1% tolerance of limit for each scheduler"
+        "Verify that CPU limits are within a 2% tolerance of limit for each scheduler"
         p = pexpect.spawn( 'python -m mininet.examples.limit' )
         opts = [ '\*\*\* Testing network ([\d\.]+) Mbps', 
                  '\*\*\* Results: \[([\d\., ]+)\]', 
                  pexpect.EOF ]
         count = 0
         bw = 0
-        tolerance = 1
+        tolerance = 2
         while True:
             index = p.expect( opts )
             if index == 0:

From 10fdd01dc8ac58d2beb25e4eb689e4a90d7362ac Mon Sep 17 00:00:00 2001
From: Brian O'Connor <bocon13@gmail.com>
Date: Tue, 10 Sep 2013 18:46:07 -0700
Subject: [PATCH 28/30] fixed runner.py and added -v and -quick options

---
 examples/test/runner.py | 37 ++++++++++++++++++++++++++++---------
 1 file changed, 28 insertions(+), 9 deletions(-)
 mode change 100644 => 100755 examples/test/runner.py

diff --git a/examples/test/runner.py b/examples/test/runner.py
old mode 100644
new mode 100755
index dfa2702..4939e08
--- a/examples/test/runner.py
+++ b/examples/test/runner.py
@@ -1,10 +1,29 @@
-import glob
-import unittest
+#!/usr/bin/env python
 
-test_file_strings = glob.glob('test_*.py')
-module_strings = [str[0:len(str)-3] for str in test_file_strings]
-print module_strings
-suites = [unittest.defaultTestLoader.loadTestsFromName(str) for str
-          in module_strings]
-testSuite = unittest.TestSuite(suites)
-text_runner = unittest.TextTestRunner().run(testSuite)
\ No newline at end of file
+"""
+Run all mininet.examples tests
+ -v : verbose output
+ -quick : skip tests that take more than ~30 seconds
+"""
+
+import unittest
+import os
+import sys
+from mininet.util import ensureRoot
+from mininet.clean import cleanup
+
+def runTests( testDir, verbosity=1 ):
+    "discover and run all tests in testDir"
+    # ensure root and cleanup before starting tests
+    ensureRoot()
+    cleanup()
+    # discover all tests in testDir
+    testSuite = unittest.defaultTestLoader.discover( testDir )
+    # run tests
+    unittest.TextTestRunner( verbosity=verbosity ).run( testSuite )
+
+if __name__ == '__main__':
+    # get the directory containing example tests
+    testDir = os.path.dirname( os.path.realpath( __file__ ) )
+    verbosity = 2 if '-v' in sys.argv else 1
+    runTests( testDir, verbosity )

From c5da46f1255111a3c163f7bfa42dd5e4034526ce Mon Sep 17 00:00:00 2001
From: Brian O'Connor <bocon13@gmail.com>
Date: Tue, 10 Sep 2013 18:49:13 -0700
Subject: [PATCH 29/30] added -quick options to skip long tests

---
 examples/test/test_cpu.py             | 2 ++
 examples/test/test_limit.py           | 2 ++
 examples/test/test_linearbandwidth.py | 2 ++
 examples/test/test_simpleperf.py      | 2 ++
 examples/test/test_tree1024.py        | 2 ++
 examples/test/test_treeping64.py      | 2 ++
 6 files changed, 12 insertions(+)

diff --git a/examples/test/test_cpu.py b/examples/test/test_cpu.py
index dd35490..2547784 100755
--- a/examples/test/test_cpu.py
+++ b/examples/test/test_cpu.py
@@ -6,11 +6,13 @@ Test for cpu.py
 
 import unittest
 import pexpect
+import sys
 
 class testCPU( unittest.TestCase ):
 
     prompt = 'mininet>'
 
+    @unittest.skipIf( '-quick' in sys.argv, 'long test' )
     def testCPU( self ):
         "Verify that CPU utilization is monotonically decreasing for each scheduler"
         p = pexpect.spawn( 'python -m mininet.examples.cpu' )
diff --git a/examples/test/test_limit.py b/examples/test/test_limit.py
index 99a8c25..db9eb33 100755
--- a/examples/test/test_limit.py
+++ b/examples/test/test_limit.py
@@ -6,9 +6,11 @@ Test for limit.py
 
 import unittest
 import pexpect
+import sys
 
 class testLimit( unittest.TestCase ):
 
+    @unittest.skipIf( '-quick' in sys.argv, 'long test' )
     def testLimit( self ):
         "Verify that CPU limits are within a 2% tolerance of limit for each scheduler"
         p = pexpect.spawn( 'python -m mininet.examples.limit' )
diff --git a/examples/test/test_linearbandwidth.py b/examples/test/test_linearbandwidth.py
index b6c47fd..d3c1144 100755
--- a/examples/test/test_linearbandwidth.py
+++ b/examples/test/test_linearbandwidth.py
@@ -6,9 +6,11 @@ Test for linearbandwidth.py
 
 import unittest
 import pexpect
+import sys
 
 class testLinearBandwidth( unittest.TestCase ):
 
+    @unittest.skipIf( '-quick' in sys.argv, 'long test' )
     def testLinearBandwidth( self ):
         "Verify that bandwidth is monotonically decreasing as # of hops increases"
         p = pexpect.spawn( 'python -m mininet.examples.linearbandwidth' )
diff --git a/examples/test/test_simpleperf.py b/examples/test/test_simpleperf.py
index 319ebc5..7d44c9c 100755
--- a/examples/test/test_simpleperf.py
+++ b/examples/test/test_simpleperf.py
@@ -7,6 +7,7 @@ Test for simpleperf.py
 import unittest
 import pexpect
 import re
+import sys
 from mininet.log import setLogLevel
 from mininet.net import Mininet
 from mininet.node import CPULimitedHost
@@ -16,6 +17,7 @@ from mininet.examples.simpleperf import SingleSwitchTopo
 
 class testSimplePerf( unittest.TestCase ):
 
+    @unittest.skipIf( '-quick' in sys.argv, 'long test' )
     def testE2E( self ):
         "Run the example and verify ping and iperf results"
         p = pexpect.spawn( 'python -m mininet.examples.simpleperf' )
diff --git a/examples/test/test_tree1024.py b/examples/test/test_tree1024.py
index 2d180cb..fbc82c5 100755
--- a/examples/test/test_tree1024.py
+++ b/examples/test/test_tree1024.py
@@ -6,11 +6,13 @@ Test for tree1024.py
 
 import unittest
 import pexpect
+import sys
 
 class testTree1024( unittest.TestCase ):
 
     prompt = 'mininet>'
 
+    @unittest.skipIf( '-quick' in sys.argv, 'long test' )
     def testTree1024( self ):
         "Run the example and do a simple ping test from h1 to h1024"
         p = pexpect.spawn( 'python -m mininet.examples.tree1024' )
diff --git a/examples/test/test_treeping64.py b/examples/test/test_treeping64.py
index 8154314..ae02afc 100755
--- a/examples/test/test_treeping64.py
+++ b/examples/test/test_treeping64.py
@@ -6,11 +6,13 @@ Test for treeping64.py
 
 import unittest
 import pexpect
+import sys
 
 class testTreePing64( unittest.TestCase ):
 
     prompt = 'mininet>'
 
+    @unittest.skipIf( '-quick' in sys.argv, 'long test' )
     def testTreePing64( self ):
         "Run the example and verify ping results"
         p = pexpect.spawn( 'python -m mininet.examples.treeping64' )

From bfb560045c2c2fad9fc155b8e729db714411f970 Mon Sep 17 00:00:00 2001
From: Brian O'Connor <bocon13@gmail.com>
Date: Tue, 10 Sep 2013 18:55:21 -0700
Subject: [PATCH 30/30] add rm to sshd tests

---
 examples/test/test_baresshd.py | 1 +
 examples/test/test_sshd.py     | 1 +
 2 files changed, 2 insertions(+)

diff --git a/examples/test/test_baresshd.py b/examples/test/test_baresshd.py
index b76fe20..d708761 100755
--- a/examples/test/test_baresshd.py
+++ b/examples/test/test_baresshd.py
@@ -29,6 +29,7 @@ class testBareSSHD( unittest.TestCase ):
         # verify that sshd is not running
         self.assertFalse( self.connected() )
         # create public key pair for testing
+        sh( 'rm -rf /tmp/ssh' )
         sh( 'mkdir /tmp/ssh' )
         sh( "ssh-keygen -t rsa -P '' -f /tmp/ssh/test_rsa" )
         sh( 'cat /tmp/ssh/test_rsa.pub >> /tmp/ssh/authorized_keys' )
diff --git a/examples/test/test_sshd.py b/examples/test/test_sshd.py
index 9d4ef1f..04bd184 100755
--- a/examples/test/test_sshd.py
+++ b/examples/test/test_sshd.py
@@ -34,6 +34,7 @@ class testSSHD( unittest.TestCase ):
 
     def setUp( self ):
         # create public key pair for testing
+        sh( 'rm -rf /tmp/ssh' )
         sh( 'mkdir /tmp/ssh' )
         sh( "ssh-keygen -t rsa -P '' -f /tmp/ssh/test_rsa" )
         sh( 'cat /tmp/ssh/test_rsa.pub >> /tmp/ssh/authorized_keys' )