cisco_node_utils 1.2.0 → 1.3.0

data/tests/test_ace.rb

@@ -18,143 +18,214 @@ require_relative '../lib/cisco_node_utils/ace'
 
 # TestAce - Minitest for Ace node utility class
 class TestAce < CiscoTestCase
+  @skip_unless_supported = 'acl'
+  @@pre_clean_needed = true # rubocop:disable Style/ClassVars
+
   def setup
-    # setup runs at the beginning of each test
     super
-    @acl_name_v4 = 'test-foo-v4-1'
-    @acl_name_v6 = 'test-foo-v6-1'
-    @seqno = 10
-    no_access_list_foo
+    remove_all_acls if @@pre_clean_needed
+    @@pre_clean_needed = false # rubocop:disable Style/ClassVars
   end
 
   def teardown
-    # teardown runs at the end of each test
-    no_access_list_foo
     super
+    remove_all_acls
   end
 
-  def no_access_list_foo
-    # Remove the test ACLs
-    %w(ipv4 ipv6).each do |afi|
-      acl_name = afi[/ipv6/] ? @acl_name_v6 : @acl_name_v4
-      config('no ' + Acl.afi_cli(afi) + ' access-list ' + acl_name)
+  def remove_all_acls
+    Acl.acls.each do |_afis, acls|
+      acls.values.each(&:destroy)
     end
   end
 
-  # TESTS
-  def test_create_destroy_ace_one
-    attr_v4_1 = {
+  # Helper to create an ACE and return the obj. The test_hash contains
+  # only the minimum properties which can be added to or overwritten as
+  # required for each test.
+  def ace_helper(afi, props=nil)
+    test_hash = {
       action:   'permit',
       proto:    'tcp',
-      src_addr: '7.8.9.6 2.3.4.5',
-      src_port: 'eq 40',
-      dst_addr: '1.2.3.4/32',
-      dst_port: 'neq 20',
+      src_addr: 'any',
+      dst_addr: 'any',
     }
+    test_hash.merge!(props) unless props.nil?
 
-    attr_v4_2 = {
-      action:   'deny',
-      proto:    'udp',
-      src_addr: '7.8.9.6/32',
-      src_port: 'eq 41',
-      dst_addr: 'host 1.2.3.4',
-      dst_port: 'neq 20',
-    }
+    a = Ace.new(afi, afi, 10)
+    begin
+      a.ace_set(test_hash)
+      a
+    end
+  rescue CliError => e
+    skip('This property is not supported on this platform') if
+      e.message[/(Invalid parameter detected|Invalid command)/]
+    flunk(e.message)
+  end
 
-    attr_v4_3 = {
-      remark: 'ipv4 remark'
-    }
+  # TESTS
+  def test_remark
+    %w(ipv4 ipv6).each do |afi|
+      a = ace_helper(afi, remark: afi)
+      assert_equal(afi, a.remark)
+    end
+  end
 
-    attr_v6_1 = {
-      action:   'permit',
-      proto:    '6',
-      src_addr: 'addrgroup fi',
-      src_port: '',
-      dst_addr: '1::7/32',
-      dst_port: '',
-    }
+  def test_action
+    %w(ipv4 ipv6).each do |afi|
+      %w(permit deny).each do |val|
+        a = ace_helper(afi, action: val)
+        assert_equal(val, a.action)
+      end
+    end
+  end
 
-    attr_v6_2 = {
-      action:   'permit',
-      proto:    'udp',
-      src_addr: '1::8/56',
-      src_port: 'eq 41',
-      dst_addr: 'any',
-      dst_port: '',
-    }
+  def test_proto
+    %w(ipv4 ipv6).each do |afi|
+      # Sampling of proto's
+      %w(ip tcp udp).each do |val|
+        val = 'ipv6' if val[/ip/] && afi[/ipv6/]
+        a = ace_helper(afi, proto: val)
+        assert_equal(val, a.proto)
+      end
+    end
+  end
 
-    attr_v6_3 = {
-      remark: 'ipv6 remark'
-    }
+  def test_addrs
+    val = '10.1.1.1/32'
+    a = ace_helper('ipv4', src_addr: val, dst_addr: val)
+    assert_equal(val, a.src_addr)
+    assert_equal(val, a.dst_addr)
+
+    val = '10.1.1.1 0.0.0.0'
+    exp = '10.1.1.1/32'
+    # This syntax will transform to 10.1.1.1/32
+    a = ace_helper('ipv4', src_addr: val, dst_addr: val)
+    assert_equal(exp, a.src_addr)
+    assert_equal(exp, a.dst_addr)
+
+    val = '10.1.1.1 2.3.4.5'
+    a = ace_helper('ipv4', src_addr: val, dst_addr: val)
+    assert_equal(val, a.src_addr)
+    assert_equal(val, a.dst_addr)
+
+    val = '10:1:1::1/128'
+    a = ace_helper('ipv6', src_addr: val, dst_addr: val)
+    assert_equal(val, a.src_addr)
+    assert_equal(val, a.dst_addr)
 
-    props = {
-      'ipv4' => [attr_v4_1, attr_v4_2, attr_v4_3],
-      'ipv6' => [attr_v6_1, attr_v6_2, attr_v6_3],
-    }
+    %w(ipv4 ipv6).each do |afi|
+      val = "addrgroup my_addrgroup_#{afi}"
+      a = ace_helper(afi, src_addr: val, dst_addr: val)
+      assert_equal(val, a.src_addr)
+      assert_equal(val, a.dst_addr)
+    end
+  end
 
+  def test_ports
     %w(ipv4 ipv6).each do |afi|
-      @seqno = 0
-      props[afi].each do |item|
-        create_destroy_ace(afi, item)
+      ['eq 2', 'neq 2', 'gt 2', 'lt 2',
+       'portgroup my_pg'].each do |val|
+        a = ace_helper(afi, src_port: val, dst_port: val)
+        assert_equal(val, a.src_port)
+        assert_equal(val, a.dst_port)
       end
     end
   end
 
-  def create_destroy_ace(afi, entry)
-    acl_name = @acl_name_v4 if afi[/(ip|ipv4)$/]
-    acl_name = @acl_name_v6 if afi[/ipv6/]
-    @seqno += 10
+  def test_dscp
+    %w(ipv4 ipv6).each do |afi|
+      %w(5 60 af11 af12 af13 af21 af22 af23 af31 af32 af33 af41 af42 af43
+         cs1 cs2 cs3 cs4 cs5 cs6 cs7 default ef).each do |val|
+        a = ace_helper(afi, dscp: val)
+        assert_equal(val, a.dscp)
+      end
+    end
+  end
+
+  def test_tcp_flags
+    %w(ipv4 ipv6).each do |afi|
+      %w(ack fin urg syn psh rst) + [
+        'ack fin', 'ack psh rst'].each do |val|
+        a = ace_helper(afi, tcp_flags: val)
+        assert_equal(val, a.tcp_flags)
+      end
+    end
+  end
 
-    Acl.new(afi, acl_name)
-    ace = Ace.new(afi, acl_name, @seqno)
-    ace.ace_set(entry)
+  def test_established
+    %w(ipv4 ipv6).each do |afi|
+      refute(ace_helper(afi).established)
+      a = ace_helper(afi, established: true)
+      assert(a.established)
+      a = ace_helper(afi, established: false)
+      refute(a.established)
+    end
+  end
 
-    afi_cli = Acl.afi_cli(afi)
-    all_aces = Ace.aces
-    found = false
-    all_aces[afi][acl_name].each do |seqno, _inst|
-      next unless seqno.to_i == @seqno.to_i
-      found = true
+  def test_http_method
+    afi = 'ipv4'
+    %w(connect delete get head post put trace).each do |val|
+      a = ace_helper(afi, http_method: val)
+      assert_equal(val, a.http_method)
     end
+  end
 
-    @default_show_command =
-      "show runn aclmgr | sec '#{afi_cli} access-list #{acl_name}'"
-    assert(found,
-           "#{afi_cli} acl #{acl_name} seqno #{@seqno} is not configured")
+  def test_log
+    %w(ipv4 ipv6).each do |afi|
+      refute(ace_helper(afi).log)
+      a = ace_helper(afi, log: true)
+      assert(a.log)
+      a = ace_helper(afi, log: false)
+      refute(a.log)
+    end
+  end
 
-    if entry.include?(:action)
-      action = "#{entry[:action]} .*"
-    else
-      action = "remark #{entry[:remark]}"
+  def test_precedence
+    afi = 'ipv4'
+    %w(critical flash flash-override immediate internet network
+       priority routine).each do |val|
+      a = ace_helper(afi, precedence: val)
+      assert_equal(val, a.precedence)
     end
-    assert_show_match(pattern: /\s+#{@seqno} #{action}$/,
-                      msg:     "failed to create ace seqno #{@seqno}")
-    ace.destroy
-    refute_show_match(pattern: /\s+#{@seqno} #{entry[:action]} .*$/,
-                      msg:     "failed to remove ace seqno #{@seqno}")
   end
 
-  def test_ace_update
-    action = 'permit'
-    proto = 'tcp'
-    src = '1.0.0.0/8'
-    dst = '3.0.0.0 0.0.0.8'
-    entry = { action: action, proto: proto, src_addr: src, dst_addr: dst }
+  def test_redirect
+    afi = 'ipv4'
+    val = 'port-channel1,port-channel2'
+    a = ace_helper(afi, redirect: val)
+    assert_equal(val, a.redirect)
+  end
 
-    a = Ace.new('ipv4', 'ace_update', 10)
-    a.ace_set(entry)
+  def test_tcp_option_length
+    afi = 'ipv4'
+    %w(0 16 28).each do |val|
+      a = ace_helper(afi, tcp_option_length: val)
+      assert_equal(val, a.tcp_option_length)
+    end
+  end
 
-    assert_equal(src, a.src_addr)
-    assert_equal(dst, a.dst_addr)
+  def test_time_range
+    val = 'my_range'
+    %w(ipv4 ipv6).each do |afi|
+      a = ace_helper(afi, time_range: val)
+      assert_equal(val, a.time_range)
+    end
+  end
 
-    src = '2.0.0.0/16'
-    entry = { action: action, proto: proto, src_addr: src, dst_addr: dst }
-    a.ace_set(entry)
-    assert_equal(src, a.src_addr)
+  def test_packet_length
+    val = 'range 80 1000'
+    %w(ipv4 ipv6).each do |afi|
+      a = ace_helper(afi, packet_length: val)
+      assert_equal(val, a.packet_length)
+    end
+  end
 
-    dst = '3.0.0.0 0.0.0.4'
-    entry = { action: action, proto: proto, src_addr: src, dst_addr: dst }
-    a.ace_set(entry)
-    assert_equal(dst, a.dst_addr)
+  def test_ttl
+    val = '3'
+    %w(ipv4 ipv6).each do |afi|
+      a = ace_helper(afi, ttl: val)
+      skip("This property has a known defect on the platform itself -\n"\
+           'CSCuy47463: access-list ttl does not nvgen') if a.ttl.nil?
+      assert_equal(val, a.ttl)
+    end
   end
 end

data/tests/test_acl.rb

@@ -17,6 +17,7 @@ require_relative '../lib/cisco_node_utils/acl'
 
 # test client for acl creation and deletion
 class TestAcl < CiscoTestCase
+  @skip_unless_supported = 'acl'
   def setup
     # setup runs at the beginning of each test
     super
@@ -84,7 +85,7 @@ class TestAcl < CiscoTestCase
     # set to false
     rtr.stats_per_entry = false
     refute_show_match(pattern: /statistics per-entry/,
-                      msg:     'failed to disnable stats')
+                      msg:     'failed to disable stats')
     refute(rtr.stats_per_entry)
 
     # default getter function
