diff --git a/DataModel_requirement.cfg b/DataModel_requirement.cfg
new file mode 100644
index 0000000..1f0dac6
--- /dev/null
+++ b/DataModel_requirement.cfg
@@ -0,0 +1,279 @@
+Device.DeviceInfo.AdditionalHardwareVersion
+Device.DeviceInfo.AdditionalSoftwareVersion
+Device.DeviceInfo.Description
+Device.DeviceInfo.HardwareVersion
+Device.DeviceInfo.Manufacturer
+Device.DeviceInfo.ManufacturerOUI
+Device.DeviceInfo.MemoryStatus.Free
+Device.DeviceInfo.MemoryStatus.Total
+Device.DeviceInfo.ModelName
+Device.DeviceInfo.ProcessStatus.CPUUsage
+Device.DeviceInfo.ProcessStatus.Process.{i}.CPUTime
+Device.DeviceInfo.ProcessStatus.Process.{i}.Command
+Device.DeviceInfo.ProcessStatus.Process.{i}.PID
+Device.DeviceInfo.ProcessStatus.Process.{i}.Priority
+Device.DeviceInfo.ProcessStatus.Process.{i}.Size
+Device.DeviceInfo.ProcessStatus.Process.{i}.State
+Device.DeviceInfo.ProcessStatus.ProcessNumberOfEntries
+Device.DeviceInfo.ProcessorNumberOfEntries
+Device.DeviceInfo.ProductClass
+Device.DeviceInfo.SerialNumber
+Device.DeviceInfo.SoftwareVersion
+Device.DeviceInfo.SupportedDataModelNumberOfEntries
+Device.DeviceInfo.TemperatureStatus.TemperatureSensorNumberOfEntries
+Device.DeviceInfo.UpTime
+Device.DeviceInfo.VendorConfigFileNumberOfEntries
+Device.DeviceInfo.VendorLogFileNumberOfEntries
+Device.Ethernet.Interface.{i}.DuplexMode
+Device.Ethernet.Interface.{i}.Enable
+Device.Ethernet.Interface.{i}.LastChange
+Device.Ethernet.Interface.{i}.LowerLayers
+Device.Ethernet.Interface.{i}.MACAddress
+Device.Ethernet.Interface.{i}.MaxBitRate
+Device.Ethernet.Interface.{i}.Name
+Device.Ethernet.Interface.{i}.Stats.BroadcastPacketsReceived
+Device.Ethernet.Interface.{i}.Stats.BroadcastPacketsSent
+Device.Ethernet.Interface.{i}.Stats.BytesReceived
+Device.Ethernet.Interface.{i}.Stats.BytesSent
+Device.Ethernet.Interface.{i}.Stats.DiscardPacketsReceived
+Device.Ethernet.Interface.{i}.Stats.DiscardPacketsSent
+Device.Ethernet.Interface.{i}.Stats.ErrorsReceived
+Device.Ethernet.Interface.{i}.Stats.ErrorsSent
+Device.Ethernet.Interface.{i}.Stats.MulticastPacketsReceived
+Device.Ethernet.Interface.{i}.Stats.MulticastPacketsSent
+Device.Ethernet.Interface.{i}.Stats.PacketsReceived
+Device.Ethernet.Interface.{i}.Stats.PacketsSent
+Device.Ethernet.Interface.{i}.Stats.UnicastPacketsReceived
+Device.Ethernet.Interface.{i}.Stats.UnicastPacketsSent
+Device.Ethernet.Interface.{i}.Stats.UnknownProtoPacketsReceived
+Device.Ethernet.Interface.{i}.Status
+Device.Ethernet.Interface.{i}.Upstream
+Device.Ethernet.Interface.{i}.X_CATAWAMPUS-ORG_ActualBitRate
+Device.Ethernet.Interface.{i}.X_CATAWAMPUS-ORG_ActualDuplexMode
+Device.Ethernet.InterfaceNumberOfEntries
+Device.Ethernet.LinkNumberOfEntries
+Device.Ethernet.VLANTerminationNumberOfEntries
+Device.InterfaceStackNumberOfEntries
+Device.ManagementServer.CWMPRetryIntervalMultiplier
+Device.ManagementServer.CWMPRetryMinimumWaitInterval
+Device.ManagementServer.ConnectionRequestPassword
+Device.ManagementServer.ConnectionRequestURL
+Device.ManagementServer.ConnectionRequestUsername
+Device.ManagementServer.DefaultActiveNotificationThrottle
+Device.ManagementServer.EnableCWMP
+Device.ManagementServer.ManageableDeviceNumberOfEntries
+Device.ManagementServer.ParameterKey
+Device.ManagementServer.Password
+Device.ManagementServer.PeriodicInformEnable
+Device.ManagementServer.PeriodicInformInterval
+Device.ManagementServer.PeriodicInformTime
+Device.ManagementServer.STUNEnable
+Device.ManagementServer.URL
+Device.ManagementServer.UpgradesManaged
+Device.ManagementServer.Username
+Device.MoCA.Interface.{i}.AssociatedDevice.{i}.MACAddress
+Device.MoCA.Interface.{i}.AssociatedDevice.{i}.NodeID
+Device.MoCA.Interface.{i}.AssociatedDevice.{i}.PHYRxRate
+Device.MoCA.Interface.{i}.AssociatedDevice.{i}.PHYTxRate
+Device.MoCA.Interface.{i}.AssociatedDevice.{i}.PacketAggregationCapability
+Device.MoCA.Interface.{i}.AssociatedDevice.{i}.PreferredNC
+Device.MoCA.Interface.{i}.AssociatedDevice.{i}.QAM256Capable
+Device.MoCA.Interface.{i}.AssociatedDevice.{i}.RxBcastPowerLevel
+Device.MoCA.Interface.{i}.AssociatedDevice.{i}.RxErroredAndMissedPackets
+Device.MoCA.Interface.{i}.AssociatedDevice.{i}.RxPackets
+Device.MoCA.Interface.{i}.AssociatedDevice.{i}.RxPowerLevel
+Device.MoCA.Interface.{i}.AssociatedDevice.{i}.RxSNR
+Device.MoCA.Interface.{i}.AssociatedDevice.{i}.TxBcastRate
+Device.MoCA.Interface.{i}.AssociatedDevice.{i}.TxPackets
+Device.MoCA.Interface.{i}.AssociatedDevice.{i}.TxPowerControlReduction
+Device.MoCA.Interface.{i}.AssociatedDeviceNumberOfEntries
+Device.MoCA.Interface.{i}.BackupNC
+Device.MoCA.Interface.{i}.CurrentOperFreq
+Device.MoCA.Interface.{i}.CurrentVersion
+Device.MoCA.Interface.{i}.Enable
+Device.MoCA.Interface.{i}.FirmwareVersion
+Device.MoCA.Interface.{i}.HighestVersion
+Device.MoCA.Interface.{i}.LastChange
+Device.MoCA.Interface.{i}.LastOperFreq
+Device.MoCA.Interface.{i}.LowerLayers
+Device.MoCA.Interface.{i}.MACAddress
+Device.MoCA.Interface.{i}.Name
+Device.MoCA.Interface.{i}.NetworkCoordinator
+Device.MoCA.Interface.{i}.NodeID
+Device.MoCA.Interface.{i}.PacketAggregationCapability
+Device.MoCA.Interface.{i}.PrivacyEnabled
+Device.MoCA.Interface.{i}.QAM256Capable
+Device.MoCA.Interface.{i}.Stats.BroadcastPacketsReceived
+Device.MoCA.Interface.{i}.Stats.BroadcastPacketsSent
+Device.MoCA.Interface.{i}.Stats.BytesReceived
+Device.MoCA.Interface.{i}.Stats.BytesSent
+Device.MoCA.Interface.{i}.Stats.DiscardPacketsReceived
+Device.MoCA.Interface.{i}.Stats.DiscardPacketsSent
+Device.MoCA.Interface.{i}.Stats.ErrorsReceived
+Device.MoCA.Interface.{i}.Stats.ErrorsSent
+Device.MoCA.Interface.{i}.Stats.MulticastPacketsReceived
+Device.MoCA.Interface.{i}.Stats.MulticastPacketsSent
+Device.MoCA.Interface.{i}.Stats.PacketsReceived
+Device.MoCA.Interface.{i}.Stats.PacketsSent
+Device.MoCA.Interface.{i}.Stats.UnicastPacketsReceived
+Device.MoCA.Interface.{i}.Stats.UnicastPacketsSent
+Device.MoCA.Interface.{i}.Stats.UnknownProtoPacketsReceived
+Device.MoCA.Interface.{i}.Status
+Device.MoCA.Interface.{i}.Upstream
+Device.MoCA.InterfaceNumberOfEntries
+Device.PeriodicStatistics.MaxReportSamples
+Device.PeriodicStatistics.MinSampleInterval
+Device.PeriodicStatistics.SampleSet.{i}.Enable
+Device.PeriodicStatistics.SampleSet.{i}.FetchSamples
+Device.PeriodicStatistics.SampleSet.{i}.Name
+Device.PeriodicStatistics.SampleSet.{i}.Parameter.{i}.CalculationMode
+Device.PeriodicStatistics.SampleSet.{i}.Parameter.{i}.Enable
+Device.PeriodicStatistics.SampleSet.{i}.Parameter.{i}.Failures
+Device.PeriodicStatistics.SampleSet.{i}.Parameter.{i}.HighThreshold
+Device.PeriodicStatistics.SampleSet.{i}.Parameter.{i}.LowThreshold
+Device.PeriodicStatistics.SampleSet.{i}.Parameter.{i}.Reference
+Device.PeriodicStatistics.SampleSet.{i}.Parameter.{i}.SampleMode
+Device.PeriodicStatistics.SampleSet.{i}.Parameter.{i}.SampleSeconds
+Device.PeriodicStatistics.SampleSet.{i}.Parameter.{i}.SuspectData
+Device.PeriodicStatistics.SampleSet.{i}.Parameter.{i}.Values
+Device.PeriodicStatistics.SampleSet.{i}.ParameterNumberOfEntries
+Device.PeriodicStatistics.SampleSet.{i}.ReportEndTime
+Device.PeriodicStatistics.SampleSet.{i}.ReportSamples
+Device.PeriodicStatistics.SampleSet.{i}.ReportStartTime
+Device.PeriodicStatistics.SampleSet.{i}.SampleInterval
+Device.PeriodicStatistics.SampleSet.{i}.SampleSeconds
+Device.PeriodicStatistics.SampleSet.{i}.Status
+Device.PeriodicStatistics.SampleSet.{i}.TimeReference
+Device.PeriodicStatistics.SampleSetNumberOfEntries
+Device.Services.STBService.{i}.Components.FrontEnd.{i}.IP.IGMP.ClientGroup.{i}.GroupAddress
+Device.Services.STBService.{i}.Components.FrontEnd.{i}.IP.IGMP.ClientGroupNumberOfEntries
+Device.Services.STBService.{i}.Components.FrontEndNumberOfEntries
+Device.Services.STBServiceNumberOfEntries
+Device.Services.StorageServices.Capabilities.FTPCapable
+Device.Services.StorageServices.Capabilities.HTTPCapable
+Device.Services.StorageServices.Capabilities.HTTPSCapable
+Device.Services.StorageServices.Capabilities.HTTPWritable
+Device.Services.StorageServices.Capabilities.SFTPCapable
+Device.Services.StorageServices.Capabilities.SupportedFileSystemTypes
+Device.Services.StorageServices.Capabilities.SupportedNetworkProtocols
+Device.Services.StorageServices.Capabilities.SupportedRaidTypes
+Device.Services.StorageServices.Capabilities.VolumeEncryptionCapable
+Device.Services.StorageServices.Enable
+Device.Services.StorageServices.LogicalVolume.{i}.Capacity
+Device.Services.StorageServices.LogicalVolume.{i}.Enable
+Device.Services.StorageServices.LogicalVolume.{i}.FileSystem
+Device.Services.StorageServices.LogicalVolume.{i}.FolderNumberOfEntries
+Device.Services.StorageServices.LogicalVolume.{i}.Name
+Device.Services.StorageServices.LogicalVolume.{i}.Status
+Device.Services.StorageServices.LogicalVolume.{i}.ThresholdLimit
+Device.Services.StorageServices.LogicalVolume.{i}.UsedSpace
+Device.Services.StorageServices.LogicalVolume.{i}.X_CATAWAMPUS-ORG_ReadOnly
+Device.Services.StorageServices.LogicalVolumeNumberOfEntries
+Device.Services.StorageServices.PhysicalMedium.{i}.Capacity
+Device.Services.StorageServices.PhysicalMedium.{i}.ConnectionType
+Device.Services.StorageServices.PhysicalMedium.{i}.FirmwareVersion
+Device.Services.StorageServices.PhysicalMedium.{i}.Health
+Device.Services.StorageServices.PhysicalMedium.{i}.HotSwappable
+Device.Services.StorageServices.PhysicalMedium.{i}.Model
+Device.Services.StorageServices.PhysicalMedium.{i}.Name
+Device.Services.StorageServices.PhysicalMedium.{i}.Removable
+Device.Services.StorageServices.PhysicalMedium.{i}.SMARTCapable
+Device.Services.StorageServices.PhysicalMedium.{i}.SerialNumber
+Device.Services.StorageServices.PhysicalMedium.{i}.Vendor
+Device.Services.StorageServices.PhysicalMediumNumberOfEntries
+Device.Services.StorageServices.StorageArrayNumberOfEntries
+Device.Services.StorageServices.UserAccountNumberOfEntries
+Device.Services.StorageServices.UserGroupNumberOfEntries
+Device.Services.StorageServices.X_CATAWAMPUS-ORG_FlashMedia.{i}.BadEraseBlocks
+Device.Services.StorageServices.X_CATAWAMPUS-ORG_FlashMedia.{i}.CorrectedErrors
+Device.Services.StorageServices.X_CATAWAMPUS-ORG_FlashMedia.{i}.EraseBlockSize
+Device.Services.StorageServices.X_CATAWAMPUS-ORG_FlashMedia.{i}.IOSize
+Device.Services.StorageServices.X_CATAWAMPUS-ORG_FlashMedia.{i}.MaxEraseCount
+Device.Services.StorageServices.X_CATAWAMPUS-ORG_FlashMedia.{i}.Name
+Device.Services.StorageServices.X_CATAWAMPUS-ORG_FlashMedia.{i}.ReservedEraseBlocks
+Device.Services.StorageServices.X_CATAWAMPUS-ORG_FlashMedia.{i}.SubVolume.{i}.DataBytes
+Device.Services.StorageServices.X_CATAWAMPUS-ORG_FlashMedia.{i}.SubVolume.{i}.Name
+Device.Services.StorageServices.X_CATAWAMPUS-ORG_FlashMedia.{i}.SubVolume.{i}.Status
+Device.Services.StorageServices.X_CATAWAMPUS-ORG_FlashMedia.{i}.SubVolumeNumberOfEntries
+Device.Services.StorageServices.X_CATAWAMPUS-ORG_FlashMedia.{i}.TotalEraseBlocks
+Device.Services.StorageServices.X_CATAWAMPUS-ORG_FlashMedia.{i}.UncorrectedErrors
+Device.Services.StorageServices.X_CATAWAMPUS-ORG_FlashMediaNumberOfEntries
+InternetGatewayDevice.DeviceInfo.AdditionalHardwareVersion
+InternetGatewayDevice.DeviceInfo.AdditionalSoftwareVersion
+InternetGatewayDevice.DeviceInfo.Description
+InternetGatewayDevice.DeviceInfo.HardwareVersion
+InternetGatewayDevice.DeviceInfo.Manufacturer
+InternetGatewayDevice.DeviceInfo.ManufacturerOUI
+InternetGatewayDevice.DeviceInfo.ModelName
+InternetGatewayDevice.DeviceInfo.ModemFirmwareVersion
+InternetGatewayDevice.DeviceInfo.ProductClass
+InternetGatewayDevice.DeviceInfo.SerialNumber
+InternetGatewayDevice.DeviceInfo.SoftwareVersion
+InternetGatewayDevice.DeviceInfo.SpecVersion
+InternetGatewayDevice.DeviceInfo.UpTime
+InternetGatewayDevice.DeviceInfo.VendorConfigFileNumberOfEntries
+InternetGatewayDevice.LANDevice.{i}.LANEthernetInterfaceNumberOfEntries
+InternetGatewayDevice.LANDevice.{i}.LANUSBInterfaceNumberOfEntries
+InternetGatewayDevice.LANDevice.{i}.LANWLANConfigurationNumberOfEntries
+InternetGatewayDevice.LANDeviceNumberOfEntries
+InternetGatewayDevice.ManagementServer.ConnectionRequestPassword
+InternetGatewayDevice.ManagementServer.ConnectionRequestURL
+InternetGatewayDevice.ManagementServer.ConnectionRequestUsername
+InternetGatewayDevice.ManagementServer.DefaultActiveNotificationThrottle
+InternetGatewayDevice.ManagementServer.EnableCWMP
+InternetGatewayDevice.ManagementServer.ParameterKey
+InternetGatewayDevice.ManagementServer.Password
+InternetGatewayDevice.ManagementServer.PeriodicInformEnable
+InternetGatewayDevice.ManagementServer.PeriodicInformInterval
+InternetGatewayDevice.ManagementServer.PeriodicInformTime
+InternetGatewayDevice.ManagementServer.URL
+InternetGatewayDevice.ManagementServer.UpgradesManaged
+InternetGatewayDevice.ManagementServer.Username
+InternetGatewayDevice.PeriodicStatistics.MaxReportSamples
+InternetGatewayDevice.PeriodicStatistics.MinSampleInterval
+InternetGatewayDevice.PeriodicStatistics.SampleSet.{i}.Enable
+InternetGatewayDevice.PeriodicStatistics.SampleSet.{i}.FetchSamples
+InternetGatewayDevice.PeriodicStatistics.SampleSet.{i}.Name
+InternetGatewayDevice.PeriodicStatistics.SampleSet.{i}.Parameter.{i}.CalculationMode
+InternetGatewayDevice.PeriodicStatistics.SampleSet.{i}.Parameter.{i}.Enable
+InternetGatewayDevice.PeriodicStatistics.SampleSet.{i}.Parameter.{i}.Failures
+InternetGatewayDevice.PeriodicStatistics.SampleSet.{i}.Parameter.{i}.HighThreshold
+InternetGatewayDevice.PeriodicStatistics.SampleSet.{i}.Parameter.{i}.LowThreshold
+InternetGatewayDevice.PeriodicStatistics.SampleSet.{i}.Parameter.{i}.Reference
+InternetGatewayDevice.PeriodicStatistics.SampleSet.{i}.Parameter.{i}.SampleMode
+InternetGatewayDevice.PeriodicStatistics.SampleSet.{i}.Parameter.{i}.SampleSeconds
+InternetGatewayDevice.PeriodicStatistics.SampleSet.{i}.Parameter.{i}.SuspectData
+InternetGatewayDevice.PeriodicStatistics.SampleSet.{i}.Parameter.{i}.Values
+InternetGatewayDevice.PeriodicStatistics.SampleSet.{i}.ParameterNumberOfEntries
+InternetGatewayDevice.PeriodicStatistics.SampleSet.{i}.ReportEndTime
+InternetGatewayDevice.PeriodicStatistics.SampleSet.{i}.ReportSamples
+InternetGatewayDevice.PeriodicStatistics.SampleSet.{i}.ReportStartTime
+InternetGatewayDevice.PeriodicStatistics.SampleSet.{i}.SampleInterval
+InternetGatewayDevice.PeriodicStatistics.SampleSet.{i}.SampleSeconds
+InternetGatewayDevice.PeriodicStatistics.SampleSet.{i}.Status
+InternetGatewayDevice.PeriodicStatistics.SampleSet.{i}.TimeReference
+InternetGatewayDevice.PeriodicStatistics.SampleSetNumberOfEntries
+InternetGatewayDevice.Time.CurrentLocalTime
+InternetGatewayDevice.Time.Enable
+InternetGatewayDevice.Time.LocalTimeZoneName
+InternetGatewayDevice.WANDeviceNumberOfEntries
+TraceRoute.DSCP
+TraceRoute.DataBlockSize
+TraceRoute.DiagnosticsState
+TraceRoute.Host
+TraceRoute.Interface
+TraceRoute.MaxHopCount
+TraceRoute.NumberOfTries
+TraceRoute.ResponseTime
+TraceRoute.RouteHopsNumberOfEntries
+TraceRoute.Timeout
+X_CATAWAMPUS-ORG_CATAWAMPUS.RuntimeEnvInfo
+X_GOOGLE-COM_GFIBERTV.Mailbox.Name
+X_GOOGLE-COM_GFIBERTV.Mailbox.Node
+X_GOOGLE-COM_GFIBERTV.Mailbox.NodeList
+X_GOOGLE-COM_GFIBERTV.Mailbox.Value
+X_GOOGLE-COM_GVSB.EpgPrimary
+X_GOOGLE-COM_GVSB.EpgSecondary
+X_GOOGLE-COM_GVSB.GvsbChannelLineup
+X_GOOGLE-COM_GVSB.GvsbKick
+X_GOOGLE-COM_GVSB.GvsbServer
diff --git a/acs.py b/acs.py
new file mode 100755
index 0000000..8725e02
--- /dev/null
+++ b/acs.py
@@ -0,0 +1,183 @@
+#!/usr/bin/python
+# Copyright 2012 Google Inc. All Rights Reserved.
+
+"""This File executes create/modify/delete operations on ACS datastore.
+
+This class is used to interact with scripts that directly modifies
+ACS datastore configuration. These ACS related actions may require
+google3 dependencies
+"""
+
+__author__ = 'Lehan Meng (lmeng@google.com)'
+
+
+import os
+import re
+
+
+class ACS(object):
+  """This class executes operations that change Device profiles on ACS."""
+
+  def __init__(self, expected_version=None, **kwargs):
+    """Constructor for this Class."""
+    self.acs_info = {
+        'url': None,
+        # expected image version ID on ACS
+        'imageVersion': expected_version,
+        'acs_path': None,
+        'outfile': 'cmdOutput.txt'}
+    for s in kwargs:
+      self.acs_info[s] = kwargs[s]
+
+  def SetLogging(self, log):
+    """Setup the logging file(s)."""
+    self.log = log
+
+  def SetImageVersion(self, expected_version):
+    """Set the expected image version that needs to be configured at ACS.
+
+    Args:
+      expected_version: the version string of the expected image.
+    """
+    m = re.match('\d+', expected_version)
+    if m is None:
+      info = self.log.CreateErrorInfo(
+          'critical',
+          'Error! Please use software id as expected image version value')
+      self.log.SendLine(None, info)
+    else:
+      self.acs_info['imageVersion'] = expected_version
+
+  def ParseAppIDFromACSURL(self, url='https://acs.e2e.gfsvc.com/cwmp'):
+    """Parse app_id from ACS instance host name."""
+    pass
+
+  def SaveConfiguration(self, profile_id, version_id, app_id,
+                        host='https://acs.e2e.gfsvc.com/cwmp'):
+    """Run the ACS configuration script from Google3 location."""
+    if not version_id:
+      v_id = self.acs_info['imageVersion']
+    else:
+      v_id = version_id
+
+    cur_dir = os.getcwd()
+    print '============' + cur_dir
+    # the acs_path is the google3 repository where upgrade_test.py
+    # locates. This test depends on it to modify ACS datastore.
+    os.chdir(self.acs_info['acs_path'])
+    print '============' + os.getcwd()
+    os.system(
+        'blaze test --notest_loasd --test_arg=--imageVersion='
+        + v_id + ' --test_arg=--profile_id='
+        + profile_id + ' --test_arg=--app_id=' + app_id
+        + ' --test_arg=--host=' + host
+        + ' --test_strategy=local :upgrade_test ')
+    os.chdir(cur_dir)
+    print '============' + os.getcwd()
+
+  def StubbyClientCall(self, cmd=None):
+    """This is the nbi_client stubby call to get parameter names and values."""
+    p = os.popen(cmd, 'r')
+    log_list = []
+    while 1:
+      line = p.readline()
+      if not line: break
+      log_list.append(line.strip())
+    return log_list
+
+  def ParseParameterAccessStates(self, cmd_list):
+    """Find out if a parameter is 'writable' or 'read-write'.
+
+    This method process the nbi_client getParameterNames() call result
+    to find out the access state of the parameters.
+    Args:
+      cmd_list: the getParameterNames() call returned result list
+    Returns:
+      a dictionary: parameter name as index, and its access state
+      as value.
+    """
+    if ('FAILED' in cmd_list[0]) or (not 'SUCCESS' in cmd_list[0]):
+      info = self.log.CreateErrorInfo(
+          'Critical', 'nbi_clienet call failed. ' + str(cmd_list[0]))
+      self.log.SendLine(None, info)
+      return False
+
+    para_dict = {}
+    for line in cmd_list:
+      if 'name:' in line:
+        name = re.sub('.*name:\s*\"(.*)\".*', r'\1', line)
+        index = cmd_list.index(line)+1
+        access = re.sub('.*writable:\s*([a-zA-Z]+)', r'\1', cmd_list[index])
+        para_dict.update({name: access})
+    return para_dict
+
+  def CheckCmdCall(self, cmd_list):
+    """Check if the RPC call is a success or failure."""
+    if ('FAILED' in cmd_list[0]) or (not 'SUCCESS' in cmd_list[0]):
+      info = self.log.CreateErrorInfo(
+          'Critical', 'nbi_client call failed. ' + str(cmd_list[0]))
+      self.log.SendLine(None, info)
+      return False
+    else:
+      return True
+
+  def ParseManagementURL(self, cmd_list):
+    """Parse Management URL from GetParameterValues query reply message.
+
+    Reply message is in the following format:
+    #########################################################
+    SUCCESS! Response: parameter_value_list {
+    parameter_value_struct {
+    name: "InternetGatewayDevice.ManagementServer.URL"
+    string_value: "https://acs.e2e.gfsvc.com/cwmp"
+       }
+    }
+    #########################################################
+
+    Args:
+      cmd_list: the ACS url information obtained from device log or file
+    Returns:
+      returns the management url found, or return false if url not found
+    """
+    if not cmd_list:
+      return False
+    for line in cmd_list:
+      if ('name:' in line and
+          'InternetGatewayDevice.ManagementServer.URL' in line):
+        s = cmd_list[cmd_list.index(line)+1]
+        m = re.search('http[s]?://(\w*\.)+com/cwmp', s)
+        if not m:
+          info = self.log.CreateErrorInfo(
+              'Warning', 'No management server URL found in GetParameterValues '
+              'query reply.')
+          self.log.SendLine(None, info)
+          return False
+        else:
+          return m.group(0)
+
+  def ParseParameterNames(self, cmd_list, replace_index=False):
+    """Parse the get values RPC call response, retrieve parameter name list.
+
+    Args:
+      cmd_list: the command reply message from nbi_client
+      replace_index: if True, the index digits in parameter names will be
+                     replaced with '.{i}.'
+    Returns:
+      return the parsed parameter name list
+    """
+    if not self.CheckCmdCall(cmd_list):
+      return False
+
+    chk_list = []
+    for line in cmd_list:
+      if 'name:' in line:
+        output = re.sub('.*\"(.*)\".*', r'\1', line)
+        if replace_index:
+          output = re.sub(r'(\.)[\d]+(\.)', r'\1{i}\2', output)
+        if chk_list.count(output) < 1:
+          chk_list.append(output)
+    return chk_list
+
+
+if __name__ == '__main__':
+  pass
diff --git a/basic_TR69.py b/basic_TR69.py
new file mode 100644
index 0000000..0b9bfae
--- /dev/null
+++ b/basic_TR69.py
@@ -0,0 +1,651 @@
+#!/usr/bin/python
+# Copyright 2012 Google Inc. All Rights Reserved.
+
+"""This class implements some basic TR069 test cases.
+
+   This class extends the TestCase Class.
+   This file implements some basic TR069 test cases to verify Bruno management
+   features. In the following test cases, only those that are defined in
+   'config.cfg' file will be executed.
+
+   Basic TR069 test cases include the following:
+   testID: 11865129  7.6.1 ACS Connection via IPv6
+   testID: 11721375  7.6.10 Verify there is a way to reset to factory default
+                            if user modifies the local configuration
+                            '/etc/init.d/S05factoryreset later'
+   testID: 14319146  7.6.19 Default ACS URL
+   testID: 11721371  7.6.2 ACS URL Pass to Bruno via Moca
+   testID: 14312009  7.6.21 Restrict the ability to locally configure ACS URL
+   testID: 14186028  7.6.22 Security of the link between the DHCPv6 server
+                            and the CPE
+   testID: 14312010  7.6.23 CPE Connection Initiation
+   testID: 14247012  7.6.24.1 Support of Connection Request notification
+                              mechanism
+   testID: 14186029  7.6.24.2 InternetGatewayDevice.ManagementServer.
+                              ConnectionRequestURL
+   testID: 14312011  7.6.24.3 InternetGatewayDevice.ManagementServer.
+                              ConnectionRequestURL format
+   testID: 14293012  7.6.24.4 No data is conveyed in the Connection
+                              Request HTTP Get notification
+   testID: 14165037  7.6.24.5 Restrict the number of Connection Request
+                              notifications
+   testID: 14315010  7.6.24.6 Connection Request Notification does not
+                              terminate current session
+   testID: 14247013  7.6.25.1 MaxEnvelopes
+   testID: 14312012  7.6.25.2 Cookie support (optional)
+   testID: 14293013  7.6.25.4 Authentication
+   testID: 14311008  7.6.26.1 SOAP namespace identifier
+   testID: 14293014  7.6.26.2 SOAP Fault element
+   testID: 14311009  7.6.26.3 SOAP future extensibility
+   testID: 14186030  7.6.27 Fault Handling
+   testID: 14319148  7.6.27.1 SOAP requests respond
+   testID: 14266497  7.6.27.2 Session Termination
+   testID: 14312013  7.6.28 Correctly handle concurrent downloads in catawampus
+   testID: 11874098  7.6.3.1 TLS (1.2)/SSL based Transport for TR-069 on IPv6
+   testID: 14315007  7.6.3.2 Support for encryption algorithms
+   testID: 14247014  7.6.32 Persist TR-069 config across reboots
+   testID: 14293015  7.6.33 Send notification when disk is full
+   testID: 14293016  7.6.34 Support for multiple SSIDs in WLANConfiguration
+   testID: 11865130  7.6.4 TR069-ACS Validation
+   testID: 11722370  7.6.5 TR069-Inform Request
+   testID: 11874103  7.6.7 Digest Authentication
+   testID: 11843139  7.6.8.1 Support of RPCs: REBOOT
+"""
+
+__author__ = 'Lehan Meng (lmeng@google.com)'
+
+
+import os
+import re
+import time
+
+from IPy import IP
+
+import device
+import ssh
+import testCase
+
+
+class BasicTR069Test(testCase.TestCase):
+  """Class for test cases: Bruno basic TR069 features.
+
+  A range of basic TR069 test cases are defined in this Class
+  """
+
+  def Init(self):
+    """Initialize the networking feature tests."""
+    # Get all device information.
+    info = self.log.CreateResultInfo(
+        '---', 'Networking test verification started...')
+    self.log.SendLine(self.test_info, info)
+    self.bruno = device.Bruno(user=self.params['user'],
+                              addr=self.params['addr'],
+                              bruno_prompt=self.params['bruno_prompt'],
+                              addr_ipv6=self.params['addr_ipv6'])
+    self.bruno.SetLogging(self.log)
+    if not self.p_ssh:
+      self.p_ssh = ssh.SSH(user=self.params['user'],
+                           addr=self.params['addr'],
+                           bruno_prompt=self.params['bruno_prompt'],
+                           addr_ipv6=self.params['addr_ipv6'])
+    self.bruno.dev_ssh = self.p_ssh
+    self.p_ssh.SetLogging(self.log)
+
+    self.__delay_5_sec = 5
+    self.__delay_5_min = 300
+    self.__delay_15_min = 900
+    return
+
+  def SshTunnel(self):
+    """Create ssh tunnel for the test."""
+    self.p_ssh.SshRetry(5, 15)
+    return
+
+  def VerifyDuplicatedAddress(self, ip_addr):
+    """Verify device can detect duplicated ipv6 address existing in network.
+
+    Set a duplicated ip address on the device.
+    Verify that the device can detect duplicated ip address
+
+    Args:
+      ip_addr: the duplicated address
+    Returns:
+      True: if duplicated detected
+      False: if duplicated address is not detected
+    """
+    time_stamp = self.bruno.GetTimeStamp()
+    self.bruno.dev_ssh.SendCmd('ip -6 addr add ' + ip_addr + '/64 dev br0')
+    time.sleep(1)
+    self.bruno.dev_ssh.SendCmd('dmesg')
+    log_list = self.bruno.dev_ssh.GetCmdOutput()
+
+    pattern_line = (
+      '\[\d*\.\d{3}\]\s*\w*\d:\s* IPv6 duplicate address\s*('
+      + ip_addr + ')\s*[/\d+]*\s*detected!')
+    self.bruno.dev_ssh.SendCmd('ip -6 addr del ' + ip_addr + '/64 dev br0')
+
+    if self.bruno.FindLineInLog(log_list, time_stamp, pattern_line):
+      info = self.log.CreateResultInfo('Pass', 'Duplicated IPv6 address '
+                                       'detected: ' + ip_addr)
+      self.log.SendLine(self.test_info, info)
+    else:
+      info = self.log.CreateResultInfo('Failed',
+                                       'Duplicated IPv6 address not detected: '
+                                       + ip_addr + '. Verification Failed!')
+      self.log.SendLine(self.test_info, info)
+    #[132344.324] br0: IPv6 duplicate address fe80:... detected!
+
+  def VerifyExpectedVersion(self):
+    """Verify if device is running on expected software version."""
+    if not self.bruno.VerifyCurrentVersion(self.params['expected_version']):
+      info = self.log.CreateErrorInfo('critical',
+                                      'Device software version is not expected!'
+                                      ' Exit!')
+      self.log.SendLine(self.test_info, info)
+      os.sys.exit(1)
+
+  def VerifyACSWithIPv6(self):
+    """Test ID: 11865129 - Verify IPv6 connection to ACS.
+
+    To verify device connects to ACS via IPv6, use tcpdump to capture
+    network packets, filtered with source IPv6 address, and destination
+    IPv6 address of Bruno and ACS.
+
+    tcpdump filter:
+      1. source address: device address
+         destination address: ACS address
+      2. source address: ACS address
+         destination address: device address
+
+    if packets on both directions are found, test succeeds.
+    Otherwise, test failed.
+    """
+    info = self.log.CreateProgressInfo(
+          '10%', 'Verifying current image version, expected: '
+          + self.params['expected_version'])
+    self.log.SendLine(self.test_info, info)
+    self.VerifyExpectedVersion()
+
+    # capture 10 packets on both directions.
+    # capture length: 100 bytes
+    packet_to_catch = '5'
+    bytes_to_catch = '100'
+    interface_to_catch = 'br0'
+    tcpdump_command = ('tcpdump -i ' + interface_to_catch + ' -c '
+                       + packet_to_catch + ' -s ' + bytes_to_catch
+                       + ' \'(((src ' + self.params['addr_ipv6']
+                       + ') and (dst ' + self.params['acs_ipv6']
+                       + ')) or ((src ' + self.params['acs_ipv6']
+                       + ') and (dst ' + self.params['addr_ipv6']
+                       + ')))\'')
+    info = self.log.CreateProgressInfo(
+          '30%', 'Calling tcpdump to capture device traffic to ACS server: '
+          'capturing on interface: ' + interface_to_catch
+          + ' Catch packets: ' + packet_to_catch)
+    self.log.SendLine(self.test_info, info)
+    self.p_ssh.SendCmd(tcpdump_command, 180)
+    info = self.log.CreateProgressInfo(
+          '60%', 'Packets captured. Analyzing...')
+    self.log.SendLine(self.test_info, info)
+    tcpdump_result = self.p_ssh.GetCmdOutput()
+    tcpdump_result.reverse()
+    if self.CheckACSIPv6Connection(tcpdump_result):
+      info = self.log.CreateProgressInfo(
+          '100%', 'TR069 traffic verified: Device connected to ACS via IPv6')
+      self.log.SendLine(self.test_info, info)
+      info = self.log.CreateResultInfo(
+          'Pass', 'TR069 traffic verified: Device connected to ACS via IPv6')
+      self.log.SendLine(self.test_info, info)
+    else:
+      info = self.log.CreateResultInfo(
+          'Failed', 'TR069 traffic verified: No IPv6 connection detected.')
+      self.log.SendLine(self.test_info, info)
+
+  def ParseDumpMsgToPackets(self, tcpdump_result):
+    """Parse tcpdump dump messages information to packets.
+
+    tcpdump result (for example):
+    14:24:36.887936 00:1a:11:30:64:e6 (oui Unknown) > a8:d0:e5:a1:e3:02    L1
+      (oui Unknown), ethertype IPv6 (0x86dd), length 86:                   L2
+    0x0000:  6000 0000 0020 0640 2605 a601 fe00 fd18  `......@&.......     L3
+    0x0010:  021a 11ff fe30 64e6 2001 4860 8005 0000  .....0d...H`....     L4
+    0x0020:  0000 0000 0000 008d e2e8 01bb 73e4 0dc8  ............s...     L5
+    0x0030:  a1bf d109 8011 0429 276b 0000 0101 080a  .......)'k......     L6
+    0x0040:  0389 b875 d29d 2401                      ...u..$.             L7
+    14:24:36.912863 a8:d0:e5:a1:e3:02 (oui Unknown) > 00:1a:11:30:64:e6    L8
+      (oui Unknown), ethertype IPv6 (0x86dd), length 86:                   L9
+    0x0000:  6000 0000 0020 0634 2001 4860 8005 0000  `......4..H`....     L10
+    0x0010:  0000 0000 0000 008d 2605 a601 fe00 fd18  ........&.......     L11
+    0x0020:  021a 11ff fe30 64e6 01bb e2e8 a1bf d109  .....0d.........     L12
+    0x0030:  73e4 0dc9 8011 05a8 6bdc 0000 0101 080a  s.......k.......     L13
+    0x0040:  d29d 763c 0389 b875                      ..v<...u             L14
+
+    This method will parse the dump message to two packets dump:
+    (new packet starts with time stamp: 14:24:36.912863)
+    packet_list[0]: line L1 ~ line L7
+    packet_list[1]: line L8 ~ line L14
+
+    Args:
+      tcpdump_result: raw dump message from tcpdump
+    Returns:
+      packet_list
+    """
+    packet_list = []
+    packet = []
+    for line in tcpdump_result:
+      m = re.search('^\s*\d{2}:\d{2}:\d{2}\.\d+\s*', line)
+      if m:
+        # new packet found:
+        packet = []
+        packet.append(line)
+        index = tcpdump_result.index(line)
+        while index+1 < len(tcpdump_result):
+          packet_line = tcpdump_result[index+1]
+          m = re.search('^\s*\d{2}:\d{2}:\d{2}\.\d+\s*', packet_line)
+          if not m:
+            # not start of next packet
+            packet.append(packet_line)
+            index +=1
+          else:
+            # next packet starts
+            packet_list.append(packet)
+            break
+    return packet_list
+
+  def FindSrcAddrFromTcpdump(self, packet):
+    """Parse source IPv6 address from tcpdump message.
+
+    Args:
+      packet: tcpdump dump message
+    Returns:
+      source address in packet dump message
+    """
+    src_addr = None
+    for line in packet:
+      m = re.search('^\s*0x0000:\s*([\da-f]{4})\s*([\da-f]{4})\s*([\da-f]{4})'
+                    '\s*([\da-f]{4})\s*([\da-f]{4})\s*([\da-f]{4})'
+                    '\s*([\da-f]{4})\s*([\da-f]{4})\s*.*', line)
+      if m:
+        # first line of packet data:
+        src_addr = (m.group(5) + ':' + m.group(6) + ':' + m.group(7)
+                    + ':' + m.group(8)) + ':'
+        index = packet.index(line)
+        m = re.search('^\s*0x0010:\s*([\da-f]{4})\s*([\da-f]{4})\s*([\da-f]{4})'
+                      '\s*([\da-f]{4})\s*([\da-f]{4})\s*([\da-f]{4})'
+                      '\s*([\da-f]{4})\s*([\da-f]{4})\s*.*', packet[index+1])
+        src_addr += (m.group(1) + ':' + m.group(2) + ':' + m.group(3)
+                     + ':' + m.group(4))
+        break
+    return src_addr
+
+  def FindDstAddrFromTcpdump(self, packet):
+    """Parse destination IPv6 address from tcpdump message.
+
+    Args:
+      packet: tcpdump dump message
+    Returns:
+      source address in packet dump message
+    """
+    dst_addr = None
+    for line in packet:
+      m = re.search('^\s*0x0010:\s*([\da-f]{4})\s*([\da-f]{4})\s*([\da-f]{4})'
+                    '\s*([\da-f]{4})\s*([\da-f]{4})\s*([\da-f]{4})'
+                    '\s*([\da-f]{4})\s*([\da-f]{4})\s*.*', line)
+      if m:
+        # first line of packet data:
+        dst_addr = (m.group(5) + ':' + m.group(6) + ':' + m.group(7)
+                    + ':' + m.group(8)) + ':'
+        index = packet.index(line)
+        m = re.search('^\s*0x0020:\s*([\da-f]{4})\s*([\da-f]{4})\s*([\da-f]{4})'
+                      '\s*([\da-f]{4})\s*([\da-f]{4})\s*([\da-f]{4})'
+                      '\s*([\da-f]{4})\s*([\da-f]{4})\s*.*', packet[index+1])
+        dst_addr += (m.group(1) + ':' + m.group(2) + ':' + m.group(3)
+                     + ':' + m.group(4))
+        break
+    return dst_addr
+
+  def CheckACSIPv6Connection(self, tcpdump_result):
+    """Examine captured packets, find IPv6 communication between ACS and device.
+
+    Args:
+      tcpdump_result: tcpdump result: captured packets message dump
+    Returns:
+      True: if bi-directional communication found from packet list.
+      False: otherwise
+    """
+    packet_list = self.ParseDumpMsgToPackets(tcpdump_result)
+    dev_to_acs = False
+    acs_to_dev = False
+    for pacekt in packet_list:
+      src_addr = IP(self.FindSrcAddrFromTcpdump(pacekt))
+      dst_addr = IP(self.FindDstAddrFromTcpdump(pacekt))
+      if (src_addr == IP(self.params['addr_ipv6'])
+          and dst_addr == IP(self.params['acs_ipv6'])):
+        dev_to_acs = True
+      if (dst_addr == IP(self.params['addr_ipv6'])
+          and src_addr == IP(self.params['acs_ipv6'])):
+        acs_to_dev = True
+
+    if dev_to_acs and acs_to_dev:
+      return True
+    else:
+      return False
+
+  def VerifyFactoryReset(self):
+    """Test case: 11721375, Verify the factory reset function of device.
+
+    Verify factory reset according to the following conditions:
+    - version
+    - address
+    - cat /etc/ntpd.conf
+    - cat /etc/resolv.conf
+    - cat /tmp/gvsbhost
+    - ls /tmp/gvsb*
+    - cat /tmp/cwmp/acs_url
+    - ls -l /var/media
+    - ls -l /rw/sage
+
+    This test will need to manually reset the device using reset button.
+    """
+    test_failed = False
+    info = self.log.CreateProgressInfo(
+          '10%', 'Verifying current image version, expected: '
+          + self.params['expected_version'])
+    self.log.SendLine(self.test_info, info)
+    self.VerifyExpectedVersion()
+
+    # get file time information:
+    wiz_bin_date = None
+    self.p_ssh.SendCmd('ls -l /rw/sage')
+    cmd_list = self.p_ssh.GetCmdOutput()
+    for line in cmd_list:
+      if 'Wiz.bin' in line:
+        m = re.search('.*(\d{4}-\d{2}-\d{2}\s*\d+:\d+).*', line)
+        if m:
+          wiz_bin_date = m.group(1)
+
+    info = self.log.CreateProgressInfo(
+          '20%', 'Please reset the device. '
+          'Hold down reset button for 5 seconds...')
+    self.log.SendLine(self.test_info, info)
+
+    info = self.log.CreateProgressInfo(
+          '30%', 'Wait ' + str(self.__delay_5_min)
+          + ' for device to reset and reboot...')
+    self.log.SendLine(self.test_info, info)
+    time.sleep(self.__delay_5_min)
+
+    info = self.log.CreateProgressInfo(
+          '40%', 'Connecting to device...')
+    self.log.SendLine(self.test_info, info)
+    self.SshTunnel()
+
+    addr = self.bruno.GetIPv4Address()
+    if not addr:
+      info = self.log.CreateErrorInfo('critical',
+                                      'Error! No IPv4 address found!')
+      self.log.SendLine(self.test_info, info)
+      test_failed = True
+    else:
+      info = self.log.CreateProgressInfo(
+          '50%', 'Checking device IPv4 address succeed: IPv4: '
+          + addr)
+      self.log.SendLine(self.test_info, info)
+
+    addr_v6 = self.bruno.GetIPv6Address()
+    if not addr_v6:
+      info = self.log.CreateErrorInfo('warning', 'No IPv6 address found!')
+      self.log.SendLine(self.test_info, info)
+    else:
+      info = self.log.CreateProgressInfo(
+          '55%', 'Checking device IPv6 address succeed: IPv6: '
+          + addr_v6[0])
+      self.log.SendLine(self.test_info, info)
+
+    if self.bruno.GetProductClass() == 'GFMS100':
+      # fat bruno, check Wiz.bin file:
+      found_file = False
+      self.p_ssh.SendCmd('ls -l /rw/sage')
+      cmd_list = self.p_ssh.GetCmdOutput()
+      for line in cmd_list:
+        if 'Wiz.bin' in line:
+          found_file = True
+          m = re.search('.*(\d{4}-\d{2}-\d{2}\s*\d+:\d+).*', line)
+          new_date = m.group(1)
+          if new_date == wiz_bin_date:
+            # if file is not updated
+            test_failed = True
+            info = self.log.CreateErrorInfo(
+                'warning', 'Wiz.bin not updated: '
+                'file date before reset: ' + wiz_bin_date
+                + ' new file date: ' + new_date)
+            self.log.SendLine(self.test_info, info)
+          else:
+            info = self.log.CreateProgressInfo(
+                '60%', 'Checking Wiz.bin file succeed: new file created at: '
+                + new_date)
+            self.log.SendLine(self.test_info, info)
+          break
+      if not found_file:
+        test_failed = True
+        info = self.log.CreateErrorInfo(
+            'critical', 'No Wiz.bin file found after reset!')
+        self.log.SendLine(self.test_info, info)
+
+    # verify ntpd.conf
+    ts = self.bruno.GetTimeServer()
+    if not ts:
+      test_failed = True
+      info = self.log.CreateErrorInfo(
+          'critical', 'No time server found in file /etc/ntpd.conf!')
+      self.log.SendLine(self.test_info, info)
+    else:
+      info = self.log.CreateProgressInfo(
+          '65%', 'Checking time server (ntpd.conf) succeed: Timeserver: '
+          + ts)
+      self.log.SendLine(self.test_info, info)
+
+    # verify resolv.conf
+    dns = self.bruno.GetDNSServer()
+    if not dns:
+      test_failed = True
+      info = self.log.CreateErrorInfo(
+          'critical', 'No DNS server found in file /etc/resolv.conf!')
+      self.log.SendLine(self.test_info, info)
+    else:
+      info = self.log.CreateProgressInfo(
+          '70%', 'Checking DNS server (resolv.conf) succeed: DNS: '
+          + dns)
+      self.log.SendLine(self.test_info, info)
+
+    # check gvsb:
+    gvsb = self.bruno.GetGVSBHost().strip()
+    if not gvsb or (gvsb != self.params['gvsb_host']):
+      test_failed = True
+      info = self.log.CreateErrorInfo(
+          'critical', 'GVSB host not found or not matching expected host!')
+      self.log.SendLine(self.test_info, info)
+    else:
+      info = self.log.CreateProgressInfo(
+          '75%', 'Checking GVSB server (gvsbhost) succeed: URL: '
+          + gvsb)
+      self.log.SendLine(self.test_info, info)
+
+    # check gvsb files:
+    self.bruno.dev_ssh.SendCmd('ls /tmp/gvsb*')
+    cmd_list = self.bruno.dev_ssh.GetCmdOutput()
+    gvsb_channel = False
+    gvsb_kick = False
+    gvsb_host = False
+    for line in cmd_list:
+      if 'gvsbhost' in line:
+        gvsb_host = True
+      elif 'gvsbchannel' in line:
+        gvsb_channel = True
+      elif 'gvsbkick' in line:
+        gvsb_kick = True
+    if not gvsb_channel or not gvsb_kick or not gvsb_host:
+      test_failed = True
+      info = self.log.CreateErrorInfo(
+          'critical', 'GVSB files missing! Check /tmp/for gvsb files')
+      self.log.SendLine(self.test_info, info)
+    else:
+      info = self.log.CreateProgressInfo(
+          '80%', 'Checking GVSB files (/tmp/gvsb*) succeed. Files found: '
+          'gvsbhost, gvsbchannel, gvsbkick.')
+      self.log.SendLine(self.test_info, info)
+
+    # verify acs url:
+    if self.bruno.GetACSUrl() != self.params['acs_url']:
+      test_failed = True
+      info = self.log.CreateErrorInfo(
+          'critical', 'ACS URL is not expected! Expected URL: '
+          + self.params['acs_url'])
+      self.log.SendLine(self.test_info, info)
+    else:
+      info = self.log.CreateProgressInfo(
+          '85%', 'Checking ACS URL (/tmp/cwmp/acs_url) succeed. URL: '
+          + self.params['acs_url'])
+      self.log.SendLine(self.test_info, info)
+
+    # verify sage properties
+    self.bruno.dev_ssh.SendCmd('ls -l /rw/sage')
+    cmd_list = self.bruno.dev_ssh.GetCmdOutput()
+    sage_prop = False
+    sage_prop_backup = False
+    for line in cmd_list:
+      if 'Sage.properties.autobackup' in line:
+        sage_prop_backup = True
+      elif 'Sage.properties' in line:
+        sage_prop = True
+    if not sage_prop or not sage_prop_backup:
+      test_failed = True
+      info = self.log.CreateErrorInfo(
+          'critical', 'Missing file in /rw/sage folder.')
+      self.log.SendLine(self.test_info, info)
+    else:
+      info = self.log.CreateProgressInfo(
+          '90%', 'Checking sage properties files (/rw/sage/) succeed.')
+      self.log.SendLine(self.test_info, info)
+
+    if test_failed:
+      info = self.log.CreateResultInfo(
+          'Failed', 'Device configuration not '
+          'restored completely after factory reset!')
+      self.log.SendLine(self.test_info, info)
+    else:
+      info = self.log.CreateResultInfo(
+          'Pass', 'Device configuration '
+          'successfully restored after factory reset.')
+      self.log.SendLine(self.test_info, info)
+      info = self.log.CreateProgressInfo(
+          '100%', 'Device configuration '
+          'successfully restored after factory reset.')
+      self.log.SendLine(self.test_info, info)
+
+  def VerifyDefaultACSURL(self):
+    """Test case: 14319146. This method verifies default ACS URL on device."""
+    # this test needs to disable the Ethernet port, therefore can not
+    # be automated via ssh tunnel
+    print 'pass this test case'
+
+  def Run(self):
+    """Run the test case."""
+    ####### Add your code here -- BEGIN #######
+    print 'Test Started...'
+
+    self.Init()
+    time.sleep(2)  # time delay between commands issued to Device
+    self.SshTunnel()
+    info = self.log.CreateProgressInfo(
+        '5%', 'SSH session to device successfully established!')
+    self.log.SendLine(self.test_info, info)
+
+    if self.test_info['testID'] == '11865129':
+      self.VerifyACSWithIPv6()
+    elif self.test_info['testID'] == '11721375':
+      self.VerifyFactoryReset()
+    elif self.test_info['testID'] == '14319146':
+      self.VerifyDefaultACSURL()
+    elif self.test_info['testID'] == '11721371':
+      print 'run test'
+    elif self.test_info['testID'] == '14312009':
+      print 'run test'
+    elif self.test_info['testID'] == '14186028':
+      print 'run test'
+    elif self.test_info['testID'] == '14312010':
+      print 'run test'
+    elif self.test_info['testID'] == '14247012':
+      print 'run test'
+    elif self.test_info['testID'] == '14186029':
+      print 'run test'
+    elif self.test_info['testID'] == '14312011':
+      print 'run test'
+    elif self.test_info['testID'] == '14293012':
+      print 'run test'
+    elif self.test_info['testID'] == '14165037':
+      print 'run test'
+    elif self.test_info['testID'] == '14315010':
+      print 'run test'
+    elif self.test_info['testID'] == '14247013':
+      print 'run test'
+    elif self.test_info['testID'] == '14312012':
+      print 'run test'
+    elif self.test_info['testID'] == '14293013':
+      print 'run test'
+    elif self.test_info['testID'] == '14311008':
+      print 'run test'
+    elif self.test_info['testID'] == '14293014':
+      print 'run test'
+    elif self.test_info['testID'] == '14311009':
+      print 'run test'
+    elif self.test_info['testID'] == '14186030':
+      print 'run test'
+    elif self.test_info['testID'] == '14319148':
+      print 'run test'
+    elif self.test_info['testID'] == '14266497':
+      print 'run test'
+    elif self.test_info['testID'] == '14312013':
+      print 'run test'
+    elif self.test_info['testID'] == '11874098':
+      print 'run test'
+    elif self.test_info['testID'] == '14315007':
+      print 'run test'
+    elif self.test_info['testID'] == '14247014':
+      print 'run test'
+    elif self.test_info['testID'] == '14293015':
+      print 'run test'
+    elif self.test_info['testID'] == '14293016':
+      print 'run test'
+    elif self.test_info['testID'] == '11865130':
+      print 'run test'
+    elif self.test_info['testID'] == '11722370':
+      print 'run test'
+    elif self.test_info['testID'] == '11874103':
+      print 'run test'
+    elif self.test_info['testID'] == '11843139':
+      print 'run test'
+    else:
+      print 'do nothing...'
+
+    print 'Test Completed...'
+    ####### Add your code here -- END   #######
+
+  def Destructor(self):
+    """This is the destructor function to call for the user extened class."""
+    self.p_ssh.close()
+
+if __name__ == '__main__':
+  # Test cases defined in this file:
+  test_defined = ['11865129', '11721375', '14319146', '11721371',
+                  '14312009', '14186028', '14312010', '14247012', '14186029',
+                  '14312011', '14293012', '14165037', '14315010', '14247013',
+                  '14312012', '14293013', '14311008', '14293014', '14311009',
+                  '14186030', '14319148', '14266497', '14312013', '11874098',
+                  '14315007', '14247014', '14293015', '14293016', '11865130',
+                  '11722370', '11874103', '11843139']
+  # To execute test cases that defined in config file:
+  test_to_execute = testCase.TestCase.FindTestCaseToExecute('config.cfg')
+  for test_id in test_to_execute:
+    if test_id in test_defined:
+      test = BasicTR069Test(testID=test_id)
diff --git a/basic_network_testcases.py b/basic_network_testcases.py
new file mode 100644
index 0000000..2979227
--- /dev/null
+++ b/basic_network_testcases.py
@@ -0,0 +1,230 @@
+#!/usr/bin/python
+# Copyright 2012 Google Inc. All Rights Reserved.
+
+"""This class implements some basic networking test cases.
+
+   This class extends the TestCase Class.
+   This file implements some test cases to verify Bruno basic networking
+   features. In the following test cases, only those that are defined in
+   'config.cfg' file will be executed.
+
+   Feature test cases include the following:
+   testID: 11874111   7.2.12 IPv6 Duplicate Address Detection
+   testID: 11724363   7.2.16 Ethernet/Moca Traffic Overloading
+   testID: 11843145   7.2.17 VLAN Pass Through
+   testID: 11723379   7.2.18 VLAN Tagging over Home Owner WiFi
+   testID: 11722378   7.2.19 VLAN Tagging over Guest WiFi
+   testID: 11721378   7.2.2 Verify BRUNO (connected to BRUNO-IS) can obtain
+                            IPv4 address via RG's DHCP service
+   testID: 11792173   7.2.20 VLAN Tag Removal
+   testID: 11721382   7.2.21 IPv6 Verify subnet with /56, /64 length
+   testID: 11843141   7.2.5 Verify client can get correct IPv4 address if
+                            the RG changes DHCP address pool
+   testID: 11721379   7.2.7 Verify time offset information obtained via
+                            DHCP option2
+"""
+
+__author__ = 'Lehan Meng (lmeng@google.com)'
+
+
+import re
+import time
+
+import device
+import ip
+import ssh
+import testCase
+
+
+class BasicNetworkingTest(testCase.TestCase):
+  """Class for test cases of Bruno networking features.
+
+      Configuration Parameters:
+      testID: 11874111/11724363/11843145/11723379
+              /11722378/11721378/11792173/11721382/
+              /11843141/11721379
+      addr = Bruno's IP address
+      user = root
+      pwd = google
+      bruno_prompt = gfibertv#
+      file = cmdOutput.txt
+      title = Basic_Networking
+  """
+
+  def Init(self):
+    """Initialize the networking feature tests."""
+    # Get all device information.
+    info = self.log.CreateResultInfo(
+        '---', 'Networking test verification started...')
+    self.log.SendLine(self.test_info, info)
+    self.bruno = device.Bruno(user=self.params['user'],
+                              addr=self.params['addr'],
+                              bruno_prompt=self.params['bruno_prompt'],
+                              addr_ipv6=self.params['addr_ipv6'])
+    self.bruno.SetLogging(self.log)
+    if not self.p_ssh:
+      self.p_ssh = ssh.SSH(user=self.params['user'],
+                           addr=self.params['addr'],
+                           bruno_prompt=self.params['bruno_prompt'],
+                           addr_ipv6=self.params['addr_ipv6'])
+    self.bruno.dev_ssh = self.p_ssh
+    self.p_ssh.SetLogging(self.log)
+    return
+
+  def SshTunnel(self):
+    """Create ssh tunnel for the test."""
+    self.p_ssh.SshRetry(5, 15)
+    return
+
+  def VerifyDuplicatedAddress(self, ip_addr):
+    """Verify device can detect duplicated ipv6 address existing in network.
+
+    Set a duplicated ip address on the device.
+    Verify that the device can detect duplicated ip address
+
+    Args:
+      ip_addr: the duplicated address
+    Returns:
+      True: if duplicated detected
+      False: if duplicated address is not detected
+    """
+    time_stamp = self.bruno.GetTimeStamp()
+    self.bruno.dev_ssh.SendCmd('ip -6 addr add ' + ip_addr + '/64 dev br0')
+    time.sleep(1)
+    self.bruno.dev_ssh.SendCmd('dmesg | grep detected')
+    log_list = self.bruno.dev_ssh.GetCmdOutput()
+
+    pattern_line = ('\[\s*\d*\.\d{3}\]\s*\w*\d:\s* IPv6 duplicate address\s*('
+                    + ip_addr + ')\s*[/\d+]*\s*detected!')
+    self.bruno.dev_ssh.SendCmd('ip -6 addr del ' + ip_addr + '/64 dev br0')
+
+    if self.bruno.FindLineInLog(log_list, time_stamp, pattern_line):
+      info = self.log.CreateResultInfo('Pass', 'Duplicated IPv6 address '
+                                       'detected: ' + ip_addr)
+      self.log.SendLine(self.test_info, info)
+    else:
+      info = self.log.CreateResultInfo('Failed',
+                                       'Duplicated IPv6 address not detected: '
+                                       + ip_addr + '. Verification Failed!')
+      self.log.SendLine(self.test_info, info)
+    #[132344.324] br0: IPv6 duplicate address fe80:... detected!
+
+  def GetIPv4Address(self):
+    """Test Bruno IP address. testID: 11874104."""
+    # Use ifconfig to check interface IP address
+    self.p_ssh.SendCmd(r'ifconfig br0')
+    line = self.p_ssh.GetCmdOutput(3)[1]
+
+    # Get Bruno IP address
+    address = ip.IPADDR(line).IsLikeIpv4Address()
+    if address is not None:
+      ip.IPADDR(address).IsValidIpv4Address()
+      info = self.log.CreateProgressInfo('---',
+                                         'Verify IP: Bruno has IP address '
+                                         + address)
+      self.log.SendLine(self.test_info, info)
+      return address
+    else:
+      info = self.log.CreateErrorInfo('critical',
+                                      'Error! Bruno does not have IP address!'
+                                      ' Exit!')
+      self.log.SendLine(self.test_info, info)
+      return False
+
+    def GetNetMask(self):
+      """Get Netmask from device."""
+      self.p_ssh.SendCmd(r'ifconfig br0')
+      line = self.p_ssh.GetCmdOutput(3)[1]
+
+      netmask = re.search(r'mask [0-9]+(?:\.[0-9]+){3}', line).group()
+      address = ip.IPADDR(netmask).IsLikeIpv4Address()
+      if address is not None:
+        ip.IPADDR(address).IsValidIpv4Address()
+        info = self.log.CreateProgressInfo('---',
+                                           'Verify IP: Bruno has netmask: '
+                                           + address)
+        self.log.SendLine(self.test_info, info)
+        return address
+      else:
+        info = self.log.CreateErrorInfo('critical',
+                                        'Error! Bruno does not have netmask!'
+                                        ' Exit!')
+        self.log.SendLine(self.test_info, info)
+      return False
+
+  def VerifyIPv6(self):
+    """Test Bruno IPv6 address. testID: 11722376."""
+    # Use ip addr to check interface IPv6 address
+    self.p_ssh.SendCmd(r'ip addr show dev br0')
+
+    for line in reversed(self.p_ssh.p_ssh.before.splitlines()[-10:]):
+      ipv6_addr = re.search('inet6.*dynamic', line)
+      # Get Bruno IPv6 address
+      if ipv6_addr is not None:
+        info = self.log.CreateProgressInfo('---',
+                                           'Verify IPv6: '
+                                           'Bruno has IPv6 address: '
+                                           + ipv6_addr.group())
+        self.log.SendLine(self.test_info, info)
+        break
+    else:
+      info = self.log.CreateErrorInfo('intermediate',
+                                      'Wanring! '
+                                      'Bruno did not have IPv6 address')
+      self.log.SendLine(self.test_info, info)
+    return
+
+  def VerifyDHCPOverBrunoIS(self):
+    """Verify Bruno (connected to Bruno-IS) can get IPv4 address from RG.
+
+    test ID: 11721378
+    This test requires thinBruno is connected to FatBruno, then to RG.
+    """
+    ip_addr = self.GetIPv4Address()
+    if ip_addr:
+      info = self.log.CreateResultInfo('Pass', 'Bruno can get IP address from '
+                                       'RG while connecting to Bruno-IS. '
+                                       'IP address: '+ ip_addr)
+      self.log.SendLine(self.test_info, info)
+    else:
+      info = self.log.CreateResultInfo('Failed',
+                                       'Bruno cannot get IP address from '
+                                       'RG. Verification Failed!')
+      self.log.SendLine(self.test_info, info)
+
+  def Run(self):
+    """Run the test case."""
+    ####### Add your code here -- BEGIN #######
+    print 'Test Started...'
+
+    self.Init()
+    time.sleep(2)  # time delay between commands issued to Device
+    self.SshTunnel()
+
+    self.VerifyIPv6()
+
+    if self.test_info['testID'] == '11874111':
+      ip_addr = self.params['addr_ipv6_dup']
+      self.VerifyDuplicatedAddress(ip_addr)
+    elif self.test_info['testID'] == '11721378':
+      self.VerifyDHCPOverBrunoIS()
+
+    # TODO(lmeng): Test cases: '11724363', '11843145', '11723379', '11722378',
+    # '11792173', '11721382', '11843141', '11721379'
+
+    print 'Test Completed...'
+    ####### Add your code here -- END   #######
+
+  def Destructor(self):
+    """This is the destructor function to call for the user extened class."""
+    self.p_ssh.close()
+
+if __name__ == '__main__':
+  # Test cases defined in this file:
+  test_defined = ['11874111', '11724363', '11843145', '11723379', '11722378',
+                  '11721378', '11792173', '11721382', '11843141', '11721379']
+  # To execute test cases that defined in config file:
+  test_to_execute = testCase.TestCase.FindTestCaseToExecute('config.cfg')
+  for test_id in test_to_execute:
+    if test_id in test_defined:
+      test = BasicNetworkingTest(testID=test_id)
diff --git a/checkall b/checkall
new file mode 100755
index 0000000..bd5aa40
--- /dev/null
+++ b/checkall
@@ -0,0 +1,20 @@
+#!/bin/sh
+#
+# Display a one-line overview of whether each device is up.
+#
+mydir=$(dirname "$0")
+cd "$mydir"
+hosts=$(./config)
+
+out=
+./run $hosts -- 'ping -c1 -w1 -n $ip >/dev/null && echo yes || echo no' |
+sort | (
+  while read name ok; do
+    case "$ok" in
+      yes) out="$out${name%:}  " ;;
+      no)  out="$out^${name%:} " ;;
+      *)   ( echo; echo "Unexpected: '$name' '$ok'" ) >&2 ;;
+    esac
+  done
+  echo "$out"
+)
diff --git a/config.cfg b/config.cfg
index 6659a21..ea3fef7 100644
--- a/config.cfg
+++ b/config.cfg
@@ -1,39 +1,126 @@
-##############################################
-# This is the config file for the test cases #
-#                                            #
-# All test cases share the same config file. #
-# Each test case configuration starts with   #
-# the testID of that test case.              #
-#                                            #
-# comment line starts with '#' and will not  #
-# be parsed as configuration information     #
-##############################################
-testID: 11843140
-user = root
-addr = 192.168.1.4
-addr_ipv6 = 2605:a601:15:9001:21a:11ff:fe30:64d5
-pwd = google
-bruno_prompt = gfibertv#
-title =Image_Download
-expected_version_id=481109
-expected_version=bruno-jaguar-3
-downgrade_version=bruno-koala-2
-downgrade_version_id=662005
-ACS_URL = https://gfiber-acs-staging.appspot.com/cwmp
-# if authentication server is required to access the device
-jump_server = jmp.googlefiber.net
-# if athena server is required to access the device:
-athena_user = lmeng
-athena_pwd = changeme
+{
+      "Image_Download":{
+        "comment":["this is a comment line",
+                   "this configuration profile is for ImageDownload test case",
+                   "the acs_path is the google3 repository where upgrade_test.py locates. This test depends on it to modify ACS datastore."],
+        "testID": ["11843140", "14165036"],
+        "title" : {"11843140":"Image_Download", "14165036":"DownloadInterrupt"},
+        "user" : "root",
+        "addr" : "192.168.1.4",
+        "addr_ipv6" : "2605:a601:fe00:fd18:21a:11ff:fe30:64e6",
+        "pwd" : "google",
+        "bruno_prompt" : "gfibertv#",
+        "expected_version_id": "987010",
+        "expected_version": "bruno-monkey-4",
+        "downgrade_version": "bruno-monkey-3",
+        "downgrade_version_id": "1038003",
+        "acs_url" : "https://gfiber-acs-staging.appspot.com/cwmp",
+        "acs_path": "/home/lmeng/git_project/google3/isp/gfiber/testing/automated_tests/upgrade_test/",
+        "acs_app_id": "gfiber-acs-staging",
+        "acs_host_name": "gfiber-acs-staging.appspot.com",
+        "jump_server" : "jmp.googlefiber.net",
+        "athena_user" : "your_uname",
+        "athena_pwd" : "your_pwd",
+        "profile_id" : "557001"
+      },
 
+      "basic_network_testcases":{
+        "comment":["addr_ipv6_dup: the duplicated address to set on device, in",
+                   "or der to detect the address duplication error."],
+        "testID": ["11874111", "11721378"],
+        "title" : {"11874111":"DuplicateIPv6Addr", "11721378":"DHCPv4OverBruno-IS"},
+        "user" : "root",
+        "addr" : "192.168.1.4",
+        "addr_ipv6" : "2605:a601:fe00:fd18:21a:11ff:fe30:64e6",
+        "bruno_prompt" : "gfibertv#",
+        "expected_version_id": "987010",
+        "expected_version": "bruno-monkey-4",
+        "addr_ipv6_dup":"2605:a601:fe00:fd18:21a:11ff:fe30:6383"
+      },
+      
+      "dataModel":{
+        "testID": ["14187024", "14165033", "14315008", "14165035", "14314007",
+                   "11865133", "14335001", "14266498", "14319149", "14314008",
+                   "11722375", "14315009", "14314009", "14165038", "15643845"],
+        "title" : {"14187024":"TR140_DataModel",
+                   "14165033":"GVSB_DataModel",
+                   "14315008":"TR098_DataModel",
+                   "14165035":"MoCA_DataModel",
+                   "14314007":"TR181_DataModel",
+                   "11865133":"TR135_DataModel",
+                   "14335001":"X_CATAWAMPUS-ORG_DataModel",
+                   "14266498":"FlashDevice_DataModel",
+                   "14319149":"X_GOOGLE-COM_DataModel",
+                   "14314008":"TR157_DataModel",
+                   "11722375":"SetParameterValuesRPC",
+                   "14315009":"ManagementServerURL",
+                   "14314009":"MonitorTemperature",
+                   "14165038":"AutoChannelEnable",
+                   "15643845":"NTPTimeZoneConfig"},
+        "user" : "root",
+        "addr" : "192.168.1.4",
+        "addr_ipv6" : "2605:a601:fe00:fd18:21a:11ff:fe30:64e6",
+        "req_file" : "data/DataModel_requirement.cfg",
+        "bruno_prompt" : "gfibertv#",
+        "expected_version_id": "959004",
+        "expected_version": "bruno-monkey-2",
+        "acs_url" : "https://gfiber-acs-staging.appspot.com/cwmp",
+        "nbi_client_path" : "/home/lmeng/git_project/google3/blaze-bin/java/com/google/fiber/provisioning/acs/client/nbi/nbi_client",
+        "para_tree_file" : "ParameterTree.xml",
+        "from_which_param_to_set": "None",
+        "param_path" : "."
+      },
+      
+      "dataModel_WiFi":{
+        "comment":["wifi_params type: e.g., string_value, is the data type accepted by nbi_client RPC call."],
+        "testID": ["14165034"],
+        "title" : {"14165034":"WiFi_configuration"},
+        "user" : "root",
+        "addr" : "192.168.1.4",
+        "addr_ipv6" : "2605:a601:fe00:fd18:21a:11ff:fe30:64e6",
+        "bruno_prompt" : "gfibertv#",
+        "expected_version_id": "987010",
+        "expected_version": "bruno-monkey-4",
+        "acs_url" : "https://gfiber-acs-staging.appspot.com/cwmp",
+        "nbi_client_path" : "/home/lmeng/git_project/google3/blaze-bin/java/com/google/fiber/provisioning/acs/client/nbi/nbi_client",
+        "account_id":"5438577436",
+        "device_label":"0101209088BC",
+        "wifi_params":{
+            "Google.Wifi.SSID":{"string_value":"Home"},
+            "Google.Wifi.Home.SSID_2GHz":{"string_value":"Home"},
+            "Google.Wifi.Enable":{"boolean_value":"true"},
+            "Google.Wifi.BeaconType":{"string_value": "Basic"},
+            "Google.Wifi.BasicEncryptionModes":{"string_value":"WEPEncryption"}}
+      },
 
+      "basic_tr069_test_case":{
+        "comment":["Factory_reset test case needs to manually reset the device"],
+        "testID": ["11865129", "11721375"],
+        "title" : {"11865129":"IPv6_Connection",
+                   "11721375":"Factory_Reset"
+                  },
+        "user" : "root",
+        "addr" : {"value":"192.168.1.4", "comment":"device ipv4 address"},
+        "expected_version": "bruno-monkey-4",
+        "addr_ipv6" : {"value":"2605:a601:fe00:fd18:21a:11ff:fe30:6383",
+                       "comment":"device ipv6 address"},
+        "acs_ipv6" : "2001:4860:8005::8d",
+        "gvsb_host": "https://gvsb.e2e.gfsvc.com/rpc",
+        "acs_url" : "https://acs.e2e.gfsvc.com/cwmp",
+        "bruno_prompt" : "gfibertv#"
+      },
+      
+      "blocked_test_case":{
+        "testID": ["14314009", "14165038"],
+        "title" : {"14314009":"MonitorTemperature",
+                   "14165038":"AutoChannelEnable"},
+        "user" : "root",
+        "addr" : "192.168.1.4",
+        "addr_ipv6" : "2605:a601:fe00:fd18:21a:11ff:fe30:64e6",
+        "bruno_prompt" : "gfibertv#"
+      }
+}
 
