diff --git a/vsphere/data_source_vsphere_custom_attribute_test.go b/vsphere/data_source_vsphere_custom_attribute_test.go
index d7ee2d4f2..1d5869d9a 100644
--- a/vsphere/data_source_vsphere_custom_attribute_test.go
+++ b/vsphere/data_source_vsphere_custom_attribute_test.go
@@ -7,50 +7,34 @@ import (
 	"github.com/hashicorp/terraform/helper/resource"
 )
 
-func TestAccDataSourceVSphereCustomAttribute(t *testing.T) {
-	var tp *testing.T
-	testAccDataSourceVSphereCustomAttributeCases := []struct {
-		name     string
-		testCase resource.TestCase
-	}{
-		{
-			"basic",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-				},
-				Providers: testAccProviders,
-				Steps: []resource.TestStep{
-					{
-						Config: testAccDataSourceVSphereCustomAttributeConfig(),
-						Check: resource.ComposeTestCheckFunc(
-							resource.TestCheckResourceAttr(
-								"data.vsphere_custom_attribute.terraform-test-attribute-data",
-								"name",
-								testAccDataSourceVSphereCustomAttributeConfigName,
-							),
-							resource.TestCheckResourceAttr(
-								"data.vsphere_custom_attribute.terraform-test-attribute-data",
-								"managed_object_type",
-								testAccDataSourceVSphereCustomAttributeConfigType,
-							),
-							resource.TestCheckResourceAttrPair(
-								"data.vsphere_custom_attribute.terraform-test-attribute-data", "id",
-								"vsphere_custom_attribute.terraform-test-attribute", "id",
-							),
-						),
-					},
-				},
+func TestAccDataSourceVSphereCustomAttribute_basic(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+		},
+		Providers: testAccProviders,
+		Steps: []resource.TestStep{
+			{
+				Config: testAccDataSourceVSphereCustomAttributeConfig(),
+				Check: resource.ComposeTestCheckFunc(
+					resource.TestCheckResourceAttr(
+						"data.vsphere_custom_attribute.terraform-test-attribute-data",
+						"name",
+						testAccDataSourceVSphereCustomAttributeConfigName,
+					),
+					resource.TestCheckResourceAttr(
+						"data.vsphere_custom_attribute.terraform-test-attribute-data",
+						"managed_object_type",
+						testAccDataSourceVSphereCustomAttributeConfigType,
+					),
+					resource.TestCheckResourceAttrPair(
+						"data.vsphere_custom_attribute.terraform-test-attribute-data", "id",
+						"vsphere_custom_attribute.terraform-test-attribute", "id",
+					),
+				),
 			},
 		},
-	}
-
-	for _, tc := range testAccDataSourceVSphereCustomAttributeCases {
-		t.Run(tc.name, func(t *testing.T) {
-			tp = t
-			resource.Test(t, tc.testCase)
-		})
-	}
+	})
 }
 
 const testAccDataSourceVSphereCustomAttributeConfigName = "terraform-test-attribute"
diff --git a/vsphere/data_source_vsphere_datacenter_test.go b/vsphere/data_source_vsphere_datacenter_test.go
index b57921b75..967849a46 100644
--- a/vsphere/data_source_vsphere_datacenter_test.go
+++ b/vsphere/data_source_vsphere_datacenter_test.go
@@ -11,64 +11,48 @@ import (
 
 var testAccDataSourceVSphereDatacenterExpectedRegexp = regexp.MustCompile("^datacenter-")
 
-func TestAccDataSourceVSphereDatacenter(t *testing.T) {
-	var tp *testing.T
-	testAccDataSourceVSphereDatacenterCases := []struct {
-		name     string
-		testCase resource.TestCase
-	}{
-		{
-			"basic",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccDataSourceVSphereDatacenterPreCheck(tp)
-				},
-				Providers: testAccProviders,
-				Steps: []resource.TestStep{
-					{
-						Config: testAccDataSourceVSphereDatacenterConfig(),
-						Check: resource.ComposeTestCheckFunc(
-							resource.TestMatchResourceAttr(
-								"data.vsphere_datacenter.dc",
-								"id",
-								testAccDataSourceVSphereDatacenterExpectedRegexp,
-							),
-						),
-					},
-				},
-			},
+func TestAccDataSourceVSphereDatacenter_basic(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccDataSourceVSphereDatacenterPreCheck(t)
 		},
-		{
-			"default",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccDataSourceVSphereDatacenterPreCheck(tp)
-				},
-				Providers: testAccProviders,
-				Steps: []resource.TestStep{
-					{
-						Config: testAccDataSourceVSphereDatacenterConfigDefault,
-						Check: resource.ComposeTestCheckFunc(
-							resource.TestMatchResourceAttr(
-								"data.vsphere_datacenter.dc",
-								"id",
-								testAccDataSourceVSphereDatacenterExpectedRegexp,
-							),
-						),
-					},
-				},
+		Providers: testAccProviders,
+		Steps: []resource.TestStep{
+			{
+				Config: testAccDataSourceVSphereDatacenterConfig(),
+				Check: resource.ComposeTestCheckFunc(
+					resource.TestMatchResourceAttr(
+						"data.vsphere_datacenter.dc",
+						"id",
+						testAccDataSourceVSphereDatacenterExpectedRegexp,
+					),
+				),
 			},
 		},
-	}
+	})
+}
 
-	for _, tc := range testAccDataSourceVSphereDatacenterCases {
-		t.Run(tc.name, func(t *testing.T) {
-			tp = t
-			resource.Test(t, tc.testCase)
-		})
-	}
+func TestAccDataSourceVSphereDatacenter_defaultDatacenter(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccDataSourceVSphereDatacenterPreCheck(t)
+		},
+		Providers: testAccProviders,
+		Steps: []resource.TestStep{
+			{
+				Config: testAccDataSourceVSphereDatacenterConfigDefault,
+				Check: resource.ComposeTestCheckFunc(
+					resource.TestMatchResourceAttr(
+						"data.vsphere_datacenter.dc",
+						"id",
+						testAccDataSourceVSphereDatacenterExpectedRegexp,
+					),
+				),
+			},
+		},
+	})
 }
 
 func testAccDataSourceVSphereDatacenterPreCheck(t *testing.T) {
diff --git a/vsphere/data_source_vsphere_datastore_test.go b/vsphere/data_source_vsphere_datastore_test.go
index 52ee9d9f5..8d90586a7 100644
--- a/vsphere/data_source_vsphere_datastore_test.go
+++ b/vsphere/data_source_vsphere_datastore_test.go
@@ -8,62 +8,46 @@ import (
 	"github.com/hashicorp/terraform/helper/resource"
 )
 
-func TestAccDataSourceVSphereDatastore(t *testing.T) {
-	var tp *testing.T
-	testAccDataSourceVSphereDatastoreCases := []struct {
-		name     string
-		testCase resource.TestCase
-	}{
-		{
-			"basic",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccDataSourceVSphereDatastorePreCheck(tp)
-				},
-				Providers: testAccProviders,
-				Steps: []resource.TestStep{
-					{
-						Config: testAccDataSourceVSphereDatastoreConfig(),
-						Check: resource.ComposeTestCheckFunc(
-							resource.TestCheckResourceAttrPair(
-								"data.vsphere_datastore.datastore_data", "id",
-								"vsphere_nas_datastore.datastore", "id",
-							),
-						),
-					},
-				},
-			},
+func TestAccDataSourceVSphereDatastore_basic(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccDataSourceVSphereDatastorePreCheck(t)
 		},
-		{
-			"no datacenter and absolute path",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccDataSourceVSphereDatastorePreCheck(tp)
-				},
-				Providers: testAccProviders,
-				Steps: []resource.TestStep{
-					{
-						Config: testAccDataSourceVSphereDatastoreConfigAbsolutePath(),
-						Check: resource.ComposeTestCheckFunc(
-							resource.TestCheckResourceAttrPair(
-								"data.vsphere_datastore.datastore_data", "id",
-								"vsphere_nas_datastore.datastore", "id",
-							),
-						),
-					},
-				},
+		Providers: testAccProviders,
+		Steps: []resource.TestStep{
+			{
+				Config: testAccDataSourceVSphereDatastoreConfig(),
+				Check: resource.ComposeTestCheckFunc(
+					resource.TestCheckResourceAttrPair(
+						"data.vsphere_datastore.datastore_data", "id",
+						"vsphere_nas_datastore.datastore", "id",
+					),
+				),
 			},
 		},
-	}
+	})
+}
 
-	for _, tc := range testAccDataSourceVSphereDatastoreCases {
-		t.Run(tc.name, func(t *testing.T) {
-			tp = t
-			resource.Test(t, tc.testCase)
-		})
-	}
+func TestAccDataSourceVSphereDatastore_noDatacenterAndAbsolutePath(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccDataSourceVSphereDatastorePreCheck(t)
+		},
+		Providers: testAccProviders,
+		Steps: []resource.TestStep{
+			{
+				Config: testAccDataSourceVSphereDatastoreConfigAbsolutePath(),
+				Check: resource.ComposeTestCheckFunc(
+					resource.TestCheckResourceAttrPair(
+						"data.vsphere_datastore.datastore_data", "id",
+						"vsphere_nas_datastore.datastore", "id",
+					),
+				),
+			},
+		},
+	})
 }
 
 func testAccDataSourceVSphereDatastorePreCheck(t *testing.T) {
diff --git a/vsphere/data_source_vsphere_distributed_virtual_switch_test.go b/vsphere/data_source_vsphere_distributed_virtual_switch_test.go
index 3e2ad5c3e..2c736cd26 100644
--- a/vsphere/data_source_vsphere_distributed_virtual_switch_test.go
+++ b/vsphere/data_source_vsphere_distributed_virtual_switch_test.go
@@ -8,126 +8,110 @@ import (
 	"github.com/hashicorp/terraform/helper/resource"
 )
 
-func TestAccDataSourceVSphereDistributedVirtualSwitch(t *testing.T) {
-	var tp *testing.T
-	testAccDataSourceVSphereDistributedVirtualSwitchCases := []struct {
-		name     string
-		testCase resource.TestCase
-	}{
-		{
-			"basic",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-				},
-				Providers: testAccProviders,
-				Steps: []resource.TestStep{
-					{
-						Config: testAccDataSourceVSphereDistributedVirtualSwitchConfig(),
-						Check: resource.ComposeTestCheckFunc(
-							resource.TestCheckResourceAttr(
-								"data.vsphere_distributed_virtual_switch.dvs-data",
-								"uplinks.#",
-								"2",
-							),
-							resource.TestCheckResourceAttr(
-								"data.vsphere_distributed_virtual_switch.dvs-data",
-								"uplinks.0",
-								"tfup1",
-							),
-							resource.TestCheckResourceAttr(
-								"data.vsphere_distributed_virtual_switch.dvs-data",
-								"uplinks.1",
-								"tfup2",
-							),
-							resource.TestCheckResourceAttrPair(
-								"data.vsphere_distributed_virtual_switch.dvs-data", "id",
-								"vsphere_distributed_virtual_switch.dvs", "id",
-							),
-						),
-					},
-				},
+func TestAccDataSourceVSphereDistributedVirtualSwitch_basic(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+		},
+		Providers: testAccProviders,
+		Steps: []resource.TestStep{
+			{
+				Config: testAccDataSourceVSphereDistributedVirtualSwitchConfig(),
+				Check: resource.ComposeTestCheckFunc(
+					resource.TestCheckResourceAttr(
+						"data.vsphere_distributed_virtual_switch.dvs-data",
+						"uplinks.#",
+						"2",
+					),
+					resource.TestCheckResourceAttr(
+						"data.vsphere_distributed_virtual_switch.dvs-data",
+						"uplinks.0",
+						"tfup1",
+					),
+					resource.TestCheckResourceAttr(
+						"data.vsphere_distributed_virtual_switch.dvs-data",
+						"uplinks.1",
+						"tfup2",
+					),
+					resource.TestCheckResourceAttrPair(
+						"data.vsphere_distributed_virtual_switch.dvs-data", "id",
+						"vsphere_distributed_virtual_switch.dvs", "id",
+					),
+				),
 			},
 		},
-		{
-			"absolute path - no datacenter specified",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-				},
-				Providers: testAccProviders,
-				Steps: []resource.TestStep{
-					{
-						Config: testAccDataSourceVSphereDistributedVirtualSwitchConfigAbsolute(),
-						Check: resource.ComposeTestCheckFunc(
-							resource.TestCheckResourceAttr(
-								"data.vsphere_distributed_virtual_switch.dvs-data",
-								"uplinks.#",
-								"2",
-							),
-							resource.TestCheckResourceAttr(
-								"data.vsphere_distributed_virtual_switch.dvs-data",
-								"uplinks.0",
-								"tfup1",
-							),
-							resource.TestCheckResourceAttr(
-								"data.vsphere_distributed_virtual_switch.dvs-data",
-								"uplinks.1",
-								"tfup2",
-							),
-							resource.TestCheckResourceAttrPair(
-								"data.vsphere_distributed_virtual_switch.dvs-data", "id",
-								"vsphere_distributed_virtual_switch.dvs", "id",
-							),
-						),
-					},
-				},
+	})
+}
+
+func TestAccDataSourceVSphereDistributedVirtualSwitch_absolutePathNoDatacenterSpecified(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+		},
+		Providers: testAccProviders,
+		Steps: []resource.TestStep{
+			{
+				Config: testAccDataSourceVSphereDistributedVirtualSwitchConfigAbsolute(),
+				Check: resource.ComposeTestCheckFunc(
+					resource.TestCheckResourceAttr(
+						"data.vsphere_distributed_virtual_switch.dvs-data",
+						"uplinks.#",
+						"2",
+					),
+					resource.TestCheckResourceAttr(
+						"data.vsphere_distributed_virtual_switch.dvs-data",
+						"uplinks.0",
+						"tfup1",
+					),
+					resource.TestCheckResourceAttr(
+						"data.vsphere_distributed_virtual_switch.dvs-data",
+						"uplinks.1",
+						"tfup2",
+					),
+					resource.TestCheckResourceAttrPair(
+						"data.vsphere_distributed_virtual_switch.dvs-data", "id",
+						"vsphere_distributed_virtual_switch.dvs", "id",
+					),
+				),
 			},
 		},
-		{
-			"create portgroup",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-				},
-				Providers: testAccProviders,
-				Steps: []resource.TestStep{
-					{
-						Config: testAccDataSourceVSphereDistributedVirtualSwitchConfigWithPortgroup(),
-						Check: resource.ComposeTestCheckFunc(
-							resource.TestCheckResourceAttr(
-								"vsphere_distributed_port_group.pg",
-								"active_uplinks.#",
-								"1",
-							),
-							resource.TestCheckResourceAttr(
-								"vsphere_distributed_port_group.pg",
-								"standby_uplinks.#",
-								"1",
-							),
-							resource.TestCheckResourceAttr(
-								"vsphere_distributed_port_group.pg",
-								"active_uplinks.0",
-								"tfup1",
-							),
-							resource.TestCheckResourceAttr(
-								"vsphere_distributed_port_group.pg",
-								"standby_uplinks.0",
-								"tfup2",
-							),
-						),
-					},
-				},
+	})
+}
+
+func TestAccDataSourceVSphereDistributedVirtualSwitch_CreatePortgroup(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+		},
+		Providers: testAccProviders,
+		Steps: []resource.TestStep{
+			{
+				Config: testAccDataSourceVSphereDistributedVirtualSwitchConfigWithPortgroup(),
+				Check: resource.ComposeTestCheckFunc(
+					resource.TestCheckResourceAttr(
+						"vsphere_distributed_port_group.pg",
+						"active_uplinks.#",
+						"1",
+					),
+					resource.TestCheckResourceAttr(
+						"vsphere_distributed_port_group.pg",
+						"standby_uplinks.#",
+						"1",
+					),
+					resource.TestCheckResourceAttr(
+						"vsphere_distributed_port_group.pg",
+						"active_uplinks.0",
+						"tfup1",
+					),
+					resource.TestCheckResourceAttr(
+						"vsphere_distributed_port_group.pg",
+						"standby_uplinks.0",
+						"tfup2",
+					),
+				),
 			},
 		},
-	}
-
-	for _, tc := range testAccDataSourceVSphereDistributedVirtualSwitchCases {
-		t.Run(tc.name, func(t *testing.T) {
-			tp = t
-			resource.Test(t, tc.testCase)
-		})
-	}
+	})
 }
 
 func testAccDataSourceVSphereDistributedVirtualSwitchConfig() string {
diff --git a/vsphere/data_source_vsphere_host_test.go b/vsphere/data_source_vsphere_host_test.go
index 6a2b0ac25..9093802df 100644
--- a/vsphere/data_source_vsphere_host_test.go
+++ b/vsphere/data_source_vsphere_host_test.go
@@ -9,65 +9,49 @@ import (
 	"github.com/hashicorp/terraform/helper/resource"
 )
 
-func TestAccDataSourceVSphereHost(t *testing.T) {
-	var tp *testing.T
-	testAccDataSourceVSphereHostCases := []struct {
-		name     string
-		testCase resource.TestCase
-	}{
-		{
-			"basic",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccDataSourceVSphereHostPreCheck(tp)
-				},
-				Providers: testAccProviders,
-				Steps: []resource.TestStep{
-					{
-						Config: testAccDataSourceVSphereHostConfig(),
-						Check: resource.ComposeTestCheckFunc(
-							resource.TestMatchResourceAttr(
-								"data.vsphere_host.host",
-								"id",
-								testAccDataSourceVSphereHostExpectedRegexp(),
-							),
-						),
-					},
-				},
-			},
+func TestAccDataSourceVSphereHost_basic(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccDataSourceVSphereHostPreCheck(t)
 		},
-		{
-			"default",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccDataSourceVSphereHostPreCheck(tp)
-					testAccSkipIfNotEsxi(tp)
-				},
-				Providers: testAccProviders,
-				Steps: []resource.TestStep{
-					{
-						Config: testAccDataSourceVSphereHostConfigDefault,
-						Check: resource.ComposeTestCheckFunc(
-							resource.TestMatchResourceAttr(
-								"data.vsphere_host.host",
-								"id",
-								testAccDataSourceVSphereHostExpectedRegexp(),
-							),
-						),
-					},
-				},
+		Providers: testAccProviders,
+		Steps: []resource.TestStep{
+			{
+				Config: testAccDataSourceVSphereHostConfig(),
+				Check: resource.ComposeTestCheckFunc(
+					resource.TestMatchResourceAttr(
+						"data.vsphere_host.host",
+						"id",
+						testAccDataSourceVSphereHostExpectedRegexp(),
+					),
+				),
 			},
 		},
-	}
+	})
+}
 
-	for _, tc := range testAccDataSourceVSphereHostCases {
-		t.Run(tc.name, func(t *testing.T) {
-			tp = t
-			resource.Test(t, tc.testCase)
-		})
-	}
+func TestAccDataSourceVSphereHost_defaultHost(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccDataSourceVSphereHostPreCheck(t)
+			testAccSkipIfNotEsxi(t)
+		},
+		Providers: testAccProviders,
+		Steps: []resource.TestStep{
+			{
+				Config: testAccDataSourceVSphereHostConfigDefault,
+				Check: resource.ComposeTestCheckFunc(
+					resource.TestMatchResourceAttr(
+						"data.vsphere_host.host",
+						"id",
+						testAccDataSourceVSphereHostExpectedRegexp(),
+					),
+				),
+			},
+		},
+	})
 }
 
 func testAccDataSourceVSphereHostPreCheck(t *testing.T) {
diff --git a/vsphere/data_source_vsphere_network_test.go b/vsphere/data_source_vsphere_network_test.go
index 34c7b15b8..f62a67041 100644
--- a/vsphere/data_source_vsphere_network_test.go
+++ b/vsphere/data_source_vsphere_network_test.go
@@ -8,106 +8,90 @@ import (
 	"github.com/hashicorp/terraform/helper/resource"
 )
 
-func TestAccDataSourceVSphereNetwork(t *testing.T) {
-	var tp *testing.T
-	testAccDataSourceVSphereNetworkCases := []struct {
-		name     string
-		testCase resource.TestCase
-	}{
-		{
-			"DVS portgroup",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccDataSourceVSphereNetworkPreCheck(tp)
-					testAccSkipIfEsxi(tp)
-				},
-				Providers: testAccProviders,
-				Steps: []resource.TestStep{
-					{
-						Config: testAccDataSourceVSphereNetworkConfigDVSPortgroup(),
-						Check: resource.ComposeTestCheckFunc(
-							resource.TestCheckResourceAttr("data.vsphere_network.net", "type", "DistributedVirtualPortgroup"),
-							resource.TestCheckResourceAttrPair(
-								"data.vsphere_network.net", "id",
-								"vsphere_distributed_port_group.pg", "id",
-							),
-						),
-					},
-				},
-			},
+func TestAccDataSourceVSphereNetwork_dvsPortgroup(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccDataSourceVSphereNetworkPreCheck(t)
+			testAccSkipIfEsxi(t)
 		},
-		{
-			"absolute path - no datacenter",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccDataSourceVSphereNetworkPreCheck(tp)
-					testAccSkipIfEsxi(tp)
-				},
-				Providers: testAccProviders,
-				Steps: []resource.TestStep{
-					{
-						Config: testAccDataSourceVSphereNetworkConfigDVSPortgroupAbsolute(),
-						Check: resource.ComposeTestCheckFunc(
-							resource.TestCheckResourceAttr("data.vsphere_network.net", "type", "DistributedVirtualPortgroup"),
-							resource.TestCheckResourceAttrPair(
-								"data.vsphere_network.net", "id",
-								"vsphere_distributed_port_group.pg", "id",
-							),
-						),
-					},
-				},
+		Providers: testAccProviders,
+		Steps: []resource.TestStep{
+			{
+				Config: testAccDataSourceVSphereNetworkConfigDVSPortgroup(),
+				Check: resource.ComposeTestCheckFunc(
+					resource.TestCheckResourceAttr("data.vsphere_network.net", "type", "DistributedVirtualPortgroup"),
+					resource.TestCheckResourceAttrPair(
+						"data.vsphere_network.net", "id",
+						"vsphere_distributed_port_group.pg", "id",
+					),
+				),
 			},
 		},
-		{
-			"host portgroups",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccDataSourceVSphereNetworkPreCheck(tp)
-				},
-				Providers: testAccProviders,
-				Steps: []resource.TestStep{
-					{
-						Config: testAccDataSourceVSphereNetworkConfigHostPortgroup(),
-						Check: resource.ComposeTestCheckFunc(
-							resource.TestCheckResourceAttr("data.vsphere_network.net", "type", "Network"),
-						),
-					},
-				},
+	})
+}
+
+func TestAccDataSourceVSphereNetwork_absolutePathNoDatacenter(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccDataSourceVSphereNetworkPreCheck(t)
+			testAccSkipIfEsxi(t)
+		},
+		Providers: testAccProviders,
+		Steps: []resource.TestStep{
+			{
+				Config: testAccDataSourceVSphereNetworkConfigDVSPortgroupAbsolute(),
+				Check: resource.ComposeTestCheckFunc(
+					resource.TestCheckResourceAttr("data.vsphere_network.net", "type", "DistributedVirtualPortgroup"),
+					resource.TestCheckResourceAttrPair(
+						"data.vsphere_network.net", "id",
+						"vsphere_distributed_port_group.pg", "id",
+					),
+				),
 			},
 		},
-		{
-			"absolute path ending in the same name - govmomi #875",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccDataSourceVSphereNetworkPreCheck(tp)
-					testAccSkipIfEsxi(tp)
-				},
-				Providers: testAccProviders,
-				Steps: []resource.TestStep{
-					{
-						Config: testAccDataSourceVSphereNetworkConfigSimilarNet(),
-						Check: resource.ComposeTestCheckFunc(
-							resource.TestCheckResourceAttrPair(
-								"data.vsphere_network.net", "id",
-								"vsphere_distributed_port_group.pg1", "id",
-							),
-						),
-					},
-				},
+	})
+}
+
+func TestAccDataSourceVSphereNetwork_hostPortgroups(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccDataSourceVSphereNetworkPreCheck(t)
+		},
+		Providers: testAccProviders,
+		Steps: []resource.TestStep{
+			{
+				Config: testAccDataSourceVSphereNetworkConfigHostPortgroup(),
+				Check: resource.ComposeTestCheckFunc(
+					resource.TestCheckResourceAttr("data.vsphere_network.net", "type", "Network"),
+				),
 			},
 		},
-	}
+	})
+}
 
-	for _, tc := range testAccDataSourceVSphereNetworkCases {
-		t.Run(tc.name, func(t *testing.T) {
-			tp = t
-			resource.Test(t, tc.testCase)
-		})
-	}
+func TestAccDataSourceVSphereNetwork_absolutePathEndingInSameName(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccDataSourceVSphereNetworkPreCheck(t)
+			testAccSkipIfEsxi(t)
+		},
+		Providers: testAccProviders,
+		Steps: []resource.TestStep{
+			{
+				Config: testAccDataSourceVSphereNetworkConfigSimilarNet(),
+				Check: resource.ComposeTestCheckFunc(
+					resource.TestCheckResourceAttrPair(
+						"data.vsphere_network.net", "id",
+						"vsphere_distributed_port_group.pg1", "id",
+					),
+				),
+			},
+		},
+	})
 }
 
 func testAccDataSourceVSphereNetworkPreCheck(t *testing.T) {
diff --git a/vsphere/data_source_vsphere_resource_pool_test.go b/vsphere/data_source_vsphere_resource_pool_test.go
index 2d8eefd29..ea0c2c87a 100644
--- a/vsphere/data_source_vsphere_resource_pool_test.go
+++ b/vsphere/data_source_vsphere_resource_pool_test.go
@@ -9,99 +9,83 @@ import (
 	"github.com/hashicorp/terraform/helper/resource"
 )
 
-func TestAccDataSourceVSphereResourcePool(t *testing.T) {
-	var tp *testing.T
-	testAccDataSourceVSphereResourcePoolCases := []struct {
-		name     string
-		testCase resource.TestCase
-	}{
-		{
-			"basic",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccDataSourceVSphereResourcePoolPreCheck(tp)
-					testAccSkipIfEsxi(tp)
-				},
-				Providers: testAccProviders,
-				Steps: []resource.TestStep{
-					{
-						Config: testAccDataSourceVSphereResourcePoolConfig(),
-						Check: resource.ComposeTestCheckFunc(
-							resource.TestMatchResourceAttr("data.vsphere_resource_pool.pool", "id", regexp.MustCompile("^resgroup-")),
-						),
-					},
-				},
-			},
+func TestAccDataSourceVSphereResourcePool_basic(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccDataSourceVSphereResourcePoolPreCheck(t)
+			testAccSkipIfEsxi(t)
 		},
-		{
-			"no datacenter and absolute path",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccDataSourceVSphereResourcePoolPreCheck(tp)
-					testAccSkipIfEsxi(tp)
-				},
-				Providers: testAccProviders,
-				Steps: []resource.TestStep{
-					{
-						Config: testAccDataSourceVSphereResourcePoolConfigAbsolutePath(),
-						Check: resource.ComposeTestCheckFunc(
-							resource.TestMatchResourceAttr("data.vsphere_resource_pool.pool", "id", regexp.MustCompile("^resgroup-")),
-						),
-					},
-				},
+		Providers: testAccProviders,
+		Steps: []resource.TestStep{
+			{
+				Config: testAccDataSourceVSphereResourcePoolConfig(),
+				Check: resource.ComposeTestCheckFunc(
+					resource.TestMatchResourceAttr("data.vsphere_resource_pool.pool", "id", regexp.MustCompile("^resgroup-")),
+				),
 			},
 		},
-		{
-			"default resource pool for ESXi",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccDataSourceVSphereResourcePoolPreCheck(tp)
-					testAccSkipIfNotEsxi(tp)
-				},
-				Providers: testAccProviders,
-				Steps: []resource.TestStep{
-					{
-						Config: testAccDataSourceVSphereResourcePoolConfigDefault,
-						Check: resource.ComposeTestCheckFunc(
-							resource.TestMatchResourceAttr("data.vsphere_resource_pool.pool", "id", regexp.MustCompile("^ha-root-pool$")),
-						),
-					},
-				},
+	})
+}
+
+func TestAccDataSourceVSphereResourcePool_noDatacenterAndAbsolutePath(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccDataSourceVSphereResourcePoolPreCheck(t)
+			testAccSkipIfEsxi(t)
+		},
+		Providers: testAccProviders,
+		Steps: []resource.TestStep{
+			{
+				Config: testAccDataSourceVSphereResourcePoolConfigAbsolutePath(),
+				Check: resource.ComposeTestCheckFunc(
+					resource.TestMatchResourceAttr("data.vsphere_resource_pool.pool", "id", regexp.MustCompile("^resgroup-")),
+				),
 			},
 		},
-		{
-			"empty name on vCenter, should error",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccDataSourceVSphereResourcePoolPreCheck(tp)
-					testAccSkipIfEsxi(tp)
-				},
-				Providers: testAccProviders,
-				Steps: []resource.TestStep{
-					{
-						Config:      testAccDataSourceVSphereResourcePoolConfigDefault,
-						ExpectError: regexp.MustCompile("name cannot be empty when using vCenter"),
-						PlanOnly:    true,
-					},
-					{
-						Config: testAccResourceVSphereEmpty,
-						Check:  resource.ComposeTestCheckFunc(),
-					},
-				},
+	})
+}
+
+func TestAccDataSourceVSphereResourcePool_defaultResourcePoolForESXi(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccDataSourceVSphereResourcePoolPreCheck(t)
+			testAccSkipIfNotEsxi(t)
+		},
+		Providers: testAccProviders,
+		Steps: []resource.TestStep{
+			{
+				Config: testAccDataSourceVSphereResourcePoolConfigDefault,
+				Check: resource.ComposeTestCheckFunc(
+					resource.TestMatchResourceAttr("data.vsphere_resource_pool.pool", "id", regexp.MustCompile("^ha-root-pool$")),
+				),
 			},
 		},
-	}
+	})
+}
 