@@ -168,6 +169,14 @@ class TestAcl < CiscoTestCase
   end
 
   def test_fragments
+    if node.product_id[/N(5|6)/]
+      a = Acl.new('ipv4', 'acl_fragments')
+      assert_nil(a.fragments)
+      assert_nil(a.default_fragments)
+      assert_raises(Cisco::UnsupportedError) { a.fragments = 'permit-all' }
+      return
+    end
+
     %w(ipv4 ipv6).each do |afi|
       acl_name = afi[/ipv6/] ? @acl_name_v6 : @acl_name_v4
       fragments(afi, acl_name)

data/tests/test_bgp_af.rb

@@ -30,34 +30,234 @@ class TestBgpAF < CiscoTestCase
   def setup
     super
     remove_all_bgps if @@pre_clean_needed
+    remove_all_vrfs if @@pre_clean_needed
+    if platform == :ios_xr && @@pre_clean_needed
+      config_no_warn('no route-policy drop_all')
+    end
     @@pre_clean_needed = false # rubocop:disable Style/ClassVars
   end
 
   def teardown
-    super
     remove_all_bgps
+    remove_all_vrfs
+    config_no_warn('no route-policy drop_all') if platform == :ios_xr
+    super
   end
 
-  def get_bgp_af_cfg(asn, vrf, af)
-    afi, safi = af
-    string =
-      @device.cmd("show run bgp all | sec 'bgp #{asn}' |  sec 'vrf #{vrf}' | " \
-                  "sec 'address-family #{afi} #{safi}' | no-more")
-    string
-  end
-
-  # show bgp ipv4 unicast dampening parameters
-  # Route Flap Dampening Parameters for VRF default Address family IPv4 Unicast:
-  # Default values in use:
-  # Half-life time                 : 15 mins
-  # Suppress penalty               : 2000
-  # Reuse penalty                  : 750
-  # Max suppress time              : 45 mins
-  # Max suppress penalty           : 6000
-  def get_bgp_af_dampening_params(_asn, vrf, af)
-    afi = af.first
-    safi = af.last
-    @device.cmd("show bgp vrf #{vrf} #{afi} #{safi} dampening parameters")
+  # Disabling line length to support wide-format test matrix definition
+  # rubocop:disable Metrics/LineLength
+
+  # Address Families to test:
+  T_AFS = [
+    #   afi  safi
+    %w(ipv4 unicast),
+    %w(ipv6 unicast),
+    %w(ipv4 multicast),
+    %w(ipv6 multicast),
+    %w(l2vpn evpn),
+
+    # TODO: These are additional address families/modifiers reported by XR, should they be tested also?
+    #       Looks like most of them are not supported on Nexus...
+    #
+
+    #     %w(ipv4 mvpn),
+    #     %w(ipv6 mvpn),
+
+    # Not on Nexus:
+    #     %w(link-state link-state),
+    #
+    #     %w(l2vpn mspw),
+    #     %w(l2vpn vpls-vpws),
+    #
+    #     %w(ipv4 flowspec),
+    #     %w(ipv4 mdt),
+    #     %w(ipv4 rt-filter),
+    #     %w(ipv4 tunnel),
+    #
+    #     %w(ipv6 flowspec),
+    #
+    #     %w(vpnv4 unicast),
+    #     %w(vpnv4 multicast),
+    #     %w(vpnv4 flowspec),
+    #
+    #     %w(vpnv6 unicast),
+    #     %w(vpnv6 multicast),
+    #     %w(vpnv6 flowspec),
+  ]
+
+  # ASs to test:
+  # TODO: Do we ever need to test more than one AS?
+  T_ASNS = ['55']
+
+  # VRFs to test:
+  T_VRFS = %w(default red)
+
+  # Value-based properties
+  T_VALUES = [
+    [:default_information_originate,  [:toggle]],
+    [:client_to_client,               [:toggle]],
+    [:additional_paths_send,          [:toggle]],
+    [:additional_paths_receive,       [:toggle]],
+    [:additional_paths_install,       [:toggle]],
+    [:advertise_l2vpn_evpn,           [:toggle]],
+
+    [:next_hop_route_map,             ['drop_all']],
+    [:additional_paths_selection,     ['drop_all']],
+    [:maximum_paths,                  [7, 9]],
+    [:maximum_paths_ibgp,             [7, 9]],
+    [:dampen_igp_metric,              [555, nil]],
+    [:default_metric,                 [50, false]],
+    [:inject_map,                     [[%w(lax sfo), %w(lax sjc), %w(nyc sfo copy-attributes), %w(sjc nyc copy-attributes)], [%w(nyc sfo copy-attributes), %w(sjc nyc copy-attributes)]]],
+  ]
+
+  # Given the cartesian product of the above parameters, not all tests are supported.
+  # Here we record which tests are expected to fail, and what kind of failure is expected.
+  # This supports a very simple workflow for adding new tests:
+  #   - Add new entry into test tables above.
+  #   - Run tests.
+  #   - When test fails, add a new 'exception' entry.
+  #   - Repeat until all tests pass.
+  #   - Condense entries using :any where possible.
+  #
+  TEST_EXCEPTIONS = [
+    #  Test                           OS      VRF        AF                    Expected result
+
+    # Tests that are successful even though a rule below says otherwise
+    [:next_hop_route_map,            :nexus,  'default', %w(l2vpn evpn),       :success],
+
+    # XR CLI Errors
+    [:additional_paths_send,         :ios_xr, :any,      :multicast,           :CliError],
+    [:additional_paths_receive,      :ios_xr, :any,      :multicast,           :CliError],
+    [:additional_paths_selection,    :ios_xr, :any,      :multicast,           :CliError],
+    [:client_to_client,              :ios_xr, :VRF,      :any,                 :CliError],
+    [:maximum_paths,                 :ios_xr, :any,      %w(l2vpn evpn),       :CliError],
+    [:maximum_paths_ibgp,            :ios_xr, :any,      %w(l2vpn evpn),       :CliError],
+    [:next_hop_route_map,            :ios_xr, :VRF,      :any,                 :CliError],
+
+    # Nexus Unsupported
+
+    # Nexus CLI Errors
+    [:any,                           :nexus,  'default', %w(l2vpn evpn),       :CliError],
+    [:advertise_l2vpn_evpn,          :nexus,  'default', :any,                 :CliError],
+    [:advertise_l2vpn_evpn,          :nexus,  :VRF,      :multicast,           :CliError],
+    [:inject_map,                    :nexus,  :any,      :multicast,           :CliError],
+  ]
+
+  # rubocop:disable Style/SpaceAroundOperators
+  # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+  def check_test_exceptions(test_, os_, vrf_, af_)
+    ret = nil
+    amb = nil
+    TEST_EXCEPTIONS.each do |test, os, vrf, af, expect|
+      next unless (test_ == test || test == :any) &&
+                  (os_   == os   || os   == :any) &&
+                  (vrf_  == vrf  || vrf  == :any ||
+                    (vrf == :VRF && vrf_ != 'default')) &&
+                  (af_   == af   || af   == :any ||
+                    (af == :unicast   && (af_.include? 'unicast'))   ||
+                    (af == :multicast && (af_.include? 'multicast')) ||
+                    (af == :ipv4      && (af_.include? 'ipv4'))      ||
+                    (af == :ipv6      && (af_.include? 'ipv6')))
+      return expect if expect == :success || expect == :skip
+
+      # Otherwise, make sure there's no ambiguity/overlap in the exceptions.
+      if !ret.nil? && ret != expect
+        assert('TEST ERROR: Exceptions matrix has ambiguous entries! ' \
+               "#{amb} and [#{test}, #{os}, #{vrf}, #{af}]")
+      end
+      ret = expect
+      amb = [test, os, vrf, af, expect]
+    end
+    # Return the expected test result
+    ret.nil? ? :success : ret
+  end
+  # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+  # rubocop:enable Style/SpaceAroundOperators
+
+  def properties_matrix(asns, vrfs, afs, values)
+    asns.each do |asn|
+      config_ios_xr_dependencies(asn)
+
+      vrfs.each do |vrf|
+        afs.each do |af|
+          # l2vpn evpn restrictions
+          if af == %w(l2vpn evpn)
+            next if vrf != 'default' ||
+                    validate_property_excluded?('feature', 'nv_overlay_evpn')
+          end
+
+          bgp_af = RouterBgpAF.new(asn, vrf, af)
+
+          values.each do |test, test_values|
+            if validate_property_excluded?('bgp_af', test.to_s)
+              assert_raises(Cisco::UnsupportedError) { bgp_af.send("#{test}=", nil) }
+              next
+            end
+
+            # What result do we expect from this test?
+            expect = check_test_exceptions(test, platform, vrf, af)
+
+            # Gather initial value, default value, and the first test value..
+            initial = bgp_af.send(test)
+
+            # Properties which are unsupported or OFF by default return initial == nil
+            if initial.nil?
+              default = nil
+              first_value = nil
+            else
+              default = bgp_af.send("default_#{test}")
+              first_value = (test_values[0] == :toggle) ? !default : test_values[0]
+            end
+
+            if expect == :skip
+              # Do nothing..
+
+            elsif expect == :CliError
+
+              # This set of parameters should produce a CLI error
+              assert_raises(Cisco::CliError,
+                            "Assert 'cli error' failed for: "\
+                            "#{test}=(#{first_value}), #{asn}, #{vrf}, #{af}") do
+                bgp_af.send("#{test}=", first_value)
+              end
+
+            else
+
+              # Check initial value == default value
+              #   Skip this assertion for properties that use auto_default: false
+              assert_equal(default, initial,
+                           "Initial value failed for: #{test}, #{asn}, #{vrf}, #{af}"
+                          ) unless  initial.nil?
+
+              # Try all the test values in order
+              test_values.each do |test_value|
+                test_value = (test_value == :toggle) ? !default : test_value
+
+                # Try the test value
+                bgp_af.send("#{test}=", test_value)
+                assert_equal(test_value, bgp_af.send(test),
+                             "Test value failed for: #{test}, #{asn}, #{vrf}, #{af}")
+              end # test_values
+
+              # Set it back to the default
+              unless default.nil?
+                bgp_af.send("#{test}=", default)
+                assert_equal(default, bgp_af.send(test),
+                             "Default assignment failed for: #{test}, #{asn}, #{vrf}, #{af}")
+              end
+            end
+
+            # Cleanup
+            bgp_af.destroy
+          end # tests
+        end # afs
+      end # vrfs
+    end # asns
+  end
+  # rubocop:enable Metrics/LineLength
+
+  def test_properties_matrix
+    properties_matrix(T_ASNS, T_VRFS, T_AFS, T_VALUES)
   end
 
   ##
