cisco_node_utils 1.3.0 → 1.4.0

data/tests/test_tacacs_server_group.rb

@@ -17,16 +17,9 @@ require_relative '../lib/cisco_node_utils/tacacs_server_group'
 require_relative '../lib/cisco_node_utils/tacacs_server_host'
 
 # Test class for Tacacs Server Group
-class TestTacacsServerGroup < CiscoTestCase
+class TestTacacsSvrGrp < CiscoTestCase
   @skip_unless_supported = 'tacacs_server_group'
 
-  def setup
-    super
-    # TBD: Remove once CSCuz44696 is resolved.
-    skip('This test is not currently supported on 7.0(3)I3 images') if
-      node.os_version[/7.0\(3\)I3\(/]
-  end
-
   def clean_tacacs_config
     config('no feature tacacs',
            'feature tacacs')
@@ -141,7 +134,7 @@ class TestTacacsServerGroup < CiscoTestCase
     destroy_aaa_group(group_name3, 'tacacs+')
   end
 
-  def test_servers_tacacs
+  def test_servers
     clean_tacacs_config
     server_name1 = '1.1.1.1'
     server_name2 = '2.2.2.2'
@@ -170,25 +163,6 @@ class TestTacacsServerGroup < CiscoTestCase
     detach_tacacsserverhost(server_name2)
   end
 
-  def test_add_server_tacacs
-    server_name1 = '1.1.1.1'
-    server_name2 = '2.2.2.2'
-    create_tacacsserverhost(server_name1)
-    create_tacacsserverhost(server_name2)
-
-    aaa_group = TacacsServerGroup.new('Group1')
-    aaa_group.servers = [server_name1, server_name2]
-
-    assert_show_match(command: config_command,
-                      pattern: /server #{server_name1}/)
-    assert_show_match(command: config_command,
-                      pattern: /server #{server_name2}/)
-
-    detach_aaaservergroup(aaa_group)
-    detach_tacacsserverhost(server_name1)
-    detach_tacacsserverhost(server_name2)
-  end
-
   def test_remove_server_tacacs
     clean_tacacs_config
     server_name1 = '1.1.1.1'
@@ -389,7 +363,7 @@ class TestTacacsServerGroup < CiscoTestCase
     detach_aaaservergroup(aaa_group)
   end
 
-  def test_get_default_source_interface_tacacs
+  def test_source_interface
     # TODO
     return if validate_property_excluded?('tacacs_server_group',
                                           'source_interface')

data/tests/test_tacacs_server_host.rb

@@ -22,7 +22,7 @@ DEFAULT_TACACS_SERVER_HOST_TIMEOUT = 0
 DEFAULT_TACACS_SERVER_HOST_ENCRYPTION_PASSWORD = ''
 
 # TestTacacsServerHost - Minitest for TacacsServerHost node utility
-class TestTacacsServerHost < CiscoTestCase
+class TestTacacsSvrHost < CiscoTestCase
   @skip_unless_supported = 'tacacs_server_host'
 
   def setup
@@ -44,7 +44,7 @@ class TestTacacsServerHost < CiscoTestCase
            'no aaa group server tacacs blue')
   end
 
-  def test_tacacsserverhost_collection_empty
+  def test_collection_empty
     hosts = TacacsServerHost.hosts
     hosts.each_value(&:destroy)
     hosts = TacacsServerHost.hosts
@@ -52,7 +52,7 @@ class TestTacacsServerHost < CiscoTestCase
     assert_empty(hosts, 'Error: Tacacs Host collection is not empty')
   end
 
-  def test_tacacsserverhost_collection
+  def test_collection
     hosts_hash = {}
     hosts_hash['4.4.4.4'] = 1138
     hosts_hash['5.5.5.5'] = DEFAULT_TACACS_SERVER_HOST_PORT
@@ -80,21 +80,18 @@ class TestTacacsServerHost < CiscoTestCase
     hosts_hash.each_key { |name| hosts[name].destroy }
   end
 
-  def test_tacacsserverhost_create_server_nil
+  def test_negative
     assert_raises(TypeError) { TacacsServerHost.new(nil) }
-  end
-
-  def test_tacacsserverhost_create_name_zero_length
     assert_raises(ArgumentError) { TacacsServerHost.new('') }
   end
 
-  def test_tacacsserverhost_create_valid
+  def test_create
     host = TacacsServerHost.new(@host_name)
     assert_show_match(msg: 'Error: Tacacs Host not created')
     host.destroy
   end
 
-  def test_tacacsserverhost_destroy
+  def test_destroy
     host = TacacsServerHost.new(@host_name)
     assert_show_match(msg: 'Error: Tacacs Host not created')
     host.destroy
@@ -102,7 +99,7 @@ class TestTacacsServerHost < CiscoTestCase
     refute_show_match(msg: 'Error: Tacacs Host still present')
   end
 
-  def test_tacacsserverhost_get_name
+  def test_name
     host = TacacsServerHost.new(@host_name)
     line = assert_show_match(msg: 'Error: Tacacs Host not found')
     assert_equal(@host_name, line.captures[0],
@@ -112,7 +109,7 @@ class TestTacacsServerHost < CiscoTestCase
     host.destroy
   end
 
-  def test_tacacsserverhost_get_name_preconfigured
+  def test_name_preconfigured
     config("tacacs-server host #{@host_name}")
 
     line = assert_show_match(msg: 'Error: Tacacs Host not found')
@@ -127,7 +124,7 @@ class TestTacacsServerHost < CiscoTestCase
     hosts.each_value(&:destroy)
   end
 
-  def test_tacacsserverhost_get_name_formats
+  def test_name_formats
     host_name = 'testhost.example.com'
     host_ip = '192.168.1.1'
 
@@ -159,7 +156,7 @@ class TestTacacsServerHost < CiscoTestCase
     hosts.each_value(&:destroy)
   end
 
-  def test_tacacsserverhost_get_port
+  def test_port_get
     host = TacacsServerHost.new(@host_name)
 
     # not previously configured
@@ -177,7 +174,7 @@ class TestTacacsServerHost < CiscoTestCase
     host.destroy
   end
 
-  def test_tacacsserverhost_get_default_port
+  def test_port_default
     host = TacacsServerHost.new(@host_name)
 
     port = DEFAULT_TACACS_SERVER_HOST_PORT
@@ -186,7 +183,7 @@ class TestTacacsServerHost < CiscoTestCase
     host.destroy
   end
 
-  def test_tacacsserverhost_set_port
+  def test_port_set
     return if platform == :ios_xr
 
     host = TacacsServerHost.new(@host_name)
@@ -202,7 +199,7 @@ class TestTacacsServerHost < CiscoTestCase
     host.destroy
   end
 
-  def test_tacacsserverhost_get_timeout
+  def test_timeout_get
     # Cleanup first
     s = @device.cmd("show run | i 'tacacs.*timeout'")[/^tacacs.*timeout.*$/]
     config("no #{s}") if s
@@ -221,7 +218,7 @@ class TestTacacsServerHost < CiscoTestCase
     host.destroy
   end
 
-  def test_tacacsserverhost_get_default_timeout
+  def test_timeout_default
     host = TacacsServerHost.new(@host_name)
 
     timeout = DEFAULT_TACACS_SERVER_HOST_TIMEOUT
@@ -230,7 +227,7 @@ class TestTacacsServerHost < CiscoTestCase
     host.destroy
   end
 
-  def test_tacacsserverhost_set_timeout
+  def test_timeout_set
     host = TacacsServerHost.new(@host_name)
 
     timeout = 30
@@ -249,7 +246,7 @@ class TestTacacsServerHost < CiscoTestCase
     host.destroy
   end
 
-  def test_tacacsserverhost_unset_timeout
+  def test_timeout_unset
     host = TacacsServerHost.new(@host_name)
 
     timeout = DEFAULT_TACACS_SERVER_HOST_TIMEOUT
@@ -261,7 +258,7 @@ class TestTacacsServerHost < CiscoTestCase
     host.destroy
   end
 
-  def test_tacacsserverhost_get_encryption_type
+  def test_encryption_type
     host = TacacsServerHost.new(@host_name)
 
     # when not configured
@@ -279,7 +276,7 @@ class TestTacacsServerHost < CiscoTestCase
     host.destroy
   end
 
-  def test_tacacsserverhost_get_default_encryption_type
+  def test_encryption_type_default
     host = TacacsServerHost.new(@host_name)
 
     assert_equal(TACACS_SERVER_ENC_NONE,
@@ -288,7 +285,7 @@ class TestTacacsServerHost < CiscoTestCase
     host.destroy
   end
 
-  def test_tacacsserverhost_get_encryption_password
+  def test_encryption_password
     host = TacacsServerHost.new(@host_name)
 
     # when not configured
@@ -312,7 +309,7 @@ class TestTacacsServerHost < CiscoTestCase
     host.destroy
   end
 
-  def test_tacacsserverhost_get_default_encryption_password
+  def test_encryption_password_default
     host = TacacsServerHost.new(@host_name)
 
     assert_equal('', TacacsServerHost.default_encryption_password,
@@ -320,7 +317,7 @@ class TestTacacsServerHost < CiscoTestCase
     host.destroy
   end
 
-  def test_tacacsserverhost_set_key
+  def test_key
     host = TacacsServerHost.new(@host_name)
 
     enctype = TACACS_SERVER_ENC_NONE
@@ -352,7 +349,7 @@ class TestTacacsServerHost < CiscoTestCase
     host.destroy
   end
 
-  def test_tacacsserverhost_unset_key
+  def test_key_unset
     # Cleanup first
     s = @device.cmd("show run | i 'tacacs.*host'")[/^tacacs.*host.*$/]
     config("no #{s}") if s
@@ -360,7 +357,7 @@ class TestTacacsServerHost < CiscoTestCase
     host = TacacsServerHost.new(@host_name)
 
     # First configure key value. Whether that can be passed
-    # will be decided by test_tacacsserverhost_set_key
+    # will be decided by test_key
     enctype = TACACS_SERVER_ENC_NONE
     pass = 'TEST'
     host.encryption_key_set(enctype, pass)
@@ -393,7 +390,7 @@ class TestTacacsServerHost < CiscoTestCase
            'no tacacs-server host 8.8.8.8 port 33')
   end
 
-  def test_create_destroy_single_with_duplicates
+  def test_duplicates
     return if platform != :ios_xr
     setup_duplicates
 

data/tests/test_vlan.rb

@@ -21,18 +21,7 @@ include Cisco
 # TestVlan - Minitest for Vlan node utility
 class TestVlan < CiscoTestCase
   @skip_unless_supported = 'vlan'
-
   @@cleaned = false # rubocop:disable Style/ClassVars
-  def cleanup
-    Vlan.vlans.each do |vlan, obj|
-      # skip reserved vlans
-      next if vlan == '1'
-      next if node.product_id[/N5K|N6K|N7K/] && (1002..1005).include?(vlan.to_i)
-      obj.destroy
-    end
-    interface_ethernet_default(interfaces[0])
-    config_no_warn('no feature vtp')
-  end
 
   def setup
     super
@@ -44,6 +33,17 @@ class TestVlan < CiscoTestCase
     cleanup
   end
 
+  def cleanup
+    remove_all_vlans
+    interface_ethernet_default(interfaces[0])
+    config_no_warn('no feature vtp')
+  end
+
+  def overlay_cleanup
+    config_no_warn('no feature vn-segment-vlan-based')
+    config_no_warn('no nv overlay evpn ; no feature nv overlay')
+  end
+
   def interface_ethernet_default(intf)
     config("default interface #{intf}")
   end
@@ -70,7 +70,7 @@ class TestVlan < CiscoTestCase
     assert_match(/Invalid value.non-numeric/, e.message)
   end
 
-  def test_create_and_destroy
+  def test_create_destroy
     v = Vlan.new(1000)
     vlans = Vlan.vlans
     assert(vlans.key?('1000'), 'Error: failed to create vlan 1000')
@@ -149,34 +149,6 @@ class TestVlan < CiscoTestCase
     v.destroy
   end
 
-  def test_name_too_long
-    v = Vlan.new(1000)
-    name = 'a' * VLAN_NAME_SIZE
-    assert_raises(RuntimeError, 'vlan misconfig did not raise RuntimeError') do
-      v.vlan_name = name
-    end
-    ref = cmd_ref.lookup('vlan', 'name')
-    assert(ref, 'Error, reference not found for vlan name')
-    v.destroy
-  end
-
-  def test_name_duplicate
-    # Testbed cleanup
-    v = Vlan.new(1000)
-    v.destroy
-    v = Vlan.new(1001)
-    v.destroy
-    # start test
-    v1 = Vlan.new(1000)
-    v1.vlan_name = 'test'
-    v2 = Vlan.new(1001)
-    assert_raises(RuntimeError, 'vlan misconfig did not raise RuntimeError') do
-      v2.vlan_name = 'test'
-    end
-    v1.destroy
-    v2.destroy
-  end
-
   def test_state_invalid
     v = Vlan.new(1000)
     assert_raises(CliError) do
@@ -234,32 +206,26 @@ class TestVlan < CiscoTestCase
                                'present on any interfaces')
 
     # Add test vlan to 3 ethernet interfaces
-    vlan_intf_max = 3
-    vlan_intf_list = []
-    Interface.interfaces.each do |name, i|
-      next unless i.name[/ethernet/]
-      interface_ethernet_default(name)
+    vlan_intf_list = interfaces.first(3)
+    vlan_intf_list.each do |intf, i|
+      interface_ethernet_default(intf)
+      i = Interface.new(intf)
       i.switchport_mode = :access
       assert_equal(i.default_access_vlan, i.access_vlan,
-                   "access vlan is not default on #{name}")
+                   "access vlan is not default on #{intf}")
 
       v.add_interface(i)
       assert_equal(vlan_id, i.access_vlan,
-                   "access vlan #{vlan_id} not present on #{name}")
-      vlan_intf_list << name
-      break if vlan_intf_list.count == vlan_intf_max
+                   "access vlan #{vlan_id} not present on #{intf}")
     end
-    count = v.interfaces.count
-    assert_equal(vlan_intf_max, count,
-                 "vlan #{vlan_id} found on #{count} interfaces, "\
-                 "expected #{vlan_intf_max} total")
+    assert_equal(vlan_intf_list.count, v.interfaces.count)
 
     # Remove test vlan from interfaces
-    vlan_intf_list.each do |name|
-      i = Interface.new(name)
+    vlan_intf_list.each do |intf|
+      i = Interface.new(intf)
       v.remove_interface(i)
       assert_equal(i.default_access_vlan, i.access_vlan,
-                   "access vlan #{vlan_id} should not be present on #{name}")
+                   "access vlan #{vlan_id} should not be present on #{intf}")
     end
     assert_empty(v.interfaces, "access vlan #{vlan_id} should not be "\
                                'present on any interfaces')