-	for _, tc := range testAccDataSourceVSphereResourcePoolCases {
-		t.Run(tc.name, func(t *testing.T) {
-			tp = t
-			resource.Test(t, tc.testCase)
-		})
-	}
+func TestAccDataSourceVSphereResourcePool_emptyNameOnVCenterShouldError(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccDataSourceVSphereResourcePoolPreCheck(t)
+			testAccSkipIfEsxi(t)
+		},
+		Providers: testAccProviders,
+		Steps: []resource.TestStep{
+			{
+				Config:      testAccDataSourceVSphereResourcePoolConfigDefault,
+				ExpectError: regexp.MustCompile("name cannot be empty when using vCenter"),
+				PlanOnly:    true,
+			},
+			{
+				Config: testAccResourceVSphereEmpty,
+				Check:  resource.ComposeTestCheckFunc(),
+			},
+		},
+	})
 }
 
 func testAccDataSourceVSphereResourcePoolPreCheck(t *testing.T) {
diff --git a/vsphere/data_source_vsphere_tag_category_test.go b/vsphere/data_source_vsphere_tag_category_test.go
index 1d98d3629..a9796a09a 100644
--- a/vsphere/data_source_vsphere_tag_category_test.go
+++ b/vsphere/data_source_vsphere_tag_category_test.go
@@ -7,65 +7,49 @@ import (
 	"github.com/hashicorp/terraform/helper/resource"
 )
 
-func TestAccDataSourceVSphereTagCategory(t *testing.T) {
-	var tp *testing.T
-	testAccDataSourceVSphereTagCategoryCases := []struct {
-		name     string
-		testCase resource.TestCase
-	}{
-		{
-			"basic",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-				},
-				Providers: testAccProviders,
-				Steps: []resource.TestStep{
-					{
-						Config: testAccDataSourceVSphereTagCategoryConfig(),
-						Check: resource.ComposeTestCheckFunc(
-							resource.TestCheckResourceAttr(
-								"data.vsphere_tag_category.terraform-test-category-data",
-								"name",
-								testAccDataSourceVSphereTagCategoryConfigName,
-							),
-							resource.TestCheckResourceAttr(
-								"data.vsphere_tag_category.terraform-test-category-data",
-								"description",
-								testAccDataSourceVSphereTagCategoryConfigDescription,
-							),
-							resource.TestCheckResourceAttr(
-								"data.vsphere_tag_category.terraform-test-category-data",
-								"cardinality",
-								testAccDataSourceVSphereTagCategoryConfigCardinality,
-							),
-							resource.TestCheckResourceAttr(
-								"data.vsphere_tag_category.terraform-test-category-data",
-								"associable_types.#",
-								"1",
-							),
-							resource.TestCheckResourceAttr(
-								"data.vsphere_tag_category.terraform-test-category-data",
-								"associable_types.3125094965",
-								testAccDataSourceVSphereTagCategoryConfigAssociableType,
-							),
-							resource.TestCheckResourceAttrPair(
-								"data.vsphere_tag_category.terraform-test-category-data", "id",
-								"vsphere_tag_category.terraform-test-category", "id",
-							),
-						),
-					},
-				},
+func TestAccDataSourceVSphereTagCategory_basic(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+		},
+		Providers: testAccProviders,
+		Steps: []resource.TestStep{
+			{
+				Config: testAccDataSourceVSphereTagCategoryConfig(),
+				Check: resource.ComposeTestCheckFunc(
+					resource.TestCheckResourceAttr(
+						"data.vsphere_tag_category.terraform-test-category-data",
+						"name",
+						testAccDataSourceVSphereTagCategoryConfigName,
+					),
+					resource.TestCheckResourceAttr(
+						"data.vsphere_tag_category.terraform-test-category-data",
+						"description",
+						testAccDataSourceVSphereTagCategoryConfigDescription,
+					),
+					resource.TestCheckResourceAttr(
+						"data.vsphere_tag_category.terraform-test-category-data",
+						"cardinality",
+						testAccDataSourceVSphereTagCategoryConfigCardinality,
+					),
+					resource.TestCheckResourceAttr(
+						"data.vsphere_tag_category.terraform-test-category-data",
+						"associable_types.#",
+						"1",
+					),
+					resource.TestCheckResourceAttr(
+						"data.vsphere_tag_category.terraform-test-category-data",
+						"associable_types.3125094965",
+						testAccDataSourceVSphereTagCategoryConfigAssociableType,
+					),
+					resource.TestCheckResourceAttrPair(
+						"data.vsphere_tag_category.terraform-test-category-data", "id",
+						"vsphere_tag_category.terraform-test-category", "id",
+					),
+				),
 			},
 		},
-	}
-
-	for _, tc := range testAccDataSourceVSphereTagCategoryCases {
-		t.Run(tc.name, func(t *testing.T) {
-			tp = t
-			resource.Test(t, tc.testCase)
-		})
-	}
+	})
 }
 
 const testAccDataSourceVSphereTagCategoryConfigName = "terraform-test-category"
diff --git a/vsphere/data_source_vsphere_tag_test.go b/vsphere/data_source_vsphere_tag_test.go
index 85983284f..78bdb5fa1 100644
--- a/vsphere/data_source_vsphere_tag_test.go
+++ b/vsphere/data_source_vsphere_tag_test.go
@@ -7,54 +7,38 @@ import (
 	"github.com/hashicorp/terraform/helper/resource"
 )
 
-func TestAccDataSourceVSphereTag(t *testing.T) {
-	var tp *testing.T
-	testAccDataSourceVSphereTagCases := []struct {
-		name     string
-		testCase resource.TestCase
-	}{
-		{
-			"basic",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-				},
-				Providers: testAccProviders,
-				Steps: []resource.TestStep{
-					{
-						Config: testAccDataSourceVSphereTagConfig(),
-						Check: resource.ComposeTestCheckFunc(
-							resource.TestCheckResourceAttr(
-								"data.vsphere_tag.terraform-test-tag-data",
-								"name",
-								testAccDataSourceVSphereTagConfigName,
-							),
-							resource.TestCheckResourceAttr(
-								"data.vsphere_tag.terraform-test-tag-data",
-								"description",
-								testAccDataSourceVSphereTagConfigDescription,
-							),
-							resource.TestCheckResourceAttrPair(
-								"data.vsphere_tag.terraform-test-tag-data", "id",
-								"vsphere_tag.terraform-test-tag", "id",
-							),
-							resource.TestCheckResourceAttrPair(
-								"data.vsphere_tag.terraform-test-tag-data", "category_id",
-								"vsphere_tag_category.terraform-test-category", "id",
-							),
-						),
-					},
-				},
+func TestAccDataSourceVSphereTag_basic(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+		},
+		Providers: testAccProviders,
+		Steps: []resource.TestStep{
+			{
+				Config: testAccDataSourceVSphereTagConfig(),
+				Check: resource.ComposeTestCheckFunc(
+					resource.TestCheckResourceAttr(
+						"data.vsphere_tag.terraform-test-tag-data",
+						"name",
+						testAccDataSourceVSphereTagConfigName,
+					),
+					resource.TestCheckResourceAttr(
+						"data.vsphere_tag.terraform-test-tag-data",
+						"description",
+						testAccDataSourceVSphereTagConfigDescription,
+					),
+					resource.TestCheckResourceAttrPair(
+						"data.vsphere_tag.terraform-test-tag-data", "id",
+						"vsphere_tag.terraform-test-tag", "id",
+					),
+					resource.TestCheckResourceAttrPair(
+						"data.vsphere_tag.terraform-test-tag-data", "category_id",
+						"vsphere_tag_category.terraform-test-category", "id",
+					),
+				),
 			},
 		},
-	}
-
-	for _, tc := range testAccDataSourceVSphereTagCases {
-		t.Run(tc.name, func(t *testing.T) {
-			tp = t
-			resource.Test(t, tc.testCase)
-		})
-	}
+	})
 }
 
 const testAccDataSourceVSphereTagConfigName = "terraform-test-tag"
diff --git a/vsphere/data_source_vsphere_virtual_machine_test.go b/vsphere/data_source_vsphere_virtual_machine_test.go
index edbdde717..9f63bdac9 100644
--- a/vsphere/data_source_vsphere_virtual_machine_test.go
+++ b/vsphere/data_source_vsphere_virtual_machine_test.go
@@ -9,76 +9,60 @@ import (
 	"github.com/hashicorp/terraform/helper/resource"
 )
 
-func TestAccDataSourceVSphereVirtualMachine(t *testing.T) {
-	var tp *testing.T
-	testAccDataSourceVSphereVirtualMachineCases := []struct {
-		name     string
-		testCase resource.TestCase
-	}{
-		{
-			"basic",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccDataSourceVSphereVirtualMachinePreCheck(tp)
-				},
-				Providers: testAccProviders,
-				Steps: []resource.TestStep{
-					{
-						Config: testAccDataSourceVSphereVirtualMachineConfig(),
-						Check: resource.ComposeTestCheckFunc(
-							resource.TestMatchResourceAttr(
-								"data.vsphere_virtual_machine.template",
-								"id",
-								regexp.MustCompile("^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$")),
-							resource.TestCheckResourceAttrSet("data.vsphere_virtual_machine.template", "guest_id"),
-							resource.TestCheckResourceAttrSet("data.vsphere_virtual_machine.template", "scsi_type"),
-							resource.TestCheckResourceAttrSet("data.vsphere_virtual_machine.template", "disks.#"),
-							resource.TestCheckResourceAttrSet("data.vsphere_virtual_machine.template", "disks.0.size"),
-							resource.TestCheckResourceAttrSet("data.vsphere_virtual_machine.template", "disks.0.eagerly_scrub"),
-							resource.TestCheckResourceAttrSet("data.vsphere_virtual_machine.template", "disks.0.thin_provisioned"),
-							resource.TestCheckResourceAttrSet("data.vsphere_virtual_machine.template", "network_interface_types.#"),
-						),
-					},
-				},
-			},
+func TestAccDataSourceVSphereVirtualMachine_basic(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccDataSourceVSphereVirtualMachinePreCheck(t)
 		},
-		{
-			"no datacenter and absolute path",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccDataSourceVSphereVirtualMachinePreCheck(tp)
-				},
-				Providers: testAccProviders,
-				Steps: []resource.TestStep{
-					{
-						Config: testAccDataSourceVSphereVirtualMachineConfigAbsolutePath(),
-						Check: resource.ComposeTestCheckFunc(
-							resource.TestMatchResourceAttr(
-								"data.vsphere_virtual_machine.template",
-								"id",
-								regexp.MustCompile("^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$")),
-							resource.TestCheckResourceAttrSet("data.vsphere_virtual_machine.template", "guest_id"),
-							resource.TestCheckResourceAttrSet("data.vsphere_virtual_machine.template", "scsi_type"),
-							resource.TestCheckResourceAttrSet("data.vsphere_virtual_machine.template", "disks.#"),
-							resource.TestCheckResourceAttrSet("data.vsphere_virtual_machine.template", "disks.0.size"),
-							resource.TestCheckResourceAttrSet("data.vsphere_virtual_machine.template", "disks.0.eagerly_scrub"),
-							resource.TestCheckResourceAttrSet("data.vsphere_virtual_machine.template", "disks.0.thin_provisioned"),
-							resource.TestCheckResourceAttrSet("data.vsphere_virtual_machine.template", "network_interface_types.#"),
-						),
-					},
-				},
+		Providers: testAccProviders,
+		Steps: []resource.TestStep{
+			{
+				Config: testAccDataSourceVSphereVirtualMachineConfig(),
+				Check: resource.ComposeTestCheckFunc(
+					resource.TestMatchResourceAttr(
+						"data.vsphere_virtual_machine.template",
+						"id",
+						regexp.MustCompile("^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$")),
+					resource.TestCheckResourceAttrSet("data.vsphere_virtual_machine.template", "guest_id"),
+					resource.TestCheckResourceAttrSet("data.vsphere_virtual_machine.template", "scsi_type"),
+					resource.TestCheckResourceAttrSet("data.vsphere_virtual_machine.template", "disks.#"),
+					resource.TestCheckResourceAttrSet("data.vsphere_virtual_machine.template", "disks.0.size"),
+					resource.TestCheckResourceAttrSet("data.vsphere_virtual_machine.template", "disks.0.eagerly_scrub"),
+					resource.TestCheckResourceAttrSet("data.vsphere_virtual_machine.template", "disks.0.thin_provisioned"),
+					resource.TestCheckResourceAttrSet("data.vsphere_virtual_machine.template", "network_interface_types.#"),
+				),
 			},
 		},
-	}
+	})
+}
 
-	for _, tc := range testAccDataSourceVSphereVirtualMachineCases {
-		t.Run(tc.name, func(t *testing.T) {
-			tp = t
-			resource.Test(t, tc.testCase)
-		})
-	}
+func TestAccDataSourceVSphereVirtualMachine_noDatacenterAndAbsolutePath(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccDataSourceVSphereVirtualMachinePreCheck(t)
+		},
+		Providers: testAccProviders,
+		Steps: []resource.TestStep{
+			{
+				Config: testAccDataSourceVSphereVirtualMachineConfigAbsolutePath(),
+				Check: resource.ComposeTestCheckFunc(
+					resource.TestMatchResourceAttr(
+						"data.vsphere_virtual_machine.template",
+						"id",
+						regexp.MustCompile("^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$")),
+					resource.TestCheckResourceAttrSet("data.vsphere_virtual_machine.template", "guest_id"),
+					resource.TestCheckResourceAttrSet("data.vsphere_virtual_machine.template", "scsi_type"),
+					resource.TestCheckResourceAttrSet("data.vsphere_virtual_machine.template", "disks.#"),
+					resource.TestCheckResourceAttrSet("data.vsphere_virtual_machine.template", "disks.0.size"),
+					resource.TestCheckResourceAttrSet("data.vsphere_virtual_machine.template", "disks.0.eagerly_scrub"),
+					resource.TestCheckResourceAttrSet("data.vsphere_virtual_machine.template", "disks.0.thin_provisioned"),
+					resource.TestCheckResourceAttrSet("data.vsphere_virtual_machine.template", "network_interface_types.#"),
+				),
+			},
+		},
+	})
 }
 
 func testAccDataSourceVSphereVirtualMachinePreCheck(t *testing.T) {
diff --git a/vsphere/data_source_vsphere_vmfs_disks_test.go b/vsphere/data_source_vsphere_vmfs_disks_test.go
index 6ae1ea26e..07a777f4c 100644
--- a/vsphere/data_source_vsphere_vmfs_disks_test.go
+++ b/vsphere/data_source_vsphere_vmfs_disks_test.go
@@ -8,56 +8,40 @@ import (
 	"github.com/hashicorp/terraform/helper/resource"
 )
 
-func TestAccDataSourceVSphereVmfsDisks(t *testing.T) {
-	var tp *testing.T
-	testAccDataSourceVSphereVmfsDisksCases := []struct {
-		name     string
-		testCase resource.TestCase
-	}{
-		{
-			"basic",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccDataSourceVSphereVmfsDisksPreCheck(tp)
-				},
-				Providers: testAccProviders,
-				Steps: []resource.TestStep{
-					{
-						Config: testAccDataSourceVSphereVmfsDisksConfig(),
-						Check: resource.ComposeTestCheckFunc(
-							resource.TestCheckOutput("found", "true"),
-						),
-					},
-				},
-			},
+func TestAccDataSourceVSphereVmfsDisks_basic(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccDataSourceVSphereVmfsDisksPreCheck(t)
 		},
-		{
-			"with regular expression",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccDataSourceVSphereVmfsDisksPreCheck(tp)
-				},
-				Providers: testAccProviders,
-				Steps: []resource.TestStep{
-					{
-						Config: testAccDataSourceVSphereVmfsDisksConfigRegexp(),
-						Check: resource.ComposeTestCheckFunc(
-							resource.TestCheckOutput("expected_length", "true"),
-						),
-					},
-				},
+		Providers: testAccProviders,
+		Steps: []resource.TestStep{
+			{
+				Config: testAccDataSourceVSphereVmfsDisksConfig(),
+				Check: resource.ComposeTestCheckFunc(
+					resource.TestCheckOutput("found", "true"),
+				),
 			},
 		},
-	}
+	})
+}
 
-	for _, tc := range testAccDataSourceVSphereVmfsDisksCases {
-		t.Run(tc.name, func(t *testing.T) {
-			tp = t
-			resource.Test(t, tc.testCase)
-		})
-	}
+func TestAccDataSourceVSphereVmfsDisks_withRegularExpression(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccDataSourceVSphereVmfsDisksPreCheck(t)
+		},
+		Providers: testAccProviders,
+		Steps: []resource.TestStep{
+			{
+				Config: testAccDataSourceVSphereVmfsDisksConfigRegexp(),
+				Check: resource.ComposeTestCheckFunc(
+					resource.TestCheckOutput("expected_length", "true"),
+				),
+			},
+		},
+	})
 }
 
 func testAccDataSourceVSphereVmfsDisksPreCheck(t *testing.T) {
@@ -117,7 +101,7 @@ data "vsphere_vmfs_disks" "available" {
 }
 
 output "expected_length" {
-  value = "${length(data.vsphere_vmfs_disks.available.disks) == 2 ? "true" : "false" }"
+  value = "${length(data.vsphere_vmfs_disks.available.disks) == 3 ? "true" : "false" }"
 }
 `, os.Getenv("VSPHERE_VMFS_REGEXP"), os.Getenv("VSPHERE_DATACENTER"), os.Getenv("VSPHERE_ESXI_HOST"))
 }
diff --git a/vsphere/resource_vsphere_custom_attribute_test.go b/vsphere/resource_vsphere_custom_attribute_test.go
index c84353d22..6c53e562e 100644
--- a/vsphere/resource_vsphere_custom_attribute_test.go
+++ b/vsphere/resource_vsphere_custom_attribute_test.go
@@ -9,148 +9,130 @@ import (
 	"github.com/hashicorp/terraform/terraform"
 )
 
-func TestAccResourceVSphereCustomAttribute(t *testing.T) {
-	var tp *testing.T
-	testAccResourceVSphereCustomAttributeCases := []struct {
-		name     string
-		testCase resource.TestCase
-	}{
-		{
-			"basic",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereCustomAttributeExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereCustomAttributeConfigBasic,
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereCustomAttributeExists(true),
-							testAccResourceVSphereCustomAttributeHasName("terraform-test-attribute"),
-							testAccResourceVSphereCustomAttributeHasType(""),
-						),
-					},
-				},
+func TestAccResourceVSphereCustomAttribute_basic(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereCustomAttributeExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereCustomAttributeConfigBasic,
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereCustomAttributeExists(true),
+					testAccResourceVSphereCustomAttributeHasName("terraform-test-attribute"),
+					testAccResourceVSphereCustomAttributeHasType(""),
+				),
 			},
 		},
-		{
-			"with type",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereCustomAttributeExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereCustomAttributeConfigType,
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereCustomAttributeExists(true),
-							testAccResourceVSphereCustomAttributeHasName("terraform-test-attribute"),
-							testAccResourceVSphereCustomAttributeHasType("VirtualMachine"),
-						),
-					},
-				},
+	})
+}
+func TestAccResourceVSphereCustomAttribute_withType(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereCustomAttributeExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereCustomAttributeConfigType,
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereCustomAttributeExists(true),
+					testAccResourceVSphereCustomAttributeHasName("terraform-test-attribute"),
+					testAccResourceVSphereCustomAttributeHasType("VirtualMachine"),
+				),
 			},
 		},
-		{
-			"rename",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereCustomAttributeExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereCustomAttributeConfigBasic,
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereCustomAttributeExists(true),
-						),
-					},
-					{
-						Config: testAccResourceVSphereCustomAttributeConfigAltName,
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereCustomAttributeExists(true),
-							testAccResourceVSphereCustomAttributeHasName("terraform-test-attribute-renamed"),
-						),
-					},
-				},
+	})
+}
+func TestAccResourceVSphereCustomAttribute_rename(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereCustomAttributeExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereCustomAttributeConfigBasic,
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereCustomAttributeExists(true),
+				),
+			},
+			{
+				Config: testAccResourceVSphereCustomAttributeConfigAltName,
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereCustomAttributeExists(true),
+					testAccResourceVSphereCustomAttributeHasName("terraform-test-attribute-renamed"),
+				),
 			},
 		},
-		{
-			"change type",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereCustomAttributeExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereCustomAttributeConfigBasic,
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereCustomAttributeExists(true),
-							testAccResourceVSphereCustomAttributeHasType(""),
-						),
-					},
-					{
-						Config: testAccResourceVSphereCustomAttributeConfigType,
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereCustomAttributeExists(true),
-							testAccResourceVSphereCustomAttributeHasType("VirtualMachine"),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereCustomAttribute_changeType(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereCustomAttributeExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereCustomAttributeConfigBasic,
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereCustomAttributeExists(true),
+					testAccResourceVSphereCustomAttributeHasType(""),
+				),
+			},
+			{
+				Config: testAccResourceVSphereCustomAttributeConfigType,
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereCustomAttributeExists(true),
+					testAccResourceVSphereCustomAttributeHasType("VirtualMachine"),
+				),
 			},
 		},
-		{
-			"import",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereCustomAttributeExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereCustomAttributeConfigBasic,
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereCustomAttributeExists(true),
-						),
-					},
-					{
-						ResourceName:      "vsphere_custom_attribute.terraform-test-attribute",
-						ImportState:       true,
-						ImportStateVerify: true,
-						ImportStateIdFunc: func(s *terraform.State) (string, error) {
-							attr, err := testGetCustomAttribute(s, "terraform-test-attribute")
-							if err != nil {
-								return "", err
-							}
-							if attr == nil {
-								return "", errors.New("custom attribute does not exist")
-							}
-							return attr.Name, nil
-						},
-						Config: testAccResourceVSphereCustomAttributeConfigBasic,
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereCustomAttributeExists(true),
-						),
-					},
+	})
+}
+
+func TestAccResourceVSphereCustomAttribute_import(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereCustomAttributeExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereCustomAttributeConfigBasic,
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereCustomAttributeExists(true),
+				),
+			},
+			{
+				ResourceName:      "vsphere_custom_attribute.terraform-test-attribute",
+				ImportState:       true,
+				ImportStateVerify: true,
+				ImportStateIdFunc: func(s *terraform.State) (string, error) {
+					attr, err := testGetCustomAttribute(s, "terraform-test-attribute")
+					if err != nil {
+						return "", err
+					}
+					if attr == nil {
+						return "", errors.New("custom attribute does not exist")
+					}
+					return attr.Name, nil
 				},
+				Config: testAccResourceVSphereCustomAttributeConfigBasic,
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereCustomAttributeExists(true),
+				),
 			},
 		},
-	}
-
-	for _, tc := range testAccResourceVSphereCustomAttributeCases {
-		t.Run(tc.name, func(t *testing.T) {
-			tp = t
-			resource.Test(t, tc.testCase)
-		})
-	}
+	})
 }
 
 func testAccResourceVSphereCustomAttributeExists(expected bool) resource.TestCheckFunc {
diff --git a/vsphere/resource_vsphere_datacenter_test.go b/vsphere/resource_vsphere_datacenter_test.go
index 626649317..198274beb 100644
--- a/vsphere/resource_vsphere_datacenter_test.go
+++ b/vsphere/resource_vsphere_datacenter_test.go
@@ -123,7 +123,7 @@ resource "vsphere_datacenter" "testDC" {
 `
 
 // Create a datacenter on the root folder
-func TestAccVSphereDatacenter_createOnRootFolder(t *testing.T) {
+func TestAccResourceVSphereDatacenter_createOnRootFolder(t *testing.T) {
 
 	resource.Test(t, resource.TestCase{
 		PreCheck:     func() { testAccPreCheck(t) },
@@ -139,7 +139,7 @@ func TestAccVSphereDatacenter_createOnRootFolder(t *testing.T) {
 }
 
 // Create a datacenter on a subfolder
-func TestAccVSphereDatacenter_createOnSubfolder(t *testing.T) {
+func TestAccResourceVSphereDatacenter_createOnSubfolder(t *testing.T) {
 	dcFolder := os.Getenv("VSPHERE_DC_FOLDER")
 
 	resource.Test(t, resource.TestCase{
@@ -160,144 +160,112 @@ func TestAccVSphereDatacenter_createOnSubfolder(t *testing.T) {
 	})
 }
 
-func TestAccVSphereDatacenterTags(t *testing.T) {
-	var tp *testing.T
-	testAccResourceVSphereNasDatastoreCases := []struct {
-		name     string
-		testCase resource.TestCase
-	}{
-		{
-			"single tag",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccCheckVSphereDatacenterDestroy,
-				Steps: []resource.TestStep{
-					{
-						Config: testAccCheckVSphereDatacenterConfigTags,
-						Check: resource.ComposeTestCheckFunc(
-							testAccCheckVSphereDatacenterExists(
-								testAccCheckVSphereDatacenterResourceName,
-								true,
-							),
-							testAccResourceVSphereDatacenterCheckTags("terraform-test-tag"),
-						),
-					},
-				},
-			},
+func TestAccResourceVSphereDatacenter_singleTag(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
 		},
-		{
-			"modify tags",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccCheckVSphereDatacenterDestroy,
-				Steps: []resource.TestStep{
-					{
-						Config: testAccCheckVSphereDatacenterConfigTags,
-						Check: resource.ComposeTestCheckFunc(
-							testAccCheckVSphereDatacenterExists(
-								testAccCheckVSphereDatacenterResourceName,
-								true,
-							),
-							testAccResourceVSphereDatacenterCheckTags("terraform-test-tag"),
-						),
-					},
-					{
-						Config: testAccCheckVSphereDatacenterConfigMultiTags,
-						Check: resource.ComposeTestCheckFunc(
-							testAccCheckVSphereDatacenterExists(
-								testAccCheckVSphereDatacenterResourceName,
-								true,
-							),
-							testAccResourceVSphereDatacenterCheckTags("terraform-test-tags-alt"),
-						),
-					},
-				},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccCheckVSphereDatacenterDestroy,
+		Steps: []resource.TestStep{
+			{
+				Config: testAccCheckVSphereDatacenterConfigTags,
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckVSphereDatacenterExists(
+						testAccCheckVSphereDatacenterResourceName,
+						true,
+					),
+					testAccResourceVSphereDatacenterCheckTags("terraform-test-tag"),
+				),
 			},
 		},
-	}
-
-	for _, tc := range testAccResourceVSphereNasDatastoreCases {
-		t.Run(tc.name, func(t *testing.T) {
-			tp = t
-			resource.Test(t, tc.testCase)
-		})
-	}
+	})
 }
 
-func TestAccVSphereDatacenterCustomAttributes(t *testing.T) {
-	var tp *testing.T
-	testAccResourceCases := []struct {
-		name     string
-		testCase resource.TestCase
-	}{
-		{
-			"single custom attribute",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccCheckVSphereDatacenterDestroy,
-				Steps: []resource.TestStep{
-					{
-						Config: testAccCheckVSphereDatacenterConfigCustomAttributes,
-						Check: resource.ComposeTestCheckFunc(
-							testAccCheckVSphereDatacenterExists(
-								testAccCheckVSphereDatacenterResourceName,
-								true,
-							),
-							testAccResourceVSphereDatacenterHasCustomAttributes(),
-						),
-					},
-				},
+func TestAccResourceVSphereDatacenter_modifyTags(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccCheckVSphereDatacenterDestroy,
+		Steps: []resource.TestStep{
+			{
+				Config: testAccCheckVSphereDatacenterConfigTags,
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckVSphereDatacenterExists(
+						testAccCheckVSphereDatacenterResourceName,
+						true,
+					),
+					testAccResourceVSphereDatacenterCheckTags("terraform-test-tag"),
+				),
 			},
+			{
+				Config: testAccCheckVSphereDatacenterConfigMultiTags,
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckVSphereDatacenterExists(
+						testAccCheckVSphereDatacenterResourceName,
+						true,
+					),
+					testAccResourceVSphereDatacenterCheckTags("terraform-test-tags-alt"),
+				),
+			},
+		},
+	})
+}
+
+func TestAccResourceVSphereDatacenter_singleCustomAttribute(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
 		},
-		{
-			"modify custom attribute",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccCheckVSphereDatacenterDestroy,
-				Steps: []resource.TestStep{
-					{
-						Config: testAccCheckVSphereDatacenterConfigCustomAttributes,
-						Check: resource.ComposeTestCheckFunc(
-							testAccCheckVSphereDatacenterExists(
-								testAccCheckVSphereDatacenterResourceName,
-								true,
-							),
-							testAccResourceVSphereDatacenterHasCustomAttributes(),
-						),
-					},
-					{
-						Config: testAccCheckVSphereDatacenterConfigMultiCustomAttributes,
-						Check: resource.ComposeTestCheckFunc(
-							testAccCheckVSphereDatacenterExists(
-								testAccCheckVSphereDatacenterResourceName,
-								true,
-							),
-							testAccResourceVSphereDatacenterHasCustomAttributes(),
-						),
-					},
-				},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccCheckVSphereDatacenterDestroy,
+		Steps: []resource.TestStep{
+			{
+				Config: testAccCheckVSphereDatacenterConfigCustomAttributes,
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckVSphereDatacenterExists(
+						testAccCheckVSphereDatacenterResourceName,
+						true,
+					),
+					testAccResourceVSphereDatacenterHasCustomAttributes(),
+				),
 			},
 		},
-	}
+	})
+}
 