-#testID: 14187024
-#title =DataModel
-#rq_file = 14187024-requirement.req
-#device_mURL = http://[2607:f8b0:400b:800::1011]/
-#device_IP = 2607:f8b0:400b:800::1011
-#serial_NO =
 
 
 
diff --git a/configs/core.py b/configs/core.py
index 1f751a1..f85e2fa 100644
--- a/configs/core.py
+++ b/configs/core.py
@@ -35,7 +35,7 @@
       if ival == False: ival = None
       if value == False: value = None
       if value == True and ival:
-        return True  # any nonempty value is true, so match it
+        continue  # any nonempty value is true, so match it
       if ival != value:
         return False
     return True
diff --git a/configs/core_test.py b/configs/core_test.py
index db97834..21b1f5f 100644
--- a/configs/core_test.py
+++ b/configs/core_test.py
@@ -14,20 +14,33 @@
 def testConfigCore():
   hosts = core.Hosts()
   WVPASSEQ(len(hosts), 0)
-  h = hosts.FindOrAdd(ether='11:22:33:44:55:66')
-  h.Set(name='testname', ip='1.2.3.4')
-  h.platform = 'bob'
+  h1 = hosts.FindOrAdd(ether='11:22:33:44:55:66')
+  h1.Set(name='testname', ip='1.2.3.4')
+  h1.platform = 'bob'
   WVPASSEQ(len(hosts), 1)