@@ -290,6 +256,12 @@ class TestVlan < CiscoTestCase
   end
 
   def test_mapped_vnis
+    if validate_property_excluded?('vlan', 'mapped_vni')
+      assert_raises(Cisco::UnsupportedError) do
+        Vlan.new(100).mapped_vni = 10_000
+      end
+      return
+    end
     # Map
     v1 = Vlan.new(100)
     vni1 = 10_000
@@ -343,13 +315,39 @@ class TestVlan < CiscoTestCase
 
   def test_mode_with_pvlan
     v = Vlan.new(1000)
-    if validate_property_excluded?('vlan', 'private_vlan_type') ||
+    if validate_property_excluded?('vlan', 'pvlan_type') ||
        validate_property_excluded?('vlan', 'mode')
-      features = 'private_vlan_type and/or vlan mode'
+      features = 'pvlan_type and/or vlan mode'
       skip("Skip test: Features #{features} are not supported on this device")
     end
     result = 'CE'
-    v.private_vlan_type = 'primary'
+    v.pvlan_type = 'primary'
     assert_equal(result, v.mode)
   end
+
+  def test_vlan_mode_fabricpath
+    if validate_property_excluded?('vlan', 'mode')
+      assert_raises(Cisco::UnsupportedError) { Vlan.new(2000).mode = 'foo' }
+      return
+    end
+    config_no_warn('no feature vn-segment-vlan-based')
+    config_no_warn('no nv overlay evpn ; no feature nv overlay')
+    # Test for valid mode
+    v = Vlan.new(2000)
+    default = v.default_mode
+    assert_equal(default, v.mode,
+                 'Mode should have been default value: #{default}')
+    v.mode = 'fabricpath'
+    assert_equal(:enabled, v.fabricpath_feature,
+                 'Fabricpath feature should have been enabled')
+    assert_equal('fabricpath', v.mode,
+                 'Mode should have been set to fabricpath')
+
+    # Test for invalid mode
+    v = Vlan.new(100)
+    assert_equal(default, v.mode,
+                 'Mode should have been default value: #{default}')
+
+    assert_raises(CliError) { v.mode = 'junk' }
+  end
 end