@@ -77,17 +277,27 @@ class TestBgpAF < CiscoTestCase
   ## Enable VXLAN and the EVPN
   ##
   def test_collection_not_empty
-    config('feature bgp',
-           'router bgp 55',
-           'address-family ipv4 unicast',
-           'vrf red',
-           'address-family ipv4 unicast',
-           'vrf blue',
-           'address-family ipv6 multicast',
-           'vrf orange',
-           'address-family ipv4 multicast',
-           'vrf black',
-           'address-family ipv6 unicast')
+    config('feature bgp') if platform == :nexus
+
+    bgp_afs = []
+    %w(default red blue orange black).each do |vrf|
+      [%w(ipv4 unicast), %w(ipv6 unicast),
+       %w(ipv4 multicast), %w(ipv6 multicast)].each do |af|
+        config_ios_xr_dependencies(55, vrf)
+        bgp_afs.push(RouterBgpAF.new(55, vrf, af))
+      end
+    end
+
+    # config('router bgp 55',
+    #        'address-family ipv4 unicast',
+    #        'vrf red',
+    #        'address-family ipv4 unicast',
+    #        'vrf blue',
+    #        'address-family ipv6 multicast',
+    #        'vrf orange',
+    #        'address-family ipv4 multicast',
+    #        'vrf black',
+    #        'address-family ipv6 unicast')
 
     # Construct a hash of routers, vrfs, afs
     routers = RouterBgpAF.afs
