cisco_node_utils 1.2.0 → 1.3.0

data/tests/test_interface.rb

@@ -15,25 +15,14 @@
 require_relative 'ciscotest'
 require_relative '../lib/cisco_node_utils/acl'
 require_relative '../lib/cisco_node_utils/interface'
+require_relative '../lib/cisco_node_utils/interface_channel_group'
+require_relative '../lib/cisco_node_utils/cisco_cmn_utils'
 require_relative '../lib/cisco_node_utils/overlay_global'
 
 include Cisco
 
 # TestInterface - Minitest for general functionality of the Interface class.
 class TestInterface < CiscoTestCase
-  # rubocop:disable Style/AlignHash
-  SWITCHPORT_SHUTDOWN_HASH = {
-    'shutdown_ethernet_switchport_shutdown'     =>
-      ['system default switchport', 'system default switchport shutdown'],
-    'shutdown_ethernet_switchport_noshutdown'   =>
-      ['system default switchport', 'no system default switchport shutdown'],
-    'shutdown_ethernet_noswitchport_shutdown'   =>
-      ['no system default switchport', 'system default switchport shutdown'],
-    'shutdown_ethernet_noswitchport_noshutdown' =>
-      ['no system default switchport', 'no system default switchport shutdown'],
-  }
-  # rubocop:enable Style/AlignHash
-
   DEFAULT_IF_ACCESS_VLAN = 1
   DEFAULT_IF_DESCRIPTION = ''
   DEFAULT_IF_IP_ADDRESS = nil
@@ -43,32 +32,103 @@ class TestInterface < CiscoTestCase
   DEFAULT_IF_VRF = ''
   IF_VRF_MAX_LENGTH = 32
 
+  def setup
+    super
+    interface_ethernet_default(interfaces[0])
+    if platform == :nexus
+      @port_channel = 'port-channel'
+      # rubocop:disable Style/AlignHash
+      @switchport_shutdown_hash = {
+        'shutdown_ethernet_switchport_shutdown'     =>
+          ['system default switchport',
+           'system default switchport shutdown'],
+        'shutdown_ethernet_switchport_noshutdown'   =>
+          ['system default switchport',
+           'no system default switchport shutdown'],
+        'shutdown_ethernet_noswitchport_shutdown'   =>
+          ['no system default switchport',
+           'system default switchport shutdown'],
+        'shutdown_ethernet_noswitchport_noshutdown' =>
+          ['no system default switchport',
+           'no system default switchport shutdown'],
+      }
+      # rubocop:enable Style/AlignHash
+    elsif platform == :ios_xr
+      @port_channel = 'Bundle-Ether'
+      @switchport_shutdown_hash = {
+        # Not really applicable to XR
+        'shutdown_ethernet_noswitchport_shutdown' => []
+      }
+    end
+  end
+
+  def teardown
+    interface_ethernet_default(interfaces[0])
+    super
+  end
+
+  def ipv4
+    if platform == :nexus
+      'ip'
+    elsif platform == :ios_xr
+      'ipv4'
+    end
+  end
+
+  def ipv4_address_pattern(address, length, secondary=false)
+    if platform == :nexus
+      if secondary
+        %r{^\s+ip address #{address}/#{length} secondary$}
+      else
+        %r{^\s+ip address #{address}/#{length}$}
+      end
+    elsif platform == :ios_xr
+      mask = Utils.length_to_bitmask(length)
+      if secondary
+        /^\s+ipv4 address #{address} #{mask} secondary$/
+      else
+        /^\s+ipv4 address #{address} #{mask}$/
+      end
+    end
+  end
+
   def interface_ipv4_config(ifname, address, length,
                             do_config=true, secip=false)
     if do_config
+      config_no_warn("interface #{ifname}",
+                     'no switchport') if platform == :nexus
       if !secip
         config("interface #{ifname}",
-               'no switchport',
-               "ip address #{address}/#{length}")
+               "#{ipv4} address #{address}/#{length}")
       else
         config("interface #{ifname}",
-               'no switchport',
-               "ip address #{address}/#{length} secondary")
+               "#{ipv4} address #{address}/#{length} secondary")
       end
     else
       config("interface #{ifname}",
-             'no ip address', # This will remove both primary and secondary
-             'switchport')
+             "no #{ipv4} address", # This will remove both primary and secondary
+            )
+      config("interface #{ifname}",
+             'switchport') if platform == :nexus
     end
   end
 
   def show_cmd(name)
-    all = (name =~ /port-channel\d/ && node.product_id =~ /N7/) ? '' : 'all'
-    "show run interface #{name} #{all} | no-more"
+    if platform == :nexus
+      all = (name =~ /port-channel\d/ && node.product_id =~ /N7/) ? '' : 'all'
+      "show run interface #{name} #{all} | no-more"
+    else
+      "show run interface #{name}"
+    end
   end
 
   def interface_count
-    output = @device.cmd('show run interface all | inc interface | no-more')
+    if platform == :nexus
+      cmd = 'show run interface all | inc interface | no-more'
+    elsif platform == :ios_xr
+      cmd = 'show run interface | inc interface'
+    end
+    output = @device.cmd(cmd)
     # Next line needs to be done because sh run interface all also shows
     # ospf interface related config
     arr = output.split("\n").select { |str| str.start_with?('interface') }
@@ -77,15 +137,34 @@ class TestInterface < CiscoTestCase
     arr.count
   end
 
-  # Helper to check for misc speed change disallowed error messages.
-  def speed_change_disallowed(message)
-    patterns = ['port doesn t support this speed',
-                'Changing interface speed is not permitted',
-                'requested config change not allowed',
-                /does not match the (transceiver speed|port capability)/]
-    skip('Skip test: Interface type does not allow config change') if
-         message[Regexp.union(patterns)]
-    flunk(message)
+  def test_capabilities
+    if validate_property_excluded?('interface', 'capabilities')
+      assert_empty(Interface.capabilities(interfaces[0]))
+    else
+      refute_empty(Interface.capabilities(interfaces[0], :hash),
+                   'A valid interface should return a non-empty hash')
+      assert_empty(Interface.capabilities('foo', :hash),
+                   'An Invalid interface should return an empty hash')
+
+      refute_empty(Interface.capabilities(interfaces[0], :raw),
+                   'A valid interface should return a non-empty array')
+      assert_empty(Interface.capabilities('foo', :raw),
+                   'An Invalid interface should return an empty array')
+    end
+  end
+
+  # Helper to get valid speeds for port
+  def capable_speed_values(interface)
+    speed_capa = Interface.capabilities(interface.name)['Speed']
+    return [] if speed_capa.nil?
+    speed_capa.split(',')
+  end
+
+  # Helper to get valid duplex values for port
+  def capable_duplex_values(interface)
+    duplex_capa = Interface.capabilities(interface.name)['Duplex']
+    return [] if duplex_capa.nil?
+    duplex_capa.split(',')
   end
 
   def create_interface(ifname=interfaces[0])
@@ -93,8 +172,47 @@ class TestInterface < CiscoTestCase
     Interface.new(ifname)
   end
 