data/tests/test_vlan_private.rb

@@ -20,17 +20,12 @@ require_relative '../lib/cisco_node_utils/vlan'
 include Cisco
 
 # TestVlan - Minitest for Vlan node utility
-class TestVlan < CiscoTestCase
+class TestVlanPVlan < CiscoTestCase
   @skip_unless_supported = 'vlan'
 
   @@cleaned = false # rubocop:disable Style/ClassVars
   def cleanup
-    Vlan.vlans.each do |vlan, obj|
-      # skip reserved vlans
-      next if vlan == '1'
-      next if node.product_id[/N5K|N6K|N7K/] && (1002..1005).include?(vlan.to_i)
-      obj.destroy
-    end
+    remove_all_vlans
     config_no_warn('no feature vtp')
     config_no_warn('no feature private-vlan')
   end
@@ -45,357 +40,357 @@ class TestVlan < CiscoTestCase
     cleanup
   end
 
-  def test_private_type_default
+  def test_type_default
     config_no_warn('no feature vtp')
     config_no_warn('feature private-vlan')
     v1 = Vlan.new(100)
     pv_type = ''
-    if validate_property_excluded?('vlan', 'private_vlan_type')
-      assert_nil(v1.private_vlan_type)
+    if validate_property_excluded?('vlan', 'pvlan_type')
+      assert_nil(v1.pvlan_type)
     else
-      assert_equal(pv_type, v1.private_vlan_type)
+      assert_equal(pv_type, v1.pvlan_type)
     end
   end
 
-  def test_private_association_default
+  def test_association_default
     config_no_warn('no feature vtp')
     config_no_warn('feature private-vlan')
     v1 = Vlan.new(100)
-    if validate_property_excluded?('vlan', 'private_vlan_type')
-      assert_nil(v1.private_vlan_type)
+    if validate_property_excluded?('vlan', 'pvlan_type')
+      assert_nil(v1.pvlan_type)
       return
     else
       result = []
-      assert_equal(result, v1.private_vlan_association)
+      assert_equal(result, v1.pvlan_association)
     end
   end
 
-  def test_private_vlan_type_primary
+  def test_type_primary
     v1 = Vlan.new(100)
     pv_type = 'primary'
-    if validate_property_excluded?('vlan', 'private_vlan_type')
-      assert_nil(v1.private_vlan_type)
+    if validate_property_excluded?('vlan', 'pvlan_type')
+      assert_nil(v1.pvlan_type)
       assert_raises(Cisco::UnsupportedError) do
-        v1.private_vlan_type = pv_type
+        v1.pvlan_type = pv_type
       end
     else
-      v1.private_vlan_type = pv_type
-      assert_equal(pv_type, v1.private_vlan_type)
+      v1.pvlan_type = pv_type
+      assert_equal(pv_type, v1.pvlan_type)
     end
   end
 