@@ -106,449 +316,73 @@ class TestBgpAF < CiscoTestCase
           afi = af_key[0]
           safi = af_key[1]
           assert(afi.length > 0, 'Error: AFI length is zero')
-          assert_match(/^ipv[46]/, afi, 'Error: AFI must be ipv4 or ipv6')
+          assert_match(/^(ip|vpn)v[46]/, afi,
+                       'Error: AFI must be vpnv4, ipv4, vpnv6 or ipv6')
           assert(safi.length > 0, 'Error: SAFI length is zero')
+          assert_match(/^(un|mult)icast/, safi,
+                       'Error: AFI must be unicast or multicast')
         end
       end
     end
   end
 
-  ########################################################
-  #                      PROPERTIES                      #
-  ########################################################
-
-  ##
-  ## default-information originate
-  ##
-  def test_default_information_originate
-    asn = '55'
-    vrf = 'red'
-    af = %w(ipv4 unicast)
-
-    #
-    # Set and verify
-    #
-    bgp_af = RouterBgpAF.new(asn, vrf, af)
-    bgp_af.default_information_originate = true
-    assert(bgp_af.default_information_originate,
-           'Error: default-information originate not set')
-
-    pattern = /^ *default-information originate$/
-    af_string = get_bgp_af_cfg(asn, vrf, af)
-
-    assert_match(pattern, af_string,
-                 "Error: 'default_information originate' is not" \
-                   ' configured and should be')
-
-    #
-    # Unset and verify
-    #
-
-    # Do a 'no default-information originate'
-    bgp_af.default_information_originate = false
-
-    pattern = /^ *default-information originate$/
-    af_string = get_bgp_af_cfg(asn, vrf, af)
-
-    refute_match(pattern, af_string,
-                 "Error: 'default_information originate' " \
-                   'is configured and should not be')
-  end
-
-  ##
-  ## client-to-client reflection
-  ##
-  def test_client_to_client
-    asn = '55'
-    vrf = 'red'
-    af = %w(ipv4 unicast)
-
-    bgp_af = RouterBgpAF.new(asn, vrf, af)
-    #
-    # Default is 'client-to-client' is configured
-    #
-    assert(bgp_af.client_to_client,
-           "Error: 'client-to-client is not configured but should be")
-    #
-    # Unset and verify
-    #
-
-    # Do a 'no client-to-client reflection'
-    bgp_af.client_to_client = false
-    pattern = /^ *no client-to-client reflection$/
-    af_string = get_bgp_af_cfg(asn, vrf, af)
-
-    assert_match(pattern, af_string,
-                 "Error: 'no client-to-client' is not configured and should be")
-
-    #
-    # Set and verify
-    #
-
-    # Do a 'client-to-client reflection'
-    bgp_af.client_to_client = true
-    af_string = get_bgp_af_cfg(asn, vrf, af)
-
-    refute_match(pattern, af_string,
-                 "Error: 'no client-to-client' is configured and should not be")
-  end
-
-  ##
-  ## next_hop route-map
-  ##
-  def test_next_hop_route_map
-    asn = '55'
-    vrf = 'red'
-    af = %w(ipv4 unicast)
-
-    #
-    # Set and verify
-    #
-    bgp_af = RouterBgpAF.new(asn, vrf, af)
-    bgp_af.next_hop_route_map = 'drop_all'
-    assert_match(bgp_af.next_hop_route_map, 'drop_all',
-                 'Error: nexthop route-map not set')
-    pattern = /^ *nexthop route-map drop_all$/
-    af_string = get_bgp_af_cfg(asn, vrf, af)
-
-    assert_match(pattern, af_string,
-                 "Error: 'nexthop route-map drop_all' is " \
-                   'not configured and should be')
-
-    #
-    # Unset and verify
-    #
-
-    # Do a 'no nexthop route-map drop_all'
-    bgp_af.next_hop_route_map = bgp_af.default_next_hop_route_map
-    af_string = get_bgp_af_cfg(asn, vrf, af)
-
-    refute_match(pattern, af_string,
-                 "Error: 'nexthop route-map drop_all' is " \
-                   'configured and should not be')
-  end
-
-  ##
-  ## additional_paths
-  ##
-  def test_additional_paths
-    asn = '55'
-    vrf = 'red'
-    af = %w(ipv4 unicast)
-
-    bgp_af = RouterBgpAF.new(asn, vrf, af)
-
-    pattern_send = 'additional-paths send'
-    pattern_receive = 'additional-paths receive'
-    pattern_install = 'additional-paths install backup'
-
-    #
-    # Default is not configured
-    #
-    af_string = get_bgp_af_cfg(asn, vrf, af)
-
-    [pattern_send, pattern_receive, pattern_install].each do |pat|
-      refute_match(pat, af_string,
-                   "Error: '#{pat}' is configured but should not be")
-    end
-
-    #
-    # Test default and getter methods
-    #
-    assert_equal(bgp_af.default_additional_paths_send,
-                 bgp_af.additional_paths_send)
-    assert_equal(bgp_af.default_additional_paths_receive,
-                 bgp_af.additional_paths_receive)
-    assert_equal(bgp_af.default_additional_paths_install,
-                 bgp_af.additional_paths_install)
-
-    #
-    # Set and verify
-    #
-
-    # Do a 'additional-paths send, receive, install'
-    bgp_af.additional_paths_send = true
-    bgp_af.additional_paths_receive = true
-    bgp_af.additional_paths_install = true
-
-    af_string = get_bgp_af_cfg(asn, vrf, af)
-
-    [pattern_send, pattern_receive, pattern_install].each do |pat|
-      assert_match(pat, af_string,
-                   "Error: '#{pat}' is not configured and should be")
-    end
-
-    #
-    # Test getter
-    #
-
-    assert(bgp_af.additional_paths_send)
-    assert(bgp_af.additional_paths_receive)
-    assert(bgp_af.additional_paths_install)
-
-    #
-    # Unset and verify
-    #
-
-    # Do a 'no additional-paths send, receive, install'
-    bgp_af.additional_paths_send = false
-    bgp_af.additional_paths_receive = false
-    bgp_af.additional_paths_install = false
-
-    af_string = get_bgp_af_cfg(asn, vrf, af)
-
-    [pattern_send, pattern_receive, pattern_install].each do |pat|
-      refute_match(pat, af_string,
-                   "Error: '#{pat}' is configured but should not be")
-    end
-  end
-
-  ##
-  ## additional_paths_selection route-map
-  ##
-  def test_additional_paths_selection
-    asn = '55'
-    vrf = 'red'
-    af = %w(ipv4 unicast)
-
-    #
-    # Set and verify
-    #
-    bgp_af = RouterBgpAF.new(asn, vrf, af)
-    bgp_af.additional_paths_selection = 'drop_all'
-
-    assert_equal(bgp_af.additional_paths_selection, 'drop_all',
-                 'Error: additional-paths selection route-map not set')
-
-    af_string = get_bgp_af_cfg(asn, vrf, af)
-    pattern = /^ *additional-paths selection route-map drop_all$/
-
-    assert_match(pattern, af_string,
-                 "Error: 'additional-paths selection route-map drop_all' is " \
-                   'not configured and should be')
-
-    #
-    # Test getter
-    #
-    pattern = /^ *drop_all$/
-    assert_match(pattern, bgp_af.additional_paths_selection,
-                 "Error: 'route-map drop_all' is not configured and should be")
-
-    #
-    # Unset and verify
-    #
+  def config_ios_xr_dependencies(asn, vrf='red')
+    return unless platform == :ios_xr
+    # These dependencies are required on ios xr
 