-  h2 = hosts.FindOrAdd(ip='1.2.3.4')
+  h1b = hosts.FindOrAdd(ip='1.2.3.4')
   WVPASSEQ(len(hosts), 1)
-  WVPASSEQ(h2.name, 'testname')
-  WVPASSEQ(h2.ether, '11:22:33:44:55:66')
-  WVPASSEQ(h, h2)
+  WVPASSEQ(h1b.name, 'testname')
+  WVPASSEQ(h1b.ether, '11:22:33:44:55:66')
+  WVPASSEQ(h1, h1b)
 
   # test Host.Query()
-  WVPASSEQ(hosts.Query(ip=True), [h])
+  WVPASSEQ(hosts.Query(ip=True), [h1])
   WVPASSEQ(hosts.Query(ip=False), [])
-  WVPASSEQ(hosts.Query(ip='1.2.3.4'), [h])
+  WVPASSEQ(hosts.Query(ip='1.2.3.4'), [h1])
   WVPASSEQ(hosts.Query(ip='1.2.3.5'), [])
   WVPASSEQ(hosts.Query(ip='1.2.3.4', maxcount=0), [])
   WVEXCEPT(core.QueryError, hosts.Query, ip='1.2.3.5', mincount=1)
+
+  # add a second host
+  h2 = hosts.FindOrAdd(ether='22:33:44:22:33:44')
+  h2.Set(name='test2')
+
+  WVPASSEQ(len(hosts), 2)
+  WVPASSEQ(hosts.Query(ip='1.2.3.4'), [h1])
+  WVPASSEQ(hosts.Query(ip=None), [h2])
+  WVPASSEQ(hosts.Query(name='test2'), [h2])
+  WVPASSEQ(hosts.Query(ip=True), [h1])
+  WVPASSEQ(sorted(hosts.Query(name=True)), sorted([h1, h2]))
+  WVPASSEQ(hosts.Query(ether=True, name='test2'), [h2])
+  WVPASSEQ(hosts.Query(ether=True, name='testname'), [h1])
diff --git a/data/DataModel_requirement.cfg b/data/DataModel_requirement.cfg
new file mode 100644
index 0000000..35f5a43
--- /dev/null
+++ b/data/DataModel_requirement.cfg
@@ -0,0 +1,296 @@
+Device.DeviceInfo.AdditionalHardwareVersion
+Device.DeviceInfo.AdditionalSoftwareVersion
+Device.DeviceInfo.Description
+Device.DeviceInfo.HardwareVersion
+Device.DeviceInfo.Manufacturer
+Device.DeviceInfo.ManufacturerOUI
+Device.DeviceInfo.MemoryStatus.Free
+Device.DeviceInfo.MemoryStatus.Total
+Device.DeviceInfo.ModelName
+Device.DeviceInfo.ProcessStatus.CPUUsage
+Device.DeviceInfo.ProcessStatus.Process.{i}.CPUTime
+Device.DeviceInfo.ProcessStatus.Process.{i}.Command
+Device.DeviceInfo.ProcessStatus.Process.{i}.PID
+Device.DeviceInfo.ProcessStatus.Process.{i}.Priority
+Device.DeviceInfo.ProcessStatus.Process.{i}.Size
+Device.DeviceInfo.ProcessStatus.Process.{i}.State
+Device.DeviceInfo.ProcessStatus.ProcessNumberOfEntries
+Device.DeviceInfo.ProcessorNumberOfEntries
+Device.DeviceInfo.ProductClass
+Device.DeviceInfo.SerialNumber
+Device.DeviceInfo.SoftwareVersion
+Device.DeviceInfo.SupportedDataModelNumberOfEntries
+Device.DeviceInfo.TemperatureStatus.TemperatureSensorNumberOfEntries
+Device.DeviceInfo.UpTime
+Device.DeviceInfo.VendorConfigFileNumberOfEntries
+Device.DeviceInfo.VendorLogFileNumberOfEntries
+Device.Ethernet.Interface.{i}.DuplexMode
+Device.Ethernet.Interface.{i}.Enable
+Device.Ethernet.Interface.{i}.LastChange
+Device.Ethernet.Interface.{i}.LowerLayers
+Device.Ethernet.Interface.{i}.MACAddress
+Device.Ethernet.Interface.{i}.MaxBitRate
+Device.Ethernet.Interface.{i}.Name
+Device.Ethernet.Interface.{i}.Stats.BroadcastPacketsReceived
+Device.Ethernet.Interface.{i}.Stats.BroadcastPacketsSent
+Device.Ethernet.Interface.{i}.Stats.BytesReceived
+Device.Ethernet.Interface.{i}.Stats.BytesSent
+Device.Ethernet.Interface.{i}.Stats.DiscardPacketsReceived
+Device.Ethernet.Interface.{i}.Stats.DiscardPacketsSent
+Device.Ethernet.Interface.{i}.Stats.ErrorsReceived
+Device.Ethernet.Interface.{i}.Stats.ErrorsSent
+Device.Ethernet.Interface.{i}.Stats.MulticastPacketsReceived
+Device.Ethernet.Interface.{i}.Stats.MulticastPacketsSent
+Device.Ethernet.Interface.{i}.Stats.PacketsReceived
+Device.Ethernet.Interface.{i}.Stats.PacketsSent
+Device.Ethernet.Interface.{i}.Stats.UnicastPacketsReceived
+Device.Ethernet.Interface.{i}.Stats.UnicastPacketsSent
+Device.Ethernet.Interface.{i}.Stats.UnknownProtoPacketsReceived
+Device.Ethernet.Interface.{i}.Status
+Device.Ethernet.Interface.{i}.Upstream
+Device.Ethernet.Interface.{i}.X_CATAWAMPUS-ORG_ActualBitRate
+Device.Ethernet.Interface.{i}.X_CATAWAMPUS-ORG_ActualDuplexMode
+Device.Ethernet.InterfaceNumberOfEntries
+Device.Ethernet.LinkNumberOfEntries
+Device.Ethernet.VLANTerminationNumberOfEntries
+Device.InterfaceStackNumberOfEntries
+Device.ManagementServer.CWMPRetryIntervalMultiplier
+Device.ManagementServer.CWMPRetryMinimumWaitInterval
+Device.ManagementServer.ConnectionRequestPassword
+Device.ManagementServer.ConnectionRequestURL
+Device.ManagementServer.ConnectionRequestUsername
+Device.ManagementServer.DefaultActiveNotificationThrottle
+Device.ManagementServer.EnableCWMP
+Device.ManagementServer.ManageableDeviceNumberOfEntries
+Device.ManagementServer.ParameterKey
+Device.ManagementServer.Password
+Device.ManagementServer.PeriodicInformEnable
+Device.ManagementServer.PeriodicInformInterval
+Device.ManagementServer.PeriodicInformTime
+Device.ManagementServer.STUNEnable
+Device.ManagementServer.URL
+Device.ManagementServer.UpgradesManaged
+Device.ManagementServer.Username
+Device.MoCA.Interface.{i}.AssociatedDevice.{i}.MACAddress
+Device.MoCA.Interface.{i}.AssociatedDevice.{i}.NodeID
+Device.MoCA.Interface.{i}.AssociatedDevice.{i}.PHYRxRate
+Device.MoCA.Interface.{i}.AssociatedDevice.{i}.PHYTxRate
+Device.MoCA.Interface.{i}.AssociatedDevice.{i}.PacketAggregationCapability
+Device.MoCA.Interface.{i}.AssociatedDevice.{i}.PreferredNC
+Device.MoCA.Interface.{i}.AssociatedDevice.{i}.QAM256Capable
+Device.MoCA.Interface.{i}.AssociatedDevice.{i}.RxBcastPowerLevel
+Device.MoCA.Interface.{i}.AssociatedDevice.{i}.RxErroredAndMissedPackets
+Device.MoCA.Interface.{i}.AssociatedDevice.{i}.RxPackets
+Device.MoCA.Interface.{i}.AssociatedDevice.{i}.RxPowerLevel
+Device.MoCA.Interface.{i}.AssociatedDevice.{i}.RxSNR
+Device.MoCA.Interface.{i}.AssociatedDevice.{i}.TxBcastRate
+Device.MoCA.Interface.{i}.AssociatedDevice.{i}.TxPackets
+Device.MoCA.Interface.{i}.AssociatedDevice.{i}.TxPowerControlReduction
+Device.MoCA.Interface.{i}.AssociatedDeviceNumberOfEntries
+Device.MoCA.Interface.{i}.BackupNC
+Device.MoCA.Interface.{i}.CurrentOperFreq
+Device.MoCA.Interface.{i}.CurrentVersion
+Device.MoCA.Interface.{i}.Enable
+Device.MoCA.Interface.{i}.FirmwareVersion
+Device.MoCA.Interface.{i}.HighestVersion
+Device.MoCA.Interface.{i}.LastChange
+Device.MoCA.Interface.{i}.LastOperFreq
+Device.MoCA.Interface.{i}.LowerLayers
+Device.MoCA.Interface.{i}.MACAddress
+Device.MoCA.Interface.{i}.Name
+Device.MoCA.Interface.{i}.NetworkCoordinator
+Device.MoCA.Interface.{i}.NodeID
+Device.MoCA.Interface.{i}.PacketAggregationCapability
+Device.MoCA.Interface.{i}.PrivacyEnabled
+Device.MoCA.Interface.{i}.QAM256Capable
+Device.MoCA.Interface.{i}.Stats.BroadcastPacketsReceived
+Device.MoCA.Interface.{i}.Stats.BroadcastPacketsSent
+Device.MoCA.Interface.{i}.Stats.BytesReceived
+Device.MoCA.Interface.{i}.Stats.BytesSent
+Device.MoCA.Interface.{i}.Stats.DiscardPacketsReceived
+Device.MoCA.Interface.{i}.Stats.DiscardPacketsSent
+Device.MoCA.Interface.{i}.Stats.ErrorsReceived
+Device.MoCA.Interface.{i}.Stats.ErrorsSent
+Device.MoCA.Interface.{i}.Stats.MulticastPacketsReceived
+Device.MoCA.Interface.{i}.Stats.MulticastPacketsSent
+Device.MoCA.Interface.{i}.Stats.PacketsReceived
+Device.MoCA.Interface.{i}.Stats.PacketsSent
+Device.MoCA.Interface.{i}.Stats.UnicastPacketsReceived
+Device.MoCA.Interface.{i}.Stats.UnicastPacketsSent
+Device.MoCA.Interface.{i}.Stats.UnknownProtoPacketsReceived
+Device.MoCA.Interface.{i}.Status
+Device.MoCA.Interface.{i}.Upstream
+Device.MoCA.InterfaceNumberOfEntries
+Device.PeriodicStatistics.MaxReportSamples
+Device.PeriodicStatistics.MinSampleInterval
+Device.PeriodicStatistics.SampleSet.{i}.Enable
+Device.PeriodicStatistics.SampleSet.{i}.FetchSamples
+Device.PeriodicStatistics.SampleSet.{i}.Name
+Device.PeriodicStatistics.SampleSet.{i}.Parameter.{i}.CalculationMode
+Device.PeriodicStatistics.SampleSet.{i}.Parameter.{i}.Enable
+Device.PeriodicStatistics.SampleSet.{i}.Parameter.{i}.Failures
+Device.PeriodicStatistics.SampleSet.{i}.Parameter.{i}.HighThreshold
+Device.PeriodicStatistics.SampleSet.{i}.Parameter.{i}.LowThreshold
+Device.PeriodicStatistics.SampleSet.{i}.Parameter.{i}.Reference
+Device.PeriodicStatistics.SampleSet.{i}.Parameter.{i}.SampleMode
+Device.PeriodicStatistics.SampleSet.{i}.Parameter.{i}.SampleSeconds
+Device.PeriodicStatistics.SampleSet.{i}.Parameter.{i}.SuspectData
+Device.PeriodicStatistics.SampleSet.{i}.Parameter.{i}.Values
+Device.PeriodicStatistics.SampleSet.{i}.ParameterNumberOfEntries
+Device.PeriodicStatistics.SampleSet.{i}.ReportEndTime
+Device.PeriodicStatistics.SampleSet.{i}.ReportSamples
+Device.PeriodicStatistics.SampleSet.{i}.ReportStartTime
+Device.PeriodicStatistics.SampleSet.{i}.SampleInterval
+Device.PeriodicStatistics.SampleSet.{i}.SampleSeconds
+Device.PeriodicStatistics.SampleSet.{i}.Status
+Device.PeriodicStatistics.SampleSet.{i}.TimeReference
+Device.PeriodicStatistics.SampleSetNumberOfEntries
+Device.Services.STBService.{i}.Components.FrontEnd.{i}.IP.IGMP.ClientGroup.{i}.GroupAddress
+Device.Services.STBService.{i}.Components.FrontEnd.{i}.IP.IGMP.ClientGroupNumberOfEntries
+Device.Services.STBService.{i}.Components.FrontEndNumberOfEntries
+Device.Services.STBServiceNumberOfEntries
+Device.Services.StorageServices.Capabilities.FTPCapable
+Device.Services.StorageServices.Capabilities.HTTPCapable
+Device.Services.StorageServices.Capabilities.HTTPSCapable
+Device.Services.StorageServices.Capabilities.HTTPWritable
+Device.Services.StorageServices.Capabilities.SFTPCapable
+Device.Services.StorageServices.Capabilities.SupportedFileSystemTypes
+Device.Services.StorageServices.Capabilities.SupportedNetworkProtocols
+Device.Services.StorageServices.Capabilities.SupportedRaidTypes
+Device.Services.StorageServices.Capabilities.VolumeEncryptionCapable
+Device.Services.StorageServices.Enable
+Device.Services.StorageServices.LogicalVolume.{i}.Capacity
+Device.Services.StorageServices.LogicalVolume.{i}.Enable
+Device.Services.StorageServices.LogicalVolume.{i}.FileSystem
+Device.Services.StorageServices.LogicalVolume.{i}.FolderNumberOfEntries
+Device.Services.StorageServices.LogicalVolume.{i}.Name
+Device.Services.StorageServices.LogicalVolume.{i}.Status
+Device.Services.StorageServices.LogicalVolume.{i}.ThresholdLimit
+Device.Services.StorageServices.LogicalVolume.{i}.UsedSpace
+Device.Services.StorageServices.LogicalVolume.{i}.X_CATAWAMPUS-ORG_ReadOnly
+Device.Services.StorageServices.LogicalVolumeNumberOfEntries
+Device.Services.StorageServices.PhysicalMedium.{i}.Capacity
+Device.Services.StorageServices.PhysicalMedium.{i}.ConnectionType
+Device.Services.StorageServices.PhysicalMedium.{i}.FirmwareVersion
+Device.Services.StorageServices.PhysicalMedium.{i}.Health
+Device.Services.StorageServices.PhysicalMedium.{i}.HotSwappable
+Device.Services.StorageServices.PhysicalMedium.{i}.Model
+Device.Services.StorageServices.PhysicalMedium.{i}.Name
+Device.Services.StorageServices.PhysicalMedium.{i}.Removable
+Device.Services.StorageServices.PhysicalMedium.{i}.SMARTCapable
+Device.Services.StorageServices.PhysicalMedium.{i}.SerialNumber
+Device.Services.StorageServices.PhysicalMedium.{i}.Vendor
+Device.Services.StorageServices.PhysicalMediumNumberOfEntries
+Device.Services.StorageServices.StorageArrayNumberOfEntries
+Device.Services.StorageServices.UserAccountNumberOfEntries
+Device.Services.StorageServices.UserGroupNumberOfEntries
+Device.Services.StorageServices.X_CATAWAMPUS-ORG_FlashMedia.{i}.BadEraseBlocks
+Device.Services.StorageServices.X_CATAWAMPUS-ORG_FlashMedia.{i}.CorrectedErrors
+Device.Services.StorageServices.X_CATAWAMPUS-ORG_FlashMedia.{i}.EraseBlockSize
+Device.Services.StorageServices.X_CATAWAMPUS-ORG_FlashMedia.{i}.IOSize
+Device.Services.StorageServices.X_CATAWAMPUS-ORG_FlashMedia.{i}.MaxEraseCount
+Device.Services.StorageServices.X_CATAWAMPUS-ORG_FlashMedia.{i}.Name
+Device.Services.StorageServices.X_CATAWAMPUS-ORG_FlashMedia.{i}.ReservedEraseBlocks
+Device.Services.StorageServices.X_CATAWAMPUS-ORG_FlashMedia.{i}.SubVolume.{i}.DataBytes
+Device.Services.StorageServices.X_CATAWAMPUS-ORG_FlashMedia.{i}.SubVolume.{i}.Name
+Device.Services.StorageServices.X_CATAWAMPUS-ORG_FlashMedia.{i}.SubVolume.{i}.Status
+Device.Services.StorageServices.X_CATAWAMPUS-ORG_FlashMedia.{i}.SubVolumeNumberOfEntries
+Device.Services.StorageServices.X_CATAWAMPUS-ORG_FlashMedia.{i}.TotalEraseBlocks
+Device.Services.StorageServices.X_CATAWAMPUS-ORG_FlashMedia.{i}.UncorrectedErrors
+Device.Services.StorageServices.X_CATAWAMPUS-ORG_FlashMediaNumberOfEntries
+InternetGatewayDevice.DeviceInfo.AdditionalHardwareVersion
+InternetGatewayDevice.DeviceInfo.AdditionalSoftwareVersion
+InternetGatewayDevice.DeviceInfo.Description
+InternetGatewayDevice.DeviceInfo.HardwareVersion
+InternetGatewayDevice.DeviceInfo.Manufacturer
+InternetGatewayDevice.DeviceInfo.ManufacturerOUI
+InternetGatewayDevice.DeviceInfo.ModelName
+InternetGatewayDevice.DeviceInfo.ModemFirmwareVersion
+InternetGatewayDevice.DeviceInfo.ProductClass
+InternetGatewayDevice.DeviceInfo.SerialNumber
+InternetGatewayDevice.DeviceInfo.SoftwareVersion
+InternetGatewayDevice.DeviceInfo.SpecVersion
+InternetGatewayDevice.DeviceInfo.UpTime
+InternetGatewayDevice.DeviceInfo.VendorConfigFileNumberOfEntries
+InternetGatewayDevice.LANDevice.{i}.LANEthernetInterfaceNumberOfEntries
+InternetGatewayDevice.LANDevice.{i}.LANUSBInterfaceNumberOfEntries
+InternetGatewayDevice.LANDevice.{i}.LANWLANConfigurationNumberOfEntries
+InternetGatewayDevice.LANDeviceNumberOfEntries
+InternetGatewayDevice.ManagementServer.ConnectionRequestPassword
+InternetGatewayDevice.ManagementServer.ConnectionRequestURL
+InternetGatewayDevice.ManagementServer.ConnectionRequestUsername
+InternetGatewayDevice.ManagementServer.DefaultActiveNotificationThrottle
+InternetGatewayDevice.ManagementServer.EnableCWMP
+InternetGatewayDevice.ManagementServer.ParameterKey
+InternetGatewayDevice.ManagementServer.Password
+InternetGatewayDevice.ManagementServer.PeriodicInformEnable
+InternetGatewayDevice.ManagementServer.PeriodicInformInterval
+InternetGatewayDevice.ManagementServer.PeriodicInformTime
+InternetGatewayDevice.ManagementServer.URL
+InternetGatewayDevice.ManagementServer.UpgradesManaged
+InternetGatewayDevice.ManagementServer.Username
+InternetGatewayDevice.PeriodicStatistics.MaxReportSamples
+InternetGatewayDevice.PeriodicStatistics.MinSampleInterval
+InternetGatewayDevice.PeriodicStatistics.SampleSet.{i}.Enable
+InternetGatewayDevice.PeriodicStatistics.SampleSet.{i}.FetchSamples
+InternetGatewayDevice.PeriodicStatistics.SampleSet.{i}.Name
+InternetGatewayDevice.PeriodicStatistics.SampleSet.{i}.Parameter.{i}.CalculationMode
+InternetGatewayDevice.PeriodicStatistics.SampleSet.{i}.Parameter.{i}.Enable
+InternetGatewayDevice.PeriodicStatistics.SampleSet.{i}.Parameter.{i}.Failures
+InternetGatewayDevice.PeriodicStatistics.SampleSet.{i}.Parameter.{i}.HighThreshold
+InternetGatewayDevice.PeriodicStatistics.SampleSet.{i}.Parameter.{i}.LowThreshold
+InternetGatewayDevice.PeriodicStatistics.SampleSet.{i}.Parameter.{i}.Reference
+InternetGatewayDevice.PeriodicStatistics.SampleSet.{i}.Parameter.{i}.SampleMode
+InternetGatewayDevice.PeriodicStatistics.SampleSet.{i}.Parameter.{i}.SampleSeconds
+InternetGatewayDevice.PeriodicStatistics.SampleSet.{i}.Parameter.{i}.SuspectData
+InternetGatewayDevice.PeriodicStatistics.SampleSet.{i}.Parameter.{i}.Values
+InternetGatewayDevice.PeriodicStatistics.SampleSet.{i}.ParameterNumberOfEntries
+InternetGatewayDevice.PeriodicStatistics.SampleSet.{i}.ReportEndTime
+InternetGatewayDevice.PeriodicStatistics.SampleSet.{i}.ReportSamples
+InternetGatewayDevice.PeriodicStatistics.SampleSet.{i}.ReportStartTime
+InternetGatewayDevice.PeriodicStatistics.SampleSet.{i}.SampleInterval
+InternetGatewayDevice.PeriodicStatistics.SampleSet.{i}.SampleSeconds
+InternetGatewayDevice.PeriodicStatistics.SampleSet.{i}.Status
+InternetGatewayDevice.PeriodicStatistics.SampleSet.{i}.TimeReference
+InternetGatewayDevice.PeriodicStatistics.SampleSetNumberOfEntries
+InternetGatewayDevice.Time.CurrentLocalTime
+InternetGatewayDevice.Time.Enable
+InternetGatewayDevice.Time.LocalTimeZoneName
+InternetGatewayDevice.WANDeviceNumberOfEntries
+TraceRoute.DSCP
+TraceRoute.DataBlockSize
+TraceRoute.DiagnosticsState
+TraceRoute.Host
+TraceRoute.Interface
+TraceRoute.MaxHopCount
+TraceRoute.NumberOfTries
+TraceRoute.ResponseTime
+TraceRoute.RouteHopsNumberOfEntries
+TraceRoute.Timeout
+X_CATAWAMPUS-ORG_CATAWAMPUS.RuntimeEnvInfo
+X_GOOGLE-COM_GFIBERTV.Mailbox.Name
+X_GOOGLE-COM_GFIBERTV.Mailbox.Node
+X_GOOGLE-COM_GFIBERTV.Mailbox.NodeList
+X_GOOGLE-COM_GFIBERTV.Mailbox.Value
+X_GOOGLE-COM_GVSB.EpgPrimary
+X_GOOGLE-COM_GVSB.EpgSecondary
+X_GOOGLE-COM_GVSB.GvsbChannelLineup
+X_GOOGLE-COM_GVSB.GvsbKick
+X_GOOGLE-COM_GVSB.GvsbServer
+STBService.{i}.ServiceMonitoring.MainStream.{i}.Total.MPEG2TSStats.TSPacketsReceived
+STBService.{i}.ServiceMonitoring.MainStream.{i}.Total.MPEG2TSStats.PacketDiscontinuityCounter
+STBService.{i}.ServiceMonitoring.MainStream.{i}.Total.DejitteringStats.EmptyBufferTime
+STBService.{i}.ServiceMonitoring.MainStream.{i}.Total.DejitteringStats.Overruns
+STBService.{i}.ServiceMonitoring.MainStream.{i}.Total.DejitteringStats.Underruns
+STBService.{i}.ServiceMonitoring.MainStream.{i}.Total.TCPStats.PacketsReceived
+STBService.{i}.ServiceMonitoring.MainStream.{i}.Total.TCPStats.PacketsRetransmitted
+STBService.{i}.ServiceMonitoring.MainStream.{i}.Total.TCPStats.BytesReceived
+STBService.{i}.Components.HDMI.{i}.DisplayDevice.Status
+STBService.{i}.Components.HDMI.{i}.DisplayDevice.SupportedResolutions
+STBService.{i}.Components.HDMI.{i}.DisplayDevice.PreferredResolution
+STBService.{i}.Components.HDMI.{i}.ResolutionValue
+STBService.{i}.Components.HDMI.{i}.DisplayDevice.EEDID
+STBService.{i}.Components.HDMI.{i}.DisplayDevice.AutoLipSyncSupport
+STBService.{i}.Components.HDMI.{i}.DisplayDevice.VideoLatency
+STBService.{i}.Components.HDMI.{i}.DisplayDevice.HDMI3DPresent
+STBService.{i}.Components.HDMI.{i}.DisplayDevice.CECSupport
diff --git a/dataModel.py b/dataModel.py
new file mode 100755
index 0000000..af45a0b
--- /dev/null
+++ b/dataModel.py
@@ -0,0 +1,1430 @@
+#!/usr/bin/python
+# Copyright 2012 Google Inc. All Rights Reserved.
+
+"""This test performs TR069 related DataModel verification.
+
+This class extends the TestCase class, it does the following:
+  1. Configure/Verify Bruno with correct TR69 parameters:
+       - ACS URL
+       - Image Version
+  2. Verify Bruno has connection to ACS (IPv6/IPv4)
+  3. Set/Get TR69 data model parameters:
+       -  getParameterNames()
+       -  getParameterValues()
+  4. Data mode:
+       - Data Models for GVSB
+       - Data Models for TR098
+       - Data Models for MoCA
+       - Data Models for TR140
+       - Data Models for TR181
+  5. This file includes the following test cases:
+       (all data models test case are pending on bug: http://b/issue?id=6813492
+        SetParameterValues does not work currently)
+       - testID: 14165033  7.6.13 Support of Data Models for GVSB (TBD)
+       - testID: 14315008  7.6.14 Support of Data Models for TR098
+       - testID: 14165035  7.6.15 Support of Data Models for MoCA
+       - testID: 14187024  7.6.16 Support of Data Models for TR140
+       - testID: 14314007  7.6.17 Support of Data Models for TR181
+       - testID: 11865133  7.6.9.1 Support of Data Models: TR135
+       - testID: 14335001  7.6.31 Implement X_CATAWAMPUS-ORG parameters
+       - testID: 14319149  7.6.29 Implement X_GOOGLE-COM data model for Sage
+                                  information
+       - testID: 14314008  7.6.30 Implement tr-157 PeriodicStatistics
+
+       - testID: 14315009  7.6.20 Support of modification of
+                                  InternetGatewayDevice.ManagementServer.URL
+       - testID: 14314009  7.6.35 Monitor temperature
+       - testID: 14266498  7.6.36 X_CATAWAMPUS-ORG_FlashDevice Storage data
+                                  model (for tracking flash wear)
+       - testID: 14165038  7.6.37 Implement AutoChannelEnable in catawampus
+       - testID: 11722375  7.6.6  TR069 - SetParameter RPC Request
+       - testID: 15643845  7.6.39 NTP-Time zone configuration
+       - testID: 14165034  7.6.14.1 WiFi Test: ACS configuration
+"""
+
+__author__ = 'Lehan Meng (lmeng@google.com)'
+
+
+import os
+import re
+import string
+import time
+import xml.etree.ElementTree as ET
+
+import acs
+import device
+import ssh
+import testCase
+
+
+class DataModelTest(testCase.TestCase):
+  """Class for TR69 DataModel and parameter verification test.
+
+  Configuration Parameters:
+    TBD
+    testID: 14187024
+    title =DataModel
+    req_file = 14187024-requirement.req
+  """
+
+  def Init(self):
+    """Initialte the test case."""
+    info = self.log.CreateResultInfo(
+        '---', 'Data model verification test started...')
+    self.log.SendLine(self.test_info, info)
+    self.bruno = device.Bruno(user=self.params['user'],
+                              addr=self.params['addr'],
+                              pwd=self.params['pwd'],
+                              cmd_prompt=self.params['bruno_prompt'])
+    if not self.p_ssh:
+      self.p_ssh = ssh.SSH(user=self.params['user'],
+                           addr=self.params['addr'],
+                           pwd=self.params['pwd'],
+                           bruno_prompt=self.params['bruno_prompt'],
+                           addr_ipv6=self.params['addr_ipv6'])
+    self.p_ssh.SetLogging(self.log)
+    self.bruno.SetLogging(self.log)
+    self.bruno.dev_ssh = self.p_ssh
+
+    self.__short_delay = 30  #short delay: 5 seconds
+    self.__delay = 80  #medium delay: 180 seconds
+    self.__long_delay = 120  #long delay: 600 seconds
+
+    self.req_file = open(self.params['req_file'], 'r')
+    self.req_tr069_params = []
+    self.acs_instance = acs.ACS()
+    self.acs_instance.SetLogging(self.log)
+
+  def SetACSURL(self, url=None):
+    """Set the ACS URL on device."""
+    if not url:
+      url = self.params['acs_url']
+    self.p_ssh.SendCmd('echo '+ url + ' > /tmp/cwmp/acs_url')
+    self.p_ssh.GetCmdOutput()[1].rstrip()
+
+  def GetACSURL(self):
+    """Get ACS URL from Device."""
+    self.p_ssh.SendCmd(r'cat /tmp/cwmp/acs_url')
+    line = self.p_ssh.GetCmdOutput()[1].strip()
+    m = re.match('http[s]?://([\w-]+\.)+\.com/cwmp', line)
+    if m is None:
+      info = self.log.CreateErrorInfo('Warning',
+                                      'Can not get ACS url')
+      self.log.SendLine(None, info)
+    else:
+      info = self.log.CreateProgressInfo('---',
+                                         'Get ACS URL from device file: '
+                                         + line)
+      self.log.SendLine(None, info)
+    return line
+
+  def GetCurrentVersion(self):
+    """Get current software version."""
+    self.p_ssh.SendCmd('more /etc/version')
+    return self.p_ssh.GetCmdOutput()[1].strip()
+
+  def TestEnvCheck(self):
+    """Verify device configuration meets the test requirement."""
+    acs_url = self.GetACSURL()
+    if acs_url != self.params['acs_url']:
+      info = self.log.CreateErrorInfo(
+          'Warning', 'ACS URL incorrect!. Expected: '
+          + self.params['acs_url'] + ', Current: '
+          + acs_url)
+      self.log.SendLine(self.test_info, info)
+      #os.sys.exit(1)
+      info = self.log.CreateProgressInfo(
+          '---', 'Reset ACS URL to Expected: ' + self.params['acs_url'])
+      self.log.SendLine(self.test_info, info)
+      self.SetACSURL()
+
+    current_version = self.GetCurrentVersion()
+    if (not current_version
+        or current_version != self.params['expected_version']):
+      info = self.log.CreateErrorInfo(
+          'critical', 'Not expected image version. Expected: '
+          + self.params['expected_version'] + ', Current: '
+          + current_version)
+      self.log.SendLine(self.test_info, info)
+    else:
+      self.AddConfigParams('current_version', current_version)
+
+  def CheckRequirement(self, chk_list, req_list):
+    """Check parameter names with parameters in requirement file.
+
+    This file will compare the parameters from Device and from requirement
+    File. The differences between the two will be written to the result log
+    file
+    Args:
+      chk_list: the list of parameters results returned by query
+      req_list: the list of parameters from requirement
+    Returns:
+      missing_list: the list of parameters that is missing from requirement
+      net_list: the list of parameters that are newly added but not in the
+                requirement
+    """
+    missing_list = []
+    new_list = []
+    #check missing parameters from Requirement
+    for req_line in req_list:
+      verify = False
+      for chk_line in chk_list:
+        if req_line == chk_line:
+          verify = True
+        elif string.find(chk_line, req_line) == 0:
+          verify = True
+      if not verify:
+        missing_list.append(req_line)
+
+    #check newly added parameters to Requirement
+    for line in chk_list:
+      if req_list.count(line) < 1 and new_list.count(line) < 1:
+        new_list.append(line)
+    return (missing_list, new_list)
+
+  def GetACSAppFromURL(self):
+    """Parse ACS appID from ACS URL string."""
+    return re.sub(r'https?://(.*).appspot.com/cwmp', r'\1',
+                  self.params['acs_url'])
+
+  def GetSerialNumber(self):
+    """This function returns Bruno device serial number."""
+    self.p_ssh.SendCmd('hnvram -r 1st_serial_number')
+    line = self.p_ssh.GetCmdOutput()[1].strip()
+    if line is None:
+      info = self.log.CreateErrorInfo('Warning',
+                                      'Can not get serial number')
+      self.log.SendLine(None, info)
+      return False
+    return re.sub(r'1st_serial_number=([0-9A-Z]{12})', r'\1', line)
+
+  def GetProductClass(self):
+    """Get product class from device system."""
+    self.p_ssh.SendCmd('cat /etc/platform')
+    return self.p_ssh.GetCmdOutput()[1].strip()
+
+  def BatchSetParametersValues(self, tree, param):
+    """Set multiple parameter values in a single nbi_client RPC call.
+
+    Set multiple parameter values
+    Args:
+      tree: the parameter names are in TreeElement structure. It has
+            parameter 'writable' states and test_value to set.
+            Parameter names/paths are sorted in alphabetical order in tree.
+      param: the parameters name list that needs to be set with new value
+    """
+    nbi_path = self.params['nbi_client_path']
+    app_id = self.GetACSAppFromURL()
+    product_class = self.GetProductClass()
+    serial_no = self.GetSerialNumber()
+
+    container = tree.findall('parameter_value_struct')
+    batch_size = 1
+    counter = 0
+    parameter_struct = ''
+
+    for node in container:
+      name = node.findtext('name')
+
+      if name in param:
+        nbi_type = node.findtext('nbi_type')
+
+        if not nbi_type:
+          info = self.log.CreateErrorInfo('Warning',
+                                          'Can not determin parameter type!')
+          self.log.SendLine(None, info)
+
+        test_value = node.findtext('test_value')
+        if nbi_type == 'string_value':
+          test_value = '"' + test_value + '"'
+        if (node.findtext('writable') == '1'
+            or node.findtext('writable') == 'true'):
+          parameter_struct += ('parameter_value_struct: <name: "'
+                               + name + '" ' + nbi_type + ': '
+                               + test_value + '> ')
+          counter += 1
+        else:
+          continue
+
+        if counter >= batch_size:
+          counter = 0
+          cmd = (nbi_path
+                 + ' --server /gns/project/apphosting/stubby/prod-appengine/'
+                 '*/' + app_id + '/default/* --service CpeParametersService '
+                 '--method SetParameterValues --request \''
+                 'cpe_id: <oui: "F88FCA" product_class: "' + product_class
+                 + '" serial_no: "' + serial_no
+                 + '"> request: <parameter_list < '
+                 + parameter_struct + ' > parameter_key: "myParamKey">\'')
+          print cmd
+          parameter_struct = ''
+          time_stamp = self.GetTimeStamp()
+          call_result = self.acs_instance.StubbyClientCall(cmd)
+          print call_result
+          if not self.acs_instance.CheckCmdCall(call_result):
+            # command not succeed according to nbi_client reply
+            # However, there is possibility that the request is successful,
+            # nbi_client reports a failure only because the timeout 60s.
+            # check device log to see if this request actually fails
+            self.p_ssh.SendCmd('dmesg | grep cwmpd:')
+            # read the last 500 lines from log
+            log_list = self.p_ssh.GetCmdOutput(500)
+            log_list.reverse()
+            reply_msg = self.ParseDeviceLogForError(
+                time_stamp, log_list, name, 'SetParameterValues')
+            if '<soap:Fault>' in reply_msg[0] or '<soap:fault>' in reply_msg[0]:
+              # failed to set parameter values (on nbi_client and device):
+              info = self.log.CreateErrorInfo(
+                  'Critical', 'Batch SetParameterValues() failed on Parameter: '
+                  + name + '. Parameter type: ' + nbi_type
+                  + '. Set test value: ' + test_value + '. Error message: \n'
+                  + ''.join(reply_msg))
+              self.log.SendLines(self.test_info, info)
+            elif '<cwmp:SetParameterValuesResponse>' in reply_msg[0]:
+              # nbi_reports failure, but success on device
+              info = self.log.CreateResultInfo(
+                  '---', 'Batch SetParameterValues() Succeeded on Parameter: '
+                  + name + '. Parameter type: ' + nbi_type
+                  + '. Set test value: ' + test_value)
+              self.log.SendLine(self.test_info, info)
+            else:
+              info = self.log.CreateErrorInfo(
+                  'Critical', 'Batch SetParameterValues() failed on Parameter: '
+                  + name + '. Parameter type: ' + nbi_type
+                  + '. Set test value: ' + test_value + '. Error message: \n'
+                  + ''.join(reply_msg))
+              self.log.SendLines(self.test_info, info)
+          else:
+            # Succeed, logging to result file:
+            self.log.SendTestData(call_result)
+            info = self.log.CreateResultInfo(
+                '---', 'Batch SetParameterValues() Succeeded on Parameter: '
+                + name + '. Parameter type: ' + nbi_type
+                + '. Set test value: ' + test_value)
+            self.log.SendLine(self.test_info, info)
+
+  def SetParameterValues(self, param='', param_type='', value=''):
+    """Set parameter values on Device.
+
+    Set parameter values
+    Args:
+      param: the parameter name that needs to be set with new value
+      param_type: type of value: string, boolean, long_int, etc
+      value: parameter value
+    Returns:
+      return setParameterValues if succeeded.
+      return error information if failed
+    """
+    nbi_path = self.params['nbi_client_path']
+    app_id = self.GetACSAppFromURL()
+    product_class = self.GetProductClass()
+    serial_no = self.GetSerialNumber()
+    # parse type:
+    if 'string' in param_type:
+      param_type = 'string_value'
+      value = '"' + value + '"'
+    elif 'bool' in param_type:
+      param_type = 'boolean_value'
+    elif 'unsignedInt' in param_type:
+      param_type = 'long_value'
+    else:
+      info = self.log.CreateErrorInfo(
+          'Critical', 'Unknown parameter type: ' + param_type)
+      self.log.SendLines(self.test_info, info)
+      os.sys.exit(1)
+
+    cmd = (nbi_path + ' --server /gns/project/apphosting/stubby/prod-appengine/'
+           '*/' + app_id + '/default/* --service CpeParametersService '
+           '--method SetParameterValues --request \''
+           'cpe_id: <oui: "F88FCA" product_class: "' + product_class
+           + '" serial_no: "' + serial_no + '"> request: <parameter_list < '
+           'parameter_value_struct: <name: "' + param +
+           '" ' + param_type + ': ' + value
+           + '> > parameter_key: "myParamKey">\'')
+    print cmd
+    call_result = self.acs_instance.StubbyClientCall(cmd)
+    if 'FAILED' in call_result[0]:
+      info = self.log.CreateErrorInfo(
+          'Warning', 'ACS failed on SetParameterValues query: ' + cmd)
+      self.log.SendLines(self.test_info, info)
+      return False
+    else:
+      print call_result
+    return call_result
+
+  def GetParameterNames(self, param='.', next_level=True):
+    """Get next level parameter names of the current queried parameter.
+
+    The next level parameter names will be output to result file
+    Due to the large number of parameter instances, parameters in the same
+    parameter family will be grouped together into a single nbi_client
+    RPC call (getParameterNames() call, this call will feedback the access
+    state information). In order to minimize the total processing time, as
+    well as the number of RPC calls to ACS appEngine. This will greatly
+    reduce the execution time.
+    Each getParameterNames call will be created as an individual thread.
+    And multiple calls are made in parallel.
+
+    Args:
+      param:
+        This is the parameter that is queried for its next level names
+        Note that currently GetParameterNames does not support multiple
+        parameter names in a query command. If parameter name is a dot,
+        and the next level is 'False', then device will return all
+        parameters under the queried parameter path
+      next_level:
+        if this parameter is True:
+          only the next level parameter names are returned
+        if this parameter is False:
+          all parameter in the requested parameter path will be returned
+    Returns:
+      return the nbi_client RPC call response. Response can be used to
+      parse for parameters' name, access attribute, etc.
+    """
+    nbi_path = self.params['nbi_client_path']
+    app_id = self.GetACSAppFromURL()
+    product_class = self.GetProductClass()
+    serial_no = self.GetSerialNumber()
+    if next_level:
+      next_level = 'true'
+    else:
+      next_level = 'false'
+    cmd = (nbi_path + ' --server /gns/project/apphosting/stubby/prod-appengine/'
+           '*/' + app_id + '/default/* --service CpeParametersService '
+           '--method GetParameterNames --request \''
+           'cpe_id: <oui: "F88FCA" product_class: "' + product_class
+           + '" serial_no: "' + serial_no + '"> request: <parameter_path: "'
+           + param + '" next_level: ' + next_level + '>\'')
+    print cmd
+    call_result = self.acs_instance.StubbyClientCall(cmd)
+    if 'FAILED' in call_result[0]:
+      self.nbi_result = []
+      info = self.log.CreateErrorInfo(
+          'Warning', 'ACS failed on GetParameterNames query: ' + cmd)
+      self.log.SendLines(self.test_info, info)
+      return False
+    else:
+      self.nbi_result = call_result
+    print call_result
+    return call_result
+
+  def GetParameterValues(self, param=''):
+    """Make a Get parameter value(s) query at ACS to request the device.
+
+    This method get value(s) of the designated parameter(s)
+    Args:
+      param: this is the parameter (path) that need to get value(s) from.
+             1. If this path ends with a dot '.', all parameters
+                under this path will be queried for values.
+             2. If this path does not end with a '.', the parameter
+                must be a leaf parameter which has a value.
+    Returns:
+      This method returns a list of parameter values and record them to file.
+    """
+    nbi_path = self.params['nbi_client_path']
+    if param == '.':
+      param = ''
+    app_id = self.GetACSAppFromURL()
+    product_class = self.GetProductClass()
+    serial_no = self.GetSerialNumber()
+    cmd = (nbi_path + ' --server /gns/project/apphosting/stubby/prod-appengine/'
+           '*/' + app_id + '/default/* --service CpeParametersService '
+           '--method GetParameterValues --request \''
+           'cpe_id: <oui: "F88FCA" product_class: "' + product_class
+           + '" serial_no: "' + serial_no + '"> request: <parameter_names: "'
+           +param + '">\'')
+
+    print cmd
+    call_result = self.acs_instance.StubbyClientCall(cmd)
+    if 'FAILED' in call_result[0]:
+      self.nbi_result = []
+      info = self.log.CreateErrorInfo(
+          'Warning', 'ACS failed on GetParameterValues query: ' + cmd)
+      self.log.SendLines(self.test_info, info)
+      return False
+    else:
+      self.nbi_result = call_result
+    print call_result
+    return call_result
+
+  def FindEndofRequest(self, log_list, index, pattern):
+    """Find the end of a request string from device log.
+
+    Some times the close tag, for example: </cwmp:SetParameterValues> is
+    separated to two consecutive log lines, due to the line length limitation.
+    This method try to search the request closing tag on separate lines
+
+    Args:
+      log_list: the device log list.
+      index: the index of the line to search for tag
+      pattern: the closing tag that need to be searched in log file
+    Returns:
+      True: if pattern find in log
+      False: if pattern not find in log
+    """
+    if index >= len(log_list)-1:
+      if pattern in log_list[index]:
+        return True
+      else:
+        return False
+
+    s = re.sub(r'\[\s*\d*\.\d*\]\s*cwmpd:\s*(.*)', r'\1', log_list[index + 1])
+    s = log_list[index].strip() + s.strip()
+
+    if pattern in s:
+      return True
+    return False
+
+  def MatchParameterName(self, line, param_name, rpc):
+    """Match rpc request logs to a parameter name."""
+    if rpc == 'GetParameterNames':
+      m = re.search(r'.*<ParameterPath>(.*)</ParameterPath>.*', line)
+      if m is not None and param_name in m.group(1):
+        return True
+      else:
+        return False
+    elif rpc == 'GetParameterValues':
+      m = re.search(r'.*<cwmp:GetParameterValues>.*<ParameterNames.*>(.*)'
+                    '</ParameterNames></cwmp:GetParameterValues>.*', line)
+      if m is not None and param_name in m.group(1):
+        return True
+      else:
+        return False
+    elif rpc == 'SetParameterValues':
+      m = re.search(r'.*<Name>(.*)</Name><Value.*', line)
+      if m is not None and param_name in m.group(1):
+        return True
+      else:
+        return False
+    else:
+      return False
+
+  def ParseDeviceLogForError(self, time_stamp, log_list, param, rpc):
+    """Parse the log information from device, Looking for cwmp errors.
+
+    Args:
+      time_stamp: looking for log events that happened only after this time
+      log_list: the cwmp event information obtained from device log
+      param: the parameter name to get value from
+      rpc: the rpc function name to search in log
+    Returns:
+      return cwmp error message found in device log.
+    """
+
+    reply_msg = []
+    start_of_rpc_reply = False
+    end_of_rpc_reply = False
+    start_of_rpc_request = False
+    end_of_rpc_request = False
+    param_matching = False
+    current_index = 0
+
+    for line in log_list:
+      # check only the getParameter query starts after the specified time:
+      if float(self.GetTimeStamp(line)) > float(time_stamp):
+        if 'CPE RECEIVED (at' in line and not start_of_rpc_request:
+          index = log_list.index(line)
+          # macthing the request query in log messages
+          for i in range(index+1, len(log_list)-1):
+            if i < len(log_list):
+              # match rpc request string
+              if '<cwmp:' + rpc + '>' in log_list[i]:
+                start_of_rpc_request = True
+              # match rpc request string end
+              if (self.FindEndofRequest(log_list, i, '</cwmp:' + rpc + '>')
+                  and start_of_rpc_request):
+                if (start_of_rpc_request and end_of_rpc_request
+                    and not param in log_list[i]):
+                  end_of_rpc_request = True
+                  # rpc request scan completed, requested parameter not matched
+                  # this request is not request of interest
+                  start_of_rpc_request = False
+                  end_of_rpc_request = False
+                  break
+              # match queried parameter in rpc request
+              if start_of_rpc_request and not end_of_rpc_request:
+                if self.MatchParameterName(log_list[i], param, rpc):
+                  param_matching = True
+                  current_index = i
+                  break
+
+        # search for end of rpc request command
+        if param_matching and not end_of_rpc_request:
+          for i in range(current_index, len(log_list)-1):
+            if i < len(log_list):
+              # match rpc request string end
+              if self.FindEndofRequest(log_list, i, '</cwmp:' + rpc + '>'):
+                end_of_rpc_request = True
+                current_index = i
+                break
+
+        # search for rpc request reply message
+        if param_matching and end_of_rpc_request:
+          for i in range(current_index, len(log_list)-1):
+            if i < len(log_list):
+              if ('<soap:Fault>' in log_list[i] or '<soap:fault>' in log_list[i]
+                  or '<cwmp:' + rpc + 'Response>' in log_list[i]):
+                start_of_rpc_reply = True
+              if (' </soap:Fault>' in log_list[i]
+                  or ' </soap:fault>' in log_list[i]
+                  or '</cwmp:' + rpc + 'Response>' in log_list[i]):
+                end_of_rpc_reply = True
+                reply_msg.append(log_list[i].strip()+'\n')
+              if start_of_rpc_reply and not end_of_rpc_reply:
+                reply_msg.append(log_list[i].strip()+'\n')
+              if start_of_rpc_reply and end_of_rpc_reply:
+                return reply_msg
+    return ['No rpc message is available in device log']
+
+  def GetParameterListFromDeviceLog(self, time_stamp, param=''):
+    """Parse TR069 data model parameters from Device log information.
+
+    Args:
+      time_stamp: looking for log events that happened only after this time
+      param: the cwmp parameter to search in device log
+    Returns:
+      return parameter list if succeeded
+      return false otherwise
+    """
+    if param == '.':
+      param = ''
+    param_list = []
+    param_list_start = False
+    param_list_end = False
+    self.device_log_result = []
+
+    self.p_ssh.SendCmd('dmesg | grep cwmpd:')
+    log_list = self.p_ssh.GetCmdOutput()
+    log_list.reverse()
+
+    for line in log_list:
+      # check only the getParameter query starts after the last known event:
+      if float(self.GetTimeStamp(line)) > float(time_stamp):
+        if '<cwmp:GetParameterValues>' in line:
+          # check the parameter query from nbi_client has been answered:
+          m = re.search(r'.*<cwmp:GetParameterValues>.*<ParameterNames.*>(.*)'
+                        '</ParameterNames></cwmp:GetParameterValues>.*', line)
+          if m is not None and param in m.group(1):
+            index = log_list.index(line)
+            for i in range(index+1, index+50):
+              if '<cwmp:GetParameterValuesResponse>' in log_list[i]:
+                param_list_start = True
+                break
+            continue
+
+      if '</cwmp:GetParameterValuesResponse>' in line:
+        if param_list_start:
+          param_list_end = True
+          break
+
+      if param_list_start:
+        self.device_log_result.append(line.strip())
+        if '<Name>' in line:
+          output = re.sub(r'.*(<Name>)(.*)(</Name>)', r'\2', line)
+          output = output.strip()
+          output = re.sub(r'(\.)[\d]+(\.)', r'\1{i}\2', output)
+          if param_list.count(output) < 1:
+            param_list.append(output)
+
+    if (not param_list_start) or (not param_list_end):
+      error_msg = self.ParseDeviceLogForError(
+          time_stamp, log_list, param, 'GetParameterValues')
+      if 'fault' in error_msg[0] or 'Fault' in error_msg[0]:
+        # error occurred in rpc request
+        info = self.log.CreateErrorInfo(
+          'Critical', 'Exit! Error while get values: ' + ''.join(error_msg))
+        self.log.SendLines(self.test_info, info)
+        os.sys.exit(1)
+      else:
+        # no error in request, request still in progress
+        return False
+    return param_list
+
+  def CreateElement(self, param_name, param_type_device,
+                    param_type_nbi, param_value):
+    """Create a new parameter node that contains parameter name and value.
+
+    Currently try to set the same value as being read from the device.
+    Parameter type may have different representations on different platforms.
+    E.g.: type 'long_value' on nbi_client is 'unsignedInt' on bruno.
+          type 'string_value' on nbi_client is 'string' on bruno
+    Args:
+      param_name: the name of the parameter (Path)
+      param_type_device: the type of the parameter represented by device format
+      param_type_nbi: the type of parameter, represented by nbi_client format
+      param_value: the value of the parameter
+    Returns:
+      return the created element node
+    """
+    e = ET.Element('parameter_value_struct')
+    name = ET.Element('name')
+    name.text = param_name
+    e.append(name)
+    device_type = ET.Element('device_type')
+    device_type.text = param_type_device
+    e.append(device_type)
+    nbi_type = ET.Element('nbi_type')
+    if not param_type_nbi:
+      if param_type_device == 'unsignedInt':
+        param_type_nbi = 'long_value'
+      elif param_type_device == 'boolean':
+        param_type_nbi = 'boolean_value'
+      elif param_type_device == 'string':
+        param_type_nbi = 'string_value'
+      else:
+        info = self.log.CreateErrorInfo(
+            'Critical', 'Exit! Unknown (new) Parameter types found from device:'
+            ': ' + param_type_device + '. Define as string_value')
+        self.log.SendLine(self.test_info, info)
+        param_type_nbi = 'string_value'
+    nbi_type.text = param_type_nbi
+    e.append(nbi_type)
+    value = ET.Element('value')
+    value.text = param_value
+    e.append(value)
+    test_value = ET.Element('test_value')
+    test_value.text = param_value
+    e.append(test_value)
+    access_state = ET.Element('writable')
+    access_state.text = 'true'
+    e.append(access_state)
+    return e
+
+  def SortElementTree(self, tree):
+    """Sort the parameters in element tree, in alphabetical order of names.
+
+    Args:
+      tree: the ElementTree data structure that holds the parameter list
+    Returns:
+      return the sorted tree data structure
+    """
+    data = []
+    container = tree.findall('parameter_value_struct')
+    for node in container:
+      key = node.findtext('name')
+      data.append((key, node))
+
+    root = ET.Element(tree.getroot().tag, tree.getroot().attrib)
+    root.text = tree.getroot().text
+    data.sort()
+    for node in data:
+      root.append(node[1])
+    return ET.ElementTree(root)
+
+  def ParseToElementTree(self):
+    """Parse the parameter list to Element Tree structure."""
+    root = ET.Element('Bruno_Automation_Test', name='Set_Parameter_Value_Test',
+                      testCases=self.test_info['testID'])
+    root.text = 'This structure stores all parameters and values for this test'
+
+    if self.nbi_result:
+      for line in self.nbi_result:
+        if 'name:' in line:
+          param_name = re.sub('.*\"(.*)\".*', r'\1', line).strip()
+          index = self.nbi_result.index(line)
+          param_type = self.nbi_result[index+1].split(':')[0].strip()
+          param_value = self.nbi_result[index+1].split(':')[1].strip()
+          root.append(self.CreateElement(param_name, None,
+                                         param_type, param_value))
+    elif self.device_log_result:
+      #self.device_log_result.reverse()
+      for line in self.device_log_result:
+        if '<Name>' in line:
+          param_name = re.sub(r'.*(<Name>)(.*)(</Name>)', r'\2', line).strip()
+
+          index = self.device_log_result.index(line) + 1
+          while not 'Value' in self.device_log_result[index]:
+            index += 1
+            if index >= len(self.device_log_result) or '<Name>' in line:
+              info = self.log.createErrorInfo(
+                  'Critical', 'Mis-matching name-value pair in log file!')
+              self.log.sendLine(self.test_info, info)
+              return False
+
+          line = self.device_log_result[index]
+          # In case value string spans multiple lines:
+          while '</Value>' not in line:
+            index +=1
+            if index >= len(self.device_log_result):
+              info = self.log.CreateErrorInfo(
+                  'Critical', 'Exit! Cannot find matching </Value> tag in log!')
+              self.log.SendLine(self.test_info, info)
+              os.sys.exit(1)
+            new_line = self.device_log_result[index]
+            # if <Name> or EOF reached before a matching </Value> is found
+            if '<Name>' in new_line:
+              info = self.log.CreateErrorInfo(
+                  'Critical', 'Exit! Cannot find matching </Value> tag in log!')
+              self.log.SendLine(self.test_info, info)
+              os.sys.exit(1)
+            new_line = re.sub('\[\s*\d*\.\d{3}\]\s*cwmpd:\s*(.*)',
+                              r'\1', new_line).strip()
+            line += new_line.strip()
+
+          param_type = re.search('.*type\s*=\s*\"[a-zA-Z]*:([a-zA-Z]*)\">.*',
+                                 line, re.DOTALL).group(1)
+          param_value = re.search('.*<Value\s*[a-zA-Z]*:type="[a-zA-Z]*:'
+                                  '[a-zA-Z]*">(.*)</Value>',
+                                  line, re.DOTALL).group(1)
+          root.append(self.CreateElement(param_name, param_type,
+                                         None, param_value))
+    else:
+      info = self.log.CreateErrorInfo(
+          'Critical', 'Failed to get parameter list from device!')
+      self.log.SendLine(self.test_info, info)
+      return False
+
+    tree = ET.ElementTree(root)
+    tree = self.SortElementTree(tree)
+    return tree
+
+  def ParametersFromXMLFile(self, file_path=None):
+    """Read parameter data from an XML format file.
+
+    Args:
+      file_path: file path to the xml file
+    Returns:
+      return the parameter list stored in the file, in the format of ElementTree
+    """
+    f = None
+    try:
+      if not file_path:
+        f = open(self.params['para_tree_file'], 'r')
+      else:
+        f = open(file_path, 'r')
+      tree = ET.parse(f)
+    except IOError, inst:
+      err_string = ('Exit! Unexpected error opening '
+                    + str(f.name) + '. ' + str(inst))
+      info = self.log.CreateErrorInfo('Critical', err_string)
+      self.log.SendLine(self.test_info, info)
+      os.sys.exit(1)
+    return tree
+
+  def ParametersToXMLFile(self, tree=None, file_path=None):
+    """Output the available parameter instance tree to XML format file.
+
+    Parameter instance results will be written to XML formated file,
+    with test value that has been set for the parameter(s)
+    For those parameters that failed to set value, they are recorded in
+    the result file.
+
+    Args:
+      tree: the parameters structure to parse to file
+      file_path: path to the output file
+    """
+    if not tree:
+      tree = self.para_tree
+    if not file_path:
+      fout = open(self.params['para_tree_file'], 'w')
+    else:
+      fout = open(file_path, 'w')
+
+    try:
+      tree.write(fout)
+    except IOError, inst:
+      err_string = ('Exit! Unexpected error writing to file '
+                    + fout.name() + str(inst))
+      info = self.log.CreateErrorInfo('Critical', err_string)
+      self.log.SendLine(self.test_info, info)
+      os.sys.exit(1)
+    fout.close()
+
+  def GetRequirementFromFile(self):
+    """Get TR69 data model parameters from requirement file.
+
+    The format of the requirement file is as follows:
+      1. Each line represents a data model parameter
+      2. If a parameter has indexed nodes, index numbers are replaced by {i}
+        ###### Begin of File ######
+        Device.Bridging.
+        Device.Bridging.Bridge.{i}.
+        Device.Bridging.Bridge.{i}.Port.{i}.
+        Device.Bridging.Bridge.{i}.Port.{i}.Stats.
+        ... ... ...
+        Device.DeviceInfo.Manufacturer
+        Device.DeviceInfo.ManufacturerOUI
+        X_GOOGLE-COM_GVSB.EpgSecondary
+        X_GOOGLE-COM_GVSB.GvsbChannelLineup
+        X_GOOGLE-COM_GVSB.GvsbKick
+        X_GOOGLE-COM_GVSB.GvsbServer
+        ###### End of File ######
+    Returns:
+      return the requirement parameters in a list
+    """
+    req_list = []
+    for line in self.req_file:
+      line = line.strip()
+      if req_list.count(line) < 1:
+        req_list.append(line)
+    return req_list
+
+  def GetTimeStamp(self, line=None):
+    """Extract the time information of most current event from Device log.
+
+    i.e., the time that the last event happens since reboot (in seconds)
+    Args:
+      line: a line of device log which contains event time information.
+            If it has value of 'None', then retrieve the last a few lines from
+            device log to extract time information.
+    Returns:
+      return the time stamp string if succeed, return -1 otherwise.
+    """
+    if line is None:
+      # get time stamp from Device log file
+      self.p_ssh.SendCmd('dmesg | grep cwmpd:')
+      # search the last 30 lines in Device log for time information
+      latest_log_entry = 30
+      log_list = self.p_ssh.GetCmdOutput(latest_log_entry)
+
+      for line in log_list:
+        m = re.match('\\[[\s]*(\d*\\.\d{3})\\]', line)
+        if m is not None:
+          # Match, return the time stamp
+          return m.group(1)
+    else:
+      # get time stamp from a Device log line
+      m = re.match('\\[[\s]*(\d*\\.\d{3})\\]', line)
+      if m is not None:
+      # Match, return the time stamp
+        return m.group(1)
+    # No time stamp found
+    info = self.log.CreateErrorInfo(
+        'Critical', 'Cannot get time information from Device log!')
+    self.log.SendLine(self.test_info, info)
+    os.sys.exit(1)
+
+  def VerifyAllReqParameters(self):
+    """Check available parameters and compare to requirement list.
+
+    This method checks all available parameters on current image, and
+    compare the list with requirement list. It will find out:
+      1. the parameters that are missing from the requirement list.
+      2. the newly added parameters that are not in the requirement list.
+    Both lists are written to the result file.
+
+    This method also output all parameter instances on current device to
+    a xml formated file, together with their types and values
+    """
+    # get parameter name lists, compare with requirement list
+    info = self.log.CreateProgressInfo(
+        '30%', 'Get parameters from nbi_client ...')
+    self.log.SendLine(self.test_info, info)
+    time_stamp = self.GetTimeStamp()
+    chk_list = self.acs_instance.ParseParameterNames(self.GetParameterValues(),
+                                                     True)
+
+    if not chk_list:
+      info = self.log.CreateProgressInfo(
+        '35%', 'ACS failed to reply, get parameters from device log ...')
+      self.log.SendLine(self.test_info, info)
+      # nbi client may fail because of timeout
+      # if that is the case, then get parameter list from device log
+      count = 0
+      while not chk_list:
+        time.sleep(self.__delay)
+        chk_list = self.GetParameterListFromDeviceLog(time_stamp)
+        count += 1
+        if count*self.__delay >= self.__long_delay:
+          info = self.log.CreateErrorInfo(
+              'Critical', 'Can not retrieve complete log info from device')
+          self.log.SendLine(self.test_info, info)
+          os.sys.exit(1)
+
+        if not chk_list:
+          info = self.log.CreateProgressInfo(
+              '40%', 'GetParameterValue query in progress, retry after '
+              + str(self.__delay) + ' seconds.')
+          self.log.SendLine(self.test_info, info)
+      chk_list.sort()
+
+    info = self.log.CreateProgressInfo(
+        '55%', 'GetParameterValue query completed, verify parameter list '
+        'with parameter requirement document.')
+    self.log.SendLine(self.test_info, info)
+    req_list = self.GetRequirementFromFile()
+    (mis_list, new_list) = self.CheckRequirement(chk_list, req_list)
+    mis_list.sort()
+    new_list.sort()
+    self.log.SendTestData(['############# Missing Parameters #############'])
+    self.log.SendTestData(mis_list)
+
+    self.log.SendTestData(['############ Newly Added Parameters ############'])
+    self.log.SendTestData(new_list)
+
+    info = self.log.CreateProgressInfo(
+        '75%', 'Verify current parameter list with requirement completed. '
+        'Check result file:' + self.log.params['f_error'] + ' for details.')
+    self.log.SendLine(self.test_info, info)
+
+    # write parameter instance to file
+    self.para_tree = self.ParseToElementTree()
+    self.ParametersToXMLFile()
+    info = self.log.CreateProgressInfo(
+        '100%', 'Update parameter file: ' + self.params['para_tree_file']
+        + ' completed.')
+    self.log.SendLine(self.test_info, info)
+    info = self.log.CreateResultInfo(
+        'Pass', 'Verification completed. '
+        'Check result file: ' + self.log.params['f_result'] + ' for missing '
+        'parameters and new parameters.')
+    self.log.SendLine(self.test_info, info)
+
+  def GetParameterAccessStateFromDeviceLog(self, time_stamp=None, param='.'):
+    """Get parameter access state from device logs.
+
+    Args:
+      time_stamp: search events only after this time in log file
+      param: the parameter to search in device log
+    Returns:
+      return dictionary: parameter names as key, and writable status as value
+    """
+    self.p_ssh.SendCmd('dmesg | grep cwmpd:')
+    log_list = self.p_ssh.GetCmdOutput()
+    log_list.reverse()
+
+    param_state_dict = {}
+    param_list_start = False
+    param_list_end = False
+
+    for line in log_list:
+      # check only the getParameter query starts after the last known event:
+      if float(self.GetTimeStamp(line)) > float(time_stamp):
+        if '<cwmp:GetParameterNames>' in line:
+          # check the parameter query from nbi_client has been answered:
+          m = re.search(
+              r'.*<cwmp:GetParameterNames>.*<ParameterPath>(.*)'
+              '</ParameterPath>.*<NextLevel>false</NextLevel>.*'
+              '</cwmp:GetParameterNames>.*', line)
+          if m and param in line:
+            index = log_list.index(line)
+            for i in range(index+1, index+30):
+              if i < len(log_list):
+                if '<cwmp:GetParameterNamesResponse>' in log_list[i]:
+                  param_list_start = True
+                  break
+            continue
+
+      if '</cwmp:GetParameterNamesResponse>' in line:
+        if param_list_start:
+          param_list_end = True
+          break
+
+      if param_list_start:
+        if '<Name>' in line:
+          name = re.search(r'.*<Name>(.*)</Name>', line).group(1).strip()
+          index = log_list.index(line)+1
+          if '<Writable>' in log_list[index]:
+            access = re.sub(r'.*<Writable>(.*)</Writable>',
+                            r'\1', log_list[index]).strip()
+            if access == '1':
+              access = 'true'
+            else:
+              access = 'false'
+            param_state_dict.update({name: access})
+
+    if (not param_list_start) or (not param_list_end):
+      error_msg = self.ParseDeviceLogForError(
+          time_stamp, log_list, param, 'GetParameterNames')
+      if 'fault' in error_msg[0] or 'Fault' in error_msg[0]:
+        info = self.log.CreateErrorInfo(
+          'Critical', 'Exit! Error while get values: ' + ''.join(error_msg))
+        self.log.SendLines(self.test_info, info)
+        os.sys.exit(1)
+      else:
+        return False
+    return param_state_dict
+
+  def UpdateParameterAccessState(self, tree, param_name='.'):
+    """Update parameters' access state (read-only, read-write status).
+
+    TR69 parameters could be either in a read-only state, or a writable
+    state. The setParameterValues() test only verifies those parameters
+    in the 'writable' state. Try to set them with new values.
+    This method is called to determine the state of each supported parameter
+
+    Args:
+      tree:
+        the ElementTree data structure that holds the parameter attribute
+        list in XML format. This tree needs to be sorted before passed to
+        this function, according to the alphabetical order of parameter
+        names.
+      param_name:
+        the parameter name to update the access state
+    Returns:
+      returns this tree with updated parameter access state information
+    """
+    time_stamp = self.GetTimeStamp()
+    cmd_list = self.GetParameterNames(param_name, False)
+    if not self.acs_instance.CheckCmdCall(cmd_list):
+      info = self.log.CreateProgressInfo(
+            '---', 'GetParameterNames() query failed on ACS. Analyzing device'
+            ' logs...')
+      self.log.SendLine(self.test_info, info)
+
+      param_dict = self.GetParameterAccessStateFromDeviceLog(time_stamp,
+                                                             param_name)
+      while not param_dict:
+        info = self.log.CreateProgressInfo(
+            '---', 'GetParameterNames() analyze in progress, wait for '
+            + str(self.__short_delay) + ' seconds.')
+        self.log.SendLine(self.test_info, info)
+        time.sleep(self.__short_delay)
+        param_dict = self.GetParameterAccessStateFromDeviceLog(time_stamp,
+                                                               param_name)
+    else:
+      param_dict = self.acs_instance.ParseParameterAccessStates(cmd_list)
+      for key in param_dict.keys():
+        if param_name.endswith('.') and param_name != '.':
+          param_dict[param_name + key] = param_dict.pop(key)
+        else:
+          param_dict[param_name + '.' + key] = param_dict.pop(key)
+
+    container = tree.findall('parameter_value_struct')
+
+    for node in container:
+      name = node.findtext('name')
+      if name in param_dict.keys():
+        e = node.find('writable')
+        if not e:
+          # Create this tag:
+          e = ET.Element('writable')
+          e.text = param_dict[name]
+          node.append(e)
+        else:
+          e.text = param_dict[name]
+      else:
+        continue
+    return tree
+
+  def MarkParametersToSet(self, param_list, param):
+    """In the sorted tree, mark all parameters before param to read-only."""
+    if not param:
+      return param_list
+
+    ls = list(param_list)
+    for name in param_list:
+      if name != param:
+        ls.remove(name)
+      else:
+        break
+    return ls
+
+  def VerifySetAllParameterValues(self):
+    """This verifies the setParameterValues() on all supported parameters.
+
+    This method tests the 'set' capability on all parameters. According
+    to the data type, the value will be set as 'string', 'long_int', 'boolean',
+    etc. Note the current test only verify the 'set' action is supported by
+    each parameter. Therefore, it will try to set the same default value on each
+    parameter (it does not change the default value of each parameter).
+
+    This test assumes that the parameter list has already been retrieved from
+    device by 'GetparameterValues', and has been written to the parameter XML
+    file.
+    """
+    tree = self.ParametersFromXMLFile()
+    #tree = self.UpdateParameterAccessState(tree)
+    tree = self.SortElementTree(tree)
+    param_list = []
+    # Currently Assume all parameters are read-write
+    container = tree.findall('parameter_value_struct')
+
+    for node in container:
+      #name = node.findtext('name')
+      #test_value = node.findtext('test_value')
+      dev_type = node.findtext('device_type')
+      nbi_type = None
+      if dev_type == 'unsignedInt':
+        nbi_type = 'long_value'
+      elif dev_type == 'boolean':
+        nbi_type = 'boolean_value'
+      elif dev_type == 'string':
+        nbi_type = 'string_value'
+      else:
+        info = self.log.CreateErrorInfo(
+            'Critical', 'Exit! Unknown (new) Parameter types found from device:'
+            ': ' + dev_type)
+        self.log.SendLine(self.test_info, info)
+        os.sys.exit(1)
+      node.find('nbi_type').text = nbi_type
+      param_list.append(node.findtext('name'))
+      e = node.find('writable')
+      if not e:
+        access_state = ET.Element('writable')
+        access_state.text = 'true'
+        node.append(access_state)
+    param_list.sort()
+    param_list = self.MarkParametersToSet(
+        param_list, self.params['from_which_param_to_set'])
+    self.BatchSetParametersValues(tree, param_list)
+
+  def VerifyNTPTimeZoneConfig(self):
+    """Verify the Time zone configuration is received and processed by Device.
+
+    Check the log of device, to find TR69 parameter:
+    InternetGatewayDevice.Time.
+    is pushed down to device. Also verify the device correctly updated local
+    time information.
+    """
+    ## Blocked by bug: http://b/issue?id=6804551
+    ## TODO(lmeng): add set values and verify set values succeeded
+    self.p_ssh.SendCmd('dmesg | grep cwmpd:')
+    log_list = self.p_ssh.GetCmdOutput()
+    time_stamp = self.GetTimeStamp()
+    log_list = self.ParseDeviceLogForError(time_stamp, log_list,
+                                           'InternetGatewayDevice.Time',
+                                           'SetParameterValues')
+    if 'No rpc message is available in device log' in log_list[0]:
+      info = self.log.CreateResultInfo(
+        '---', 'Failed. Can not find TR69 Time zone information in device log')
+      self.log.SendLine(self.test_info, info)
+    elif 'fault' in log_list[0]:
+      info = self.log.CreateResultInfo(
+        '---', 'Failed to apply Time zone configuration on device.')
+      self.log.SendLine(self.test_info, info)
+    else:
+      info = self.log.CreateResultInfo(
+        '---', 'Succeed to setup Time zone on deivce.')
+      self.log.SendLine(self.test_info, info)
+
+  def VerifyManagementServerURL(self):
+    """Verify set and get Management Server URL from device."""
+    # This test is blocked by bug: http://b/issue?id=6813492
+    mngmt_url_param = 'InternetGatewayDevice.ManagementServer.URL'
+    url_from_dev_param = self.acs_instance.ParseManagementURL(
+        self.GetParameterValues(mngmt_url_param))
+    info = self.log.CreateProgressInfo(
+            '15%', 'Get management url from TR069 parameter: '
+            + mngmt_url_param + '. Value: ' + url_from_dev_param)
+    self.log.SendLine(self.test_info, info)
+    if not url_from_dev_param:
+      info = self.log.CreateProgressInfo(
+            '30%', 'Can not found Value for: '
+            'InternetGatewayDevice.ManagementServer.URL'
+            '. Verify to set default URL: ' + self.params['default_url'])
+      self.log.SendLine(self.test_info, info)
+      url_from_dev_param = self.params['default_url']
+
+    info = self.log.CreateProgressInfo(
+            '50%', 'Set parameter value for: '
+            'InternetGatewayDevice.ManagementServer.URL'
+            '. Value: ' + url_from_dev_param)
+    self.log.SendLine(self.test_info, info)
+    result = self.SetParameterValues(mngmt_url_param, 'string',
+                                     url_from_dev_param)
+    if not result:
+      info = self.log.CreateErrorInfo(
+          'Critical', 'Failed to set parameter: '
+          'InternetGatewayDevice.ManagementServer.URL')
+      self.log.SendLine(self.test_info, info)
+      info = self.log.CreateResultInfo(
+          'Failed', 'Failed to set parameter: '
+          'InternetGatewayDevice.ManagementServer.URL')
+      self.log.SendLine(self.test_info, info)
+    else:
+      info = self.log.CreateProgressInfo(
+          '100%', 'Succeeded to set parameter: '
+          'InternetGatewayDevice.ManagementServer.URL')
+      self.log.SendLine(self.test_info, info)
+      info = self.log.CreateResultInfo(
+          'Pass', 'Succeeded to set parameter: '
+          'InternetGatewayDevice.ManagementServer.URL')
+      self.log.SendLine(self.test_info, info)
+
+  def VerifySetParameterValuesRPC(self):
+    """Test case: 11722375. To verify SetParameterValues RPC.
+
+    To verify SetParametersRPC, this methond also try to set all parameters
+    which have 'write-able' status, with test value.
+    """
+    # update parameter access state:
+    info = self.log.CreateProgressInfo(
+        '20%', 'Read Parameters read/write status from file.')
+    self.log.SendLine(self.test_info, info)
+    tree = self.ParametersFromXMLFile()
+    info = self.log.CreateProgressInfo(
+        '50%', 'Update parameters read/write status from Device.')
+    self.log.SendLine(self.test_info, info)
+    tree = self.UpdateParameterAccessState(tree, self.params['param_path'])
+    self.ParametersToXMLFile(tree)
+    # set parameter values:
+    self.VerifySetAllParameterValues()
+    info = self.log.CreateProgressInfo(
+        '100%', 'Verify: Set values for all parameters completed.')
+    self.log.SendLine(self.test_info, info)
+    info = self.log.CreateResultInfo(
+        'Pass', 'Verification: set parameter '
+        'values completed. '
+        'Check result file: ' + self.log.params['f_result'] + ' for details.')
+    self.log.SendLine(self.test_info, info)
+
+  def VerifyMonitorTemperature(self):
+    """Test the temperature monitor on device.
+
+    This feature is not available for first launch.
+    """
+    info = self.log.CreateResultInfo(
+        'Block', 'This feature is not availalbe '
+        'on the first launch images.')
+    self.log.SendLine(self.test_info, info)
+
+  def VerifyAutoChannelEnable(self):
+    """Test AutoChannelEnable on device.
+
+    This feature is not available for first launch.
+    """
+    info = self.log.CreateResultInfo(
+        'Block', 'This feature is not availalbe '
+        'on the first launch images.')
+    self.log.SendLine(self.test_info, info)
+
+  def SetServiceConfigs(self, param_dict):
+    """Set service parameter profile on ACS.
+
+    This method sets the service configurations on ACS, and returns the
+    SetServiceConfigs result.
+    Args:
+      param_dict:
+        it is in this format in config file:
+        "wifi_params":{
+            "Google.Wifi.SSID":{"string_value":"Home"},
+            "Google.Wifi.Home.SSID_2GHz":{"string_value":"Home"},
+            "Google.Wifi.Enable":{"boolean_value":"true"},
+            "Google.Wifi.BeaconType":{"string_value": "Basic"},
+            "Google.Wifi.BasicEncryptionModes":{"string_value":"WEPEncryption"}
+    Returns:
+      True: if set succeeded
+      False: otherwise
+    """
+    app_id = self.GetACSAppFromURL()
+    nbi_path = self.params['nbi_client_path']
+    account_id = self.params['account_id']
+    device_label = self.params['device_label']
+    parameter_value_struct = ''
+
+    # parameter_value_struct: <name: "Google.Wifi.BasicEncryptionModes"
+    # string_value: "WEPEncryption">
+    for key in param_dict.iterkeys():
+      name = key
+      param_type = param_dict[key].keys()[0]
+      value = None
+      if 'string' in param_type:
+        value = '"' + param_dict[key].values()[0] + '"'
+      else:
+        value = param_dict[key].values()[0]
+      parameter_value_struct += (
+          ' parameter_value_struct: <name: "'
+          + name + '" ' + param_type +': ' + value + '> ')
+
+    parameter_value_struct = None
+    cmd = (nbi_path
+           + ' --server /gns/project/apphosting/stubby/prod-appengine/'
+           '*/' + app_id + '/default/* --service AccountService '
+           '--method SetServiceConfigs --request \''
+           'account_device_id: <account_id: "' + account_id
+           + '" device_label: "' + device_label + '"> parameter_list: < '
+           + parameter_value_struct + ' > async_apply_now: false\'')
+    print cmd
+    call_result = self.acs_instance.StubbyClientCall(cmd)
+    if 'FAILED' in call_result[0]:
+      info = self.log.CreateErrorInfo(
+          'Warning', 'ACS failed on SetServiceConfigs query: ' + cmd)
+      self.log.SendLines(self.test_info, info)
+      return False
+    else:
+      print call_result
+    return call_result
+
+  def VerifyWiFiConfiguration(self):
+    """Test case: 14165034, WiFi configuration verification.
+
+    This test case will set WiFi parameters on ACS, and verify
+    that the service profile is correctly pushed to device.
+    Thin Bruno is configured with correct WiFi network.
+
+    The WiFi parameters and values in specified in config file
+    in JSON format, e.g.:
+    "Google.Wifi.SSID":{"string_value":"Home"},
+    "Google.Wifi.Home.SSID_2GHz":{"string_value":"Home"},
+    "Google.Wifi.Enable":{"boolean_value":"true"},
+    "Google.Wifi.BeaconType":{string_value: "Basic"},
+    "Google.Wifi.BasicEncryptionModes":{"string_value":"WEPEncryption"}
+
+    Returns:
+      return False if test failed
+    """
+    info = self.log.CreateProgressInfo(
+          '10%', 'Setup SetServiceConfigs on ACS...')
+    self.log.SendLine(self.test_info, info)
+    if not self.SetServiceConfigs(self.params['wifi_params']):
+      return False
+    else:
+      info = self.log.CreateProgressInfo(
+          '20%', 'Setup SetServiceConfigs on ACS succeed.')
+      self.log.SendLine(self.test_info, info)
+
+    # Verify if the service is pushed to device
+    # TODO(lmeng): what parameters to set and to verify
+
+  #################### for Data Model Test Case  ####################
+
+  def Run(self):
+    """Run the test case."""
+    ####### Add your code here -- BEGIN #######
+    print 'Test Started...'
+    self.Init()
+    self.p_ssh.SshRetry(5, 15)
+    info = self.log.CreateProgressInfo(
+        '5%', 'SSH session to device successfully established!')
+    self.log.SendLine(self.test_info, info)
+
+    #check device profile/image is as erquired management url from ACS
+    self.TestEnvCheck()
+    info = self.log.CreateProgressInfo(
+        '10%', 'Check device test setup completed!')
+    self.log.SendLine(self.test_info, info)
+
+    if (self.test_info['testID'] == '14187024'
+        or self.test_info['testID'] == '14165033'
+        or self.test_info['testID'] == '14315008'
+        or self.test_info['testID'] == '14165035'
+        or self.test_info['testID'] == '14314007'
+        or self.test_info['testID'] == '11865133'
+        or self.test_info['testID'] == '14335001'
+        or self.test_info['testID'] == '14266498'
+        or self.test_info['testID'] == '14319149'
+        or self.test_info['testID'] == '14314008'):
+      self.VerifyAllReqParameters()
+    elif self.test_info['testID'] == '11722375':
+      self.VerifySetParameterValuesRPC()
+    elif self.test_info['testID'] == '14315009':
+      self.VerifyManagementServerURL()
+    elif self.test_info['testID'] == '14314009':
+      self.VerifyMonitorTemperature()
+    elif self.test_info['testID'] == '14165038':
+      self.VerifyAutoChannelEnable()
+    elif self.test_info['testID'] == '15643845':
+      self.VerifyNTPTimeZoneConfig()
+    elif self.test_info['testID'] == '14165034':
+      self.VerifyWiFiConfiguration()
+    else:
+      return
+    print 'Test Completed...'
+    ####### Add your code here -- END   #######
+
+  def Destructor(self):
+    self.p_ssh.Close()
+
+if __name__ == '__main__':
+  # Test cases defined in this file:
+  test_defined = ['14187024', '14165033', '14315008', '14165035', '14314007',
+                  '11865133', '14335001', '14266498', '14319149', '14314008',
+                  '11722375', '14315009', '14314009', '14165038', '15643845',
+                  '14165034']
+  # To execute test cases that defined in config file:
+  test = DataModelTest(testID='14165034')
+  test_to_execute = testCase.TestCase.FindTestCaseToExecute('config.cfg')
+  for test_id in test_to_execute:
+    if test_id in test_defined:
+      test = DataModelTest(testID=test_id)
diff --git a/device.py b/device.py
index c02fa33..f3eb65c 100644
--- a/device.py
+++ b/device.py
@@ -1,17 +1,24 @@
 #!/usr/bin/python
 # Copyright 2012 Google Inc. All Rights Reserved.
 