-  def test_no_private_vlan_type_primary
+  def test_no_pvlan_type_primary
     v1 = Vlan.new(200)
     pv_type = 'primary'
-    if validate_property_excluded?('vlan', 'private_vlan_type')
-      assert_nil(v1.private_vlan_type)
+    if validate_property_excluded?('vlan', 'pvlan_type')
+      assert_nil(v1.pvlan_type)
       assert_raises(Cisco::UnsupportedError) do
-        v1.private_vlan_type = pv_type
+        v1.pvlan_type = pv_type
       end
       return
     else
-      v1.private_vlan_type = pv_type
-      assert_equal(pv_type, v1.private_vlan_type)
+      v1.pvlan_type = pv_type
+      assert_equal(pv_type, v1.pvlan_type)
       pv_type = ''
-      v1.private_vlan_type = pv_type
-      assert_equal(pv_type, v1.private_vlan_type)
+      v1.pvlan_type = pv_type
+      assert_equal(pv_type, v1.pvlan_type)
     end
   end
 
-  def test_multi_private_vlan_type_primary
+  def test_multi_pvlan_type_primary
     v1 = Vlan.new(100)
     v2 = Vlan.new(101)
     v3 = Vlan.new(200)
     v4 = Vlan.new(201)
     v5 = Vlan.new(203)
     pv_type = 'primary'
-    if validate_property_excluded?('vlan', 'private_vlan_type')
-      assert_nil(v1.private_vlan_type)
+    if validate_property_excluded?('vlan', 'pvlan_type')
+      assert_nil(v1.pvlan_type)
       assert_raises(Cisco::UnsupportedError) do
-        v1.private_vlan_type = pv_type
+        v1.pvlan_type = pv_type
       end
       return
     else
-      v1.private_vlan_type = pv_type
-      v2.private_vlan_type = pv_type
-      v3.private_vlan_type = pv_type
-      v4.private_vlan_type = pv_type
-      v5.private_vlan_type = pv_type
-
-      assert_equal(pv_type, v1.private_vlan_type)
-      assert_equal(pv_type, v2.private_vlan_type)
-      assert_equal(pv_type, v3.private_vlan_type)
-      assert_equal(pv_type, v4.private_vlan_type)
-      assert_equal(pv_type, v5.private_vlan_type)
+      v1.pvlan_type = pv_type
+      v2.pvlan_type = pv_type
+      v3.pvlan_type = pv_type
+      v4.pvlan_type = pv_type
+      v5.pvlan_type = pv_type
+
+      assert_equal(pv_type, v1.pvlan_type)
+      assert_equal(pv_type, v2.pvlan_type)
+      assert_equal(pv_type, v3.pvlan_type)
+      assert_equal(pv_type, v4.pvlan_type)
+      assert_equal(pv_type, v5.pvlan_type)
     end
   end
 
-  def test_private_vlan_type_isolated
+  def test_type_isolated
     v1 = Vlan.new(100)
     pv_type = 'isolated'
-    if validate_property_excluded?('vlan', 'private_vlan_type')
-      assert_nil(v1.private_vlan_type)
+    if validate_property_excluded?('vlan', 'pvlan_type')
+      assert_nil(v1.pvlan_type)
       assert_raises(Cisco::UnsupportedError) do
-        v1.private_vlan_type = pv_type
+        v1.pvlan_type = pv_type
       end
     else
-      v1.private_vlan_type = pv_type
-      assert_equal(pv_type, v1.private_vlan_type)
+      v1.pvlan_type = pv_type
+      assert_equal(pv_type, v1.pvlan_type)
     end
   end
 
-  def test_private_vlan_type_community
+  def test_type_community
     v1 = Vlan.new(100)
     pv_type = 'community'
-    if validate_property_excluded?('vlan', 'private_vlan_type')
-      assert_nil(v1.private_vlan_type)
+    if validate_property_excluded?('vlan', 'pvlan_type')
+      assert_nil(v1.pvlan_type)
       assert_raises(Cisco::UnsupportedError) do
-        v1.private_vlan_type = pv_type
+        v1.pvlan_type = pv_type
       end
     else
-      v1.private_vlan_type = pv_type
-      assert_equal(pv_type, v1.private_vlan_type)
+      v1.pvlan_type = pv_type
+      assert_equal(pv_type, v1.pvlan_type)
     end
   end
 
-  def test_private_vlan_type_isolated_primary
+  def test_type_isolated_primary
     v1 = Vlan.new(100)
     pv_type = 'isolated'
-    if validate_property_excluded?('vlan', 'private_vlan_type')
-      assert_nil(v1.private_vlan_type)
+    if validate_property_excluded?('vlan', 'pvlan_type')
+      assert_nil(v1.pvlan_type)
       assert_raises(Cisco::UnsupportedError) do
-        v1.private_vlan_type = pv_type
+        v1.pvlan_type = pv_type
       end
       return
     else
-      v1.private_vlan_type = pv_type
-      assert_equal(pv_type, v1.private_vlan_type)
+      v1.pvlan_type = pv_type
+      assert_equal(pv_type, v1.pvlan_type)
       v2 = Vlan.new(200)
       pv_type = 'primary'
-      v2.private_vlan_type = pv_type
-      assert_equal(pv_type, v2.private_vlan_type)
+      v2.pvlan_type = pv_type
+      assert_equal(pv_type, v2.pvlan_type)
     end
   end
 
-  def test_private_vlan_type_isolated_community_primary
+  def test_type_isolated_community_primary
     v1 = Vlan.new(100)
     pv_type = 'isolated'
-    if validate_property_excluded?('vlan', 'private_vlan_type')
-      assert_nil(v1.private_vlan_type)
+    if validate_property_excluded?('vlan', 'pvlan_type')
+      assert_nil(v1.pvlan_type)
       assert_raises(Cisco::UnsupportedError) do
-        v1.private_vlan_type = pv_type
+        v1.pvlan_type = pv_type
       end
       return
     else
-      v1.private_vlan_type = pv_type
-      assert_equal(pv_type, v1.private_vlan_type)
+      v1.pvlan_type = pv_type
+      assert_equal(pv_type, v1.pvlan_type)
       v2 = Vlan.new(200)
       pv_type = 'primary'
-      v2.private_vlan_type = pv_type
-      assert_equal(pv_type, v2.private_vlan_type)
+      v2.pvlan_type = pv_type
+      assert_equal(pv_type, v2.pvlan_type)
       v3 = Vlan.new(300)
       pv_type = 'community'