-	for _, tc := range testAccResourceCases {
-		t.Run(tc.name, func(t *testing.T) {
-			tp = t
-			resource.Test(t, tc.testCase)
-		})
-	}
+func TestAccResourceVSphereDatacenter_modifyCustomAttribute(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccCheckVSphereDatacenterDestroy,
+		Steps: []resource.TestStep{
+			{
+				Config: testAccCheckVSphereDatacenterConfigCustomAttributes,
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckVSphereDatacenterExists(
+						testAccCheckVSphereDatacenterResourceName,
+						true,
+					),
+					testAccResourceVSphereDatacenterHasCustomAttributes(),
+				),
+			},
+			{
+				Config: testAccCheckVSphereDatacenterConfigMultiCustomAttributes,
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckVSphereDatacenterExists(
+						testAccCheckVSphereDatacenterResourceName,
+						true,
+					),
+					testAccResourceVSphereDatacenterHasCustomAttributes(),
+				),
+			},
+		},
+	})
 }
 
 func testAccCheckVSphereDatacenterDestroy(s *terraform.State) error {
@@ -317,7 +285,6 @@ func testAccCheckVSphereDatacenterDestroy(s *terraform.State) error {
 		if err != nil {
 			switch err.(type) {
 			case *find.NotFoundError:
-				fmt.Printf("Expected error received: %s\n", err)
 				return nil
 			default:
 				return err
@@ -355,7 +322,6 @@ func testAccCheckVSphereDatacenterExists(n string, exists bool) resource.TestChe
 				if exists {
 					return fmt.Errorf("datacenter does not exist: %s", e.Error())
 				}
-				fmt.Printf("Expected error received: %s\n", e.Error())
 				return nil
 			default:
 				return err
diff --git a/vsphere/resource_vsphere_distributed_port_group_test.go b/vsphere/resource_vsphere_distributed_port_group_test.go
index b21b3b578..f036fa7c3 100644
--- a/vsphere/resource_vsphere_distributed_port_group_test.go
+++ b/vsphere/resource_vsphere_distributed_port_group_test.go
@@ -11,221 +11,205 @@ import (
 	"github.com/vmware/govmomi/vim25/types"
 )
 
-func TestAccResourceVSphereDistributedPortGroup(t *testing.T) {
-	var tp *testing.T
-	testAccResourceVSphereDistributedPortGroupCases := []struct {
-		name     string
-		testCase resource.TestCase
-	}{
-		{
-			"basic",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereDistributedPortGroupPreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereDistributedPortGroupExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereDistributedPortGroupConfig(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereDistributedPortGroupExists(true),
-						),
-					},
-				},
-			},
+func TestAccResourceVSphereDistributedPortGroup_basic(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereDistributedPortGroupPreCheck(t)
 		},
-		{
-			"inherit policy diff check",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereDistributedPortGroupPreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereDistributedPortGroupExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereDistributedPortGroupConfigPolicyInherit(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereDistributedPortGroupExists(true),
-						),
-					},
-				},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereDistributedPortGroupExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereDistributedPortGroupConfig(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereDistributedPortGroupExists(true),
+				),
 			},
 		},
-		{
-			"inherit policy diff check (vlan range - typeset edition)",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereDistributedPortGroupPreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereDistributedPortGroupExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereDistributedPortGroupConfigPolicyInheritVLANRange(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereDistributedPortGroupExists(true),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereDistributedPortGroup_inheritPolicyDiffCheck(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereDistributedPortGroupPreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereDistributedPortGroupExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereDistributedPortGroupConfigPolicyInherit(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereDistributedPortGroupExists(true),
+				),
 			},
 		},
-		{
-			"override vlan",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereDistributedPortGroupPreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereDistributedPortGroupExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereDistributedPortGroupConfigOverrideVLAN(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereDistributedPortGroupExists(true),
-							testAccResourceVSphereDistributedVirtualSwitchHasVlanRange(1000, 1999),
-							testAccResourceVSphereDistributedPortGroupHasVlanRange(3000, 3999),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereDistributedPortGroup_inheritPolicyDiffCheckVlanRangeTypeSetEdition(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereDistributedPortGroupPreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereDistributedPortGroupExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereDistributedPortGroupConfigPolicyInheritVLANRange(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereDistributedPortGroupExists(true),
+				),
 			},
 		},
-		{
-			"single tag",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereDistributedPortGroupPreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereDistributedPortGroupExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereDistributedPortGroupConfigSingleTag(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereDistributedPortGroupExists(true),
-							testAccResourceVSphereDistributedPortGroupCheckTags("terraform-test-tag"),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereDistributedPortGroup_overrideVlan(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereDistributedPortGroupPreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereDistributedPortGroupExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereDistributedPortGroupConfigOverrideVLAN(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereDistributedPortGroupExists(true),
+					testAccResourceVSphereDistributedVirtualSwitchHasVlanRange(1000, 1999),
+					testAccResourceVSphereDistributedPortGroupHasVlanRange(3000, 3999),
+				),
 			},
 		},
-		{
-			"multi tag",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereDistributedPortGroupPreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereDistributedPortGroupExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereDistributedPortGroupConfigMultiTag(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereDistributedPortGroupExists(true),
-							testAccResourceVSphereDistributedPortGroupCheckTags("terraform-test-tags-alt"),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereDistributedPortGroup_singleTag(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereDistributedPortGroupPreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereDistributedPortGroupExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereDistributedPortGroupConfigSingleTag(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereDistributedPortGroupExists(true),
+					testAccResourceVSphereDistributedPortGroupCheckTags("terraform-test-tag"),
+				),
 			},
 		},
-		{
-			"import",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereDistributedPortGroupPreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereDistributedPortGroupExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereDistributedPortGroupConfig(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereDistributedPortGroupExists(true),
-						),
-					},
-					{
-						ResourceName:            "vsphere_distributed_port_group.pg",
-						ImportState:             true,
-						ImportStateVerify:       true,
-						ImportStateVerifyIgnore: []string{"vlan_range"},
-						ImportStateIdFunc: func(s *terraform.State) (string, error) {
-							pg, err := testGetDVPortgroup(s, "pg")
-							if err != nil {
-								return "", err
-							}
-							return pg.InventoryPath, nil
-						},
-						Config: testAccResourceVSphereDistributedPortGroupConfig(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereDistributedPortGroupExists(true),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereDistributedPortGroup_multiTag(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereDistributedPortGroupPreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereDistributedPortGroupExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereDistributedPortGroupConfigMultiTag(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereDistributedPortGroupExists(true),
+					testAccResourceVSphereDistributedPortGroupCheckTags("terraform-test-tags-alt"),
+				),
 			},
 		},
-		{
-			"single custom attribute",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereDistributedPortGroupPreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereDistributedPortGroupExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereDistributedPortGroupConfigSingleCustomAttribute(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereDistributedPortGroupExists(true),
-							testAccResourceVSphereDistributedPortGroupCheckCustomAttributes(),
-						),
-					},
+	})
+}
+
+func TestAccResourceVSphereDistributedPortGroup_import(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereDistributedPortGroupPreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereDistributedPortGroupExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereDistributedPortGroupConfig(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereDistributedPortGroupExists(true),
+				),
+			},
+			{
+				ResourceName:            "vsphere_distributed_port_group.pg",
+				ImportState:             true,
+				ImportStateVerify:       true,
+				ImportStateVerifyIgnore: []string{"vlan_range"},
+				ImportStateIdFunc: func(s *terraform.State) (string, error) {
+					pg, err := testGetDVPortgroup(s, "pg")
+					if err != nil {
+						return "", err
+					}
+					return pg.InventoryPath, nil
 				},
+				Config: testAccResourceVSphereDistributedPortGroupConfig(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereDistributedPortGroupExists(true),
+				),
 			},
 		},
-		{
-			"multi custom attribute",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereDistributedPortGroupPreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereDistributedPortGroupExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereDistributedPortGroupConfigSingleCustomAttribute(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereDistributedPortGroupExists(true),
-							testAccResourceVSphereDistributedPortGroupCheckCustomAttributes(),
-						),
-					},
-					{
-						Config: testAccResourceVSphereDistributedPortGroupConfigMultiCustomAttribute(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereDistributedPortGroupExists(true),
-							testAccResourceVSphereDistributedPortGroupCheckCustomAttributes(),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereDistributedPortGroup_singleCustomAttribute(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereDistributedPortGroupPreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereDistributedPortGroupExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereDistributedPortGroupConfigSingleCustomAttribute(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereDistributedPortGroupExists(true),
+					testAccResourceVSphereDistributedPortGroupCheckCustomAttributes(),
+				),
 			},
 		},
-	}
+	})
+}
 
-	for _, tc := range testAccResourceVSphereDistributedPortGroupCases {
-		t.Run(tc.name, func(t *testing.T) {
-			tp = t
-			resource.Test(t, tc.testCase)
-		})
-	}
+func TestAccResourceVSphereDistributedPortGroup_multiCustomAttribute(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereDistributedPortGroupPreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereDistributedPortGroupExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereDistributedPortGroupConfigSingleCustomAttribute(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereDistributedPortGroupExists(true),
+					testAccResourceVSphereDistributedPortGroupCheckCustomAttributes(),
+				),
+			},
+			{
+				Config: testAccResourceVSphereDistributedPortGroupConfigMultiCustomAttribute(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereDistributedPortGroupExists(true),
+					testAccResourceVSphereDistributedPortGroupCheckCustomAttributes(),
+				),
+			},
+		},
+	})
 }
 
 func testAccResourceVSphereDistributedPortGroupPreCheck(t *testing.T) {
diff --git a/vsphere/resource_vsphere_distributed_virtual_switch_test.go b/vsphere/resource_vsphere_distributed_virtual_switch_test.go
index f73f4f55e..79b601c9b 100644
--- a/vsphere/resource_vsphere_distributed_virtual_switch_test.go
+++ b/vsphere/resource_vsphere_distributed_virtual_switch_test.go
@@ -15,432 +15,417 @@ import (
 	"github.com/vmware/govmomi/vim25/types"
 )
 
-func TestAccResourceVSphereDistributedVirtualSwitch(t *testing.T) {
-	var tp *testing.T
-	testAccResourceVSphereDistributedVirtualSwitchCases := []struct {
-		name     string
-		testCase resource.TestCase
-	}{
-		{
-			"basic",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereDistributedVirtualSwitchPreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereDistributedVirtualSwitchExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereDistributedVirtualSwitchConfig(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereDistributedVirtualSwitchExists(true),
-						),
-					},
-				},
-			},
+func TestAccResourceVSphereDistributedVirtualSwitch_basic(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereDistributedVirtualSwitchPreCheck(t)
 		},
-		{
-			"no hosts",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereDistributedVirtualSwitchPreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereDistributedVirtualSwitchExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereDistributedVirtualSwitchConfigNoHosts(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereDistributedVirtualSwitchExists(true),
-						),
-					},
-				},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereDistributedVirtualSwitchExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereDistributedVirtualSwitchConfig(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereDistributedVirtualSwitchExists(true),
+				),
 			},
 		},