-  def interface_ethernet_default(ethernet_id)
-    config("default interface ethernet #{ethernet_id}")
+  def interface_ethernet_default(ethernet_intf)
+    config("default interface #{ethernet_intf}")
+  end
+
+  def interface_supports_property?(intf, message)
+    patterns = ['requested config change not allowed',
+                '% Invalid command']
+    skip("Interface '#{intf}' does not support property") if
+      message[Regexp.union(patterns)]
+    flunk(message)
+  end
+
+  # Helper to find first valid speed that isn't "auto"
+  def valid_speed_set(interface)
+    valid_speed = nil
+    speeds = capable_speed_values(interface)
+    speeds.each do |value|
+      next if value == 'auto'
+      begin
+        interface.speed = value
+        assert_equal(value, interface.speed)
+      rescue Cisco::CliError => e
+        next if speed_change_disallowed?(e.message)
+        raise
+      end
+      # Exit loop once proper speed is found
+      valid_speed = value
+      break
+    end
+    valid_speed
+  end
+
+  # Helper to check for misc speed change disallowed error messages.
+  def speed_change_disallowed?(message)
+    patterns = ['port doesn t support this speed',
+                'Changing interface speed is not permitted',
+                'requested config change not allowed',
+                /does not match the (transceiver speed|port capability)/,
+                'but the transceiver doesn t support this speed',
+                '% Ambiguous parameter']
+    message[Regexp.union(patterns)]
   end
 
   def validate_interfaces_not_empty
@@ -109,6 +227,7 @@ class TestInterface < CiscoTestCase
 
   def system_default_switchport_shutdown
     state = []
+    return state if platform == :ios_xr
     s = @device.cmd("sh run all | in \"system default switchport\"")
 
     s.split("\n")[1..-2].each do |line|
@@ -124,7 +243,7 @@ class TestInterface < CiscoTestCase
     inttype_h.each do |k, v|
       interface = v[:interface]
 
-      SWITCHPORT_SHUTDOWN_HASH.each do |lookup_string, config_array|
+      @switchport_shutdown_hash.each do |lookup_string, config_array|
         # puts "lookup_string: #{lookup_string}"
 
         # Configure the system default shwitchport and shutdown settings
@@ -178,7 +297,7 @@ class TestInterface < CiscoTestCase
                    "Error: #{interface.name}, switchport mode, default, " \
                    'not correct')
     end
-  rescue RuntimeError => e
+  rescue Cisco::CliError => e
     skip('NX-OS defect: system default switchport nvgens twice') if
       e.message[/Expected zero.one value/]
     flunk(e.message)
@@ -228,7 +347,7 @@ class TestInterface < CiscoTestCase
       address = v[:address_len].split('/').first
       length = v[:address_len].split('/').last.to_i
 