-      v3.private_vlan_type = pv_type
-      assert_equal(pv_type, v3.private_vlan_type)
+      v3.pvlan_type = pv_type
+      assert_equal(pv_type, v3.pvlan_type)
     end
   end
 
-  def test_private_vlan_type_change_isolated_to_primary
+  def test_type_change_isolated_to_primary
     v1 = Vlan.new(100)
     pv_type = 'isolated'
-    if validate_property_excluded?('vlan', 'private_vlan_type')
-      assert_nil(v1.private_vlan_type)
+    if validate_property_excluded?('vlan', 'pvlan_type')
+      assert_nil(v1.pvlan_type)
       assert_raises(Cisco::UnsupportedError) do
-        v1.private_vlan_type = pv_type
+        v1.pvlan_type = pv_type
       end
       return
     else
-      v1.private_vlan_type = pv_type
-      assert_equal(pv_type, v1.private_vlan_type)
+      v1.pvlan_type = pv_type
+      assert_equal(pv_type, v1.pvlan_type)
       pv_type = 'primary'
-      v1.private_vlan_type = pv_type
-      assert_equal(pv_type, v1.private_vlan_type)
+      v1.pvlan_type = pv_type
+      assert_equal(pv_type, v1.pvlan_type)
     end
   end
 
-  def test_private_vlan_type_change_isolated_to_community
+  def test_type_change_isolated_to_community
     v1 = Vlan.new(100)
     pv_type = 'isolated'
-    if validate_property_excluded?('vlan', 'private_vlan_type')
-      assert_nil(v1.private_vlan_type)
+    if validate_property_excluded?('vlan', 'pvlan_type')
+      assert_nil(v1.pvlan_type)
       assert_raises(Cisco::UnsupportedError) do
-        v1.private_vlan_type = pv_type
+        v1.pvlan_type = pv_type
       end
       return
     else
-      v1.private_vlan_type = pv_type
-      assert_equal(pv_type, v1.private_vlan_type)
+      v1.pvlan_type = pv_type
+      assert_equal(pv_type, v1.pvlan_type)
       pv_type = 'community'
-      v1.private_vlan_type = pv_type
-      assert_equal(pv_type, v1.private_vlan_type)
+      v1.pvlan_type = pv_type
+      assert_equal(pv_type, v1.pvlan_type)
     end
   end
 
-  def test_private_vlan_type_change_community_to_isolated
+  def test_type_change_community_to_isolated
     v1 = Vlan.new(100)
     pv_type = 'community'
-    if validate_property_excluded?('vlan', 'private_vlan_type')
-      assert_nil(v1.private_vlan_type)
+    if validate_property_excluded?('vlan', 'pvlan_type')
+      assert_nil(v1.pvlan_type)
       assert_raises(Cisco::UnsupportedError) do
-        v1.private_vlan_type = pv_type
+        v1.pvlan_type = pv_type
       end
       return
     else
-      v1.private_vlan_type = pv_type
-      assert_equal(pv_type, v1.private_vlan_type)
+      v1.pvlan_type = pv_type
+      assert_equal(pv_type, v1.pvlan_type)
       pv_type = 'isolated'
-      v1.private_vlan_type = pv_type
-      assert_equal(pv_type, v1.private_vlan_type)
+      v1.pvlan_type = pv_type
+      assert_equal(pv_type, v1.pvlan_type)
     end
   end
 
-  def test_private_vlan_type_change_community_to_primary
+  def test_type_change_community_to_primary
     v1 = Vlan.new(100)
     pv_type = 'community'
-    if validate_property_excluded?('vlan', 'private_vlan_type')
-      assert_nil(v1.private_vlan_type)
+    if validate_property_excluded?('vlan', 'pvlan_type')
+      assert_nil(v1.pvlan_type)
       assert_raises(Cisco::UnsupportedError) do
-        v1.private_vlan_type = pv_type
+        v1.pvlan_type = pv_type
       end
       return
     else
-      v1.private_vlan_type = pv_type
-      assert_equal(pv_type, v1.private_vlan_type)
+      v1.pvlan_type = pv_type
+      assert_equal(pv_type, v1.pvlan_type)
       pv_type = 'primary'
-      v1.private_vlan_type = pv_type
-      assert_equal(pv_type, v1.private_vlan_type)
+      v1.pvlan_type = pv_type
+      assert_equal(pv_type, v1.pvlan_type)
     end
   end
 
-  def test_private_vlan_type_change_primary_to_isolated
+  def test_type_change_primary_to_isolated
     v1 = Vlan.new(100)
     pv_type = 'primary'
-    if validate_property_excluded?('vlan', 'private_vlan_type')
-      assert_nil(v1.private_vlan_type)
+    if validate_property_excluded?('vlan', 'pvlan_type')
+      assert_nil(v1.pvlan_type)
       assert_raises(Cisco::UnsupportedError) do
-        v1.private_vlan_type = pv_type
+        v1.pvlan_type = pv_type
       end
       return
     else
-      v1.private_vlan_type = pv_type
-      assert_equal(pv_type, v1.private_vlan_type)
+      v1.pvlan_type = pv_type
+      assert_equal(pv_type, v1.pvlan_type)
       pv_type = 'isolated'
-      v1.private_vlan_type = pv_type
-      assert_equal(pv_type, v1.private_vlan_type)
+      v1.pvlan_type = pv_type
+      assert_equal(pv_type, v1.pvlan_type)
     end
   end
 
-  def test_private_vlan_type_change_primary_to_community
+  def test_type_change_primary_to_community
     v1 = Vlan.new(100)
     pv_type = 'primary'
-    if validate_property_excluded?('vlan', 'private_vlan_type')
-      assert_nil(v1.private_vlan_type)
+    if validate_property_excluded?('vlan', 'pvlan_type')
+      assert_nil(v1.pvlan_type)
       assert_raises(Cisco::UnsupportedError) do
-        v1.private_vlan_type = pv_type
+        v1.pvlan_type = pv_type
       end
       return
     else
-      v1.private_vlan_type = pv_type
-      assert_equal(pv_type, v1.private_vlan_type)
+      v1.pvlan_type = pv_type
+      assert_equal(pv_type, v1.pvlan_type)
       pv_type = 'community'
-      v1.private_vlan_type = pv_type
-      assert_equal(pv_type, v1.private_vlan_type)
+      v1.pvlan_type = pv_type
+      assert_equal(pv_type, v1.pvlan_type)
     end
   end
 
-  def test_private_vlan_isolate_association
+  def test_isolate_association
     vlan_list = %w(100 101)
     result = ['101']
     v1 = Vlan.new(vlan_list[0])
     v2 = Vlan.new(vlan_list[1])
     pv_type = 'primary'