-    # Do a 'no additional-paths selection route-map drop_all'
-    bgp_af.additional_paths_selection =
-      bgp_af.default_additional_paths_selection
+    # "rd auto" required, otherwise XR reports:
+    #   'The RD for the VRF must be present before an
+    #        address family is activated'
 
-    af_string = get_bgp_af_cfg(asn, vrf, af)
+    # "bgp router-id" requred, otherwise XR reports:
+    #   'BGP router ID must be configured.'
 
-    refute_match(pattern, af_string,
-                 "Error: 'additional-paths selection route-map drop_all' is " \
-                   'configured and should not be')
-  end
+    # "address-family vpnv4 unicast" required, otherwise XR reports:
+    #   'The parent address family has not been initialized'
 
-  ##
-  ## advertise_l2vpn_evpn
-  ##
-  def advertise_l2vpn_evpn(asn, vrf, af)
-    bgp_af = RouterBgpAF.new(asn, vrf, af)
-
-    #
-    # Set and verify
-    #
-    val = false
-    bgp_af.advertise_l2vpn_evpn = val
-    assert_equal(val, bgp_af.advertise_l2vpn_evpn,
-                 'Error: advertise l2vpn evpn value does not match set value')
+    cfg = ["router bgp #{asn}",
+           'bgp router-id 10.1.1.1',
+           'address-family vpnv4 unicast',
+           'address-family vpnv6 unicast',
+           'address-family vpnv4 multicast',
+           'address-family vpnv6 multicast',
+          ]
+    cfg << "vrf #{vrf}" << 'rd auto' unless vrf == 'default'
+    config(cfg)
 
-    val = true
-    bgp_af.advertise_l2vpn_evpn = val
-    assert_equal(val, bgp_af.advertise_l2vpn_evpn,
-                 'Error: advertise l2vpn evpn value does not match set value')
-
-    val = bgp_af.default_advertise_l2vpn_evpn
-    bgp_af.advertise_l2vpn_evpn = val
-    assert_equal(val, bgp_af.advertise_l2vpn_evpn,
-                 'Error: advertise l2vpn evpn value does not match default' \
-                 'value')
-  end
+    # Needed for testing route-policy commands
+    config_no_warn('route-policy drop_all', 'end-policy')
 
-  def test_advertise_l2vpn_evpn
-    afs = [%w(ipv4 unicast), %w(ipv6 unicast)]
-    afs.each do |af|
-      advertise_l2vpn_evpn(55, 'red', af)
-    end
+    # TBD: Reduce the number of different route-policies used by this test
+    # and move the remaining ones into this method. Then create an
+    # unconfig_ios_xr_dependencies to handle the cleanups.
   end
 
-  ##
-  ## get_dampen_igp_metric
-  ##
-  def test_dampen_igp_metric
-    asn = '44'
-    vrf = 'green'
-    af = %w(ipv4 multicast)
-
-    bgp_af = RouterBgpAF.new(asn, vrf, af)
-
-    #
-    # Verify default value
-    #
-    assert_equal(bgp_af.dampen_igp_metric, bgp_af.default_dampen_igp_metric,
-                 "Error: Default 'dampen-igp-metric' value should be " \
-                   "#{bgp_af.default_dampen_igp_metric}")
-
-    #
-    # Set and verify 'dampen-igp-metric <value>'
-    #
-
-    # Do a 'dampen-igp-metric 555'
-    pattern = /^ *dampen-igp-metric 555$/
-    bgp_af.dampen_igp_metric = 555
-
-    af_string = get_bgp_af_cfg(asn, vrf, af)
-
-    assert_match(pattern, af_string,
-                 "Error: 'dampen-igp-metric 555' is not configured " \
-                   'and should be')
-    #
-    # Test getter
-    #
-    assert_equal(bgp_af.dampen_igp_metric, 555,
-                 'Error: dampen_igp_metric should be 555')
-
-    #
-    # Set and verify 'no dampen-igp-metric'
-    #
-
-    # Do a 'no dampen-igp-metric'
-    pattern = /no dampen-igp-metric$/
-    bgp_af.dampen_igp_metric = nil
-
-    af_string = get_bgp_af_cfg(asn, vrf, af)
-
-    assert_match(pattern, af_string,
-                 "Error: 'no dampen-igp-metric' is not configured " \
-                   'and should be')
-    #
-    # Test getter
-    #
-    assert_equal(bgp_af.dampen_igp_metric, nil,
-                 'Error: dampen_igp_metric should be nil')
-
-    #
-    # Set default value explicitly
-    #
-    bgp_af.dampen_igp_metric = bgp_af.default_dampen_igp_metric
-    assert_equal(bgp_af.dampen_igp_metric, bgp_af.default_dampen_igp_metric,
-                 "Error: Default 'dampen-igp-metric' value should be " \
-                   "#{bgp_af.default_dampen_igp_metric}")
-  end
+  ########################################################
+  #                      PROPERTIES                      #
+  ########################################################
 
-  ##
-  ## dampening
-  ##
-  # rubocop:disable Metrics/MethodLength
   def test_dampening
     asn = '101'
-
-    ############################################
-    # Set and verify 'dampening' with defaults #
-    ############################################
-    vrf = 'orange'
     af = %w(ipv4 unicast)
+    if platform == :nexus
+      vrf = 'orange'
+    elsif platform == :ios_xr
+      vrf = 'default'
+      config_ios_xr_dependencies(asn, vrf)
+      config_no_warn('route-policy DropAllTraffic', 'end-policy')
+    end
     bgp_af = RouterBgpAF.new(asn, vrf, af)
 
     # Test no dampening configured
     assert_nil(bgp_af.dampening)
 