-      pattern = %r{^\s+ip address #{address}/#{length}}
+      pattern = ipv4_address_pattern(address, length)
       assert_show_match(command: show_cmd(interface.name),
                         pattern: pattern)
       assert_equal(address, interface.ipv4_address,
@@ -248,7 +367,6 @@ class TestInterface < CiscoTestCase
       # Unconfigure ipaddress
       interface.ipv4_addr_mask_set(interface.default_ipv4_address,
                                    interface.default_ipv4_netmask_length)
-      pattern = %r{^\s+ip address #{address}/#{length}}
       refute_show_match(command: show_cmd(interface.name),
                         pattern: pattern,
                         msg:     "ipv4 address still present in CLI for #{k}")
@@ -270,7 +388,11 @@ class TestInterface < CiscoTestCase
       cmd = show_cmd(interface.name)
 
       # puts "value - #{v[:proxy_arp]}"
-      pattern = (/^\s+ip proxy-arp/)
+      if platform == :nexus
+        pattern = /^\s+ip proxy-arp/
+      elsif platform == :ios_xr
+        pattern = /^\s+proxy-arp/
+      end
       if v[:proxy_arp]
         assert_show_match(command: cmd, pattern: pattern)
       else
@@ -322,15 +444,15 @@ class TestInterface < CiscoTestCase
       assert_equal(ref.default_value, interface.default_ipv4_redirects,
                    "ipv4 redirects default incorrect for interface #{k}")
 
-      if ref.config_set?
+      if ref.setter?
         cmd = show_cmd(interface.name)
         interface.ipv4_redirects = true
         assert(interface.ipv4_redirects, "Couldn't set redirects to true")
-        refute_show_match(command: cmd, pattern: ref.test_config_get_regex[1])
+        refute_show_match(command: cmd, pattern: /^\s+no #{ipv4} redirects/)
 
         interface.ipv4_redirects = false
         refute(interface.ipv4_redirects, "Couldn't set redirects to false")
-        refute_show_match(command: cmd, pattern: ref.test_config_get_regex[0])
+        refute_show_match(command: cmd, pattern: /^#{ipv4} redirects/)
       else
         # Getter should return same value as default if setter isn't supported
         assert_equal(interface.ipv4_redirects, interface.default_ipv4_redirects,
@@ -405,38 +527,18 @@ class TestInterface < CiscoTestCase
     description = 'This is a test description ! '
     interface.description = description
     assert_equal(description.rstrip, interface.description)
-    interface_ethernet_default(interfaces_id[0])
   end
 
-  def test_interface_encapsulation_dot1q_change
+  def test_encapsulation_dot1q
     interface = Interface.new(interfaces[0])
-    interface.switchport_mode = :disabled
+    interface.switchport_mode = :disabled if platform == :nexus
     subif = Interface.new(interfaces[0] + '.1')
-
+    assert_raises(Cisco::CliError) { subif.encapsulation_dot1q = 'hello' }
     subif.encapsulation_dot1q = 20
     assert_equal(20, subif.encapsulation_dot1q)
     subif.encapsulation_dot1q = 25
     assert_equal(25, subif.encapsulation_dot1q)
-    interface_ethernet_default(interfaces_id[0])
-  end
-
-  def test_interface_encapsulation_dot1q_invalid
-    interface = Interface.new(interfaces[0])
-    interface.switchport_mode = :disabled
-    subif = Interface.new(interfaces[0] + '.1')
-
-    assert_raises(RuntimeError) { subif.encapsulation_dot1q = 'hello' }
-    interface_ethernet_default(interfaces_id[0])
-  end
-
-  def test_interface_encapsulation_dot1q_valid
-    interface = Interface.new(interfaces[0])
-    interface.switchport_mode = :disabled
-    subif = Interface.new(interfaces[0] + '.1')
-
-    subif.encapsulation_dot1q = 20
-    assert_equal(20, subif.encapsulation_dot1q)
-    interface_ethernet_default(interfaces_id[0])
+    subif.destroy
   end
 
   def test_interface_mtu_change
@@ -446,13 +548,14 @@ class TestInterface < CiscoTestCase
     assert_equal(1520, interface.mtu)
     interface.mtu = 1580
     assert_equal(1580, interface.mtu)
-    interface_ethernet_default(interfaces_id[0])
+    interface.mtu = interface.default_mtu
+    assert_equal(interface.default_mtu, interface.mtu)
   end
 
   def test_interface_mtu_invalid
     interface = Interface.new(interfaces[0])
     interface.switchport_mode = :disabled
-    assert_raises(RuntimeError) { interface.mtu = 'hello' }
+    assert_raises(Cisco::CliError) { interface.mtu = 'hello' }
   end
 
   def test_interface_mtu_valid
@@ -460,65 +563,83 @@ class TestInterface < CiscoTestCase
     interface.switchport_mode = :disabled
     interface.mtu = 1550
     assert_equal(1550, interface.mtu)
-    interface_ethernet_default(interfaces_id[0])
+    interface.mtu = interface.default_mtu
+    assert_equal(interface.default_mtu, interface.mtu)
   end
 
-  def test_interface_speed_change
-    interface = Interface.new(interfaces[0])
-    begin
-      interface.speed = 100
-      assert_equal('100', interface.speed)
-      interface.speed = 1000
-      assert_equal('1000', interface.speed)
-      interface_ethernet_default(interfaces_id[0])
-    rescue RuntimeError => e
-      speed_change_disallowed(e.message)
-    end
+  def test_mtu_invalid_loopback
+    # Loopback interfaces don't permit MTU configuration
+    interface = Interface.new('loopback100')
+    assert_nil(interface.mtu)
+    assert_nil(interface.default_mtu)
+    assert_raises(Cisco::UnsupportedError) { interface.mtu = 1550 }
+    interface.destroy
   end
 
-  def test_interface_speed_invalid
+  def test_speed
     interface = Interface.new(interfaces[0])
-    assert_raises(RuntimeError) { interface.speed = 'hello' }
-  end
+    if validate_property_excluded?('interface', 'speed')
+      assert_nil(interface.speed)
+      assert_nil(interface.default_speed)
+      assert_raises(Cisco::UnsupportedError) { interface.speed = 1000 }
+      return
+    end
 
-  def test_interface_speed_valid
-    interface = Interface.new(interfaces[0])
-    interface.speed = 1000
-    assert_equal('1000', interface.speed)
-    interface_ethernet_default(interfaces_id[0])
-  rescue RuntimeError => e
-    speed_change_disallowed(e.message)
-  end
+    # Test invalid speed
+    assert_raises(RuntimeError, Cisco::CliError) { interface.speed = 'hello' }
+
+    # Test up to two non-default values
+    speed_values = capable_speed_values(interface)
+    warn("No valid speeds found on #{interface.name}") if speed_values.empty?
+    successful_runs = 0
+    speed_values.each do |value|
+      break if successful_runs >= 2
+      begin
+        interface.speed = value
+        assert_equal(value, interface.speed)
+        successful_runs += 1
+      rescue Cisco::CliError => e
+        # Many of the 'capable' speeds are actually not valid values
+        # Try next available speed value if CLI rejects current value
+        next if speed_change_disallowed?(e.message)
+        raise
+      end
+    end
 
-  def test_interface_duplex_change
-    interface = Interface.new(interfaces[0])
-    interface.speed = 1000
-    interface.duplex = 'full'
-    assert_equal('full', interface.duplex)
-    interface.duplex = 'auto'
-    assert_equal('auto', interface.duplex)
-    interface_ethernet_default(interfaces_id[0])
-  rescue RuntimeError => e
-    speed_change_disallowed(e.message)
+    # Test default speed value
+    interface.speed = interface.default_speed
+    assert_equal(interface.speed, interface.default_speed)
   end
 
-  def test_interface_duplex_invalid
+  def test_duplex
     interface = Interface.new(interfaces[0])
-    interface.speed = 1000
-    assert_raises(RuntimeError) { interface.duplex = 'hello' }
-    interface_ethernet_default(interfaces_id[0])
-  rescue RuntimeError => e
-    speed_change_disallowed(e.message)
-  end
+    if validate_property_excluded?('interface', 'duplex')
+      assert_nil(interface.duplex)
+      assert_nil(interface.default_duplex)
+      assert_raises(Cisco::UnsupportedError) { interface.duplex = 'full' }
+      return
+    end
 
-  def test_interface_duplex_valid
-    interface = Interface.new(interfaces[0])
-    interface.speed = 1000
-    interface.duplex = 'full'
-    assert_equal('full', interface.duplex)
-    interface_ethernet_default(interfaces_id[0])
-  rescue RuntimeError => e
-    speed_change_disallowed(e.message)
+    # Test invalid duplex
+    assert_raises(RuntimeError, Cisco::CliError) { interface.duplex = 'hello' }
+
+    # Ensure speed is non-auto value
+    if interface.default_speed == 'auto'
+      valid_speed = valid_speed_set(interface)
+      skip('Cannot configure non-auto speed') if valid_speed.nil?
+    end
+
+    # Test non-default values
+    duplex_values = capable_duplex_values(interface)
+    warn("No valid duplex found on #{interface.name}") if duplex_values.empty?
+    duplex_values.each do |value|
+      interface.duplex = value
+      assert_equal(value, interface.duplex)
+    end
+
+    # Test default duplex value
+    interface.duplex = interface.default_duplex
+    assert_equal(interface.duplex, interface.default_duplex)
   end
 
   def test_interface_shutdown_valid
@@ -528,30 +649,14 @@ class TestInterface < CiscoTestCase
 
     interface.shutdown = false
     refute(interface.shutdown, 'Error: shutdown state is not false')
-    interface_ethernet_default(interfaces_id[0])
-  end
-
-  def test_interface_get_access_vlan
-    interface = Interface.new(interfaces[0])
-    interface.switchport_mode = :disabled
-    interface.switchport_mode = :access
-    assert_equal(DEFAULT_IF_ACCESS_VLAN, interface.access_vlan)
-    interface_ethernet_default(interfaces_id[0])
-  end
-
-  def test_interface_get_access_vlan_switchport_disabled
-    interface = Interface.new(interfaces[0])
-    interface.switchport_mode = :disabled
-    assert_equal(DEFAULT_IF_ACCESS_VLAN, interface.access_vlan)
-    interface_ethernet_default(interfaces_id[0])
   end
 
-  def test_interface_get_access_vlan_switchport_trunk
-    interface = Interface.new(interfaces[0])
-    interface.switchport_mode = :disabled
-    interface.switchport_mode = :trunk
-    assert_equal(DEFAULT_IF_ACCESS_VLAN, interface.access_vlan)
-    interface_ethernet_default(interfaces_id[0])
+  def test_svi_prop_nil_when_ethernet
+    intf = Interface.new(interfaces[0])
+    assert_nil(intf.svi_autostate,
+               'Error: svi_autostate should be nil when interface is ethernet')
+    assert_nil(intf.svi_management,
+               'Error: svi_management should be nil when interface is ethernet')
   end
 
   #   def test_interface_get_prefix_list_when_switchport
@@ -559,13 +664,12 @@ class TestInterface < CiscoTestCase
   #     interface.switchport_mode = :access
   #     addresses = interface.prefixes
   #     assert_empty(addresses)
-  #     interface_ethernet_default(interfaces_id[0])
   #   end
   #
   #   def test_interface_get_prefix_list_with_ipv4_address_assignment
   #     interface = Interface.new(interfaces[0])
   #     interface.switchport_mode = :access
-  #     interface.switchport_mode = :disabled
+  #     interface.switchport_mode = :disabled if platform == :nexus
   #     config("interface #{interfaces[0]}",
   #            'ip address 192.168.1.100 255.255.255.0')
   #     prefixes = interface.prefixes
@@ -573,13 +677,12 @@ class TestInterface < CiscoTestCase
   #     assert(prefixes.has_key?("192.168.1.100"))
   #     interface.switchport_mode = :access
   #     prefixes = nil
-  #     interface_ethernet_default(interfaces_id[0])
   #   end
   #
   #   def test_interface_get_prefix_list_with_ipv6_address_assignment
   #     interface = Interface.new(interfaces[0] )
   #     interface.switchport_mode = :access
-  #     interface.switchport_mode = :disabled
+  #     interface.switchport_mode = :disabled if platform == :nexus
   #     config("interface #{interfaces[0]}",
   #            'ipv6 address fd56:31f7:e4ad:5585::1/64")
   #     prefixes = interface.prefixes
@@ -587,13 +690,12 @@ class TestInterface < CiscoTestCase
   #     assert(prefixes.has_key?("fd56:31f7:e4ad:5585::1"))
   #     interface.switchport_mode = :access
   #     prefixes = nil
-  #     interface_ethernet_default(interfaces_id[0])
   #   end
   #
   #   def test_interface_prefix_list_with_both_ip4_and_ipv6_address_assignments
   #     interface = Interface.new(interfaces[0])
   #     interface.switchport_mode = :access
-  #     interface.switchport_mode = :disabled
+  #     interface.switchport_mode = :disabled if platform == :nexus
   #     config("interface #{interfaces[0]}",
   #            'ip address 192.168.1.100 255.255.255.0',
   #            'ipv6 address fd56:31f7:e4ad:5585::1/64')
@@ -603,127 +705,131 @@ class TestInterface < CiscoTestCase
   #     assert(prefixes.has_key?("fd56:31f7:e4ad:5585::1"))
   #     interface.switchport_mode = :access
   #     prefixes = nil
-  #     interface_ethernet_default(interfaces_id[0])
   #   end
 
-  def negotiate_auto_helper(interface, default, cmd_ref)
+  def negotiate_auto_helper(interface, default, speed)
+    if validate_property_excluded?('interface',
+                                   interface.negotiate_auto_lookup_string)
+      assert_raises(Cisco::UnsupportedError) { interface.negotiate_auto = true }
+      return
+    end
+    # Check current default state before any other changes
     inf_name = interface.name
-
-    # Test default
     assert_equal(default, interface.default_negotiate_auto,
                  "Error: #{inf_name} negotiate auto default value mismatch")
 
-    interface.negotiate_auto = default
-    # Delay as this change is sometimes too quick for some interfaces
-    sleep 1 unless default == interface.negotiate_auto
-    node.cache_flush
-    assert_equal(default, interface.negotiate_auto,
-                 "Error: #{inf_name} negotiate auto value " \
-                 'should be same as default')
-
-    unless cmd_ref.config_set?
-      # check the set for unsupported platforms
-      assert_raises(RuntimeError) do
-        interface.negotiate_auto = true
-      end
-      return
+    # Test non-defaults: Note that 'speed' and 'negotiate' are tightly coupled
+    # on some platforms. Some platforms need the speed command to be toggled
+    # before negotiate will work without raising an error; while others just
+    # need a non-'auto' speed value or may not support 'auto' at all; therefore
+    # just set a static speed value before setting any negotiate settings.
+    if default == true
+      negotiate_false(interface, speed)
+      negotiate_true(interface, speed)
+    else
+      negotiate_true(interface, speed)
+      negotiate_false(interface, speed)
     end
+  end
 
-    interface.negotiate_auto = default
-    assert_equal(default, interface.negotiate_auto,
-                 "Error: #{inf_name} negotiate auto value not #{default}")
-
-    pattern = cmd_ref.test_config_get_regex[default ? 1 : 0]
-    assert_show_match(pattern: pattern)
-
-    non_default = !default
+  def negotiate_true(interface, speed)
+    # puts " true: 'speed #{speed}', 'negotiate auto'"
+    intf = interface.name
+    interface.speed = speed
+    interface.negotiate_auto = true
+    assert(interface.negotiate_auto,
+           "#{intf} negotiate auto value should be true")
+    assert_show_match(pattern: /^\s+negotiate auto/)
+  rescue Cisco::CliError => e
+    # 10G+ interfaces do not support negotiation
+    interface_supports_property?(intf, e.message)
+  end
+
+  # Yes, this method is nearly identical to negotiate_true.
+  # The negotiate property is evil to troubleshoot. Keep them separate.
+  def negotiate_false(interface, speed)
+    # puts "false: 'speed #{speed}', 'no negotiate auto'"
+    intf = interface.name
+    interface.speed = speed
+    interface.negotiate_auto = false
+    refute(interface.negotiate_auto,
+           "#{intf} negotiate auto value should be false")
+    assert_show_match(pattern: /^\s+no negotiate auto/)
+  rescue Cisco::CliError => e
+    # 10G+ interfaces do not support negotiation
+    interface_supports_property?(intf, e.message)
+  end
 
-    # Some 'supported' platforms let us set the negotiate value to its
-    # default but not actually change it.
+  def test_negotiate_auto_portchannel
+    # Create interface member of this group (required for XR)
+    member = InterfaceChannelGroup.new(interfaces[0])
     begin
-      interface.negotiate_auto = non_default
-    rescue RuntimeError
-      assert_equal(default, interface.negotiate_auto,
-                   "Error: #{inf_name} negotiate auto value not #{default}")
-      return
+      member.channel_group = 10
+    rescue Cisco::UnsupportedError
+      # Some XR platform/version combinations don't support port-channel intfs
+      skip('bundle id config not supported on this node') if platform == :ios_xr
+      raise
     end
 
-    # Delay as this change is sometimes too quick for some interfaces
-    sleep 1 unless non_default == interface.negotiate_auto
-    node.cache_flush
-
-    assert_equal(non_default, interface.negotiate_auto,
-                 "Error: #{inf_name} negotiate auto value not #{non_default}")
-
-    pattern = cmd_ref.test_config_get_regex[non_default ? 1 : 0]
-    assert_show_match(pattern: pattern)
-
-    # Clean up after ourselves
-    interface.negotiate_auto = default
-    assert_equal(default, interface.negotiate_auto,
-                 "Error: #{inf_name} negotiate auto value not #{default}")
+    # Clean up any stale config first
+    inf_name = "#{@port_channel}10"
+    Interface.new(inf_name).destroy
 
-    pattern = cmd_ref.test_config_get_regex[default ? 1 : 0]
-    assert_show_match(pattern: pattern)
-  end
-
-  def test_negotiate_auto_portchannel
-    ref = cmd_ref.lookup('interface',
-                         'negotiate_auto_portchannel')
-    assert(ref, 'Error, reference not found')
-
-    inf_name = 'port-channel10'
-    config('interface port-channel 10')
     interface = Interface.new(inf_name)
-    default = ref.default_value
-    @default_show_command = show_cmd(inf_name)
+    if validate_property_excluded?('interface', 'negotiate_auto_portchannel')
+      assert_nil(interface.negotiate_auto)
+      assert_nil(interface.default_negotiate_auto)
+      assert_raises(Cisco::UnsupportedError) do
+        interface.negotiate_auto = false
+      end
+    else
+      default = interface.default_negotiate_auto
+      @default_show_command = show_cmd(inf_name)
 
-    # Test with switchport
-    negotiate_auto_helper(interface, default, ref)
+      # Port-channels will raise an error on some platforms unless they
+      # have a static speed value set first.
+      speed = '100'
 
-    # Test with no switchport
-    config('interface port-channel 10', 'no switchport')
-    negotiate_auto_helper(interface, default, ref)
+      # Test with switchport
+      interface.switchport_mode = :access
+      negotiate_auto_helper(interface, default, speed)
+
+      # Test with no switchport
+      interface.switchport_mode = :disabled
+      negotiate_auto_helper(interface, default, speed)
+    end
 
     # Cleanup
-    config('no interface port-channel 10')
+    interface.destroy
   end
 
   def test_negotiate_auto_ethernet
-    ref = cmd_ref.lookup('interface',
-                         'negotiate_auto_ethernet')
-    assert(ref, 'Error, reference not found')
-
-    # Cleanup
-    interface_ethernet_default(interfaces_id[0])
-
-    # Some platforms does not support negotiate auto
-    # if so then we abort the test.
-
     inf_name = interfaces[0]
     interface = Interface.new(inf_name)
 
-    # Some platforms/interfaces/versions do not support negotiation changes
-    begin
-      interface.negotiate_auto = false
-    rescue CliError => e
-      skip('Skip test: Interface type does not allow config change') if
-        e.message[/requested config change not allowed/]
-      flunk(e.message)
+    if validate_property_excluded?('interface', 'negotiate_auto_ethernet')
+      assert_nil(interface.negotiate_auto)
+      assert_nil(interface.default_negotiate_auto)
+      assert_raises(Cisco::UnsupportedError) do
+        interface.negotiate_auto = false
+      end
+      return
     end
 
-    default = ref.default_value
+    # Find a static speed. Some platforms will raise an error unless
+    # speed is configured before setting negotiate auto.
+    speed = valid_speed_set(interface)
+
+    default = interface.default_negotiate_auto
     @default_show_command = show_cmd(inf_name)
 
     # Test with switchport
-    negotiate_auto_helper(interface, default, ref)
+    interface.switchport_mode = :access
+    negotiate_auto_helper(interface, default, speed)
 
     # Test with no switchport
-    config("interface #{interfaces[0]}", 'no switchport')
-    negotiate_auto_helper(interface, default, ref)
-
-    # Cleanup
-    interface_ethernet_default(interfaces_id[0])
+    interface.switchport_mode = :disabled
+    negotiate_auto_helper(interface, default, speed)
   end
 
   def test_negotiate_auto_loopback
@@ -731,12 +837,12 @@ class TestInterface < CiscoTestCase
                          'negotiate_auto_other_interfaces')
     assert(ref, 'Error, reference not found')
 
-    inf_name = 'loopback2'
-    config('interface loopback 2')
-    interface = Interface.new(inf_name)
+    int = 'loopback2'
+    config("interface #{int}")
+    interface = Interface.new(int)
 
     assert_equal(interface.negotiate_auto, ref.default_value,
-                 "Error: #{inf_name} negotiate auto value mismatch")
+                 "Error: #{int} negotiate auto value mismatch")
 
     assert_raises(Cisco::UnsupportedError) do
       interface.negotiate_auto = true
@@ -746,7 +852,7 @@ class TestInterface < CiscoTestCase
     end
 
     # Cleanup
-    config('no interface loopback 2')
+    config("no interface #{int}")
   end
 
   def test_interfaces_not_empty
@@ -755,20 +861,18 @@ class TestInterface < CiscoTestCase
 
   def test_interface_ipv4_addr_mask_set_address_invalid
     interface = create_interface
-    interface.switchport_mode = :disabled
-    assert_raises(RuntimeError) do
+    interface.switchport_mode = :disabled if platform == :nexus
+    assert_raises(Cisco::CliError) do
       interface.ipv4_addr_mask_set('', 14)
     end
-    interface_ethernet_default(interfaces_id[0])
   end
 
   def test_interface_ipv4_addr_mask_set_netmask_invalid
     interface = create_interface
-    interface.switchport_mode = :disabled
-    assert_raises(RuntimeError) do
+    interface.switchport_mode = :disabled if platform == :nexus
+    assert_raises(Cisco::CliError) do
       interface.ipv4_addr_mask_set('8.1.1.2', DEFAULT_IF_IP_NETMASK_LEN)
     end
-    interface_ethernet_default(interfaces_id[0])
   end
 
   def test_ipv4_acl
@@ -781,9 +885,13 @@ class TestInterface < CiscoTestCase
 
     # create acls first
     %w(v4acl1 v4acl2 v4acl3 v4acl4).each do |acl_name|
-      Acl.new('ipv4', acl_name)
+      if platform == :nexus
+        Acl.new('ipv4', acl_name)
+      else
+        # TODO: Acl is not yet supported on XR
+        config("ipv4 access-list #{acl_name} 1 permit any")
+      end
     end
-    interface_ethernet_default(interfaces[0])
     intf = Interface.new(interfaces[0])
 
     intf.ipv4_acl_in = 'v4acl1'
@@ -803,7 +911,7 @@ class TestInterface < CiscoTestCase
 
     # delete acls
     %w(v4acl1 v4acl2 v4acl3 v4acl4).each do |acl_name|
-      config('no ip access-list ' + acl_name)
+      config("no #{ipv4} access-list #{acl_name}")
     end
   end
 
@@ -814,12 +922,16 @@ class TestInterface < CiscoTestCase
     #     ipv6 traffic-filter v6acl1 in
     #     ipv6 traffic-filter v6acl2 out
     #
-    interface_ethernet_default(interfaces[0])
     intf = Interface.new(interfaces[0])
 
     # create acls first
     %w(v6acl1 v6acl2 v6acl3 v6acl4).each do |acl_name|
-      Acl.new('ipv6', acl_name)
+      if platform == :nexus
+        Acl.new('ipv6', acl_name)
+      else
+        # TODO: Acl is not yet supported on XR
+        config("ipv6 access-list #{acl_name} 1 permit any any")
+      end
     end
 
     intf.ipv6_acl_in = 'v6acl1'
@@ -845,7 +957,7 @@ class TestInterface < CiscoTestCase
 
   def test_interface_ipv4_address
     interface = create_interface
-    interface.switchport_mode = :disabled
+    interface.switchport_mode = :disabled if platform == :nexus
     address = '8.7.1.1'
     sec_addr = '10.5.5.1'
     secondary = true
@@ -853,7 +965,7 @@ class TestInterface < CiscoTestCase
 
     # Primary: setter, getter
     interface.ipv4_addr_mask_set(address, length)
-    pattern = %r{^\s+ip address #{address}/#{length}}
+    pattern = ipv4_address_pattern(address, length)
     assert_show_match(pattern: pattern,
                       msg:     'Error: ipv4 address missing in CLI')
     assert_equal(address, interface.ipv4_address,
@@ -863,12 +975,12 @@ class TestInterface < CiscoTestCase
 
     # Secondary: setter, getter
     interface.ipv4_addr_mask_set(sec_addr, length, secondary)
-    pattern = %r{^\s+ip address #{sec_addr}/#{length} secondary}
+    pattern = ipv4_address_pattern(sec_addr, length, secondary)
     assert_show_match(pattern: pattern,
                       msg:     'Error: ipv4 address missing in CLI')
     assert_equal(sec_addr, interface.ipv4_address_secondary,
                  'Error: ipv4 address get value mismatch')
-    assert_equal(length, interface.ipv4_netmask_length,
+    assert_equal(length, interface.ipv4_netmask_length_secondary,
                  'Error: ipv4 netmask length get value mismatch')
 
     # get default
@@ -888,7 +1000,7 @@ class TestInterface < CiscoTestCase
     interface.ipv4_addr_mask_set(interface.default_ipv4_address, length,
                                  secondary)
     interface.ipv4_addr_mask_set(interface.default_ipv4_address, length)
-    pattern = (/^\s+ip address (.*)/)
+    pattern = (/^\s+ip(v4)? address (.*)/)
     refute_show_match(pattern: pattern,
                       msg:     'Error: ipv4 address still present in CLI')
     assert_equal(DEFAULT_IF_IP_ADDRESS, interface.ipv4_address,
@@ -896,8 +1008,6 @@ class TestInterface < CiscoTestCase
     assert_equal(DEFAULT_IF_IP_NETMASK_LEN,
                  interface.ipv4_netmask_length,
                  'Error: ipv4 netmask length default get value mismatch')
-
-    interface_ethernet_default(interfaces_id[0])
   end
 
   def test_interface_ipv4_address_getter_with_preconfig
@@ -915,7 +1025,6 @@ class TestInterface < CiscoTestCase
                  'Error: ipv4 netmask length get value mismatch')
     # unconfigure ipaddress
     interface_ipv4_config(ifname, address, length, false)
-    interface_ethernet_default(interfaces_id[0])
   end
 
   def test_interface_ipv4_address_getter_with_preconfig_secondary
@@ -937,31 +1046,81 @@ class TestInterface < CiscoTestCase
                  'Error: ipv4 netmask length get value mismatch')
     # unconfigure ipaddress includign secondary
     interface_ipv4_config(ifname, address, length, false, false)
-    interface_ethernet_default(interfaces_id[0])
   end
 
   def test_interface_ipv4_arp_timeout
-    # Setup
-    config('no interface vlan11')
-    int = Interface.new('vlan11')
-
-    # Test default
-    assert_equal(int.default_ipv4_arp_timeout, int.ipv4_arp_timeout)
-    # Test non-default
-    int.ipv4_arp_timeout = 300
-    assert_equal(300, int.ipv4_arp_timeout)
-    # Set back to default
-    int.ipv4_arp_timeout = int.default_ipv4_arp_timeout
-    assert_equal(int.default_ipv4_arp_timeout, int.ipv4_arp_timeout)
-
+    unless platform == :ios_xr
+      # Setup
+      config_no_warn('no interface vlan11')
+      int = Interface.new('vlan11')
+
+      # Test default
+      assert_equal(int.default_ipv4_arp_timeout, int.ipv4_arp_timeout)
+      # Test non-default
+      int.ipv4_arp_timeout = 300
+      assert_equal(300, int.ipv4_arp_timeout)
+      # Set back to default
+      int.ipv4_arp_timeout = int.default_ipv4_arp_timeout
+      assert_equal(int.default_ipv4_arp_timeout, int.ipv4_arp_timeout)
+    end
     # Attempt to configure on a non-vlan interface
     nonvlanint = create_interface
     assert_raises(RuntimeError) { nonvlanint.ipv4_arp_timeout = 300 }
   end
 
+  def test_interface_ipv4_forwarding
+    intf = interfaces[0]
+    i = Interface.new(intf)
+
+    if platform == :ios_xr
+      assert_nil(i.default_ipv4_forwarding)
+      assert_nil(i.ipv4_forwarding)
+      assert_raises(Cisco::UnsupportedError) { i.ipv4_forwarding = false }
+      return
+    end
+
+    assert_equal(i.default_ipv4_forwarding, i.ipv4_forwarding)
+    begin
+      i.switchport_mode = :disabled
+      i.ipv4_forwarding = true
+    rescue RuntimeError, CliError => e
+      # RuntimeError when switchport_mode fails (some lc's, e.g. N7K-F248XP-25E)
+      # CliError when ipv4_forwarding fails
+      interface_supports_property?(intf, e.message)
+    end
+    assert(i.ipv4_forwarding)
+
+    i.ipv4_forwarding = false
+    refute(i.ipv4_forwarding)
+
+    i.ipv4_forwarding = true
+    assert(i.ipv4_forwarding)
+    i.ipv4_forwarding = i.default_ipv4_forwarding
+    assert_equal(i.default_ipv4_forwarding, i.ipv4_forwarding)
+  end
+
   def test_interface_fabric_forwarding_anycast_gateway
+    # Ensure N7k has compatible interface
+    mt_full_interface? if node.product_id[/N7/]
+
+    if validate_property_excluded?('overlay_global', 'anycast_gateway_mac')
+      assert_raises(Cisco::UnsupportedError) do
+        OverlayGlobal.new.anycast_gateway_mac = '1223.3445.5668'
+      end
+      return
+    end
+    if validate_property_excluded?('interface',
+                                   'fabric_forwarding_anycast_gateway')
+      int = Interface.new('vlan11')
+      OverlayGlobal.new.anycast_gateway_mac = '1223.3445.5668'
+      assert_raises(Cisco::UnsupportedError) do
+        int.fabric_forwarding_anycast_gateway = true
+      end
+      return
+    end
+
     # Setup
-    config('no interface vlan11')
+    config_no_warn('no interface vlan11')
     int = Interface.new('vlan11')
     foo = OverlayGlobal.new
     foo.anycast_gateway_mac = '1223.3445.5668'
@@ -986,17 +1145,26 @@ class TestInterface < CiscoTestCase
 
     # 5. Attempt to set 'fabric forwarding anycast gateway' while the
     #    overlay gateway mac is not set.
-    foo.anycast_gateway_mac = foo.default_anycast_gateway_mac
-    assert_raises(RuntimeError) { int.fabric_forwarding_anycast_gateway = true }
+    int.destroy
+    int = Interface.new('vlan11')
+    bar = OverlayGlobal.new
+    bar.anycast_gateway_mac = bar.default_anycast_gateway_mac
+    assert_raises(RuntimeError) do
+      int.fabric_forwarding_anycast_gateway = true
+    end
   end
 
   def test_interface_ipv4_proxy_arp
     interface = create_interface
-    interface.switchport_mode = :disabled
+    interface.switchport_mode = :disabled if platform == :nexus
 
     # set with value true
     interface.ipv4_proxy_arp = true
-    pattern = (/^\s+ip proxy-arp/)
+    if platform == :nexus
+      pattern = /^\s+ip proxy-arp/
+    elsif platform == :ios_xr
+      pattern = /^\s+proxy-arp/
+    end
     assert_show_match(pattern: pattern,
                       msg:     'Error: ip proxy-arp enable missing in CLI')
     assert(interface.ipv4_proxy_arp,
@@ -1021,59 +1189,68 @@ class TestInterface < CiscoTestCase
     assert_equal(DEFAULT_IF_IP_PROXY_ARP,
                  interface.ipv4_proxy_arp,
                  'Error: ip proxy-arp default get value mismatch')
-
-    interface_ethernet_default(interfaces_id[0])
   end
 
   def test_interface_ipv4_redirects
     interface = create_interface
-    interface.switchport_mode = :disabled
+    interface.switchport_mode = :disabled if platform == :nexus
+
+    ref = cmd_ref.lookup('interface', 'ipv4_redirects_other_interfaces')
+    assert(ref, 'Error, reference not found')
+
+    # check default value
+    assert_equal(interface.default_ipv4_redirects, interface.ipv4_redirects,
+                 'Error: ip redirects default get value mismatch')
 
     # set with value false
     interface.ipv4_redirects = false
-    pattern = (/^\s+no ip redirects/)
-    assert_show_match(pattern: pattern,
-                      msg:     'Error: ip redirects disable missing in CLI')
+    if interface.default_ipv4_redirects == true
+      assert_show_match(pattern: /^\s+no #{ipv4} redirects/,
+                        msg:     'Error: ip redirects disable missing in CLI')
+    end
+    refute_show_match(pattern: /^\s+#{ipv4} redirects/)
     refute(interface.ipv4_redirects,
            "Error: ip redirects get value 'false' mismatch")
 
     # set with value true
     interface.ipv4_redirects = true
-    refute_show_match(pattern: pattern,
+    if interface.default_ipv4_redirects == false
+      assert_show_match(pattern: /^\s+#{ipv4} redirects/)
+    end
+    refute_show_match(pattern: /^\s+no #{ipv4} redirects/,
                       msg:     'Error: ip redirects enable missing in CLI')
     assert(interface.ipv4_redirects,
            "Error: ip redirects get value 'true' mismatch")
 
-    # get default
-    assert_equal(DEFAULT_IF_IP_REDIRECTS,
-                 interface.default_ipv4_redirects,
-                 'Error: ip redirects get default value mismatch')
-
     # get default and set
     interface.ipv4_redirects = interface.default_ipv4_redirects
-    refute_show_match(pattern: pattern,
+    if interface.default_ipv4_redirects
+      pat = /^\s+no #{ipv4} redirects/
+    else
+      pat = /^\s+#{ipv4} redirects/
+    end
+    refute_show_match(pattern: pat,
                       msg:     'Error: default ip redirects set failed')
-    assert_equal(DEFAULT_IF_IP_REDIRECTS, interface.ipv4_redirects,
+    assert_equal(interface.default_ipv4_redirects, interface.ipv4_redirects,
                  'Error: ip redirects default get value mismatch')
-
-    interface_ethernet_default(interfaces_id[0])
   end
 
   def config_from_hash(inttype_h)
     inttype_h.each do |k, v|
-      # puts "TEST: pre-config hash key : #{k}"
       config('feature interface-vlan') if (/^Vlan\d./).match(k.to_s)
 
-      # puts "TEST: pre-config k: v '#{k} : #{v}'"
       cfg = ["interface #{k}"]
-      if !(/^Ethernet\d.\d/).match(k.to_s).nil? ||
-         !(/^port-channel\d/).match(k.to_s).nil?
-        cfg << 'no switchport'
+
+      switchport_intfs = Regexp.union(/ethernet/i, @port_channel)
+      cfg << 'no switchport' if platform == :nexus && k =~ switchport_intfs
+
+      cfg << "#{ipv4} address #{v[:address_len]}" unless v[:address_len].nil?
+      if platform == :nexus
+        cfg << 'ip proxy-arp' if v[:proxy_arp]
+      elsif platform == :ios_xr
+        cfg << 'proxy-arp' if v[:proxy_arp]
       end
-      # puts "k: #{k}, k1: #{k1}, address #{v1[:address_len]}"
-      cfg << "ip address #{v[:address_len]}" unless v[:address_len].nil?
-      cfg << 'ip proxy-arp' if v[:proxy_arp]
-      cfg << 'ip redirects' if v[:redirects]
+      cfg << '#{ipv4} redirects' if v[:redirects]
       cfg << "description #{v[:description]}" unless v[:description].nil?
       config(*cfg)
 
@@ -1083,9 +1260,7 @@ class TestInterface < CiscoTestCase
     inttype_h
   end
 
-  # NOTE - Changes to this method may require new validation methods
-  #        to be created or existing ones to be modified.
-  def test_interface_ipv4_all_interfaces
+  def interface_test_data
     inttype_h = {}
     inttype_h[interfaces[0]] = {
       address_len:         '8.7.1.1/15',
@@ -1097,31 +1272,33 @@ class TestInterface < CiscoTestCase
       shutdown:            false,
       change_shutdown:     true,
       default_shutdown:    false,
-      switchport:          :disabled,
-      default_switchport:  :disabled,
-      access_vlan:         DEFAULT_IF_ACCESS_VLAN,
-      default_access_vlan: DEFAULT_IF_ACCESS_VLAN,
-      vrf_new:             'test2',
-      default_vrf:         DEFAULT_IF_VRF,
-    }
-    inttype_h['Vlan45'] = {
-      address_len:         '9.7.1.1/15',
-      proxy_arp:           true,
-      redirects:           false,
-      description:         'Company A',
-      description_new:     'Mini Me',
-      default_description: DEFAULT_IF_DESCRIPTION,
-      shutdown:            true,
-      change_shutdown:     false,
-      default_shutdown:    true,
-      switchport:          :disabled,
-      default_switchport:  :disabled,
+      switchport:          platform == :ios_xr ? nil : :disabled,
+      default_switchport:  platform == :ios_xr ? nil : :disabled,
       access_vlan:         DEFAULT_IF_ACCESS_VLAN,
       default_access_vlan: DEFAULT_IF_ACCESS_VLAN,
       vrf_new:             'test2',
       default_vrf:         DEFAULT_IF_VRF,
     }
-    inttype_h['port-channel48'] = {
+    unless platform == :ios_xr
+      inttype_h['Vlan45'] = {
+        address_len:         '9.7.1.1/15',
+        proxy_arp:           true,
+        redirects:           false,
+        description:         'Company A',
+        description_new:     'Mini Me',
+        default_description: DEFAULT_IF_DESCRIPTION,
+        shutdown:            true,
+        change_shutdown:     false,
+        default_shutdown:    true,
+        switchport:          :disabled,
+        default_switchport:  :disabled,
+        access_vlan:         DEFAULT_IF_ACCESS_VLAN,
+        default_access_vlan: DEFAULT_IF_ACCESS_VLAN,
+        vrf_new:             'test2',
+        default_vrf:         DEFAULT_IF_VRF,
+      }
+    end
+    inttype_h["#{@port_channel}48"] = {
       address_len:         '10.7.1.1/15',
       proxy_arp:           false,
       redirects:           false,
@@ -1131,8 +1308,8 @@ class TestInterface < CiscoTestCase
       shutdown:            false,
       change_shutdown:     true,
       default_shutdown:    false,
-      switchport:          :disabled,
-      default_switchport:  :disabled,
+      switchport:          platform == :ios_xr ? nil : :disabled,
+      default_switchport:  platform == :ios_xr ? nil : :disabled,
       access_vlan:         DEFAULT_IF_ACCESS_VLAN,
       default_access_vlan: DEFAULT_IF_ACCESS_VLAN,
       vrf_new:             'test2',
@@ -1147,8 +1324,8 @@ class TestInterface < CiscoTestCase
       shutdown:            false,
       change_shutdown:     true,
       default_shutdown:    false,
-      switchport:          :disabled,
-      default_switchport:  :disabled,
+      switchport:          platform == :ios_xr ? nil : :disabled,
+      default_switchport:  platform == :ios_xr ? nil : :disabled,
       access_vlan:         DEFAULT_IF_ACCESS_VLAN,
       default_access_vlan: DEFAULT_IF_ACCESS_VLAN,
       vrf_new:             'test2',
@@ -1156,52 +1333,71 @@ class TestInterface < CiscoTestCase
     }
     # Skipping mgmt0 interface since that interface is our 'path' to
     # master should revisit this later
+    inttype_h
+  end
+
+  # NOTE - Changes to this method may require new validation methods
+  #        to be created or existing ones to be modified.
+  def test_interface_ipv4_all_interfaces
+    inttype_h = interface_test_data
 
     # Set system defaults to "factory" values prior to initial test.
     config(*
-      SWITCHPORT_SHUTDOWN_HASH['shutdown_ethernet_noswitchport_shutdown'])
+      @switchport_shutdown_hash['shutdown_ethernet_noswitchport_shutdown'])
 
     # pre-configure
+    begin
+      interface_ethernet_default(interfaces[1])
+      InterfaceChannelGroup.new(interfaces[1]).channel_group = 48
+    rescue Cisco::UnsupportedError
+      raise unless platform == :ios_xr
+      # Some XR platform/version combos don't support port-channels
+      inttype_h.delete("#{@port_channel}48")
+    end
+
     inttype_h = config_from_hash(inttype_h)
 
     # Steps to cleanup the preload configuration
     cfg = []
     inttype_h.each_key do |k|
-      cfg << "#{/^Ethernet/.match(k) ? 'default' : 'no'} interface #{k}"
+      if /ethernet/.match(k)
+        # leave interface there, but unconfigure it
+        cfg.push(*get_interface_cleanup_config(k))
+      else
+        # remove interface
+        cfg << "no interface #{k}"
+      end
     end
-    cfg << 'no feature interface-vlan'
+    cfg << 'no feature interface-vlan' unless platform == :ios_xr
 
     begin
       # Validate the collection
       validate_interfaces_not_empty
       validate_get_switchport(inttype_h)
       validate_description(inttype_h)
-      validate_get_access_vlan(inttype_h)
+      validate_get_access_vlan(inttype_h) unless platform == :ios_xr
       validate_ipv4_address(inttype_h)
       validate_ipv4_proxy_arp(inttype_h)
       validate_ipv4_redirects(inttype_h)
       validate_interface_shutdown(inttype_h)
       validate_vrf(inttype_h)
       config(*cfg)
+      interface_ethernet_default(interfaces[1])
     rescue Minitest::Assertion
       # clean up before failing
       config(*cfg)
+      interface_ethernet_default(interfaces[1])
       raise
     end
   end
 
   def test_interface_vrf_default
-    config('interface loopback1', 'vrf member foo')
     interface = Interface.new('loopback1')
+    assert_empty(interface.vrf)
+    interface.vrf = 'foo'
+    assert_equal(interface.vrf, 'foo')
     interface.vrf = interface.default_vrf
-    assert_equal(DEFAULT_IF_VRF, interface.vrf)
-  end
-
-  def test_interface_vrf_empty
-    config('interface loopback1', 'vrf member foo')
-    interface = Interface.new('loopback1')
-    interface.vrf = DEFAULT_IF_VRF
-    assert_equal(DEFAULT_IF_VRF, interface.vrf)
+    assert_equal(interface.vrf, interface.default_vrf)
   end
 
   def test_interface_vrf_invalid_type
@@ -1212,7 +1408,7 @@ class TestInterface < CiscoTestCase
   def test_interface_vrf_exceeds_max_length
     interface = Interface.new('loopback1')
     long_string = 'a' * (IF_VRF_MAX_LENGTH + 1)
-    assert_raises(RuntimeError) { interface.vrf = long_string }
+    assert_raises(Cisco::CliError) { interface.vrf = long_string }
   end
 
   def test_interface_vrf_override
@@ -1233,14 +1429,59 @@ class TestInterface < CiscoTestCase
     interface.destroy
   end
 
+  def test_vrf_change_with_ip_addr
+    interface = Interface.new('loopback1')
+    address = '192.168.100.1'
+    length = 24
+    interface_ipv4_config('loopback1', address, length)
+    assert_equal(address, interface.ipv4_address)
+    assert_equal(length, interface.ipv4_netmask_length)
+
+    vrf1 = 'test1'
+    interface.vrf = vrf1
+    assert_equal(address, interface.ipv4_address,
+                 'IPv4 address wrong after changing from vrf default => test1')
+    assert_equal(length, interface.ipv4_netmask_length,
+                 'IPv4 mask wrong after changing from vrf default => test1')
+    assert_equal(vrf1, interface.vrf)
+
+    vrf2 = 'test2'
+    interface.vrf = vrf2
+    assert_equal(address, interface.ipv4_address,
+                 'IPv4 address wrong after changing from vrf test1 => test2')
+    assert_equal(length, interface.ipv4_netmask_length,
+                 'IPv4 mask wrong after changing from vrf test1 => test2')
+    assert_equal(vrf2, interface.vrf)
+
+    interface.vrf = DEFAULT_IF_VRF
+    assert_equal(address, interface.ipv4_address,
+                 'IPv4 address wrong after changing from vrf test2 => default')
+    assert_equal(length, interface.ipv4_netmask_length,
+                 'IPv4 mask wrong after changing from vrf test2 => default')
+    assert_equal(DEFAULT_IF_VRF, interface.vrf)
+  end
+
   def test_ipv4_pim_sparse_mode
+    config('no feature pim') if platform == :nexus
+    i = Interface.new(interfaces[0])
+    if platform == :ios_xr
+      assert_nil(i.ipv4_pim_sparse_mode)
+      assert_nil(i.default_ipv4_pim_sparse_mode)
+      assert_raises(Cisco::UnsupportedError) { i.ipv4_pim_sparse_mode = true }
+      return
+    end
+    begin
+      i.switchport_mode = :disabled
+    rescue Cisco::CliError => e
+      skip_message = 'Interface does not support switchport disable'
+      skip(skip_message) if e.message['requested config change not allowed']
+      raise
+    end
     # Sample cli:
     #
     #   interface Ethernet1/1
     #     ip pim sparse-mode
     #
-    config('no feature pim')
-    i = Interface.new(interfaces[0])
     i.ipv4_pim_sparse_mode = false
     refute(i.ipv4_pim_sparse_mode)