-    if validate_property_excluded?('vlan', 'private_vlan_type')
-      assert_nil(v1.private_vlan_type)
+    if validate_property_excluded?('vlan', 'pvlan_type')
+      assert_nil(v1.pvlan_type)
       assert_raises(Cisco::UnsupportedError) do
-        v1.private_vlan_type = pv_type
+        v1.pvlan_type = pv_type
       end
       return
     else
-      v1.private_vlan_type = pv_type
-      assert_equal(pv_type, v1.private_vlan_type)
+      v1.pvlan_type = pv_type
+      assert_equal(pv_type, v1.pvlan_type)
       pv_type = 'isolated'
-      v2.private_vlan_type = pv_type
-      assert_equal(pv_type, v2.private_vlan_type)
+      v2.pvlan_type = pv_type
+      assert_equal(pv_type, v2.pvlan_type)
 
-      v1.private_vlan_association = ['101']
+      v1.pvlan_association = ['101']
 
-      assert_equal(result, v1.private_vlan_association)
+      assert_equal(result, v1.pvlan_association)
     end
   end
 
-  def test_private_vlan_community_association
+  def test_community_association
     vlan_list = %w(100 101)
     result = ['101']
     v1 = Vlan.new(vlan_list[0])
     v2 = Vlan.new(vlan_list[1])
     pv_type = 'primary'
-    if validate_property_excluded?('vlan', 'private_vlan_type')
-      assert_nil(v1.private_vlan_type)
+    if validate_property_excluded?('vlan', 'pvlan_type')
+      assert_nil(v1.pvlan_type)
       assert_raises(Cisco::UnsupportedError) do
-        v1.private_vlan_type = pv_type
+        v1.pvlan_type = pv_type
       end
       return
     else
-      v1.private_vlan_type = pv_type
-      assert_equal(pv_type, v1.private_vlan_type)
+      v1.pvlan_type = pv_type
+      assert_equal(pv_type, v1.pvlan_type)
       pv_type = 'community'
-      v2.private_vlan_type = pv_type
-      assert_equal(pv_type, v2.private_vlan_type)
+      v2.pvlan_type = pv_type
+      assert_equal(pv_type, v2.pvlan_type)
 
-      v1.private_vlan_association = ['101']
+      v1.pvlan_association = ['101']
 
-      assert_equal(result, v1.private_vlan_association)
+      assert_equal(result, v1.pvlan_association)
     end
   end
 
-  def test_private_vlan_association_failure
+  def test_association_failure
     vlan_list = %w(100 101 200)
     result = %w(101 200)
     v1 = Vlan.new(vlan_list[0])
     v2 = Vlan.new(vlan_list[1])
     v3 = Vlan.new(vlan_list[2])
     pv_type = 'primary'
-    if validate_property_excluded?('vlan', 'private_vlan_type')
-      assert_nil(v1.private_vlan_type)
+    if validate_property_excluded?('vlan', 'pvlan_type')
+      assert_nil(v1.pvlan_type)
       assert_raises(Cisco::UnsupportedError) do
-        v1.private_vlan_type = pv_type
+        v1.pvlan_type = pv_type
       end
       return
     else
-      v1.private_vlan_type = pv_type
-      assert_equal(pv_type, v1.private_vlan_type)
+      v1.pvlan_type = pv_type
+      assert_equal(pv_type, v1.pvlan_type)
       pv_type = 'isolated'
-      v2.private_vlan_type = pv_type
-      assert_equal(pv_type, v2.private_vlan_type)
+      v2.pvlan_type = pv_type
+      assert_equal(pv_type, v2.pvlan_type)
       pv_type = 'community'
-      v3.private_vlan_type = pv_type
-      assert_equal(pv_type, v3.private_vlan_type)
+      v3.pvlan_type = pv_type
+      assert_equal(pv_type, v3.pvlan_type)
 
-      v1.private_vlan_association = %w(101 200)
+      v1.pvlan_association = %w(101 200)
 
-      assert_equal(result, v1.private_vlan_association)
+      assert_equal(result, v1.pvlan_association)
 
       pv_type = 'isolated'
       assert_raises(RuntimeError, 'vlan misconf did not raise RuntimeError') do
-        v3.private_vlan_type = pv_type
+        v3.pvlan_type = pv_type
       end
 
-      assert_equal(result, v1.private_vlan_association)
+      assert_equal(result, v1.pvlan_association)
 
     end
   end
 
-  def test_private_vlan_association_operational_and_not_operational
+  def test_association_ops
     vlan_list = %w(100 101 200)
     result = %w(101 200)
 
@@ -403,109 +398,109 @@ class TestVlan < CiscoTestCase
     v2 = Vlan.new(vlan_list[1])
 
     pv_type = 'primary'
-    if validate_property_excluded?('vlan', 'private_vlan_type')
-      assert_nil(v1.private_vlan_type)
+    if validate_property_excluded?('vlan', 'pvlan_type')
+      assert_nil(v1.pvlan_type)
       assert_raises(Cisco::UnsupportedError) do
-        v1.private_vlan_type = pv_type
+        v1.pvlan_type = pv_type
       end
       return
     else
-      v1.private_vlan_type = pv_type
-      assert_equal(pv_type, v1.private_vlan_type)
+      v1.pvlan_type = pv_type
+      assert_equal(pv_type, v1.pvlan_type)
 
       pv_type = 'isolated'
-      v2.private_vlan_type = pv_type
-      assert_equal(pv_type, v2.private_vlan_type)
+      v2.pvlan_type = pv_type
+      assert_equal(pv_type, v2.pvlan_type)
 
-      v1.private_vlan_association = %w(101 200)
+      v1.pvlan_association = %w(101 200)
 
-      assert_equal(result, v1.private_vlan_association)
+      assert_equal(result, v1.pvlan_association)
     end
   end
 
-  def test_private_vlan_association_vlan_not_configured
+  def test_association_vlan_not_configured
     vlan_list = %w(100 101 200)
     result = %w(101 200)
     v1 = Vlan.new(vlan_list[0])
     v2 = Vlan.new(vlan_list[1])
     pv_type = 'primary'
-    if validate_property_excluded?('vlan', 'private_vlan_type')
-      assert_nil(v1.private_vlan_type)
+    if validate_property_excluded?('vlan', 'pvlan_type')
+      assert_nil(v1.pvlan_type)
       assert_raises(Cisco::UnsupportedError) do
-        v1.private_vlan_type = pv_type
+        v1.pvlan_type = pv_type
       end
       return
     else
-      v1.private_vlan_type = pv_type
-      assert_equal(pv_type, v1.private_vlan_type)
+      v1.pvlan_type = pv_type
+      assert_equal(pv_type, v1.pvlan_type)
       pv_type = 'isolated'