-    pattern = /^ *dampening$/
-
-    bgp_af.dampening = []
-
-    # Check property got set
-    af_string = get_bgp_af_cfg(asn, vrf, af)
-
-    assert_match(pattern, af_string,
-                 "Error: 'dampening' is not configured and should be")
-
-    # Check properties got set
-    af_string = get_bgp_af_dampening_params(asn, vrf, af)
-
-    pattern_params1 = 'Half-life time                 : 15 mins'
-    pattern_params2 = 'Suppress penalty               : 2000'
-    pattern_params3 = 'Reuse penalty                  : 750'
-    pattern_params4 = 'Max suppress time              : 45 mins'
-    pattern_params5 = 'Max suppress penalty           : 6000'
-
-    error = ("Error: 'dampening' properties are incorrect")
-
-    assert_match(pattern_params1, af_string, error)
-    assert_match(pattern_params2, af_string, error)
-    assert_match(pattern_params3, af_string, error)
-    assert_match(pattern_params4, af_string, error)
-    assert_match(pattern_params5, af_string, error)
-
-    # Check getter
-    assert_empty(bgp_af.dampening, 'Error: dampening is configured and ' \
-                 'should not be')
-
-    #
-    # Unset and verify
-    #
-    bgp_af.dampening = nil
-
-    af_string = get_bgp_af_cfg(asn, vrf, af)
-    pattern = /^ *dampening$/
-
-    refute_match(pattern, af_string, "Error: 'dampening' is still configured")
-
-    #
-    # Test Getters
-    #
-    assert_nil(bgp_af.dampening)
-    assert_nil(bgp_af.dampening_half_time)
-    assert_nil(bgp_af.dampening_reuse_time)
-    assert_nil(bgp_af.dampening_suppress_time)
-    assert_nil(bgp_af.dampening_max_suppress_time)
-    assert_nil(bgp_af.dampening_routemap)
-
-    bgp_af.destroy
-
     #############################################
     # Set and verify 'dampening' with overrides #
     #############################################
-    vrf = 'green'
-    af = %w(ipv4 multicast)
-    bgp_af = RouterBgpAF.new(asn, vrf, af)
 
     bgp_af.dampening = %w(1 2 3 4)
 
-    # Check property got set
-    af_string = get_bgp_af_cfg(asn, vrf, af)
-    pattern = /^ *dampening 1 2 3 4$/
-
-    assert_match(pattern, af_string,
-                 "Error: 'dampening' is not configured and should be")
-
-    # Check properties got set
-    af_string = get_bgp_af_dampening_params(asn, vrf, af)
-
-    pattern_params1 = 'Half-life time                 : 1 mins'
-    pattern_params2 = 'Suppress penalty               : 3'
-    pattern_params3 = 'Reuse penalty                  : 2'
-    pattern_params4 = 'Max suppress time              : 4 mins'
-    pattern_params5 = 'Max suppress penalty           : 32'
-
-    error = ("Error: 'dampening' properties are incorrect")
-
-    assert_match(pattern_params1, af_string, error)
-    assert_match(pattern_params2, af_string, error)
-    assert_match(pattern_params3, af_string, error)
-    assert_match(pattern_params4, af_string, error)
-    assert_match(pattern_params5, af_string, error)
-
     # Check getters
     assert_equal(bgp_af.dampening, %w(1 2 3 4),
                  'Error: dampening getter did not match')
@@ -563,92 +397,28 @@ class TestBgpAF < CiscoTestCase
     assert_empty(bgp_af.dampening_routemap,
                  'A routemap should not be configured')
 
-    #
-    # Unset and verify
-    #
-    bgp_af.dampening = nil
-
-    af_string = get_bgp_af_cfg(asn, vrf, af)
-    pattern = /^ *dampening$/
-
-    refute_match(pattern, af_string, "Error: 'dampening' is still configured")
-
     #############################################
     # Set and verify 'dampening' with route-map #
     #############################################
-    vrf = 'brown'
-    af = %w(ipv6 unicast)
-    bgp_af = RouterBgpAF.new(asn, vrf, af)
 
     bgp_af.dampening = 'DropAllTraffic'
 
-    pattern = /^ *dampening route-map DropAllTraffic$/
-
-    # Check property got set
-    af_string = get_bgp_af_cfg(asn, vrf, af)
-
-    assert_match(pattern, af_string,
-                 "Error: 'dampening' is not configured and should be")
-
-    # Check properties got set
-    af_string = get_bgp_af_dampening_params(asn, vrf, af)
-    pattern_params = 'Dampening policy configured: DropAllTraffic'
-
-    assert_match(pattern_params, af_string,
-                 'Error: dampening properties DropAllTraffic is not ' \
-                   'configured and should be')
-
     # Check getters
-    assert_equal(bgp_af.dampening, 'DropAllTraffic',
-                 'Error: dampening getter did not match')
-    assert_equal(bgp_af.dampening_routemap, 'DropAllTraffic',
-                 'Error: dampening getter did not match')
-
-    #
-    # Unset and verify
-    #
-    bgp_af.dampening = nil
-    af_string = get_bgp_af_cfg(asn, vrf, af)
-    pattern = /^ *dampening$/
-
-    refute_match(pattern, af_string, "Error: 'dampening' is still configured")
+    assert_equal('DropAllTraffic', bgp_af.dampening)
+    assert_equal('DropAllTraffic', bgp_af.dampening_routemap)
 
     #############################################
-    # Set and verify 'dampening' with default   #
+    # Set and verify 'dampening' to defaults    #
     #############################################
-    vrf = 'sangria'
-    af = %w(ipv4 multicast)
-    bgp_af = RouterBgpAF.new(asn, vrf, af)
 
     bgp_af.dampening = bgp_af.default_dampening
 
-    # Check property got set
-    af_string = get_bgp_af_cfg(asn, vrf, af)
-
-    assert_match(pattern, af_string,
-                 "Error: 'dampening' is not configured and should be")
-
-    # Check properties got set
-    af_string = get_bgp_af_dampening_params(asn, vrf, af)
-
-    pattern_params1 = 'Half-life time                 : 15 mins'
-    pattern_params2 = 'Suppress penalty               : 2000'
-    pattern_params3 = 'Reuse penalty                  : 750'
-    pattern_params4 = 'Max suppress time              : 45 mins'
-    pattern_params5 = 'Max suppress penalty           : 6000'
-
-    error = ("Error: 'dampening' properties are incorrect")
+    # Check getters
 
-    assert_match(pattern_params1, af_string, error)
-    assert_match(pattern_params2, af_string, error)
-    assert_match(pattern_params3, af_string, error)
-    assert_match(pattern_params4, af_string, error)
-    assert_match(pattern_params5, af_string, error)
+    assert_equal(bgp_af.default_dampening, bgp_af.dampening)
 