-"""This class defines devices."""
+"""This class defines devices.
 
-__author__ = 'Lin Xue (linxue@google.com)'
-
-"""This file defines the base class of all devices,
+   This file defines the base class of all devices,
    and specific device classes, such as Bruno, Spirent, etc.
 """
 
+__author__ = 'Lin Xue (linxue@google.com)'
+__author__ = 'Lehan Meng (lmeng@google.com)'
+
+
+import re
+
+import ip
+
 
 class Device(object):
   """Base class of all devices.
+
      information of device class:
      addr: address of device
      user: user name of device
@@ -23,24 +30,14 @@
      other: other information of device
   """
 
-  dev_info = {'addr': 'None',
-              'user': 'None',
-              'pwd': 'None',
-              'dev_name': 'None',
-              'cmd_prompt': 'None',
-              'other': 'None'}
-
   def GetDevInfo(self):
     """This function returns device information."""
-
     return (self.dev_info['dev_name'], self.dev_info['other'])
 
   def SetLogging(self, logging):
-    """This function set logging for device"""
-
+    """This function set logging for device."""
     self.log = logging
     return
-
 # End of Device class
 
 
@@ -48,13 +45,20 @@
   """Bruno device class."""
 
   def __init__(self, **kwargs):
-    """ Constructor for Bruno device
-        device name: Bruno, and other device informations
+    """Constructor for Bruno device.
+
+    device name: Bruno, and other device informations
     """