-		{
-			"remove a NIC",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereDistributedVirtualSwitchPreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereDistributedVirtualSwitchExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereDistributedVirtualSwitchConfig(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereDistributedVirtualSwitchExists(true),
-						),
-					},
-					{
-						Config: testAccResourceVSphereDistributedVirtualSwitchConfigSingleNIC(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereDistributedVirtualSwitchExists(true),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereDistributedVirtualSwitch_noHosts(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereDistributedVirtualSwitchPreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereDistributedVirtualSwitchExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereDistributedVirtualSwitchConfigNoHosts(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereDistributedVirtualSwitchExists(true),
+				),
 			},
 		},
-		{
-			"standby with explicit failover order",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereDistributedVirtualSwitchPreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereDistributedVirtualSwitchExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereDistributedVirtualSwitchConfigStandbyLink(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereDistributedVirtualSwitchExists(true),
-							testAccResourceVSphereDistributedVirtualSwitchHasUplinks([]string{"tfup1", "tfup2"}),
-							testAccResourceVSphereDistributedVirtualSwitchHasActiveUplinks([]string{"tfup1"}),
-							testAccResourceVSphereDistributedVirtualSwitchHasStandbyUplinks([]string{"tfup2"}),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereDistributedVirtualSwitch_removeNIC(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereDistributedVirtualSwitchPreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereDistributedVirtualSwitchExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereDistributedVirtualSwitchConfig(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereDistributedVirtualSwitchExists(true),
+				),
+			},
+			{
+				Config: testAccResourceVSphereDistributedVirtualSwitchConfigSingleNIC(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereDistributedVirtualSwitchExists(true),
+				),
 			},
 		},
-		{
-			"basic, then change to standby with failover order",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereDistributedVirtualSwitchPreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereDistributedVirtualSwitchExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereDistributedVirtualSwitchConfig(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereDistributedVirtualSwitchExists(true),
-						),
-					},
-					{
-						Config: testAccResourceVSphereDistributedVirtualSwitchConfigStandbyLink(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereDistributedVirtualSwitchExists(true),
-							testAccResourceVSphereDistributedVirtualSwitchHasUplinks([]string{"tfup1", "tfup2"}),
-							testAccResourceVSphereDistributedVirtualSwitchHasActiveUplinks([]string{"tfup1"}),
-							testAccResourceVSphereDistributedVirtualSwitchHasStandbyUplinks([]string{"tfup2"}),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereDistributedVirtualSwitch_standbyWithExplicitFailoverOrder(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereDistributedVirtualSwitchPreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereDistributedVirtualSwitchExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereDistributedVirtualSwitchConfigStandbyLink(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereDistributedVirtualSwitchExists(true),
+					testAccResourceVSphereDistributedVirtualSwitchHasUplinks([]string{"tfup1", "tfup2"}),
+					testAccResourceVSphereDistributedVirtualSwitchHasActiveUplinks([]string{"tfup1"}),
+					testAccResourceVSphereDistributedVirtualSwitchHasStandbyUplinks([]string{"tfup2"}),
+				),
 			},
 		},
-		{
-			"upgrade version",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereDistributedVirtualSwitchPreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereDistributedVirtualSwitchExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereDistributedVirtualSwitchConfigStaticVersion("6.0.0"),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereDistributedVirtualSwitchExists(true),
-							testAccResourceVSphereDistributedVirtualSwitchHasVersion("6.0.0"),
-						),
-					},
-					{
-						Config: testAccResourceVSphereDistributedVirtualSwitchConfigStaticVersion("6.5.0"),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereDistributedVirtualSwitchExists(true),
-							testAccResourceVSphereDistributedVirtualSwitchHasVersion("6.5.0"),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereDistributedVirtualSwitch_basicToStandbyWithFailover(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereDistributedVirtualSwitchPreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereDistributedVirtualSwitchExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereDistributedVirtualSwitchConfig(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereDistributedVirtualSwitchExists(true),
+				),
+			},
+			{
+				Config: testAccResourceVSphereDistributedVirtualSwitchConfigStandbyLink(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereDistributedVirtualSwitchExists(true),
+					testAccResourceVSphereDistributedVirtualSwitchHasUplinks([]string{"tfup1", "tfup2"}),
+					testAccResourceVSphereDistributedVirtualSwitchHasActiveUplinks([]string{"tfup1"}),
+					testAccResourceVSphereDistributedVirtualSwitchHasStandbyUplinks([]string{"tfup2"}),
+				),
 			},
 		},
-		{
-			"network resource control",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereDistributedVirtualSwitchPreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereDistributedVirtualSwitchExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereDistributedVirtualSwitchConfigNetworkResourceControl(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereDistributedVirtualSwitchExists(true),
-							testAccResourceVSphereDistributedVirtualSwitchHasNetworkResourceControlEnabled(),
-							testAccResourceVSphereDistributedVirtualSwitchHasNetworkResourceControlVersion(
-								types.DistributedVirtualSwitchNetworkResourceControlVersionVersion3,
-							),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereDistributedVirtualSwitch_upgradeVersion(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereDistributedVirtualSwitchPreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereDistributedVirtualSwitchExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereDistributedVirtualSwitchConfigStaticVersion("6.0.0"),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereDistributedVirtualSwitchExists(true),
+					testAccResourceVSphereDistributedVirtualSwitchHasVersion("6.0.0"),
+				),
+			},
+			{
+				Config: testAccResourceVSphereDistributedVirtualSwitchConfigStaticVersion("6.5.0"),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereDistributedVirtualSwitchExists(true),
+					testAccResourceVSphereDistributedVirtualSwitchHasVersion("6.5.0"),
+				),
 			},
 		},
-		{
-			"explicit uplinks",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereDistributedVirtualSwitchPreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereDistributedVirtualSwitchExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereDistributedVirtualSwitchConfigUplinks(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereDistributedVirtualSwitchExists(true),
-							testAccResourceVSphereDistributedVirtualSwitchHasUplinks([]string{"tfup1", "tfup2"}),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereDistributedVirtualSwitch_networkResourceControl(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereDistributedVirtualSwitchPreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereDistributedVirtualSwitchExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereDistributedVirtualSwitchConfigNetworkResourceControl(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereDistributedVirtualSwitchExists(true),
+					testAccResourceVSphereDistributedVirtualSwitchHasNetworkResourceControlEnabled(),
+					testAccResourceVSphereDistributedVirtualSwitchHasNetworkResourceControlVersion(
+						types.DistributedVirtualSwitchNetworkResourceControlVersionVersion3,
+					),
+				),
 			},
 		},
-		{
-			"modify uplinks",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereDistributedVirtualSwitchPreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereDistributedVirtualSwitchExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereDistributedVirtualSwitchConfig(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereDistributedVirtualSwitchExists(true),
-							testAccResourceVSphereDistributedVirtualSwitchHasUplinks(
-								[]string{
-									"uplink1",
-									"uplink2",
-									"uplink3",
-									"uplink4",
-								},
-							),
-						),
-					},
-					{
-						Config: testAccResourceVSphereDistributedVirtualSwitchConfigStandbyLink(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereDistributedVirtualSwitchExists(true),
-							testAccResourceVSphereDistributedVirtualSwitchHasUplinks(
-								[]string{
-									"tfup1",
-									"tfup2",
-								},
-							),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereDistributedVirtualSwitch_explicitUplinks(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereDistributedVirtualSwitchPreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereDistributedVirtualSwitchExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereDistributedVirtualSwitchConfigUplinks(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereDistributedVirtualSwitchExists(true),
+					testAccResourceVSphereDistributedVirtualSwitchHasUplinks([]string{"tfup1", "tfup2"}),
+				),
 			},
 		},
-		{
-			"in folder",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereDistributedVirtualSwitchPreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereDistributedVirtualSwitchExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereDistributedVirtualSwitchConfigInFolder(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereDistributedVirtualSwitchExists(true),
-							testAccResourceVSphereDistributedVirtualSwitchMatchInventoryPath("tf-network-folder"),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereDistributedVirtualSwitch_modifyUplinks(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereDistributedVirtualSwitchPreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereDistributedVirtualSwitchExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereDistributedVirtualSwitchConfig(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereDistributedVirtualSwitchExists(true),
+					testAccResourceVSphereDistributedVirtualSwitchHasUplinks(
+						[]string{
+							"uplink1",
+							"uplink2",
+							"uplink3",
+							"uplink4",
+						},
+					),
+				),
+			},
+			{
+				Config: testAccResourceVSphereDistributedVirtualSwitchConfigStandbyLink(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereDistributedVirtualSwitchExists(true),
+					testAccResourceVSphereDistributedVirtualSwitchHasUplinks(
+						[]string{
+							"tfup1",
+							"tfup2",
+						},
+					),
+				),
 			},
 		},
-		{
-			"single tag",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereDistributedVirtualSwitchPreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereDistributedVirtualSwitchExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereDistributedVirtualSwitchConfigSingleTag(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereDistributedVirtualSwitchExists(true),
-							testAccResourceVSphereDistributedVirtualSwitchCheckTags("terraform-test-tag"),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereDistributedVirtualSwitch_inFolder(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereDistributedVirtualSwitchPreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereDistributedVirtualSwitchExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereDistributedVirtualSwitchConfigInFolder(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereDistributedVirtualSwitchExists(true),
+					testAccResourceVSphereDistributedVirtualSwitchMatchInventoryPath("tf-network-folder"),
+				),
 			},
 		},
-		{
-			"modify tags",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereDistributedVirtualSwitchPreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereDistributedVirtualSwitchExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereDistributedVirtualSwitchConfigSingleTag(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereDistributedVirtualSwitchExists(true),
-							testAccResourceVSphereDistributedVirtualSwitchCheckTags("terraform-test-tag"),
-						),
-					},
-					{
-						Config: testAccResourceVSphereDistributedVirtualSwitchConfigMultiTag(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereDistributedVirtualSwitchExists(true),
-							testAccResourceVSphereDistributedVirtualSwitchCheckTags("terraform-test-tags-alt"),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereDistributedVirtualSwitch_singleTag(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereDistributedVirtualSwitchPreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereDistributedVirtualSwitchExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereDistributedVirtualSwitchConfigSingleTag(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereDistributedVirtualSwitchExists(true),
+					testAccResourceVSphereDistributedVirtualSwitchCheckTags("terraform-test-tag"),
+				),
 			},
 		},
-		{
-			"netflow",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereDistributedVirtualSwitchPreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereDistributedVirtualSwitchExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereDistributedVirtualSwitchConfigNetflow(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereDistributedVirtualSwitchExists(true),
-							testAccResourceVSphereDistributedVirtualSwitchHasNetflow(),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereDistributedVirtualSwitch_modifyTags(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereDistributedVirtualSwitchPreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereDistributedVirtualSwitchExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereDistributedVirtualSwitchConfigSingleTag(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereDistributedVirtualSwitchExists(true),
+					testAccResourceVSphereDistributedVirtualSwitchCheckTags("terraform-test-tag"),
+				),
+			},
+			{
+				Config: testAccResourceVSphereDistributedVirtualSwitchConfigMultiTag(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereDistributedVirtualSwitchExists(true),
+					testAccResourceVSphereDistributedVirtualSwitchCheckTags("terraform-test-tags-alt"),
+				),
 			},
 		},
-		{
-			"vlan ranges",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereDistributedVirtualSwitchPreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereDistributedVirtualSwitchExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereDistributedVirtualSwitchConfigMultiVlanRange(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereDistributedVirtualSwitchExists(true),
-							testAccResourceVSphereDistributedVirtualSwitchHasVlanRange(1000, 1999),
-							testAccResourceVSphereDistributedVirtualSwitchHasVlanRange(3000, 3999),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereDistributedVirtualSwitch_netflow(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereDistributedVirtualSwitchPreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereDistributedVirtualSwitchExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereDistributedVirtualSwitchConfigNetflow(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereDistributedVirtualSwitchExists(true),
+					testAccResourceVSphereDistributedVirtualSwitchHasNetflow(),
+				),
 			},
 		},
-		{
-			"import",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereDistributedVirtualSwitchPreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereDistributedVirtualSwitchExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereDistributedVirtualSwitchConfig(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereDistributedVirtualSwitchExists(true),
-						),
-					},
-					{
-						ResourceName:      "vsphere_distributed_virtual_switch.dvs",
-						ImportState:       true,
-						ImportStateVerify: true,
-						ImportStateIdFunc: func(s *terraform.State) (string, error) {
-							dvs, err := testGetDVS(s, "dvs")
-							if err != nil {
-								return "", err
-							}
-							return dvs.InventoryPath, nil
-						},
-						Config: testAccResourceVSphereDistributedVirtualSwitchConfig(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereDistributedVirtualSwitchExists(true),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereDistributedVirtualSwitch_vlanRanges(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereDistributedVirtualSwitchPreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereDistributedVirtualSwitchExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereDistributedVirtualSwitchConfigMultiVlanRange(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereDistributedVirtualSwitchExists(true),
+					testAccResourceVSphereDistributedVirtualSwitchHasVlanRange(1000, 1999),
+					testAccResourceVSphereDistributedVirtualSwitchHasVlanRange(3000, 3999),
+				),
 			},
 		},
-		{
-			"single custom attribute",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereDistributedVirtualSwitchPreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereDistributedVirtualSwitchExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereDistributedVirtualSwitchConfigSingleCustomAttribute(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereDistributedVirtualSwitchExists(true),
-							testAccResourceVSphereDistributedVirtualSwitchCheckCustomAttributes(),
-						),
-					},
+	})
+}
+
+func TestAccResourceVSphereDistributedVirtualSwitch_import(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereDistributedVirtualSwitchPreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereDistributedVirtualSwitchExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereDistributedVirtualSwitchConfig(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereDistributedVirtualSwitchExists(true),
+				),
+			},
+			{
+				ResourceName:            "vsphere_distributed_virtual_switch.dvs",
+				ImportState:             true,
+				ImportStateVerify:       true,
+				ImportStateVerifyIgnore: []string{"vlan_range"},
+				ImportStateIdFunc: func(s *terraform.State) (string, error) {
+					dvs, err := testGetDVS(s, "dvs")
+					if err != nil {
+						return "", err
+					}
+					return dvs.InventoryPath, nil
 				},
+				Config: testAccResourceVSphereDistributedVirtualSwitchConfig(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereDistributedVirtualSwitchExists(true),
+				),
 			},
 		},
-		{
-			"multi custom attribute",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereDistributedVirtualSwitchPreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereDistributedVirtualSwitchExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereDistributedVirtualSwitchConfigSingleCustomAttribute(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereDistributedVirtualSwitchExists(true),
-							testAccResourceVSphereDistributedVirtualSwitchCheckCustomAttributes(),
-						),
-					},
-					{
-						Config: testAccResourceVSphereDistributedVirtualSwitchConfigMultiCustomAttribute(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereDistributedVirtualSwitchExists(true),
-							testAccResourceVSphereDistributedVirtualSwitchCheckCustomAttributes(),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereDistributedVirtualSwitch_singleCustomAttribute(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereDistributedVirtualSwitchPreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereDistributedVirtualSwitchExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereDistributedVirtualSwitchConfigSingleCustomAttribute(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereDistributedVirtualSwitchExists(true),
+					testAccResourceVSphereDistributedVirtualSwitchCheckCustomAttributes(),
+				),
 			},
 		},
-	}
+	})
+}
 
-	for _, tc := range testAccResourceVSphereDistributedVirtualSwitchCases {
-		t.Run(tc.name, func(t *testing.T) {
-			tp = t
-			resource.Test(t, tc.testCase)
-		})
-	}
+func TestAccResourceVSphereDistributedVirtualSwitch_multiCustomAttribute(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereDistributedVirtualSwitchPreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereDistributedVirtualSwitchExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereDistributedVirtualSwitchConfigSingleCustomAttribute(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereDistributedVirtualSwitchExists(true),
+					testAccResourceVSphereDistributedVirtualSwitchCheckCustomAttributes(),
+				),
+			},
+			{
+				Config: testAccResourceVSphereDistributedVirtualSwitchConfigMultiCustomAttribute(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereDistributedVirtualSwitchExists(true),
+					testAccResourceVSphereDistributedVirtualSwitchCheckCustomAttributes(),
+				),
+			},
+		},
+	})
 }
 
 func testAccResourceVSphereDistributedVirtualSwitchPreCheck(t *testing.T) {
@@ -623,7 +608,7 @@ func testAccResourceVSphereDistributedVirtualSwitchMatchInventoryPath(expected s
 			return err
 		}
 
-		expected, err := folder.RootPathParticleNetwork.PathFromNewRoot(dvs.InventoryPath, folder.RootPathParticleNetwork, expected)
+		expected, err = folder.RootPathParticleNetwork.PathFromNewRoot(dvs.InventoryPath, folder.RootPathParticleNetwork, expected)
 		actual := path.Dir(dvs.InventoryPath)
 		if err != nil {
 			return fmt.Errorf("bad: %s", err)
diff --git a/vsphere/resource_vsphere_file_test.go b/vsphere/resource_vsphere_file_test.go
index b54ba713d..a7b82cb1f 100644
--- a/vsphere/resource_vsphere_file_test.go
+++ b/vsphere/resource_vsphere_file_test.go
@@ -14,7 +14,7 @@ import (
 )
 
 // Basic file creation (upload to vSphere)
-func TestAccVSphereFile_basic(t *testing.T) {
+func TestAccResourceVSphereFile_basic(t *testing.T) {
 	testVmdkFileData := []byte("# Disk DescriptorFile\n")
 	testVmdkFile := "/tmp/tf_test.vmdk"
 	err := ioutil.WriteFile(testVmdkFile, testVmdkFileData, 0644)
@@ -55,7 +55,7 @@ func TestAccVSphereFile_basic(t *testing.T) {
 }
 
 // Basic file copy within vSphere
-func TestAccVSphereFile_basicUploadAndCopy(t *testing.T) {
+func TestAccResourceVSphereFile_basicUploadAndCopy(t *testing.T) {
 	testVmdkFileData := []byte("# Disk DescriptorFile\n")
 	sourceFile := "/tmp/tf_test.vmdk"
 	uploadResourceName := "myfileupload"
@@ -108,7 +108,7 @@ func TestAccVSphereFile_basicUploadAndCopy(t *testing.T) {
 }
 
 // file creation followed by a rename of file (update)
-func TestAccVSphereFile_renamePostCreation(t *testing.T) {
+func TestAccResourceVSphereFile_renamePostCreation(t *testing.T) {
 	testVmdkFileData := []byte("# Disk DescriptorFile\n")
 	testVmdkFile := "/tmp/tf_test.vmdk"
 	err := ioutil.WriteFile(testVmdkFile, testVmdkFileData, 0644)
@@ -166,7 +166,7 @@ func TestAccVSphereFile_renamePostCreation(t *testing.T) {
 }
 
 // file upload, then copy, finally the copy is renamed (moved) (update)
-func TestAccVSphereFile_uploadAndCopyAndUpdate(t *testing.T) {
+func TestAccResourceVSphereFile_uploadAndCopyAndUpdate(t *testing.T) {
 	testVmdkFileData := []byte("# Disk DescriptorFile\n")
 	sourceFile := "/tmp/tf_test.vmdk"
 	uploadResourceName := "myfileupload"
@@ -266,9 +266,8 @@ func testAccCheckVSphereFileDestroy(s *terraform.State) error {
 
 		_, err = ds.Stat(context.TODO(), rs.Primary.Attributes["destination_file"])
 		if err != nil {
-			switch e := err.(type) {
+			switch err.(type) {
 			case object.DatastoreNoSuchFileError:
-				fmt.Printf("Expected error received: %s\n", e.Error())
 				return nil
 			default:
 				return err
@@ -313,7 +312,6 @@ func testAccCheckVSphereFileExists(n string, df string, exists bool) resource.Te
 				if exists {
 					return fmt.Errorf("File does not exist: %s", e.Error())
 				}
-				fmt.Printf("Expected error received: %s\n", e.Error())
 				return nil
 			default:
 				return err
diff --git a/vsphere/resource_vsphere_folder_migrate_test.go b/vsphere/resource_vsphere_folder_migrate_test.go
index e86d463a9..b3744a4f6 100644
--- a/vsphere/resource_vsphere_folder_migrate_test.go
+++ b/vsphere/resource_vsphere_folder_migrate_test.go
@@ -18,7 +18,7 @@ func testAccResourceVSphereFolderMigrateStatePreCheck(t *testing.T) {
 	}
 }
 
-func TestAccResourceVSphereFolderMigrateState(t *testing.T) {
+func TestAccResourceVSphereFolderMigrateState_basic(t *testing.T) {
 	testAccResourceVSphereFolderMigrateStatePreCheck(t)
 	testAccPreCheck(t)
 
diff --git a/vsphere/resource_vsphere_folder_test.go b/vsphere/resource_vsphere_folder_test.go
index c98c9fbab..edd5aead3 100644
--- a/vsphere/resource_vsphere_folder_test.go
+++ b/vsphere/resource_vsphere_folder_test.go
@@ -19,452 +19,437 @@ const testAccResourceVSphereFolderConfigExpectedAltName = "terraform-renamed-fol
 const testAccResourceVSphereFolderConfigExpectedParentName = "terraform-test-parent"
 const testAccResourceVSphereFolderConfigOOBName = "terraform-test-oob"
 
-func TestAccResourceVSphereFolder(t *testing.T) {
-	var tp *testing.T
-	var s *terraform.State
-	testAccResourceVSphereFolderCases := []struct {
-		name     string
-		testCase resource.TestCase
-	}{
-		{
-			"basic (VM folder)",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereFolderExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereFolderConfigBasic(
-							testAccResourceVSphereFolderConfigExpectedName,
-							folder.VSphereFolderTypeVM,
-						),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereFolderExists(true),
-							testAccResourceVSphereFolderHasName(testAccResourceVSphereFolderConfigExpectedName),
-							testAccResourceVSphereFolderHasType(folder.VSphereFolderTypeVM),
-						),
-					},
-				},
+func TestAccResourceVSphereFolder_vmFolder(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereFolderExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereFolderConfigBasic(
+					testAccResourceVSphereFolderConfigExpectedName,
+					folder.VSphereFolderTypeVM,
+				),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereFolderExists(true),
+					testAccResourceVSphereFolderHasName(testAccResourceVSphereFolderConfigExpectedName),
+					testAccResourceVSphereFolderHasType(folder.VSphereFolderTypeVM),
+				),
 			},
 		},
-		{
-			"datastore folder",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereFolderExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereFolderConfigBasic(
-							testAccResourceVSphereFolderConfigExpectedName,
-							folder.VSphereFolderTypeDatastore,
-						),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereFolderExists(true),
-							testAccResourceVSphereFolderHasName(testAccResourceVSphereFolderConfigExpectedName),
-							testAccResourceVSphereFolderHasType(folder.VSphereFolderTypeDatastore),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereFolder_datastoreFolder(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereFolderExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereFolderConfigBasic(
+					testAccResourceVSphereFolderConfigExpectedName,
+					folder.VSphereFolderTypeDatastore,
+				),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereFolderExists(true),
+					testAccResourceVSphereFolderHasName(testAccResourceVSphereFolderConfigExpectedName),
+					testAccResourceVSphereFolderHasType(folder.VSphereFolderTypeDatastore),
+				),
 			},
 		},
-		{
-			"network folder",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereFolderExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereFolderConfigBasic(
-							testAccResourceVSphereFolderConfigExpectedName,
-							folder.VSphereFolderTypeNetwork,
-						),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereFolderExists(true),
-							testAccResourceVSphereFolderHasName(testAccResourceVSphereFolderConfigExpectedName),
-							testAccResourceVSphereFolderHasType(folder.VSphereFolderTypeNetwork),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereFolder_networkFolder(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereFolderExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereFolderConfigBasic(
+					testAccResourceVSphereFolderConfigExpectedName,
+					folder.VSphereFolderTypeNetwork,
+				),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereFolderExists(true),
+					testAccResourceVSphereFolderHasName(testAccResourceVSphereFolderConfigExpectedName),
+					testAccResourceVSphereFolderHasType(folder.VSphereFolderTypeNetwork),
+				),
 			},
 		},
-		{
-			"host folder",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereFolderExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereFolderConfigBasic(
-							testAccResourceVSphereFolderConfigExpectedName,
-							folder.VSphereFolderTypeHost,
-						),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereFolderExists(true),
-							testAccResourceVSphereFolderHasName(testAccResourceVSphereFolderConfigExpectedName),
-							testAccResourceVSphereFolderHasType(folder.VSphereFolderTypeHost),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereFolder_hostFolder(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereFolderExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereFolderConfigBasic(
+					testAccResourceVSphereFolderConfigExpectedName,
+					folder.VSphereFolderTypeHost,
+				),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereFolderExists(true),
+					testAccResourceVSphereFolderHasName(testAccResourceVSphereFolderConfigExpectedName),
+					testAccResourceVSphereFolderHasType(folder.VSphereFolderTypeHost),
+				),
 			},
 		},
-		{
-			"datacenter folder",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereFolderExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereFolderConfigBasic(
-							testAccResourceVSphereFolderConfigExpectedName,
-							folder.VSphereFolderTypeDatacenter,
-						),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereFolderExists(true),
-							testAccResourceVSphereFolderHasName(testAccResourceVSphereFolderConfigExpectedName),
-							testAccResourceVSphereFolderHasType(folder.VSphereFolderTypeDatacenter),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereFolder_datacenterFolder(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereFolderExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereFolderConfigBasic(
+					testAccResourceVSphereFolderConfigExpectedName,
+					folder.VSphereFolderTypeDatacenter,
+				),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereFolderExists(true),
+					testAccResourceVSphereFolderHasName(testAccResourceVSphereFolderConfigExpectedName),
+					testAccResourceVSphereFolderHasType(folder.VSphereFolderTypeDatacenter),
+				),
 			},
 		},
-		{
-			"rename",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereFolderExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereFolderConfigBasic(
-							testAccResourceVSphereFolderConfigExpectedName,
-							folder.VSphereFolderTypeVM,
-						),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereFolderExists(true),
-							testAccResourceVSphereFolderHasName(testAccResourceVSphereFolderConfigExpectedName),
-							testAccResourceVSphereFolderHasType(folder.VSphereFolderTypeVM),
-						),
-					},
-					{
-						Config: testAccResourceVSphereFolderConfigBasic(
-							testAccResourceVSphereFolderConfigExpectedAltName,
-							folder.VSphereFolderTypeVM,
-						),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereFolderExists(true),
-							testAccResourceVSphereFolderHasName(testAccResourceVSphereFolderConfigExpectedAltName),
-							testAccResourceVSphereFolderHasType(folder.VSphereFolderTypeVM),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereFolder_rename(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereFolderExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereFolderConfigBasic(
+					testAccResourceVSphereFolderConfigExpectedName,
+					folder.VSphereFolderTypeVM,
+				),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereFolderExists(true),
+					testAccResourceVSphereFolderHasName(testAccResourceVSphereFolderConfigExpectedName),
+					testAccResourceVSphereFolderHasType(folder.VSphereFolderTypeVM),
+				),
+			},
+			{
+				Config: testAccResourceVSphereFolderConfigBasic(
+					testAccResourceVSphereFolderConfigExpectedAltName,
+					folder.VSphereFolderTypeVM,
+				),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereFolderExists(true),
+					testAccResourceVSphereFolderHasName(testAccResourceVSphereFolderConfigExpectedAltName),
+					testAccResourceVSphereFolderHasType(folder.VSphereFolderTypeVM),
+				),
 			},
 		},
-		{
-			"subfolder",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereFolderExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereFolderConfigSubFolder(
-							testAccResourceVSphereFolderConfigExpectedName,
-							folder.VSphereFolderTypeVM,
-						),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereFolderExists(true),
-							testAccResourceVSphereFolderHasName(testAccResourceVSphereFolderConfigExpectedName),
-							testAccResourceVSphereFolderHasType(folder.VSphereFolderTypeVM),
-							testAccResourceVSphereFolderHasParent(false, testAccResourceVSphereFolderConfigExpectedParentName),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereFolder_subfolder(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereFolderExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereFolderConfigSubFolder(
+					testAccResourceVSphereFolderConfigExpectedName,
+					folder.VSphereFolderTypeVM,
+				),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereFolderExists(true),
+					testAccResourceVSphereFolderHasName(testAccResourceVSphereFolderConfigExpectedName),
+					testAccResourceVSphereFolderHasType(folder.VSphereFolderTypeVM),
+					testAccResourceVSphereFolderHasParent(false, testAccResourceVSphereFolderConfigExpectedParentName),
+				),
 			},
 		},
-		{
-			"move to subfolder",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereFolderExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereFolderConfigBasic(
-							testAccResourceVSphereFolderConfigExpectedName,
-							folder.VSphereFolderTypeVM,
-						),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereFolderExists(true),
-							testAccResourceVSphereFolderHasName(testAccResourceVSphereFolderConfigExpectedName),
-							testAccResourceVSphereFolderHasType(folder.VSphereFolderTypeVM),
-							testAccResourceVSphereFolderHasParent(true, "vm"),
-						),
-					},
-					{
-						Config: testAccResourceVSphereFolderConfigSubFolder(
-							testAccResourceVSphereFolderConfigExpectedName,
-							folder.VSphereFolderTypeVM,
-						),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereFolderExists(true),
-							testAccResourceVSphereFolderHasName(testAccResourceVSphereFolderConfigExpectedName),
-							testAccResourceVSphereFolderHasType(folder.VSphereFolderTypeVM),
-							testAccResourceVSphereFolderHasParent(false, testAccResourceVSphereFolderConfigExpectedParentName),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereFolder_moveToSubfolder(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereFolderExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereFolderConfigBasic(
+					testAccResourceVSphereFolderConfigExpectedName,
+					folder.VSphereFolderTypeVM,
+				),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereFolderExists(true),
+					testAccResourceVSphereFolderHasName(testAccResourceVSphereFolderConfigExpectedName),
+					testAccResourceVSphereFolderHasType(folder.VSphereFolderTypeVM),
+					testAccResourceVSphereFolderHasParent(true, "vm"),
+				),
+			},
+			{
+				Config: testAccResourceVSphereFolderConfigSubFolder(
+					testAccResourceVSphereFolderConfigExpectedName,
+					folder.VSphereFolderTypeVM,
+				),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereFolderExists(true),
+					testAccResourceVSphereFolderHasName(testAccResourceVSphereFolderConfigExpectedName),
+					testAccResourceVSphereFolderHasType(folder.VSphereFolderTypeVM),
+					testAccResourceVSphereFolderHasParent(false, testAccResourceVSphereFolderConfigExpectedParentName),
+				),
 			},
 		},
-		{
-			"tags",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereFolderExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereFolderConfigTag(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereFolderExists(true),
-							testAccResourceVSphereFolderHasName(testAccResourceVSphereFolderConfigExpectedName),
-							testAccResourceVSphereFolderHasType(folder.VSphereFolderTypeVM),
-							testAccResourceVSphereFolderCheckTags("terraform-test-tag"),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereFolder_tags(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereFolderExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereFolderConfigTag(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereFolderExists(true),
+					testAccResourceVSphereFolderHasName(testAccResourceVSphereFolderConfigExpectedName),
+					testAccResourceVSphereFolderHasType(folder.VSphereFolderTypeVM),
+					testAccResourceVSphereFolderCheckTags("terraform-test-tag"),
+				),
 			},
 		},
-		{
-			"modify tags",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereFolderExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereFolderConfigTag(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereFolderExists(true),
-							testAccResourceVSphereFolderHasName(testAccResourceVSphereFolderConfigExpectedName),
-							testAccResourceVSphereFolderHasType(folder.VSphereFolderTypeVM),
-							testAccResourceVSphereFolderCheckTags("terraform-test-tag"),
-						),
-					},
-					{
-						Config: testAccResourceVSphereFolderConfigMultiTag(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereFolderExists(true),
-							testAccResourceVSphereFolderHasName(testAccResourceVSphereFolderConfigExpectedName),
-							testAccResourceVSphereFolderHasType(folder.VSphereFolderTypeVM),
-							testAccResourceVSphereFolderCheckTags("terraform-test-tags-alt"),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereFolder_modifyTags(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereFolderExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereFolderConfigTag(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereFolderExists(true),
+					testAccResourceVSphereFolderHasName(testAccResourceVSphereFolderConfigExpectedName),
+					testAccResourceVSphereFolderHasType(folder.VSphereFolderTypeVM),
+					testAccResourceVSphereFolderCheckTags("terraform-test-tag"),
+				),
+			},
+			{
+				Config: testAccResourceVSphereFolderConfigMultiTag(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereFolderExists(true),
+					testAccResourceVSphereFolderHasName(testAccResourceVSphereFolderConfigExpectedName),
+					testAccResourceVSphereFolderHasType(folder.VSphereFolderTypeVM),
+					testAccResourceVSphereFolderCheckTags("terraform-test-tags-alt"),
+				),
 			},
 		},
-		{
-			"custom attributes",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereFolderExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereFolderCustomAttribute(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereFolderExists(true),
-							testAccResourceVSphereFolderHasName(testAccResourceVSphereFolderConfigExpectedName),
-							testAccResourceVSphereFolderHasType(folder.VSphereFolderTypeVM),
-							testAccResourceVSphereFolderHasCustomAttributes(),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereFolder_customAttributes(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereFolderExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereFolderCustomAttribute(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereFolderExists(true),
+					testAccResourceVSphereFolderHasName(testAccResourceVSphereFolderConfigExpectedName),
+					testAccResourceVSphereFolderHasType(folder.VSphereFolderTypeVM),
+					testAccResourceVSphereFolderHasCustomAttributes(),
+				),
 			},
 		},
-		{
-			"modify custom attributes",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereFolderExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereFolderCustomAttribute(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereFolderExists(true),
-							testAccResourceVSphereFolderHasName(testAccResourceVSphereFolderConfigExpectedName),
-							testAccResourceVSphereFolderHasType(folder.VSphereFolderTypeVM),
-							testAccResourceVSphereFolderHasCustomAttributes(),
-						),
-					},
-					{
-						Config: testAccResourceVSphereFolderMultiCustomAttributes(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereFolderExists(true),
-							testAccResourceVSphereFolderHasName(testAccResourceVSphereFolderConfigExpectedName),
-							testAccResourceVSphereFolderHasType(folder.VSphereFolderTypeVM),
-							testAccResourceVSphereFolderHasCustomAttributes(),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereFolder_modifyCustomAttributes(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereFolderExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereFolderCustomAttribute(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereFolderExists(true),
+					testAccResourceVSphereFolderHasName(testAccResourceVSphereFolderConfigExpectedName),
+					testAccResourceVSphereFolderHasType(folder.VSphereFolderTypeVM),
+					testAccResourceVSphereFolderHasCustomAttributes(),
+				),
+			},
+			{
+				Config: testAccResourceVSphereFolderMultiCustomAttributes(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereFolderExists(true),
+					testAccResourceVSphereFolderHasName(testAccResourceVSphereFolderConfigExpectedName),
+					testAccResourceVSphereFolderHasType(folder.VSphereFolderTypeVM),
+					testAccResourceVSphereFolderHasCustomAttributes(),
+				),
 			},
 		},
-		{
-			"remove all custom attributes",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereFolderExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereFolderMultiCustomAttributes(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereFolderExists(true),
-							testAccResourceVSphereFolderHasName(testAccResourceVSphereFolderConfigExpectedName),
-							testAccResourceVSphereFolderHasType(folder.VSphereFolderTypeVM),
-							testAccResourceVSphereFolderHasCustomAttributes(),
-						),
-					},
-					{
-						Config: testAccResourceVSphereFolderRemovedCustomAttributes(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereFolderExists(true),
-							testAccResourceVSphereFolderHasName(testAccResourceVSphereFolderConfigExpectedName),
-							testAccResourceVSphereFolderHasType(folder.VSphereFolderTypeVM),
-							testAccResourceVSphereFolderHasCustomAttributes(),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereFolder_removeAllCustomAttributes(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereFolderExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereFolderMultiCustomAttributes(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereFolderExists(true),
+					testAccResourceVSphereFolderHasName(testAccResourceVSphereFolderConfigExpectedName),
+					testAccResourceVSphereFolderHasType(folder.VSphereFolderTypeVM),
+					testAccResourceVSphereFolderHasCustomAttributes(),
+				),
+			},
+			{
+				Config: testAccResourceVSphereFolderRemovedCustomAttributes(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereFolderExists(true),
+					testAccResourceVSphereFolderHasName(testAccResourceVSphereFolderConfigExpectedName),
+					testAccResourceVSphereFolderHasType(folder.VSphereFolderTypeVM),
+					testAccResourceVSphereFolderHasCustomAttributes(),
+				),
 			},
 		},
-		{
-			"prevent delete if not empty",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
+	})
+}
+
+func TestAccResourceVSphereFolder_preventDeleteIfNotEmpty(t *testing.T) {
+	var s *terraform.State
+
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereFolderExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereFolderConfigBasic(
+					testAccResourceVSphereFolderConfigExpectedName,
+					folder.VSphereFolderTypeVM,
+				),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereFolderExists(true),
+					testAccResourceVSphereFolderHasName(testAccResourceVSphereFolderConfigExpectedName),
+					testAccResourceVSphereFolderHasType(folder.VSphereFolderTypeVM),
+					copyStatePtr(&s),
+				),
+			},
+			{
+				PreConfig: func() {
+					if err := testAccResourceVSphereFolderCreateOOB(s); err != nil {
+						panic(err)
+					}
 				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereFolderExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereFolderConfigBasic(
-							testAccResourceVSphereFolderConfigExpectedName,
-							folder.VSphereFolderTypeVM,
-						),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereFolderExists(true),
-							testAccResourceVSphereFolderHasName(testAccResourceVSphereFolderConfigExpectedName),
-							testAccResourceVSphereFolderHasType(folder.VSphereFolderTypeVM),
-							copyStatePtr(&s),
-						),
-					},
-					{
-						PreConfig: func() {
-							if err := testAccResourceVSphereFolderCreateOOB(s); err != nil {
-								panic(err)
-							}
-						},
-						Config: testAccResourceVSphereFolderConfigBasic(
-							testAccResourceVSphereFolderConfigExpectedName,
-							folder.VSphereFolderTypeVM,
-						),
-						Destroy:     true,
-						ExpectError: regexp.MustCompile("folder is not empty, please remove all items before deleting"),
-					},
-					{
-						PreConfig: func() {
-							if err := testAccResourceVSphereFolderDeleteOOB(s); err != nil {
-								panic(err)
-							}
-						},
-						Config: testAccResourceVSphereFolderConfigBasic(
-							testAccResourceVSphereFolderConfigExpectedName,
-							folder.VSphereFolderTypeVM,
-						),
-					},
+				Config: testAccResourceVSphereFolderConfigBasic(
+					testAccResourceVSphereFolderConfigExpectedName,
+					folder.VSphereFolderTypeVM,
+				),
+				Destroy:     true,
+				ExpectError: regexp.MustCompile("folder is not empty, please remove all items before deleting"),
+			},
+			{
+				PreConfig: func() {
+					if err := testAccResourceVSphereFolderDeleteOOB(s); err != nil {
+						panic(err)
+					}
 				},
+				Config: testAccResourceVSphereFolderConfigBasic(
+					testAccResourceVSphereFolderConfigExpectedName,
+					folder.VSphereFolderTypeVM,
+				),
 			},
 		},
-		{
-			"import",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereFolderExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereFolderConfigBasic(
-							testAccResourceVSphereFolderConfigExpectedName,
-							folder.VSphereFolderTypeVM,
-						),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereFolderExists(true),
-						),
-					},
-					{
-						ResourceName:      "vsphere_folder.folder",
-						ImportState:       true,
-						ImportStateVerify: true,
-						ImportStateIdFunc: func(s *terraform.State) (string, error) {
-							folder, err := testGetFolder(s, "folder")
-							if err != nil {
-								return "", err
-							}
-							return folder.InventoryPath, nil
-						},
-						Config: testAccResourceVSphereFolderConfigBasic(
-							testAccResourceVSphereFolderConfigExpectedName,
-							folder.VSphereFolderTypeVM,
-						),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereFolderExists(true),
-							testAccResourceVSphereFolderHasName(testAccResourceVSphereFolderConfigExpectedName),
-							testAccResourceVSphereFolderHasType(folder.VSphereFolderTypeVM),
-						),
-					},
+	})
+}
+
+func TestAccResourceVSphereFolder_import(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereFolderExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereFolderConfigBasic(
+					testAccResourceVSphereFolderConfigExpectedName,
+					folder.VSphereFolderTypeVM,
+				),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereFolderExists(true),
+				),
+			},
+			{
+				ResourceName:      "vsphere_folder.folder",
+				ImportState:       true,
+				ImportStateVerify: true,
+				ImportStateIdFunc: func(s *terraform.State) (string, error) {
+					folder, err := testGetFolder(s, "folder")
+					if err != nil {
+						return "", err
+					}
+					return folder.InventoryPath, nil
 				},
+				Config: testAccResourceVSphereFolderConfigBasic(
+					testAccResourceVSphereFolderConfigExpectedName,
+					folder.VSphereFolderTypeVM,
+				),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereFolderExists(true),
+					testAccResourceVSphereFolderHasName(testAccResourceVSphereFolderConfigExpectedName),
+					testAccResourceVSphereFolderHasType(folder.VSphereFolderTypeVM),
+				),
 			},
 		},
-	}
-
-	for _, tc := range testAccResourceVSphereFolderCases {
-		t.Run(tc.name, func(t *testing.T) {
-			tp = t
-			resource.Test(t, tc.testCase)
-		})
-	}
+	})
 }
 
 func testAccResourceVSphereFolderExists(expected bool) resource.TestCheckFunc {
diff --git a/vsphere/resource_vsphere_host_port_group_test.go b/vsphere/resource_vsphere_host_port_group_test.go
index f84eb8e82..b66fd7488 100644
--- a/vsphere/resource_vsphere_host_port_group_test.go
+++ b/vsphere/resource_vsphere_host_port_group_test.go
@@ -10,91 +10,75 @@ import (
 	"github.com/hashicorp/terraform/terraform"
 )
 
-func TestAccResourceVSphereHostPortGroup(t *testing.T) {
-	var tp *testing.T
-	testAccResourceVSphereHostPortGroupCases := []struct {
-		name     string
-		testCase resource.TestCase
-	}{
-		{
-			"basic, inherited policy",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereHostPortGroupPreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereHostPortGroupExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereHostPortGroupConfig(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereHostPortGroupExists(true),
-						),
-					},
-				},
-			},
+func TestAccResourceVSphereHostPortGroup_basic(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereHostPortGroupPreCheck(t)
 		},
-		{
-			"more complex configuration and overridden attributes",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereHostPortGroupPreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereHostPortGroupExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereHostPortGroupConfigWithOverrides(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereHostPortGroupExists(true),
-							testAccResourceVSphereHostPortGroupCheckVlan(1000),
-							testAccResourceVSphereHostPortGroupCheckEffectiveActive([]string{os.Getenv("VSPHERE_HOST_NIC0")}),
-							testAccResourceVSphereHostPortGroupCheckEffectiveStandby([]string{os.Getenv("VSPHERE_HOST_NIC1")}),
-							testAccResourceVSphereHostPortGroupCheckEffectivePromisc(true),
-						),
-					},
-				},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereHostPortGroupExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereHostPortGroupConfig(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereHostPortGroupExists(true),
+				),
 			},
 		},
-		{
-			"basic, then complex config",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereHostPortGroupPreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereHostPortGroupExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereHostPortGroupConfig(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereHostPortGroupExists(true),
-						),
-					},
-					{
-						Config: testAccResourceVSphereHostPortGroupConfigWithOverrides(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereHostPortGroupExists(true),
-							testAccResourceVSphereHostPortGroupCheckVlan(1000),
-							testAccResourceVSphereHostPortGroupCheckEffectiveActive([]string{os.Getenv("VSPHERE_HOST_NIC0")}),
-							testAccResourceVSphereHostPortGroupCheckEffectiveStandby([]string{os.Getenv("VSPHERE_HOST_NIC1")}),
-							testAccResourceVSphereHostPortGroupCheckEffectivePromisc(true),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereHostPortGroup_complexWithOverrides(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereHostPortGroupPreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereHostPortGroupExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereHostPortGroupConfigWithOverrides(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereHostPortGroupExists(true),
+					testAccResourceVSphereHostPortGroupCheckVlan(1000),
+					testAccResourceVSphereHostPortGroupCheckEffectiveActive([]string{os.Getenv("VSPHERE_HOST_NIC0")}),
+					testAccResourceVSphereHostPortGroupCheckEffectiveStandby([]string{os.Getenv("VSPHERE_HOST_NIC1")}),
+					testAccResourceVSphereHostPortGroupCheckEffectivePromisc(true),
+				),
 			},
 		},
-	}
+	})
+}
 
-	for _, tc := range testAccResourceVSphereHostPortGroupCases {
-		t.Run(tc.name, func(t *testing.T) {
-			tp = t
-			resource.Test(t, tc.testCase)
-		})
-	}
+func TestAccResourceVSphereHostPortGroup_basicToComplex(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereHostPortGroupPreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereHostPortGroupExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereHostPortGroupConfig(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereHostPortGroupExists(true),
+				),
+			},
+			{
+				Config: testAccResourceVSphereHostPortGroupConfigWithOverrides(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereHostPortGroupExists(true),
+					testAccResourceVSphereHostPortGroupCheckVlan(1000),
+					testAccResourceVSphereHostPortGroupCheckEffectiveActive([]string{os.Getenv("VSPHERE_HOST_NIC0")}),
+					testAccResourceVSphereHostPortGroupCheckEffectiveStandby([]string{os.Getenv("VSPHERE_HOST_NIC1")}),
+					testAccResourceVSphereHostPortGroupCheckEffectivePromisc(true),
+				),
+			},
+		},
+	})
 }
 
 func testAccResourceVSphereHostPortGroupPreCheck(t *testing.T) {
diff --git a/vsphere/resource_vsphere_host_virtual_switch_test.go b/vsphere/resource_vsphere_host_virtual_switch_test.go
index 777b18df3..79531bd1d 100644
--- a/vsphere/resource_vsphere_host_virtual_switch_test.go
+++ b/vsphere/resource_vsphere_host_virtual_switch_test.go
@@ -11,196 +11,180 @@ import (
 	"github.com/hashicorp/terraform/terraform"
 )
 
-func TestAccResourceVSphereHostVirtualSwitch(t *testing.T) {
-	var tp *testing.T
-	testAccResourceVSphereHostVirtualSwitchCases := []struct {
-		name     string
-		testCase resource.TestCase
-	}{
-		{
-			"basic",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereHostVirtualSwitchPreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereHostVirtualSwitchExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereHostVirtualSwitchConfig(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereHostVirtualSwitchExists(true),
-						),
-					},
-				},
-			},
+func TestAccResourceVSphereHostVirtualSwitch_basic(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereHostVirtualSwitchPreCheck(t)
 		},
-		{
-			"basic, then remove a NIC",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereHostVirtualSwitchPreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereHostVirtualSwitchExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereHostVirtualSwitchConfig(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereHostVirtualSwitchExists(true),
-						),
-					},
-					{
-						Config: testAccResourceVSphereHostVirtualSwitchConfigSingleNIC(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereHostVirtualSwitchExists(true),
-						),
-					},
-				},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereHostVirtualSwitchExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereHostVirtualSwitchConfig(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereHostVirtualSwitchExists(true),
+				),
 			},
 		},
-		{
-			"create with no NICs",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereHostVirtualSwitchPreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereHostVirtualSwitchExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereHostVirtualSwitchConfigNoNIC(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereHostVirtualSwitchExists(true),
-							testAccResourceVSphereHostVirtualSwitchNoBridge(),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereHostVirtualSwitch_removeNIC(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereHostVirtualSwitchPreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereHostVirtualSwitchExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereHostVirtualSwitchConfig(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereHostVirtualSwitchExists(true),
+				),
 			},
+			{
+				Config: testAccResourceVSphereHostVirtualSwitchConfigSingleNIC(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereHostVirtualSwitchExists(true),
+				),
+			},
+		},
+	})
+}
+
+func TestAccResourceVSphereHostVirtualSwitch_noNICs(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereHostVirtualSwitchPreCheck(t)
 		},
-		{
-			"bad active NIC list",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereHostVirtualSwitchPreCheck(tp)
-				},
-				Providers: testAccProviders,
-				Steps: []resource.TestStep{
-					{
-						Config:      testAccResourceVSphereHostVirtualSwitchConfigBadActive(),
-						ExpectError: regexp.MustCompile(fmt.Sprintf("active NIC entry %q not present in network_adapters list", os.Getenv("VSPHERE_HOST_NIC0"))),
-						PlanOnly:    true,
-					},
-					{
-						Config: testAccResourceVSphereEmpty,
-						Check:  resource.ComposeTestCheckFunc(),
-					},
-				},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereHostVirtualSwitchExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereHostVirtualSwitchConfigNoNIC(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereHostVirtualSwitchExists(true),
+					testAccResourceVSphereHostVirtualSwitchNoBridge(),
+				),
 			},
 		},
