def setUp(self):
self.sgwPgwIoService = IoService("sgwPgw", 9000)
self.sgwPgwIoService.start()
self.mmeIoService = IoService("mme", 9001)
self.mmeIoService.start()
self.mmeResult, self.sgwPgwResult = 0, 0
self.mmeSuccessCount, self.mmeFailureCount = 0, 0
def test_rrcConnectionSetupProcedureSuccessful(self):
time.sleep(0.1) # Wait for S1 Setup
def rrcComplete(result):
self.result = result
self.result = None
ueIoService = IoService("ue", 9001)
ueIoService.start()
rrcProcedure = RrcConnectionEstablishmentProcedure({
"maxPrachPreambleAttempts": 5,
"prachPreambleRepeatDelay": 0.7,
"macContentionResolutionTimeout": 0.5,
"rrcConnectionSetupTimeoutT300": 2.0
}, (localhost(), 9000), ueIoService, rrcComplete, {
"ueIdentityType": "randomValue",
"ueIdentityValue": 3434,
"rrcEstablishmentCause": "moSignaling",
"selectedPlmnIdentity": 2801,
"initialNasMessage": {
"nasMessageType": "attachRequest"
},
})
rrcProcedure.execute()
time.sleep(2)
self.assertEqual(self.result, RrcConnectionEstablishmentProcedure.Success)
ueIoService.stop()
class TestinitialUeContextSetupProcedure(unittest.TestCase):
def setUp(self):
self.mmeIoService = IoService("mme", 9000)
self.enbIoService = IoService("enb", 9001)
[s.start() for s in self.mmeIoService, self.enbIoService]
self.enbProcedure = EnbinitialContextSetupProcedure(3, 0.5, self.enbIoService,
self.__procedureEnbCompleteCallback__)
def tearDown(self):
[s.stop() for s in self.enbIoService, self.ueIoService]
def __procedureEnbCompleteCallback__(self, result, addr, a, b, args=None):
self.enbResult = result
def test_procedureSuccessful(self):
self.enbProcedure.start((localhost(), 9001), 0, "12")
time.sleep(0.1)
self.mmeIoService.sendMessage("enb", *initialContextSetupRequest(0))
time.sleep(0.1)
self.assertEqual(self.result, EnbinitialContextSetupProcedureHandler.Complete)
def testName(self):
pass
def setUp(self):
self.ioService = IoService("service", 9000)
self.ioService.start()
self.cfg = Configuration(
{
"rrm": {
"t3212": 64,
"csEnabled": True,
"psEnabled": False
},
"son": {
"enabled": True,
"utrafdd": {
"enabled": True,
"scanOnBoot": True,
"freqs": [10787, 9137],
},
"gsm": {
"enabled": True,
"scanOnBoot": True,
"freqs": [514, 516]
}
},
"oam": {
"cliEnabled": True,
"username": "******",
"password": "******"
}
}, self.ioService)
self.result = [None, None]
def setUp(self):
self.sampleS1SetupRequestParameters = {
"globalEnbId": 345,
"enbName": "Taksim",
"supportedTas": [
(41433, ("28603", "28604")),
(41434, ("28603", "28604")),
],
"csgIdList": [101, 122],
"defaultPagingDrx": [32, 64, 128],
}
self.sampleS1SetupResponseParameters = {
"mmeName": "Istanbul",
"servedGummeis": [
(("28603", "28604"), (0, 1, 2), (23, 58, 127)),
(("00108"), (0,), (12, 13, 14)),
],
"relativeMmeCapacity": 255,
"criticalityDiagnostics": None,
}
self.enbIoService = IoService("enb", 9001)
self.mmeIoService = IoService("mme", 9000)
[s.start() for s in self.enbIoService, self.mmeIoService]
self.procedure = S1SetupProcedure(self.sampleS1SetupRequestParameters,
(localhost(), 9000), self.enbIoService, self.__procedureProgressCallback__)
self.enbIoService.addIncomingMessageCallback(self.procedure.handleIncomingMessage)
self.progress = None
self.args = None
def setUp(self):
self.enbIoService = IoService("enb", 9000)
self.ueIoService = IoService("ue", 9001)
[s.start() for s in self.enbIoService, self.ueIoService]
self.enbProcedure = EnbInitialSecurityActivationProcedureHandler(
self.enbIoService, self.__procedureCompleteCallback__)
self.enbIoService.addIncomingMessageCallback(self.enbProcedure.handleIncomingMessage)
self.result = None
def setUp(self):
self.enbIoService = IoService("enb", 9000)
self.ueIoService = IoService("ue", 9001)
[s.start() for s in self.enbIoService, self.ueIoService]
self.enbProcedure = EnbInitialSecurityActivationProcedureHandler(
self.enbIoService, self.__procedureCompleteCallback__)
self.enbIoService.addIncomingMessageCallback(
self.enbProcedure.handleIncomingMessage)
self.result = None
def setUp(self):
self.ioService = IoService("service", 9000)
self.ioService.start()
self.cfg = Configuration({
"rrm": {
"t3212": 64,
"csEnabled": True,
"psEnabled": False
},
"son": {
"enabled": True,
"utrafdd": {
"enabled": True,
"scanOnBoot": True,
"freqs": [10787, 9137],
},
"gsm": {
"enabled": True,
"scanOnBoot": True,
"freqs": [514, 516]
}
},
"oam": {
"cliEnabled": True,
"username": "******",
"password": "******"
}
}, self.ioService)
self.result = [None, None]
def setUp(self):
self.mmeIoService = IoService("mme", 9000)
self.mmeIoService.start()
self.mmeParameters = {
"mmeName": "Istanbul",
"servedGummeis": [
(("28603", "28604"), (0, 1, 2), (23, 58, 127)),
(("00108"), (0,), (12, 13, 14)),
],
"timeToWait": 1,
"flags": {
"rejectS1SetupRequestsFromRegisteredEnbs": True
},
"criticalityDiagnostics": None,
}
self.enbProcedureParameters = lambda globalEnbId, enbName, tac: {
"globalEnbId": globalEnbId,
"enbName": enbName,
"supportedTas": [
(tac, ("28603", "28604")),
],
"csgIdList": [],
"defaultPagingDrx": [32, 64, 128],
}
self.numEnbs = 2
self.enbIoServices = [IoService("enb{}".format(i), 9001 + i) for i in range(self.numEnbs)]
self.enbProcedures = [
EnbS1SetupProcedure(self.enbProcedureParameters(i, "enb{}".format(i), 59900 + i),
(localhost(), 9000), s, self.__enbS1SetupProcedureProgressCallback__)
for i, s in enumerate(self.enbIoServices)]
[s.start() for s in self.enbIoServices]
self.numSuccess, self.numWaitingForNextAttempt = 0, 0
class TestIoServiceAssertions(unittest.TestCase):
def setUp(self):
self.ioservice = IoService("service", 9000)
def test_funcStop(self):
with self.assertRaises(RuntimeError):
self.ioservice.stop()
def test_funcStartTimer(self):
with self.assertRaises(RuntimeError):
foo = self.ioservice.createTimer(1.0, lambda: None)
foo.start()
def test_funcSendMessage(self):
with self.assertRaises(RuntimeError):
self.ioservice.sendMessage((localhost(), 9000), "interface", "channelInfo", {"key": "value"})
class TestIoServiceAssertions(unittest.TestCase):
def setUp(self):
self.ioservice = IoService("service", 9000)
def test_funcStop(self):
with self.assertRaises(RuntimeError):
self.ioservice.stop()
def test_funcStartTimer(self):
with self.assertRaises(RuntimeError):
foo = self.ioservice.createTimer(1.0, lambda: None)
foo.start()
def test_funcSendMessage(self):
with self.assertRaises(RuntimeError):
self.ioservice.sendMessage((localhost(), 9000), "interface", "channelInfo", {"key": "value"})
class TestEnbInitialSecurityActivationProcedure(unittest.TestCase):
def setUp(self):
self.enbIoService = IoService("enb", 9000)
self.ueIoService = IoService("ue", 9001)
[s.start() for s in self.enbIoService, self.ueIoService]
self.enbProcedure = EnbInitialSecurityActivationProcedureHandler(
self.enbIoService, self.__procedureCompleteCallback__)
self.enbIoService.addIncomingMessageCallback(self.enbProcedure.handleIncomingMessage)
self.result = None
def __procedureCompleteCallback__(self, result, rrcTransactionIdentifier):
self.result = result
def test_procedureSuccessful(self):
self.enbProcedure.start((localhost(), 9001), 0, "cipherAlgo", "integProtAlgo")
time.sleep(0.1)
self.ueIoService.sendMessage("enb", *securityModeComplete(0))
time.sleep(0.1)
self.assertEqual(self.result, EnbInitialSecurityActivationProcedureHandler.Complete)
class TestS1apSetupProcedureInitiation(unittest.TestCase):
def setUp(self):
self.enbIoService = IoService("enb", 9001)
self.mmeIoService = IoService("mme", 9000)
[s.start() for s in self.enbIoService, self.mmeIoService]
def tearDown(self):
[s.stop() for s in self.enbIoService, self.mmeIoService]
def __procedureProgressCallback__(self, progress, args):
self.progress = progress
self.args = args
def test_missingS1SetupRequestParameters(self):
with self.assertRaises(Exception):
self.procedure = S1SetupProcedure({}, (localhost(), 9000),
self.enbIoService, self.__procedureProgressCallback__)
self.enbIoService.addIncomingMessageCallback(self.procedure.handleIncomingMessage)
self.procedure.execute()
self.procedure.terminate()
def test_rrcConnectionSetupProcedureSuccessful(self):
time.sleep(0.1) # Wait for S1 Setup
def rrcComplete(result):
self.result = result
self.result = None
ueIoService = IoService("ue", 9001)
ueIoService.start()
rrcProcedure = RrcConnectionEstablishmentProcedure(
{
"maxPrachPreambleAttempts": 5,
"prachPreambleRepeatDelay": 0.7,
"macContentionResolutionTimeout": 0.5,
"rrcConnectionSetupTimeoutT300": 2.0
}, (localhost(), 9000), ueIoService, rrcComplete, {
"ueIdentityType": "randomValue",
"ueIdentityValue": 3434,
"rrcEstablishmentCause": "moSignaling",
"selectedPlmnIdentity": 2801,
"initialNasMessage": {
"nasMessageType": "attachRequest"
},
})
rrcProcedure.execute()
time.sleep(2)
self.assertEqual(self.result,
RrcConnectionEstablishmentProcedure.Success)
ueIoService.stop()
def setUp(self):
self.mmeIoService = IoService("mme", 9000)
self.mmeIoService.start()
self.mmeParameters = {
"mmeName":
"Istanbul",
"servedGummeis": [
(("28603", "28604"), (0, 1, 2), (23, 58, 127)),
(("00108"), (0, ), (12, 13, 14)),
],
"timeToWait":
1,
"flags": {
"rejectS1SetupRequestsFromRegisteredEnbs": True
},
"criticalityDiagnostics":
None,
}
self.enbProcedureParameters = lambda globalEnbId, enbName, tac: {
"globalEnbId": globalEnbId,
"enbName": enbName,
"supportedTas": [
(tac, ("28603", "28604")),
],
"csgIdList": [],
"defaultPagingDrx": [32, 64, 128],
}
self.numEnbs = 2
self.enbIoServices = [
IoService("enb{}".format(i), 9001 + i) for i in range(self.numEnbs)
]
self.enbProcedures = [
EnbS1SetupProcedure(
self.enbProcedureParameters(i, "enb{}".format(i),
59900 + i), (localhost(), 9000), s,
self.__enbS1SetupProcedureProgressCallback__)
for i, s in enumerate(self.enbIoServices)
]
[s.start() for s in self.enbIoServices]
self.numSuccess, self.numWaitingForNextAttempt = 0, 0
class TestEnbInitialSecurityActivationProcedure(unittest.TestCase):
def setUp(self):
self.enbIoService = IoService("enb", 9000)
self.ueIoService = IoService("ue", 9001)
[s.start() for s in self.enbIoService, self.ueIoService]
self.enbProcedure = EnbInitialSecurityActivationProcedureHandler(
self.enbIoService, self.__procedureCompleteCallback__)
self.enbIoService.addIncomingMessageCallback(
self.enbProcedure.handleIncomingMessage)
self.result = None
def __procedureCompleteCallback__(self, result, rrcTransactionIdentifier):
self.result = result
def test_procedureSuccessful(self):
self.enbProcedure.start((localhost(), 9001), 0, "cipherAlgo",
"integProtAlgo")
time.sleep(0.1)
self.ueIoService.sendMessage("enb", *securityModeComplete(0))
time.sleep(0.1)
self.assertEqual(self.result,
EnbInitialSecurityActivationProcedureHandler.Complete)
class TestS1apSetupProcedureInitiation(unittest.TestCase):
def setUp(self):
self.enbIoService = IoService("enb", 9001)
self.mmeIoService = IoService("mme", 9000)
[s.start() for s in self.enbIoService, self.mmeIoService]
def tearDown(self):
[s.stop() for s in self.enbIoService, self.mmeIoService]
def __procedureProgressCallback__(self, progress, args):
self.progress = progress
self.args = args
def test_missingS1SetupRequestParameters(self):
with self.assertRaises(Exception):
self.procedure = S1SetupProcedure(
{}, (localhost(), 9000), self.enbIoService,
self.__procedureProgressCallback__)
self.enbIoService.addIncomingMessageCallback(
self.procedure.handleIncomingMessage)
self.procedure.execute()
self.procedure.terminate()
def setUp(self):
self.enbIoService = IoService("enb", 9000)
self.ueIoService = IoService("ue", 9001)
[s.start() for s in self.enbIoService, self.ueIoService]
procedureParameters = {
"maxPrachPreambleAttempts": 5,
"prachPreambleRepeatDelay": 0.7,
"macContentionResolutionTimeout": 0.5,
"rrcConnectionSetupTimeoutT300": 2.0
}
rrcEstablishmentInputParameters = {
"ueIdentityType": "randomValue",
"ueIdentityValue": 3434,
"rrcEstablishmentCause": "moSignaling",
"selectedPlmnIdentity": 2801,
"initialNasMessage": {
"nasMessageType": "attachRequest"
}
}
self.procedure = RrcConnectionEstablishmentProcedure(
procedureParameters, (localhost(), 9000), self.ueIoService,
self.__procedureCompleteCallback__,
rrcEstablishmentInputParameters)
def setUp(self):
self.sampleS1SetupRequestParameters = {
"globalEnbId":
345,
"enbName":
"Taksim",
"supportedTas": [
(41433, ("28603", "28604")),
(41434, ("28603", "28604")),
],
"csgIdList": [101, 122],
"defaultPagingDrx": [32, 64, 128],
}
self.sampleS1SetupResponseParameters = {
"mmeName":
"Istanbul",
"servedGummeis": [
(("28603", "28604"), (0, 1, 2), (23, 58, 127)),
(("00108"), (0, ), (12, 13, 14)),
],
"relativeMmeCapacity":
255,
"criticalityDiagnostics":
None,
}
self.enbIoService = IoService("enb", 9001)
self.mmeIoService = IoService("mme", 9000)
[s.start() for s in self.enbIoService, self.mmeIoService]
self.procedure = S1SetupProcedure(self.sampleS1SetupRequestParameters,
(localhost(), 9000),
self.enbIoService,
self.__procedureProgressCallback__)
self.enbIoService.addIncomingMessageCallback(
self.procedure.handleIncomingMessage)
self.progress = None
self.args = None
def setUp(self):
self.mme = Mme(
"mme", 8999, {
"system": {
"mmeName":
"Istanbul",
"servedGummeis": [
(("28603", "28604"), (0, 1, 2), (23, 58, 127)),
(("00108"), (0, ), (12, 13, 14)),
],
"maximumEnbsAllowed":
2,
},
"s1": {
"s1SetupTimeToWait": 1,
},
})
self.mme.execute()
self.enb = Enb(
"enb", 9000, {
"control": {
"adminState": True,
},
"system": {
"globalEnbId": 345,
"enbName": "Taksim",
"supportedTas": [
(127, ("28603", "28604")),
],
"csgIdList": [],
"defaultPagingDrx": [32, 64, 128],
},
"rrc": {
"maxRrcConnectionSetupAttempts": 5,
"rrcConnectionSetupTimeout": 0.7,
},
"mme": {
"address": (localhost(), 8999),
"s1SetupParameters": ConfigPath("system"),
"properties": None,
},
})
self.enb.execute()
self.numUes = 5
self.ueIoServices = [
IoService(str(i), 9001 + i) for i in range(self.numUes)
]
[s.start() for s in self.ueIoServices]
class Mme(StateMachine):
def __init__(self, name, port, configData):
super(Mme, self).__init__()
self.ioService = IoService(name, port)
self.config = Configuration(configData, self.ioService)
self.setContext({"config": self.config, "ioService": self.ioService})
def execute(self):
self.ioService.addIncomingMessageCallback(self.handleIncomingMessage)
self.ioService.start()
self.changeState(Default)
def terminate(self):
self.ioService.stop()
class Mme(StateMachine):
def __init__(self, name, port, configData):
super(Mme, self).__init__()
self.ioService = IoService(name, port)
self.config = Configuration(configData, self.ioService)
self.setContext({"config": self.config, "ioService": self.ioService})
def execute(self):
self.ioService.addIncomingMessageCallback(self.handleIncomingMessage)
self.ioService.start()
self.changeState(Default)
def terminate(self):
self.ioService.stop()
def setUp(self):
self.enbIoService = IoService("enb", 9000)
self.ueIoService = IoService("ue", 9001)
[s.start() for s in self.enbIoService, self.ueIoService]
procedureParameters = {
"maxPrachPreambleAttempts": 5,
"prachPreambleRepeatDelay": 0.7,
"macContentionResolutionTimeout": 0.5,
"rrcConnectionSetupTimeoutT300": 2.0
}
rrcEstablishmentInputParameters = {
"ueIdentityType": "randomValue",
"ueIdentityValue": 3434,
"rrcEstablishmentCause": "moSignaling",
"selectedPlmnIdentity": 2801,
"initialNasMessage": {
"nasMessageType": "attachRequest"
}
}
self.procedure = RrcConnectionEstablishmentProcedure(
procedureParameters, (localhost(), 9000),
self.ueIoService, self.__procedureCompleteCallback__, rrcEstablishmentInputParameters)
class Enb(StateMachine):
def __init__(self, name, port, configData):
super(Enb, self).__init__()
self.ioService = IoService(name, port)
self.config = Configuration(configData, self.ioService)
self.setContext({"config": self.config, "ioService": self.ioService})
def execute(self):
self.ioService.addIncomingMessageCallback(self.handleIncomingMessage)
self.ioService.start()
self.config.addListener("control.adminState",
self.__onAdminStateChanged__)
self.changeState(Deregistered)
if self.config.getValue("control.adminState"):
self.handleCommand("register")
def __onAdminStateChanged__(self, _, adminState):
mapping = {True: "register", False: "deregister"}
self.handleCommand(mapping[adminState])
def terminate(self):
self.ioService.stop()
class Enb(StateMachine):
def __init__(self, name, port, configData):
super(Enb, self).__init__()
self.ioService = IoService(name, port)
self.config = Configuration(configData, self.ioService)
self.setContext({"config": self.config, "ioService": self.ioService})
def execute(self):
self.ioService.addIncomingMessageCallback(self.handleIncomingMessage)
self.ioService.start()
self.config.addListener("control.adminState", self.__onAdminStateChanged__)
self.changeState(Deregistered)
if self.config.getValue("control.adminState"):
self.handleCommand("register")
def __onAdminStateChanged__(self, _, adminState):
mapping = {True: "register", False: "deregister"}
self.handleCommand(mapping[adminState])
def terminate(self):
self.ioService.stop()
class TestS1apSetupProcedure(unittest.TestCase):
def setUp(self):
self.sampleS1SetupRequestParameters = {
"globalEnbId":
345,
"enbName":
"Taksim",
"supportedTas": [
(41433, ("28603", "28604")),
(41434, ("28603", "28604")),
],
"csgIdList": [101, 122],
"defaultPagingDrx": [32, 64, 128],
}
self.sampleS1SetupResponseParameters = {
"mmeName":
"Istanbul",
"servedGummeis": [
(("28603", "28604"), (0, 1, 2), (23, 58, 127)),
(("00108"), (0, ), (12, 13, 14)),
],
"relativeMmeCapacity":
255,
"criticalityDiagnostics":
None,
}
self.enbIoService = IoService("enb", 9001)
self.mmeIoService = IoService("mme", 9000)
[s.start() for s in self.enbIoService, self.mmeIoService]
self.procedure = S1SetupProcedure(self.sampleS1SetupRequestParameters,
(localhost(), 9000),
self.enbIoService,
self.__procedureProgressCallback__)
self.enbIoService.addIncomingMessageCallback(
self.procedure.handleIncomingMessage)
self.progress = None
self.args = None
def tearDown(self):
[s.stop() for s in self.enbIoService, self.mmeIoService]
def __procedureProgressCallback__(self, progress, args=None):
self.progress = progress
self.args = args
def test_procedureSuccessful(self):
self.procedure.execute()
time.sleep(0.1)
self.mmeIoService.sendMessage(
"enb", *s1SetupResponse(**self.sampleS1SetupResponseParameters))
time.sleep(0.1)
self.assertEqual(self.progress, S1SetupProcedure.ProgressSuccess)
self.procedure.terminate()
def test_procedureFirstRejectedThenSuccessful(self):
self.procedure.execute()
time.sleep(0.2)
self.mmeIoService.sendMessage(
"enb",
*s1SetupFailure(
**{
"cause": "congestion",
"timeToWait": 1,
"criticalityDiagnostics": None,
}))
time.sleep(0.1)
self.assertEqual(self.progress,
S1SetupProcedure.ProgressWaitForNextAttempt)
time.sleep(1.1) # greater than value of 'Time to wait' IE
self.mmeIoService.sendMessage(
"enb", *s1SetupResponse(**self.sampleS1SetupResponseParameters))
time.sleep(0.1)
self.assertEqual(self.progress, S1SetupProcedure.ProgressSuccess)
self.procedure.terminate()
def __init__(self, name, port, configData):
super(Mme, self).__init__()
self.ioService = IoService(name, port)
self.config = Configuration(configData, self.ioService)
self.setContext({"config": self.config, "ioService": self.ioService})
class TestIoServiceTimers(unittest.TestCase):
def setUp(self):
self.ioservice = IoService("timer", 9000)
self.ioservice.start()
def test_startTimer(self):
def onSuccess():
self.successful = True
self.successful = False
foo = self.ioservice.createTimer(0.1, onSuccess)
foo.start()
time.sleep(0.2)
self.assertTrue(self.successful)
def test_startTimerWithArguments(self):
def onSuccess(*args, **kwargs):
self.assertEqual(args, (1, 2, 3))
self.assertEqual(kwargs, {"kwargOne": 4, "kwargTwo": 5, "kwargThree": 6})
self.successful = True
self.successful = False
foo = self.ioservice.createTimer(0.1, onSuccess, 1, 2, 3, kwargOne=4, kwargTwo=5, kwargThree=6)
foo.start()
time.sleep(0.2)
self.assertTrue(self.successful)
def test_cancelTimer(self):
def onExpiration():
self.expired = True
self.expired = False
foo = self.ioservice.createTimer(0.2, onExpiration)
foo.start()
time.sleep(0.1)
foo.cancel()
time.sleep(0.2)
self.assertFalse(self.expired)
def test_restartTimer(self):
def onExpiration():
self.count += 1
if self.count < 2:
foo = self.ioservice.createTimer(0.05, onExpiration)
foo.start()
self.count = 0
foo = self.ioservice.createTimer(0.05, onExpiration)
foo.start()
time.sleep(0.2)
self.assertEqual(self.count, 2)
def test_restartCanceledTimer(self):
def onExpiration():
self.successful = True
foo = self.ioservice.createTimer(0.1, onExpiration)
foo.start()
time.sleep(0.05)
foo.cancel()
foo = self.ioservice.createTimer(0.1, onExpiration)
foo.start()
time.sleep(0.2)
self.assertTrue(self.successful)
def tearDown(self):
self.ioservice.stop()
class TestRrcConnectionProcedure(unittest.TestCase):
def setUp(self):
self.enbIoService = IoService("enb", 9000)
self.ueIoService = IoService("ue", 9001)
[s.start() for s in self.enbIoService, self.ueIoService]
procedureParameters = {
"maxPrachPreambleAttempts": 5,
"prachPreambleRepeatDelay": 0.7,
"macContentionResolutionTimeout": 0.5,
"rrcConnectionSetupTimeoutT300": 2.0
}
rrcEstablishmentInputParameters = {
"ueIdentityType": "randomValue",
"ueIdentityValue": 3434,
"rrcEstablishmentCause": "moSignaling",
"selectedPlmnIdentity": 2801,
"initialNasMessage": {
"nasMessageType": "attachRequest"
}
}
self.procedure = RrcConnectionEstablishmentProcedure(
procedureParameters, (localhost(), 9000),
self.ueIoService, self.__procedureCompleteCallback__, rrcEstablishmentInputParameters)
def tearDown(self):
[s.stop() for s in self.enbIoService, self.ueIoService]
def __procedureCompleteCallback__(self, result):
self.result = result
def test_noRandomAccessResponseReceived(self):
self.result = None
self.procedure.execute()
time.sleep(3.7)
self.assertEqual(self.result,
RrcConnectionEstablishmentProcedure.ErrorNoRandomAccessResponse)
self.procedure.terminate()
def test_noContentionResolutionIdentityReceived(self):
self.result = None
self.procedure.execute()
time.sleep(0.4) # smaller than 0.7
temporaryCrnti = 43
uplinkGrant = 12
self.enbIoService.sendMessage("ue", *randomAccessResponse(
self.procedure.raRnti, self.procedure.rapid, temporaryCrnti, uplinkGrant))
time.sleep(2.0) # greater than 0.5
self.assertEqual(self.result,
RrcConnectionEstablishmentProcedure.ErrorNoContentionResolutionIdentity)
self.procedure.terminate()
def test_noRrcConnectionSetupReceived(self):
self.result = None
self.procedure.execute()
time.sleep(0.4) # smaller than 0.7
temporaryCrnti = 43
uplinkGrant = 12
self.enbIoService.sendMessage("ue", *randomAccessResponse(
self.procedure.raRnti, self.procedure.rapid, temporaryCrnti, uplinkGrant))
time.sleep(0.2) # smaller than 0.5
interface, channelInfo, message = contentionResolutionIdentity(
temporaryCrnti, self.procedure.rrcConnectionRequestMessage)
self.enbIoService.sendMessage("ue", interface, channelInfo, message)
time.sleep(2.5) # greater than 2.0
self.assertEqual(self.result,
RrcConnectionEstablishmentProcedure.ErrorNoRrcConnectionSetup)
self.procedure.terminate()
def test_rrcConnectionEstablished(self):
self.result = None
self.procedure.execute()
time.sleep(0.4) # smaller than 0.7
temporaryCrnti = 43
uplinkGrant = 12
self.enbIoService.sendMessage("ue", *randomAccessResponse(
self.procedure.raRnti, self.procedure.rapid, temporaryCrnti, uplinkGrant))
time.sleep(0.2) # smaller than 0.5
interface, channelInfo, message = contentionResolutionIdentity(
temporaryCrnti, self.procedure.rrcConnectionRequestMessage)
self.enbIoService.sendMessage("ue", interface, channelInfo, message)
time.sleep(0.5) # less than 2.0
rrcTransactionIdentifier = 4
interface, channelInfo, message = rrcConnectionSetup(temporaryCrnti, rrcTransactionIdentifier)
self.enbIoService.sendMessage("ue", interface, channelInfo, message)
time.sleep(0.5)
self.assertEqual(self.result, RrcConnectionEstablishmentProcedure.Success)
self.procedure.terminate()
def test_rrcConnectionEstablishedButSubsequentSetupsIgnored(self):
self.result = None
self.procedure.execute()
time.sleep(0.4) # smaller than 0.7
temporaryCrnti = 43
uplinkGrant = 12
self.enbIoService.sendMessage("ue", *randomAccessResponse(
self.procedure.raRnti, self.procedure.rapid, temporaryCrnti, uplinkGrant))
time.sleep(0.2) # smaller than 0.5
interface, channelInfo, message = contentionResolutionIdentity(
temporaryCrnti, self.procedure.rrcConnectionRequestMessage)
self.enbIoService.sendMessage("ue", interface, channelInfo, message)
time.sleep(0.5) # less than 2.0
rrcTransactionIdentifier = 4
interface, channelInfo, message = rrcConnectionSetup(temporaryCrnti, rrcTransactionIdentifier)
self.enbIoService.sendMessage("ue", interface, channelInfo, message)
time.sleep(0.5)
self.assertEqual(self.result, RrcConnectionEstablishmentProcedure.Success)
self.result = None
self.enbIoService.sendMessage("ue", interface, channelInfo, message)
time.sleep(0.2)
self.assertEqual(self.result, None)
self.procedure.terminate()
def setUp(self):
self.ioservice = IoService("timer", 9000)
self.ioservice.start()
def __init__(self, name, port, configData):
super(Enb, self).__init__()
self.ioService = IoService(name, port)
self.config = Configuration(configData, self.ioService)
self.setContext({"config": self.config, "ioService": self.ioService})
def setUp(self):
self.enbIoService = IoService("enb", 9001)
self.mmeIoService = IoService("mme", 9000)
[s.start() for s in self.enbIoService, self.mmeIoService]
class TestS1apSetupProcedure(unittest.TestCase):
def setUp(self):
self.sampleS1SetupRequestParameters = {
"globalEnbId": 345,
"enbName": "Taksim",
"supportedTas": [
(41433, ("28603", "28604")),
(41434, ("28603", "28604")),
],
"csgIdList": [101, 122],
"defaultPagingDrx": [32, 64, 128],
}
self.sampleS1SetupResponseParameters = {
"mmeName": "Istanbul",
"servedGummeis": [
(("28603", "28604"), (0, 1, 2), (23, 58, 127)),
(("00108"), (0,), (12, 13, 14)),
],
"relativeMmeCapacity": 255,
"criticalityDiagnostics": None,
}
self.enbIoService = IoService("enb", 9001)
self.mmeIoService = IoService("mme", 9000)
[s.start() for s in self.enbIoService, self.mmeIoService]
self.procedure = S1SetupProcedure(self.sampleS1SetupRequestParameters,
(localhost(), 9000), self.enbIoService, self.__procedureProgressCallback__)
self.enbIoService.addIncomingMessageCallback(self.procedure.handleIncomingMessage)
self.progress = None
self.args = None
def tearDown(self):
[s.stop() for s in self.enbIoService, self.mmeIoService]
def __procedureProgressCallback__(self, progress, args=None):
self.progress = progress
self.args = args
def test_procedureSuccessful(self):
self.procedure.execute()
time.sleep(0.1)
self.mmeIoService.sendMessage("enb", *s1SetupResponse(**self.sampleS1SetupResponseParameters))
time.sleep(0.1)
self.assertEqual(self.progress, S1SetupProcedure.ProgressSuccess)
self.procedure.terminate()
def test_procedureFirstRejectedThenSuccessful(self):
self.procedure.execute()
time.sleep(0.2)
self.mmeIoService.sendMessage("enb", *s1SetupFailure(**{
"cause": "congestion",
"timeToWait": 1,
"criticalityDiagnostics": None,
}))
time.sleep(0.1)
self.assertEqual(self.progress, S1SetupProcedure.ProgressWaitForNextAttempt)
time.sleep(1.1) # greater than value of 'Time to wait' IE
self.mmeIoService.sendMessage("enb", *s1SetupResponse(**self.sampleS1SetupResponseParameters))
time.sleep(0.1)
self.assertEqual(self.progress, S1SetupProcedure.ProgressSuccess)
self.procedure.terminate()
class TestS1SetupProcedureHandler(unittest.TestCase):
def setUp(self):
self.hssIoService = IoService("hss", 9000)
self.hssIoService.start()
self.mmeIoService = IoService("mme", 9001)
self.mmeIoService.start()
self.mmeSuccess, self.hssSuccess = 0, 0
def tearDown(self):
self.hssIoService.stop()
self.mmeIoService.stop()
def __mmeAuthCompleteCallback__(self, result, authContext=None):
self.mmeSuccess += 1
def __hssAuthCompleteCallback__(self, result, imsi):
self.hssSuccess += 1
def test_nAuthInfoRetrievalProcedureSuccess(self):
n = 100
visitedPlmnId = "28603"
mmeAuthProcHandler = MmeAuthProcedureHandler((localhost(), 9000), self.mmeIoService, self.__mmeAuthCompleteCallback__)
self.mmeIoService.addIncomingMessageCallback(mmeAuthProcHandler.handleIncomingMessage)
hssAuthProcHandler = HssAuthProcedureHandler(self.hssIoService, self.__hssAuthCompleteCallback__)
self.hssIoService.addIncomingMessageCallback(hssAuthProcHandler.handleIncomingMessage)
for _ in range(n):
randomImsi = visitedPlmnId + "".join([str(random.randrange(0, 10)) for __ in range(10)])
mmeAuthProcHandler.execute(randomImsi, visitedPlmnId)
time.sleep(0.1)
time.sleep(1.0)
self.assertEqual(self.mmeSuccess, n)
self.assertEqual(self.hssSuccess, n)
class TestS1SetupProcedureHandler(unittest.TestCase):
def setUp(self):
self.hssIoService = IoService("hss", 9000)
self.hssIoService.start()
self.mmeIoService = IoService("mme", 9001)
self.mmeIoService.start()
self.mmeSuccess, self.hssSuccess = 0, 0
def tearDown(self):
self.hssIoService.stop()
self.mmeIoService.stop()
def __mmeAuthCompleteCallback__(self, result, authContext=None):
self.mmeSuccess += 1
def __hssAuthCompleteCallback__(self, result, imsi):
self.hssSuccess += 1
def test_nAuthInfoRetrievalProcedureSuccess(self):
n = 100
visitedPlmnId = "28603"
mmeAuthProcHandler = MmeAuthProcedureHandler((localhost(), 9000), self.mmeIoService, self.__mmeAuthCompleteCallback__)
self.mmeIoService.addIncomingMessageCallback(mmeAuthProcHandler.handleIncomingMessage)
hssAuthProcHandler = HssAuthProcedureHandler(self.hssIoService, self.__hssAuthCompleteCallback__)
self.hssIoService.addIncomingMessageCallback(hssAuthProcHandler.handleIncomingMessage)
for _ in range(n):
randomImsi = visitedPlmnId + "".join([str(random.randrange(0, 10)) for __ in range(10)])
mmeAuthProcHandler.execute(randomImsi, visitedPlmnId)
time.sleep(0.1)
time.sleep(1.0)
self.assertEqual(self.mmeSuccess, n)
self.assertEqual(self.hssSuccess, n)
def setUp(self):
self.hssIoService = IoService("hss", 9000)
self.hssIoService.start()
self.mmeIoService = IoService("mme", 9001)
self.mmeIoService.start()
self.mmeSuccess, self.hssSuccess = 0, 0
def setUp(self):
self.ioservice = IoService("service", 9000)
class TestS1SetupProcedureHandler(unittest.TestCase):
def setUp(self):
self.mmeIoService = IoService("mme", 9000)
self.mmeIoService.start()
self.mmeParameters = {
"mmeName":
"Istanbul",
"servedGummeis": [
(("28603", "28604"), (0, 1, 2), (23, 58, 127)),
(("00108"), (0, ), (12, 13, 14)),
],
"timeToWait":
1,
"flags": {
"rejectS1SetupRequestsFromRegisteredEnbs": True
},
"criticalityDiagnostics":
None,
}
self.enbProcedureParameters = lambda globalEnbId, enbName, tac: {
"globalEnbId": globalEnbId,
"enbName": enbName,
"supportedTas": [
(tac, ("28603", "28604")),
],
"csgIdList": [],
"defaultPagingDrx": [32, 64, 128],
}
self.numEnbs = 2
self.enbIoServices = [
IoService("enb{}".format(i), 9001 + i) for i in range(self.numEnbs)
]
self.enbProcedures = [
EnbS1SetupProcedure(
self.enbProcedureParameters(i, "enb{}".format(i),
59900 + i), (localhost(), 9000), s,
self.__enbS1SetupProcedureProgressCallback__)
for i, s in enumerate(self.enbIoServices)
]
[s.start() for s in self.enbIoServices]
self.numSuccess, self.numWaitingForNextAttempt = 0, 0
def tearDown(self):
self.mmeProcedureHandler.terminate()
self.mmeIoService.stop()
[p.terminate() for p in self.enbProcedures]
[s.stop() for s in self.enbIoServices]
def __enbS1SetupProcedureProgressCallback__(self, progress, args=None):
if progress == EnbS1SetupProcedure.ProgressSuccess:
self.numSuccess += 1
elif progress == EnbS1SetupProcedure.ProgressWaitForNextAttempt:
self.numWaitingForNextAttempt += 1
def __mmeOnEnbRegisteredCallback__(self, globalEnbId):
self.enbPool.add(globalEnbId)
def test_AllSuccessfulS1Setups(self):
self.enbPool = MmeServiceArea(self.numEnbs)
self.mmeProcedureHandler = MmeS1SetupProcedureHandler(
self.mmeParameters, self.enbPool, self.mmeIoService,
self.__mmeOnEnbRegisteredCallback__)
self.mmeIoService.addIncomingMessageCallback(
self.mmeProcedureHandler.handleIncomingS1SetupMessage)
self.mmeProcedureHandler.execute()
[p.execute() for p in self.enbProcedures]
time.sleep(0.9)
self.assertEqual(self.numSuccess, self.numEnbs)
self.assertEqual(len(self.enbPool), self.numEnbs)
def test_AllSuccessfulS1SetupsExceptOne(self):
self.enbPool = MmeServiceArea(self.numEnbs)
self.mmeProcedureHandler = MmeS1SetupProcedureHandler(
self.mmeParameters, self.enbPool, self.mmeIoService,
self.__mmeOnEnbRegisteredCallback__)
self.mmeIoService.addIncomingMessageCallback(
self.mmeProcedureHandler.handleIncomingS1SetupMessage)
self.mmeProcedureHandler.execute()
[p.execute() for p in self.enbProcedures]
time.sleep(0.9)
self.assertEqual(self.numSuccess, self.numEnbs - 1)
self.assertEqual(self.numWaitingForNextAttempt, 1)
self.assertEqual(len(self.enbPool), self.numEnbs - 1)
def setUp(self):
self.ioservice = IoService("timer", 9000)
self.ioservice.start()
def setUp(self):
self.ioservice = IoService("service", 9000)
def setUp(self):
self.mme = Mme(
"mme", 8999, {
"system": {
"mmeName":
"Istanbul",
"servedGummeis": [
(("28603", "28604"), (0, 1, 2), (23, 58, 127)),
(("00108"), (0, ), (12, 13, 14)),
],
"maximumEnbsAllowed":
2,
},
"s1": {
"s1SetupTimeToWait": 1,
},
})
self.mme.execute()
self.enb = Enb(
"enb", 9000, {
"control": {
"adminState": True,
},
"system": {
"globalEnbId": 345,
"enbName": "Taksim",
"supportedTas": [
(127, ("28603", "28604")),
],
"csgIdList": [],
"defaultPagingDrx": [32, 64, 128],
},
"rrc": {
"maxRrcConnectionSetupAttempts": 5,
"rrcConnectionSetupTimeout": 0.7,
},
"mme": {
"address": (localhost(), 8999),
"s1SetupParameters": ConfigPath("system"),
"properties": None,
},
})
self.enb.execute()
procedureParameters = {
"maxPrachPreambleAttempts": 5,
"prachPreambleRepeatDelay": 0.7,
"macContentionResolutionTimeout": 0.5,
"rrcConnectionSetupTimeoutT300": 2.0
}
args = lambda i: {
"ueIdentityType": "randomValue",
"ueIdentityValue": 3434,
"rrcEstablishmentCause": "moSignaling",
"selectedPlmnIdentity": 2801,
"initialNasMessage": {
"nasMessageType": "attachRequest"
},
}
self.ueIoServices = [IoService(str(i), 9001 + i) for i in range(20)]
[s.start() for s in self.ueIoServices]
self.ueProcedures = [
UeRrcConnectionEstablishmentProcedure(
procedureParameters,
(localhost(), 9000), s, self.__procedureCompleteCallback__,
args(i)) for i, s in enumerate(self.ueIoServices)
]
self.numSuccess = 0
class TestConfiguration(unittest.TestCase):
def setUp(self):
self.ioService = IoService("service", 9000)
self.ioService.start()
self.cfg = Configuration({
"rrm": {
"t3212": 64,
"csEnabled": True,
"psEnabled": False
},
"son": {
"enabled": True,
"utrafdd": {
"enabled": True,
"scanOnBoot": True,
"freqs": [10787, 9137],
},
"gsm": {
"enabled": True,
"scanOnBoot": True,
"freqs": [514, 516]
}
},
"oam": {
"cliEnabled": True,
"username": "******",
"password": "******"
}
}, self.ioService)
self.result = [None, None]
def tearDown(self):
self.ioService.stop()
def test_setValue(self):
self.cfg.setValue(("oam", "cliEnabled"), False)
self.assertFalse(self.cfg.content["oam"]["cliEnabled"])
def test_setValueWithDotFormat(self):
self.cfg.setValue("oam.cliEnabled", False)
self.assertFalse(self.cfg.content["oam"]["cliEnabled"])
def test_getValue(self):
self.assertEqual(self.cfg.getValue(("oam", "username")), "fap123")
def test_getValueWithDotFormat(self):
self.assertEqual(self.cfg.getValue("oam.username"), "fap123")
def test_listenerCalledOnValueChanged(self):
def onValueChanged(path, value):
self.result = (path, value)
self.cfg.addListener("oam", onValueChanged)
self.cfg.setValue("oam.cliEnabled", False)
time.sleep(0.1)
self.assertListEqual(self.result[0], list(("oam", "cliEnabled")))
self.assertEqual(self.result[1], False)
def test_listenerNotCalledOnValueChanged(self):
self.listenerCalled = False
def onValueChanged(path, value):
self.listenerCalled = True
self.cfg.addListener("oam.cliEnabled", onValueChanged)
self.cfg.setValue("rrm.t3212", 10)
time.sleep(0.1)
self.assertFalse(self.listenerCalled)
def setUp(self):
self.ioservices = [IoService(str(i), 9000 + i) for i in range(2)]
[s.start() for s in self.ioservices]
self.numSuccess = 0
def setUp(self):
self.hssIoService = IoService("hss", 9000)
self.hssIoService.start()
self.mmeIoService = IoService("mme", 9001)
self.mmeIoService.start()
self.mmeSuccess, self.hssSuccess = 0, 0
def setUp(self):
self.mmeIoService = IoService("mme", 9000)
self.enbIoService = IoService("enb", 9001)
[s.start() for s in self.mmeIoService, self.enbIoService]
self.enbProcedure = EnbinitialContextSetupProcedure(3, 0.5, self.enbIoService,
self.__procedureEnbCompleteCallback__)
class TestRrcConnectionProcedure(unittest.TestCase):
def setUp(self):
self.enbIoService = IoService("enb", 9000)
self.ueIoService = IoService("ue", 9001)
[s.start() for s in self.enbIoService, self.ueIoService]
procedureParameters = {
"maxPrachPreambleAttempts": 5,
"prachPreambleRepeatDelay": 0.7,
"macContentionResolutionTimeout": 0.5,
"rrcConnectionSetupTimeoutT300": 2.0
}
rrcEstablishmentInputParameters = {
"ueIdentityType": "randomValue",
"ueIdentityValue": 3434,
"rrcEstablishmentCause": "moSignaling",
"selectedPlmnIdentity": 2801,
"initialNasMessage": {
"nasMessageType": "attachRequest"
}
}
self.procedure = RrcConnectionEstablishmentProcedure(
procedureParameters, (localhost(), 9000), self.ueIoService,
self.__procedureCompleteCallback__,
rrcEstablishmentInputParameters)
def tearDown(self):
[s.stop() for s in self.enbIoService, self.ueIoService]
def __procedureCompleteCallback__(self, result):
self.result = result
def test_noRandomAccessResponseReceived(self):
self.result = None
self.procedure.execute()
time.sleep(3.7)
self.assertEqual(
self.result,
RrcConnectionEstablishmentProcedure.ErrorNoRandomAccessResponse)
self.procedure.terminate()
def test_noContentionResolutionIdentityReceived(self):
self.result = None
self.procedure.execute()
time.sleep(0.4) # smaller than 0.7
temporaryCrnti = 43
uplinkGrant = 12
self.enbIoService.sendMessage(
"ue",
*randomAccessResponse(self.procedure.raRnti, self.procedure.rapid,
temporaryCrnti, uplinkGrant))
time.sleep(2.0) # greater than 0.5
self.assertEqual(
self.result, RrcConnectionEstablishmentProcedure.
ErrorNoContentionResolutionIdentity)
self.procedure.terminate()
def test_noRrcConnectionSetupReceived(self):
self.result = None
self.procedure.execute()
time.sleep(0.4) # smaller than 0.7
temporaryCrnti = 43
uplinkGrant = 12
self.enbIoService.sendMessage(
"ue",
*randomAccessResponse(self.procedure.raRnti, self.procedure.rapid,
temporaryCrnti, uplinkGrant))
time.sleep(0.2) # smaller than 0.5
interface, channelInfo, message = contentionResolutionIdentity(
temporaryCrnti, self.procedure.rrcConnectionRequestMessage)
self.enbIoService.sendMessage("ue", interface, channelInfo, message)
time.sleep(2.5) # greater than 2.0
self.assertEqual(
self.result,
RrcConnectionEstablishmentProcedure.ErrorNoRrcConnectionSetup)
self.procedure.terminate()
def test_rrcConnectionEstablished(self):
self.result = None
self.procedure.execute()
time.sleep(0.4) # smaller than 0.7
temporaryCrnti = 43
uplinkGrant = 12
self.enbIoService.sendMessage(
"ue",
*randomAccessResponse(self.procedure.raRnti, self.procedure.rapid,
temporaryCrnti, uplinkGrant))
time.sleep(0.2) # smaller than 0.5
interface, channelInfo, message = contentionResolutionIdentity(
temporaryCrnti, self.procedure.rrcConnectionRequestMessage)
self.enbIoService.sendMessage("ue", interface, channelInfo, message)
time.sleep(0.5) # less than 2.0
rrcTransactionIdentifier = 4
interface, channelInfo, message = rrcConnectionSetup(
temporaryCrnti, rrcTransactionIdentifier)
self.enbIoService.sendMessage("ue", interface, channelInfo, message)
time.sleep(0.5)
self.assertEqual(self.result,
RrcConnectionEstablishmentProcedure.Success)
self.procedure.terminate()
def test_rrcConnectionEstablishedButSubsequentSetupsIgnored(self):
self.result = None
self.procedure.execute()
time.sleep(0.4) # smaller than 0.7
temporaryCrnti = 43
uplinkGrant = 12
self.enbIoService.sendMessage(
"ue",
*randomAccessResponse(self.procedure.raRnti, self.procedure.rapid,
temporaryCrnti, uplinkGrant))
time.sleep(0.2) # smaller than 0.5
interface, channelInfo, message = contentionResolutionIdentity(
temporaryCrnti, self.procedure.rrcConnectionRequestMessage)
self.enbIoService.sendMessage("ue", interface, channelInfo, message)
time.sleep(0.5) # less than 2.0
rrcTransactionIdentifier = 4
interface, channelInfo, message = rrcConnectionSetup(
temporaryCrnti, rrcTransactionIdentifier)
self.enbIoService.sendMessage("ue", interface, channelInfo, message)
time.sleep(0.5)
self.assertEqual(self.result,
RrcConnectionEstablishmentProcedure.Success)
self.result = None
self.enbIoService.sendMessage("ue", interface, channelInfo, message)
time.sleep(0.2)
self.assertEqual(self.result, None)
self.procedure.terminate()
class TestIoServiceTimers(unittest.TestCase):
def setUp(self):
self.ioservice = IoService("timer", 9000)
self.ioservice.start()
def test_startTimer(self):
def onSuccess():
self.successful = True
self.successful = False
foo = self.ioservice.createTimer(0.1, onSuccess)
foo.start()
time.sleep(0.2)
self.assertTrue(self.successful)
def test_startTimerWithArguments(self):
def onSuccess(*args, **kwargs):
self.assertEqual(args, (1, 2, 3))
self.assertEqual(kwargs, {"kwargOne": 4, "kwargTwo": 5, "kwargThree": 6})
self.successful = True
self.successful = False
foo = self.ioservice.createTimer(0.1, onSuccess, 1, 2, 3, kwargOne=4, kwargTwo=5, kwargThree=6)
foo.start()
time.sleep(0.2)
self.assertTrue(self.successful)
def test_cancelTimer(self):
def onExpiration():
self.expired = True
self.expired = False
foo = self.ioservice.createTimer(0.2, onExpiration)
foo.start()
time.sleep(0.1)
foo.cancel()
time.sleep(0.2)
self.assertFalse(self.expired)
def test_restartTimer(self):
def onExpiration():
self.count += 1
if self.count < 2:
foo = self.ioservice.createTimer(0.05, onExpiration)
foo.start()
self.count = 0
foo = self.ioservice.createTimer(0.05, onExpiration)
foo.start()
time.sleep(0.2)
self.assertEqual(self.count, 2)
def test_restartCanceledTimer(self):
def onExpiration():
self.successful = True
foo = self.ioservice.createTimer(0.1, onExpiration)
foo.start()
time.sleep(0.05)
foo.cancel()
foo = self.ioservice.createTimer(0.1, onExpiration)
foo.start()
time.sleep(0.2)
self.assertTrue(self.successful)
def tearDown(self):
self.ioservice.stop()
def setUp(self):
self.ioservices = [IoService(str(i), 9000 + i) for i in range(2)]
def setUp(self):
self.enbIoService = IoService("enb", 9001)
self.mmeIoService = IoService("mme", 9000)
[s.start() for s in self.enbIoService, self.mmeIoService]
class TestS1SetupProcedureHandler(unittest.TestCase):
def setUp(self):
self.hssIoService = IoService("hss", 9000)
self.hssIoService.start()
self.mmeIoService = IoService("mme", 9001)
self.mmeIoService.start()
self.mmeSuccessCount, self.hssSuccessCount = 0, 0
def tearDown(self):
self.hssIoService.stop()
self.mmeIoService.stop()
def __mmeAuthCompleteCallback__(self, result, authContext=None):
if result == MmeAuthProcedureHandler.Success:
self.mmeSuccessCount += 1
def __hssAuthCompleteCallback__(self, result, imsi):
if result == HssAuthProcedureHandler.Success:
self.hssSuccessCount += 1
def test_nAuthInfoRetrievalProcedureSuccess(self):
n = 100
visitedPlmnId = "28603"
mmeAuthProcHandler = MmeAuthProcedureHandler((localhost(), 9000), self.mmeIoService, 1, self.__mmeAuthCompleteCallback__)
self.mmeIoService.addIncomingMessageCallback(mmeAuthProcHandler.handleIncomingMessage)
hssAuthProcHandler = HssAuthProcedureHandler(self.hssIoService, self.__hssAuthCompleteCallback__)
self.hssIoService.addIncomingMessageCallback(hssAuthProcHandler.handleIncomingMessage)
for _ in range(n):
randomImsi = visitedPlmnId + "".join([str(random.randrange(0, 10)) for __ in range(10)])
hssAuthProcHandler.knownIMSIs.append(randomImsi)
mmeAuthProcHandler.execute(randomImsi, visitedPlmnId)
time.sleep(0.1)
time.sleep(1.0)
self.assertEqual(self.mmeSuccessCount, n)
self.assertEqual(self.hssSuccessCount, n)
def test_roamingNotAllowedError(self):
visitedPlmnId = "47836"
imsi = "286031595270296"
mmeAuthProcHandler = MmeAuthProcedureHandler((localhost(), 9000), self.mmeIoService, 1, self.__mmeAuthCompleteCallback__)
self.mmeIoService.addIncomingMessageCallback(mmeAuthProcHandler.handleIncomingMessage)
hssAuthProcHandler = HssAuthProcedureHandler(self.hssIoService, self.__hssAuthCompleteCallback__)
self.hssIoService.addIncomingMessageCallback(hssAuthProcHandler.handleIncomingMessage)
mmeAuthProcHandler.execute(imsi, visitedPlmnId)
self.assertEqual(self.mmeSuccessCount,0)
def test_unknownImsiError(self):
n = 10
visitedPlmnId = "28603"
imsi = "286056548201466"
mmeAuthProcHandler = MmeAuthProcedureHandler((localhost(), 9000), self.mmeIoService, 1, self.__mmeAuthCompleteCallback__)
self.mmeIoService.addIncomingMessageCallback(mmeAuthProcHandler.handleIncomingMessage)
hssAuthProcHandler = HssAuthProcedureHandler(self.hssIoService, self.__hssAuthCompleteCallback__)
self.hssIoService.addIncomingMessageCallback(hssAuthProcHandler.handleIncomingMessage)
for _ in range(n):
randomImsi = visitedPlmnId + "".join([str(random.randrange(0, 10)) for __ in range(10)])
hssAuthProcHandler.knownIMSIs.append(randomImsi)
mmeAuthProcHandler.execute(imsi, visitedPlmnId)
self.assertEqual(self.mmeSuccessCount,0)
def test_responseTimeoutError(self):
n = 100
visitedPlmnId = "28603"
mmeAuthProcHandler = MmeAuthProcedureHandler((localhost(), 9000), self.mmeIoService, 1, self.__mmeAuthCompleteCallback__)
self.mmeIoService.addIncomingMessageCallback(mmeAuthProcHandler.handleIncomingMessage)
hssAuthProcHandler = HssAuthProcedureHandler(self.hssIoService, self.__hssAuthCompleteCallback__)
self.hssIoService.addIncomingMessageCallback(hssAuthProcHandler.handleIncomingMessage)
for _ in range(n):
randomImsi = visitedPlmnId + "".join([str(random.randrange(0, 10)) for __ in range(10)])
hssAuthProcHandler.knownIMSIs.append(randomImsi)
mmeAuthProcHandler.execute(randomImsi, visitedPlmnId)
time.sleep(0.05)
time.sleep(5.0)
self.assertEqual(self.mmeSuccessCount, n - mmeAuthProcHandler.timeoutCounter)
class TestConfiguration(unittest.TestCase):
def setUp(self):
self.ioService = IoService("service", 9000)
self.ioService.start()
self.cfg = Configuration(
{
"rrm": {
"t3212": 64,
"csEnabled": True,
"psEnabled": False
},
"son": {
"enabled": True,
"utrafdd": {
"enabled": True,
"scanOnBoot": True,
"freqs": [10787, 9137],
},
"gsm": {
"enabled": True,
"scanOnBoot": True,
"freqs": [514, 516]
}
},
"oam": {
"cliEnabled": True,
"username": "******",
"password": "******"
}
}, self.ioService)
self.result = [None, None]
def tearDown(self):
self.ioService.stop()
def test_setValue(self):
self.cfg.setValue(("oam", "cliEnabled"), False)
self.assertFalse(self.cfg.content["oam"]["cliEnabled"])
def test_setValueWithDotFormat(self):
self.cfg.setValue("oam.cliEnabled", False)
self.assertFalse(self.cfg.content["oam"]["cliEnabled"])
def test_getValue(self):
self.assertEqual(self.cfg.getValue(("oam", "username")), "fap123")
def test_getValueWithDotFormat(self):
self.assertEqual(self.cfg.getValue("oam.username"), "fap123")
def test_listenerCalledOnValueChanged(self):
def onValueChanged(path, value):
self.result = (path, value)
self.cfg.addListener("oam", onValueChanged)
self.cfg.setValue("oam.cliEnabled", False)
time.sleep(0.1)
self.assertListEqual(self.result[0], list(("oam", "cliEnabled")))
self.assertEqual(self.result[1], False)
def test_listenerNotCalledOnValueChanged(self):
self.listenerCalled = False
def onValueChanged(path, value):
self.listenerCalled = True
self.cfg.addListener("oam.cliEnabled", onValueChanged)
self.cfg.setValue("rrm.t3212", 10)
time.sleep(0.1)
self.assertFalse(self.listenerCalled)
class TestGtpcCreateSessionProcedureHandler(unittest.TestCase):
def setUp(self):
self.sgwPgwIoService = IoService("sgwPgw", 9000)
self.sgwPgwIoService.start()
self.mmeIoService = IoService("mme", 9001)
self.mmeIoService.start()
self.mmeResult, self.sgwPgwResult = 0, 0
self.mmeSuccessCount, self.mmeFailureCount = 0, 0
def tearDown(self):
self.sgwPgwIoService.stop()
self.mmeIoService.stop()
def __mmeCreateSessionCompleteCallback__(self, result, responseMessageCause=None):
self.mmeResult = result
if result == MmeCreateSessionHandler.Success:
self.mmeSuccessCount += 1
else:
self.mmeFailureCount += 1
def __sgwPgwCreateSessionCompleteCallback__(self, result, sgwContextInfo=None):
self.sgwPgwResult = result
self.sgwContextInfo = sgwContextInfo
# print sgwContextInfo
def test_noCreateSessionResponseReceived(self):
self.mmeResult = None
mmeCreateSessionHandler = MmeCreateSessionHandler((localhost(), 9002), self.mmeIoService, 0.5, 3, self.__mmeCreateSessionCompleteCallback__)
self.mmeIoService.addIncomingMessageCallback(mmeCreateSessionHandler.handleIncomingMessage)
imsi = "35353"
createSessionRequestMessage = \
{"imsi": imsi,
"pgwS5S8AddressForContolPlane": {"interfaceType": "ipv4", "teid": 0,
"address": localhost()},
"senderFteidForControlPlane": {"interfaceType": "ipv4", "teid": 45, "address": localhost()},
"pdnAddressAllocation": {"pdnType": "ipv4", "pdnAddressAndPrefix": "0.0.0.0"},
"bearerContextsToBeCreated": [{"epsBearerId": 0,
"s1uEnbFteid": {"interfaceType": "ipv4", "teid": 45, "address": localhost()},
"bearerLevelQos": None}]
}
mmeCreateSessionHandler.execute(imsi, createSessionRequestMessage)
time.sleep(0.5*3 + 0.2)
self.assertEqual(self.mmeResult,
MmeCreateSessionHandler.ErrorNoCreateSessionResponse)
def test_nNoCreateSessionResponseReceived(self):
self.mmeResult = None
mmeCreateSessionHandler = MmeCreateSessionHandler((localhost(), 9002), self.mmeIoService, 0.5, 3, self.__mmeCreateSessionCompleteCallback__)
self.mmeIoService.addIncomingMessageCallback(mmeCreateSessionHandler.handleIncomingMessage)
for i in range(100):
imsi = "2867" + str(i)
createSessionRequestMessage = \
{"imsi": imsi,
"senderFteidForControlPlane": {"interfaceType": "ipv4", "teid": i, "address": localhost()},
"pgwS5S8AddressForContolPlane": {"interfaceType": "ipv4", "teid": 0,
"address": localhost()},
"pdnAddressAllocation": {"pdnType": "ipv4", "pdnAddressAndPrefix": "0.0.0.0"},
"bearerContextsToBeCreated": [{"epsBearerId": 0,
"s1uEnbFteid": {"interfaceType": "ipv4", "teid": 45, "address": localhost()},
"bearerLevelQos": None}]
}
mmeCreateSessionHandler.execute(imsi, createSessionRequestMessage)
time.sleep(0.5*3 + 0.5)
self.assertEqual(self.mmeFailureCount, 100)
def test_CreateSessionProcedureSuccess(self):
mmeCreateSessionHandler = MmeCreateSessionHandler((localhost(), 9000), self.mmeIoService, 0.5, 3, self.__mmeCreateSessionCompleteCallback__)
self.mmeIoService.addIncomingMessageCallback(mmeCreateSessionHandler.handleIncomingMessage)
sgwPgwBearerResourceHandler = SgwPgwBearerResourceHandler(localhost(), localhost())
sgwPgwCreateSessionHandler = SgwPgwCreateSessionHandler((localhost(), 9001), localhost(), self.sgwPgwIoService,
sgwPgwBearerResourceHandler, self.__sgwPgwCreateSessionCompleteCallback__)
self.sgwPgwIoService.addIncomingMessageCallback(sgwPgwCreateSessionHandler.handleCreateSessionRequestMessage)
imsi = "35353"
createSessionRequestMessage = \
{"imsi": imsi,
"senderFteidForControlPlane": {"interfaceType": "ipv4", "teid": 45, "address": localhost()},
"pgwS5S8AddressForContolPlane": {"interfaceType": "ipv4", "teid": 0,
"address": localhost()},
"pdnAddressAllocation": {"pdnType": "ipv4", "pdnAddressAndPrefix": "0.0.0.0"},
"bearerContextsToBeCreated": [{"epsBearerId": 0,
"bearerLevelQos": None}]
}
mmeCreateSessionHandler.execute(imsi, createSessionRequestMessage)
time.sleep(1.0)
self.assertEqual(self.mmeResult, MmeCreateSessionHandler.Success)
self.assertEqual(self.sgwPgwResult, SgwPgwCreateSessionHandler.Success)
def test_DuplicateCreateSessionRequestProcedureSuccess(self):
mmeCreateSessionHandler = MmeCreateSessionHandler((localhost(), 9000), self.mmeIoService, 0.5, 3, self.__mmeCreateSessionCompleteCallback__)
self.mmeIoService.addIncomingMessageCallback(mmeCreateSessionHandler.handleIncomingMessage)
sgwPgwBearerResourceHandler = SgwPgwBearerResourceHandler(localhost(), localhost())
sgwPgwCreateSessionHandler = SgwPgwCreateSessionHandler((localhost(), 9001), localhost(), self.sgwPgwIoService,
sgwPgwBearerResourceHandler, self.__sgwPgwCreateSessionCompleteCallback__)
self.sgwPgwIoService.addIncomingMessageCallback(sgwPgwCreateSessionHandler.handleCreateSessionRequestMessage)
imsi = "35353"
createSessionRequestMessage = \
{"imsi": imsi,
"senderFteidForControlPlane": {"interfaceType": "ipv4", "teid": 45, "address": localhost()},
"pgwS5S8AddressForContolPlane": {"interfaceType": "ipv4", "teid": 0,
"address": localhost()},
"pdnAddressAllocation": {"pdnType": "ipv4", "pdnAddressAndPrefix": "0.0.0.0"},
"bearerContextsToBeCreated": [{"epsBearerId": 0,
"bearerLevelQos": None}]
}
mmeCreateSessionHandler.execute(imsi, createSessionRequestMessage)
time.sleep(1.0)
self.assertEqual(self.mmeResult, MmeCreateSessionHandler.Success)
self.assertEqual(self.sgwPgwResult, SgwPgwCreateSessionHandler.Success)
mmeCreateSessionHandler.execute(imsi, createSessionRequestMessage) # send duplicate message but with a new sequence number
time.sleep(1.0)
self.assertEqual(self.mmeResult, MmeCreateSessionHandler.Success)
self.assertEqual(self.sgwPgwResult, SgwPgwCreateSessionHandler.Success)
def test_nCreateSessionProcedureSuccess(self):
mmeCreateSessionHandler = MmeCreateSessionHandler((localhost(), 9000), self.mmeIoService, 0.5, 3, self.__mmeCreateSessionCompleteCallback__)
self.mmeIoService.addIncomingMessageCallback(mmeCreateSessionHandler.handleIncomingMessage)
sgwPgwBearerResourceHandler = SgwPgwBearerResourceHandler(localhost(), localhost())
sgwPgwCreateSessionHandler = SgwPgwCreateSessionHandler((localhost(), 9001), localhost(), self.sgwPgwIoService,
sgwPgwBearerResourceHandler, self.__sgwPgwCreateSessionCompleteCallback__)
self.sgwPgwIoService.addIncomingMessageCallback(sgwPgwCreateSessionHandler.handleCreateSessionRequestMessage)
imsiArray = []
for i in range(100):
imsi = "2867" + str(i)
imsiArray.append(imsi)
createSessionRequestMessage = \
{"imsi": imsi,
"senderFteidForControlPlane": {"interfaceType": "ipv4", "teid": i, "address": localhost()},
"pgwS5S8AddressForContolPlane": {"interfaceType": "ipv4", "teid": 0,
"address": localhost()},
"pdnAddressAllocation": {"pdnType": "ipv4", "pdnAddressAndPrefix": "0.0.0.0"},
"bearerContextsToBeCreated": [{"epsBearerId": 0,
"bearerLevelQos": None}]
}
mmeCreateSessionHandler.execute(imsi, createSessionRequestMessage)
time.sleep(0.1)
time.sleep(1.0)
self.assertEqual(self.mmeSuccessCount, 100)
self.assertEqual(set(sgwPgwCreateSessionHandler.establishedS11SessionContexts), set(imsiArray))
mmeTeidsForControlPlane = []
for i in range(100):
imsi = "2867" + str(i)
mmeTeidsForControlPlane.append(sgwPgwCreateSessionHandler.establishedS11SessionContexts[imsi]["mmeFteidForControlPlane"]["teid"])
self.assertEqual(set(mmeTeidsForControlPlane), set(range(100)))
def setUp(self):
self.enbIoService = IoService("enb", 9000)
self.ueIoService = IoService("ue", 9001)
[s.start() for s in self.enbIoService, self.ueIoService]
self.enbProcedure = EnbRrcConnectionEstablishmentProcedure(
3, 0.5, self.enbIoService, self.__procedureEnbCompleteCallback__)
class TestS1SetupProcedureHandler(unittest.TestCase):
def setUp(self):
self.mmeIoService = IoService("mme", 9000)
self.mmeIoService.start()
self.mmeParameters = {
"mmeName": "Istanbul",
"servedGummeis": [
(("28603", "28604"), (0, 1, 2), (23, 58, 127)),
(("00108"), (0,), (12, 13, 14)),
],
"timeToWait": 1,
"flags": {
"rejectS1SetupRequestsFromRegisteredEnbs": True
},
"criticalityDiagnostics": None,
}
self.enbProcedureParameters = lambda globalEnbId, enbName, tac: {
"globalEnbId": globalEnbId,
"enbName": enbName,
"supportedTas": [
(tac, ("28603", "28604")),
],
"csgIdList": [],
"defaultPagingDrx": [32, 64, 128],
}
self.numEnbs = 2
self.enbIoServices = [IoService("enb{}".format(i), 9001 + i) for i in range(self.numEnbs)]
self.enbProcedures = [
EnbS1SetupProcedure(self.enbProcedureParameters(i, "enb{}".format(i), 59900 + i),
(localhost(), 9000), s, self.__enbS1SetupProcedureProgressCallback__)
for i, s in enumerate(self.enbIoServices)]
[s.start() for s in self.enbIoServices]
self.numSuccess, self.numWaitingForNextAttempt = 0, 0
def tearDown(self):
self.mmeProcedureHandler.terminate()
self.mmeIoService.stop()
[p.terminate() for p in self.enbProcedures]
[s.stop() for s in self.enbIoServices]
def __enbS1SetupProcedureProgressCallback__(self, progress, args=None):
if progress == EnbS1SetupProcedure.ProgressSuccess:
self.numSuccess += 1
elif progress == EnbS1SetupProcedure.ProgressWaitForNextAttempt:
self.numWaitingForNextAttempt += 1
def __mmeOnEnbRegisteredCallback__(self, globalEnbId):
self.enbPool.add(globalEnbId)
def test_AllSuccessfulS1Setups(self):
self.enbPool = MmeServiceArea(self.numEnbs)
self.mmeProcedureHandler = MmeS1SetupProcedureHandler(self.mmeParameters, self.enbPool, self.mmeIoService,
self.__mmeOnEnbRegisteredCallback__)
self.mmeIoService.addIncomingMessageCallback(self.mmeProcedureHandler.handleIncomingS1SetupMessage)
self.mmeProcedureHandler.execute()
[p.execute() for p in self.enbProcedures]
time.sleep(0.9)
self.assertEqual(self.numSuccess, self.numEnbs)
self.assertEqual(len(self.enbPool), self.numEnbs)
def test_AllSuccessfulS1SetupsExceptOne(self):
self.enbPool = MmeServiceArea(self.numEnbs)
self.mmeProcedureHandler = MmeS1SetupProcedureHandler(self.mmeParameters, self.enbPool, self.mmeIoService,
self.__mmeOnEnbRegisteredCallback__)
self.mmeIoService.addIncomingMessageCallback(self.mmeProcedureHandler.handleIncomingS1SetupMessage)
self.mmeProcedureHandler.execute()
[p.execute() for p in self.enbProcedures]
time.sleep(0.9)
self.assertEqual(self.numSuccess, self.numEnbs - 1)
self.assertEqual(self.numWaitingForNextAttempt, 1)
self.assertEqual(len(self.enbPool), self.numEnbs - 1)