+    self.dev_info = {'addr': 'None',
+                     'user': 'None',
+                     'pwd': 'None',
+                     'dev_name': 'None',
+                     'cmd_prompt': 'None',
+                     'other': 'None'}
+
     self.dev_info['dev_name'] = 'Bruno'
     for s in kwargs:
-        self.dev_info[s] = kwargs[s]
-
+      self.dev_info[s] = kwargs[s]
     self.dev_ssh = None
 
     # Bruno Device attributes
@@ -76,26 +80,26 @@
     self.dev_epgpri = None
     # EPG secondary
     self.dev_epgsec = None
-
     return
 
   def GetDevCmd(self, cmd='', dev_attr='', dev_log=''):
     """This function sends command to Bruno.
+
        Then it gets back the results
        If success, save the results and write log
        If fail, show Warning message
-       Args:
-            cmd:
-                the command sent to Bruno system
-                to query the device information
-            dev_attr:
-                the device attribute
-                which can be get from this command
-            dev_log:
-                the logging message to be shown in log
-
+    Args:
+      cmd:
+        the command sent to Bruno system
+        to query the device information
+      dev_attr:
+        the device attribute
+        which can be get from this command
+      dev_log:
+        the logging message to be shown in log
+    Returns:
+      return the command results
     """
-
     # Send command to query Bruno device information
     self.dev_ssh.SendCmd(cmd)
 