-      v2.private_vlan_type = pv_type
-      assert_equal(pv_type, v2.private_vlan_type)
+      v2.pvlan_type = pv_type
+      assert_equal(pv_type, v2.pvlan_type)
 
-      v1.private_vlan_association = %w(101 200)
-      assert_equal(result, v1.private_vlan_association)
+      v1.pvlan_association = %w(101 200)
+      assert_equal(result, v1.pvlan_association)
     end
   end
 
-  def test_private_vlan_association_add_vlan
+  def test_association_add_vlan
     vlan_list = %w(100 101)
     result = ['101']
     v1 = Vlan.new(vlan_list[0])
     v2 = Vlan.new(vlan_list[1])
     pv_type = 'primary'
-    if validate_property_excluded?('vlan', 'private_vlan_type')
-      assert_nil(v1.private_vlan_type)
+    if validate_property_excluded?('vlan', 'pvlan_type')
+      assert_nil(v1.pvlan_type)
       assert_raises(Cisco::UnsupportedError) do
-        v1.private_vlan_type = pv_type
+        v1.pvlan_type = pv_type
       end
       return
     else
-      v1.private_vlan_type = pv_type
-      assert_equal(pv_type, v1.private_vlan_type)
+      v1.pvlan_type = pv_type
+      assert_equal(pv_type, v1.pvlan_type)
       pv_type = 'isolated'
-      v2.private_vlan_type = pv_type
-      assert_equal(pv_type, v2.private_vlan_type)
+      v2.pvlan_type = pv_type
+      assert_equal(pv_type, v2.pvlan_type)
 
-      v1.private_vlan_association = ['101']
-      assert_equal(result, v1.private_vlan_association)
+      v1.pvlan_association = ['101']
+      assert_equal(result, v1.pvlan_association)
     end
   end
 
-  def test_private_vlan_association_remove_vlan
+  def test_association_remove_vlan
     vlan_list = %w(100 101 200)
     result = %w(101 200)
     v1 = Vlan.new(vlan_list[0])
     v2 = Vlan.new(vlan_list[1])
     v3 = Vlan.new(vlan_list[2])
     pv_type = 'primary'
-    if validate_property_excluded?('vlan', 'private_vlan_type')
-      assert_nil(v1.private_vlan_type)
+    if validate_property_excluded?('vlan', 'pvlan_type')
+      assert_nil(v1.pvlan_type)
       assert_raises(Cisco::UnsupportedError) do
-        v1.private_vlan_type = pv_type
+        v1.pvlan_type = pv_type
       end
       return
     else
-      v1.private_vlan_type = pv_type
-      assert_equal(pv_type, v1.private_vlan_type)
+      v1.pvlan_type = pv_type
+      assert_equal(pv_type, v1.pvlan_type)
       pv_type = 'isolated'
-      v2.private_vlan_type = pv_type
-      assert_equal(pv_type, v2.private_vlan_type)
+      v2.pvlan_type = pv_type
+      assert_equal(pv_type, v2.pvlan_type)
 
       pv_type = 'community'
-      v3.private_vlan_type = pv_type
-      assert_equal(pv_type, v3.private_vlan_type)
+      v3.pvlan_type = pv_type
+      assert_equal(pv_type, v3.pvlan_type)
 
-      v1.private_vlan_association = %w(101 200)
-      assert_equal(result, v1.private_vlan_association)
+      v1.pvlan_association = %w(101 200)
+      assert_equal(result, v1.pvlan_association)
 
-      # v1.private_vlan_association_remove_vlans = '101'
+      # v1.pvlan_association_remove_vlans = '101'
       # result = '200'
       # assert_equal(result, vlan_list(v1))
 
     end
   end
 
-  def test_no_private_vlan_association
+  def test_no_pvlan_association
     vlan_list = %w(100 101 200)
     result = %w(101 200)
     v1 = Vlan.new(vlan_list[0])
@@ -513,35 +508,35 @@ class TestVlan < CiscoTestCase
     v3 = Vlan.new(vlan_list[2])
 
     pv_type = 'primary'
-    if validate_property_excluded?('vlan', 'private_vlan_type')
-      assert_nil(v1.private_vlan_type)
+    if validate_property_excluded?('vlan', 'pvlan_type')
+      assert_nil(v1.pvlan_type)
       assert_raises(Cisco::UnsupportedError) do
-        v1.private_vlan_type = pv_type
+        v1.pvlan_type = pv_type
       end
       return
     else
-      v1.private_vlan_type = pv_type
-      assert_equal(pv_type, v1.private_vlan_type)
+      v1.pvlan_type = pv_type
+      assert_equal(pv_type, v1.pvlan_type)
 
       pv_type = 'isolated'
-      v2.private_vlan_type = pv_type
-      assert_equal(pv_type, v2.private_vlan_type)
+      v2.pvlan_type = pv_type
+      assert_equal(pv_type, v2.pvlan_type)
 
       pv_type = 'community'
-      v3.private_vlan_type = pv_type
-      assert_equal(pv_type, v3.private_vlan_type)
+      v3.pvlan_type = pv_type
+      assert_equal(pv_type, v3.pvlan_type)
 
-      v1.private_vlan_association = %w(101 200)
-      assert_equal(result, v1.private_vlan_association)
+      v1.pvlan_association = %w(101 200)
+      assert_equal(result, v1.pvlan_association)
 
-      v1.private_vlan_association = ['200']
+      v1.pvlan_association = ['200']
       result = ['200']
-      assert_equal(result, v1.private_vlan_association)
+      assert_equal(result, v1.pvlan_association)
 
     end
   end
 
-  def test_no_private_vlan_association_all
+  def test_no_pvlan_association_all
     vlan_list = %w(100 101 200)
     result = %w(101 200)
     v1 = Vlan.new(vlan_list[0])
@@ -549,121 +544,113 @@ class TestVlan < CiscoTestCase
     v3 = Vlan.new(vlan_list[2])
 
     pv_type = 'primary'
-    if validate_property_excluded?('vlan', 'private_vlan_type')
-      assert_nil(v1.private_vlan_type)
+    if validate_property_excluded?('vlan', 'pvlan_type')
+      assert_nil(v1.pvlan_type)
       assert_raises(Cisco::UnsupportedError) do
-        v1.private_vlan_type = pv_type
+        v1.pvlan_type = pv_type
       end
       return
     else
-      v1.private_vlan_type = pv_type
-      assert_equal(pv_type, v1.private_vlan_type)
+      v1.pvlan_type = pv_type
+      assert_equal(pv_type, v1.pvlan_type)
 
       pv_type = 'isolated'