-		{
-			"bad standby NIC list",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereHostVirtualSwitchPreCheck(tp)
-				},
-				Providers: testAccProviders,
-				Steps: []resource.TestStep{
-					{
-						Config:      testAccResourceVSphereHostVirtualSwitchConfigBadStandby(),
-						ExpectError: regexp.MustCompile(fmt.Sprintf("standby NIC entry %q not present in network_adapters list", os.Getenv("VSPHERE_HOST_NIC0"))),
-						PlanOnly:    true,
-					},
-					{
-						Config: testAccResourceVSphereEmpty,
-						Check:  resource.ComposeTestCheckFunc(),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereHostVirtualSwitch_badActiveNICList(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereHostVirtualSwitchPreCheck(t)
+		},
+		Providers: testAccProviders,
+		Steps: []resource.TestStep{
+			{
+				Config:      testAccResourceVSphereHostVirtualSwitchConfigBadActive(),
+				ExpectError: regexp.MustCompile(fmt.Sprintf("active NIC entry %q not present in network_adapters list", os.Getenv("VSPHERE_HOST_NIC0"))),
+				PlanOnly:    true,
+			},
+			{
+				Config: testAccResourceVSphereEmpty,
+				Check:  resource.ComposeTestCheckFunc(),
 			},
 		},
-		{
-			"basic, then remove all NICs",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereHostVirtualSwitchPreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereHostVirtualSwitchExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereHostVirtualSwitchConfig(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereHostVirtualSwitchExists(true),
-						),
-					},
-					{
-						Config: testAccResourceVSphereHostVirtualSwitchConfigNoNIC(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereHostVirtualSwitchExists(true),
-							testAccResourceVSphereHostVirtualSwitchNoBridge(),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereHostVirtualSwitch_badStandbyNICList(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereHostVirtualSwitchPreCheck(t)
+		},
+		Providers: testAccProviders,
+		Steps: []resource.TestStep{
+			{
+				Config:      testAccResourceVSphereHostVirtualSwitchConfigBadStandby(),
+				ExpectError: regexp.MustCompile(fmt.Sprintf("standby NIC entry %q not present in network_adapters list", os.Getenv("VSPHERE_HOST_NIC0"))),
+				PlanOnly:    true,
 			},
+			{
+				Config: testAccResourceVSphereEmpty,
+				Check:  resource.ComposeTestCheckFunc(),
+			},
+		},
+	})
+}
+
+func TestAccResourceVSphereHostVirtualSwitch_removeAllNICs(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereHostVirtualSwitchPreCheck(t)
 		},
-		{
-			"standby with explicit failover order",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereHostVirtualSwitchPreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereHostVirtualSwitchExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereHostVirtualSwitchConfigStandbyLink(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereHostVirtualSwitchExists(true),
-						),
-					},
-				},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereHostVirtualSwitchExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereHostVirtualSwitchConfig(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereHostVirtualSwitchExists(true),
+				),
 			},
+			{
+				Config: testAccResourceVSphereHostVirtualSwitchConfigNoNIC(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereHostVirtualSwitchExists(true),
+					testAccResourceVSphereHostVirtualSwitchNoBridge(),
+				),
+			},
+		},
+	})
+}
+
+func TestAccResourceVSphereHostVirtualSwitch_standbyWithExplicitFailoverOrder(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereHostVirtualSwitchPreCheck(t)
 		},
-		{
-			"basic, then change to standby with failover order",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereHostVirtualSwitchPreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereHostVirtualSwitchExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereHostVirtualSwitchConfig(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereHostVirtualSwitchExists(true),
-						),
-					},
-					{
-						Config: testAccResourceVSphereHostVirtualSwitchConfigStandbyLink(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereHostVirtualSwitchExists(true),
-						),
-					},
-				},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereHostVirtualSwitchExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereHostVirtualSwitchConfigStandbyLink(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereHostVirtualSwitchExists(true),
+				),
 			},
 		},
-	}
+	})
+}
 