@@ -111,8 +115,7 @@
                                          'Get ' + dev_log + ': ' + line)
       self.log.SendLine(None, info)
       dev_attr = line
-
-    return line
+    return line.strip()
 
   def GetSerialNumber(self):
     """This function returns Bruno device serial number."""
@@ -130,20 +133,107 @@
 
     return result
 
-  def GetIPAddress(self):
-    """This function returns Bruno device IP address."""
+  def VerifyCurrentVersion(self, version):
+    """Check if the current software version matches the given version.
 
+    Args:
+      version: the expected version string to check with device software
+    Returns:
+      True: if the current version matches the given version
+      False: if otherwise
+    """
+    if version == self.GetCurrentVersion():
+      return True
+    else:
+      return False
+
+  def GetIPaddress(self):
+    """This function returns Bruno device IP address."""
+    # Obsoleted
     result = self.GetDevCmd(r'ifconfig br0', self.dev_ip,
                             'IP address')
 
     return result
 
+  def GetDNSServer(self):
+    """This function returns device DNS server name."""
+    self.dev_ssh.SendCmd('cat /etc/resolv.conf')
+    cmd_list = self.dev_ssh.GetCmdOutput()
+    dns = None
+    for line in cmd_list:
+      m = re.search('nameserver (.*)', line)
+      if m:
+        dns = m.group(1)
+        break
+    return dns
+
+  def GetTimeServer(self):
+    """This function returns device DNS server name."""
+    self.dev_ssh.SendCmd('cat /etc/ntpd.conf')
+    cmd_list = self.dev_ssh.GetCmdOutput()
+    ts = None
+    for line in cmd_list:
+      m = re.search('server (.*)', line)
+      if m:
+        ts = m.group(1)
+        break
+    return ts
+
+  def GetGVSBHost(self):
+    """This function returns device GVSB host server name."""
+    self.dev_ssh.SendCmd('cat /tmp/gvsbhost')
+    cmd_line = self.dev_ssh.GetCmdOutput(2)[0]
+    m = re.search('http[s]?://[\w\d\./-]*', cmd_line)
+    if m:
+      return m.group(0)
+    return None
+
+  def GetIPv4Address(self):
+    """This function returns Bruno device IPv4 address."""
+    self.dev_ssh.SendCmd('ip addr show dev br0')
+    cmd_list = self.dev_ssh.GetCmdOutput()
+    address = None
+    for line in cmd_list:
+      if 'inet ' in line and 'scope global' in line:
+        address = ip.IPADDR(line).IsLikeIpv4Address()
+
+    if not address:
+      info = self.log.CreateErrorInfo('critical',
+                                      'Can not detect IPv4 address on device!')
+      self.log.SendLine(None, info)
+    return address
+
+  def GetIPv6Address(self):
+    """This function returns Bruno device IPv6 address.
+
+    This function will return a list of addresses. Sometimes device may
+    have multiple IPv6 addresses.
+
+    Returns:
+      return the obtained IPv6 address
+    """
+    self.dev_ssh.SendCmd('ip addr show dev br0')
+    cmd_list = self.dev_ssh.GetCmdOutput()
+    address = []
+    for line in cmd_list:
+      if 'inet6 ' in line and 'scope global' in line:
+        print line
+        m = re.match('inet6 ([\da-f:]+)/\d+ scope global \w*', line.strip())
+        if not m:
+          info = self.log.CreateErrorInfo(
+              'critical', 'Can not detect valid IPv6 address '
+              'on device! ' + line)
+          self.log.SendLine(None, info)
+          return address
+        addr = m.group(1)
+        address.append(addr)
+    return address
+
   def GetDevTime(self):
     """This function returns Bruno device current date."""
 
     result = self.GetDevCmd(r'date', self.dev_time,
                             'current date')
-
     return result
 
   def GetACSUrl(self):
@@ -151,9 +241,22 @@
 
     result = self.GetDevCmd(r'cat /tmp/cwmp/acs_url', self.dev_acs,
                             'ACS URL')