-    # Check getters
-    assert_empty(bgp_af.dampening, 'Error: dampening not configured ' \
-                 'and should be')
-    assert_equal(bgp_af.default_dampening_half_time, bgp_af.dampening_half_time,
+    assert_equal(bgp_af.default_dampening_half_time,
+                 bgp_af.dampening_half_time,
                  'Wrong default dampening half_time value configured')
     assert_equal(bgp_af.default_dampening_reuse_time,
                  bgp_af.dampening_reuse_time,
@@ -663,15 +433,20 @@ class TestBgpAF < CiscoTestCase
                  bgp_af.dampening_routemap,
                  'The default dampening routemap should configured')
 
-    #
-    # Unset and verify
-    #
+    ############################################
+    # Turn off 'dampening'                     #
+    ############################################
+
     bgp_af.dampening = nil
-    af_string = get_bgp_af_cfg(asn, vrf, af)
+    assert_nil(bgp_af.dampening)
+    assert_nil(bgp_af.dampening_half_time)
+    assert_nil(bgp_af.dampening_reuse_time)
+    assert_nil(bgp_af.dampening_suppress_time)
+    assert_nil(bgp_af.dampening_max_suppress_time)
+    assert_nil(bgp_af.dampening_routemap)
 
-    refute_match(pattern, af_string, "Error: 'dampening' is still configured")
+    bgp_af.destroy
   end
-  # rubocop:enable Metrics/AbcSize,Metrics/MethodLength
 
   ##
   ## distance
@@ -681,6 +456,7 @@ class TestBgpAF < CiscoTestCase
     vrf = 'red'
     af = %w(ipv4 unicast)
 
+    config_ios_xr_dependencies(asn)
     bgp_af = RouterBgpAF.new(asn, vrf, af)
     distance = [{ ebgp: 20, ibgp: 40, local: 60 },
                 { ebgp:  bgp_af.default_distance_ebgp,
@@ -705,163 +481,6 @@ class TestBgpAF < CiscoTestCase
     bgp_af.destroy
   end
 
-  ##
-  ## default_metric
-  ##
-  def default_metric(asn, vrf, af)
-    bgp_af = RouterBgpAF.new(asn, vrf, af)
-
-    refute(bgp_af.default_default_metric,
-           'default value for default default metric should be false')
-    #
-    # Set and verify
-    #
-    val = 50
-    bgp_af.default_metric = val
-    assert_equal(val, bgp_af.default_metric,
-                 'Error: default metric value does not match set value')
-
-    val = bgp_af.default_default_metric
-    bgp_af.default_metric = val
-    assert_equal(val, bgp_af.default_metric,
-                 'Error: default metric value does not match default' \
-                 'value')
-  end
-
-  def test_default_metric
-    afs = [%w(ipv4 unicast), %w(ipv6 unicast)]
-    afs.each do |af|
-      default_metric(55, 'red', af)
-    end
-  end
-
-  ##
-  ## inject_map
-  ##
-  def inject_map(asn, vrf, af)
-    # rubocop:disable Style/WordArray
-    master = [['lax', 'sfo'],
-              ['lax', 'sjc'],
-              ['nyc', 'sfo', 'copy-attributes'],
-              ['sjc', 'nyc', 'copy-attributes']]
-    bgp_af = RouterBgpAF.new(asn, vrf, af)
-
-    # Test1: both/import/export when no commands are present. Each target
-    # option will be tested with and without evpn (6 separate types)
-    should = master.clone
-    inject_map_tester(bgp_af, should, 'Test 1')
-
-    # Test 2: remove half of the entries
-    should = [['lax', 'sfo'], ['nyc', 'sfo', 'copy-attributes']]
-    # rubocop:enable Style/WordArray
-    inject_map_tester(bgp_af, should, 'Test 2')
-
-    # Test 3: restore the removed entries
-    should = master.clone
-    inject_map_tester(bgp_af, should, 'Test 3')
-
-    # Test 4: 'default'
-    should = bgp_af.default_inject_map
-    inject_map_tester(bgp_af, should, 'Test 4')
-  end
-
-  def inject_map_tester(bgp_af, should, test_id)
-    bgp_af.send('inject_map=', should)
-    result = bgp_af.send('inject_map')
-    assert_equal(should, result,
-                 "#{test_id} : inject_map")
-  end
-
-  def test_inject_map
-    afs = [%w(ipv4 unicast), %w(ipv6 unicast)]
-    afs.each do |af|
-      inject_map(55, 'red', af)
-    end
-  end
-
-  ##
-  ## maximum_paths
-  ##
-  def maximum_paths(asn, vrf, af)
-    bgp_af = RouterBgpAF.new(asn, vrf, af)
-
-    #
-    # Set and verify
-    #
-    val = 7
-    bgp_af.maximum_paths = val
-    assert_equal(bgp_af.maximum_paths, val,
-                 'Error: maximum paths value not match to set value')
-
-    val = 9
-    bgp_af.maximum_paths = val
-    assert_equal(bgp_af.maximum_paths, val,
-                 'Error: maximum paths value not match to set value')
-
-    val = bgp_af.default_maximum_paths
-    bgp_af.maximum_paths = val
-    assert_equal(bgp_af.maximum_paths, val,
-                 'Error: maximum paths value not match to default value')
-  end
-
-  def test_maximum_paths
-    vrfs = %w(default red)
-    afs = [%w(ipv4 unicast), %w(ipv6 unicast)]
-    vrfs.each do |vrf|
-      afs.each do |af|
-        maximum_paths(55, vrf, af)
-      end
-    end
-  end
-
-  ##
-  ## maximum_paths_ibgp
-  ##
-  def maximum_paths_ibgp(asn, vrf, af)
-    /ipv4/.match(af) ? af = %w(ipv4 unicast) : af = %w(ipv6 unicast)
-    bgp_af = RouterBgpAF.new(asn, vrf, af)
-
-    #
-    # Set and verify
-    #
-    val = 7
-    bgp_af.maximum_paths_ibgp = val
-    assert_equal(bgp_af.maximum_paths_ibgp, val,
-                 'Error: maximum paths ibgp value not match to set value')
-
-    val = 9
-    bgp_af.maximum_paths_ibgp = val
-    assert_equal(bgp_af.maximum_paths_ibgp, val,
-                 'Error: maximum paths ibgp value not match to set value')
-
-    val = bgp_af.default_maximum_paths_ibgp
-    bgp_af.maximum_paths = val
-    assert_equal(bgp_af.default_maximum_paths_ibgp, val,
-                 'Error: maximum paths ibgp value not match to default value')
-  end
-
-  def test_maximum_paths_ibgp
-    asn = '55'
-    vrf = 'default'
-    af = 'ipv4 unicast'
-    maximum_paths_ibgp(asn, vrf, af)
-
-    asn = '55'
-    vrf = 'red'
-    af = 'ipv4 unicast'
-    maximum_paths_ibgp(asn, vrf, af)
-
-    asn = '55'
-    vrf = 'default'
-    af = 'ipv6 unicast'
-    maximum_paths_ibgp(asn, vrf, af)
-
-    asn = '55'
-    vrf = 'red'
-    af = 'ipv6 unicast'
-    maximum_paths_ibgp(asn, vrf, af)
-  end
-
   ##
   ## network
   ##
@@ -872,13 +491,22 @@ class TestBgpAF < CiscoTestCase
     vrfs.each do |vrf|
       afs.each do |af|
         dbg = sprintf('[VRF %s AF %s]', vrf, af.join('/'))
+        config_ios_xr_dependencies(1)
         af_obj = RouterBgpAF.new(1, vrf, af)
         network_cmd(af_obj, dbg)
+
+        af_obj.destroy
       end
     end
   end
 
   def network_cmd(af, dbg)
+    if platform == :ios_xr
+      %w(rtmap1 rtmap2 rtmap3 rtmap5 rtmap6 rtmap7).each do |policy|
+        config_no_warn("route-policy #{policy}", 'end-policy')
+      end
+    end
+
     # Initial 'should' state
     if /ipv6/.match(dbg)
       master = [
@@ -926,7 +554,13 @@ class TestBgpAF < CiscoTestCase
                  "#{dbg} Test 3. Restore the removed networks")
 
     # Test: Change route-maps on existing networks
-    should = master.map { |network, rm| [network, "#{rm}_55"] }
+    if platform == :ios_xr
+      %w(rtmap1_55 rtmap2_55 rtmap3_55 rtmap5_55
+         rtmap6_55 rtmap7_55).each do |policy|
+        config_no_warn("route-policy #{policy}", 'end-policy')
+      end
+    end
+    should = master.map { |network, rm| [network, rm.nil? ? nil : "#{rm}_55"] }
     af.networks = should
     result = af.networks
     assert_equal(should.sort, result.sort,
@@ -938,6 +572,12 @@ class TestBgpAF < CiscoTestCase
     result = af.networks
     assert_equal(should.sort, result.sort,
                  "#{dbg} Test 5. 'Default'")
+    return unless platform == :ios_xr
+    %w(rtmap1 rtmap2 rtmap3 rtmap5 rtmap6 rtmap7
+       rtmap1_55 rtmap2_55 rtmap3_55
+       rtmap5_55 rtmap6_55 rtmap7_55).each do |policy|
+      config("no route-policy #{policy}")
+    end
   end
 
   ##
@@ -950,8 +590,10 @@ class TestBgpAF < CiscoTestCase
     vrfs.each do |vrf|
       afs.each do |af|
         dbg = sprintf('[VRF %s AF %s]', vrf, af.join('/'))
+        config_ios_xr_dependencies(1)
         af = RouterBgpAF.new(1, vrf, af)
         redistribute_cmd(af, dbg)
+        af.destroy
       end
     end
   end
@@ -960,13 +602,22 @@ class TestBgpAF < CiscoTestCase
     # rubocop:disable Style/WordArray
     # Initial 'should' state
     ospf = (dbg.include? 'ipv6') ? 'ospfv3 3' : 'ospf 3'
-    master = [['direct',  'rm_direct'],
-              ['lisp',    'rm_lisp'],
-              ['static',  'rm_static'],
-              ['eigrp 1', 'rm_eigrp'],
-              ['isis 2',  'rm_isis'],
-              [ospf,      'rm_ospf'],
-              ['rip 4',   'rm_rip']]
+    if platform == :nexus
+      master = [['direct',  'rm_direct'],
+                ['lisp',    'rm_lisp'],
+                ['static',  'rm_static'],
+                ['eigrp 1', 'rm_eigrp'],
+                ['isis 2',  'rm_isis'],
+                [ospf,      'rm_ospf'],
+                ['rip 4',   'rm_rip']]
+    elsif platform == :ios_xr
+      config_no_warn('route-policy my_policy', 'end-policy')
+      master = [['connected', 'my_policy'],
+                ['eigrp 1',   'my_policy'],
+                [ospf,        'my_policy'],
+                ['static',    'my_policy']]
+      master.push(['isis abc', 'my_policy']) if dbg.include? 'default'
+    end
     # rubocop:enable Style/WordArray
 
     # Test: Add all protocols w/route-maps when no cmds are present
@@ -991,6 +642,9 @@ class TestBgpAF < CiscoTestCase
                  "#{dbg} Test 3. Restore the removed protocols")
 
     # Test: Change route-maps on existing commands
+    if platform == :ios_xr
+      config_no_warn('route-policy my_policy_2', 'end-policy')
+    end
     should = master.map { |prot_only, rm| [prot_only, "#{rm}_2"] }
     af.redistribute = should
     result = af.redistribute
@@ -1003,6 +657,10 @@ class TestBgpAF < CiscoTestCase
     result = af.redistribute
     assert_equal(should.sort, result.sort,
                  "#{dbg} Test 5. 'Default'")
+    return unless platform == :ios_xr
+    %w(my_policy my_policy_2).each do |policy|
+      config("no route-policy #{policy}")
+    end
   end
 
   ##
@@ -1099,36 +757,36 @@ class TestBgpAF < CiscoTestCase
     assert_equal(expected, result, 'Test 5. delta mismatch')
   end
 
-  ##
-  ## suppress_inactive
-  ##
-  def suppress_inactive(asn, vrf, af)
-    bgp_af = RouterBgpAF.new(asn, vrf, af)
+  def test_respond_to?
+    config_ios_xr_dependencies('22')
+    bgp_af = RouterBgpAF.new('22', 'red', %w(ipv4 unicast))
 
-    #
-    # Set and verify
-    #
-    val = false
-    bgp_af.suppress_inactive = val
-    refute(bgp_af.suppress_inactive,
-           'Error: suppress inactive value does not match set value')
+    # Functions that are actually defined in bgp_af.rb
+    assert_respond_to(bgp_af, :dampening_max_suppress_time)
+    assert_respond_to(bgp_af, :next_hop_route_map=)
+    assert_respond_to(bgp_af, :default_additional_paths_selection)
 
-    val = true
-    bgp_af.suppress_inactive = val
-    assert(bgp_af.suppress_inactive,
-           'Error: suppress inactive value does not match set value')
-
-    val = bgp_af.default_suppress_inactive
-    bgp_af.suppress_inactive = val
-    refute(bgp_af.suppress_inactive,
-           'Error: suppress inactive value does not match default value')
-  end
-
-  def test_suppress_inactive
-    afs = [%w(ipv4 unicast), %w(ipv6 unicast)]
-    afs.each do |af|
-      suppress_inactive(55, 'red', af)
+    # Functions that are covered by the method_missing magic
+    assert_respond_to(bgp_af, :next_hop_route_map)
+    assert_respond_to(bgp_af, :additional_paths_selection)
+    assert_respond_to(bgp_af, :default_default_information_originate)
+    if platform == :ios_xr
+      # not supported
+      refute_respond_to(bgp_af, :default_information_originate=)
+    else
+      assert_respond_to(bgp_af, :default_information_originate=)
     end
+    assert_respond_to(bgp_af, :table_map)
+    assert_respond_to(bgp_af, :default_table_map)
+
+    # Functions that are explicitly excluded from method_missing
+    refute_respond_to(bgp_af, :table_map=)
+    refute_respond_to(bgp_af, :table_map_filter=)
+
+    # Functions that shouldn't be covered by method_missing
+    refute_respond_to(bgp_af, :default_next_hop_route_map=)
+
+    bgp_af.destroy
   end
 
   ##
@@ -1142,35 +800,44 @@ class TestBgpAF < CiscoTestCase
     #
     val = 'sjc'
     bgp_af.table_map_set(val)
-    assert_equal(val, bgp_af.table_map,
-                 'Error: default metric value does not match set value')
+    assert_equal(val, bgp_af.table_map)
 
     val = bgp_af.default_table_map
     bgp_af.table_map_set(val)
-    assert_equal(val, bgp_af.table_map,
-                 'Error: default metric value does not match default' \
-                 'value')
+    assert_equal(val, bgp_af.table_map)
+
+    if validate_property_excluded?('bgp_af', 'table_map_filter')
+      assert_raises(Cisco::UnsupportedError) do
+        bgp_af.table_map_set('sjc', true)
+      end
+      assert_nil(bgp_af.default_table_map_filter)
+      return
+    end
 
     val = false
     bgp_af.table_map_set('sjc', val)
-    refute(bgp_af.table_map_filter,
-           'Error: suppress inactive value does not match set value')
+    refute(bgp_af.table_map_filter)
 
     val = true
     bgp_af.table_map_set('sjc', val)
-    assert(bgp_af.table_map_filter,
-           'Error: suppress inactive value does not match set value')
+    assert(bgp_af.table_map_filter)
 
-    val = bgp_af.default_table_map_filter
-    bgp_af.table_map_set('sjc', val)
-    refute(bgp_af.table_map_filter,
-           'Error: suppress inactive value does not match default value')
+    default = bgp_af.default_table_map_filter
+    bgp_af.table_map_set('sjc', default)
+    assert_equal(default, bgp_af.table_map_filter)
   end
 
   def test_table_map
+    if platform == :ios_xr
+      config_no_warn('route-policy sjc', 'end-policy')
+      config_ios_xr_dependencies('55')
+    end
+
     afs = [%w(ipv4 unicast), %w(ipv6 unicast)]
     afs.each do |af|
       table_map(55, 'red', af)
     end
+
+    config('no route-policy sjc') if platform == :ios_xr
   end
 end