-      v2.private_vlan_type = pv_type
-      assert_equal(pv_type, v2.private_vlan_type)
+      v2.pvlan_type = pv_type
+      assert_equal(pv_type, v2.pvlan_type)
 
       pv_type = 'community'
-      v3.private_vlan_type = pv_type
-      assert_equal(pv_type, v3.private_vlan_type)
+      v3.pvlan_type = pv_type
+      assert_equal(pv_type, v3.pvlan_type)
 
-      v1.private_vlan_association = %w(101 200)
-      assert_equal(result, v1.private_vlan_association)
-      v1.private_vlan_association = []
+      v1.pvlan_association = %w(101 200)
+      assert_equal(result, v1.pvlan_association)
+      v1.pvlan_association = []
       result = []
-      assert_equal(result, v1.private_vlan_association)
+      assert_equal(result, v1.pvlan_association)
 
     end
   end
 
-  def test_private_vlan_isolate_community_association
+  def test_isolate_community_association
     vlan_list = %w(100 101 200)
     result = %w(101 200)
     v1 = Vlan.new(vlan_list[0])
     v2 = Vlan.new(vlan_list[1])
     v3 = Vlan.new(vlan_list[2])
     pv_type = 'primary'
-    if validate_property_excluded?('vlan', 'private_vlan_type')
-      assert_nil(v1.private_vlan_type)
+    if validate_property_excluded?('vlan', 'pvlan_type')
+      assert_nil(v1.pvlan_type)
       assert_raises(Cisco::UnsupportedError) do
-        v1.private_vlan_type = pv_type
+        v1.pvlan_type = pv_type
       end
       return
     else
-      v1.private_vlan_type = pv_type
-      assert_equal(pv_type, v1.private_vlan_type)
+      v1.pvlan_type = pv_type
+      assert_equal(pv_type, v1.pvlan_type)
       pv_type = 'isolated'
-      v2.private_vlan_type = pv_type
-      assert_equal(pv_type, v2.private_vlan_type)
+      v2.pvlan_type = pv_type
+      assert_equal(pv_type, v2.pvlan_type)
       pv_type = 'community'
-      v3.private_vlan_type = pv_type
-      assert_equal(pv_type, v3.private_vlan_type)
+      v3.pvlan_type = pv_type
+      assert_equal(pv_type, v3.pvlan_type)
 
-      v1.private_vlan_association = %w(101 200)
+      v1.pvlan_association = %w(101 200)
 
-      assert_equal(result, v1.private_vlan_association)
+      assert_equal(result, v1.pvlan_association)
     end
   end
 
-  def test_private_vlan_multi_isolate_community_association
+  def test_multi_isolate_community_association
     vlan_list = %w(100 101 102 104 105 200 201 202)
-    result = %w(101 104 105 200 202)
     v1 = Vlan.new(vlan_list[0])
 
     pv_type = 'primary'
-    if validate_property_excluded?('vlan', 'private_vlan_type')
-      assert_nil(v1.private_vlan_type)
-      assert_raises(Cisco::UnsupportedError) do
-        v1.private_vlan_type = pv_type
-      end
+    if validate_property_excluded?('vlan', 'pvlan_type')
+      assert_nil(v1.pvlan_type)
+      assert_raises(Cisco::UnsupportedError) { v1.pvlan_type = pv_type }
       return
-    else
-      v2 = Vlan.new(vlan_list[1])
-      v3 = Vlan.new(vlan_list[2])
-      v4 = Vlan.new(vlan_list[3])
-      v5 = Vlan.new(vlan_list[4])
-      v6 = Vlan.new(vlan_list[5])
-      v7 = Vlan.new(vlan_list[6])
-
-      v1.private_vlan_type = pv_type
-      assert_equal(pv_type, v1.private_vlan_type)
-
-      pv_type = 'isolated'
-      v2.private_vlan_type = pv_type
-      assert_equal(pv_type, v2.private_vlan_type)
+    end
 
-      pv_type = 'isolated'
-      v3.private_vlan_type = pv_type
-      assert_equal(pv_type, v3.private_vlan_type)
+    v2 = Vlan.new(vlan_list[1])
+    v3 = Vlan.new(vlan_list[2])
+    v4 = Vlan.new(vlan_list[3])
+    v5 = Vlan.new(vlan_list[4])
+    v6 = Vlan.new(vlan_list[5])
+    v7 = Vlan.new(vlan_list[6])
 
-      pv_type = 'community'
-      v4.private_vlan_type = pv_type
-      assert_equal(pv_type, v4.private_vlan_type)
+    v1.pvlan_type = pv_type
+    assert_equal(pv_type, v1.pvlan_type)
 
-      pv_type = 'community'
-      v5.private_vlan_type = pv_type
-      assert_equal(pv_type, v5.private_vlan_type)
+    pv_type = 'isolated'
+    v2.pvlan_type = pv_type
+    assert_equal(pv_type, v2.pvlan_type)
 
-      pv_type = 'community'
-      v6.private_vlan_type = pv_type
-      assert_equal(pv_type, v6.private_vlan_type)
+    pv_type = 'isolated'
+    v3.pvlan_type = pv_type
+    assert_equal(pv_type, v3.pvlan_type)
 
-      pv_type = 'primary'
-      v7.private_vlan_type = pv_type
-      assert_equal(pv_type, v7.private_vlan_type)
+    pv_type = 'community'
+    v4.pvlan_type = pv_type
+    assert_equal(pv_type, v4.pvlan_type)
 
-      v1.private_vlan_association = ['101', '104-105', '200', '202']
+    pv_type = 'community'
+    v5.pvlan_type = pv_type
+    assert_equal(pv_type, v5.pvlan_type)
 
-      assert_equal(result, v1.private_vlan_association)
+    pv_type = 'community'
+    v6.pvlan_type = pv_type
+    assert_equal(pv_type, v6.pvlan_type)
 
-      v1.private_vlan_association = ['101', '103-105', '108']
+    pv_type = 'primary'
+    v7.pvlan_type = pv_type
+    assert_equal(pv_type, v7.pvlan_type)
 
-      result = %w(101 103 104 105 108)
-      assert_equal(result, v1.private_vlan_association)
+    v1.pvlan_association = %w(101 104 105 200 202)
+    result = %w(101 104-105 200 202)
+    assert_equal(result, v1.pvlan_association)
 
-      v1.private_vlan_association = ['101', '103-105', '108']
-      result = %w(101 103 104 105 108)
-      assert_equal(result, v1.private_vlan_association)
-    end
+    v1.pvlan_association = %w(101 103 104-105 108)
+    result = %w(101 103-105 108)
+    assert_equal(result, v1.pvlan_association)
   end
 end