From 84d385b4d3491b072cdbea41d62127aa61c6f5e7 Mon Sep 17 00:00:00 2001 From: Lorenzo Colitti Date: Tue, 26 Jan 2016 23:22:28 +0900 Subject: [PATCH] Fix lint warnings. Change-Id: I3b881be8b665ba790e7da79b3560c159d72be1e2 --- tests/net_test/sock_diag_test.py | 143 ++++++++++++++++++++------------------- tests/net_test/tcp_test.py | 4 +- 2 files changed, 76 insertions(+), 71 deletions(-) diff --git a/tests/net_test/sock_diag_test.py b/tests/net_test/sock_diag_test.py index dad81061..3c5d0a97 100755 --- a/tests/net_test/sock_diag_test.py +++ b/tests/net_test/sock_diag_test.py @@ -14,21 +14,21 @@ # See the License for the specific language governing permissions and # limitations under the License. +# pylint: disable=g-bad-todo,g-bad-file-header,wildcard-import from errno import * # pylint: disable=wildcard-import import os import random +import re from socket import * # pylint: disable=wildcard-import +import threading import time import unittest -import csocket -import cstruct import multinetwork_base import net_test import packets import sock_diag import tcp_test -import threading NUM_SOCKETS = 30 @@ -41,7 +41,7 @@ class SockDiagBaseTest(multinetwork_base.MultiNetworkBaseTest): def _CreateLotsOfSockets(): # Dict mapping (addr, sport, dport) tuples to socketpairs. socketpairs = {} - for i in xrange(NUM_SOCKETS): + for _ in xrange(NUM_SOCKETS): family, addr = random.choice([ (AF_INET, "127.0.0.1"), (AF_INET6, "::1"), @@ -68,7 +68,9 @@ class SockDiagBaseTest(multinetwork_base.MultiNetworkBaseTest): self.socketpairs = {} def tearDown(self): - [s.close() for socketpair in self.socketpairs.values() for s in socketpair] + for socketpair in self.socketpairs.values(): + for s in socketpair: + s.close() super(SockDiagBaseTest, self).tearDown() @@ -87,7 +89,7 @@ class SockDiagTest(SockDiagBaseTest): self.assertEqual(diag_msg.id.dst, self.sock_diag.PaddedAddress(dst)) self.assertEqual(diag_msg.id.dport, dport) else: - assertRaisesErrno(ENOTCONN, s.getpeername) + self.assertRaisesErrno(ENOTCONN, s.getpeername) def testFindsMappedSockets(self): """Tests that inet_diag_find_one_icsk can find mapped sockets. @@ -119,7 +121,7 @@ class SockDiagTest(SockDiagBaseTest): # Find the cookies for all of our sockets. cookies = {} - for diag_msg, attrs in sockets: + for diag_msg, unused_attrs in sockets: addr = self.sock_diag.GetSourceAddress(diag_msg) sport = diag_msg.id.sport dport = diag_msg.id.dport @@ -144,11 +146,12 @@ class SockDiagTest(SockDiagBaseTest): # Check that we can find a diag_msg once we know the cookie. req = self.sock_diag.DiagReqFromSocket(sock) req.id.cookie = cookie - req.states = 1 << diag_msg.state diag_msg = self.sock_diag.GetSockDiag(req) + req.states = 1 << diag_msg.state self.assertSockDiagMatchesSocket(sock, diag_msg) def testBytecodeCompilation(self): + # pylint: disable=bad-whitespace instructions = [ (sock_diag.INET_DIAG_BC_S_GE, 1, 8, 0), # 0 (sock_diag.INET_DIAG_BC_D_LE, 1, 7, 0xffff), # 8 @@ -160,6 +163,7 @@ class SockDiagTest(SockDiagBaseTest): # 76 acc # 80 rej ] + # pylint: enable=bad-whitespace bytecode = self.sock_diag.PackBytecode(instructions) expected = ( "0208500000000000" @@ -208,8 +212,8 @@ class SockDiagTest(SockDiagBaseTest): # specific and remove it. self.assertFalse(self.sock_diag.DumpAllInetSockets(IPPROTO_TCP, "")) - pair4 = net_test.CreateSocketPair(AF_INET, SOCK_STREAM, "127.0.0.1") - pair6 = net_test.CreateSocketPair(AF_INET6, SOCK_STREAM, "::1") + unused_pair4 = net_test.CreateSocketPair(AF_INET, SOCK_STREAM, "127.0.0.1") + unused_pair6 = net_test.CreateSocketPair(AF_INET6, SOCK_STREAM, "::1") bytecode4 = self.sock_diag.PackBytecode([ (sock_diag.INET_DIAG_BC_S_COND, 1, 2, ("0.0.0.0", 0, -1))]) @@ -295,7 +299,7 @@ class SockDestroyTest(SockDiagBaseTest): def testClosesSockets(self): self.socketpairs = self._CreateLotsOfSockets() - for (addr, _, _), socketpair in self.socketpairs.iteritems(): + for _, socketpair in self.socketpairs.iteritems(): # Close one of the sockets. # This will send a RST that will close the other side as well. s = random.choice(socketpair) @@ -303,7 +307,6 @@ class SockDestroyTest(SockDiagBaseTest): self.sock_diag.CloseSocketFromFd(s) else: diag_msg = self.sock_diag.FindSockDiagFromFd(s) - family = AF_INET6 if ":" in addr else AF_INET # Get the cookie wrong and ensure that we get an error and the socket # is not closed. @@ -323,7 +326,7 @@ class SockDestroyTest(SockDiagBaseTest): def testNonTcpSockets(self): s = socket(AF_INET6, SOCK_DGRAM, 0) s.connect(("::1", 53)) - diag_msg = self.sock_diag.FindSockDiagFromFd(s) + self.sock_diag.FindSockDiagFromFd(s) # No exceptions? Good. self.assertRaisesErrno(EOPNOTSUPP, self.sock_diag.CloseSocketFromFd, s) # TODO: @@ -342,7 +345,7 @@ class SocketExceptionThread(threading.Thread): def run(self): try: self.operation(self.sock) - except Exception, e: + except IOError, e: self.exception = e @@ -424,69 +427,71 @@ class SockDestroyTcpTest(tcp_test.TcpBaseTest, SockDiagBaseTest): return [self.sock_diag.DiagReqFromDiagMsg(d, IPPROTO_TCP) for d, _ in children] - def CheckChildSocket(self, state, statename, parent_first): - for version in [4, 5, 6]: - self.IncomingConnection(version, state, self.netid) + def CheckChildSocket(self, version, statename, parent_first): + state = getattr(tcp_test, statename) - d = self.sock_diag.FindSockDiagFromFd(self.s) - parent = self.sock_diag.DiagReqFromDiagMsg(d, IPPROTO_TCP) - children = self.FindChildSockets(self.s) - self.assertEquals(1, len(children)) + self.IncomingConnection(version, state, self.netid) - is_established = (state == tcp_test.NOT_YET_ACCEPTED) + d = self.sock_diag.FindSockDiagFromFd(self.s) + parent = self.sock_diag.DiagReqFromDiagMsg(d, IPPROTO_TCP) + children = self.FindChildSockets(self.s) + self.assertEquals(1, len(children)) - # The new TCP listener code in 4.4 makes SYN_RECV sockets live in the - # regular TCP hash tables, and inet_diag_find_one_icsk can find them. - # Before 4.4, we can see those sockets in dumps, but we can't fetch - # or close them. - can_close_children = is_established or net_test.LINUX_VERSION >= (4, 4) + is_established = (state == tcp_test.TCP_NOT_YET_ACCEPTED) - for child in children: - if can_close_children: - self.sock_diag.GetSockDiag(child) # No errors? Good, child found. - else: - self.assertRaisesErrno(ENOENT, self.sock_diag.GetSockDiag, child) - - def CloseParent(expect_reset): - msg = "Closing parent IPv%d %s socket %s child" % ( - version, statename, "before" if parent_first else "after") - self.CheckRstOnClose(self.s, None, expect_reset, msg) - self.assertRaisesErrno(ENOENT, self.sock_diag.GetSockDiag, parent) - - def CheckChildrenClosed(): - for child in children: - self.assertRaisesErrno(ENOENT, self.sock_diag.GetSockDiag, child) - - def CloseChildren(): - for child in children: - msg = "Closing child IPv%d %s socket %s parent" % ( - version, statename, "after" if parent_first else "before") - self.sock_diag.GetSockDiag(child) - self.CheckRstOnClose(None, child, is_established, msg) - self.assertRaisesErrno(ENOENT, self.sock_diag.GetSockDiag, child) - CheckChildrenClosed() + # The new TCP listener code in 4.4 makes SYN_RECV sockets live in the + # regular TCP hash tables, and inet_diag_find_one_icsk can find them. + # Before 4.4, we can see those sockets in dumps, but we can't fetch + # or close them. + can_close_children = is_established or net_test.LINUX_VERSION >= (4, 4) - if parent_first: - # Closing the parent will close child sockets, which will send a RST, - # iff they are already established. - CloseParent(is_established) - if is_established: - CheckChildrenClosed() - elif can_close_children: - CloseChildren() - CheckChildrenClosed() - self.s.close() + for child in children: + if can_close_children: + self.sock_diag.GetSockDiag(child) # No errors? Good, child found. else: - if can_close_children: - CloseChildren() - CloseParent(False) - self.s.close() + self.assertRaisesErrno(ENOENT, self.sock_diag.GetSockDiag, child) + + def CloseParent(expect_reset): + msg = "Closing parent IPv%d %s socket %s child" % ( + version, statename, "before" if parent_first else "after") + self.CheckRstOnClose(self.s, None, expect_reset, msg) + self.assertRaisesErrno(ENOENT, self.sock_diag.GetSockDiag, parent) + + def CheckChildrenClosed(): + for child in children: + self.assertRaisesErrno(ENOENT, self.sock_diag.GetSockDiag, child) + + def CloseChildren(): + for child in children: + msg = "Closing child IPv%d %s socket %s parent" % ( + version, statename, "after" if parent_first else "before") + self.sock_diag.GetSockDiag(child) + self.CheckRstOnClose(None, child, is_established, msg) + self.assertRaisesErrno(ENOENT, self.sock_diag.GetSockDiag, child) + CheckChildrenClosed() + + if parent_first: + # Closing the parent will close child sockets, which will send a RST, + # iff they are already established. + CloseParent(is_established) + if is_established: + CheckChildrenClosed() + elif can_close_children: + CloseChildren() + CheckChildrenClosed() + self.s.close() + else: + if can_close_children: + CloseChildren() + CloseParent(False) + self.s.close() def testChildSockets(self): - self.CheckChildSocket(tcp_test.TCP_SYN_RECV, "TCP_SYN_RECV", False) - self.CheckChildSocket(tcp_test.TCP_SYN_RECV, "TCP_SYN_RECV", True) - self.CheckChildSocket(tcp_test.NOT_YET_ACCEPTED, "not yet accepted", False) - self.CheckChildSocket(tcp_test.NOT_YET_ACCEPTED, "not yet accepted", True) + for version in [4, 5, 6]: + self.CheckChildSocket(version, "TCP_SYN_RECV", False) + self.CheckChildSocket(version, "TCP_SYN_RECV", True) + self.CheckChildSocket(version, "TCP_NOT_YET_ACCEPTED", False) + self.CheckChildSocket(version, "TCP_NOT_YET_ACCEPTED", True) def CloseDuringBlockingCall(self, sock, call, expected_errno): thread = SocketExceptionThread(sock, call) diff --git a/tests/net_test/tcp_test.py b/tests/net_test/tcp_test.py index 2c97bafa..81a6884e 100644 --- a/tests/net_test/tcp_test.py +++ b/tests/net_test/tcp_test.py @@ -35,7 +35,7 @@ TCP_LISTEN = 10 TCP_CLOSING = 11 TCP_NEW_SYN_RECV = 12 -NOT_YET_ACCEPTED = -1 +TCP_NOT_YET_ACCEPTED = -1 class TcpBaseTest(multinetwork_base.MultiNetworkBaseTest): @@ -94,7 +94,7 @@ class TcpBaseTest(multinetwork_base.MultiNetworkBaseTest): establishing_ack = packets.ACK(version, remoteaddr, myaddr, reply)[1] self.ReceivePacketOn(netid, establishing_ack) - if end_state == NOT_YET_ACCEPTED: + if end_state == TCP_NOT_YET_ACCEPTED: return self.accepted, _ = self.s.accept() -- 2.11.0