-
     return result
 
+  def VerifyCurrentACSURL(self, url):
+    """Check if the current ACS URL matches the given URL.
+
+    Args:
+      url: the expected url string to check with device ACS URL
+    Returns:
+      True: if the current url matches the given url
+      False: otherwise
+    """
+    if url == self.GetACSUrl():
+      return True
+    else:
+      return False
+
   def GetDnldImage(self):
     """This function returns Bruno device current downloading image."""
 
@@ -163,7 +266,7 @@
     return result
 
   def GetProductClass(self):
-    """This function returns Bruno device product class"""
+    """This function returns Bruno device product class."""
 
     result = self.GetDevCmd(r'cat /etc/platform', self.dev_class,
                             'product class')
@@ -171,7 +274,7 @@
     return result
 
   def GetEpgPrimary(self):
-    """This function returns Bruno device primary EPG"""
+    """This function returns Bruno device primary EPG."""
 
     result = self.GetDevCmd(r'cat /tmp/epgprimary', self.dev_epgpri,
                             'EPG primary')
@@ -179,7 +282,7 @@
     return result
 
   def GetEpgSecond(self):
-    """This function returns Bruno device secondary EPG"""
+    """This function returns Bruno device secondary EPG."""
 
     result = self.GetDevCmd(r'cat /tmp/epgsecondary', self.dev_epgsec,
                             'EPG secondary')
@@ -197,7 +300,7 @@
     # Other device informations
     self.GetSerialNumber()
     self.GetCurrentVersion()
-    self.GetIPAddress()
+    self.GetIPv4Address()
     self.GetDevTime()
     self.GetACSUrl()
     self.GetDnldImage()
@@ -207,6 +310,59 @@
 
     return
 
+  def GetTimeStamp(self, line=None):
+    """Extract the time information of most current event from Device log.
+
+    i.e., the time that the last event happens since reboot (in seconds)
+    Args:
+      line: a line of device log which contains event time information.
+            If it has value of 'None', then retrieve the last a few lines from
+            device log to extract time information.
+    Returns:
+      return the time stamp string if succeed, return -1 otherwise.
+    """
+    if not line:
+      # get time stamp from Device log file
+      self.dev_ssh.SendCmd('dmesg | grep cwmpd:')
+      log_list = self.dev_ssh.GetCmdOutput()
+
+      for line in log_list:
+        m = re.match('\\[[\s]*(\d*\\.\d{3})\\]', line)
+        if m:
+          # Match, return the time stamp
+          return m.group(1)
+    else:
+      # get time stamp from a Device log line
+      m = re.match('\\[[\s]*(\d*\\.\d{3})\\]', line)
+      if m:
+      # Match, return the time stamp
+        return m.group(1)
+    # No time stamp found
+    return -1
+
+  def FindLineInLog(self, log_list, time_stamp, pattern_line):
+    """Match a particular string from device logs.
+
+    Find a particular string or line from device log
+    Args:
+      log_list: the device log to search from
+      time_stamp: to search events that are after this time
+      pattern_line: the string or line that need to be matched in device log
+    Returns:
+      True: if 'line' matched
+      False: 'line' not found in device log
+    """
+    m = re.compile(pattern_line)
+    for line in log_list:
+      if float(self.GetTimeStamp(line)) > float(time_stamp):
+        #Debug
+        if 'detected' in line:
+          print 'here'
+
+        matching = m.search(line)
+        if matching:
+          return True
+    return False
 # End of Bruno device class
 
 
@@ -214,7 +370,8 @@
   """Spirent device class."""
 
   def __init__(self, **kwargs):
-    """ Constructor for Spirent device
+    """Constructor for Spirent device.
+
         device name: Spirent, and other device informations
     """
 
diff --git a/download.py b/download.py
index 475b287..d39b6e4 100755
--- a/download.py
+++ b/download.py
@@ -4,18 +4,11 @@
 """This class defines the test case "image download" from ACS.
 
 This class extends the TestCase Class.
-testID: 11843140
-This test does the following tasks:
-  - check current image version
-    - if the current version is the same as expected version,
-      this test will first to try to downgrade it to the downgrade_version.
-    - Then, it will Run image download test
-    - Fianlly, it will downgrade to downgrade_version if this has not been
-      done. This is to test the download handling capabilities of the
-      expected_version
-  - configure ACS instance with these software versions
-  - verify image download and installation to be complete and successful, by
-    observing a successfully reboot after installation
+This file includes the following test cases:
+  - testID: 11843140  7.6.11 Verify firmware upgrade/downgrade by ACS
+  - testID: 14165036  7.6.18 Negative test: Bruno Image download interruption
+  - testID: 14334001  7.6.25.3 File Transfer (File upload is optional, this is
+                               then basically the same test case as download.)
 """
 
 __author__ = 'Lehan Meng (lmeng@google.com)'
@@ -43,20 +36,17 @@
       title =Image_Download
       current_version=None
       expected_version=bruno-iguana-2-dg
-      ACS_URL = https://gfiber-acs-staging.appspot.com/cwmp
+      acs_url = https://gfiber-acs-staging.appspot.com/cwmp
   """
 
   def Init(self):
     """Initialte the DownloadTest instance."""
-    self.p_ssh = ssh.SSH(user=self.params['user'],
-                         addr=self.params['addr'],
-                         pwd=self.params['pwd'],
-                         bruno_prompt=self.params['bruno_prompt'],
-                         addr_ipv6=self.params['addr_ipv6'],
-                         athena_user=self.params['athena_user'],
-                         athena_pwd=self.params['athena_pwd'],
-                         jump_server=self.params['jump_server'])
-    self.p_ssh.Setlogging(self.log)
+    if not self.p_ssh:
+      self.p_ssh = ssh.SSH(user=self.params['user'],
+                           addr=self.params['addr'],
+                           bruno_prompt=self.params['bruno_prompt'],
+                           addr_ipv6=self.params['addr_ipv6'])
+      self.p_ssh.SetLogging(self.log)
     self.__debug = False
     self.__short_delay = 5  #short delay: 5 seconds
     self.__delay = 180  #medium delay: 180 seconds
@@ -69,18 +59,18 @@
     """
     self.p_ssh.SendCmd('cat /tmp/cwmp/acs_url')
     line = self.p_ssh.GetCmdOutput()[1]
-    m_1 = re.match(self.params['ACS_URL'], line)
+    m_1 = re.match(self.params['acs_url'], line)
     if m_1 is None:
       info = self.log.CreateErrorInfo(
           'intermediate',
           'ACS URL unknown! Update ACS URL manually')
       self.log.SendLine(self.test_info, info)
 
-      self.p_ssh.SendCmd('echo ' + self.params['ACS_URL']
+      self.p_ssh.SendCmd('echo ' + self.params['acs_url']
                          + ' > /tmp/cwmp/acs_url')
-      self.AddConfigParams('current_ACS_url', self.params['ACS_URL'])
+      self.AddConfigParams('current_ACS_url', self.params['acs_url'])
     else:
-      self.AddConfigParams('current_ACS_url', self.params['ACS_URL'])
+      self.AddConfigParams('current_ACS_url', self.params['acs_url'])
 
   def SetACSUrl(self, url='http://acs-sandbox.appspot.com/cwmp'):
     """Set ACS URL on the device."""
@@ -115,8 +105,7 @@
       # get time stamp from Device log file
       self.p_ssh.SendCmd('dmesg | grep cwmpd:')
       # search the last 30 lines in Device log for time information
-      latest_log_entry = 30
-      log_list = self.p_ssh.GetCmdOutput(latest_log_entry)
+      log_list = self.p_ssh.GetCmdOutput()
 
       for line in log_list:
         m = re.match('\\[[\s]*(\d*\\.\d{3})\\]', line)
@@ -131,30 +120,29 @@
         return m.group(1)
 
     # No time stamp found
-    return -1
+    info = self.log.createErrorInfo(
+              'Critical', 'Exit! Can not find time information from '
+              'device log ...')
+    self.log.sendLine(self.test_info, info)
+    return os.sys.exit(1)
 
-  def ConfigACS(self):
+  def ConfigACS(self, version_id):
     """Setup the ACS device profile with expected image.
 
     Then restart the cwmpd process on device to
     initiate the inform/download process
+    Args:
+      version_id: the expected version id that needs to be configured
     Returns:
       return the time stamp string if succeed, return -1 otherwise.
     """
     #configure ACS:
-    acs_instance = acs.ACS(self.params['expected_version_id'])
+    acs_instance = acs.ACS(acs_path=self.params['acs_path'])
     acs_instance.SetLogging(self.log)
-    acs_instance.SaveConfiguration()
+    acs_instance.SaveConfiguration(
+        self.params['profile_id'], version_id, self.params['acs_app_id'],
+        self.params['acs_host_name'])
 
-    #self.p_ssh.SendCmd('/etc/Init.d/S85catawampus restart')
-    # To setup any device service parameter using nbi_client will trigger
-    # ACS to make a remote connection request to the device.
-    # However, currently ACS does not provide separate stubby call to
-    # only request a remote connection.
-    # As walk around:
-    #   1. call remote management URL locally to initiate Inform immediately
-    #   2. wait for the next periodic inform to initiate download
-    # Here go for the 2nd option.
     time_stamp = self.GetTimeStamp()
     return time_stamp
 
@@ -220,30 +208,34 @@
       return True if rebooted
       return False otherwise
     """
+    time.sleep(5)
     s = self.GetTimeStamp()
-    if float(s) < float(time_stamp):
+    print 'previous time stamp: ' + time_stamp
+    print 'current time stamp: ' + s
+    if float(s) < float(time_stamp) and s is not -1:
       return True
     return False
 
-  def CheckImageInstallation(self, time_stamp):
+  def CheckImageInstallation(self, time_stamp, version):
     """Check if the Image installation and Device reboot is successful.
 
     An upgrade is considered complete only after the device is rebooted
     after image installation
     Args:
       time_stamp: check if a reboot is done after this time
+      version: the image version that needs to be installed
     Returns:
       return True if installation succeeded
       return False otherwise
     """
-    self.p_ssh.ExitToAthena()
-    time.sleep(3*self.__short_delay)
-    self.p_ssh.SshRetryFromAthena()
+    self.p_ssh.Close()
+    time.sleep(6*self.__short_delay)
+    self.p_ssh.SshRetry()
     count = 0
     ts = time_stamp
     while not self.IsRebooted(ts):
       count +=1
-      if count*self.__short_delay*3 > self.__long_delay:
+      if count*self.__short_delay*6 > self.__long_delay:
         info = self.log.CreateErrorInfo(
             'critical',
             'Error! File download longer than ' + str(self.__long_delay)
@@ -252,61 +244,56 @@
         os.sys.exit(1)
 
       t = self.GetTimeStamp()
-      if t > ts:
+      if float(t) > float(ts):
         ts = t
-      self.p_ssh.ExitToAthena()
+      self.p_ssh.Close()
       info = self.log.CreateProgressInfo(
-          '90%', 'Wait ' + str(3*self.__short_delay)
+          '---', 'Wait ' + str(6*self.__short_delay)
           + ' seconds for image installation and device reboot...')
       self.log.SendLine(self.test_info, info)
-      time.sleep(3*self.__short_delay)
-      self.p_ssh.SshRetryFromAthena()
+      time.sleep(6*self.__short_delay)
+      self.p_ssh.SshRetry()
 
     time.sleep(2*self.__short_delay)
     self.p_ssh.SendCmd('more /etc/version')
     line = self.p_ssh.GetCmdOutput()[1]
     crt_version = line.strip()
-    print crt_version + '########' + self.params['expected_version']
-    if crt_version == self.params['expected_version']:
+    print crt_version + '########' + version
+    if crt_version == version:
       return True
     else:
       return False
 
-  def Run(self):
-    """Run the test case."""
-    ####### Add your code here -- BEGIN #######
-    print 'Test Started...'
-    self.Init()
-    self.p_ssh.SshToAthena()
-    info = self.log.CreateProgressInfo(
-        '5%', 'SSH session to Athena server successfully established!')
-    self.log.SendLine(self.test_info, info)
+  def VerifyImageDownload(self):
+    """Verify image download and upgrade.
 
-    max_test_idx = 2
+    This test checks the following:
+      - check current image version
+      - if current_version is not expected_version as defined in config file:
+        - Upgrade to expected_version (verify expected version can boot up)
+        - Downgrade from expected_version to downgrade_version
+          (verify downgrade handling capability of expected_version image)
+        - Finally upgrade to expected_version, and keep device in this state.
+      - if the current version is already the expected_version,
+        - Downgrade from expected_version to downgrade_version
+          (verify downgrade handling capability of expected_version image)
+        - Finally upgrade to expected_version, and keep device in this state.
+
+    At the same time, it also verifies:
+      - configure ACS with these software versions
+    """
+    max_test_idx = 3
     current_test_idx = 1
+    upgrade = True
 
-    while current_test_idx < max_test_idx:
-      self.p_ssh.SshRetryFromAthena()
+    while current_test_idx <= max_test_idx:
       info = self.log.CreateResultInfo(
           '---', 'Test Sequence Number: ' + str(current_test_idx))
       self.log.SendLine(self.test_info, info)
-      while self.CheckDownloadFileExists():
-        # current in download
-        info = self.log.CreateProgressInfo(
-            '10%', 'Another downloading in progress, retry after '
-            + str(self.__short_delay) + 'seconds...')
-        self.log.SendLine(self.test_info, info)
-        self.p_ssh.ExitToAthena()
-        time.sleep(self.__short_delay)
-        self.p_ssh.SshRetryFromAthena()
-
-      info = self.log.CreateProgressInfo(
-          '15%', 'SSH session to device successfully established!')
-      self.log.SendLine(self.test_info, info)
 
       self.CheckACSUrl()
       info = self.log.CreateProgressInfo('20%', 'Current ACS url: '
-                                         + self.params['ACS_URL'])
+                                         + self.params['acs_url'])
       self.log.SendLine(self.test_info, info)
 
       self.CheckVersion()
@@ -314,47 +301,199 @@
                                          + self.params['current_version'])
       self.log.SendLine(self.test_info, info)
 
-      # Need to do:
-      # check if the currently version is already expected version,
-      # if so, downgrade first, then Run this test
-      #if self.params['current_version'] == self.params['expected_version']:
-      #  info = self.log.createErrorInfo(
-      #        'low', 'Currently image is expected version, '
-      #        + 'please try other images.')
-      #  self.log.sendLine(self.test_info, info)
+      if self.params['current_version'] == self.params['expected_version']:
+        if current_test_idx == 1:
+          current_test_idx += 1
+          upgrade = False
+          continue
 
-      self.time_stamp = self.ConfigACS()
-      info = self.log.CreateProgressInfo('40%', 'Expected Version: '
-                                         + self.params['expected_version'])
-      self.log.SendLine(self.test_info, info)
+      version = None
+      if upgrade:
+        self.time_stamp = self.ConfigACS(self.params['expected_version_id'])
+        info = self.log.CreateProgressInfo('40%', 'Expected Version: '
+                                           + self.params['expected_version'])
+        self.log.SendLine(self.test_info, info)
+        version = self.params['expected_version']
+      else:
+        self.time_stamp = self.ConfigACS(self.params['downgrade_version_id'])
+        info = self.log.CreateProgressInfo('40%', 'Downgrade Version: '
+                                           + self.params['downgrade_version'])
+        self.log.SendLine(self.test_info, info)
+        version = self.params['downgrade_version']
+
       info = self.log.CreateProgressInfo(
-          '40%', 'Successfully configured ACS for expected image version')
+          '50%', 'Successfully configured ACS for image version: ' + version)
       self.log.SendLine(self.test_info, info)
 
       time.sleep(self.__short_delay)  # time delay for log update
-      if self.CheckImageInstallation(self.time_stamp):
+      self.time_stamp = self.GetTimeStamp()
+      if self.CheckImageInstallation(self.time_stamp, version):
         info = self.log.CreateProgressInfo(
             '100%', 'Image successfully upgraded to expected version: '
             'from: ' + self.params['current_version']
-            + ' to: ' + self.params['expected_version'])
+            + ' to: ' + version)
         self.log.SendLine(self.test_info, info)
         info = self.log.CreateResultInfo(
             'Pass', 'Image successfully upgraded to expected version: '
             'from: ' + self.params['current_version']
-            + ' to: ' + self.params['expected_version'])
+            + ' to: ' + version)
         self.log.SendLine(self.test_info, info)
       else:
         info = self.log.CreateErrorInfo(
             'critical',
             'Error! Image version does not match expected version!')
         self.log.SendLine(self.test_info, info)
+        info = self.log.CreateResultInfo(
+            'Failed', 'Image failed to upgraded to expected version: '
+            'from: ' + self.params['current_version']
+            + ' to: ' + version)
+        self.log.SendLine(self.test_info, info)
 
       current_test_idx += 1
-      self.p_ssh.ExitToAthena()
-    # Need to do:
-    # downgrade from expected_version
-    # To verify the capability of the download handling on expected version
-    # image
+      if upgrade:
+        upgrade = False
+      else:
+        upgrade = True
+
+  def ImageUpgrade(self, expected_version, expected_version_id):
+    """This function upgrade device image to expected version.
+
+    Args:
+      expected_version: the version to be upgraded to
+      expected_version_id: the id of the expected version
+    Returns:
+      True if upgrade succeeds
+      False if upgrade fails
+    """
+    version = self.GetVersion()
+    if version == expected_version:
+      info = self.log.CreateProgressInfo(
+            '---', 'Image is already expected versioin: '
+            + expected_version)
+      self.log.SendLine(self.test_info, info)
+      return True
+    self.time_stamp = self.ConfigACS(expected_version_id)
+    info = self.log.CreateProgressInfo(
+          '---', 'Successfully configured ACS for image version: '
+          + expected_version)
+    self.log.SendLine(self.test_info, info)
+
+    time.sleep(self.__short_delay)  # time delay for log update
+    self.time_stamp = self.GetTimeStamp()
+    if self.CheckImageInstallation(self.time_stamp, expected_version):
+      info = self.log.CreateProgressInfo(
+            '---', 'Image successfully upgraded to expected version: '
+            'from: ' + version + ' to: ' + expected_version)
+      self.log.SendLine(self.test_info, info)
+      return True
+    else:
+      info = self.log.CreateErrorInfo(
+          'critical',
+          'Error! Image version does not match expected version!')
+      self.log.SendLine(self.test_info, info)
+      return False
+
+  def VerifyDownloadInterrupt(self):
+    """Negative test case: verify image download interruption.
+
+    This case tests device's capability of image upgrade in case of
+    power loss, power cycle, or multiple download requests from ACS.
+    The device should finally be able to complete the download and
+    image upgrade process from expected_version to downgrade_version.
+
+    Returns:
+      return: False if the verification fails
+      return: True otherwise
+    """
+    self.CheckVersion()
+    if self.params['current_version'] != self.params['expected_version']:
+      info = self.log.CreateProgressInfo(
+          '5%', 'Current version is not expected version to test, upgrade to: '
+          + self.params['expected_version'])
+      self.log.SendLine(self.test_info, info)
+      if not self.ImageUpgrade(self.params['expected_version'],
+                               self.params['expected_version_id']):
+        info = self.log.CreateErrorInfo(
+            'critical',
+            'Failed to upgrade version to: '
+            + self.params['expected_version'])
+        self.log.SendLine(self.test_info, info)
+        return False
+    self.ConfigACS(self.params['downgrade_version_id'])
+    info = self.log.CreateProgressInfo(
+          '10%', 'Successfully configured ACS for image version: '
+          + self.params['downgrade_version'])
+    self.log.SendLine(self.test_info, info)
+
+    time.sleep(6*self.__short_delay)
+
+    info = self.log.CreateProgressInfo(
+          '40%', 'Download started, reboot the device.')
+    self.log.SendLine(self.test_info, info)
+    time_stamp = self.GetTimeStamp()
+    self.p_ssh.SendCmd('reboot')
+    self.p_ssh.GetCmdOutput()
+    while not self.IsRebooted(time_stamp):
+      self.p_ssh.Close()
+      time.sleep(self.__short_delay*3)
+      self.p_ssh.SshRetry()
+      info = self.log.CreateProgressInfo(
+          '60%', 'Downloading interrupted, waiting for device boot up.')
+      self.log.SendLine(self.test_info, info)
+
+    time_stamp = self.GetTimeStamp()
+    version = self.GetVersion()
+    if version != self.params['downgrade_version']:
+      count = 0
+      while not self.IsRebooted(time_stamp):
+        count += 1
+        if count*self.__short_delay > self.__long_delay:
+          info = self.log.CreateErrorInfo(
+              'critical',
+              'Error! Image downloading is not successful after interruption!')
+          self.log.SendLine(self.test_info, info)
+          info = self.log.CreateResultInfo(
+              'Failed',
+              'Image failed to upgraded to version: '
+              + self.params['downgrade_version'] + ' ('
+              + self.__long_delay + ' seconds) after interrupted.')
+          self.log.SendLine(self.test_info, info)
+          return False
+        time_stamp = self.GetTimeStamp()
+        info = self.log.CreateProgressInfo(
+          '80%', 'Waiting for downloading complete after interruption.')
+        self.log.SendLine(self.test_info, info)
+        time.sleep(self.__short_delay*5)
+
+    info = self.log.CreateProgressInfo(
+        '100%', 'Image successfully upgraded to version: '
+        + self.params['downgrade_version'] + ' after interrupted.')
+    self.log.SendLine(self.test_info, info)
+    info = self.log.CreateResultInfo(
+        'Pass', 'Image successfully upgraded to version: '
+        + self.params['downgrade_version'] + ' after interrupted.')
+    self.log.SendLine(self.test_info, info)
+    return True
+
+  def Run(self):
+    """Run the test case."""
+    ####### Add your code here -- BEGIN #######
+    print 'Test Started...'
+    self.Init()
+    self.p_ssh.SshRetry()
+    info = self.log.CreateProgressInfo(
+        '5%', 'SSH session to device successfully established!')
+    self.log.SendLine(self.test_info, info)
+
+    if self.test_info['testID'] == '11843140':
+      self.VerifyImageDownload()
+      info = self.log.CreateResultInfo(
+        '----', 'For file transfer test, refer to image download test result:'
+        ' testID: 11843140.')
+      self.log.SendLine(self.test_info, info)
+    elif self.test_info['testID'] == '14165036':
+      self.VerifyDownloadInterrupt()
+
     print 'Test Completed...'
     ####### Add your code here -- END   #######
 
@@ -365,4 +504,10 @@
 
 
 if __name__ == '__main__':
-  DownloadTest(testID='11843140', key_word='Download')
\ No newline at end of file
+  # Test cases defined in this file:
+  test_defined = ['11843140', '14165036', '14334001']
+  # To execute test cases that defined in config file:
+  test_to_execute = testCase.TestCase.FindTestCaseToExecute('config.cfg')
+  for test_id in test_to_execute:
+    if test_id in test_defined:
+      test = DownloadTest(testID=test_id)
diff --git a/logging.py b/logging.py
old mode 100644
new mode 100755
index ade9f50..dd1654a
--- a/logging.py
+++ b/logging.py
@@ -16,17 +16,13 @@
 
 
 import datetime
+import errno
+import os
 
 
 class Logging(object):
   """This Class collects and writes test information to log files."""
 
-  params = {'std_out': '1',
-           'f_result': 'result.log',
-           'f_error': 'error.log',
-           'f_progress': 'progress.log',
-           'delimiter': '\t'}
-
   def __init__(self, **kwargs):
     """initiate the logging instance.
 
@@ -36,15 +32,129 @@
       kwargs['f_progres']: file name for test progres
       kwargs['std_out']: by default, send a copy of the log info to stdout
     """
-    for s in ('f_result', 'f_error', 'f_progress', 'std_out'):
-      if s in kwargs:
-        self.params[s] = kwargs[s]
 
-    self.rst_file = open(self.params['f_result'], 'a')
-    self.err_file = open(self.params['f_error'], 'a')
-    self.prg_file = open(self.params['f_progress'], 'a')
+    self.params = {'std_out': '1',
+                   'f_result': 'result.log',
+                   'f_error': 'error.log',
+                   'f_progress': 'progress.log',
+                   'delimiter': '\t',
+                   'out_folder': 'log',
+                   'in_folder': 'data'}
+    for s in kwargs:
+      self.params[s] = kwargs[s]
+
+    try:
+      os.makedirs(self.params['out_folder'])
+    except OSError, e:
+      if e.errno != errno.EEXIST:
+        raise
+
+    now = datetime.datetime.now()
+    s_time = now.strftime('%Y-%m-%d_%H:%M:%S.%f')
+    for f_name in ['f_result', 'f_error', 'f_progress']:
+      name = self.ParseLogFileName(self.params[f_name], 'w', s_time)
+      if name:
+        self.params[f_name] = name
+      else:
+        print 'Error! Fail to create log File.'
+    self.rst_file = open(self.params['f_result'], 'w+')
+    self.err_file = open(self.params['f_error'], 'w+')
+    self.prg_file = open(self.params['f_progress'], 'w+')
     self.NewTestStart()
 
+  def CreateFile(self, f_name, access='r'):
+    """Create a file for read/write.
+
+    Args:
+      f_name: the file name that needs to be created
+      access: 'r': read, input file
+              'w': write, output file
+              'rw': read and write
+    Returns:
+      f_obj: return the file object
+             if not succeed, return False
+    """
+    f_obj = None
+    if access == 'r':
+      # for input file
+      try:
+        f_obj = open(f_name, 'r')
+      except IOError:
+        print 'Cannot open the input file, return'
+        return False
+    elif access == 'w':
+      # for input file
+      try:
+        os.makedirs(self.params['out_folder'])
+      except OSError, e:
+        if e.errno != errno.EEXIST:
+          print 'Cannot create folder! Return'
+          return False
+      full_path = self.ParseLogFileName(f_name, access)
+      if full_path:
+        try:
+          f_obj = open(full_path, 'w+')
+        except IOError:
+          print 'Cannot open the given file, return'
+          return False
+      else:
+        # Can not parse file name
+        print 'Cannot parse given file name'
+        return False
+    else:
+      # read-write file:
+      try:
+        f_obj = open(f_name, 'r')
+      except IOError:
+        print 'Cannot open the input file, return'
+        return False
+    return f_obj
+
+  def ParseLogFileName(self, f_name, access='r', time_stamp=None):
+    """Generate an uniq log file name for each test case instance.
+
+    Args:
+      f_name: file name
+      access: 'r': read mode
+              'w': write mode
+              'rw': read-write
+      time_stamp: the time tag used for file name
+                  if None, create a new tag using current time
+    Returns:
+      return the parsed file name
+    """
+    if not f_name:
+      f_name = 'logFile.log'
+    if not time_stamp:
+      now = datetime.datetime.now()
+      s_time = now.strftime('%Y-%m-%d_%H:%M:%S.%f')
+    else:
+      s_time = time_stamp
+
+    ls = f_name.split('.')
+    ext_name = ''
+    name = ''
+    if len(ls) == 1:
+      name = ls[0]
+    else:
+      ext_name = ls.pop(-1)
+      for s in ls:
+        name += (s+'.')
+      name = name.rstrip('.')
+
+    if not ext_name:
+      ext_name = 'log'
+    folder = None
+    if access == 'r':
+      folder = self.params['in_folder']
+    elif access == 'w':
+      folder = self.params['out_folder']
+    else:
+      folder = self.params['in_folder']
+    name = (folder + '/' + name + '_testID-' + self.params['testID']
+            + '_'+ s_time + '.' + ext_name)
+    return name
+
   def SendLineToResult(self, test_info, result_info):
     """Send test result (one-line) information to the result file.
 
@@ -56,7 +166,7 @@
     """
     now = datetime.datetime.now()
     if test_info is not None:
-      line = (now.strftime('%Y-%m-%d %H:%M') + self.params['delimiter']
+      line = (now.strftime('%Y-%m-%d %H:%M:%S.%f') + self.params['delimiter']
               + 'testID:' + test_info['testID']
               + self.params['delimiter'] + 'TestStartAt:'
               + test_info['start_time']
@@ -69,7 +179,8 @@
 
     if self.params['std_out'] > 0:
       print line
-    return self.rst_file.write(line)
+    self.rst_file.write(line)
+    self.rst_file.flush()
 
   def NewTestStart(self):
     """Mark the start of a new test in the file."""
@@ -91,7 +202,7 @@
     """
     now = datetime.datetime.now()
     if test_info is not None:
-      line = (now.strftime('%Y-%m-%d %H:%M') + self.params['delimiter']
+      line = (now.strftime('%Y-%m-%d %H:%M:%S.%f') + self.params['delimiter']
               + 'testID:' + test_info['testID'] + self.params['delimiter']
               + 'TestStartAt:' + test_info['start_time']
               + self.params['delimiter'] + 'Keyword:'
@@ -99,13 +210,14 @@
               + error_info['severity'] + self.params['delimiter']
               + error_info['note'] + '\n')
     else:
-      line = (now.strftime('%Y-%m-%d %H:%M') + self.params['delimiter'] +
+      line = (now.strftime('%Y-%m-%d %H:%M:%S.%f') + self.params['delimiter'] +
               error_info['severity'] + self.params['delimiter']
               + error_info['note'] + '\n')
 
     if self.params['std_out'] > 0:
       print line
-    return self.err_file.write(line)
+    self.err_file.write(line)
+    self.err_file.flush()
 
   def SendLineToProgress(self, test_info, progress_info):
     """Send test progress (one-line) information to the progress file.
@@ -119,20 +231,21 @@
     """
     now = datetime.datetime.now()
     if test_info is not None:
-      line = (now.strftime('%Y-%m-%d %H:%M') + self.params['delimiter']
+      line = (now.strftime('%Y-%m-%d %H:%M:%S.%f') + self.params['delimiter']
               + 'testID:' + test_info['testID'] + self.params['delimiter']
               + 'TestStartAt:'+ test_info['start_time']
               + self.params['delimiter'] + 'Keyword:' + test_info['key_word']
               + self.params['delimiter'] + progress_info['percent']
               + self.params['delimiter'] + progress_info['note'] + '\n')
     else:
-      line = (now.strftime('%Y-%m-%d %H:%M') + self.params['delimiter']
+      line = (now.strftime('%Y-%m-%d %H:%M:%S.%f') + self.params['delimiter']
               + progress_info['percent'] + self.params['delimiter']
               + progress_info['note'] + '\n')
 
     if self.params['std_out'] > 0:
       print line
-    return self.prg_file.write(line)
+    self.prg_file.write(line)
+    self.prg_file.flush()
 
   def SendLine(self, test_info, info):
     """Send test (one-line) information to the corresponding log file.
@@ -151,12 +264,18 @@
     elif info['type'] == 'progress':
       return self.SendLineToProgress(test_info, info)
 
+  def SendTestData(self, data_list):
+    """Send test data to result file."""
+    for line in data_list:
+      self.rst_file.write(line + '\n')
+    self.err_file.flush()
+
   def SendLines(self, test_info, info):
     """Send test output (multiple lines) to the corresponding log file.
 
     Args:
       test_info: test case related info: testID, start_time, key_word, etc
-      info: test results/error/progress information (single line)
+      info: test results/error/progress information
             test_info could be "None" for class other than TestCase
     Returns:
       return 1 when succeed
@@ -242,4 +361,4 @@
     """Close the log files."""
     self.rst_file.close()
     self.err_file.close()
-    self.prg_file.close()
\ No newline at end of file
+    self.prg_file.close()
diff --git a/run.py b/run.py
index b0e5088..1130dc7 100755
--- a/run.py
+++ b/run.py
@@ -17,7 +17,7 @@
 optspec = """
 run [options...] <hosts> -- <command string...>
 --
-r,raw           Raw output (don't prefix with the host's name)
+r,raw           Raw output (don't redirect stdin/stdout/stderr)
 q,quiet         Quiet: don't print to stderr for nonzero exit codes
 """
 
@@ -42,27 +42,32 @@
 
 
 class Handler(object):
-  def __init__(self, prefix, fileobj, raw):
+  """When data is received from the given file, print it line by line."""
+
+  def __init__(self, prefix, fileobj):
     self.prefix = prefix
     self.fileobj = fileobj
-    self.raw = raw
+    self.buf = ''
+
+  def __del__(self):
+    if self.buf and not self.buf.endswith('\n'):
+      self.buf += '\n'
+    self.PrintBuf()
 
   def fileno(self):  #gpylint: disable-msg=C6409
     return self.fileobj.fileno()
 
+  def PrintBuf(self):
+    while '\n' in self.buf:
+      line, self.buf = self.buf.split('\n', 1)
+      print '%s: %s' % (self.prefix, line)
+
   def Run(self):
     """Read from this handler and write its results to stdout."""
-    buf = os.read(self.fileobj.fileno(), 65536)
-    if buf:
-      if self.raw:
-        sys.stdout.write(buf)
-      else:
-        if not buf.endswith('\n'):
-          buf += '\n'
-        lines = buf.split('\n')[:-1]
-        for line in lines:
-          print '%s: %s' % (self.prefix, line)
-    return buf
+    got = os.read(self.fileobj.fileno(), 65536)
+    self.buf += got
+    self.PrintBuf()
+    return got
 
 
 def main():
@@ -95,11 +100,14 @@
     else:
       argv = cmd[0]
       shell = True
-    p = subprocess.Popen(argv, env=env, shell=shell,
-                         stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    if opt.raw:
+      p = subprocess.Popen(argv, env=env, shell=shell)
+    else:
+      p = subprocess.Popen(argv, env=env, shell=shell,
+                           stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+      handlers.append(Handler(host.name, p.stdout))
+      handlers.append(Handler(host.name, p.stderr))
     procs.append((host, p))
-    handlers.append(Handler(host.name, p.stdout, opt.raw))
-    handlers.append(Handler(host.name, p.stderr, opt.raw))
 
   while handlers:
     r, _, _ = select.select(handlers, [], [])
diff --git a/ssh.py b/ssh.py
old mode 100644
new mode 100755
index 8b9f2e3..7232542
--- a/ssh.py
+++ b/ssh.py
@@ -54,9 +54,10 @@
       'bruno_prompt': '\(none\)#',
       'jump_server': 'jmp.googlefiber.net',
       'jump_prompt': None,
-      'athena_user': None,
-      'athena_pwd': None,
-      'athena_prompt': None}
+      'athena_user': 'lmeng',
+      'athena_pwd': 'changeme',
+      'athena_prompt': None,
+      'ssh_use_athena': False}
 
     self.tmp_file = tempfile.TemporaryFile(mode='w+t')
 
@@ -66,19 +67,13 @@
 
     for s in kwargs:
       self.params[s] = kwargs[s]
-
     #populate prompt on jump and athena server:
-    if self.params['athena_user'] is not 'None':
+    if self.params['athena_user']:
       self.params['jump_prompt'] = self.params['athena_user'] + '@jmp101.nuq1:'
       self.params['athena_prompt'] = ('[' + self.params['athena_user']
                                       + '@athenasrv3 ~]$')
 
-    if dev is not None:
-      # parameters used to open an ssh tunnel to this device
-      for s in ('user', 'addr', 'pwd', 'bruno_prompt', 'addr_ipv6'):
-        self.params[s] = kwargs[s]
-
-  def Setlogging(self, logging):
+  def SetLogging(self, logging):
     """Setup the logging file(s)."""
     self.log = logging
 
@@ -102,7 +97,7 @@
     p_ssh = pexpect.spawn('ssh '+self.params['user']+'@'+addr)
     i = p_ssh.expect(
         [ssh_newkey, 'password:', self.params['bruno_prompt'], pexpect.EOF,
-         '\(none\)#', 'gfibertv#', pexpect.TIMEOUT])
+         '\(none\)#', 'gfibertv#', pexpect.TIMEOUT], self.__long_delay)
 
     while 1:
       if i == 0:
@@ -123,25 +118,14 @@
         if i == 5: self.params['bruno_prompt'] = 'gfibertv#'
         return True
       if i == 3 or i == 6:
-        print 'Key or connection timeout'
+        print 'ssh did not respond, or connection timeout'
         return False
       if i < 0 or i > 6:
         print 'Error, quit'
         return False
 
-  def SshFromAthena(self):
-    """Initiate an ssh tunnel from the athenasrv3 to the device.
-
-    Returns:
-      return True when succeed, return False otherwise
-    """
-    # clear the temp file
-    self.tmp_file.close()
-    self.tmp_file = tempfile.TemporaryFile(mode='w+t')
-    self.p_ssh.logfile = self.tmp_file
-    #Const
-    ssh_newkey = 'Are you sure you want to continue connecting'
-
+  def SetDeviceSSHKey(self):
+    """Setup ssh-agent on athena server."""
     self.p_ssh.sendline('ssh-agent /bin/bash')
     self.p_ssh.expect(self.params['athena_prompt'])
     #p_ssh.expect(self.params['athena_prompt'])
@@ -153,6 +137,24 @@
     self.p_ssh.expect(self.params['athena_prompt'])
     #print self.p_ssh.before
 
+  def SshFromAthena(self, set_key=False):
+    """Initiate an ssh tunnel from the athenasrv3 to the device.
+
+    Args:
+      set_key: if set True, ssh-key will be reset before ssh
+    Returns:
+      return True when succeed, return False otherwise
+    """
+    # clear the temp file
+    self.tmp_file.close()
+    self.tmp_file = tempfile.TemporaryFile(mode='w+t')
+    self.p_ssh.logfile = self.tmp_file
+    #Const
+    ssh_newkey = 'Are you sure you want to continue connecting'
+
+    if set_key:
+      self.SetDeviceSSHKey()
+
     if self.params['addr_ipv6']:
       addr = self.params['addr_ipv6']
     else:
@@ -189,8 +191,8 @@
 
   def ExitToAthena(self):
     """Terminate the ssh tunnel to device, and exit to athenasrv3."""
-    self.p_ssh.sendline('exit')
-    self.p_ssh.expect(self.params['athena_prompt'])
+    #self.p_ssh.sendline('exit')
+    #self.p_ssh.expect(self.params['athena_prompt'])
     self.p_ssh.sendline('exit')
     self.p_ssh.expect(self.params['athena_prompt'])
 
@@ -203,12 +205,13 @@
     Returns:
       return True upon success
     """
+    self.params['ssh_use_athena'] = True
     p_ssh = pexpect.spawn('ssh -a ' + self.params['jump_server'])
     print 'ssh -a jmp.googlefiber.net ...'
     #p_ssh.expect('lmeng@jmp101.nuq1:.*[\\$]')
     i = p_ssh.expect(
         [self.params['jump_prompt'], pexpect.TIMEOUT, pexpect.EOF],
-        self.__short_delay)
+        self.__short_delay*3)
     if i == 1 or i == 2:
       info = self.log.CreateErrorInfo(
             'critical', 'Cannot establish SSH tunnel to jump server.'
@@ -254,7 +257,7 @@
             + str(delay) + ' seconds')
         self.log.SendLine(None, info)
         time.sleep(delay)
-        tunnel = self.p_ssh.Ssh()
+        tunnel = self.Ssh()
         retry += 1
 
       if retry >= max_retry:
@@ -269,14 +272,15 @@
         '---', 'ssh session to Device successfully established!')
     self.log.SendLine(None, info)
 
-  def SshRetryFromAthena(self, max_retry=5, retry_delay=15):
+  def SshRetryFromAthena(self, max_retry=5, retry_delay=15, set_key=False):
     """Establish ssh connection to Device from athenasrv3, retry upon failure.
 
     Args:
       max_retry: the total number of retry
       retry_delay: delay between each ssh try
+      set_key: if ssh-key needs to be set
     """
-    tunnel = self.SshFromAthena()
+    tunnel = self.SshFromAthena(set_key)
     if not tunnel:
       retry = 0
       while not tunnel and retry < max_retry:
@@ -301,11 +305,19 @@
         '---', 'ssh session to Device successfully established!')
     self.log.SendLine(None, info)
 
-  def SendCmd(self, cmd):
-    """Send a command to the Device over ssh tunnel."""
+  def SendCmd(self, cmd, delay=10):
+    """Send a command to the Device over ssh tunnel.
+
+    Args:
+      cmd: the shell command to execute
+      delay: time delay while waiting for shell prompt after command is
+             executed
+    Returns:
+      return True if send command succeeded
+    """
     self.p_ssh.sendline(cmd)
     i = self.p_ssh.expect(
-        [self.params['bruno_prompt'], pexpect.EOF, pexpect.TIMEOUT], 10)
+        [self.params['bruno_prompt'], pexpect.EOF, pexpect.TIMEOUT], delay)
 
     while 1:
       if i == 0:
@@ -315,13 +327,16 @@
         # prompt not returned
         info = self.log.CreateErrorInfo(
             'Warning', 'Device not responding to shell command or timeout.'
-            ' Connect after 3 seconds ...')
+            ' Connect after 10 seconds ...')
         self.log.SendLine(None, info)
-        time.sleep(3)
-        self.SshRetryFromAthena()
+        time.sleep(10)
+        if self.params['ssh_use_athena']:
+          self.SshRetryFromAthena()
+        else:
+          self.SshRetry()
         self.p_ssh.sendline(cmd)
         i = self.p_ssh.expect(
-            [self.params['bruno_prompt'], pexpect.EOF, pexpect.TIMEOUT], 5)
+            [self.params['bruno_prompt'], pexpect.EOF, pexpect.TIMEOUT], delay)
 
   def GetCmdOutput(self, buff_size=0):
     """Get lines from the command output of the device, in a bottom up manner.
@@ -367,18 +382,18 @@
   def Close(self):
     # exit the ssh tunnel
     self.p_ssh.sendline('exit')
-    i = self.expect([self.p_ssh.params['athena_prompt'],
-                     self.p_ssh.params['jump_prompt'],
-                     self.p_ssh.params['bruno_prompt'],
-                     pexpect.EOF, pexpect.TIMEOUT])
+    i = self.p_ssh.expect([self.params['athena_prompt'],
+                           self.params['jump_prompt'],
+                           self.params['bruno_prompt'],
+                           pexpect.EOF, pexpect.TIMEOUT])
     while 1:
       if i == 0:
         # now at athena server:
         self.p_ssh.sendline('exit')
-        i = self.expect([self.p_ssh.params['athena_prompt'],
-                         self.p_ssh.params['jump_prompt'],
-                         self.p_ssh.params['bruno_prompt'],
-                         pexpect.EOF, pexpect.TIMEOUT])
+        i = self.p_ssh.expect([self.params['athena_prompt'],
+                               self.params['jump_prompt'],
+                               self.params['bruno_prompt'],
+                               pexpect.EOF, pexpect.TIMEOUT])
       elif i == 1:
         # now at jump server:
         self.p_ssh.sendline('exit')
@@ -386,21 +401,20 @@
       elif i == 2:
         # now at bruno:
         self.p_ssh.sendline('exit')
-        i = self.expect([self.p_ssh.params['athena_prompt'],
-                         self.p_ssh.params['jump_prompt'],
-                         self.p_ssh.params['bruno_prompt'],
+        i = self.expect([self.params['athena_prompt'],
+                         self.params['jump_prompt'],
+                         self.params['bruno_prompt'],
                          pexpect.EOF, pexpect.TIMEOUT])
       elif i == 3 or i == 4:
         # time out:
-        print 'Timeout when closing the ssh tunnel!'
+        print 'Exit from Device.'
         break
       else:
-        print 'Error'
         break
 
   def __del__(self):
-    self.tempFile.Close()
-    self.p_ssh.Close()
+    self.tmp_file.close()
+    #self.Close()
 
 # End of SSH class
 
diff --git a/sshto b/sshto
new file mode 100755
index 0000000..8c4f7e2
--- /dev/null
+++ b/sshto
@@ -0,0 +1,44 @@
+#!/bin/sh
+#
+# ssh (or, if no network, portsh) into the given device.
+#
+mydir=$(dirname "$0")
+cd "$mydir"
+
+name=$1
+shift
+
+log()
+{
+  echo "$@" >&2
+}
+
+
+die()
+{
+  log "$@"
+  exit 99
+}
+
+
+if [ -z "$name" ]; then
+  die "Usage: $0 <configname> [command...]"
+fi
+
+cmd=$(args="$*" ./run --quiet --raw "$name" -- '
+  if [ -n "$ip6" ] && ping6 -n -c1 -w2 $ip6 >/dev/null 2>&1; then
+    echo "ssh root@$ip6"
+  elif [ -n "$ip" ] && ping -n -c1 -w2 $ip >/dev/null 2>&1; then
+    echo "ssh root@$ip"
+  elif [ -n "$serialport" ]; then
+    if [ -n "$args" ]; then
+      echo "./portsh/portsh -pgoogle $serialport"
+    else
+      echo "./portsh/port $serialport"
+    fi
+  else
+    exit 1
+  fi
+') || die "Fatal: host '$name' has no live IP or serial port"
+log ">>> $cmd --" "$@"
+exec $cmd -- "$@"
diff --git a/testCase.py b/testCase.py
old mode 100644
new mode 100755
index 81e289d..bd2932e
--- a/testCase.py
+++ b/testCase.py
@@ -11,9 +11,13 @@
 __author__ = 'Lehan Meng (lmeng@google.com)'
 
 import datetime
+import json
 import logging
+import os
 import re
 
+import device
+
 
 class TestCase(object):
   """Base class for all test cases.
@@ -28,12 +32,13 @@
   placed in here.
   """
 
-  def __init__(self, **kwargs):
+  def __init__(self, ssh=None, **kwargs):
     """Initiate a test class instance.
 
     Args:
+      ssh: ssh tunnel to device
       kwargs['testID']: The assigned test ID on TCM
-      kwargs['title']: Title (section number) of the test case
+      kwargs['title']: Title (keyword) of the test case
       kwargs['start_time']: Start time of the test case (for statistic purpose)
       kwargs['key_word']: the label of the test case
       kwargs['description']: description if required
@@ -48,15 +53,165 @@
                       'configFile': 'config.cfg'}
     self.params = {}
 
-    for s in ('testID', 'title', 'start_time', 'key_word',
-              'description', 'configFile'):
-      if s in kwargs:
-        self.test_info[s] = kwargs[s]
+    for s in kwargs:
+      self.test_info[s] = kwargs[s]
 
-    self.log = logging.Logging()
-    self.ParseConfig()
+    self.device = device.Device()
+
+    self.log = logging.Logging(testID=self.test_info['testID'])
+    self.ParseJSONConfigFile()
+    #self.ParseConfig()
+    if ssh:
+      self.p_ssh = ssh
+    else:
+      self.p_ssh = None
     self.Run()
 
+  @staticmethod
+  def FindTestCaseID(file_name):
+    """Parse the configuration file for test case.
+
+    Find test ids in the configuration file.
+    Args:
+      file_name: the configure file to parse
+    Returns:
+      return the test case ids that needs to run the test
+    """
+    test_id_list = []
+    cfg_file = open(file_name, 'r')
+    cfg_list = cfg_file.readlines()
+    for line in cfg_list:
+      s = line.strip().strip('\n')
+      m = re.match(r'testID\s*:\s*(\d*)\s*$', s)
+      if (m is not None) and not s.startswith('#'):
+        test_id_list.append(m.group(1))
+    cfg_file.close()
+    return test_id_list
+
+  @staticmethod
+  def FindTestCaseToExecute(file_name):
+    """Parse the configuration file for test case.
+
+    Find test ids in the configuration file.
+    Args:
+      file_name: the configure file to parse
+    Returns:
+      return the test case ids that needs to run the test
+    """
+    test_id_list = []
+    try:
+      cfg_file = open(file_name, 'r')
+    except IOError:
+      print 'Cannot open the input file, return'
+      return os.sys.exit(1)
+    data = json.load(cfg_file)
+    cfg_file.close()
+
+    for test_case in data.iterkeys():
+      for key in data[test_case].iterkeys():
+        if isinstance(data[test_case][key], list) and key == 'testID':
+          for i in range(0, len(data[test_case][key])):
+            test_id_list.append(data[test_case][key][i])
+    return test_id_list
+
+  def ConfigForThisTestCase(self, data):
+    """Match if the configuration data is for current test case.
+
+    Args:
+      data: configuration data
+    Returns:
+      True: if the data is for current test case
+      False: if otherwise
+    """
+    for key in data.iterkeys():
+      if key == 'testID':
+        if self.test_info['testID'] in data[key]:
+          return True
+        else:
+          return False
+    return False
+
+  def ParseJSONConfigFile(self):
+    """Parse the JSON format configuration file.
+
+    The sturcture of a JSON file is as follows:
+    File format: parameter_names: string_values (or lists of values)
+                 comment is defined in the comment tag (JSON does not support
+                 comment).
+     'Test_Case_Description' : {
+     'comment': ['comments'],
+     'testID': ['11843140', '111111', '222222'],
+     'user' : 'root',
+     'addr' : '192.168.1.4',
+     'addr_ipv6' : 'None',
+     'pwd' : 'google',
+     'bruno_prompt' : 'gfibertv#',
+     'title' : 'Download',
+     'expected_version_id': '716006',
+     'expected_version': 'bruno-koala-5',
+     'downgrade_version': 'bruno-koala-4',
+     'downgrade_version_id': '728001',
+     'acs_url' : 'https://gfiber-acs-staging.appspot.com/cwmp',
+     'jump_server' : 'jmp.googlefiber.net',
+     'athena_user' : 'your_uname',
+     'athena_pwd' : 'your_pwd'
+    }
+
+    Returns:
+      return True if configure file parsed successfully
+    """
+    try:
+      self.cfg_file = open(self.test_info['configFile'], 'r')
+    except IOError:
+      print 'Cannot open the input file, return'
+      return os.sys.exit(1)
+    data = json.load(self.cfg_file)
+    self.cfg_file.close()
+
+    test_id_matched = False
+    for test_case in data.iterkeys():
+      if not self.ConfigForThisTestCase(data[test_case]):
+        continue
+      for key in data[test_case].iterkeys():
+        if isinstance(data[test_case][key], (str, unicode)):
+          value = data[test_case][key]
+          if not value or value == 'None':
+            self.params[key] = None
+          else:
+            self.params[key] = value
+        elif isinstance(data[test_case][key], dict):
+          if (key == 'title' and
+              self.test_info['testID'] in data[test_case][key]):
+            self.params[key] = data[test_case][key][self.test_info['testID']]
+            self.test_info['key_word'] = self.params[key]
+          else:
+            self.params[key] = data[test_case][key]
+        elif isinstance(data[test_case][key], list):
+          if key == 'testID':
+            for i in range(0, len(data[test_case][key])):
+              test_id = data[test_case][key][i]
+              if str(self.test_info['testID']) == test_id:
+                test_id_matched = True
+          elif key == 'comment':
+            # do not process comment lines
+            continue
+          else:
+            self.params[key] = data[test_case][key]
+        else:
+          info = self.log.CreateErrorInfo(
+              'Low', 'Warning: Configuration Parameter type unknown '
+              'in file ' + self.test_info['configFile'] + ': '
+              + test_case + ':' + key)
+          self.log.SendLine(self.test_info, info)
+
+    if not test_id_matched:
+      info = self.log.CreateErrorInfo(
+          'Low', 'Warning: No configuration found for this test '
+          'case in file: ' + self.test_info['configFile'])
+      self.log.SendLine(self.test_info, info)
+      os.sys.exit(1)
+    return True
+
   def ParseConfig(self):
     """Parse the configuration file for test case.
 
@@ -82,13 +237,16 @@
       reuturn 1 if succeed
     """
     # dictionary for params
-    self.cfg_file = open(self.test_info['configFile'], 'r')
+    try:
+      self.cfg_file = open(self.test_info['configFile'], 'r')
+    except IOError:
+      print 'Cannot open the input file, return'
+      return os.sys.exit(1)
 
     cfg_list = self.cfg_file.readlines()
     test_id_matched = False
-
     for line in cfg_list:
-      s = line.lstrip().strip().strip('\n')
+      s = line.strip().strip('\n')
       m = re.match('testID: ' + str(self.test_info['testID']), s)
       if (m is not None) and not s.startswith('#'):
         # test case matching succeed
@@ -105,7 +263,7 @@
           self.log.sendLine(self.test_info, info)
 
         s = cfg_list[index]
-        s = s.lstrip().rstrip()
+        s = s.strip()
         s = s.split('#', 2)[0]
 
         m = re.match('testID: ', s)
@@ -114,8 +272,8 @@
           # read and create current test case configuration data as dictionary
           # format: parameter = value
           if s is not '' and not s.startswith('#'):
-            name = s.split('=')[0].strip().lstrip()
-            value = s.split('=')[1].strip().lstrip()
+            name = s.split('=')[0].strip()
+            value = s.split('=')[1].strip()
             if not value or value == 'None':
               self.params[name] = None
             else:
@@ -124,17 +282,18 @@
           index += 1
           if index == len(cfg_list): break
           s = cfg_list[index]
-          s = s.lstrip().rstrip()
+          s = s.strip()
           m = re.match('testID: ', s)
 
     # all configuration parsed
     self.cfg_file.close()
     if not test_id_matched:
       # end of file  reached
-      info = self.log.createErrorInfo(
+      info = self.log.CreateErrorInfo(
           'Low', 'Warning: No configuration found for this test case in file: '
           + self.test_info['configFile'])
-      self.log.sendLine(self.test_info, info)
+      self.log.SendLine(self.test_info, info)
+      os.sys.exit(1)
     return True
 
   def AddConfigParams(self, par='par', value='value'):
@@ -144,7 +303,8 @@
       par: parameter name
       value: parameter value
     """
-    self.params.setdefault(par.strip().lstrip(), value.strip().lstrip())
+    if par and value:
+      self.params[par.strip()] = value.strip()
 
   def __del__(self):
     pass
@@ -159,4 +319,4 @@
     ##### Add your code here -- END   #######
 
   def Destructor(self):
-    pass
\ No newline at end of file
+    pass