-	for _, tc := range testAccResourceVSphereHostVirtualSwitchCases {
-		t.Run(tc.name, func(t *testing.T) {
-			tp = t
-			resource.Test(t, tc.testCase)
-		})
-	}
+func TestAccResourceVSphereHostVirtualSwitch_changeToStandby(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereHostVirtualSwitchPreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereHostVirtualSwitchExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereHostVirtualSwitchConfig(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereHostVirtualSwitchExists(true),
+				),
+			},
+			{
+				Config: testAccResourceVSphereHostVirtualSwitchConfigStandbyLink(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereHostVirtualSwitchExists(true),
+				),
+			},
+		},
+	})
 }
 
 func testAccResourceVSphereHostVirtualSwitchPreCheck(t *testing.T) {
diff --git a/vsphere/resource_vsphere_license_test.go b/vsphere/resource_vsphere_license_test.go
index 29443a6da..70192f238 100644
--- a/vsphere/resource_vsphere_license_test.go
+++ b/vsphere/resource_vsphere_license_test.go
@@ -20,7 +20,7 @@ resource "vsphere_license" "foo" {
 }
 `
 
-func TestAccVSphereLicenseBasic(t *testing.T) {
+func TestAccResourceVSphereLicense_basic(t *testing.T) {
 
 	resource.Test(t, resource.TestCase{
 		PreCheck: func() {
@@ -41,7 +41,7 @@ func TestAccVSphereLicenseBasic(t *testing.T) {
 
 }
 
-func TestAccVSphereLicenseInvalid(t *testing.T) {
+func TestAccResourceVSphereLicense_invalid(t *testing.T) {
 
 	resource.Test(t, resource.TestCase{
 		PreCheck: func() {
@@ -61,7 +61,7 @@ func TestAccVSphereLicenseInvalid(t *testing.T) {
 
 }
 
-func TestAccVSphereLicenseWithLabelsOnVCenter(t *testing.T) {
+func TestAccResourceVSphereLicense_withLabelsOnVCenter(t *testing.T) {
 
 	resource.Test(t, resource.TestCase{
 		PreCheck: func() {
@@ -82,7 +82,7 @@ func TestAccVSphereLicenseWithLabelsOnVCenter(t *testing.T) {
 
 }
 
-func TestAccVSphereLicenseWithLabelsOnESXiServer(t *testing.T) {
+func TestAccResourceVSphereLicense_withLabelsOnESXiServer(t *testing.T) {
 
 	resource.Test(t, resource.TestCase{
 		PreCheck: func() {
diff --git a/vsphere/resource_vsphere_nas_datastore_test.go b/vsphere/resource_vsphere_nas_datastore_test.go
index a30c5ac02..cc616c5d3 100644
--- a/vsphere/resource_vsphere_nas_datastore_test.go
+++ b/vsphere/resource_vsphere_nas_datastore_test.go
@@ -13,306 +13,290 @@ import (
 	"github.com/terraform-providers/terraform-provider-vsphere/vsphere/internal/helper/viapi"
 )
 
-func TestAccResourceVSphereNasDatastore(t *testing.T) {
-	var tp *testing.T
-	testAccResourceVSphereNasDatastoreCases := []struct {
-		name     string
-		testCase resource.TestCase
-	}{
-		{
-			"basic",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereNasDatastorePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereNasDatastoreExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereNasDatastoreConfigBasic(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereNasDatastoreExists(true),
-						),
-					},
-				},
-			},
+func TestAccResourceVSphereNasDatastore_basic(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereNasDatastorePreCheck(t)
 		},
-		{
-			"multi-host",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereNasDatastorePreCheck(tp)
-					testAccSkipIfEsxi(tp)
-				},
-				Providers: testAccProviders,
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereNasDatastoreConfigMultiHost(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereNasDatastoreExists(true),
-						),
-					},
-				},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereNasDatastoreExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereNasDatastoreConfigBasic(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereNasDatastoreExists(true),
+				),
 			},
 		},
-		{
-			"basic, then multi-host",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereNasDatastorePreCheck(tp)
-				},
-				Providers: testAccProviders,
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereNasDatastoreConfigBasic(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereNasDatastoreExists(true),
-						),
-					},
-					{
-						Config:      testAccResourceVSphereNasDatastoreConfigMultiHost(),
-						ExpectError: expectErrorIfNotVirtualCenter(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereNasDatastoreExists(true),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereNasDatastore_multiHost(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereNasDatastorePreCheck(t)
+			testAccSkipIfEsxi(t)
+		},
+		Providers: testAccProviders,
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereNasDatastoreConfigMultiHost(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereNasDatastoreExists(true),
+				),
 			},
 		},
-		{
-			"multi-host, then basic",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereNasDatastorePreCheck(tp)
-					testAccSkipIfEsxi(tp)
-				},
-				Providers: testAccProviders,
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereNasDatastoreConfigMultiHost(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereNasDatastoreExists(true),
-						),
-					},
-					{
-						Config: testAccResourceVSphereNasDatastoreConfigBasic(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereNasDatastoreExists(true),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereNasDatastore_basicToMultiHost(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereNasDatastorePreCheck(t)
+		},
+		Providers: testAccProviders,
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereNasDatastoreConfigBasic(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereNasDatastoreExists(true),
+				),
+			},
+			{
+				Config:      testAccResourceVSphereNasDatastoreConfigMultiHost(),
+				ExpectError: expectErrorIfNotVirtualCenter(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereNasDatastoreExists(true),
+				),
 			},
 		},
-		{
-			"rename datastore",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereNasDatastorePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereNasDatastoreExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereNasDatastoreConfigBasic(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereNasDatastoreExists(true),
-						),
-					},
-					{
-						Config: testAccResourceVSphereNasDatastoreConfigBasicAltName(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereNasDatastoreExists(true),
-							testAccResourceVSphereNasDatastoreHasName("terraform-test-nas-renamed"),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereNasDatastore_multiHostToBasic(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereNasDatastorePreCheck(t)
+			testAccSkipIfEsxi(t)
+		},
+		Providers: testAccProviders,
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereNasDatastoreConfigMultiHost(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereNasDatastoreExists(true),
+				),
+			},
+			{
+				Config: testAccResourceVSphereNasDatastoreConfigBasic(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereNasDatastoreExists(true),
+				),
 			},
 		},
-		{
-			"with folder",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereNasDatastorePreCheck(tp)
-					// NOTE: This test can't run on ESXi without giving a "dangling
-					// resource" error during testing - "move to folder after" hits the
-					// error on the same path of the call stack that triggers an error in
-					// both create and update and should provide adequate coverage
-					// barring manual testing.
-					testAccSkipIfEsxi(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereNasDatastoreExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereNasDatastoreConfigBasicFolder(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereNasDatastoreExists(true),
-							testAccResourceVSphereNasDatastoreMatchInventoryPath(os.Getenv("VSPHERE_DS_FOLDER")),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereNasDatastore_renameDatastore(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereNasDatastorePreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereNasDatastoreExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereNasDatastoreConfigBasic(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereNasDatastoreExists(true),
+				),
+			},
+			{
+				Config: testAccResourceVSphereNasDatastoreConfigBasicAltName(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereNasDatastoreExists(true),
+					testAccResourceVSphereNasDatastoreHasName("terraform-test-nas-renamed"),
+				),
 			},
 		},
-		{
-			"move to folder after",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereNasDatastorePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereNasDatastoreExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereNasDatastoreConfigBasic(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereNasDatastoreExists(true),
-						),
-					},
-					{
-						Config:      testAccResourceVSphereNasDatastoreConfigBasicFolder(),
-						ExpectError: expectErrorIfNotVirtualCenter(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereNasDatastoreExists(true),
-							testAccResourceVSphereNasDatastoreMatchInventoryPath(os.Getenv("VSPHERE_DS_FOLDER")),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereNasDatastore_inFolder(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereNasDatastorePreCheck(t)
+			// NOTE: This test can't run on ESXi without giving a "dangling
+			// resource" error during testing - "move to folder after" hits the
+			// error on the same path of the call stack that triggers an error in
+			// both create and update and should provide adequate coverage
+			// barring manual testing.
+			testAccSkipIfEsxi(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereNasDatastoreExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereNasDatastoreConfigBasicFolder(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereNasDatastoreExists(true),
+					testAccResourceVSphereNasDatastoreMatchInventoryPath(os.Getenv("VSPHERE_DS_FOLDER")),
+				),
 			},
 		},
-		{
-			"single tag",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereNasDatastorePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereNasDatastoreExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereNasDatastoreConfigBasicTags(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereNasDatastoreExists(true),
-							testAccResourceVSphereDatastoreCheckTags("vsphere_nas_datastore.datastore", "terraform-test-tag"),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereNasDatastore_moveToFolder(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereNasDatastorePreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereNasDatastoreExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereNasDatastoreConfigBasic(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereNasDatastoreExists(true),
+				),
+			},
+			{
+				Config:      testAccResourceVSphereNasDatastoreConfigBasicFolder(),
+				ExpectError: expectErrorIfNotVirtualCenter(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereNasDatastoreExists(true),
+					testAccResourceVSphereNasDatastoreMatchInventoryPath(os.Getenv("VSPHERE_DS_FOLDER")),
+				),
 			},
 		},
-		{
-			"modify tags",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereNasDatastorePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereNasDatastoreExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereNasDatastoreConfigBasicTags(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereNasDatastoreExists(true),
-							testAccResourceVSphereDatastoreCheckTags("vsphere_nas_datastore.datastore", "terraform-test-tag"),
-						),
-					},
-					{
-						Config: testAccResourceVSphereNasDatastoreConfigMultiTags(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereNasDatastoreExists(true),
-							testAccResourceVSphereDatastoreCheckTags("vsphere_nas_datastore.datastore", "terraform-test-tags-alt"),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereNasDatastore_singleTag(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereNasDatastorePreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereNasDatastoreExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereNasDatastoreConfigBasicTags(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereNasDatastoreExists(true),
+					testAccResourceVSphereDatastoreCheckTags("vsphere_nas_datastore.datastore", "terraform-test-tag"),
+				),
 			},
 		},
-		{
-			"import",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereNasDatastorePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereNasDatastoreExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereNasDatastoreConfigBasic(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereNasDatastoreExists(true),
-						),
-					},
-					{
-						Config:            testAccResourceVSphereNasDatastoreConfigBasic(),
-						ImportState:       true,
-						ResourceName:      "vsphere_nas_datastore.datastore",
-						ImportStateVerify: true,
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereNasDatastore_modifyTags(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereNasDatastorePreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereNasDatastoreExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereNasDatastoreConfigBasicTags(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereNasDatastoreExists(true),
+					testAccResourceVSphereDatastoreCheckTags("vsphere_nas_datastore.datastore", "terraform-test-tag"),
+				),
+			},
+			{
+				Config: testAccResourceVSphereNasDatastoreConfigMultiTags(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereNasDatastoreExists(true),
+					testAccResourceVSphereDatastoreCheckTags("vsphere_nas_datastore.datastore", "terraform-test-tags-alt"),
+				),
 			},
 		},
-		{
-			"single custom attribute",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereNasDatastorePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereNasDatastoreExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereNasDatastoreConfigSingleCustomAttribute(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereNasDatastoreExists(true),
-							testAccResourceVSphereNasDatastoreHasCustomAttributes(),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereNasDatastore_import(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereNasDatastorePreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereNasDatastoreExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereNasDatastoreConfigBasic(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereNasDatastoreExists(true),
+				),
+			},
+			{
+				Config:            testAccResourceVSphereNasDatastoreConfigBasic(),
+				ImportState:       true,
+				ResourceName:      "vsphere_nas_datastore.datastore",
+				ImportStateVerify: true,
 			},
 		},
-		{
-			"multi custom attribute",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereNasDatastorePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereNasDatastoreExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereNasDatastoreConfigSingleCustomAttribute(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereNasDatastoreExists(true),
-							testAccResourceVSphereNasDatastoreHasCustomAttributes(),
-						),
-					},
-					{
-						Config: testAccResourceVSphereNasDatastoreConfigMultiCustomAttributes(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereNasDatastoreExists(true),
-							testAccResourceVSphereNasDatastoreHasCustomAttributes(),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereNasDatastore_singleCustomAttribute(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereNasDatastorePreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereNasDatastoreExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereNasDatastoreConfigSingleCustomAttribute(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereNasDatastoreExists(true),
+					testAccResourceVSphereNasDatastoreHasCustomAttributes(),
+				),
 			},
 		},
-	}
+	})
+}
 
-	for _, tc := range testAccResourceVSphereNasDatastoreCases {
-		t.Run(tc.name, func(t *testing.T) {
-			tp = t
-			resource.Test(t, tc.testCase)
-		})
-	}
+func TestAccResourceVSphereNasDatastore_multiCustomAttribute(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereNasDatastorePreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereNasDatastoreExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereNasDatastoreConfigSingleCustomAttribute(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereNasDatastoreExists(true),
+					testAccResourceVSphereNasDatastoreHasCustomAttributes(),
+				),
+			},
+			{
+				Config: testAccResourceVSphereNasDatastoreConfigMultiCustomAttributes(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereNasDatastoreExists(true),
+					testAccResourceVSphereNasDatastoreHasCustomAttributes(),
+				),
+			},
+		},
+	})
 }
 
 func testAccResourceVSphereNasDatastorePreCheck(t *testing.T) {
@@ -380,7 +364,7 @@ func testAccResourceVSphereNasDatastoreMatchInventoryPath(expected string) resou
 			return err
 		}
 
-		expected, err := folder.RootPathParticleDatastore.PathFromNewRoot(ds.InventoryPath, folder.RootPathParticleDatastore, expected)
+		expected, err = folder.RootPathParticleDatastore.PathFromNewRoot(ds.InventoryPath, folder.RootPathParticleDatastore, expected)
 		actual := path.Dir(ds.InventoryPath)
 		if err != nil {
 			return fmt.Errorf("bad: %s", err)
diff --git a/vsphere/resource_vsphere_tag_category_test.go b/vsphere/resource_vsphere_tag_category_test.go
index 8ca0a2060..54fea3932 100644
--- a/vsphere/resource_vsphere_tag_category_test.go
+++ b/vsphere/resource_vsphere_tag_category_test.go
@@ -13,174 +13,177 @@ import (
 	"github.com/hashicorp/terraform/terraform"
 )
 
-func TestAccResourceVSphereTagCategory(t *testing.T) {
-	var tp *testing.T
-	testAccResourceVSphereTagCategoryCases := []struct {
-		name     string
-		testCase resource.TestCase
-	}{
-		{
-			"basic",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereTagCategoryExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereTagCategoryConfigBasic,
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereTagCategoryExists(true),
-							testAccResourceVSphereTagCategoryHasName("terraform-test-category"),
-							testAccResourceVSphereTagCategoryHasCardinality(vSphereTagCategoryCardinalitySingle),
-							testAccResourceVSphereTagCategoryHasTypes([]string{
-								vSphereTagTypeVirtualMachine,
-							}),
-						),
-					},
-				},
+func TestAccResourceVSphereTagCategory_basic(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereTagCategoryExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereTagCategoryConfigBasic,
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereTagCategoryExists(true),
+					testAccResourceVSphereTagCategoryHasName("terraform-test-category"),
+					testAccResourceVSphereTagCategoryHasCardinality(vSphereTagCategoryCardinalitySingle),
+					testAccResourceVSphereTagCategoryHasTypes([]string{
+						vSphereTagTypeVirtualMachine,
+					}),
+				),
 			},
 		},
-		{
-			"add type",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereTagCategoryExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereTagCategoryConfigBasic,
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereTagCategoryExists(true),
-							testAccResourceVSphereTagCategoryHasTypes([]string{
-								vSphereTagTypeVirtualMachine,
-							}),
-						),
-					},
-					{
-						Config: testAccResourceVSphereTagCategoryConfigMultiType,
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereTagCategoryExists(true),
-							testAccResourceVSphereTagCategoryHasTypes([]string{
-								vSphereTagTypeVirtualMachine,
-								vSphereTagTypeDatastore,
-							}),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereTagCategory_addType(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereTagCategoryExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereTagCategoryConfigBasic,
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereTagCategoryExists(true),
+					testAccResourceVSphereTagCategoryHasTypes([]string{
+						vSphereTagTypeVirtualMachine,
+					}),
+				),
+			},
+			{
+				Config: testAccResourceVSphereTagCategoryConfigMultiType,
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereTagCategoryExists(true),
+					testAccResourceVSphereTagCategoryHasTypes([]string{
+						vSphereTagTypeVirtualMachine,
+						vSphereTagTypeDatastore,
+					}),
+				),
 			},
 		},
-		{
-			"remove type, should error",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereTagCategoryExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereTagCategoryConfigMultiType,
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereTagCategoryExists(true),
-						),
-					},
-					{
-						Config:      testAccResourceVSphereTagCategoryConfigBasic,
-						ExpectError: regexp.MustCompile("removal of associable types is not supported"),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereTagCategory_removeTypeShouldError(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereTagCategoryExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereTagCategoryConfigMultiType,
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereTagCategoryExists(true),
+				),
+			},
+			{
+				Config:      testAccResourceVSphereTagCategoryConfigBasic,
+				ExpectError: regexp.MustCompile("removal of associable types is not supported"),
 			},
 		},
-		{
-			"rename",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereTagCategoryExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereTagCategoryConfigBasic,
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereTagCategoryExists(true),
-						),
-					},
-					{
-						Config: testAccResourceVSphereTagCategoryConfigAltName,
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereTagCategoryExists(true),
-							testAccResourceVSphereTagCategoryHasName("terraform-test-category-renamed"),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereTagCategory_rename(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereTagCategoryExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereTagCategoryConfigBasic,
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereTagCategoryExists(true),
+				),
+			},
+			{
+				Config: testAccResourceVSphereTagCategoryConfigAltName,
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereTagCategoryExists(true),
+					testAccResourceVSphereTagCategoryHasName("terraform-test-category-renamed"),
+				),
 			},
 		},
-		{
-			"single cardinality",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereTagCategoryExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereTagCategoryConfigSingleCardinality,
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereTagCategoryExists(true),
-							testAccResourceVSphereTagCategoryHasCardinality(vSphereTagCategoryCardinalitySingle),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereTagCategory_singleCardinality(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereTagCategoryExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereTagCategoryConfigSingleCardinality,
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereTagCategoryExists(true),
+					testAccResourceVSphereTagCategoryHasCardinality(vSphereTagCategoryCardinalitySingle),
+				),
 			},
 		},
-		{
-			"import",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereTagCategoryExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereTagCategoryConfigBasic,
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereTagCategoryExists(true),
-						),
-					},
-					{
-						ResourceName:      "vsphere_tag_category.terraform-test-category",
-						ImportState:       true,
-						ImportStateVerify: true,
-						ImportStateIdFunc: func(s *terraform.State) (string, error) {
-							cat, err := testGetTagCategory(s, "terraform-test-category")
-							if err != nil {
-								return "", err
-							}
-							return cat.Name, nil
-						},
-						Config: testAccResourceVSphereTagCategoryConfigBasic,
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereTagCategoryExists(true),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereTagCategory_multiCardinality(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereTagCategoryExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereTagCategoryConfigMultiCardinality,
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereTagCategoryExists(true),
+					testAccResourceVSphereTagCategoryHasCardinality(vSphereTagCategoryCardinalityMultiple),
+				),
 			},
 		},
-	}
+	})
+}
 
-	for _, tc := range testAccResourceVSphereTagCategoryCases {
-		t.Run(tc.name, func(t *testing.T) {
-			tp = t
-			resource.Test(t, tc.testCase)
-		})
-	}
+func TestAccResourceVSphereTagCategory_import(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereTagCategoryExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereTagCategoryConfigBasic,
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereTagCategoryExists(true),
+				),
+			},
+			{
+				ResourceName:      "vsphere_tag_category.terraform-test-category",
+				ImportState:       true,
+				ImportStateVerify: true,
+				ImportStateIdFunc: func(s *terraform.State) (string, error) {
+					cat, err := testGetTagCategory(s, "terraform-test-category")
+					if err != nil {
+						return "", err
+					}
+					return cat.Name, nil
+				},
+				Config: testAccResourceVSphereTagCategoryConfigBasic,
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereTagCategoryExists(true),
+				),
+			},
+		},
+	})
 }
 
 func testAccResourceVSphereTagCategoryExists(expected bool) resource.TestCheckFunc {
diff --git a/vsphere/resource_vsphere_tag_test.go b/vsphere/resource_vsphere_tag_test.go
index ca9f2a607..43ca71d0c 100644
--- a/vsphere/resource_vsphere_tag_test.go
+++ b/vsphere/resource_vsphere_tag_test.go
@@ -12,162 +12,146 @@ import (
 	"github.com/hashicorp/terraform/terraform"
 )
 
-func TestAccResourceVSphereTag(t *testing.T) {
-	var tp *testing.T
-	testAccResourceVSphereTagCases := []struct {
-		name     string
-		testCase resource.TestCase
-	}{
-		{
-			"basic",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereTagExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereTagConfigBasic,
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereTagExists(true),
-							testAccResourceVSphereTagHasName("terraform-test-tag"),
-							testAccResourceVSphereTagHasDescription("Managed by Terraform"),
-							testAccResourceVSphereTagHasCategory(),
-						),
-					},
-				},
+func TestAccResourceVSphereTag_basic(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereTagExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereTagConfigBasic,
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereTagExists(true),
+					testAccResourceVSphereTagHasName("terraform-test-tag"),
+					testAccResourceVSphereTagHasDescription("Managed by Terraform"),
+					testAccResourceVSphereTagHasCategory(),
+				),
 			},
 		},
-		{
-			"change name",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereTagExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereTagConfigBasic,
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereTagExists(true),
-						),
-					},
-					{
-						Config: testAccResourceVSphereTagConfigAltName,
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereTagExists(true),
-							testAccResourceVSphereTagHasName("terraform-test-tag-renamed"),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereTag_changeName(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereTagExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereTagConfigBasic,
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereTagExists(true),
+				),
+			},
+			{
+				Config: testAccResourceVSphereTagConfigAltName,
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereTagExists(true),
+					testAccResourceVSphereTagHasName("terraform-test-tag-renamed"),
+				),
 			},
 		},
-		{
-			"change description",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereTagExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereTagConfigBasic,
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereTagExists(true),
-						),
-					},
-					{
-						Config: testAccResourceVSphereTagConfigAltDescription,
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereTagExists(true),
-							testAccResourceVSphereTagHasDescription("Still managed by Terraform"),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereTag_changeDescription(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereTagExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereTagConfigBasic,
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereTagExists(true),
+				),
+			},
+			{
+				Config: testAccResourceVSphereTagConfigAltDescription,
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereTagExists(true),
+					testAccResourceVSphereTagHasDescription("Still managed by Terraform"),
+				),
 			},
 		},
-		{
-			"detach all tags",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereTagExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereTagConfigOnFolderAttached(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereTagExists(true),
-						),
-					},
-					{
-						Config: testAccResourceVSphereTagConfigOnFolderNotAttached(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereTagExists(true),
-							testAccResourceVSphereFolderCheckNoTags(),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereTag_detachAllTags(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereTagExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereTagConfigOnFolderAttached(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereTagExists(true),
+				),
+			},
+			{
+				Config: testAccResourceVSphereTagConfigOnFolderNotAttached(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereTagExists(true),
+					testAccResourceVSphereFolderCheckNoTags(),
+				),
 			},
 		},
-		{
-			"import",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereTagExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereTagConfigBasic,
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereTagExists(true),
-						),
-					},
-					{
-						ResourceName:      "vsphere_tag.terraform-test-tag",
-						ImportState:       true,
-						ImportStateVerify: true,
-						ImportStateIdFunc: func(s *terraform.State) (string, error) {
-							cat, err := testGetTagCategory(s, "terraform-test-category")
-							if err != nil {
-								return "", err
-							}
-							tag, err := testGetTag(s, "terraform-test-tag")
-							if err != nil {
-								return "", err
-							}
-							m := make(map[string]string)
-							m["category_name"] = cat.Name
-							m["tag_name"] = tag.Name
-							b, err := json.Marshal(m)
-							if err != nil {
-								return "", err
-							}
-
-							return string(b), nil
-						},
-						Config: testAccResourceVSphereTagConfigBasic,
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereTagExists(true),
-						),
-					},
+	})
+}
+
+func TestAccResourceVSphereTag_import(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereTagExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereTagConfigBasic,
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereTagExists(true),
+				),
+			},
+			{
+				ResourceName:      "vsphere_tag.terraform-test-tag",
+				ImportState:       true,
+				ImportStateVerify: true,
+				ImportStateIdFunc: func(s *terraform.State) (string, error) {
+					cat, err := testGetTagCategory(s, "terraform-test-category")
+					if err != nil {
+						return "", err
+					}
+					tag, err := testGetTag(s, "terraform-test-tag")
+					if err != nil {
+						return "", err
+					}
+					m := make(map[string]string)
+					m["category_name"] = cat.Name
+					m["tag_name"] = tag.Name
+					b, err := json.Marshal(m)
+					if err != nil {
+						return "", err
+					}
+
+					return string(b), nil
 				},
+				Config: testAccResourceVSphereTagConfigBasic,
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereTagExists(true),
+				),
 			},
 		},
-	}
-
-	for _, tc := range testAccResourceVSphereTagCases {
-		t.Run(tc.name, func(t *testing.T) {
-			tp = t
-			resource.Test(t, tc.testCase)
-		})
-	}
+	})
 }
 
 func testAccResourceVSphereTagExists(expected bool) resource.TestCheckFunc {
diff --git a/vsphere/resource_vsphere_virtual_machine_snapshot_test.go b/vsphere/resource_vsphere_virtual_machine_snapshot_test.go
index 38ff38e9e..c748cb1e1 100644
--- a/vsphere/resource_vsphere_virtual_machine_snapshot_test.go
+++ b/vsphere/resource_vsphere_virtual_machine_snapshot_test.go
@@ -11,7 +11,7 @@ import (
 	"github.com/terraform-providers/terraform-provider-vsphere/vsphere/internal/helper/virtualmachine"
 )
 
-func TestAccResourceVSphereVirtualMachineSnapshot_Basic(t *testing.T) {
+func TestAccResourceVSphereVirtualMachineSnapshot_basic(t *testing.T) {
 	resource.Test(t, resource.TestCase{
 		PreCheck: func() {
 			testAccPreCheck(t)
diff --git a/vsphere/resource_vsphere_virtual_machine_test.go b/vsphere/resource_vsphere_virtual_machine_test.go
index deafd5b68..ee855c7c8 100644
--- a/vsphere/resource_vsphere_virtual_machine_test.go
+++ b/vsphere/resource_vsphere_virtual_machine_test.go
@@ -34,1809 +34,1810 @@ const (
 	testAccResourceVSphereVirtualMachineAnnotation        = "Managed by Terraform"
 )
 
-func TestAccResourceVSphereVirtualMachine(t *testing.T) {
-	var tp *testing.T
-	var state *terraform.State
-	testAccResourceVSphereVirtualMachineCases := []struct {
-		name     string
-		testCase resource.TestCase
-	}{
-		{
-			"basic",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVirtualMachinePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigBasic(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-							resource.TestMatchResourceAttr("vsphere_virtual_machine.vm", "moid", regexp.MustCompile("^vm-")),
-						),
-					},
-				},
-			},
+func TestAccResourceVSphereVirtualMachine_basic(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVirtualMachinePreCheck(t)
 		},
-		{
-			"ESXi-only test",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVirtualMachinePreCheck(tp)
-					testAccSkipIfNotEsxi(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigBasicESXiOnly(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-						),
-					},
-				},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigBasic(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+					resource.TestMatchResourceAttr("vsphere_virtual_machine.vm", "moid", regexp.MustCompile("^vm-")),
+				),
 			},
 		},
-		{
-			"shutdown OK",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVirtualMachinePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigBasic(),
-						Check: resource.ComposeTestCheckFunc(
-							copyStatePtr(&state),
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-						),
-					},
-					{
-						PreConfig: func() {
-							if err := testPowerOffVM(state, "vm"); err != nil {
-								panic(err)
-							}
-						},
-						PlanOnly: true,
-						Config:   testAccResourceVSphereVirtualMachineConfigBasic(),
-					},
-				},
-			},
+	})
+}
+
+func TestAccResourceVSphereVirtualMachine_ESXiOnly(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVirtualMachinePreCheck(t)
+			testAccSkipIfNotEsxi(t)
 		},
-		{
-			"re-create on deletion",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVirtualMachinePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigBasic(),
-						Check: resource.ComposeTestCheckFunc(
-							copyState(&state),
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-						),
-					},
-					{
-						PreConfig: func() {
-							if err := testDeleteVM(state, "vm"); err != nil {
-								panic(err)
-							}
-						},
-						Config: testAccResourceVSphereVirtualMachineConfigBasic(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-							func(s *terraform.State) error {
-								oldID := state.RootModule().Resources["vsphere_virtual_machine.vm"].Primary.ID
-								return testCheckResourceNotAttr("vsphere_virtual_machine.vm", "id", oldID)(s)
-							},
-						),
-					},
-				},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigBasicESXiOnly(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+				),
 			},
 		},
-		{
-			"multi-device",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVirtualMachinePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigMultiDevice(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-							testAccResourceVSphereVirtualMachineCheckMultiDevice([]bool{true, true, true}, []bool{true, true, true}),
-						),
-					},
-				},
-			},
+	})
+}
+
+func TestAccResourceVSphereVirtualMachine_shutdownOK(t *testing.T) {
+	var state *terraform.State
+
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVirtualMachinePreCheck(t)
 		},
-		{
-			"add devices",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVirtualMachinePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigBasic(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-						),
-					},
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigMultiDevice(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-							testAccResourceVSphereVirtualMachineCheckMultiDevice([]bool{true, true, true}, []bool{true, true, true}),
-						),
-					},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigBasic(),
+				Check: resource.ComposeTestCheckFunc(
+					copyStatePtr(&state),
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+				),
+			},
+			{
+				PreConfig: func() {
+					if err := testPowerOffVM(state, "vm"); err != nil {
+						panic(err)
+					}
 				},
+				PlanOnly: true,
+				Config:   testAccResourceVSphereVirtualMachineConfigBasic(),
 			},
 		},
-		{
-			"remove middle devices",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVirtualMachinePreCheck(tp)
+	})
+}
+
+func TestAccResourceVSphereVirtualMachine_reCreateOnDeletion(t *testing.T) {
+	var state *terraform.State
+
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVirtualMachinePreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigBasic(),
+				Check: resource.ComposeTestCheckFunc(
+					copyState(&state),
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+				),
+			},
+			{
+				PreConfig: func() {
+					if err := testDeleteVM(state, "vm"); err != nil {
+						panic(err)
+					}
 				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigMultiDevice(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-							testAccResourceVSphereVirtualMachineCheckMultiDevice([]bool{true, true, true}, []bool{true, true, true}),
-						),
-					},
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigRemoveMiddle(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-							testAccResourceVSphereVirtualMachineCheckMultiDevice([]bool{true, false, true}, []bool{true, false, true}),
-						),
+				Config: testAccResourceVSphereVirtualMachineConfigBasic(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+					func(s *terraform.State) error {
+						oldID := state.RootModule().Resources["vsphere_virtual_machine.vm"].Primary.ID
+						return testCheckResourceNotAttr("vsphere_virtual_machine.vm", "id", oldID)(s)
 					},
-				},
+				),
 			},
 		},
-		{
-			"remove middle devices, change disk unit",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVirtualMachinePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigMultiDevice(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-							testAccResourceVSphereVirtualMachineCheckMultiDevice([]bool{true, true, true}, []bool{true, true, true}),
-						),
-					},
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigRemoveMiddleChangeUnit(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-							testAccResourceVSphereVirtualMachineCheckMultiDevice([]bool{true, false, true}, []bool{true, false, true}),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereVirtualMachine_multiDevice(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVirtualMachinePreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigMultiDevice(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+					testAccResourceVSphereVirtualMachineCheckMultiDevice([]bool{true, true, true}, []bool{true, true, true}),
+				),
 			},
 		},
-		{
-			"high disk unit numbers",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVirtualMachinePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigMultiHighBus(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-							testAccResourceVSphereVirtualMachineCheckDiskBus("terraform-test.vmdk", 0, 0),
-							testAccResourceVSphereVirtualMachineCheckDiskBus("terraform-test_1.vmdk", 1, 0),
-							testAccResourceVSphereVirtualMachineCheckDiskBus("terraform-test_2.vmdk", 2, 1),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereVirtualMachine_addDevices(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVirtualMachinePreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigBasic(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+				),
+			},
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigMultiDevice(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+					testAccResourceVSphereVirtualMachineCheckMultiDevice([]bool{true, true, true}, []bool{true, true, true}),
+				),
 			},
 		},
-		{
-			"high disk units to regular single controller",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVirtualMachinePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigMultiHighBus(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-							testAccResourceVSphereVirtualMachineCheckDiskBus("terraform-test.vmdk", 0, 0),
-							testAccResourceVSphereVirtualMachineCheckDiskBus("terraform-test_1.vmdk", 1, 0),
-							testAccResourceVSphereVirtualMachineCheckDiskBus("terraform-test_2.vmdk", 2, 1),
-						),
-					},
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigMultiDevice(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-							testAccResourceVSphereVirtualMachineCheckDiskBus("terraform-test.vmdk", 0, 0),
-							testAccResourceVSphereVirtualMachineCheckDiskBus("terraform-test_1.vmdk", 0, 1),
-							testAccResourceVSphereVirtualMachineCheckDiskBus("terraform-test_2.vmdk", 0, 2),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereVirtualMachine_removeMiddleDevices(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVirtualMachinePreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigMultiDevice(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+					testAccResourceVSphereVirtualMachineCheckMultiDevice([]bool{true, true, true}, []bool{true, true, true}),
+				),
+			},
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigRemoveMiddle(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+					testAccResourceVSphereVirtualMachineCheckMultiDevice([]bool{true, false, true}, []bool{true, false, true}),
+				),
 			},
 		},
-		{
-			"cdrom",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVirtualMachinePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigCdrom(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-							testAccResourceVSphereVirtualMachineCheckCdrom(),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereVirtualMachine_removeMiddleDevicesChangeDiskUnit(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVirtualMachinePreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigMultiDevice(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+					testAccResourceVSphereVirtualMachineCheckMultiDevice([]bool{true, true, true}, []bool{true, true, true}),
+				),
+			},
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigRemoveMiddleChangeUnit(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+					testAccResourceVSphereVirtualMachineCheckMultiDevice([]bool{true, false, true}, []bool{true, false, true}),
+				),
 			},
 		},
-		{
-			"maximum number of nics",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVirtualMachinePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigMaxNIC(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-							testAccResourceVSphereVirtualMachineCheckNICCount(10),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereVirtualMachine_highDiskUnitNumbers(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVirtualMachinePreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigMultiHighBus(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+					testAccResourceVSphereVirtualMachineCheckDiskBus("terraform-test.vmdk", 0, 0),
+					testAccResourceVSphereVirtualMachineCheckDiskBus("terraform-test_1.vmdk", 1, 0),
+					testAccResourceVSphereVirtualMachineCheckDiskBus("terraform-test_2.vmdk", 2, 1),
+				),
 			},
 		},
-		{
-			"upgrade cpu and ram",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVirtualMachinePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigBasic(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-						),
-					},
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigBeefy(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-							testAccResourceVSphereVirtualMachineCheckCPUMem(4, 8192),
-							// Since hot-add should be off, we expect that the VM was powered
-							// off as a part of this step. This helps check the functionality
-							// of the check for later tests as well.
-							testAccResourceVSphereVirtualMachineCheckPowerOffEvent(true),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereVirtualMachine_highDiskUnitsToRegularSingleController(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVirtualMachinePreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigMultiHighBus(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+					testAccResourceVSphereVirtualMachineCheckDiskBus("terraform-test.vmdk", 0, 0),
+					testAccResourceVSphereVirtualMachineCheckDiskBus("terraform-test_1.vmdk", 1, 0),
+					testAccResourceVSphereVirtualMachineCheckDiskBus("terraform-test_2.vmdk", 2, 1),
+				),
+			},
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigMultiDevice(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+					testAccResourceVSphereVirtualMachineCheckDiskBus("terraform-test.vmdk", 0, 0),
+					testAccResourceVSphereVirtualMachineCheckDiskBus("terraform-test_1.vmdk", 0, 1),
+					testAccResourceVSphereVirtualMachineCheckDiskBus("terraform-test_2.vmdk", 0, 2),
+				),
 			},
 		},
-		{
-			"modify annotation",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVirtualMachinePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigBasic(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-						),
-					},
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigBasicAnnotation(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-							testAccResourceVSphereVirtualMachineCheckAnnotation(),
-							testAccResourceVSphereVirtualMachineCheckPowerOffEvent(false),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereVirtualMachine_cdrom(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVirtualMachinePreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigCdrom(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+					testAccResourceVSphereVirtualMachineCheckCdrom(),
+				),
 			},
 		},
-		{
-			"grow disk",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVirtualMachinePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigGrowDisk(10),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-							testAccResourceVSphereVirtualMachineCheckDiskSize(10),
-						),
-					},
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigGrowDisk(20),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-							testAccResourceVSphereVirtualMachineCheckDiskSize(20),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereVirtualMachine_maximumNumberOfNICs(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVirtualMachinePreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigMaxNIC(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+					testAccResourceVSphereVirtualMachineCheckNICCount(10),
+				),
 			},
 		},
-		{
-			"swap scsi bus",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVirtualMachinePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigBasic(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-							testAccResourceVSphereVirtualMachineCheckSCSIBus(virtualdevice.SubresourceControllerTypeParaVirtual),
-						),
-					},
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigLsiLogicSAS(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-							testAccResourceVSphereVirtualMachineCheckSCSIBus(virtualdevice.SubresourceControllerTypeLsiLogicSAS),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereVirtualMachine_upgradeCPUAndRam(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVirtualMachinePreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigBasic(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+				),
+			},
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigBeefy(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+					testAccResourceVSphereVirtualMachineCheckCPUMem(4, 8192),
+					// Since hot-add should be off, we expect that the VM was powered
+					// off as a part of this step. This helps check the functionality
+					// of the check for later tests as well.
+					testAccResourceVSphereVirtualMachineCheckPowerOffEvent(true),
+				),
 			},
 		},
-		{
-			"extraconfig",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVirtualMachinePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigExtraConfig("foo", "bar"),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-							testAccResourceVSphereVirtualMachineCheckExtraConfig("foo", "bar"),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereVirtualMachine_modifyAnnotation(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVirtualMachinePreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigBasic(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+				),
+			},
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigBasicAnnotation(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+					testAccResourceVSphereVirtualMachineCheckAnnotation(),
+					testAccResourceVSphereVirtualMachineCheckPowerOffEvent(false),
+				),
 			},
 		},
-		{
-			"extraconfig swap keys",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVirtualMachinePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigExtraConfig("foo", "bar"),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-							testAccResourceVSphereVirtualMachineCheckExtraConfig("foo", "bar"),
-						),
-					},
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigExtraConfig("baz", "qux"),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-							testAccResourceVSphereVirtualMachineCheckExtraConfig("baz", "qux"),
-							testAccResourceVSphereVirtualMachineCheckExtraConfigKeyMissing("foo"),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereVirtualMachine_growDisk(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVirtualMachinePreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigGrowDisk(10),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+					testAccResourceVSphereVirtualMachineCheckDiskSize(10),
+				),
+			},
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigGrowDisk(20),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+					testAccResourceVSphereVirtualMachineCheckDiskSize(20),
+				),
 			},
 		},
-		{
-			"attach existing vmdk",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVirtualMachinePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigExistingVmdk(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-							testAccResourceVSphereVirtualMachineCheckExistingVmdk(),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereVirtualMachine_swapSCSIBus(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVirtualMachinePreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigBasic(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+					testAccResourceVSphereVirtualMachineCheckSCSIBus(virtualdevice.SubresourceControllerTypeParaVirtual),
+				),
+			},
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigLsiLogicSAS(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+					testAccResourceVSphereVirtualMachineCheckSCSIBus(virtualdevice.SubresourceControllerTypeLsiLogicSAS),
+				),
 			},
 		},
-		{
-			"in folder",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVirtualMachinePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigInFolder(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-							testAccResourceVSphereVirtualMachineCheckFolder("terraform-test-vms"),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereVirtualMachine_extraConfig(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVirtualMachinePreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigExtraConfig("foo", "bar"),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+					testAccResourceVSphereVirtualMachineCheckExtraConfig("foo", "bar"),
+				),
 			},
 		},
-		{
-			"move to folder",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVirtualMachinePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigBasic(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-						),
-					},
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigInFolder(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-							testAccResourceVSphereVirtualMachineCheckFolder("terraform-test-vms"),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereVirtualMachine_extraConfigSwapKeys(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVirtualMachinePreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigExtraConfig("foo", "bar"),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+					testAccResourceVSphereVirtualMachineCheckExtraConfig("foo", "bar"),
+				),
+			},
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigExtraConfig("baz", "qux"),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+					testAccResourceVSphereVirtualMachineCheckExtraConfig("baz", "qux"),
+					testAccResourceVSphereVirtualMachineCheckExtraConfigKeyMissing("foo"),
+				),
 			},
 		},
-		{
-			"static mac",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVirtualMachinePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigStaticMAC(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-							testAccResourceVSphereVirtualMachineCheckStaticMACAddr(),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereVirtualMachine_attachExistingVmdk(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVirtualMachinePreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigExistingVmdk(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+					testAccResourceVSphereVirtualMachineCheckExistingVmdk(),
+				),
 			},
 		},
-		{
-			"single tag",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVirtualMachinePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigSingleTag(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-							testAccResourceVSphereVirtualMachineCheckTags("terraform-test-tag"),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereVirtualMachine_inFolder(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVirtualMachinePreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigInFolder(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+					testAccResourceVSphereVirtualMachineCheckFolder("terraform-test-vms"),
+				),
 			},
 		},
-		{
-			"multiple tags",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVirtualMachinePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigMultiTag(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-							testAccResourceVSphereVirtualMachineCheckTags("terraform-test-tags-alt"),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereVirtualMachine_moveToFolder(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVirtualMachinePreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigBasic(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+				),
+			},
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigInFolder(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+					testAccResourceVSphereVirtualMachineCheckFolder("terraform-test-vms"),
+				),
 			},
 		},
-		{
-			"switch tags",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVirtualMachinePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigSingleTag(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-							testAccResourceVSphereVirtualMachineCheckTags("terraform-test-tag"),
-						),
-					},
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigMultiTag(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-							testAccResourceVSphereVirtualMachineCheckTags("terraform-test-tags-alt"),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereVirtualMachine_staticMAC(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVirtualMachinePreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigStaticMAC(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+					testAccResourceVSphereVirtualMachineCheckStaticMACAddr(),
+				),
 			},
 		},
-		{
-			"orphaned (renamed) disk in place of existing",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVirtualMachinePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigBasic(),
-						Check: resource.ComposeTestCheckFunc(
-							copyStatePtr(&state),
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-						),
-					},
-					{
-						PreConfig: func() {
-							if err := testRenameVMFirstDisk(state, "vm", "foobar.vmdk"); err != nil {
-								panic(err)
-							}
-						},
-						Config: testAccResourceVSphereVirtualMachineConfigBasic(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-							// The only real way we can check to see if this is actually
-							// functional in the current test framework is by checking that
-							// the file we renamed to was not deleted (this is due to a lack
-							// of ability to check diff in the test framework right now).
-							testCheckVMDiskFileExists("terraform-test.vmdk"),
-							testCheckVMDiskFileExists("foobar.vmdk"),
-						),
-					},
-					// The last step is a cleanup step. This assumes the test is
-					// functional as the orphaned disk will be now detached and not
-					// deleted when the VM is destroyed.
-					{
-						PreConfig: func() {
-							if err := testDeleteVMDisk(state, "vm", "foobar.vmdk"); err != nil {
-								panic(err)
-							}
-						},
-						Config: testAccResourceVSphereVirtualMachineConfigBasic(),
-						Check:  resource.ComposeTestCheckFunc(),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereVirtualMachine_singleTag(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVirtualMachinePreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigSingleTag(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+					testAccResourceVSphereVirtualMachineCheckTags("terraform-test-tag"),
+				),
 			},
 		},
-		{
-			"block computed disk name",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVirtualMachinePreCheck(tp)
-				},
-				Providers: testAccProviders,
-				Steps: []resource.TestStep{
-					{
-						Config:      testAccResourceVSphereVirtualMachineConfigComputedDisk(),
-						ExpectError: regexp.MustCompile("disk label or name must be defined and cannot be computed"),
-						PlanOnly:    true,
-					},
-					{
-						Config: testAccResourceVSphereEmpty,
-						Check:  resource.ComposeTestCheckFunc(),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereVirtualMachine_multipleTags(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVirtualMachinePreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigMultiTag(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+					testAccResourceVSphereVirtualMachineCheckTags("terraform-test-tags-alt"),
+				),
 			},
 		},
-		{
-			"block vapp settings on non-clones",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVirtualMachinePreCheck(tp)
-				},
-				Providers: testAccProviders,
-				Steps: []resource.TestStep{
-					{
-						Config:      testAccResourceVSphereVirtualMachineVAppPropertiesNonClone(),
-						ExpectError: regexp.MustCompile("vApp properties can only be set on cloned virtual machines"),
-					},
-					{
-						Config: testAccResourceVSphereEmpty,
-						Check:  resource.ComposeTestCheckFunc(),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereVirtualMachine_switchTags(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVirtualMachinePreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigSingleTag(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+					testAccResourceVSphereVirtualMachineCheckTags("terraform-test-tag"),
+				),
 			},
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigMultiTag(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+					testAccResourceVSphereVirtualMachineCheckTags("terraform-test-tags-alt"),
+				),
+			},
+		},
+	})
+}
+
+func TestAccResourceVSphereVirtualMachine_renamedDiskInPlaceOfExisting(t *testing.T) {
+	var state *terraform.State
+
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVirtualMachinePreCheck(t)
 		},
-		{
-			"block vapp settings on non-clones after creation",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVirtualMachinePreCheck(tp)
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigBasic(),
+				Check: resource.ComposeTestCheckFunc(
+					copyStatePtr(&state),
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+				),
+			},
+			{
+				PreConfig: func() {
+					if err := testRenameVMFirstDisk(state, "vm", "foobar.vmdk"); err != nil {
+						panic(err)
+					}
 				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigBasic(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-						),
-					},
-					{
-						Config:      testAccResourceVSphereVirtualMachineVAppPropertiesNonClone(),
-						ExpectError: regexp.MustCompile("this VM lacks a vApp configuration and cannot have vApp properties set on it"),
-					},
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigBasic(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-						),
-					},
+				Config: testAccResourceVSphereVirtualMachineConfigBasic(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+					// The only real way we can check to see if this is actually
+					// functional in the current test framework is by checking that
+					// the file we renamed to was not deleted (this is due to a lack
+					// of ability to check diff in the test framework right now).
+					testCheckVMDiskFileExists("terraform-test.vmdk"),
+					testCheckVMDiskFileExists("foobar.vmdk"),
+				),
+			},
+			// The last step is a cleanup step. This assumes the test is
+			// functional as the orphaned disk will be now detached and not
+			// deleted when the VM is destroyed.
+			{
+				PreConfig: func() {
+					if err := testDeleteVMDisk(state, "vm", "foobar.vmdk"); err != nil {
+						panic(err)
+					}
 				},
+				Config: testAccResourceVSphereVirtualMachineConfigBasic(),
+				Check:  resource.ComposeTestCheckFunc(),
 			},
 		},
-		{
-			"block disk label starting with orphaned prefix",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVirtualMachinePreCheck(tp)
-				},
-				Providers: testAccProviders,
-				Steps: []resource.TestStep{
-					{
-						Config:      testAccResourceVSphereVirtualMachineConfigBadOrphanedLabel(),
-						ExpectError: regexp.MustCompile(regexp.QuoteMeta(`disk label "orphaned_disk_0" cannot start with "orphaned_disk_"`)),
-						PlanOnly:    true,
-					},
-					{
-						Config: testAccResourceVSphereEmpty,
-						Check:  resource.ComposeTestCheckFunc(),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereVirtualMachine_blockComputedDiskName(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVirtualMachinePreCheck(t)
+		},
+		Providers: testAccProviders,
+		Steps: []resource.TestStep{
+			{
+				Config:      testAccResourceVSphereVirtualMachineConfigComputedDisk(),
+				ExpectError: regexp.MustCompile("disk label or name must be defined and cannot be computed"),
+				PlanOnly:    true,
+			},
+			{
+				Config: testAccResourceVSphereEmpty,
+				Check:  resource.ComposeTestCheckFunc(),
 			},
 		},
-		{
-			"create into empty cluster, no environment browser",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVirtualMachinePreCheck(tp)
-				},
-				Providers: testAccProviders,
-				Steps: []resource.TestStep{
-					{
-						Config:      testAccResourceVSphereVirtualMachineConfigBasicEmptyCluster(),
-						ExpectError: regexp.MustCompile("compute resource .* is missing an Environment Browser\\. Check host, cluster, and vSphere license health of all associated resources and try again"),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereVirtualMachine_blockVAppSettingsOnNonClones(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVirtualMachinePreCheck(t)
+		},
+		Providers: testAccProviders,
+		Steps: []resource.TestStep{
+			{
+				Config:      testAccResourceVSphereVirtualMachineVAppPropertiesNonClone(),
+				ExpectError: regexp.MustCompile("vApp properties can only be set on cloned virtual machines"),
+			},
+			{
+				Config: testAccResourceVSphereEmpty,
+				Check:  resource.ComposeTestCheckFunc(),
 			},
 		},
-		{
-			"clone from template",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVirtualMachinePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigClone(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-							resource.TestCheckResourceAttr("vsphere_virtual_machine.vm", "default_ip_address", os.Getenv("VSPHERE_IPV4_ADDRESS")),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereVirtualMachine_blockVAppSettingsOnNonClonesAfterCreation(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVirtualMachinePreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigBasic(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+				),
+			},
+			{
+				Config:      testAccResourceVSphereVirtualMachineVAppPropertiesNonClone(),
+				ExpectError: regexp.MustCompile("this VM lacks a vApp configuration and cannot have vApp properties set on it"),
+			},
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigBasic(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+				),
 			},
 		},
-		{
-			"clone, modify disk and SCSI type at same time",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVirtualMachinePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigCloneChangeDiskAndSCSI(),
-						Check: resource.ComposeTestCheckFunc(
-							copyStatePtr(&state),
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-							func(s *terraform.State) error {
-								oldSize, _ := strconv.Atoi(state.RootModule().Resources["data.vsphere_virtual_machine.template"].Primary.Attributes["disks.0.size"])
-								newSize := oldSize * 2
-								return resource.TestCheckResourceAttr("vsphere_virtual_machine.vm", "disk.0.size", strconv.Itoa(newSize))(s)
-							},
-							func(s *terraform.State) error {
-								oldBus := state.RootModule().Resources["data.vsphere_virtual_machine.template"].Primary.Attributes["scsi_type"]
-								var expected string
-								if oldBus == virtualdevice.SubresourceControllerTypeParaVirtual {
-									expected = virtualdevice.SubresourceControllerTypeLsiLogicSAS
-								} else {
-									expected = virtualdevice.SubresourceControllerTypeParaVirtual
-								}
-								return resource.TestCheckResourceAttr("vsphere_virtual_machine.vm", "scsi_type", expected)(s)
-							},
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereVirtualMachine_blockDiskLabelStartingWithOrphanedPrefix(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVirtualMachinePreCheck(t)
+		},
+		Providers: testAccProviders,
+		Steps: []resource.TestStep{
+			{
+				Config:      testAccResourceVSphereVirtualMachineConfigBadOrphanedLabel(),
+				ExpectError: regexp.MustCompile(regexp.QuoteMeta(`disk label "orphaned_disk_0" cannot start with "orphaned_disk_"`)),
+				PlanOnly:    true,
+			},
+			{
+				Config: testAccResourceVSphereEmpty,
+				Check:  resource.ComposeTestCheckFunc(),
 			},
 		},
-		{
-			"clone, multi-nic (template should have one)",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVirtualMachinePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigCloneMultiNIC(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-							resource.TestCheckResourceAttr("vsphere_virtual_machine.vm", "default_ip_address", os.Getenv("VSPHERE_IPV4_ADDRESS")),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereVirtualMachine_createIntoEmptyClusterNoEnvironmentBrowser(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVirtualMachinePreCheck(t)
+		},
+		Providers: testAccProviders,
+		Steps: []resource.TestStep{
+			{
+				Config:      testAccResourceVSphereVirtualMachineConfigBasicEmptyCluster(),
+				ExpectError: regexp.MustCompile("compute resource .* is missing an Environment Browser\\. Check host, cluster, and vSphere license health of all associated resources and try again"),
 			},
 		},
-		{
-			"clone with different timezone",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVirtualMachinePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigCloneTimeZone("America/Vancouver"),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereVirtualMachine_cloneFromTemplate(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVirtualMachinePreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigClone(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+					resource.TestCheckResourceAttr("vsphere_virtual_machine.vm", "default_ip_address", os.Getenv("VSPHERE_IPV4_ADDRESS")),
+				),
 			},
 		},
-		{
-			"clone with bad timezone",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVirtualMachinePreCheck(tp)
-				},
-				Providers: testAccProviders,
-				Steps: []resource.TestStep{
-					{
-						Config:      testAccResourceVSphereVirtualMachineConfigCloneTimeZone("Pacific Standard Time"),
-						ExpectError: regexp.MustCompile("must be similar to America/Los_Angeles or other Linux/Unix TZ format"),
-						PlanOnly:    true,
+	})
+}
+
+func TestAccResourceVSphereVirtualMachine_cloneModifyDiskAndSCSITypeAtSameTime(t *testing.T) {
+	var state *terraform.State
+
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVirtualMachinePreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigCloneChangeDiskAndSCSI(),
+				Check: resource.ComposeTestCheckFunc(
+					copyStatePtr(&state),
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+					func(s *terraform.State) error {
+						oldSize, _ := strconv.Atoi(state.RootModule().Resources["data.vsphere_virtual_machine.template"].Primary.Attributes["disks.0.size"])
+						newSize := oldSize * 2
+						return resource.TestCheckResourceAttr("vsphere_virtual_machine.vm", "disk.0.size", strconv.Itoa(newSize))(s)
 					},
-					{
-						Config: testAccResourceVSphereEmpty,
-						Check:  resource.ComposeTestCheckFunc(),
+					func(s *terraform.State) error {
+						oldBus := state.RootModule().Resources["data.vsphere_virtual_machine.template"].Primary.Attributes["scsi_type"]
+						var expected string
+						if oldBus == virtualdevice.SubresourceControllerTypeParaVirtual {
+							expected = virtualdevice.SubresourceControllerTypeLsiLogicSAS
+						} else {
+							expected = virtualdevice.SubresourceControllerTypeParaVirtual
+						}
+						return resource.TestCheckResourceAttr("vsphere_virtual_machine.vm", "scsi_type", expected)(s)
 					},
-				},
+				),
 			},
 		},
-		{
-			"clone with bad eagerly_scrub with linked_clone",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVirtualMachinePreCheck(tp)
-				},
-				Providers: testAccProviders,
-				Steps: []resource.TestStep{
-					{
-						Config:      testAccResourceVSphereVirtualMachineConfigBadEager(),
-						ExpectError: regexp.MustCompile("must have same value for eagerly_scrub as source when using linked_clone"),
-						PlanOnly:    true,
-					},
-					{
-						Config: testAccResourceVSphereEmpty,
-						Check:  resource.ComposeTestCheckFunc(),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereVirtualMachine_cloneMultiNICFromSingleNICTemplate(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVirtualMachinePreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigCloneMultiNIC(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+					resource.TestCheckResourceAttr("vsphere_virtual_machine.vm", "default_ip_address", os.Getenv("VSPHERE_IPV4_ADDRESS")),
+				),
 			},
 		},
-		{
-			"clone with bad thin_provisioned with linked_clone",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVirtualMachinePreCheck(tp)
-				},
-				Providers: testAccProviders,
-				Steps: []resource.TestStep{
-					{
-						Config:      testAccResourceVSphereVirtualMachineConfigBadThin(),
-						ExpectError: regexp.MustCompile("must have same value for thin_provisioned as source when using linked_clone"),
-						PlanOnly:    true,
-					},
-					{
-						Config: testAccResourceVSphereEmpty,
-						Check:  resource.ComposeTestCheckFunc(),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereVirtualMachine_cloneWithDifferentTimezone(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVirtualMachinePreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigCloneTimeZone("America/Vancouver"),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+				),
 			},
 		},
-		{
-			"clone with bad size with linked_clone",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVirtualMachinePreCheck(tp)
-				},
-				Providers: testAccProviders,
-				Steps: []resource.TestStep{
-					{
-						Config:      testAccResourceVSphereVirtualMachineConfigBadSizeLinked(),
-						ExpectError: regexp.MustCompile("must be the exact size of source when using linked_clone"),
-						PlanOnly:    true,
-					},
-					{
-						Config: testAccResourceVSphereEmpty,
-						Check:  resource.ComposeTestCheckFunc(),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereVirtualMachine_cloneWithBadTimezone(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVirtualMachinePreCheck(t)
+		},
+		Providers: testAccProviders,
+		Steps: []resource.TestStep{
+			{
+				Config:      testAccResourceVSphereVirtualMachineConfigCloneTimeZone("Pacific Standard Time"),
+				ExpectError: regexp.MustCompile("must be similar to America/Los_Angeles or other Linux/Unix TZ format"),
+				PlanOnly:    true,
+			},
+			{
+				Config: testAccResourceVSphereEmpty,
+				Check:  resource.ComposeTestCheckFunc(),
 			},
 		},
-		{
-			"clone with bad size without linked_clone",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVirtualMachinePreCheck(tp)
-				},
-				Providers: testAccProviders,
-				Steps: []resource.TestStep{
-					{
-						Config:      testAccResourceVSphereVirtualMachineConfigBadSizeUnlinked(),
-						ExpectError: regexp.MustCompile("must be at least the same size of source when cloning"),
-						PlanOnly:    true,
-					},
-					{
-						Config: testAccResourceVSphereEmpty,
-						Check:  resource.ComposeTestCheckFunc(),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereVirtualMachine_cloneWithBadEagerlyScrubWithLinkedClone(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVirtualMachinePreCheck(t)
+		},
+		Providers: testAccProviders,
+		Steps: []resource.TestStep{
+			{
+				Config:      testAccResourceVSphereVirtualMachineConfigBadEager(),
+				ExpectError: regexp.MustCompile("must have same value for eagerly_scrub as source when using linked_clone"),
+				PlanOnly:    true,
+			},
+			{
+				Config: testAccResourceVSphereEmpty,
+				Check:  resource.ComposeTestCheckFunc(),
 			},
 		},
-		{
-			"clone - attempt to add vapp properties to a VM that does not support them - create",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVirtualMachinePreCheck(tp)
-				},
-				Providers: testAccProviders,
-				Steps: []resource.TestStep{
-					{
-						Config:      testAccResourceVSphereVirtualMachineConfigCloneBadVAppSettings(),
-						ExpectError: regexp.MustCompile("this VM lacks a vApp configuration and cannot have vApp properties set on it"),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereVirtualMachine_cloneWithBadThinProvisionedWithLinkedClone(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVirtualMachinePreCheck(t)
+		},
+		Providers: testAccProviders,
+		Steps: []resource.TestStep{
+			{
+				Config:      testAccResourceVSphereVirtualMachineConfigBadThin(),
+				ExpectError: regexp.MustCompile("must have same value for thin_provisioned as source when using linked_clone"),
+				PlanOnly:    true,
+			},
+			{
+				Config: testAccResourceVSphereEmpty,
+				Check:  resource.ComposeTestCheckFunc(),
 			},
 		},
-		{
-			"clone - attempt to add vapp properties to a VM that does not support them - update",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVirtualMachinePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigClone(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-						),
-					},
-					{
-						Config:      testAccResourceVSphereVirtualMachineConfigCloneBadVAppSettings(),
-						ExpectError: regexp.MustCompile("this VM lacks a vApp configuration and cannot have vApp properties set on it"),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereVirtualMachine_cloneWithBadSizeWithLinkedClone(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVirtualMachinePreCheck(t)
+		},
+		Providers: testAccProviders,
+		Steps: []resource.TestStep{
+			{
+				Config:      testAccResourceVSphereVirtualMachineConfigBadSizeLinked(),
+				ExpectError: regexp.MustCompile("must be the exact size of source when using linked_clone"),
+				PlanOnly:    true,
+			},
+			{
+				Config: testAccResourceVSphereEmpty,
+				Check:  resource.ComposeTestCheckFunc(),
 			},
 		},
-		{
-			"clone into empty cluster, no environment browser (fails on plan)",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVirtualMachinePreCheck(tp)
-				},
-				Providers: testAccProviders,
-				Steps: []resource.TestStep{
-					{
-						Config:      testAccResourceVSphereVirtualMachineConfigCloneEmptyCluster(),
-						ExpectError: regexp.MustCompile("compute resource .* is missing an Environment Browser\\. Check host, cluster, and vSphere license health of all associated resources and try again"),
-						PlanOnly:    true,
-					},
-					{
-						Config: testAccResourceVSphereEmpty,
-						Check:  resource.ComposeTestCheckFunc(),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereVirtualMachine_cloneWithBadSizeWithoutLinkedClone(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVirtualMachinePreCheck(t)
+		},
+		Providers: testAccProviders,
+		Steps: []resource.TestStep{
+			{
+				Config:      testAccResourceVSphereVirtualMachineConfigBadSizeUnlinked(),
+				ExpectError: regexp.MustCompile("must be at least the same size of source when cloning"),
+				PlanOnly:    true,
+			},
+			{
+				Config: testAccResourceVSphereEmpty,
+				Check:  resource.ComposeTestCheckFunc(),
 			},
 		},
-		{
-			"clone with different hostname",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVirtualMachinePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigCloneHostname(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-							testAccResourceVSphereVirtualMachineCheckHostname("terraform-test-renamed"),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereVirtualMachine_cloneUnsupportedVAppPropertiesOnCreate(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVirtualMachinePreCheck(t)
+		},
+		Providers: testAccProviders,
+		Steps: []resource.TestStep{
+			{
+				Config:      testAccResourceVSphereVirtualMachineConfigCloneBadVAppSettings(),
+				ExpectError: regexp.MustCompile("this VM lacks a vApp configuration and cannot have vApp properties set on it"),
 			},
 		},
-		{
-			"clone with extra disks",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVirtualMachinePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigCloneExtraDisks(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-							testAccResourceVSphereVirtualMachineCheckExtraDisks(),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereVirtualMachine_cloneUnsupportedVAppPropertiesOnUpdate(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVirtualMachinePreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigClone(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+				),
+			},
+			{
+				Config:      testAccResourceVSphereVirtualMachineConfigCloneBadVAppSettings(),
+				ExpectError: regexp.MustCompile("this VM lacks a vApp configuration and cannot have vApp properties set on it"),
 			},
 		},
-		{
-			"clone with cdrom",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVirtualMachinePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigCloneWithCdrom(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-							testAccResourceVSphereVirtualMachineCheckCdrom(),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereVirtualMachine_cloneIntoEmptyCluster(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVirtualMachinePreCheck(t)
+		},
+		Providers: testAccProviders,
+		Steps: []resource.TestStep{
+			{
+				Config:      testAccResourceVSphereVirtualMachineConfigCloneEmptyCluster(),
+				ExpectError: regexp.MustCompile("compute resource .* is missing an Environment Browser\\. Check host, cluster, and vSphere license health of all associated resources and try again"),
+				PlanOnly:    true,
+			},
+			{
+				Config: testAccResourceVSphereEmpty,
+				Check:  resource.ComposeTestCheckFunc(),
 			},
 		},
-		{
-			"clone with vapp properties",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVirtualMachinePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigCloneWithVAppProperties(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-							testAccResourceVSphereVirtualMachineCheckVAppConfigKey("guestinfo.hostname", "terraform-test.test.internal"),
-							testAccResourceVSphereVirtualMachineCheckVAppConfigKey("guestinfo.dns.server.0", os.Getenv("VSPHERE_DNS")),
-						),
-					},
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigCloneUpdatingVAppProperties(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-							testAccResourceVSphereVirtualMachineCheckVAppConfigKey("guestinfo.hostname", "terraform-test.test.internal"),
-							testAccResourceVSphereVirtualMachineCheckVAppConfigKey("guestinfo.dns.server.0", os.Getenv("VSPHERE_DNS")),
-							testAccResourceVSphereVirtualMachineCheckVAppConfigKey("guestinfo.dns.server.1", "8.8.8.8"),
-						),
-					},
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigCloneWithVAppProperties(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-							testAccResourceVSphereVirtualMachineCheckVAppConfigKey("guestinfo.hostname", "terraform-test.test.internal"),
-							testAccResourceVSphereVirtualMachineCheckVAppConfigKey("guestinfo.dns.server.0", os.Getenv("VSPHERE_DNS")),
-							testAccResourceVSphereVirtualMachineCheckVAppConfigKey("guestinfo.dns.server.1", ""),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereVirtualMachine_cloneWithDifferentHostname(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVirtualMachinePreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigCloneHostname(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+					testAccResourceVSphereVirtualMachineCheckHostname("terraform-test-renamed"),
+				),
 			},
 		},
-		{
-			"bad vapp property - clone create",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVirtualMachinePreCheck(tp)
-				},
-				Providers: testAccProviders,
-				Steps: []resource.TestStep{
-					{
-						Config:      testAccResourceVSphereVirtualMachineConfigCloneVAppPropertiesBadKey(),
-						ExpectError: regexp.MustCompile(regexp.QuoteMeta("unsupported vApp properties in vapp.properties: [foo]")),
-					},
-					{
-						Config: testAccResourceVSphereEmpty,
-						Check:  resource.ComposeTestCheckFunc(),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereVirtualMachine_cloneWithExtraDisks(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVirtualMachinePreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigCloneExtraDisks(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+					testAccResourceVSphereVirtualMachineCheckExtraDisks(),
+				),
 			},
 		},
-		{
-			"bad vapp property - clone update",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVirtualMachinePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigCloneWithVAppProperties(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-							testAccResourceVSphereVirtualMachineCheckVAppConfigKey("guestinfo.hostname", "terraform-test.test.internal"),
-							testAccResourceVSphereVirtualMachineCheckVAppConfigKey("guestinfo.dns.server.0", os.Getenv("VSPHERE_DNS")),
-						),
-					},
-					{
-						Config:      testAccResourceVSphereVirtualMachineConfigCloneVAppPropertiesBadKey(),
-						ExpectError: regexp.MustCompile(regexp.QuoteMeta("unsupported vApp properties in vapp.properties: [foo]")),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereVirtualMachine_cloneWithCdrom(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVirtualMachinePreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigCloneWithCdrom(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+					testAccResourceVSphereVirtualMachineCheckCdrom(),
+				),
 			},
 		},
-		{
-			"cpu hot add",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVirtualMachinePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
-				Steps: []resource.TestStep{
-					{
-						// Starting config
-						Config: testAccResourceVSphereVirtualMachineConfigWithHotAdd(2, 2048, true, false, true),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-							testAccResourceVSphereVirtualMachineCheckCPUMem(2, 2048),
-						),
-					},
-					{
-						// Add CPU w/hot-add
-						Config: testAccResourceVSphereVirtualMachineConfigWithHotAdd(4, 2048, true, false, true),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-							testAccResourceVSphereVirtualMachineCheckCPUMem(4, 2048),
-							testAccResourceVSphereVirtualMachineCheckPowerOffEvent(false),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereVirtualMachine_cloneWithVAppProperties(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVirtualMachinePreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigCloneWithVAppProperties(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+					testAccResourceVSphereVirtualMachineCheckVAppConfigKey("guestinfo.hostname", "terraform-test.test.internal"),
+					testAccResourceVSphereVirtualMachineCheckVAppConfigKey("guestinfo.dns.server.0", os.Getenv("VSPHERE_DNS")),
+				),
+			},
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigCloneUpdatingVAppProperties(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+					testAccResourceVSphereVirtualMachineCheckVAppConfigKey("guestinfo.hostname", "terraform-test.test.internal"),
+					testAccResourceVSphereVirtualMachineCheckVAppConfigKey("guestinfo.dns.server.0", os.Getenv("VSPHERE_DNS")),
+					testAccResourceVSphereVirtualMachineCheckVAppConfigKey("guestinfo.dns.server.1", "8.8.8.8"),
+				),
+			},
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigCloneWithVAppProperties(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+					testAccResourceVSphereVirtualMachineCheckVAppConfigKey("guestinfo.hostname", "terraform-test.test.internal"),
+					testAccResourceVSphereVirtualMachineCheckVAppConfigKey("guestinfo.dns.server.0", os.Getenv("VSPHERE_DNS")),
+					testAccResourceVSphereVirtualMachineCheckVAppConfigKey("guestinfo.dns.server.1", ""),
+				),
 			},
 		},
-		{
-			"memory hot add",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVirtualMachinePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
-				Steps: []resource.TestStep{
-					{
-						// Starting config
-						Config: testAccResourceVSphereVirtualMachineConfigWithHotAdd(2, 2048, true, false, true),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-							testAccResourceVSphereVirtualMachineCheckCPUMem(2, 2048),
-						),
-					},
-					{
-						// Add memory with hot-add
-						Config: testAccResourceVSphereVirtualMachineConfigWithHotAdd(2, 3072, true, false, true),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-							testAccResourceVSphereVirtualMachineCheckCPUMem(2, 3072),
-							testAccResourceVSphereVirtualMachineCheckPowerOffEvent(false),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereVirtualMachine_cloneWithBadVAppPropertyOnCreate(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVirtualMachinePreCheck(t)
+		},
+		Providers: testAccProviders,
+		Steps: []resource.TestStep{
+			{
+				Config:      testAccResourceVSphereVirtualMachineConfigCloneVAppPropertiesBadKey(),
+				ExpectError: regexp.MustCompile(regexp.QuoteMeta("unsupported vApp properties in vapp.properties: [foo]")),
+			},
+			{
+				Config: testAccResourceVSphereEmpty,
+				Check:  resource.ComposeTestCheckFunc(),
 			},
 		},
-		{
-			"dual-stack ipv4 and ipv6",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVirtualMachinePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigDualStack(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-							testAccResourceVSphereVirtualMachineCheckNet("fd00::2", "32", "fd00::1"),
-							testAccResourceVSphereVirtualMachineCheckNet(
-								os.Getenv("VSPHERE_IPV4_ADDRESS"),
-								os.Getenv("VSPHERE_IPV4_PREFIX"),
-								os.Getenv("VSPHERE_IPV4_GATEWAY"),
-							),
-							resource.TestCheckResourceAttr("vsphere_virtual_machine.vm", "default_ip_address", os.Getenv("VSPHERE_IPV4_ADDRESS")),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereVirtualMachine_cloneWithBadVAppPropertyOnUpdate(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVirtualMachinePreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigCloneWithVAppProperties(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+					testAccResourceVSphereVirtualMachineCheckVAppConfigKey("guestinfo.hostname", "terraform-test.test.internal"),
+					testAccResourceVSphereVirtualMachineCheckVAppConfigKey("guestinfo.dns.server.0", os.Getenv("VSPHERE_DNS")),
+				),
+			},
+			{
+				Config:      testAccResourceVSphereVirtualMachineConfigCloneVAppPropertiesBadKey(),
+				ExpectError: regexp.MustCompile(regexp.QuoteMeta("unsupported vApp properties in vapp.properties: [foo]")),
 			},
 		},
-		{
-			"ipv6 only",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVirtualMachinePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigIPv6Only(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-							testAccResourceVSphereVirtualMachineCheckNet("fd00::2", "32", "fd00::1"),
-							resource.TestCheckResourceAttr("vsphere_virtual_machine.vm", "default_ip_address", "fd00::2"),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereVirtualMachine_cpuHotAdd(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVirtualMachinePreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
+		Steps: []resource.TestStep{
+			{
+				// Starting config
+				Config: testAccResourceVSphereVirtualMachineConfigWithHotAdd(2, 2048, true, false, true),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+					testAccResourceVSphereVirtualMachineCheckCPUMem(2, 2048),
+				),
+			},
+			{
+				// Add CPU w/hot-add
+				Config: testAccResourceVSphereVirtualMachineConfigWithHotAdd(4, 2048, true, false, true),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+					testAccResourceVSphereVirtualMachineCheckCPUMem(4, 2048),
+					testAccResourceVSphereVirtualMachineCheckPowerOffEvent(false),
+				),
 			},
 		},
-		{
-			"windows template, customization events and proper IP",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVirtualMachinePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigWindows(),
-						Check: resource.ComposeTestCheckFunc(
-							copyStatePtr(&state),
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-							testAccResourceVSphereVirtualMachineCheckCustomizationSucceeded(),
-							testAccResourceVSphereVirtualMachineCheckNet(
-								os.Getenv("VSPHERE_IPV4_ADDRESS"),
-								os.Getenv("VSPHERE_IPV4_PREFIX"),
-								os.Getenv("VSPHERE_IPV4_GATEWAY"),
-							),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereVirtualMachine_memoryHotAdd(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVirtualMachinePreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
+		Steps: []resource.TestStep{
+			{
+				// Starting config
+				Config: testAccResourceVSphereVirtualMachineConfigWithHotAdd(2, 2048, true, false, true),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+					testAccResourceVSphereVirtualMachineCheckCPUMem(2, 2048),
+				),
+			},
+			{
+				// Add memory with hot-add
+				Config: testAccResourceVSphereVirtualMachineConfigWithHotAdd(2, 3072, true, false, true),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+					testAccResourceVSphereVirtualMachineCheckCPUMem(2, 3072),
+					testAccResourceVSphereVirtualMachineCheckPowerOffEvent(false),
+				),
 			},
 		},
-		{
-			"host vmotion",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVirtualMachinePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigHostVMotion(os.Getenv("VSPHERE_ESXI_HOST")),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-							testAccResourceVSphereVirtualMachineCheckHost(os.Getenv("VSPHERE_ESXI_HOST")),
-						),
-					},
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigHostVMotion(os.Getenv("VSPHERE_ESXI_HOST2")),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-							testAccResourceVSphereVirtualMachineCheckHost(os.Getenv("VSPHERE_ESXI_HOST2")),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereVirtualMachine_dualStackIPv4AndIPv6(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVirtualMachinePreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigDualStack(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+					testAccResourceVSphereVirtualMachineCheckNet("fd00::2", "32", "fd00::1"),
+					testAccResourceVSphereVirtualMachineCheckNet(
+						os.Getenv("VSPHERE_IPV4_ADDRESS"),
+						os.Getenv("VSPHERE_IPV4_PREFIX"),
+						os.Getenv("VSPHERE_IPV4_GATEWAY"),
+					),
+					resource.TestCheckResourceAttr("vsphere_virtual_machine.vm", "default_ip_address", os.Getenv("VSPHERE_IPV4_ADDRESS")),
+				),
 			},
 		},
-		{
-			"resource pool vmotion",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVirtualMachinePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigResourcePoolVMotion(os.Getenv("VSPHERE_RESOURCE_POOL")),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-							testAccResourceVSphereVirtualMachineCheckResourcePool(os.Getenv("VSPHERE_RESOURCE_POOL")),
-						),
-					},
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigResourcePoolVMotion(fmt.Sprintf("%s/Resources", os.Getenv("VSPHERE_CLUSTER"))),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-							testAccResourceVSphereVirtualMachineCheckResourcePool(fmt.Sprintf("%s/Resources", os.Getenv("VSPHERE_CLUSTER"))),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereVirtualMachine_IPv6Only(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVirtualMachinePreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigIPv6Only(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+					testAccResourceVSphereVirtualMachineCheckNet("fd00::2", "32", "fd00::1"),
+					resource.TestCheckResourceAttr("vsphere_virtual_machine.vm", "default_ip_address", "fd00::2"),
+				),
 			},
 		},
-		{
-			"storage vmotion - global setting",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVirtualMachinePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigStorageVMotionGlobal(os.Getenv("VSPHERE_DATASTORE")),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-							testAccResourceVSphereVirtualMachineCheckVmxDatastore(os.Getenv("VSPHERE_DATASTORE")),
-							testAccResourceVSphereVirtualMachineCheckVmdkDatastore("terraform-test.vmdk", os.Getenv("VSPHERE_DATASTORE")),
-						),
-					},
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigStorageVMotionGlobal(os.Getenv("VSPHERE_DATASTORE2")),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-							testAccResourceVSphereVirtualMachineCheckVmxDatastore(os.Getenv("VSPHERE_DATASTORE2")),
-							testAccResourceVSphereVirtualMachineCheckVmdkDatastore("terraform-test.vmdk", os.Getenv("VSPHERE_DATASTORE2")),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereVirtualMachine_windowsTemplateCustomizationEventsAndProperIP(t *testing.T) {
+	var state *terraform.State
+
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVirtualMachinePreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigWindows(),
+				Check: resource.ComposeTestCheckFunc(
+					copyStatePtr(&state),
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+					testAccResourceVSphereVirtualMachineCheckCustomizationSucceeded(),
+					testAccResourceVSphereVirtualMachineCheckNet(
+						os.Getenv("VSPHERE_IPV4_ADDRESS"),
+						os.Getenv("VSPHERE_IPV4_PREFIX"),
+						os.Getenv("VSPHERE_IPV4_GATEWAY"),
+					),
+				),
 			},
 		},
-		{
-			"storage vmotion - single disk",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVirtualMachinePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigStorageVMotionSingleDisk(os.Getenv("VSPHERE_DATASTORE")),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-							testAccResourceVSphereVirtualMachineCheckVmxDatastore(os.Getenv("VSPHERE_DATASTORE")),
-							testAccResourceVSphereVirtualMachineCheckVmdkDatastore("terraform-test.vmdk", os.Getenv("VSPHERE_DATASTORE")),
-							testAccResourceVSphereVirtualMachineCheckVmdkDatastore("terraform-test_1.vmdk", os.Getenv("VSPHERE_DATASTORE")),
-						),
-					},
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigStorageVMotionSingleDisk(os.Getenv("VSPHERE_DATASTORE2")),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-							testAccResourceVSphereVirtualMachineCheckVmxDatastore(os.Getenv("VSPHERE_DATASTORE")),
-							testAccResourceVSphereVirtualMachineCheckVmdkDatastore("terraform-test.vmdk", os.Getenv("VSPHERE_DATASTORE")),
-							testAccResourceVSphereVirtualMachineCheckVmdkDatastore("terraform-test_1.vmdk", os.Getenv("VSPHERE_DATASTORE2")),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereVirtualMachine_hostVMotion(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVirtualMachinePreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigHostVMotion(os.Getenv("VSPHERE_ESXI_HOST")),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+					testAccResourceVSphereVirtualMachineCheckHost(os.Getenv("VSPHERE_ESXI_HOST")),
+				),
+			},
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigHostVMotion(os.Getenv("VSPHERE_ESXI_HOST2")),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+					testAccResourceVSphereVirtualMachineCheckHost(os.Getenv("VSPHERE_ESXI_HOST2")),
+				),
 			},
 		},
-		{
-			"storage vmotion - pin datastore",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVirtualMachinePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigStorageVMotionPinDatastore(os.Getenv("VSPHERE_DATASTORE")),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-							testAccResourceVSphereVirtualMachineCheckVmxDatastore(os.Getenv("VSPHERE_DATASTORE")),
-							testAccResourceVSphereVirtualMachineCheckVmdkDatastore("terraform-test.vmdk", os.Getenv("VSPHERE_DATASTORE")),
-							testAccResourceVSphereVirtualMachineCheckVmdkDatastore("terraform-test_1.vmdk", os.Getenv("VSPHERE_DATASTORE")),
-						),
-					},
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigStorageVMotionPinDatastore(os.Getenv("VSPHERE_DATASTORE2")),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-							testAccResourceVSphereVirtualMachineCheckVmxDatastore(os.Getenv("VSPHERE_DATASTORE2")),
-							testAccResourceVSphereVirtualMachineCheckVmdkDatastore("terraform-test.vmdk", os.Getenv("VSPHERE_DATASTORE2")),
-							testAccResourceVSphereVirtualMachineCheckVmdkDatastore("terraform-test_1.vmdk", os.Getenv("VSPHERE_DATASTORE")),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereVirtualMachine_resourcePoolVMotion(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVirtualMachinePreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigResourcePoolVMotion(os.Getenv("VSPHERE_RESOURCE_POOL")),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+					testAccResourceVSphereVirtualMachineCheckResourcePool(os.Getenv("VSPHERE_RESOURCE_POOL")),
+				),
+			},
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigResourcePoolVMotion(fmt.Sprintf("%s/Resources", os.Getenv("VSPHERE_CLUSTER"))),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+					testAccResourceVSphereVirtualMachineCheckResourcePool(fmt.Sprintf("%s/Resources", os.Getenv("VSPHERE_CLUSTER"))),
+				),
 			},
 		},
-		{
-			"storage vmotion - renamed virtual machine",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVirtualMachinePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigStorageVMotionRename("terraform-test", os.Getenv("VSPHERE_DATASTORE")),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-							testAccResourceVSphereVirtualMachineCheckVmxDatastore(os.Getenv("VSPHERE_DATASTORE")),
-							testAccResourceVSphereVirtualMachineCheckVmdkDatastore("terraform-test.vmdk", os.Getenv("VSPHERE_DATASTORE")),
-						),
-					},
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigStorageVMotionRename("foobar-test", os.Getenv("VSPHERE_DATASTORE")),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-							testAccResourceVSphereVirtualMachineCheckVmxDatastore(os.Getenv("VSPHERE_DATASTORE")),
-							testAccResourceVSphereVirtualMachineCheckVmdkDatastore("terraform-test.vmdk", os.Getenv("VSPHERE_DATASTORE")),
-						),
-					},
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigStorageVMotionRename("foobar-test", os.Getenv("VSPHERE_DATASTORE2")),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-							testAccResourceVSphereVirtualMachineCheckVmxDatastore(os.Getenv("VSPHERE_DATASTORE2")),
-							testAccResourceVSphereVirtualMachineCheckVmdkDatastore("foobar-test.vmdk", os.Getenv("VSPHERE_DATASTORE2")),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereVirtualMachine_storageVMotionGlobalSetting(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVirtualMachinePreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigStorageVMotionGlobal(os.Getenv("VSPHERE_DATASTORE")),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+					testAccResourceVSphereVirtualMachineCheckVmxDatastore(os.Getenv("VSPHERE_DATASTORE")),
+					testAccResourceVSphereVirtualMachineCheckVmdkDatastore("terraform-test.vmdk", os.Getenv("VSPHERE_DATASTORE")),
+				),
+			},
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigStorageVMotionGlobal(os.Getenv("VSPHERE_DATASTORE2")),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+					testAccResourceVSphereVirtualMachineCheckVmxDatastore(os.Getenv("VSPHERE_DATASTORE2")),
+					testAccResourceVSphereVirtualMachineCheckVmdkDatastore("terraform-test.vmdk", os.Getenv("VSPHERE_DATASTORE2")),
+				),
 			},
 		},
-		{
-			"storage vmotion - linked clones",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVirtualMachinePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigStorageVMotionLinkedClone(os.Getenv("VSPHERE_DATASTORE")),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-							testAccResourceVSphereVirtualMachineCheckVmxDatastore(os.Getenv("VSPHERE_DATASTORE")),
-							testAccResourceVSphereVirtualMachineCheckVmdkDatastore("terraform-test.vmdk", os.Getenv("VSPHERE_DATASTORE")),
-						),
-					},
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigStorageVMotionLinkedClone(os.Getenv("VSPHERE_DATASTORE2")),
-						Check: resource.ComposeTestCheckFunc(
-							copyStatePtr(&state),
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-							testAccResourceVSphereVirtualMachineCheckVmxDatastore(os.Getenv("VSPHERE_DATASTORE2")),
-							func(s *terraform.State) error {
-								filename := path.Base(state.RootModule().Resources["vsphere_virtual_machine.vm"].Primary.Attributes["disk.0.path"])
-								return testAccResourceVSphereVirtualMachineCheckVmdkDatastore(filename, os.Getenv("VSPHERE_DATASTORE2"))(s)
-							},
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereVirtualMachine_storageVMotionSingleDisk(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVirtualMachinePreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigStorageVMotionSingleDisk(os.Getenv("VSPHERE_DATASTORE")),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+					testAccResourceVSphereVirtualMachineCheckVmxDatastore(os.Getenv("VSPHERE_DATASTORE")),
+					testAccResourceVSphereVirtualMachineCheckVmdkDatastore("terraform-test.vmdk", os.Getenv("VSPHERE_DATASTORE")),
+					testAccResourceVSphereVirtualMachineCheckVmdkDatastore("terraform-test_1.vmdk", os.Getenv("VSPHERE_DATASTORE")),
+				),
+			},
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigStorageVMotionSingleDisk(os.Getenv("VSPHERE_DATASTORE2")),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+					testAccResourceVSphereVirtualMachineCheckVmxDatastore(os.Getenv("VSPHERE_DATASTORE")),
+					testAccResourceVSphereVirtualMachineCheckVmdkDatastore("terraform-test.vmdk", os.Getenv("VSPHERE_DATASTORE")),
+					testAccResourceVSphereVirtualMachineCheckVmdkDatastore("terraform-test_1.vmdk", os.Getenv("VSPHERE_DATASTORE2")),
+				),
 			},
 		},
-		{
-			"storage vmotion - block externally attached disks",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVirtualMachinePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigStorageVMotionAttachedDisk(os.Getenv("VSPHERE_DATASTORE")),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-							testAccResourceVSphereVirtualMachineCheckVmxDatastore(os.Getenv("VSPHERE_DATASTORE")),
-							testAccResourceVSphereVirtualMachineCheckVmdkDatastore("terraform-test.vmdk", os.Getenv("VSPHERE_DATASTORE")),
-						),
-					},
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigStorageVMotionAttachedDisk(os.Getenv("VSPHERE_DATASTORE2")),
-						ExpectError: regexp.MustCompile(regexp.QuoteMeta(
-							fmt.Sprintf("externally attached disk %q cannot be migrated", testAccResourceVSphereVirtualMachineDiskNameExtraVmdk),
-						)),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereVirtualMachine_storageVMotionPinDatastore(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVirtualMachinePreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigStorageVMotionPinDatastore(os.Getenv("VSPHERE_DATASTORE")),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+					testAccResourceVSphereVirtualMachineCheckVmxDatastore(os.Getenv("VSPHERE_DATASTORE")),
+					testAccResourceVSphereVirtualMachineCheckVmdkDatastore("terraform-test.vmdk", os.Getenv("VSPHERE_DATASTORE")),
+					testAccResourceVSphereVirtualMachineCheckVmdkDatastore("terraform-test_1.vmdk", os.Getenv("VSPHERE_DATASTORE")),
+				),
+			},
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigStorageVMotionPinDatastore(os.Getenv("VSPHERE_DATASTORE2")),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+					testAccResourceVSphereVirtualMachineCheckVmxDatastore(os.Getenv("VSPHERE_DATASTORE2")),
+					testAccResourceVSphereVirtualMachineCheckVmdkDatastore("terraform-test.vmdk", os.Getenv("VSPHERE_DATASTORE2")),
+					testAccResourceVSphereVirtualMachineCheckVmdkDatastore("terraform-test_1.vmdk", os.Getenv("VSPHERE_DATASTORE")),
+				),
 			},
 		},
-		{
-			"single custom attribute",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVirtualMachinePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigWithCustomAttribute(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-							testAccResourceVSphereVirtualMachineCheckCustomAttributes(),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereVirtualMachine_storageVMotionRenamedVirtualMachine(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVirtualMachinePreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigStorageVMotionRename("terraform-test", os.Getenv("VSPHERE_DATASTORE")),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+					testAccResourceVSphereVirtualMachineCheckVmxDatastore(os.Getenv("VSPHERE_DATASTORE")),
+					testAccResourceVSphereVirtualMachineCheckVmdkDatastore("terraform-test.vmdk", os.Getenv("VSPHERE_DATASTORE")),
+				),
+			},
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigStorageVMotionRename("foobar-test", os.Getenv("VSPHERE_DATASTORE")),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+					testAccResourceVSphereVirtualMachineCheckVmxDatastore(os.Getenv("VSPHERE_DATASTORE")),
+					testAccResourceVSphereVirtualMachineCheckVmdkDatastore("terraform-test.vmdk", os.Getenv("VSPHERE_DATASTORE")),
+				),
+			},
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigStorageVMotionRename("foobar-test", os.Getenv("VSPHERE_DATASTORE2")),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+					testAccResourceVSphereVirtualMachineCheckVmxDatastore(os.Getenv("VSPHERE_DATASTORE2")),
+					testAccResourceVSphereVirtualMachineCheckVmdkDatastore("foobar-test.vmdk", os.Getenv("VSPHERE_DATASTORE2")),
+				),
 			},
 		},
-		{
-			"multi custom attribute",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVirtualMachinePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigWithMultiCustomAttribute(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-							testAccResourceVSphereVirtualMachineCheckCustomAttributes(),
-						),
+	})
+}
+
+func TestAccResourceVSphereVirtualMachine_storageVMotionLinkedClones(t *testing.T) {
+	var state *terraform.State
+
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVirtualMachinePreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigStorageVMotionLinkedClone(os.Getenv("VSPHERE_DATASTORE")),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+					testAccResourceVSphereVirtualMachineCheckVmxDatastore(os.Getenv("VSPHERE_DATASTORE")),
+					testAccResourceVSphereVirtualMachineCheckVmdkDatastore("terraform-test.vmdk", os.Getenv("VSPHERE_DATASTORE")),
+				),
+			},
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigStorageVMotionLinkedClone(os.Getenv("VSPHERE_DATASTORE2")),
+				Check: resource.ComposeTestCheckFunc(
+					copyStatePtr(&state),
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+					testAccResourceVSphereVirtualMachineCheckVmxDatastore(os.Getenv("VSPHERE_DATASTORE2")),
+					func(s *terraform.State) error {
+						filename := path.Base(state.RootModule().Resources["vsphere_virtual_machine.vm"].Primary.Attributes["disk.0.path"])
+						return testAccResourceVSphereVirtualMachineCheckVmdkDatastore(filename, os.Getenv("VSPHERE_DATASTORE2"))(s)
 					},
-				},
+				),
 			},
 		},
-		{
-			"switch custom attribute",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVirtualMachinePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigWithCustomAttribute(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-							testAccResourceVSphereVirtualMachineCheckCustomAttributes(),
-						),
-					},
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigWithMultiCustomAttribute(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-							testAccResourceVSphereVirtualMachineCheckCustomAttributes(),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereVirtualMachine_storageVMotionBlockExternallyAttachedDisks(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVirtualMachinePreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigStorageVMotionAttachedDisk(os.Getenv("VSPHERE_DATASTORE")),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+					testAccResourceVSphereVirtualMachineCheckVmxDatastore(os.Getenv("VSPHERE_DATASTORE")),
+					testAccResourceVSphereVirtualMachineCheckVmdkDatastore("terraform-test.vmdk", os.Getenv("VSPHERE_DATASTORE")),
+				),
+			},
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigStorageVMotionAttachedDisk(os.Getenv("VSPHERE_DATASTORE2")),
+				ExpectError: regexp.MustCompile(regexp.QuoteMeta(
+					fmt.Sprintf("externally attached disk %q cannot be migrated", testAccResourceVSphereVirtualMachineDiskNameExtraVmdk),
+				)),
 			},
 		},
-		// TODO: Remove this test in 2.0
-		{
-			"transition to label",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVirtualMachinePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigBasicDiskNameOrLabel("name"),
-						Check: resource.ComposeTestCheckFunc(
-							copyState(&state),
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-						),
-					},
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigBasicDiskNameOrLabel("label"),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-							func(s *terraform.State) error {
-								uuid := state.RootModule().Resources["vsphere_virtual_machine.vm"].Primary.Attributes["disk.0.uuid"]
-								return resource.TestCheckResourceAttr("vsphere_virtual_machine.vm", "disk.0.uuid", uuid)(s)
-							},
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereVirtualMachine_singleCustomAttribute(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVirtualMachinePreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigWithCustomAttribute(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+					testAccResourceVSphereVirtualMachineCheckCustomAttributes(),
+				),
 			},
 		},
-		// TODO: Remove this test in 2.0
-		{
-			"prevent revert to name",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVirtualMachinePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigBasicDiskNameOrLabel("name"),
-						Check: resource.ComposeTestCheckFunc(
-							copyState(&state),
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-						),
-					},
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigBasicDiskNameOrLabel("label"),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-							func(s *terraform.State) error {
-								uuid := state.RootModule().Resources["vsphere_virtual_machine.vm"].Primary.Attributes["disk.0.uuid"]
-								return resource.TestCheckResourceAttr("vsphere_virtual_machine.vm", "disk.0.uuid", uuid)(s)
-							},
-						),
-					},
-					{
-						Config:      testAccResourceVSphereVirtualMachineConfigBasicDiskNameOrLabel("name"),
-						ExpectError: regexp.MustCompile("cannot migrate from label to name"),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereVirtualMachine_multiCustomAttribute(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVirtualMachinePreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigWithMultiCustomAttribute(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+					testAccResourceVSphereVirtualMachineCheckCustomAttributes(),
+				),
 			},
 		},
-		// TODO: Remove this test in 2.0
-		{
-			"transition to label - attached disk",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVirtualMachinePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigExistingVmdkWithName(),
-						Check: resource.ComposeTestCheckFunc(
-							copyState(&state),
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-						),
-					},
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigExistingVmdkWithLabel(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-							func(s *terraform.State) error {
-								uuid := state.RootModule().Resources["vsphere_virtual_machine.vm"].Primary.Attributes["disk.1.uuid"]
-								if err := resource.TestCheckResourceAttr("vsphere_virtual_machine.vm", "disk.1.uuid", uuid)(s); err != nil {
-									return err
-								}
-								return resource.TestCheckResourceAttr("vsphere_virtual_machine.vm", "disk.1.attach", "true")(s)
-							},
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereVirtualMachine_switchCustomAttribute(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVirtualMachinePreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigWithCustomAttribute(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+					testAccResourceVSphereVirtualMachineCheckCustomAttributes(),
+				),
+			},
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigWithMultiCustomAttribute(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+					testAccResourceVSphereVirtualMachineCheckCustomAttributes(),
+				),
 			},
 		},
-		{
-			"import",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVirtualMachinePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigBasic(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-						),
-					},
-					{
-						ResourceName:      "vsphere_virtual_machine.vm",
-						ImportState:       true,
-						ImportStateVerify: true,
-						ImportStateVerifyIgnore: []string{
-							"disk",
-							"imported",
-						},
-						ImportStateIdFunc: func(s *terraform.State) (string, error) {
-							vm, err := testGetVirtualMachine(s, "vm")
-							if err != nil {
-								return "", err
-							}
-							return vm.InventoryPath, nil
-						},
-						Config: testAccResourceVSphereVirtualMachineConfigBasic(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-						),
+	})
+}
+
+func TestAccResourceVSphereVirtualMachine_transitionToLabel(t *testing.T) {
+	// TODO: Remove this test in 2.0
+	var state *terraform.State
+
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVirtualMachinePreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigBasicDiskNameOrLabel("name"),
+				Check: resource.ComposeTestCheckFunc(
+					copyState(&state),
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+				),
+			},
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigBasicDiskNameOrLabel("label"),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+					func(s *terraform.State) error {
+						uuid := state.RootModule().Resources["vsphere_virtual_machine.vm"].Primary.Attributes["disk.0.uuid"]
+						return resource.TestCheckResourceAttr("vsphere_virtual_machine.vm", "disk.0.uuid", uuid)(s)
 					},
-				},
+				),
 			},
 		},
-		{
-			"import with multiple disks at different SCSI slots",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVirtualMachinePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereVirtualMachineConfigMultiHighBus(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-						),
+	})
+}
+
+func TestAccResourceVSphereVirtualMachine_preventRevertToName(t *testing.T) {
+	// TODO: Remove this test in 2.0
+	var state *terraform.State
+
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVirtualMachinePreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigBasicDiskNameOrLabel("name"),
+				Check: resource.ComposeTestCheckFunc(
+					copyState(&state),
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+				),
+			},
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigBasicDiskNameOrLabel("label"),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+					func(s *terraform.State) error {
+						uuid := state.RootModule().Resources["vsphere_virtual_machine.vm"].Primary.Attributes["disk.0.uuid"]
+						return resource.TestCheckResourceAttr("vsphere_virtual_machine.vm", "disk.0.uuid", uuid)(s)
 					},
-					{
-						ResourceName:      "vsphere_virtual_machine.vm",
-						ImportState:       true,
-						ImportStateVerify: true,
-						ImportStateVerifyIgnore: []string{
-							"disk",
-							"imported",
-						},
-						ImportStateIdFunc: func(s *terraform.State) (string, error) {
-							vm, err := testGetVirtualMachine(s, "vm")
-							if err != nil {
-								return "", err
-							}
-							return vm.InventoryPath, nil
-						},
-						Config: testAccResourceVSphereVirtualMachineConfigMultiHighBus(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVirtualMachineCheckExists(true),
-						),
+				),
+			},
+			{
+				Config:      testAccResourceVSphereVirtualMachineConfigBasicDiskNameOrLabel("name"),
+				ExpectError: regexp.MustCompile("cannot migrate from label to name"),
+			},
+		},
+	})
+}
+
+func TestAccResourceVSphereVirtualMachine_transitionToLabelAttachedDisk(t *testing.T) {
+	// TODO: Remove this test in 2.0
+	var state *terraform.State
+
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVirtualMachinePreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigExistingVmdkWithName(),
+				Check: resource.ComposeTestCheckFunc(
+					copyState(&state),
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+				),
+			},
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigExistingVmdkWithLabel(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+					func(s *terraform.State) error {
+						uuid := state.RootModule().Resources["vsphere_virtual_machine.vm"].Primary.Attributes["disk.1.uuid"]
+						if err := resource.TestCheckResourceAttr("vsphere_virtual_machine.vm", "disk.1.uuid", uuid)(s); err != nil {
+							return err
+						}
+						return resource.TestCheckResourceAttr("vsphere_virtual_machine.vm", "disk.1.attach", "true")(s)
 					},
+				),
+			},
+		},
+	})
+}
+
+func TestAccResourceVSphereVirtualMachine_import(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVirtualMachinePreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigBasic(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+				),
+			},
+			{
+				ResourceName:      "vsphere_virtual_machine.vm",
+				ImportState:       true,
+				ImportStateVerify: true,
+				ImportStateVerifyIgnore: []string{
+					"disk",
+					"imported",
+				},
+				ImportStateIdFunc: func(s *terraform.State) (string, error) {
+					vm, err := testGetVirtualMachine(s, "vm")
+					if err != nil {
+						return "", err
+					}
+					return vm.InventoryPath, nil
 				},
+				Config: testAccResourceVSphereVirtualMachineConfigBasic(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+				),
 			},
 		},
-	}
+	})
+}
 
-	for _, tc := range testAccResourceVSphereVirtualMachineCases {
-		t.Run(tc.name, func(t *testing.T) {
-			tp = t
-			resource.Test(t, tc.testCase)
-		})
-	}
+func TestAccResourceVSphereVirtualMachine_importWithMultipleDisksAtDifferentSCSISlots(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVirtualMachinePreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereVirtualMachineCheckExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereVirtualMachineConfigMultiHighBus(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+				),
+			},
+			{
+				ResourceName:      "vsphere_virtual_machine.vm",
+				ImportState:       true,
+				ImportStateVerify: true,
+				ImportStateVerifyIgnore: []string{
+					"disk",
+					"imported",
+				},
+				ImportStateIdFunc: func(s *terraform.State) (string, error) {
+					vm, err := testGetVirtualMachine(s, "vm")
+					if err != nil {
+						return "", err
+					}
+					return vm.InventoryPath, nil
+				},
+				Config: testAccResourceVSphereVirtualMachineConfigMultiHighBus(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVirtualMachineCheckExists(true),
+				),
+			},
+		},
+	})
 }
 
 func testAccResourceVSphereVirtualMachinePreCheck(t *testing.T) {
diff --git a/vsphere/resource_vsphere_vmfs_datastore_test.go b/vsphere/resource_vsphere_vmfs_datastore_test.go
index 6a5879ff2..f6f570120 100644
--- a/vsphere/resource_vsphere_vmfs_datastore_test.go
+++ b/vsphere/resource_vsphere_vmfs_datastore_test.go
@@ -14,350 +14,335 @@ import (
 	"github.com/terraform-providers/terraform-provider-vsphere/vsphere/internal/helper/viapi"
 )
 
-func TestAccResourceVSphereVmfsDatastore(t *testing.T) {
-	var tp *testing.T
-	testAccResourceVSphereVmfsDatastoreCases := []struct {
-		name     string
-		testCase resource.TestCase
-	}{
-		{
-			"basic",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVmfsDatastorePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereVmfsDatastoreExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereVmfsDatastoreConfigStaticSingle(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVmfsDatastoreExists(true),
-						),
-					},
-				},
-			},
+func TestAccResourceVSphereVmfsDatastore_basic(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVmfsDatastorePreCheck(t)
 		},
-		{
-			"multi-disk",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVmfsDatastorePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereVmfsDatastoreExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereVmfsDatastoreConfigStaticMulti(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVmfsDatastoreExists(true),
-						),
-					},
-				},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereVmfsDatastoreExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereVmfsDatastoreConfigStaticSingle(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVmfsDatastoreExists(true),
+				),
 			},
 		},
-		{
-			"discovery via data source",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVmfsDatastorePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereVmfsDatastoreExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereVmfsDatastoreConfigDiscoverDatasource(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVmfsDatastoreExists(true),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereVmfsDatastore_multiDisk(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVmfsDatastorePreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereVmfsDatastoreExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereVmfsDatastoreConfigStaticMulti(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVmfsDatastoreExists(true),
+				),
 			},
 		},
-		{
-			"add disks through update",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVmfsDatastorePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereVmfsDatastoreExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereVmfsDatastoreConfigStaticSingle(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVmfsDatastoreExists(true),
-						),
-					},
-					{
-						Config: testAccResourceVSphereVmfsDatastoreConfigStaticMulti(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVmfsDatastoreExists(true),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereVmfsDatastore_discoveryViaDatasource(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVmfsDatastorePreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereVmfsDatastoreExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereVmfsDatastoreConfigDiscoverDatasource(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVmfsDatastoreExists(true),
+				),
 			},
 		},
-		{
-			"rename datastore",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVmfsDatastorePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereVmfsDatastoreExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereVmfsDatastoreConfigStaticSingle(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVmfsDatastoreExists(true),
-						),
-					},
-					{
-						Config: testAccResourceVSphereVmfsDatastoreConfigStaticSingleAltName(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVmfsDatastoreExists(true),
-							testAccResourceVSphereVmfsDatastoreHasName("terraform-test-renamed"),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereVmfsDatastore_addDisksThroughUpdate(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVmfsDatastorePreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereVmfsDatastoreExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereVmfsDatastoreConfigStaticSingle(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVmfsDatastoreExists(true),
+				),
+			},
+			{
+				Config: testAccResourceVSphereVmfsDatastoreConfigStaticMulti(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVmfsDatastoreExists(true),
+				),
 			},
 		},
-		{
-			"with folder",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVmfsDatastorePreCheck(tp)
-					// NOTE: This test can't run on ESXi without giving a "dangling
-					// resource" error during testing - "move to folder after" hits the
-					// error on the same path of the call stack that triggers an error in
-					// both create and update and should provide adequate coverage
-					// barring manual testing.
-					testAccSkipIfEsxi(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereVmfsDatastoreExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereVmfsDatastoreConfigStaticSingleFolder(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVmfsDatastoreExists(true),
-							testAccResourceVSphereVmfsDatastoreMatchInventoryPath(os.Getenv("VSPHERE_DS_FOLDER")),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereVmfsDatastore_renameDatastore(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVmfsDatastorePreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereVmfsDatastoreExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereVmfsDatastoreConfigStaticSingle(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVmfsDatastoreExists(true),
+				),
+			},
+			{
+				Config: testAccResourceVSphereVmfsDatastoreConfigStaticSingleAltName(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVmfsDatastoreExists(true),
+					testAccResourceVSphereVmfsDatastoreHasName("terraform-test-renamed"),
+				),
 			},
 		},
-		{
-			"move to folder after",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVmfsDatastorePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereVmfsDatastoreExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereVmfsDatastoreConfigStaticSingle(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVmfsDatastoreExists(true),
-						),
-					},
-					{
-						Config:      testAccResourceVSphereVmfsDatastoreConfigStaticSingleFolder(),
-						ExpectError: expectErrorIfNotVirtualCenter(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVmfsDatastoreExists(true),
-							testAccResourceVSphereVmfsDatastoreMatchInventoryPath(os.Getenv("VSPHERE_DS_FOLDER")),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereVmfsDatastore_withFolder(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVmfsDatastorePreCheck(t)
+			// NOTE: This test can't run on ESXi without giving a "dangling
+			// resource" error during testing - "move to folder after" hits the
+			// error on the same path of the call stack that triggers an error in
+			// both create and update and should provide adequate coverage
+			// barring manual testing.
+			testAccSkipIfEsxi(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereVmfsDatastoreExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereVmfsDatastoreConfigStaticSingleFolder(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVmfsDatastoreExists(true),
+					testAccResourceVSphereVmfsDatastoreMatchInventoryPath(os.Getenv("VSPHERE_DS_FOLDER")),
+				),
 			},
 		},
-		{
-			"single tag",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVmfsDatastorePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereVmfsDatastoreExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereVmfsDatastoreConfigTags(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVmfsDatastoreExists(true),
-							testAccResourceVSphereDatastoreCheckTags("vsphere_vmfs_datastore.datastore", "terraform-test-tag"),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereVmfsDatastore_moveToFolderAfter(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVmfsDatastorePreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereVmfsDatastoreExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereVmfsDatastoreConfigStaticSingle(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVmfsDatastoreExists(true),
+				),
+			},
+			{
+				Config:      testAccResourceVSphereVmfsDatastoreConfigStaticSingleFolder(),
+				ExpectError: expectErrorIfNotVirtualCenter(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVmfsDatastoreExists(true),
+					testAccResourceVSphereVmfsDatastoreMatchInventoryPath(os.Getenv("VSPHERE_DS_FOLDER")),
+				),
 			},
 		},
-		{
-			"modify tags",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVmfsDatastorePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereVmfsDatastoreExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereVmfsDatastoreConfigTags(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVmfsDatastoreExists(true),
-							testAccResourceVSphereDatastoreCheckTags("vsphere_vmfs_datastore.datastore", "terraform-test-tag"),
-						),
-					},
-					{
-						Config: testAccResourceVSphereVmfsDatastoreConfigMultiTags(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVmfsDatastoreExists(true),
-							testAccResourceVSphereDatastoreCheckTags("vsphere_vmfs_datastore.datastore", "terraform-test-tags-alt"),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereVmfsDatastore_singleTag(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVmfsDatastorePreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereVmfsDatastoreExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereVmfsDatastoreConfigTags(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVmfsDatastoreExists(true),
+					testAccResourceVSphereDatastoreCheckTags("vsphere_vmfs_datastore.datastore", "terraform-test-tag"),
+				),
 			},
 		},
-		{
-			"bad disk entry",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVmfsDatastorePreCheck(tp)
-				},
-				Providers: testAccProviders,
-				Steps: []resource.TestStep{
-					{
-						Config:      testAccResourceVSphereVmfsDatastoreConfigBadDisk(),
-						ExpectError: regexp.MustCompile("empty entry"),
-						PlanOnly:    true,
-					},
-					{
-						Config: testAccResourceVSphereEmpty,
-						Check:  resource.ComposeTestCheckFunc(),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereVmfsDatastore_modifyTags(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVmfsDatastorePreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereVmfsDatastoreExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereVmfsDatastoreConfigTags(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVmfsDatastoreExists(true),
+					testAccResourceVSphereDatastoreCheckTags("vsphere_vmfs_datastore.datastore", "terraform-test-tag"),
+				),
+			},
+			{
+				Config: testAccResourceVSphereVmfsDatastoreConfigMultiTags(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVmfsDatastoreExists(true),
+					testAccResourceVSphereDatastoreCheckTags("vsphere_vmfs_datastore.datastore", "terraform-test-tags-alt"),
+				),
 			},
 		},
-		{
-			"duplicate disk entry",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVmfsDatastorePreCheck(tp)
-				},
-				Providers: testAccProviders,
-				Steps: []resource.TestStep{
-					{
-						Config:      testAccResourceVSphereVmfsDatastoreConfigDuplicateDisk(),
-						ExpectError: regexp.MustCompile("duplicate name"),
-						PlanOnly:    true,
-					},
-					{
-						Config: testAccResourceVSphereEmpty,
-						Check:  resource.ComposeTestCheckFunc(),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereVmfsDatastore_badDiskEntry(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVmfsDatastorePreCheck(t)
+		},
+		Providers: testAccProviders,
+		Steps: []resource.TestStep{
+			{
+				Config:      testAccResourceVSphereVmfsDatastoreConfigBadDisk(),
+				ExpectError: regexp.MustCompile("empty entry"),
+				PlanOnly:    true,
+			},
+			{
+				Config: testAccResourceVSphereEmpty,
+				Check:  resource.ComposeTestCheckFunc(),
 			},
 		},
-		{
-			"import",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVmfsDatastorePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereVmfsDatastoreExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereVmfsDatastoreConfigStaticSingle(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVmfsDatastoreExists(true),
-						),
-					},
-					{
-						Config:      testAccResourceVSphereVmfsDatastoreConfigStaticSingle(),
-						ImportState: true,
-						ImportStateIdFunc: func(s *terraform.State) (string, error) {
-							vars, err := testClientVariablesForResource(s, "vsphere_vmfs_datastore.datastore")
-							if err != nil {
-								return "", err
-							}
-
-							return fmt.Sprintf("%s:%s", vars.resourceID, vars.resourceAttributes["host_system_id"]), nil
-						},
-						ResourceName:      "vsphere_vmfs_datastore.datastore",
-						ImportStateVerify: true,
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereVmfsDatastore_duplicateDiskEntry(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVmfsDatastorePreCheck(t)
+		},
+		Providers: testAccProviders,
+		Steps: []resource.TestStep{
+			{
+				Config:      testAccResourceVSphereVmfsDatastoreConfigDuplicateDisk(),
+				ExpectError: regexp.MustCompile("duplicate name"),
+				PlanOnly:    true,
+			},
+			{
+				Config: testAccResourceVSphereEmpty,
+				Check:  resource.ComposeTestCheckFunc(),
 			},
 		},
-		{
-			"single custom attribute",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVmfsDatastorePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereVmfsDatastoreExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereVmfsDatastoreConfigCustomAttributes(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVmfsDatastoreExists(true),
-							testAccResourceVSphereVmfsDatastoreHasCustomAttributes(),
-						),
-					},
+	})
+}
+
+func TestAccResourceVSphereVmfsDatastore_import(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVmfsDatastorePreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereVmfsDatastoreExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereVmfsDatastoreConfigStaticSingle(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVmfsDatastoreExists(true),
+				),
+			},
+			{
+				Config:      testAccResourceVSphereVmfsDatastoreConfigStaticSingle(),
+				ImportState: true,
+				ImportStateIdFunc: func(s *terraform.State) (string, error) {
+					vars, err := testClientVariablesForResource(s, "vsphere_vmfs_datastore.datastore")
+					if err != nil {
+						return "", err
+					}
+
+					return fmt.Sprintf("%s:%s", vars.resourceID, vars.resourceAttributes["host_system_id"]), nil
 				},
+				ResourceName:            "vsphere_vmfs_datastore.datastore",
+				ImportStateVerify:       true,
+				ImportStateVerifyIgnore: []string{"multiple_host_access"},
 			},
 		},
-		{
-			"multi custom attribute",
-			resource.TestCase{
-				PreCheck: func() {
-					testAccPreCheck(tp)
-					testAccResourceVSphereVmfsDatastorePreCheck(tp)
-				},
-				Providers:    testAccProviders,
-				CheckDestroy: testAccResourceVSphereVmfsDatastoreExists(false),
-				Steps: []resource.TestStep{
-					{
-						Config: testAccResourceVSphereVmfsDatastoreConfigCustomAttributes(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVmfsDatastoreExists(true),
-							testAccResourceVSphereVmfsDatastoreHasCustomAttributes(),
-						),
-					},
-					{
-						Config: testAccResourceVSphereVmfsDatastoreConfigMultiCustomAttributes(),
-						Check: resource.ComposeTestCheckFunc(
-							testAccResourceVSphereVmfsDatastoreExists(true),
-							testAccResourceVSphereVmfsDatastoreHasCustomAttributes(),
-						),
-					},
-				},
+	})
+}
+
+func TestAccResourceVSphereVmfsDatastore_singleCustomAttribute(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVmfsDatastorePreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereVmfsDatastoreExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereVmfsDatastoreConfigCustomAttributes(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVmfsDatastoreExists(true),
+					testAccResourceVSphereVmfsDatastoreHasCustomAttributes(),
+				),
 			},
 		},
-	}
+	})
+}
 
-	for _, tc := range testAccResourceVSphereVmfsDatastoreCases {
-		t.Run(tc.name, func(t *testing.T) {
-			tp = t
-			resource.Test(t, tc.testCase)
-		})
-	}
+func TestAccResourceVSphereVmfsDatastore_multiCustomAttribute(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			testAccResourceVSphereVmfsDatastorePreCheck(t)
+		},
+		Providers:    testAccProviders,
+		CheckDestroy: testAccResourceVSphereVmfsDatastoreExists(false),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccResourceVSphereVmfsDatastoreConfigCustomAttributes(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVmfsDatastoreExists(true),
+					testAccResourceVSphereVmfsDatastoreHasCustomAttributes(),
+				),
+			},
+			{
+				Config: testAccResourceVSphereVmfsDatastoreConfigMultiCustomAttributes(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccResourceVSphereVmfsDatastoreExists(true),
+					testAccResourceVSphereVmfsDatastoreHasCustomAttributes(),
+				),
+			},
+		},
+	})
 }
 
 func testAccResourceVSphereVmfsDatastorePreCheck(t *testing.T) {
@@ -425,7 +410,7 @@ func testAccResourceVSphereVmfsDatastoreMatchInventoryPath(expected string) reso
 			return err
 		}
 
-		expected, err := folder.RootPathParticleDatastore.PathFromNewRoot(ds.InventoryPath, folder.RootPathParticleDatastore, expected)
+		expected, err = folder.RootPathParticleDatastore.PathFromNewRoot(ds.InventoryPath, folder.RootPathParticleDatastore, expected)
 		actual := path.Dir(ds.InventoryPath)
 		if err != nil {
 			return fmt.Errorf("bad: %s", err)