def TFS_SoftwareUpgrade_001 ():
try:
t1 = time.localtime()
testResult = ''
result = ''
TESTCASE = 'SoftwareUpgrade_001'
glob.testDesc = """FTP the software image and activate it on the radio"""
RemoteStationIP = glob.Configs['RadioIP'].strip().split(',')
TargetRadioIP = glob.Configs['RadioVirtualIP']
serverIp = glob.Configs['RadioFTPServer']
userName = glob.Configs['FTPUserName']
password = glob.Configs['FTPPassword']
targetVersion = glob.Configs['TargetVersion']
manualLock = -1
activeUnit = 2
# Log Test Case Header
print('TESTCASE # %s\n' %TESTCASE)
glob.DlogName = glob.resultsDir + "\\" + TESTCASE + ".log"
logFile(glob.DlogName,"===============================================================\n")
logFile(glob.DlogName,"TESTCASE %s\n\n"%TESTCASE)
print ('#****************************************************************************')
print ('# START OF TEST CASE ')
print ('#****************************************************************************')
result = term.checkIfProtectedUnit (TargetRadioIP)
if (result[0]):
STEP ('Step 1: Set the Software manual Lock\n\n')
result = maint.setSoftwareManualLock(RemoteStationIP[1], manualLock, activeUnit)
validateStep('Set Software Manual on radio %s' %RemoteStationIP[1] , result, TESTCASE)
time.sleep(5)
result = ''
print ('#****************************************************************************')
STEP ('Step 2: FTP the software\n\n')
result = soft.FTPTransfer (RemoteStationIP[1], serverIp, userName, password)
validateStep('FTP the software', result, TESTCASE)
result = ''
print ('#****************************************************************************')
STEP ('Step 3: Set the Software manual Lock\n\n')
activeUnit = 1
result = maint.setSoftwareManualLock(RemoteStationIP[0], manualLock, activeUnit)
validateStep('Set Software Manual on radio %s' %RemoteStationIP[0] , result, TESTCASE)
time.sleep(5)
result = ''
print ('#****************************************************************************')
STEP ('Step 4: FTP the software\n\n')
result = soft.FTPTransfer (RemoteStationIP[0], serverIp, userName, password)
validateStep('FTP the software', result, TESTCASE)
result = ''
print ('#****************************************************************************')
STEP ('Step 5: Disable the Software manual Lock\n\n')
manualLock = 0
result = maint.setSoftwareManualLock(RemoteStationIP[0], manualLock, activeUnit)
validateStep('Set Software Manual on radio %s' %RemoteStationIP[0] , result, TESTCASE)
time.sleep(5)
result = ''
print ('#****************************************************************************')
else:
STEP ('Step 1: FTP the software\n\n')
result = soft.FTPTransfer (TargetRadioIP, serverIp, userName, password)
validateStep('FTP the software', result, TESTCASE)
result = ''
print ('#****************************************************************************')
STEP ('Step 6: Activate the software on each of the remote3 radios\n\n')
# Find if this is a PIPS radio
result = term.checkIfProtectedUnit (TargetRadioIP)
if (result[0]):
# Find the active Unit in this Remote Radio
res = term.getProtectedActiveUnit(TargetRadioIP)
if (res[2] == 1):
# If primary is active unit, then activate the secondary radio
result = soft.SwActivation (RemoteStationIP[1], targetVersion)
validateStep('Activate the software on the secondary unit', result, TESTCASE)
result = ''
# Now activate the software on the primary unit
result = soft.SwActivation (RemoteStationIP[0], targetVersion)
validateStep('Activate the software on the secondary unit', result, TESTCASE)
result = ''
else:
# If secondary is active unit, then activate the primary radio
result = soft.SwActivation (RemoteStationIP[0], targetVersion)
validateStep('Activate the software on the primary unit', result, TESTCASE)
result = ''
# Now activate the software on the secondary unit
result = soft.SwActivation (RemoteStationIP[1], targetVersion)
validateStep('Activate the software on the secondary unit', result, TESTCASE)
result = ''
else:
STEP ('Step 2: Activate the software on each of the remote3 radios\n\n')
result = soft.SwActivation (TargetRadioIP, targetVersion)
validateStep('Activate the software on the Remote3 radio', result, TESTCASE)
result = ''
print ('#****************************************************************************')
except TestException:
testResult = 'FAIL'
pass
else:
testResult = 'PASS'
print ('#****************************************************************************')
print ('# END OF TEST CASE ')
print ('#****************************************************************************')
finish (t1, TESTCASE, testResult)
def TFS_SoftwareUpgrade_002():
try:
t1 = time.localtime()
testResult = ""
result = ""
TESTCASE = "SoftwareUpgrade_002"
glob.testDesc = """FTP the software image to the primary and then do a inter-unit transfer
to the secondary radio and activate the software"""
PIPSStationIP = glob.Configs["PIPSRadioIP"].strip().split(",")
# serverIPList = PIPSStationIP[0].strip().split('.')
# serverIp = serverIPList[0]+'.'+serverIPList[1]+'.'+serverIPList[2]+'.'+'6'
serverIp = glob.Configs["FTPServerIP"]
userName = glob.Configs["FTPUserName"]
password = glob.Configs["FTPPassword"]
targetVersion = glob.Configs["TargetVersion"]
manualLock = -1
activeUnit = 1
# Log Test Case Header
print("TESTCASE # %s\n" % TESTCASE)
glob.DlogName = glob.resultsDir + "\\" + TESTCASE + ".log"
logFile(glob.DlogName, "===============================================================\n")
logFile(glob.DlogName, "TESTCASE %s\n\n" % TESTCASE)
print("#****************************************************************************")
print("# START OF TEST CASE ")
print("#****************************************************************************")
STEP("COMMON: Set the Software manual Lock\n\n")
result = maint.setSoftwareManualLock(PIPSStationIP[0], manualLock, activeUnit)
validateStep("Set Software Manual on radio %s" % PIPSStationIP[0], result, TESTCASE)
manualLockSet = True
result = ""
print("#****************************************************************************")
STEP("Step 1: FTP the software\n\n")
result = soft.FTPTransfer(PIPSStationIP[0], serverIp, userName, password)
validateStep("FTP the software", result, TESTCASE)
result = ""
print("#****************************************************************************")
STEP("Step 2: Do a Inter Unit transfer of the software to secondary\n")
result = soft.InterUnitTransfer(PIPSStationIP[1])
validateStep("Inter Unit Transfer the software", result, TESTCASE)
result = ""
print("#****************************************************************************")
STEP("COMMON: Disable the Software manual Lock\n\n")
manualLock = 0
result = maint.setSoftwareManualLock(PIPSStationIP[0], manualLock, activeUnit)
validateStep("Set Software Manual on radio %s" % PIPSStationIP[0], result, TESTCASE)
manualLockSet = True
result = ""
print("#****************************************************************************")
for i in range(0, len(PIPSStationIP)):
STEP("Step 3: Activate the software on the radio\n\n")
result = soft.SwActivation(PIPSStationIP[i], targetVersion)
validateStep("Activate the software", result, TESTCASE)
result = ""
except TestException:
testResult = "FAIL"
pass
else:
testResult = "PASS"
print("#****************************************************************************")
print("# END OF TEST CASE ")
print("#****************************************************************************")
finish(t1, TESTCASE, testResult)
def TFS_SoftwareUpgrade_003 ():
try:
t1 = time.localtime()
testResult = ''
result = ''
TESTCASE = 'SoftwareUpgrade_003'
glob.testDesc = """FTP the software to the base radio and then redistribute to all
the remote radios and then activate on the remote radios
and then on the base radio."""
TargetRadioIP = []
BaseStationIP = glob.Configs['BaseStationRadioIP'].strip().split(',')
TargetBaseIP = glob.Configs['BaseStationVirtualIP']
RepeaterStation1IP = glob.Configs['RepeaterStation1RadioIP'].strip().split(',')
RepeaterStation2IP = glob.Configs['RepeaterStation2RadioIP'].strip().split(',')
TargetRepeater1IP = glob.Configs['RepeaterStation1VirtualIP']
TargetRepeater2IP = glob.Configs['RepeaterStation2VirtualIP']
RemoteStation1IP = glob.Configs['RemoteStation1RadioIP'].strip().split(',')
RemoteStation2IP = glob.Configs['RemoteStation2RadioIP'].strip().split(',')
RemoteStation3IP = glob.Configs['RemoteStation3RadioIP'].strip().split(',')
TargetRemote1IP = glob.Configs['RemoteStation1VirtualIP']
TargetRemote2IP = glob.Configs['RemoteStation2VirtualIP']
TargetRemote3IP = glob.Configs['RemoteStation3VirtualIP']
TargetRadioIP = TargetRadioIP + BaseStationIP
TargetRadioIP = TargetRadioIP + RepeaterStation1IP
TargetRadioIP = TargetRadioIP + RepeaterStation2IP
TargetRadioIP = TargetRadioIP + RemoteStation1IP
TargetRadioIP = TargetRadioIP + RemoteStation2IP
TargetRadioIP = TargetRadioIP + RemoteStation3IP
serverIp = glob.Configs['FTPServerIP']
userName = glob.Configs['FTPUserName']
password = glob.Configs['FTPPassword']
targetVersion = glob.Configs['TargetVersion']
manualLock = -1
activeUnit = 2
channelSizes = 4
txFrequency = 950056250
rxFrequency = 950093750
rptrTxFrequency = 950093750
rptrRxFrequency = 950056250
rem3TxFrequency = 950093750
rem3RxFrequency = 950056250
txPower = 340 # This denotes txPower as 15dB
txPower_rptr = 340 # This denotes txPower as 20dB
nwRadius = 2
nwProximity = 2 # overlapping Coverage Mode
rpt1NwSeg = 10
rpt2NwSeg = 12
nwTrafficType = 0 # user defined mode
defaultTtl = 0
serialTtl = 0
srlPrtCfgMode = 1
flowCtrl = 1 # sets the flow control to CTS-RTS
mtuSize = 512
baseTermOpMode = 1 # sets operMOde as Base
rptrTermOpMode = 2 # sets operMode as Repeater
remoteOperMode = 3 # sets operMode as Remote
etherMode = 1
# Log Test Case Header
print('TESTCASE # %s\n' %TESTCASE)
glob.DlogName = glob.resultsDir + "\\" + TESTCASE + ".log"
logFile(glob.DlogName,"===============================================================\n")
logFile(glob.DlogName,"TESTCASE %s\n\n"%TESTCASE)
print ('#****************************************************************************')
print ('# COMMON TEST SETUP ')
print ('#****************************************************************************')
for i in range(0,len(BaseStationIP)):
STEP('COMMON: Configure PIPS Radio as Base Station\n\n')
result = term.setTerminalOperMode(BaseStationIP[i], baseTermOpMode, etherMode)
validateStep('Configure DUT1: %s Radio as Base Station\n\n' %BaseStationIP[i], result, TESTCASE)
result = ''
print ('#****************************************************************************')
STEP ('COMMON: Configure the single Tx and Rx Frequency on all radios\n\n')
print ('TargetRadio: %s' %BaseStationIP[i])
result = rad.setTxSettings (BaseStationIP[i], txFrequency,txPower)
validateStep('Set the Tx Frequency on radio %s' %BaseStationIP[i] , result, TESTCASE)
result = ''
# Set the Rx Frequency on the radios
result = rad.setRxSettings (BaseStationIP[i], rxFrequency)
validateStep('Set the Rx Frequency on radio %s' %BaseStationIP[i] , result, TESTCASE)
result = ''
print ('#****************************************************************************')
STEP ('COMMON: Set the network Radius and Network Proximity\n\n')
result = term.setRFNetworkDetails(BaseStationIP[i], nwRadius, nwProximity)
validateStep('Set Network Radius and Network Proximity on radio %s' %BaseStationIP[i] , result, TESTCASE)
result = ''
print ('#****************************************************************************')
STEP('COMMON: Configure Channel Size on the All the Radios\n\n')
result = rad.setRadioChannelSize(BaseStationIP[i], channelSizes)
validateStep('Configure Channel Size as %s on %s Radio \n\n' %(channelSizes,BaseStationIP[i]), result, TESTCASE)
result = ''
print ('#****************************************************************************')
# Reboot the radio for the configuration to take effect
STEP ("COMMON: Reboot the DUT\n\n")
result = maint.rebootRadio(BaseStationIP[i], 1)
validateStep('Reboot the radio %s after 5 secs' %BaseStationIP[i] , result, TESTCASE)
result = ''
print ('#****************************************************************************')
for i in range(0,len(RepeaterStation1IP)):
STEP('COMMON: Configure PIPS Radio as Repeater Station 1\n\n')
result = term.setTerminalOperMode(RepeaterStation1IP[i], rptrTermOpMode, etherMode)
validateStep('Configure DUT1: %s Radio as Repeater Station 1\n\n' %RepeaterStation1IP[i], result, TESTCASE)
result = ''
print ('#****************************************************************************')
STEP ('COMMON: Configure the single Tx and Rx Frequency on all radios\n\n')
print ('TargetRadio: %s' %RepeaterStation1IP[i])
result = rad.setTxSettings (RepeaterStation1IP[i], rptrTxFrequency, txPower_rptr)
validateStep('Set the Tx Frequency on radio %s' %RepeaterStation1IP[i] , result, TESTCASE)
result = ''
# Set the Rx Frequency on the radios
result = rad.setRxSettings (RepeaterStation1IP[i], rptrRxFrequency)
validateStep('Set the Rx Frequency on radio %s' %RepeaterStation1IP[i] , result, TESTCASE)
result = ''
print ('#****************************************************************************')
STEP ('COMMON: Set the network Radius and Network Proximity\n\n')
result = term.setRFNetworkDetails(RepeaterStation1IP[i], nwRadius, nwProximity, rpt1NwSeg)
validateStep('Set Network Radius and Network Proximity on radio %s' %RepeaterStation1IP[i] , result, TESTCASE)
result = ''
print ('#****************************************************************************')
STEP('COMMON: Configure Channel Size on the All the Radios\n\n')
result = rad.setRadioChannelSize(RepeaterStation1IP[i], channelSizes)
validateStep('Configure Channel Size as %s on %s Radio \n\n' %(channelSizes,RepeaterStation1IP[i]), result, TESTCASE)
result = ''
print ('#****************************************************************************')
# Reboot the radio for the configuration to take effect
STEP ("COMMON: Reboot the DUT\n\n")
result = maint.rebootRadio(RepeaterStation1IP[i], 1)
validateStep('Reboot the radio %s after 5 secs' %RepeaterStation1IP[i] , result, TESTCASE)
result = ''
print ('#****************************************************************************')
for i in range(0,len(RepeaterStation2IP)):
STEP('COMMON: Configure PIPS Radio as Repeater Station 1\n\n')
result = term.setTerminalOperMode(RepeaterStation2IP[i], rptrTermOpMode, etherMode)
validateStep('Configure DUT1: %s Radio as Repeater Station 1\n\n' %RepeaterStation2IP[i], result, TESTCASE)
result = ''
print ('#****************************************************************************')
STEP ('COMMON: Configure the single Tx and Rx Frequency on all radios\n\n')
print ('TargetRadio: %s' %RepeaterStation2IP[i])
result = rad.setTxSettings (RepeaterStation2IP[i], rptrTxFrequency, txPower)
validateStep('Set the Tx Frequency on radio %s' %RepeaterStation2IP[i] , result, TESTCASE)
result = ''
# Set the Rx Frequency on the radios
result = rad.setRxSettings (RepeaterStation2IP[i], rptrRxFrequency)
validateStep('Set the Rx Frequency on radio %s' %RepeaterStation2IP[i] , result, TESTCASE)
result = ''
print ('#****************************************************************************')
STEP ('COMMON: Set the network Radius and Network Proximity\n\n')
result = term.setRFNetworkDetails(RepeaterStation2IP[i], nwRadius, nwProximity, rpt2NwSeg)
validateStep('Set Network Radius and Network Proximity on radio %s' %RepeaterStation2IP[i] , result, TESTCASE)
result = ''
print ('#****************************************************************************')
STEP('COMMON: Configure Channel Size on the All the Radios\n\n')
result = rad.setRadioChannelSize(RepeaterStation2IP[i], channelSizes)
validateStep('Configure Channel Size as %s on %s Radio \n\n' %(channelSizes,RepeaterStation2IP[i]), result, TESTCASE)
result = ''
print ('#****************************************************************************')
# Reboot the radio for the configuration to take effect
STEP ("COMMON: Reboot the DUT\n\n")
result = maint.rebootRadio(RepeaterStation2IP[i], 1)
validateStep('Reboot the radio %s after 5 secs' %RepeaterStation2IP[i] , result, TESTCASE)
result = ''
print ('#****************************************************************************')
for i in range(0,len(RemoteStation1IP)):
STEP('COMMON: Configure Radio as Remote Station\n\n')
result = term.setTerminalOperMode(RemoteStation1IP[i], remoteOperMode, etherMode)
validateStep('Configure DUT1: %s Radio as Remote Station\n\n' %RemoteStation1IP[i], result, TESTCASE)
result = ''
print ('#****************************************************************************')
STEP ('COMMON: Set the network Radius and Network Proximity\n\n')
result = term.setRFNetworkDetails(RemoteStation1IP[i], nwRadius, nwProximity, rpt1NwSeg)
validateStep('Set Network Radius and Network Proximity on radio %s' %RemoteStation1IP[i] , result, TESTCASE)
result = ''
print ('#****************************************************************************')
STEP ('COMMON: Configure the single Tx and Rx Frequency on all radios\n\n')
print ('TargetRadio: %s' %RemoteStation1IP[i])
result = rad.setTxSettings (RemoteStation1IP[i], txFrequency, txPower)
validateStep('Set the Tx Frequency on radio %s' %RemoteStation1IP[i] , result, TESTCASE)
result = ''
# Set the Rx Frequency on the radios
result = rad.setRxSettings (RemoteStation1IP[i], rxFrequency)
validateStep('Set the Rx Frequency on radio %s' %RemoteStation1IP[i] , result, TESTCASE)
result = ''
print ('#****************************************************************************')
STEP('COMMON: Configure Channel Size on the All the Radios\n\n')
result = rad.setRadioChannelSize(RemoteStation1IP[i], channelSizes)
validateStep('Configure Channel Size as %s on %s Radio \n\n' %(channelSizes,RemoteStation1IP[i]), result, TESTCASE)
result = ''
print ('#****************************************************************************')
# Reboot the radio for the configuration to take effect
STEP ("COMMON: Reboot the DUT\n\n")
result = maint.rebootRadio(RemoteStation1IP[i], 1)
validateStep('Reboot the radio %s after 5 secs' %RemoteStation1IP[i] , result, TESTCASE)
result = ''
print ('#****************************************************************************')
for i in range(0,len(RemoteStation2IP)):
STEP('COMMON: Configure Radio as Remote Station\n\n')
result = term.setTerminalOperMode(RemoteStation2IP[i], remoteOperMode, etherMode)
validateStep('Configure DUT1: %s Radio as Remote Station\n\n' %RemoteStation2IP[i], result, TESTCASE)
result = ''
print ('#****************************************************************************')
STEP ('COMMON: Set the network Radius and Network Proximity\n\n')
result = term.setRFNetworkDetails(RemoteStation2IP[i], nwRadius, nwProximity, rpt2NwSeg)
validateStep('Set Network Radius and Network Proximity on radio %s' %RemoteStation2IP[i] , result, TESTCASE)
result = ''
STEP ('COMMON: Configure the single Tx and Rx Frequency on all radios\n\n')
print ('TargetRadio: %s' %RemoteStation2IP[i])
result = rad.setTxSettings (RemoteStation2IP[i], txFrequency, txPower)
validateStep('Set the Tx Frequency on radio %s' %RemoteStation2IP[i] , result, TESTCASE)
result = ''
# Set the Rx Frequency on the radios
result = rad.setRxSettings (RemoteStation2IP[i], rxFrequency)
validateStep('Set the Rx Frequency on radio %s' %RemoteStation2IP[i] , result, TESTCASE)
result = ''
print ('#****************************************************************************')
STEP('COMMON: Configure Channel Size on the All the Radios\n\n')
result = rad.setRadioChannelSize(RemoteStation2IP[i], channelSizes)
validateStep('Configure Channel Size as %s on %s Radio \n\n' %(channelSizes,RemoteStation2IP[i]), result, TESTCASE)
result = ''
print ('#****************************************************************************')
# Reboot the radio for the configuration to take effect
STEP ("COMMON: Reboot the DUT\n\n")
result = maint.rebootRadio(RemoteStation2IP[i], 1)
validateStep('Reboot the radio %s after 5 secs' %RemoteStation2IP[i] , result, TESTCASE)
result = ''
print ('#****************************************************************************')
for i in range(0,len(RemoteStation3IP)):
STEP('COMMON: Configure Radio as Remote Station\n\n')
result = term.setTerminalOperMode(RemoteStation3IP[i], remoteOperMode, etherMode)
validateStep('Configure DUT1: %s Radio as Remote Station\n\n' %RemoteStation3IP[i], result, TESTCASE)
result = ''
print ('#****************************************************************************')
STEP ('COMMON: Set the network Radius and Network Proximity\n\n')
result = term.setRFNetworkDetails(RemoteStation3IP[i], nwRadius, nwProximity)
validateStep('Set Network Radius and Network Proximity on radio %s' %RemoteStation3IP[i] , result, TESTCASE)
result = ''
STEP ('COMMON: Configure the single Tx and Rx Frequency on all radios\n\n')
print ('TargetRadio: %s' %RemoteStation3IP[i])
result = rad.setTxSettings (RemoteStation3IP[i], rem3TxFrequency, txPower)
validateStep('Set the Tx Frequency on radio %s' %RemoteStation3IP[i] , result, TESTCASE)
result = ''
# Set the Rx Frequency on the radios
result = rad.setRxSettings (RemoteStation3IP[i], rem3RxFrequency)
validateStep('Set the Rx Frequency on radio %s' %RemoteStation3IP[i] , result, TESTCASE)
result = ''
print ('#****************************************************************************')
STEP('COMMON: Configure Channel Size on the All the Radios\n\n')
result = rad.setRadioChannelSize(RemoteStation3IP[i], channelSizes)
validateStep('Configure Channel Size as %s on %s Radio \n\n' %(channelSizes,RemoteStation3IP[i]), result, TESTCASE)
result = ''
print ('#****************************************************************************')
# Reboot the radio for the configuration to take effect
STEP ("COMMON: Reboot the DUT\n\n")
result = maint.rebootRadio(RemoteStation3IP[i], 1)
validateStep('Reboot the radio %s after 5 secs' %RemoteStation3IP[i] , result, TESTCASE)
result = ''
print ('#****************************************************************************')
print ('#****************************************************************************')
print ('# START OF TEST CASE ')
print ('#****************************************************************************')
# Find if Base is a protected Unit
result = term.checkIfProtectedUnit (TargetBaseIP)
if (result[0]):
# Find the active Unit in this Remote Radio
STEP ('Step 1: Perform a software manual lock to seconndary unit on Base Radio')
result = maint.setSoftwareManualLock(BaseStationIP[1], manualLock, activeUnit)
validateStep('Set Software Manual on radio %s' %BaseStationIP[1] , result, TESTCASE)
result = ''
time.sleep(5)
print ('#****************************************************************************')
STEP ('Step 2: FTP the software to secondary radio\n\n')
result = soft.FTPTransfer (BaseStationIP[1], serverIp, userName, password)
validateStep('FTP the software', result, TESTCASE)
result = ''
print ('#****************************************************************************')
STEP ('Step 3: Perform a software manual lock to primary unit on Base Radio')
activeUnit = 1
result = maint.setSoftwareManualLock(BaseStationIP[0], manualLock, activeUnit)
validateStep('Set Software Manual on radio %s' %BaseStationIP[0] , result, TESTCASE)
time.sleep(5)
result = ''
print ('#****************************************************************************')
STEP ('Step 4: FTP the software to primary radio\n\n')
result = soft.FTPTransfer (BaseStationIP[0], serverIp, userName, password)
validateStep('FTP the software', result, TESTCASE)
result = ''
print ('#****************************************************************************')
STEP ('Step 5: Disable the Software manual Lock\n\n')
manualLock = 0
result = maint.setSoftwareManualLock(BaseStationIP[0], manualLock, activeUnit)
validateStep('Set Software Manual on radio %s' %BaseStationIP[0] , result, TESTCASE)
result = ''
print ('#****************************************************************************')
else:
STEP ('Step 2: FTP the software to Base radio\n\n')
result = soft.FTPTransfer (TargetBaseIP, serverIp, userName, password)
validateStep('FTP the software', result, TESTCASE)
result = ''
print ('#****************************************************************************')
STEP ('Step 6: Do a Remote Distribute to all the radios\n\n')
result = soft.BaseDistribute (BaseStationIP[0])
validateStep('Remote Distribute the software the software', result, TESTCASE)
result = ''
print ('#****************************************************************************')
STEP ('Step 6a: Do a InterUnit Transfer to the standby radios for PIPS Remote1')
# Find if this is a PIPS radio
result = term.checkIfProtectedUnit (TargetRemote1IP)
if (result[0]):
# Find the active Unit in this Remote Radio
res = term.getProtectedActiveUnit(TargetRemote1IP)
if (res[2] == 1):
# Set the software manual lock to the active unit and then do the
# Inter Unit Transfer
manualLock = -1
activeUnit = 1
result = maint.setSoftwareManualLock(RemoteStation1IP[0], manualLock, activeUnit)
validateStep('Set Software Manual on radio %s' %RemoteStation1IP[0] , result, TESTCASE)
result = ''
# Do a Inter Unit Transfer
result = soft.InterUnitTransfer (RemoteStation1IP[1])
validateStep('Inter Unit Transfer the software', result, TESTCASE)
result = ''
# Disable the software manual lock
manualLock = 0
result = maint.setSoftwareManualLock(RemoteStation1IP[0], manualLock, activeUnit)
validateStep('Set Software Manual on radio %s' %RemoteStation1IP[0] , result, TESTCASE)
result = ''
else:
# Set the software manual lock to the active unit and then do the
# Inter Unit Transfer
manualLock = -1
activeUnit = 2
result = maint.setSoftwareManualLock(RemoteStation1IP[1], manualLock, activeUnit)
validateStep('Set Software Manual on radio %s' %RemoteStation1IP[1] , result, TESTCASE)
result = ''
# Do a Inter Unit Transfer
result = soft.InterUnitTransfer (RemoteStation1IP[0])
validateStep('Inter Unit Transfer the software', result, TESTCASE)
result = ''
# Disable the software manual lock
manualLock = 0
result = maint.setSoftwareManualLock(RemoteStation1IP[1], manualLock, activeUnit)
validateStep('Set Software Manual on radio %s' %RemoteStation1IP[1] , result, TESTCASE)
result = ''
print ('#****************************************************************************')
STEP ('Step 6b: Do a InterUnit Transfer to the standby radios for PIPS Repeater1')
# Find if this is a PIPS radio
result = term.checkIfProtectedUnit (TargetRepeater1IP)
if (result[0]):
# Find the active Unit in this Repeater Radio
res = term.getProtectedActiveUnit(TargetRepeater1IP)
if (res[2] == 1):
# Set the software manual lock to the active unit and then do the
# Inter Unit Transfer
manualLock = -1
activeUnit = 1
result = maint.setSoftwareManualLock(RepeaterStation1IP[0], manualLock, activeUnit)
validateStep('Set Software Manual on radio %s' %RepeaterStation1IP[0] , result, TESTCASE)
result = ''
# Do a Inter Unit Transfer
result = soft.InterUnitTransfer (RepeaterStation1IP[1])
validateStep('Inter Unit Transfer the software', result, TESTCASE)
result = ''
# Disable the software manual lock
manualLock = 0
result = maint.setSoftwareManualLock(RepeaterStation1IP[0], manualLock, activeUnit)
validateStep('Set Software Manual on radio %s' %RepeaterStation1IP[0] , result, TESTCASE)
result = ''
else:
# Set the software manual lock to the active unit and then do the
# Inter Unit Transfer
manualLock = -1
activeUnit = 2
result = maint.setSoftwareManualLock(RepeaterStation1IP[1], manualLock, activeUnit)
validateStep('Set Software Manual on radio %s' %RepeaterStation1IP[1] , result, TESTCASE)
result = ''
# Do a Inter Unit Transfer
result = soft.InterUnitTransfer (RepeaterStation1IP[0])
validateStep('Inter Unit Transfer the software', result, TESTCASE)
result = ''
# Disable the software manual lock
manualLock = 0
result = maint.setSoftwareManualLock(RepeaterStation1IP[1], manualLock, activeUnit)
validateStep('Set Software Manual on radio %s' %RepeaterStation1IP[1] , result, TESTCASE)
result = ''
print ('#****************************************************************************')
STEP ('Step 7: Activate the software on each of the remote radios\n\n')
# Find if this is a PIPS radio
result = term.checkIfProtectedUnit (TargetRemote1IP)
if (result[0]):
# Find the active Unit in this Remote Radio
res = term.getProtectedActiveUnit(TargetRemote1IP)
if (res[2] == 1):
# If primary is active unit, then activate the secondary radio
result = soft.SwActivation (RemoteStation1IP[1], targetVersion)
validateStep('Activate the software on the secondary unit', result, TESTCASE)
result = ''
# Now activate the software on the primary unit
result = soft.SwActivation (RemoteStation1IP[0], targetVersion)
validateStep('Activate the software on the secondary unit', result, TESTCASE)
result = ''
else:
# If secondary is active unit, then activate the primary radio
result = soft.SwActivation (RemoteStation1IP[0], targetVersion)
validateStep('Activate the software on the primary unit', result, TESTCASE)
result = ''
# Now activate the software on the secondary unit
result = soft.SwActivation (RemoteStation1IP[1], targetVersion)
validateStep('Activate the software on the secondary unit', result, TESTCASE)
result = ''
else:
result = soft.SwActivation (TargetRemote1IP, targetVersion)
validateStep('Activate the software on the Remote1 radio', result, TESTCASE)
result = ''
print ('#****************************************************************************')
STEP ('Step 8: Activate the software on each of the remote2 radios\n\n')
# Find if this is a PIPS radio
result = term.checkIfProtectedUnit (TargetRemote2IP)
if (result[0]):
# Find the active Unit in this Remote Radio
res = term.getProtectedActiveUnit(TargetRemote2IP)
if (res[2] == 1):
# If primary is active unit, then activate the secondary radio
result = soft.SwActivation (RemoteStation2IP[1], targetVersion)
validateStep('Activate the software on the secondary unit', result, TESTCASE)
result = ''
# Now activate the software on the primary unit
result = soft.SwActivation (RemoteStation2IP[0], targetVersion)
validateStep('Activate the software on the secondary unit', result, TESTCASE)
result = ''
else:
# If secondary is active unit, then activate the primary radio
result = soft.SwActivation (RemoteStation2IP[0], targetVersion)
validateStep('Activate the software on the primary unit', result, TESTCASE)
result = ''
# Now activate the software on the secondary unit
result = soft.SwActivation (RemoteStation2IP[1], targetVersion)
validateStep('Activate the software on the secondary unit', result, TESTCASE)
result = ''
else:
result = soft.SwActivation (TargetRemote2IP, targetVersion)
validateStep('Activate the software on the Remote2 radio', result, TESTCASE)
result = ''
print ('#****************************************************************************')
STEP ('Step 9: Activate the software on each of the remote3 radios\n\n')
# Find if this is a PIPS radio
result = term.checkIfProtectedUnit (TargetRemote3IP)
if (result[0]):
# Find the active Unit in this Remote Radio
res = term.getProtectedActiveUnit(TargetRemote3IP)
if (res[2] == 1):
# If primary is active unit, then activate the secondary radio
result = soft.SwActivation (RemoteStation3IP[1], targetVersion)
validateStep('Activate the software on the secondary unit', result, TESTCASE)
result = ''
# Now activate the software on the primary unit
result = soft.SwActivation (RemoteStation3IP[0], targetVersion)
validateStep('Activate the software on the secondary unit', result, TESTCASE)
result = ''
else:
# If secondary is active unit, then activate the primary radio
result = soft.SwActivation (RemoteStation3IP[0], targetVersion)
validateStep('Activate the software on the primary unit', result, TESTCASE)
result = ''
# Now activate the software on the secondary unit
result = soft.SwActivation (RemoteStation3IP[1], targetVersion)
validateStep('Activate the software on the secondary unit', result, TESTCASE)
result = ''
else:
result = soft.SwActivation (TargetRemote3IP, targetVersion)
validateStep('Activate the software on the Remote3 radio', result, TESTCASE)
result = ''
print ('#****************************************************************************')
STEP ('Step 10: Activate the software on each of the Repeater1 radios\n\n')
# Find if this is a PIPS radio
result = term.checkIfProtectedUnit (TargetRepeater1IP)
if (result[0]):
# Find the active Unit in this Remote Radio
res = term.getProtectedActiveUnit(TargetRepeater1IP)
if (res[2] == 1):
# If primary is active unit, then activate the secondary radio
result = soft.SwActivation (RepeaterStation1IP[1], targetVersion)
validateStep('Activate the software on the secondary unit', result, TESTCASE)
result = ''
# Now activate the software on the primary unit
result = soft.SwActivation (RepeaterStation1IP[0], targetVersion)
validateStep('Activate the software on the secondary unit', result, TESTCASE)
result = ''
else:
# If secondary is active unit, then activate the primary radio
result = soft.SwActivation (RepeaterStation1IP[0], targetVersion)
validateStep('Activate the software on the primary unit', result, TESTCASE)
result = ''
# Now activate the software on the secondary unit
result = soft.SwActivation (RepeaterStation1IP[1], targetVersion)
validateStep('Activate the software on the secondary unit', result, TESTCASE)
result = ''
else:
result = soft.SwActivation (TargetRepeater1IP, targetVersion)
validateStep('Activate the software on the Repeater1 radio', result, TESTCASE)
result = ''
print ('#****************************************************************************')
STEP ('Step 11: Activate the software on each of the Repeater2 radios\n\n')
# Find if this is a PIPS radio
result = term.checkIfProtectedUnit (TargetRepeater2IP)
if (result[0]):
# Find the active Unit in this Remote Radio
res = term.getProtectedActiveUnit(TargetRepeater2IP)
if (res[2] == 1):
# If primary is active unit, then activate the secondary radio
result = soft.SwActivation (RepeaterStation2IP[1], targetVersion)
validateStep('Activate the software on the secondary unit', result, TESTCASE)
result = ''
# Now activate the software on the primary unit
result = soft.SwActivation (RepeaterStation2IP[0], targetVersion)
validateStep('Activate the software on the secondary unit', result, TESTCASE)
result = ''
else:
# If secondary is active unit, then activate the primary radio
result = soft.SwActivation (RepeaterStation2IP[0], targetVersion)
validateStep('Activate the software on the primary unit', result, TESTCASE)
result = ''
# Now activate the software on the secondary unit
result = soft.SwActivation (RepeaterStation2IP[1], targetVersion)
validateStep('Activate the software on the secondary unit', result, TESTCASE)
result = ''
else:
result = soft.SwActivation (TargetRepeater2IP, targetVersion)
validateStep('Activate the software on the Repeater2 radio', result, TESTCASE)
result = ''
print ('#****************************************************************************')
STEP ('Step 11: Activate the software on each of the Base radios\n\n')
# Find if this is a PIPS radio
result = term.checkIfProtectedUnit (TargetBaseIP)
if (result[0]):
# Find the active Unit in this Remote Radio
res = term.getProtectedActiveUnit(TargetBaseIP)
if (res[2] == 1):
# If primary is active unit, then activate the secondary radio
result = soft.SwActivation (BaseStationIP[1], targetVersion)
validateStep('Activate the software on the secondary unit', result, TESTCASE)
result = ''
# Now activate the software on the primary unit
result = soft.SwActivation (BaseStationIP[0], targetVersion)
validateStep('Activate the software on the secondary unit', result, TESTCASE)
result = ''
else:
# If secondary is active unit, then activate the primary radio
result = soft.SwActivation (BaseStationIP[0], targetVersion)
validateStep('Activate the software on the primary unit', result, TESTCASE)
result = ''
# Now activate the software on the secondary unit
result = soft.SwActivation (BaseStationIP[1], targetVersion)
validateStep('Activate the software on the secondary unit', result, TESTCASE)
result = ''
else:
result = soft.SwActivation (TargetBaseIP, targetVersion)
validateStep('Activate the software on the Base radio', result, TESTCASE)
result = ''
print ('#****************************************************************************')
except TestException:
testResult = 'FAIL'
pass
else:
testResult = 'PASS'
finally:
print ('\n#****************************************************************************')
print ('# CLEANUP SECTION ')
print ('#****************************************************************************')
for i in range (0,len(TargetRadioIP)):
# ******************************************************************
STEP ('CLEANUP: Restore the DUTs to User Defaults\n\n')
result = maint.restoreUserDefaults (TargetRadioIP[i], 1)
validateStep('Restoring User Defaults on %s\n\n' %TargetRadioIP[i], result, TESTCASE)
result = ''
print ('#****************************************************************************')
print ('# END OF TEST CASE ')
print ('#****************************************************************************')
finish (t1, TESTCASE, testResult)
