apps_accessors_test.go

// Copyright 2017 The go-github AUTHORS. All rights reserved.
//
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Code generated by gen-accessors; DO NOT EDIT.
// Instead, please run "go generate ./..." as described here:
// https://github.com/google/go-github/blob/master/CONTRIBUTING.md#submitting-a-patch

package godo

import (
	"testing"
)

func TestApp_GetActiveDeployment(tt *testing.T) {
	a := &App{}
	a.GetActiveDeployment()
	a = nil
	a.GetActiveDeployment()
}

func TestApp_GetBuildConfig(tt *testing.T) {
	a := &App{}
	a.GetBuildConfig()
	a = nil
	a.GetBuildConfig()
}

func TestApp_GetCreatedAt(tt *testing.T) {
	a := &App{}
	a.GetCreatedAt()
	a = nil
	a.GetCreatedAt()
}

func TestApp_GetDedicatedIps(tt *testing.T) {
	a := &App{}
	a.GetDedicatedIps()
	a = nil
	a.GetDedicatedIps()
}

func TestApp_GetDefaultIngress(tt *testing.T) {
	a := &App{}
	a.GetDefaultIngress()
	a = nil
	a.GetDefaultIngress()
}

func TestApp_GetDomains(tt *testing.T) {
	a := &App{}
	a.GetDomains()
	a = nil
	a.GetDomains()
}

func TestApp_GetID(tt *testing.T) {
	a := &App{}
	a.GetID()
	a = nil
	a.GetID()
}

func TestApp_GetInProgressDeployment(tt *testing.T) {
	a := &App{}
	a.GetInProgressDeployment()
	a = nil
	a.GetInProgressDeployment()
}

func TestApp_GetLastDeploymentActiveAt(tt *testing.T) {
	a := &App{}
	a.GetLastDeploymentActiveAt()
	a = nil
	a.GetLastDeploymentActiveAt()
}

func TestApp_GetLastDeploymentCreatedAt(tt *testing.T) {
	a := &App{}
	a.GetLastDeploymentCreatedAt()
	a = nil
	a.GetLastDeploymentCreatedAt()
}

func TestApp_GetLiveDomain(tt *testing.T) {
	a := &App{}
	a.GetLiveDomain()
	a = nil
	a.GetLiveDomain()
}

func TestApp_GetLiveURL(tt *testing.T) {
	a := &App{}
	a.GetLiveURL()
	a = nil
	a.GetLiveURL()
}

func TestApp_GetLiveURLBase(tt *testing.T) {
	a := &App{}
	a.GetLiveURLBase()
	a = nil
	a.GetLiveURLBase()
}

func TestApp_GetOwnerUUID(tt *testing.T) {
	a := &App{}
	a.GetOwnerUUID()
	a = nil
	a.GetOwnerUUID()
}

func TestApp_GetPendingDeployment(tt *testing.T) {
	a := &App{}
	a.GetPendingDeployment()
	a = nil
	a.GetPendingDeployment()
}

func TestApp_GetPinnedDeployment(tt *testing.T) {
	a := &App{}
	a.GetPinnedDeployment()
	a = nil
	a.GetPinnedDeployment()
}

func TestApp_GetProjectID(tt *testing.T) {
	a := &App{}
	a.GetProjectID()
	a = nil
	a.GetProjectID()
}

func TestApp_GetRegion(tt *testing.T) {
	a := &App{}
	a.GetRegion()
	a = nil
	a.GetRegion()
}

func TestApp_GetSpec(tt *testing.T) {
	a := &App{}
	a.GetSpec()
	a = nil
	a.GetSpec()
}

func TestApp_GetTierSlug(tt *testing.T) {
	a := &App{}
	a.GetTierSlug()
	a = nil
	a.GetTierSlug()
}

func TestApp_GetUpdatedAt(tt *testing.T) {
	a := &App{}
	a.GetUpdatedAt()
	a = nil
	a.GetUpdatedAt()
}

func TestAppAlert_GetComponentName(tt *testing.T) {
	a := &AppAlert{}
	a.GetComponentName()
	a = nil
	a.GetComponentName()
}

func TestAppAlert_GetEmails(tt *testing.T) {
	a := &AppAlert{}
	a.GetEmails()
	a = nil
	a.GetEmails()
}

func TestAppAlert_GetID(tt *testing.T) {
	a := &AppAlert{}
	a.GetID()
	a = nil
	a.GetID()
}

func TestAppAlert_GetPhase(tt *testing.T) {
	a := &AppAlert{}
	a.GetPhase()
	a = nil
	a.GetPhase()
}

func TestAppAlert_GetProgress(tt *testing.T) {
	a := &AppAlert{}
	a.GetProgress()
	a = nil
	a.GetProgress()
}

func TestAppAlert_GetSlackWebhooks(tt *testing.T) {
	a := &AppAlert{}
	a.GetSlackWebhooks()
	a = nil
	a.GetSlackWebhooks()
}

func TestAppAlert_GetSpec(tt *testing.T) {
	a := &AppAlert{}
	a.GetSpec()
	a = nil
	a.GetSpec()
}

func TestAppAlertProgress_GetSteps(tt *testing.T) {
	a := &AppAlertProgress{}
	a.GetSteps()
	a = nil
	a.GetSteps()
}

func TestAppAlertProgressStep_GetEndedAt(tt *testing.T) {
	a := &AppAlertProgressStep{}
	a.GetEndedAt()
	a = nil
	a.GetEndedAt()
}

func TestAppAlertProgressStep_GetName(tt *testing.T) {
	a := &AppAlertProgressStep{}
	a.GetName()
	a = nil
	a.GetName()
}

func TestAppAlertProgressStep_GetReason(tt *testing.T) {
	a := &AppAlertProgressStep{}
	a.GetReason()
	a = nil
	a.GetReason()
}

func TestAppAlertProgressStep_GetStartedAt(tt *testing.T) {
	a := &AppAlertProgressStep{}
	a.GetStartedAt()
	a = nil
	a.GetStartedAt()
}

func TestAppAlertProgressStep_GetStatus(tt *testing.T) {
	a := &AppAlertProgressStep{}
	a.GetStatus()
	a = nil
	a.GetStatus()
}

func TestAppAlertProgressStep_GetSteps(tt *testing.T) {
	a := &AppAlertProgressStep{}
	a.GetSteps()
	a = nil
	a.GetSteps()
}

func TestAppAlertProgressStepReason_GetCode(tt *testing.T) {
	a := &AppAlertProgressStepReason{}
	a.GetCode()
	a = nil
	a.GetCode()
}

func TestAppAlertProgressStepReason_GetMessage(tt *testing.T) {
	a := &AppAlertProgressStepReason{}
	a.GetMessage()
	a = nil
	a.GetMessage()
}

func TestAppAlertSlackWebhook_GetChannel(tt *testing.T) {
	a := &AppAlertSlackWebhook{}
	a.GetChannel()
	a = nil
	a.GetChannel()
}

func TestAppAlertSlackWebhook_GetURL(tt *testing.T) {
	a := &AppAlertSlackWebhook{}
	a.GetURL()
	a = nil
	a.GetURL()
}

func TestAppAlertSpec_GetDisabled(tt *testing.T) {
	a := &AppAlertSpec{}
	a.GetDisabled()
	a = nil
	a.GetDisabled()
}

func TestAppAlertSpec_GetOperator(tt *testing.T) {
	a := &AppAlertSpec{}
	a.GetOperator()
	a = nil
	a.GetOperator()
}

func TestAppAlertSpec_GetRule(tt *testing.T) {
	a := &AppAlertSpec{}
	a.GetRule()
	a = nil
	a.GetRule()
}

func TestAppAlertSpec_GetValue(tt *testing.T) {
	a := &AppAlertSpec{}
	a.GetValue()
	a = nil
	a.GetValue()
}

func TestAppAlertSpec_GetWindow(tt *testing.T) {
	a := &AppAlertSpec{}
	a.GetWindow()
	a = nil
	a.GetWindow()
}

func TestAppAutoscalingSpec_GetMaxInstanceCount(tt *testing.T) {
	a := &AppAutoscalingSpec{}
	a.GetMaxInstanceCount()
	a = nil
	a.GetMaxInstanceCount()
}

func TestAppAutoscalingSpec_GetMetrics(tt *testing.T) {
	a := &AppAutoscalingSpec{}
	a.GetMetrics()
	a = nil
	a.GetMetrics()
}

func TestAppAutoscalingSpec_GetMinInstanceCount(tt *testing.T) {
	a := &AppAutoscalingSpec{}
	a.GetMinInstanceCount()
	a = nil
	a.GetMinInstanceCount()
}

func TestAppAutoscalingSpecMetricCPU_GetPercent(tt *testing.T) {
	a := &AppAutoscalingSpecMetricCPU{}
	a.GetPercent()
	a = nil
	a.GetPercent()
}

func TestAppAutoscalingSpecMetrics_GetCPU(tt *testing.T) {
	a := &AppAutoscalingSpecMetrics{}
	a.GetCPU()
	a = nil
	a.GetCPU()
}

func TestAppBuildConfig_GetCNBVersioning(tt *testing.T) {
	a := &AppBuildConfig{}
	a.GetCNBVersioning()
	a = nil
	a.GetCNBVersioning()
}

func TestAppBuildConfigCNBVersioning_GetBuildpacks(tt *testing.T) {
	a := &AppBuildConfigCNBVersioning{}
	a.GetBuildpacks()
	a = nil
	a.GetBuildpacks()
}

func TestAppBuildConfigCNBVersioning_GetStackID(tt *testing.T) {
	a := &AppBuildConfigCNBVersioning{}
	a.GetStackID()
	a = nil
	a.GetStackID()
}

func TestAppCORSPolicy_GetAllowCredentials(tt *testing.T) {
	a := &AppCORSPolicy{}
	a.GetAllowCredentials()
	a = nil
	a.GetAllowCredentials()
}

func TestAppCORSPolicy_GetAllowHeaders(tt *testing.T) {
	a := &AppCORSPolicy{}
	a.GetAllowHeaders()
	a = nil
	a.GetAllowHeaders()
}

func TestAppCORSPolicy_GetAllowMethods(tt *testing.T) {
	a := &AppCORSPolicy{}
	a.GetAllowMethods()
	a = nil
	a.GetAllowMethods()
}

func TestAppCORSPolicy_GetAllowOrigins(tt *testing.T) {
	a := &AppCORSPolicy{}
	a.GetAllowOrigins()
	a = nil
	a.GetAllowOrigins()
}

func TestAppCORSPolicy_GetExposeHeaders(tt *testing.T) {
	a := &AppCORSPolicy{}
	a.GetExposeHeaders()
	a = nil
	a.GetExposeHeaders()
}

func TestAppCORSPolicy_GetMaxAge(tt *testing.T) {
	a := &AppCORSPolicy{}
	a.GetMaxAge()
	a = nil
	a.GetMaxAge()
}

func TestAppCreateRequest_GetProjectID(tt *testing.T) {
	a := &AppCreateRequest{}
	a.GetProjectID()
	a = nil
	a.GetProjectID()
}

func TestAppCreateRequest_GetSpec(tt *testing.T) {
	a := &AppCreateRequest{}
	a.GetSpec()
	a = nil
	a.GetSpec()
}

func TestAppDatabaseSpec_GetClusterName(tt *testing.T) {
	a := &AppDatabaseSpec{}
	a.GetClusterName()
	a = nil
	a.GetClusterName()
}

func TestAppDatabaseSpec_GetDBName(tt *testing.T) {
	a := &AppDatabaseSpec{}
	a.GetDBName()
	a = nil
	a.GetDBName()
}

func TestAppDatabaseSpec_GetDBUser(tt *testing.T) {
	a := &AppDatabaseSpec{}
	a.GetDBUser()
	a = nil
	a.GetDBUser()
}

func TestAppDatabaseSpec_GetEngine(tt *testing.T) {
	a := &AppDatabaseSpec{}
	a.GetEngine()
	a = nil
	a.GetEngine()
}

func TestAppDatabaseSpec_GetName(tt *testing.T) {
	a := &AppDatabaseSpec{}
	a.GetName()
	a = nil
	a.GetName()
}

func TestAppDatabaseSpec_GetNumNodes(tt *testing.T) {
	a := &AppDatabaseSpec{}
	a.GetNumNodes()
	a = nil
	a.GetNumNodes()
}

func TestAppDatabaseSpec_GetProduction(tt *testing.T) {
	a := &AppDatabaseSpec{}
	a.GetProduction()
	a = nil
	a.GetProduction()
}

func TestAppDatabaseSpec_GetSize(tt *testing.T) {
	a := &AppDatabaseSpec{}
	a.GetSize()
	a = nil
	a.GetSize()
}

func TestAppDatabaseSpec_GetVersion(tt *testing.T) {
	a := &AppDatabaseSpec{}
	a.GetVersion()
	a = nil
	a.GetVersion()
}

func TestAppDedicatedIp_GetID(tt *testing.T) {
	a := &AppDedicatedIp{}
	a.GetID()
	a = nil
	a.GetID()
}

func TestAppDedicatedIp_GetIp(tt *testing.T) {
	a := &AppDedicatedIp{}
	a.GetIp()
	a = nil
	a.GetIp()
}

func TestAppDedicatedIp_GetStatus(tt *testing.T) {
	a := &AppDedicatedIp{}
	a.GetStatus()
	a = nil
	a.GetStatus()
}

func TestAppDomain_GetCertificateExpiresAt(tt *testing.T) {
	a := &AppDomain{}
	a.GetCertificateExpiresAt()
	a = nil
	a.GetCertificateExpiresAt()
}

func TestAppDomain_GetID(tt *testing.T) {
	a := &AppDomain{}
	a.GetID()
	a = nil
	a.GetID()
}

func TestAppDomain_GetPhase(tt *testing.T) {
	a := &AppDomain{}
	a.GetPhase()
	a = nil
	a.GetPhase()
}

func TestAppDomain_GetProgress(tt *testing.T) {
	a := &AppDomain{}
	a.GetProgress()
	a = nil
	a.GetProgress()
}

func TestAppDomain_GetRotateValidationRecords(tt *testing.T) {
	a := &AppDomain{}
	a.GetRotateValidationRecords()
	a = nil
	a.GetRotateValidationRecords()
}

func TestAppDomain_GetSpec(tt *testing.T) {
	a := &AppDomain{}
	a.GetSpec()
	a = nil
	a.GetSpec()
}

func TestAppDomain_GetValidation(tt *testing.T) {
	a := &AppDomain{}
	a.GetValidation()
	a = nil
	a.GetValidation()
}

func TestAppDomain_GetValidations(tt *testing.T) {
	a := &AppDomain{}
	a.GetValidations()
	a = nil
	a.GetValidations()
}

func TestAppDomainProgress_GetSteps(tt *testing.T) {
	a := &AppDomainProgress{}
	a.GetSteps()
	a = nil
	a.GetSteps()
}

func TestAppDomainProgressStep_GetEndedAt(tt *testing.T) {
	a := &AppDomainProgressStep{}
	a.GetEndedAt()
	a = nil
	a.GetEndedAt()
}

func TestAppDomainProgressStep_GetName(tt *testing.T) {
	a := &AppDomainProgressStep{}
	a.GetName()
	a = nil
	a.GetName()
}

func TestAppDomainProgressStep_GetReason(tt *testing.T) {
	a := &AppDomainProgressStep{}
	a.GetReason()
	a = nil
	a.GetReason()
}

func TestAppDomainProgressStep_GetStartedAt(tt *testing.T) {
	a := &AppDomainProgressStep{}
	a.GetStartedAt()
	a = nil
	a.GetStartedAt()
}

func TestAppDomainProgressStep_GetStatus(tt *testing.T) {
	a := &AppDomainProgressStep{}
	a.GetStatus()
	a = nil
	a.GetStatus()
}

func TestAppDomainProgressStep_GetSteps(tt *testing.T) {
	a := &AppDomainProgressStep{}
	a.GetSteps()
	a = nil
	a.GetSteps()
}

func TestAppDomainProgressStepReason_GetCode(tt *testing.T) {
	a := &AppDomainProgressStepReason{}
	a.GetCode()
	a = nil
	a.GetCode()
}

func TestAppDomainProgressStepReason_GetMessage(tt *testing.T) {
	a := &AppDomainProgressStepReason{}
	a.GetMessage()
	a = nil
	a.GetMessage()
}

func TestAppDomainSpec_GetCertificate(tt *testing.T) {
	a := &AppDomainSpec{}
	a.GetCertificate()
	a = nil
	a.GetCertificate()
}

func TestAppDomainSpec_GetDomain(tt *testing.T) {
	a := &AppDomainSpec{}
	a.GetDomain()
	a = nil
	a.GetDomain()
}

func TestAppDomainSpec_GetMinimumTLSVersion(tt *testing.T) {
	a := &AppDomainSpec{}
	a.GetMinimumTLSVersion()
	a = nil
	a.GetMinimumTLSVersion()
}

func TestAppDomainSpec_GetType(tt *testing.T) {
	a := &AppDomainSpec{}
	a.GetType()
	a = nil
	a.GetType()
}

func TestAppDomainSpec_GetWildcard(tt *testing.T) {
	a := &AppDomainSpec{}
	a.GetWildcard()
	a = nil
	a.GetWildcard()
}

func TestAppDomainSpec_GetZone(tt *testing.T) {
	a := &AppDomainSpec{}
	a.GetZone()
	a = nil
	a.GetZone()
}

func TestAppDomainValidation_GetTXTName(tt *testing.T) {
	a := &AppDomainValidation{}
	a.GetTXTName()
	a = nil
	a.GetTXTName()
}

func TestAppDomainValidation_GetTXTValue(tt *testing.T) {
	a := &AppDomainValidation{}
	a.GetTXTValue()
	a = nil
	a.GetTXTValue()
}

func TestAppEgressSpec_GetType(tt *testing.T) {
	a := &AppEgressSpec{}
	a.GetType()
	a = nil
	a.GetType()
}

func TestAppFunctionsSpec_GetAlerts(tt *testing.T) {
	a := &AppFunctionsSpec{}
	a.GetAlerts()
	a = nil
	a.GetAlerts()
}

func TestAppFunctionsSpec_GetBitbucket(tt *testing.T) {
	a := &AppFunctionsSpec{}
	a.GetBitbucket()
	a = nil
	a.GetBitbucket()
}

func TestAppFunctionsSpec_GetCORS(tt *testing.T) {
	a := &AppFunctionsSpec{}
	a.GetCORS()
	a = nil
	a.GetCORS()
}

func TestAppFunctionsSpec_GetEnvs(tt *testing.T) {
	a := &AppFunctionsSpec{}
	a.GetEnvs()
	a = nil
	a.GetEnvs()
}

func TestAppFunctionsSpec_GetGit(tt *testing.T) {
	a := &AppFunctionsSpec{}
	a.GetGit()
	a = nil
	a.GetGit()
}

func TestAppFunctionsSpec_GetGitHub(tt *testing.T) {
	a := &AppFunctionsSpec{}
	a.GetGitHub()
	a = nil
	a.GetGitHub()
}

func TestAppFunctionsSpec_GetGitLab(tt *testing.T) {
	a := &AppFunctionsSpec{}
	a.GetGitLab()
	a = nil
	a.GetGitLab()
}

func TestAppFunctionsSpec_GetLogDestinations(tt *testing.T) {
	a := &AppFunctionsSpec{}
	a.GetLogDestinations()
	a = nil
	a.GetLogDestinations()
}

func TestAppFunctionsSpec_GetName(tt *testing.T) {
	a := &AppFunctionsSpec{}
	a.GetName()
	a = nil
	a.GetName()
}

func TestAppFunctionsSpec_GetRoutes(tt *testing.T) {
	a := &AppFunctionsSpec{}
	a.GetRoutes()
	a = nil
	a.GetRoutes()
}

func TestAppFunctionsSpec_GetSourceDir(tt *testing.T) {
	a := &AppFunctionsSpec{}
	a.GetSourceDir()
	a = nil
	a.GetSourceDir()
}

func TestAppIngressSpec_GetLoadBalancer(tt *testing.T) {
	a := &AppIngressSpec{}
	a.GetLoadBalancer()
	a = nil
	a.GetLoadBalancer()
}

func TestAppIngressSpec_GetLoadBalancerSize(tt *testing.T) {
	a := &AppIngressSpec{}
	a.GetLoadBalancerSize()
	a = nil
	a.GetLoadBalancerSize()
}

func TestAppIngressSpec_GetRules(tt *testing.T) {
	a := &AppIngressSpec{}
	a.GetRules()
	a = nil
	a.GetRules()
}

func TestAppIngressSpecRule_GetComponent(tt *testing.T) {
	a := &AppIngressSpecRule{}
	a.GetComponent()
	a = nil
	a.GetComponent()
}

func TestAppIngressSpecRule_GetCORS(tt *testing.T) {
	a := &AppIngressSpecRule{}
	a.GetCORS()
	a = nil
	a.GetCORS()
}

func TestAppIngressSpecRule_GetMatch(tt *testing.T) {
	a := &AppIngressSpecRule{}
	a.GetMatch()
	a = nil
	a.GetMatch()
}

func TestAppIngressSpecRule_GetRedirect(tt *testing.T) {
	a := &AppIngressSpecRule{}
	a.GetRedirect()
	a = nil
	a.GetRedirect()
}

func TestAppIngressSpecRuleMatch_GetPath(tt *testing.T) {
	a := &AppIngressSpecRuleMatch{}
	a.GetPath()
	a = nil
	a.GetPath()
}

func TestAppIngressSpecRuleRoutingComponent_GetName(tt *testing.T) {
	a := &AppIngressSpecRuleRoutingComponent{}
	a.GetName()
	a = nil
	a.GetName()
}

func TestAppIngressSpecRuleRoutingComponent_GetPreservePathPrefix(tt *testing.T) {
	a := &AppIngressSpecRuleRoutingComponent{}
	a.GetPreservePathPrefix()
	a = nil
	a.GetPreservePathPrefix()
}

func TestAppIngressSpecRuleRoutingComponent_GetRewrite(tt *testing.T) {
	a := &AppIngressSpecRuleRoutingComponent{}
	a.GetRewrite()
	a = nil
	a.GetRewrite()
}

func TestAppIngressSpecRuleRoutingRedirect_GetAuthority(tt *testing.T) {
	a := &AppIngressSpecRuleRoutingRedirect{}
	a.GetAuthority()
	a = nil
	a.GetAuthority()
}

func TestAppIngressSpecRuleRoutingRedirect_GetPort(tt *testing.T) {
	a := &AppIngressSpecRuleRoutingRedirect{}
	a.GetPort()
	a = nil
	a.GetPort()
}

func TestAppIngressSpecRuleRoutingRedirect_GetRedirectCode(tt *testing.T) {
	a := &AppIngressSpecRuleRoutingRedirect{}
	a.GetRedirectCode()
	a = nil
	a.GetRedirectCode()
}

func TestAppIngressSpecRuleRoutingRedirect_GetScheme(tt *testing.T) {
	a := &AppIngressSpecRuleRoutingRedirect{}
	a.GetScheme()
	a = nil
	a.GetScheme()
}

func TestAppIngressSpecRuleRoutingRedirect_GetUri(tt *testing.T) {
	a := &AppIngressSpecRuleRoutingRedirect{}
	a.GetUri()
	a = nil
	a.GetUri()
}

func TestAppIngressSpecRuleStringMatch_GetPrefix(tt *testing.T) {
	a := &AppIngressSpecRuleStringMatch{}
	a.GetPrefix()
	a = nil
	a.GetPrefix()
}

func TestAppInstanceSize_GetBandwidthAllowanceGib(tt *testing.T) {
	a := &AppInstanceSize{}
	a.GetBandwidthAllowanceGib()
	a = nil
	a.GetBandwidthAllowanceGib()
}

func TestAppInstanceSize_GetCPUs(tt *testing.T) {
	a := &AppInstanceSize{}
	a.GetCPUs()
	a = nil
	a.GetCPUs()
}

func TestAppInstanceSize_GetCPUType(tt *testing.T) {
	a := &AppInstanceSize{}
	a.GetCPUType()
	a = nil
	a.GetCPUType()
}

func TestAppInstanceSize_GetDeprecationIntent(tt *testing.T) {
	a := &AppInstanceSize{}
	a.GetDeprecationIntent()
	a = nil
	a.GetDeprecationIntent()
}

func TestAppInstanceSize_GetFeaturePreview(tt *testing.T) {
	a := &AppInstanceSize{}
	a.GetFeaturePreview()
	a = nil
	a.GetFeaturePreview()
}

func TestAppInstanceSize_GetMemoryBytes(tt *testing.T) {
	a := &AppInstanceSize{}
	a.GetMemoryBytes()
	a = nil
	a.GetMemoryBytes()
}

func TestAppInstanceSize_GetName(tt *testing.T) {
	a := &AppInstanceSize{}
	a.GetName()
	a = nil
	a.GetName()
}

func TestAppInstanceSize_GetScalable(tt *testing.T) {
	a := &AppInstanceSize{}
	a.GetScalable()
	a = nil
	a.GetScalable()
}

func TestAppInstanceSize_GetSingleInstanceOnly(tt *testing.T) {
	a := &AppInstanceSize{}
	a.GetSingleInstanceOnly()
	a = nil
	a.GetSingleInstanceOnly()
}

func TestAppInstanceSize_GetSlug(tt *testing.T) {
	a := &AppInstanceSize{}
	a.GetSlug()
	a = nil
	a.GetSlug()
}

func TestAppInstanceSize_GetTierDowngradeTo(tt *testing.T) {
	a := &AppInstanceSize{}
	a.GetTierDowngradeTo()
	a = nil
	a.GetTierDowngradeTo()
}

func TestAppInstanceSize_GetTierSlug(tt *testing.T) {
	a := &AppInstanceSize{}
	a.GetTierSlug()
	a = nil
	a.GetTierSlug()
}

func TestAppInstanceSize_GetTierUpgradeTo(tt *testing.T) {
	a := &AppInstanceSize{}
	a.GetTierUpgradeTo()
	a = nil
	a.GetTierUpgradeTo()
}

func TestAppInstanceSize_GetUSDPerMonth(tt *testing.T) {
	a := &AppInstanceSize{}
	a.GetUSDPerMonth()
	a = nil
	a.GetUSDPerMonth()
}

func TestAppInstanceSize_GetUSDPerSecond(tt *testing.T) {
	a := &AppInstanceSize{}
	a.GetUSDPerSecond()
	a = nil
	a.GetUSDPerSecond()
}

func TestAppJobSpec_GetAlerts(tt *testing.T) {
	a := &AppJobSpec{}
	a.GetAlerts()
	a = nil
	a.GetAlerts()
}

func TestAppJobSpec_GetBitbucket(tt *testing.T) {
	a := &AppJobSpec{}
	a.GetBitbucket()
	a = nil
	a.GetBitbucket()
}

func TestAppJobSpec_GetBuildCommand(tt *testing.T) {
	a := &AppJobSpec{}
	a.GetBuildCommand()
	a = nil
	a.GetBuildCommand()
}

func TestAppJobSpec_GetDockerfilePath(tt *testing.T) {
	a := &AppJobSpec{}
	a.GetDockerfilePath()
	a = nil
	a.GetDockerfilePath()
}

func TestAppJobSpec_GetEnvironmentSlug(tt *testing.T) {
	a := &AppJobSpec{}
	a.GetEnvironmentSlug()
	a = nil
	a.GetEnvironmentSlug()
}

func TestAppJobSpec_GetEnvs(tt *testing.T) {
	a := &AppJobSpec{}
	a.GetEnvs()
	a = nil
	a.GetEnvs()
}

func TestAppJobSpec_GetGit(tt *testing.T) {
	a := &AppJobSpec{}
	a.GetGit()
	a = nil
	a.GetGit()
}

func TestAppJobSpec_GetGitHub(tt *testing.T) {
	a := &AppJobSpec{}
	a.GetGitHub()
	a = nil
	a.GetGitHub()
}

func TestAppJobSpec_GetGitLab(tt *testing.T) {
	a := &AppJobSpec{}
	a.GetGitLab()
	a = nil
	a.GetGitLab()
}

func TestAppJobSpec_GetImage(tt *testing.T) {
	a := &AppJobSpec{}
	a.GetImage()
	a = nil
	a.GetImage()
}

func TestAppJobSpec_GetInstanceCount(tt *testing.T) {
	a := &AppJobSpec{}
	a.GetInstanceCount()
	a = nil
	a.GetInstanceCount()
}

func TestAppJobSpec_GetInstanceSizeSlug(tt *testing.T) {
	a := &AppJobSpec{}
	a.GetInstanceSizeSlug()
	a = nil
	a.GetInstanceSizeSlug()
}

func TestAppJobSpec_GetKind(tt *testing.T) {
	a := &AppJobSpec{}
	a.GetKind()
	a = nil
	a.GetKind()
}

func TestAppJobSpec_GetLogDestinations(tt *testing.T) {
	a := &AppJobSpec{}
	a.GetLogDestinations()
	a = nil
	a.GetLogDestinations()
}

func TestAppJobSpec_GetName(tt *testing.T) {
	a := &AppJobSpec{}
	a.GetName()
	a = nil
	a.GetName()
}

func TestAppJobSpec_GetRunCommand(tt *testing.T) {
	a := &AppJobSpec{}
	a.GetRunCommand()
	a = nil
	a.GetRunCommand()
}

func TestAppJobSpec_GetSourceDir(tt *testing.T) {
	a := &AppJobSpec{}
	a.GetSourceDir()
	a = nil
	a.GetSourceDir()
}

func TestAppJobSpec_GetTermination(tt *testing.T) {
	a := &AppJobSpec{}
	a.GetTermination()
	a = nil
	a.GetTermination()
}

func TestAppJobSpecTermination_GetGracePeriodSeconds(tt *testing.T) {
	a := &AppJobSpecTermination{}
	a.GetGracePeriodSeconds()
	a = nil
	a.GetGracePeriodSeconds()
}

func TestAppLogDestinationSpec_GetDatadog(tt *testing.T) {
	a := &AppLogDestinationSpec{}
	a.GetDatadog()
	a = nil
	a.GetDatadog()
}

func TestAppLogDestinationSpec_GetEndpoint(tt *testing.T) {
	a := &AppLogDestinationSpec{}
	a.GetEndpoint()
	a = nil
	a.GetEndpoint()
}

func TestAppLogDestinationSpec_GetHeaders(tt *testing.T) {
	a := &AppLogDestinationSpec{}
	a.GetHeaders()
	a = nil
	a.GetHeaders()
}

func TestAppLogDestinationSpec_GetLogtail(tt *testing.T) {
	a := &AppLogDestinationSpec{}
	a.GetLogtail()
	a = nil
	a.GetLogtail()
}

func TestAppLogDestinationSpec_GetName(tt *testing.T) {
	a := &AppLogDestinationSpec{}
	a.GetName()
	a = nil
	a.GetName()
}

func TestAppLogDestinationSpec_GetOpenSearch(tt *testing.T) {
	a := &AppLogDestinationSpec{}
	a.GetOpenSearch()
	a = nil
	a.GetOpenSearch()
}

func TestAppLogDestinationSpec_GetPapertrail(tt *testing.T) {
	a := &AppLogDestinationSpec{}
	a.GetPapertrail()
	a = nil
	a.GetPapertrail()
}

func TestAppLogDestinationSpec_GetTLSInsecure(tt *testing.T) {
	a := &AppLogDestinationSpec{}
	a.GetTLSInsecure()
	a = nil
	a.GetTLSInsecure()
}

func TestAppLogDestinationSpecDataDog_GetApiKey(tt *testing.T) {
	a := &AppLogDestinationSpecDataDog{}
	a.GetApiKey()
	a = nil
	a.GetApiKey()
}

func TestAppLogDestinationSpecDataDog_GetEndpoint(tt *testing.T) {
	a := &AppLogDestinationSpecDataDog{}
	a.GetEndpoint()
	a = nil
	a.GetEndpoint()
}

func TestAppLogDestinationSpecHeader_GetKey(tt *testing.T) {
	a := &AppLogDestinationSpecHeader{}
	a.GetKey()
	a = nil
	a.GetKey()
}

func TestAppLogDestinationSpecHeader_GetValue(tt *testing.T) {
	a := &AppLogDestinationSpecHeader{}
	a.GetValue()
	a = nil
	a.GetValue()
}

func TestAppLogDestinationSpecLogtail_GetToken(tt *testing.T) {
	a := &AppLogDestinationSpecLogtail{}
	a.GetToken()
	a = nil
	a.GetToken()
}

func TestAppLogDestinationSpecOpenSearch_GetBasicAuth(tt *testing.T) {
	a := &AppLogDestinationSpecOpenSearch{}
	a.GetBasicAuth()
	a = nil
	a.GetBasicAuth()
}

func TestAppLogDestinationSpecOpenSearch_GetClusterName(tt *testing.T) {
	a := &AppLogDestinationSpecOpenSearch{}
	a.GetClusterName()
	a = nil
	a.GetClusterName()
}

func TestAppLogDestinationSpecOpenSearch_GetEndpoint(tt *testing.T) {
	a := &AppLogDestinationSpecOpenSearch{}
	a.GetEndpoint()
	a = nil
	a.GetEndpoint()
}

func TestAppLogDestinationSpecOpenSearch_GetIndexName(tt *testing.T) {
	a := &AppLogDestinationSpecOpenSearch{}
	a.GetIndexName()
	a = nil
	a.GetIndexName()
}

func TestAppLogDestinationSpecPapertrail_GetEndpoint(tt *testing.T) {
	a := &AppLogDestinationSpecPapertrail{}
	a.GetEndpoint()
	a = nil
	a.GetEndpoint()
}

func TestAppMaintenanceSpec_GetArchive(tt *testing.T) {
	a := &AppMaintenanceSpec{}
	a.GetArchive()
	a = nil
	a.GetArchive()
}

func TestAppMaintenanceSpec_GetEnabled(tt *testing.T) {
	a := &AppMaintenanceSpec{}
	a.GetEnabled()
	a = nil
	a.GetEnabled()
}

func TestAppProposeRequest_GetAppID(tt *testing.T) {
	a := &AppProposeRequest{}
	a.GetAppID()
	a = nil
	a.GetAppID()
}

func TestAppProposeRequest_GetSpec(tt *testing.T) {
	a := &AppProposeRequest{}
	a.GetSpec()
	a = nil
	a.GetSpec()
}

func TestAppProposeResponse_GetAppCost(tt *testing.T) {
	a := &AppProposeResponse{}
	a.GetAppCost()
	a = nil
	a.GetAppCost()
}

func TestAppProposeResponse_GetAppIsStarter(tt *testing.T) {
	a := &AppProposeResponse{}
	a.GetAppIsStarter()
	a = nil
	a.GetAppIsStarter()
}

func TestAppProposeResponse_GetAppIsStatic(tt *testing.T) {
	a := &AppProposeResponse{}
	a.GetAppIsStatic()
	a = nil
	a.GetAppIsStatic()
}

func TestAppProposeResponse_GetAppNameAvailable(tt *testing.T) {
	a := &AppProposeResponse{}
	a.GetAppNameAvailable()
	a = nil
	a.GetAppNameAvailable()
}

func TestAppProposeResponse_GetAppNameSuggestion(tt *testing.T) {
	a := &AppProposeResponse{}
	a.GetAppNameSuggestion()
	a = nil
	a.GetAppNameSuggestion()
}

func TestAppProposeResponse_GetAppTierDowngradeCost(tt *testing.T) {
	a := &AppProposeResponse{}
	a.GetAppTierDowngradeCost()
	a = nil
	a.GetAppTierDowngradeCost()
}

func TestAppProposeResponse_GetAppTierUpgradeCost(tt *testing.T) {
	a := &AppProposeResponse{}
	a.GetAppTierUpgradeCost()
	a = nil
	a.GetAppTierUpgradeCost()
}

func TestAppProposeResponse_GetExistingStarterApps(tt *testing.T) {
	a := &AppProposeResponse{}
	a.GetExistingStarterApps()
	a = nil
	a.GetExistingStarterApps()
}

func TestAppProposeResponse_GetExistingStaticApps(tt *testing.T) {
	a := &AppProposeResponse{}
	a.GetExistingStaticApps()
	a = nil
	a.GetExistingStaticApps()
}

func TestAppProposeResponse_GetMaxFreeStarterApps(tt *testing.T) {
	a := &AppProposeResponse{}
	a.GetMaxFreeStarterApps()
	a = nil
	a.GetMaxFreeStarterApps()
}

func TestAppProposeResponse_GetMaxFreeStaticApps(tt *testing.T) {
	a := &AppProposeResponse{}
	a.GetMaxFreeStaticApps()
	a = nil
	a.GetMaxFreeStaticApps()
}

func TestAppProposeResponse_GetSpec(tt *testing.T) {
	a := &AppProposeResponse{}
	a.GetSpec()
	a = nil
	a.GetSpec()
}

func TestAppRegion_GetContinent(tt *testing.T) {
	a := &AppRegion{}
	a.GetContinent()
	a = nil
	a.GetContinent()
}

func TestAppRegion_GetDataCenters(tt *testing.T) {
	a := &AppRegion{}
	a.GetDataCenters()
	a = nil
	a.GetDataCenters()
}

func TestAppRegion_GetDefault(tt *testing.T) {
	a := &AppRegion{}
	a.GetDefault()
	a = nil
	a.GetDefault()
}

func TestAppRegion_GetDisabled(tt *testing.T) {
	a := &AppRegion{}
	a.GetDisabled()
	a = nil
	a.GetDisabled()
}

func TestAppRegion_GetFlag(tt *testing.T) {
	a := &AppRegion{}
	a.GetFlag()
	a = nil
	a.GetFlag()
}

func TestAppRegion_GetLabel(tt *testing.T) {
	a := &AppRegion{}
	a.GetLabel()
	a = nil
	a.GetLabel()
}

func TestAppRegion_GetReason(tt *testing.T) {
	a := &AppRegion{}
	a.GetReason()
	a = nil
	a.GetReason()
}

func TestAppRegion_GetSlug(tt *testing.T) {
	a := &AppRegion{}
	a.GetSlug()
	a = nil
	a.GetSlug()
}

func TestAppRouteSpec_GetPath(tt *testing.T) {
	a := &AppRouteSpec{}
	a.GetPath()
	a = nil
	a.GetPath()
}

func TestAppRouteSpec_GetPreservePathPrefix(tt *testing.T) {
	a := &AppRouteSpec{}
	a.GetPreservePathPrefix()
	a = nil
	a.GetPreservePathPrefix()
}

func TestAppServiceSpec_GetAlerts(tt *testing.T) {
	a := &AppServiceSpec{}
	a.GetAlerts()
	a = nil
	a.GetAlerts()
}

func TestAppServiceSpec_GetAutoscaling(tt *testing.T) {
	a := &AppServiceSpec{}
	a.GetAutoscaling()
	a = nil
	a.GetAutoscaling()
}

func TestAppServiceSpec_GetBitbucket(tt *testing.T) {
	a := &AppServiceSpec{}
	a.GetBitbucket()
	a = nil
	a.GetBitbucket()
}

func TestAppServiceSpec_GetBuildCommand(tt *testing.T) {
	a := &AppServiceSpec{}
	a.GetBuildCommand()
	a = nil
	a.GetBuildCommand()
}

func TestAppServiceSpec_GetCORS(tt *testing.T) {
	a := &AppServiceSpec{}
	a.GetCORS()
	a = nil
	a.GetCORS()
}

func TestAppServiceSpec_GetDockerfilePath(tt *testing.T) {
	a := &AppServiceSpec{}
	a.GetDockerfilePath()
	a = nil
	a.GetDockerfilePath()
}

func TestAppServiceSpec_GetEnvironmentSlug(tt *testing.T) {
	a := &AppServiceSpec{}
	a.GetEnvironmentSlug()
	a = nil
	a.GetEnvironmentSlug()
}

func TestAppServiceSpec_GetEnvs(tt *testing.T) {
	a := &AppServiceSpec{}
	a.GetEnvs()
	a = nil
	a.GetEnvs()
}

func TestAppServiceSpec_GetGit(tt *testing.T) {
	a := &AppServiceSpec{}
	a.GetGit()
	a = nil
	a.GetGit()
}

func TestAppServiceSpec_GetGitHub(tt *testing.T) {
	a := &AppServiceSpec{}
	a.GetGitHub()
	a = nil
	a.GetGitHub()
}

func TestAppServiceSpec_GetGitLab(tt *testing.T) {
	a := &AppServiceSpec{}
	a.GetGitLab()
	a = nil
	a.GetGitLab()
}

func TestAppServiceSpec_GetHealthCheck(tt *testing.T) {
	a := &AppServiceSpec{}
	a.GetHealthCheck()
	a = nil
	a.GetHealthCheck()
}

func TestAppServiceSpec_GetHTTPPort(tt *testing.T) {
	a := &AppServiceSpec{}
	a.GetHTTPPort()
	a = nil
	a.GetHTTPPort()
}

func TestAppServiceSpec_GetImage(tt *testing.T) {
	a := &AppServiceSpec{}
	a.GetImage()
	a = nil
	a.GetImage()
}

func TestAppServiceSpec_GetInstanceCount(tt *testing.T) {
	a := &AppServiceSpec{}
	a.GetInstanceCount()
	a = nil
	a.GetInstanceCount()
}

func TestAppServiceSpec_GetInstanceSizeSlug(tt *testing.T) {
	a := &AppServiceSpec{}
	a.GetInstanceSizeSlug()
	a = nil
	a.GetInstanceSizeSlug()
}

func TestAppServiceSpec_GetInternalPorts(tt *testing.T) {
	a := &AppServiceSpec{}
	a.GetInternalPorts()
	a = nil
	a.GetInternalPorts()
}

func TestAppServiceSpec_GetLogDestinations(tt *testing.T) {
	a := &AppServiceSpec{}
	a.GetLogDestinations()
	a = nil
	a.GetLogDestinations()
}

func TestAppServiceSpec_GetName(tt *testing.T) {
	a := &AppServiceSpec{}
	a.GetName()
	a = nil
	a.GetName()
}

func TestAppServiceSpec_GetProtocol(tt *testing.T) {
	a := &AppServiceSpec{}
	a.GetProtocol()
	a = nil
	a.GetProtocol()
}

func TestAppServiceSpec_GetRoutes(tt *testing.T) {
	a := &AppServiceSpec{}
	a.GetRoutes()
	a = nil
	a.GetRoutes()
}

func TestAppServiceSpec_GetRunCommand(tt *testing.T) {
	a := &AppServiceSpec{}
	a.GetRunCommand()
	a = nil
	a.GetRunCommand()
}

func TestAppServiceSpec_GetSourceDir(tt *testing.T) {
	a := &AppServiceSpec{}
	a.GetSourceDir()
	a = nil
	a.GetSourceDir()
}

func TestAppServiceSpec_GetTermination(tt *testing.T) {
	a := &AppServiceSpec{}
	a.GetTermination()
	a = nil
	a.GetTermination()
}

func TestAppServiceSpecHealthCheck_GetFailureThreshold(tt *testing.T) {
	a := &AppServiceSpecHealthCheck{}
	a.GetFailureThreshold()
	a = nil
	a.GetFailureThreshold()
}

func TestAppServiceSpecHealthCheck_GetHTTPPath(tt *testing.T) {
	a := &AppServiceSpecHealthCheck{}
	a.GetHTTPPath()
	a = nil
	a.GetHTTPPath()
}

func TestAppServiceSpecHealthCheck_GetInitialDelaySeconds(tt *testing.T) {
	a := &AppServiceSpecHealthCheck{}
	a.GetInitialDelaySeconds()
	a = nil
	a.GetInitialDelaySeconds()
}

func TestAppServiceSpecHealthCheck_GetPath(tt *testing.T) {
	a := &AppServiceSpecHealthCheck{}
	a.GetPath()
	a = nil
	a.GetPath()
}

func TestAppServiceSpecHealthCheck_GetPeriodSeconds(tt *testing.T) {
	a := &AppServiceSpecHealthCheck{}
	a.GetPeriodSeconds()
	a = nil
	a.GetPeriodSeconds()
}

func TestAppServiceSpecHealthCheck_GetPort(tt *testing.T) {
	a := &AppServiceSpecHealthCheck{}
	a.GetPort()
	a = nil
	a.GetPort()
}

func TestAppServiceSpecHealthCheck_GetSuccessThreshold(tt *testing.T) {
	a := &AppServiceSpecHealthCheck{}
	a.GetSuccessThreshold()
	a = nil
	a.GetSuccessThreshold()
}

func TestAppServiceSpecHealthCheck_GetTimeoutSeconds(tt *testing.T) {
	a := &AppServiceSpecHealthCheck{}
	a.GetTimeoutSeconds()
	a = nil
	a.GetTimeoutSeconds()
}

func TestAppServiceSpecTermination_GetDrainSeconds(tt *testing.T) {
	a := &AppServiceSpecTermination{}
	a.GetDrainSeconds()
	a = nil
	a.GetDrainSeconds()
}

func TestAppServiceSpecTermination_GetGracePeriodSeconds(tt *testing.T) {
	a := &AppServiceSpecTermination{}
	a.GetGracePeriodSeconds()
	a = nil
	a.GetGracePeriodSeconds()
}

func TestAppSpec_GetAlerts(tt *testing.T) {
	a := &AppSpec{}
	a.GetAlerts()
	a = nil
	a.GetAlerts()
}

func TestAppSpec_GetDatabases(tt *testing.T) {
	a := &AppSpec{}
	a.GetDatabases()
	a = nil
	a.GetDatabases()
}

func TestAppSpec_GetDomains(tt *testing.T) {
	a := &AppSpec{}
	a.GetDomains()
	a = nil
	a.GetDomains()
}

func TestAppSpec_GetEgress(tt *testing.T) {
	a := &AppSpec{}
	a.GetEgress()
	a = nil
	a.GetEgress()
}

func TestAppSpec_GetEnvs(tt *testing.T) {
	a := &AppSpec{}
	a.GetEnvs()
	a = nil
	a.GetEnvs()
}

func TestAppSpec_GetFeatures(tt *testing.T) {
	a := &AppSpec{}
	a.GetFeatures()
	a = nil
	a.GetFeatures()
}

func TestAppSpec_GetFunctions(tt *testing.T) {
	a := &AppSpec{}
	a.GetFunctions()
	a = nil
	a.GetFunctions()
}

func TestAppSpec_GetIngress(tt *testing.T) {
	a := &AppSpec{}
	a.GetIngress()
	a = nil
	a.GetIngress()
}

func TestAppSpec_GetJobs(tt *testing.T) {
	a := &AppSpec{}
	a.GetJobs()
	a = nil
	a.GetJobs()
}

func TestAppSpec_GetMaintenance(tt *testing.T) {
	a := &AppSpec{}
	a.GetMaintenance()
	a = nil
	a.GetMaintenance()
}

func TestAppSpec_GetName(tt *testing.T) {
	a := &AppSpec{}
	a.GetName()
	a = nil
	a.GetName()
}

func TestAppSpec_GetRegion(tt *testing.T) {
	a := &AppSpec{}
	a.GetRegion()
	a = nil
	a.GetRegion()
}

func TestAppSpec_GetServices(tt *testing.T) {
	a := &AppSpec{}
	a.GetServices()
	a = nil
	a.GetServices()
}

func TestAppSpec_GetStaticSites(tt *testing.T) {
	a := &AppSpec{}
	a.GetStaticSites()
	a = nil
	a.GetStaticSites()
}

func TestAppSpec_GetWorkers(tt *testing.T) {
	a := &AppSpec{}
	a.GetWorkers()
	a = nil
	a.GetWorkers()
}

func TestAppStaticSiteSpec_GetBitbucket(tt *testing.T) {
	a := &AppStaticSiteSpec{}
	a.GetBitbucket()
	a = nil
	a.GetBitbucket()
}

func TestAppStaticSiteSpec_GetBuildCommand(tt *testing.T) {
	a := &AppStaticSiteSpec{}
	a.GetBuildCommand()
	a = nil
	a.GetBuildCommand()
}

func TestAppStaticSiteSpec_GetCatchallDocument(tt *testing.T) {
	a := &AppStaticSiteSpec{}
	a.GetCatchallDocument()
	a = nil
	a.GetCatchallDocument()
}

func TestAppStaticSiteSpec_GetCORS(tt *testing.T) {
	a := &AppStaticSiteSpec{}
	a.GetCORS()
	a = nil
	a.GetCORS()
}

func TestAppStaticSiteSpec_GetDockerfilePath(tt *testing.T) {
	a := &AppStaticSiteSpec{}
	a.GetDockerfilePath()
	a = nil
	a.GetDockerfilePath()
}

func TestAppStaticSiteSpec_GetEnvironmentSlug(tt *testing.T) {
	a := &AppStaticSiteSpec{}
	a.GetEnvironmentSlug()
	a = nil
	a.GetEnvironmentSlug()
}

func TestAppStaticSiteSpec_GetEnvs(tt *testing.T) {
	a := &AppStaticSiteSpec{}
	a.GetEnvs()
	a = nil
	a.GetEnvs()
}

func TestAppStaticSiteSpec_GetErrorDocument(tt *testing.T) {
	a := &AppStaticSiteSpec{}
	a.GetErrorDocument()
	a = nil
	a.GetErrorDocument()
}

func TestAppStaticSiteSpec_GetGit(tt *testing.T) {
	a := &AppStaticSiteSpec{}
	a.GetGit()
	a = nil
	a.GetGit()
}

func TestAppStaticSiteSpec_GetGitHub(tt *testing.T) {
	a := &AppStaticSiteSpec{}
	a.GetGitHub()
	a = nil
	a.GetGitHub()
}

func TestAppStaticSiteSpec_GetGitLab(tt *testing.T) {
	a := &AppStaticSiteSpec{}
	a.GetGitLab()
	a = nil
	a.GetGitLab()
}

func TestAppStaticSiteSpec_GetIndexDocument(tt *testing.T) {
	a := &AppStaticSiteSpec{}
	a.GetIndexDocument()
	a = nil
	a.GetIndexDocument()
}

func TestAppStaticSiteSpec_GetName(tt *testing.T) {
	a := &AppStaticSiteSpec{}
	a.GetName()
	a = nil
	a.GetName()
}

func TestAppStaticSiteSpec_GetOutputDir(tt *testing.T) {
	a := &AppStaticSiteSpec{}
	a.GetOutputDir()
	a = nil
	a.GetOutputDir()
}

func TestAppStaticSiteSpec_GetRoutes(tt *testing.T) {
	a := &AppStaticSiteSpec{}
	a.GetRoutes()
	a = nil
	a.GetRoutes()
}

func TestAppStaticSiteSpec_GetSourceDir(tt *testing.T) {
	a := &AppStaticSiteSpec{}
	a.GetSourceDir()
	a = nil
	a.GetSourceDir()
}

func TestAppStringMatch_GetExact(tt *testing.T) {
	a := &AppStringMatch{}
	a.GetExact()
	a = nil
	a.GetExact()
}

func TestAppStringMatch_GetPrefix(tt *testing.T) {
	a := &AppStringMatch{}
	a.GetPrefix()
	a = nil
	a.GetPrefix()
}

func TestAppStringMatch_GetRegex(tt *testing.T) {
	a := &AppStringMatch{}
	a.GetRegex()
	a = nil
	a.GetRegex()
}

func TestAppTier_GetBuildSeconds(tt *testing.T) {
	a := &AppTier{}
	a.GetBuildSeconds()
	a = nil
	a.GetBuildSeconds()
}

func TestAppTier_GetEgressBandwidthBytes(tt *testing.T) {
	a := &AppTier{}
	a.GetEgressBandwidthBytes()
	a = nil
	a.GetEgressBandwidthBytes()
}

func TestAppTier_GetName(tt *testing.T) {
	a := &AppTier{}
	a.GetName()
	a = nil
	a.GetName()
}

func TestAppTier_GetSlug(tt *testing.T) {
	a := &AppTier{}
	a.GetSlug()
	a = nil
	a.GetSlug()
}

func TestAppVariableDefinition_GetKey(tt *testing.T) {
	a := &AppVariableDefinition{}
	a.GetKey()
	a = nil
	a.GetKey()
}

func TestAppVariableDefinition_GetScope(tt *testing.T) {
	a := &AppVariableDefinition{}
	a.GetScope()
	a = nil
	a.GetScope()
}

func TestAppVariableDefinition_GetType(tt *testing.T) {
	a := &AppVariableDefinition{}
	a.GetType()
	a = nil
	a.GetType()
}

func TestAppVariableDefinition_GetValue(tt *testing.T) {
	a := &AppVariableDefinition{}
	a.GetValue()
	a = nil
	a.GetValue()
}

func TestAppWorkerSpec_GetAlerts(tt *testing.T) {
	a := &AppWorkerSpec{}
	a.GetAlerts()
	a = nil
	a.GetAlerts()
}

func TestAppWorkerSpec_GetAutoscaling(tt *testing.T) {
	a := &AppWorkerSpec{}
	a.GetAutoscaling()
	a = nil
	a.GetAutoscaling()
}

func TestAppWorkerSpec_GetBitbucket(tt *testing.T) {
	a := &AppWorkerSpec{}
	a.GetBitbucket()
	a = nil
	a.GetBitbucket()
}

func TestAppWorkerSpec_GetBuildCommand(tt *testing.T) {
	a := &AppWorkerSpec{}
	a.GetBuildCommand()
	a = nil
	a.GetBuildCommand()
}

func TestAppWorkerSpec_GetDockerfilePath(tt *testing.T) {
	a := &AppWorkerSpec{}
	a.GetDockerfilePath()
	a = nil
	a.GetDockerfilePath()
}

func TestAppWorkerSpec_GetEnvironmentSlug(tt *testing.T) {
	a := &AppWorkerSpec{}
	a.GetEnvironmentSlug()
	a = nil
	a.GetEnvironmentSlug()
}

func TestAppWorkerSpec_GetEnvs(tt *testing.T) {
	a := &AppWorkerSpec{}
	a.GetEnvs()
	a = nil
	a.GetEnvs()
}

func TestAppWorkerSpec_GetGit(tt *testing.T) {
	a := &AppWorkerSpec{}
	a.GetGit()
	a = nil
	a.GetGit()
}

func TestAppWorkerSpec_GetGitHub(tt *testing.T) {
	a := &AppWorkerSpec{}
	a.GetGitHub()
	a = nil
	a.GetGitHub()
}

func TestAppWorkerSpec_GetGitLab(tt *testing.T) {
	a := &AppWorkerSpec{}
	a.GetGitLab()
	a = nil
	a.GetGitLab()
}

func TestAppWorkerSpec_GetImage(tt *testing.T) {
	a := &AppWorkerSpec{}
	a.GetImage()
	a = nil
	a.GetImage()
}

func TestAppWorkerSpec_GetInstanceCount(tt *testing.T) {
	a := &AppWorkerSpec{}
	a.GetInstanceCount()
	a = nil
	a.GetInstanceCount()
}

func TestAppWorkerSpec_GetInstanceSizeSlug(tt *testing.T) {
	a := &AppWorkerSpec{}
	a.GetInstanceSizeSlug()
	a = nil
	a.GetInstanceSizeSlug()
}

func TestAppWorkerSpec_GetLogDestinations(tt *testing.T) {
	a := &AppWorkerSpec{}
	a.GetLogDestinations()
	a = nil
	a.GetLogDestinations()
}

func TestAppWorkerSpec_GetName(tt *testing.T) {
	a := &AppWorkerSpec{}
	a.GetName()
	a = nil
	a.GetName()
}

func TestAppWorkerSpec_GetRunCommand(tt *testing.T) {
	a := &AppWorkerSpec{}
	a.GetRunCommand()
	a = nil
	a.GetRunCommand()
}

func TestAppWorkerSpec_GetSourceDir(tt *testing.T) {
	a := &AppWorkerSpec{}
	a.GetSourceDir()
	a = nil
	a.GetSourceDir()
}

func TestAppWorkerSpec_GetTermination(tt *testing.T) {
	a := &AppWorkerSpec{}
	a.GetTermination()
	a = nil
	a.GetTermination()
}

func TestAppWorkerSpecTermination_GetGracePeriodSeconds(tt *testing.T) {
	a := &AppWorkerSpecTermination{}
	a.GetGracePeriodSeconds()
	a = nil
	a.GetGracePeriodSeconds()
}

func TestBitbucketSourceSpec_GetBranch(tt *testing.T) {
	b := &BitbucketSourceSpec{}
	b.GetBranch()
	b = nil
	b.GetBranch()
}

func TestBitbucketSourceSpec_GetDeployOnPush(tt *testing.T) {
	b := &BitbucketSourceSpec{}
	b.GetDeployOnPush()
	b = nil
	b.GetDeployOnPush()
}

func TestBitbucketSourceSpec_GetRepo(tt *testing.T) {
	b := &BitbucketSourceSpec{}
	b.GetRepo()
	b = nil
	b.GetRepo()
}

func TestBuildpack_GetDescription(tt *testing.T) {
	b := &Buildpack{}
	b.GetDescription()
	b = nil
	b.GetDescription()
}

func TestBuildpack_GetDocsLink(tt *testing.T) {
	b := &Buildpack{}
	b.GetDocsLink()
	b = nil
	b.GetDocsLink()
}

func TestBuildpack_GetID(tt *testing.T) {
	b := &Buildpack{}
	b.GetID()
	b = nil
	b.GetID()
}

func TestBuildpack_GetLatest(tt *testing.T) {
	b := &Buildpack{}
	b.GetLatest()
	b = nil
	b.GetLatest()
}

func TestBuildpack_GetMajorVersion(tt *testing.T) {
	b := &Buildpack{}
	b.GetMajorVersion()
	b = nil
	b.GetMajorVersion()
}

func TestBuildpack_GetName(tt *testing.T) {
	b := &Buildpack{}
	b.GetName()
	b = nil
	b.GetName()
}

func TestBuildpack_GetVersion(tt *testing.T) {
	b := &Buildpack{}
	b.GetVersion()
	b = nil
	b.GetVersion()
}

func TestDeployment_GetCause(tt *testing.T) {
	d := &Deployment{}
	d.GetCause()
	d = nil
	d.GetCause()
}

func TestDeployment_GetCauseDetails(tt *testing.T) {
	d := &Deployment{}
	d.GetCauseDetails()
	d = nil
	d.GetCauseDetails()
}

func TestDeployment_GetClonedFrom(tt *testing.T) {
	d := &Deployment{}
	d.GetClonedFrom()
	d = nil
	d.GetClonedFrom()
}

func TestDeployment_GetCreatedAt(tt *testing.T) {
	d := &Deployment{}
	d.GetCreatedAt()
	d = nil
	d.GetCreatedAt()
}

func TestDeployment_GetFunctions(tt *testing.T) {
	d := &Deployment{}
	d.GetFunctions()
	d = nil
	d.GetFunctions()
}

func TestDeployment_GetID(tt *testing.T) {
	d := &Deployment{}
	d.GetID()
	d = nil
	d.GetID()
}

func TestDeployment_GetJobs(tt *testing.T) {
	d := &Deployment{}
	d.GetJobs()
	d = nil
	d.GetJobs()
}

func TestDeployment_GetLoadBalancerID(tt *testing.T) {
	d := &Deployment{}
	d.GetLoadBalancerID()
	d = nil
	d.GetLoadBalancerID()
}

func TestDeployment_GetPhase(tt *testing.T) {
	d := &Deployment{}
	d.GetPhase()
	d = nil
	d.GetPhase()
}

func TestDeployment_GetPhaseLastUpdatedAt(tt *testing.T) {
	d := &Deployment{}
	d.GetPhaseLastUpdatedAt()
	d = nil
	d.GetPhaseLastUpdatedAt()
}

func TestDeployment_GetPreviousDeploymentID(tt *testing.T) {
	d := &Deployment{}
	d.GetPreviousDeploymentID()
	d = nil
	d.GetPreviousDeploymentID()
}

func TestDeployment_GetProgress(tt *testing.T) {
	d := &Deployment{}
	d.GetProgress()
	d = nil
	d.GetProgress()
}

func TestDeployment_GetServices(tt *testing.T) {
	d := &Deployment{}
	d.GetServices()
	d = nil
	d.GetServices()
}

func TestDeployment_GetSpec(tt *testing.T) {
	d := &Deployment{}
	d.GetSpec()
	d = nil
	d.GetSpec()
}

func TestDeployment_GetStaticSites(tt *testing.T) {
	d := &Deployment{}
	d.GetStaticSites()
	d = nil
	d.GetStaticSites()
}

func TestDeployment_GetTierSlug(tt *testing.T) {
	d := &Deployment{}
	d.GetTierSlug()
	d = nil
	d.GetTierSlug()
}

func TestDeployment_GetTiming(tt *testing.T) {
	d := &Deployment{}
	d.GetTiming()
	d = nil
	d.GetTiming()
}

func TestDeployment_GetUpdatedAt(tt *testing.T) {
	d := &Deployment{}
	d.GetUpdatedAt()
	d = nil
	d.GetUpdatedAt()
}

func TestDeployment_GetWorkers(tt *testing.T) {
	d := &Deployment{}
	d.GetWorkers()
	d = nil
	d.GetWorkers()
}

func TestDeploymentCauseDetails_GetAutoscaler(tt *testing.T) {
	d := &DeploymentCauseDetails{}
	d.GetAutoscaler()
	d = nil
	d.GetAutoscaler()
}

func TestDeploymentCauseDetails_GetDigitalOceanUserAction(tt *testing.T) {
	d := &DeploymentCauseDetails{}
	d.GetDigitalOceanUserAction()
	d = nil
	d.GetDigitalOceanUserAction()
}

func TestDeploymentCauseDetails_GetDOCRPush(tt *testing.T) {
	d := &DeploymentCauseDetails{}
	d.GetDOCRPush()
	d = nil
	d.GetDOCRPush()
}

func TestDeploymentCauseDetails_GetGitPush(tt *testing.T) {
	d := &DeploymentCauseDetails{}
	d.GetGitPush()
	d = nil
	d.GetGitPush()
}

func TestDeploymentCauseDetails_GetInternal(tt *testing.T) {
	d := &DeploymentCauseDetails{}
	d.GetInternal()
	d = nil
	d.GetInternal()
}

func TestDeploymentCauseDetails_GetType(tt *testing.T) {
	d := &DeploymentCauseDetails{}
	d.GetType()
	d = nil
	d.GetType()
}

func TestDeploymentCauseDetailsAutoscalerAction_GetAutoscaled(tt *testing.T) {
	d := &DeploymentCauseDetailsAutoscalerAction{}
	d.GetAutoscaled()
	d = nil
	d.GetAutoscaled()
}

func TestDeploymentCauseDetailsDigitalOceanUser_GetEmail(tt *testing.T) {
	d := &DeploymentCauseDetailsDigitalOceanUser{}
	d.GetEmail()
	d = nil
	d.GetEmail()
}

func TestDeploymentCauseDetailsDigitalOceanUser_GetFullName(tt *testing.T) {
	d := &DeploymentCauseDetailsDigitalOceanUser{}
	d.GetFullName()
	d = nil
	d.GetFullName()
}

func TestDeploymentCauseDetailsDigitalOceanUser_GetUUID(tt *testing.T) {
	d := &DeploymentCauseDetailsDigitalOceanUser{}
	d.GetUUID()
	d = nil
	d.GetUUID()
}

func TestDeploymentCauseDetailsDigitalOceanUserAction_GetName(tt *testing.T) {
	d := &DeploymentCauseDetailsDigitalOceanUserAction{}
	d.GetName()
	d = nil
	d.GetName()
}

func TestDeploymentCauseDetailsDigitalOceanUserAction_GetUser(tt *testing.T) {
	d := &DeploymentCauseDetailsDigitalOceanUserAction{}
	d.GetUser()
	d = nil
	d.GetUser()
}

func TestDeploymentCauseDetailsDOCRPush_GetImageDigest(tt *testing.T) {
	d := &DeploymentCauseDetailsDOCRPush{}
	d.GetImageDigest()
	d = nil
	d.GetImageDigest()
}

func TestDeploymentCauseDetailsDOCRPush_GetRegistry(tt *testing.T) {
	d := &DeploymentCauseDetailsDOCRPush{}
	d.GetRegistry()
	d = nil
	d.GetRegistry()
}

func TestDeploymentCauseDetailsDOCRPush_GetRepository(tt *testing.T) {
	d := &DeploymentCauseDetailsDOCRPush{}
	d.GetRepository()
	d = nil
	d.GetRepository()
}

func TestDeploymentCauseDetailsDOCRPush_GetTag(tt *testing.T) {
	d := &DeploymentCauseDetailsDOCRPush{}
	d.GetTag()
	d = nil
	d.GetTag()
}

func TestDeploymentCauseDetailsGitPush_GetBitbucket(tt *testing.T) {
	d := &DeploymentCauseDetailsGitPush{}
	d.GetBitbucket()
	d = nil
	d.GetBitbucket()
}

func TestDeploymentCauseDetailsGitPush_GetCommitAuthor(tt *testing.T) {
	d := &DeploymentCauseDetailsGitPush{}
	d.GetCommitAuthor()
	d = nil
	d.GetCommitAuthor()
}

func TestDeploymentCauseDetailsGitPush_GetCommitMessage(tt *testing.T) {
	d := &DeploymentCauseDetailsGitPush{}
	d.GetCommitMessage()
	d = nil
	d.GetCommitMessage()
}

func TestDeploymentCauseDetailsGitPush_GetCommitSHA(tt *testing.T) {
	d := &DeploymentCauseDetailsGitPush{}
	d.GetCommitSHA()
	d = nil
	d.GetCommitSHA()
}

func TestDeploymentCauseDetailsGitPush_GetGitHub(tt *testing.T) {
	d := &DeploymentCauseDetailsGitPush{}
	d.GetGitHub()
	d = nil
	d.GetGitHub()
}

func TestDeploymentCauseDetailsGitPush_GetGitLab(tt *testing.T) {
	d := &DeploymentCauseDetailsGitPush{}
	d.GetGitLab()
	d = nil
	d.GetGitLab()
}

func TestDeploymentCauseDetailsGitPush_GetUsername(tt *testing.T) {
	d := &DeploymentCauseDetailsGitPush{}
	d.GetUsername()
	d = nil
	d.GetUsername()
}

func TestDeploymentFunctions_GetName(tt *testing.T) {
	d := &DeploymentFunctions{}
	d.GetName()
	d = nil
	d.GetName()
}

func TestDeploymentFunctions_GetNamespace(tt *testing.T) {
	d := &DeploymentFunctions{}
	d.GetNamespace()
	d = nil
	d.GetNamespace()
}

func TestDeploymentFunctions_GetSourceCommitHash(tt *testing.T) {
	d := &DeploymentFunctions{}
	d.GetSourceCommitHash()
	d = nil
	d.GetSourceCommitHash()
}

func TestDeploymentJob_GetBuildpacks(tt *testing.T) {
	d := &DeploymentJob{}
	d.GetBuildpacks()
	d = nil
	d.GetBuildpacks()
}

func TestDeploymentJob_GetName(tt *testing.T) {
	d := &DeploymentJob{}
	d.GetName()
	d = nil
	d.GetName()
}

func TestDeploymentJob_GetSourceCommitHash(tt *testing.T) {
	d := &DeploymentJob{}
	d.GetSourceCommitHash()
	d = nil
	d.GetSourceCommitHash()
}

func TestDeploymentProgress_GetErrorSteps(tt *testing.T) {
	d := &DeploymentProgress{}
	d.GetErrorSteps()
	d = nil
	d.GetErrorSteps()
}

func TestDeploymentProgress_GetPendingSteps(tt *testing.T) {
	d := &DeploymentProgress{}
	d.GetPendingSteps()
	d = nil
	d.GetPendingSteps()
}

func TestDeploymentProgress_GetRunningSteps(tt *testing.T) {
	d := &DeploymentProgress{}
	d.GetRunningSteps()
	d = nil
	d.GetRunningSteps()
}

func TestDeploymentProgress_GetSteps(tt *testing.T) {
	d := &DeploymentProgress{}
	d.GetSteps()
	d = nil
	d.GetSteps()
}

func TestDeploymentProgress_GetSuccessSteps(tt *testing.T) {
	d := &DeploymentProgress{}
	d.GetSuccessSteps()
	d = nil
	d.GetSuccessSteps()
}

func TestDeploymentProgress_GetSummarySteps(tt *testing.T) {
	d := &DeploymentProgress{}
	d.GetSummarySteps()
	d = nil
	d.GetSummarySteps()
}

func TestDeploymentProgress_GetTotalSteps(tt *testing.T) {
	d := &DeploymentProgress{}
	d.GetTotalSteps()
	d = nil
	d.GetTotalSteps()
}

func TestDeploymentProgressStep_GetComponentName(tt *testing.T) {
	d := &DeploymentProgressStep{}
	d.GetComponentName()
	d = nil
	d.GetComponentName()
}

func TestDeploymentProgressStep_GetEndedAt(tt *testing.T) {
	d := &DeploymentProgressStep{}
	d.GetEndedAt()
	d = nil
	d.GetEndedAt()
}

func TestDeploymentProgressStep_GetMessageBase(tt *testing.T) {
	d := &DeploymentProgressStep{}
	d.GetMessageBase()
	d = nil
	d.GetMessageBase()
}

func TestDeploymentProgressStep_GetName(tt *testing.T) {
	d := &DeploymentProgressStep{}
	d.GetName()
	d = nil
	d.GetName()
}

func TestDeploymentProgressStep_GetReason(tt *testing.T) {
	d := &DeploymentProgressStep{}
	d.GetReason()
	d = nil
	d.GetReason()
}

func TestDeploymentProgressStep_GetStartedAt(tt *testing.T) {
	d := &DeploymentProgressStep{}
	d.GetStartedAt()
	d = nil
	d.GetStartedAt()
}

func TestDeploymentProgressStep_GetStatus(tt *testing.T) {
	d := &DeploymentProgressStep{}
	d.GetStatus()
	d = nil
	d.GetStatus()
}

func TestDeploymentProgressStep_GetSteps(tt *testing.T) {
	d := &DeploymentProgressStep{}
	d.GetSteps()
	d = nil
	d.GetSteps()
}

func TestDeploymentProgressStepReason_GetCode(tt *testing.T) {
	d := &DeploymentProgressStepReason{}
	d.GetCode()
	d = nil
	d.GetCode()
}

func TestDeploymentProgressStepReason_GetMessage(tt *testing.T) {
	d := &DeploymentProgressStepReason{}
	d.GetMessage()
	d = nil
	d.GetMessage()
}

func TestDeploymentService_GetBuildpacks(tt *testing.T) {
	d := &DeploymentService{}
	d.GetBuildpacks()
	d = nil
	d.GetBuildpacks()
}

func TestDeploymentService_GetName(tt *testing.T) {
	d := &DeploymentService{}
	d.GetName()
	d = nil
	d.GetName()
}

func TestDeploymentService_GetSourceCommitHash(tt *testing.T) {
	d := &DeploymentService{}
	d.GetSourceCommitHash()
	d = nil
	d.GetSourceCommitHash()
}

func TestDeploymentStaticSite_GetBuildpacks(tt *testing.T) {
	d := &DeploymentStaticSite{}
	d.GetBuildpacks()
	d = nil
	d.GetBuildpacks()
}

func TestDeploymentStaticSite_GetName(tt *testing.T) {
	d := &DeploymentStaticSite{}
	d.GetName()
	d = nil
	d.GetName()
}

func TestDeploymentStaticSite_GetSourceCommitHash(tt *testing.T) {
	d := &DeploymentStaticSite{}
	d.GetSourceCommitHash()
	d = nil
	d.GetSourceCommitHash()
}

func TestDeploymentTiming_GetBuildBillable(tt *testing.T) {
	d := &DeploymentTiming{}
	d.GetBuildBillable()
	d = nil
	d.GetBuildBillable()
}

func TestDeploymentTiming_GetBuildTotal(tt *testing.T) {
	d := &DeploymentTiming{}
	d.GetBuildTotal()
	d = nil
	d.GetBuildTotal()
}

func TestDeploymentTiming_GetComponents(tt *testing.T) {
	d := &DeploymentTiming{}
	d.GetComponents()
	d = nil
	d.GetComponents()
}

func TestDeploymentTiming_GetDatabaseProvision(tt *testing.T) {
	d := &DeploymentTiming{}
	d.GetDatabaseProvision()
	d = nil
	d.GetDatabaseProvision()
}

func TestDeploymentTiming_GetDeploying(tt *testing.T) {
	d := &DeploymentTiming{}
	d.GetDeploying()
	d = nil
	d.GetDeploying()
}

func TestDeploymentTiming_GetPending(tt *testing.T) {
	d := &DeploymentTiming{}
	d.GetPending()
	d = nil
	d.GetPending()
}

func TestDeploymentTimingComponent_GetBuildBillable(tt *testing.T) {
	d := &DeploymentTimingComponent{}
	d.GetBuildBillable()
	d = nil
	d.GetBuildBillable()
}

func TestDeploymentTimingComponent_GetName(tt *testing.T) {
	d := &DeploymentTimingComponent{}
	d.GetName()
	d = nil
	d.GetName()
}

func TestDeploymentWorker_GetBuildpacks(tt *testing.T) {
	d := &DeploymentWorker{}
	d.GetBuildpacks()
	d = nil
	d.GetBuildpacks()
}

func TestDeploymentWorker_GetName(tt *testing.T) {
	d := &DeploymentWorker{}
	d.GetName()
	d = nil
	d.GetName()
}

func TestDeploymentWorker_GetSourceCommitHash(tt *testing.T) {
	d := &DeploymentWorker{}
	d.GetSourceCommitHash()
	d = nil
	d.GetSourceCommitHash()
}

func TestDeployTemplate_GetSpec(tt *testing.T) {
	d := &DeployTemplate{}
	d.GetSpec()
	d = nil
	d.GetSpec()
}

func TestDetectRequest_GetBitbucket(tt *testing.T) {
	d := &DetectRequest{}
	d.GetBitbucket()
	d = nil
	d.GetBitbucket()
}

func TestDetectRequest_GetCommitSHA(tt *testing.T) {
	d := &DetectRequest{}
	d.GetCommitSHA()
	d = nil
	d.GetCommitSHA()
}

func TestDetectRequest_GetGit(tt *testing.T) {
	d := &DetectRequest{}
	d.GetGit()
	d = nil
	d.GetGit()
}

func TestDetectRequest_GetGitHub(tt *testing.T) {
	d := &DetectRequest{}
	d.GetGitHub()
	d = nil
	d.GetGitHub()
}

func TestDetectRequest_GetGitLab(tt *testing.T) {
	d := &DetectRequest{}
	d.GetGitLab()
	d = nil
	d.GetGitLab()
}

func TestDetectRequest_GetSourceDir(tt *testing.T) {
	d := &DetectRequest{}
	d.GetSourceDir()
	d = nil
	d.GetSourceDir()
}

func TestDetectResponse_GetComponents(tt *testing.T) {
	d := &DetectResponse{}
	d.GetComponents()
	d = nil
	d.GetComponents()
}

func TestDetectResponse_GetPending(tt *testing.T) {
	d := &DetectResponse{}
	d.GetPending()
	d = nil
	d.GetPending()
}

func TestDetectResponse_GetTemplate(tt *testing.T) {
	d := &DetectResponse{}
	d.GetTemplate()
	d = nil
	d.GetTemplate()
}

func TestDetectResponse_GetTemplateError(tt *testing.T) {
	d := &DetectResponse{}
	d.GetTemplateError()
	d = nil
	d.GetTemplateError()
}

func TestDetectResponse_GetTemplateFound(tt *testing.T) {
	d := &DetectResponse{}
	d.GetTemplateFound()
	d = nil
	d.GetTemplateFound()
}

func TestDetectResponse_GetTemplateValid(tt *testing.T) {
	d := &DetectResponse{}
	d.GetTemplateValid()
	d = nil
	d.GetTemplateValid()
}

func TestDetectResponseComponent_GetBuildCommand(tt *testing.T) {
	d := &DetectResponseComponent{}
	d.GetBuildCommand()
	d = nil
	d.GetBuildCommand()
}

func TestDetectResponseComponent_GetBuildpacks(tt *testing.T) {
	d := &DetectResponseComponent{}
	d.GetBuildpacks()
	d = nil
	d.GetBuildpacks()
}

func TestDetectResponseComponent_GetDockerfiles(tt *testing.T) {
	d := &DetectResponseComponent{}
	d.GetDockerfiles()
	d = nil
	d.GetDockerfiles()
}

func TestDetectResponseComponent_GetEnvironmentSlug(tt *testing.T) {
	d := &DetectResponseComponent{}
	d.GetEnvironmentSlug()
	d = nil
	d.GetEnvironmentSlug()
}

func TestDetectResponseComponent_GetEnvVars(tt *testing.T) {
	d := &DetectResponseComponent{}
	d.GetEnvVars()
	d = nil
	d.GetEnvVars()
}

func TestDetectResponseComponent_GetHTTPPorts(tt *testing.T) {
	d := &DetectResponseComponent{}
	d.GetHTTPPorts()
	d = nil
	d.GetHTTPPorts()
}

func TestDetectResponseComponent_GetRunCommand(tt *testing.T) {
	d := &DetectResponseComponent{}
	d.GetRunCommand()
	d = nil
	d.GetRunCommand()
}

func TestDetectResponseComponent_GetServerlessPackages(tt *testing.T) {
	d := &DetectResponseComponent{}
	d.GetServerlessPackages()
	d = nil
	d.GetServerlessPackages()
}

func TestDetectResponseComponent_GetSourceDir(tt *testing.T) {
	d := &DetectResponseComponent{}
	d.GetSourceDir()
	d = nil
	d.GetSourceDir()
}

func TestDetectResponseComponent_GetStrategy(tt *testing.T) {
	d := &DetectResponseComponent{}
	d.GetStrategy()
	d = nil
	d.GetStrategy()
}

func TestDetectResponseComponent_GetTypes(tt *testing.T) {
	d := &DetectResponseComponent{}
	d.GetTypes()
	d = nil
	d.GetTypes()
}

func TestDetectResponseServerlessFunction_GetLimits(tt *testing.T) {
	d := &DetectResponseServerlessFunction{}
	d.GetLimits()
	d = nil
	d.GetLimits()
}

func TestDetectResponseServerlessFunction_GetName(tt *testing.T) {
	d := &DetectResponseServerlessFunction{}
	d.GetName()
	d = nil
	d.GetName()
}

func TestDetectResponseServerlessFunction_GetPackage(tt *testing.T) {
	d := &DetectResponseServerlessFunction{}
	d.GetPackage()
	d = nil
	d.GetPackage()
}

func TestDetectResponseServerlessFunction_GetRuntime(tt *testing.T) {
	d := &DetectResponseServerlessFunction{}
	d.GetRuntime()
	d = nil
	d.GetRuntime()
}

func TestDetectResponseServerlessFunctionLimits_GetLogs(tt *testing.T) {
	d := &DetectResponseServerlessFunctionLimits{}
	d.GetLogs()
	d = nil
	d.GetLogs()
}

func TestDetectResponseServerlessFunctionLimits_GetMemory(tt *testing.T) {
	d := &DetectResponseServerlessFunctionLimits{}
	d.GetMemory()
	d = nil
	d.GetMemory()
}

func TestDetectResponseServerlessFunctionLimits_GetTimeout(tt *testing.T) {
	d := &DetectResponseServerlessFunctionLimits{}
	d.GetTimeout()
	d = nil
	d.GetTimeout()
}

func TestDetectResponseServerlessPackage_GetFunctions(tt *testing.T) {
	d := &DetectResponseServerlessPackage{}
	d.GetFunctions()
	d = nil
	d.GetFunctions()
}

func TestDetectResponseServerlessPackage_GetName(tt *testing.T) {
	d := &DetectResponseServerlessPackage{}
	d.GetName()
	d = nil
	d.GetName()
}

func TestGetAppDatabaseConnectionDetailsResponse_GetConnectionDetails(tt *testing.T) {
	g := &GetAppDatabaseConnectionDetailsResponse{}
	g.GetConnectionDetails()
	g = nil
	g.GetConnectionDetails()
}

func TestGetDatabaseConnectionDetailsResponse_GetComponentName(tt *testing.T) {
	g := &GetDatabaseConnectionDetailsResponse{}
	g.GetComponentName()
	g = nil
	g.GetComponentName()
}

func TestGetDatabaseConnectionDetailsResponse_GetDatabaseName(tt *testing.T) {
	g := &GetDatabaseConnectionDetailsResponse{}
	g.GetDatabaseName()
	g = nil
	g.GetDatabaseName()
}

func TestGetDatabaseConnectionDetailsResponse_GetDatabaseURL(tt *testing.T) {
	g := &GetDatabaseConnectionDetailsResponse{}
	g.GetDatabaseURL()
	g = nil
	g.GetDatabaseURL()
}

func TestGetDatabaseConnectionDetailsResponse_GetHost(tt *testing.T) {
	g := &GetDatabaseConnectionDetailsResponse{}
	g.GetHost()
	g = nil
	g.GetHost()
}

func TestGetDatabaseConnectionDetailsResponse_GetPassword(tt *testing.T) {
	g := &GetDatabaseConnectionDetailsResponse{}
	g.GetPassword()
	g = nil
	g.GetPassword()
}

func TestGetDatabaseConnectionDetailsResponse_GetPools(tt *testing.T) {
	g := &GetDatabaseConnectionDetailsResponse{}
	g.GetPools()
	g = nil
	g.GetPools()
}

func TestGetDatabaseConnectionDetailsResponse_GetPort(tt *testing.T) {
	g := &GetDatabaseConnectionDetailsResponse{}
	g.GetPort()
	g = nil
	g.GetPort()
}

func TestGetDatabaseConnectionDetailsResponse_GetSslMode(tt *testing.T) {
	g := &GetDatabaseConnectionDetailsResponse{}
	g.GetSslMode()
	g = nil
	g.GetSslMode()
}

func TestGetDatabaseConnectionDetailsResponse_GetUsername(tt *testing.T) {
	g := &GetDatabaseConnectionDetailsResponse{}
	g.GetUsername()
	g = nil
	g.GetUsername()
}

func TestGetDatabaseConnectionDetailsResponsePool_GetDatabaseName(tt *testing.T) {
	g := &GetDatabaseConnectionDetailsResponsePool{}
	g.GetDatabaseName()
	g = nil
	g.GetDatabaseName()
}

func TestGetDatabaseConnectionDetailsResponsePool_GetDatabaseURL(tt *testing.T) {
	g := &GetDatabaseConnectionDetailsResponsePool{}
	g.GetDatabaseURL()
	g = nil
	g.GetDatabaseURL()
}

func TestGetDatabaseConnectionDetailsResponsePool_GetHost(tt *testing.T) {
	g := &GetDatabaseConnectionDetailsResponsePool{}
	g.GetHost()
	g = nil
	g.GetHost()
}

func TestGetDatabaseConnectionDetailsResponsePool_GetPassword(tt *testing.T) {
	g := &GetDatabaseConnectionDetailsResponsePool{}
	g.GetPassword()
	g = nil
	g.GetPassword()
}

func TestGetDatabaseConnectionDetailsResponsePool_GetPoolName(tt *testing.T) {
	g := &GetDatabaseConnectionDetailsResponsePool{}
	g.GetPoolName()
	g = nil
	g.GetPoolName()
}

func TestGetDatabaseConnectionDetailsResponsePool_GetPort(tt *testing.T) {
	g := &GetDatabaseConnectionDetailsResponsePool{}
	g.GetPort()
	g = nil
	g.GetPort()
}

func TestGetDatabaseConnectionDetailsResponsePool_GetSslMode(tt *testing.T) {
	g := &GetDatabaseConnectionDetailsResponsePool{}
	g.GetSslMode()
	g = nil
	g.GetSslMode()
}

func TestGetDatabaseConnectionDetailsResponsePool_GetUsername(tt *testing.T) {
	g := &GetDatabaseConnectionDetailsResponsePool{}
	g.GetUsername()
	g = nil
	g.GetUsername()
}

func TestGetDatabaseTrustedSourceResponse_GetIsEnabled(tt *testing.T) {
	g := &GetDatabaseTrustedSourceResponse{}
	g.GetIsEnabled()
	g = nil
	g.GetIsEnabled()
}

func TestGitHubSourceSpec_GetBranch(tt *testing.T) {
	g := &GitHubSourceSpec{}
	g.GetBranch()
	g = nil
	g.GetBranch()
}

func TestGitHubSourceSpec_GetDeployOnPush(tt *testing.T) {
	g := &GitHubSourceSpec{}
	g.GetDeployOnPush()
	g = nil
	g.GetDeployOnPush()
}

func TestGitHubSourceSpec_GetRepo(tt *testing.T) {
	g := &GitHubSourceSpec{}
	g.GetRepo()
	g = nil
	g.GetRepo()
}

func TestGitLabSourceSpec_GetBranch(tt *testing.T) {
	g := &GitLabSourceSpec{}
	g.GetBranch()
	g = nil
	g.GetBranch()
}

func TestGitLabSourceSpec_GetDeployOnPush(tt *testing.T) {
	g := &GitLabSourceSpec{}
	g.GetDeployOnPush()
	g = nil
	g.GetDeployOnPush()
}

func TestGitLabSourceSpec_GetRepo(tt *testing.T) {
	g := &GitLabSourceSpec{}
	g.GetRepo()
	g = nil
	g.GetRepo()
}

func TestGitSourceSpec_GetBranch(tt *testing.T) {
	g := &GitSourceSpec{}
	g.GetBranch()
	g = nil
	g.GetBranch()
}

func TestGitSourceSpec_GetRepoCloneURL(tt *testing.T) {
	g := &GitSourceSpec{}
	g.GetRepoCloneURL()
	g = nil
	g.GetRepoCloneURL()
}

func TestImageSourceSpec_GetDeployOnPush(tt *testing.T) {
	i := &ImageSourceSpec{}
	i.GetDeployOnPush()
	i = nil
	i.GetDeployOnPush()
}

func TestImageSourceSpec_GetDigest(tt *testing.T) {
	i := &ImageSourceSpec{}
	i.GetDigest()
	i = nil
	i.GetDigest()
}

func TestImageSourceSpec_GetRegistry(tt *testing.T) {
	i := &ImageSourceSpec{}
	i.GetRegistry()
	i = nil
	i.GetRegistry()
}

func TestImageSourceSpec_GetRegistryCredentials(tt *testing.T) {
	i := &ImageSourceSpec{}
	i.GetRegistryCredentials()
	i = nil
	i.GetRegistryCredentials()
}

func TestImageSourceSpec_GetRegistryType(tt *testing.T) {
	i := &ImageSourceSpec{}
	i.GetRegistryType()
	i = nil
	i.GetRegistryType()
}

func TestImageSourceSpec_GetRepository(tt *testing.T) {
	i := &ImageSourceSpec{}
	i.GetRepository()
	i = nil
	i.GetRepository()
}

func TestImageSourceSpec_GetTag(tt *testing.T) {
	i := &ImageSourceSpec{}
	i.GetTag()
	i = nil
	i.GetTag()
}

func TestImageSourceSpecDeployOnPush_GetEnabled(tt *testing.T) {
	i := &ImageSourceSpecDeployOnPush{}
	i.GetEnabled()
	i = nil
	i.GetEnabled()
}

func TestListBuildpacksResponse_GetBuildpacks(tt *testing.T) {
	l := &ListBuildpacksResponse{}
	l.GetBuildpacks()
	l = nil
	l.GetBuildpacks()
}

func TestOpenSearchBasicAuth_GetPassword(tt *testing.T) {
	o := &OpenSearchBasicAuth{}
	o.GetPassword()
	o = nil
	o.GetPassword()
}

func TestOpenSearchBasicAuth_GetUser(tt *testing.T) {
	o := &OpenSearchBasicAuth{}
	o.GetUser()
	o = nil
	o.GetUser()
}

func TestResetDatabasePasswordRequest_GetAppID(tt *testing.T) {
	r := &ResetDatabasePasswordRequest{}
	r.GetAppID()
	r = nil
	r.GetAppID()
}

func TestResetDatabasePasswordRequest_GetComponentName(tt *testing.T) {
	r := &ResetDatabasePasswordRequest{}
	r.GetComponentName()
	r = nil
	r.GetComponentName()
}

func TestResetDatabasePasswordResponse_GetDeployment(tt *testing.T) {
	r := &ResetDatabasePasswordResponse{}
	r.GetDeployment()
	r = nil
	r.GetDeployment()
}

func TestToggleDatabaseTrustedSourceRequest_GetAppID(tt *testing.T) {
	t := &ToggleDatabaseTrustedSourceRequest{}
	t.GetAppID()
	t = nil
	t.GetAppID()
}

func TestToggleDatabaseTrustedSourceRequest_GetComponentName(tt *testing.T) {
	t := &ToggleDatabaseTrustedSourceRequest{}
	t.GetComponentName()
	t = nil
	t.GetComponentName()
}

func TestToggleDatabaseTrustedSourceRequest_GetEnable(tt *testing.T) {
	t := &ToggleDatabaseTrustedSourceRequest{}
	t.GetEnable()
	t = nil
	t.GetEnable()
}

func TestToggleDatabaseTrustedSourceResponse_GetIsEnabled(tt *testing.T) {
	t := &ToggleDatabaseTrustedSourceResponse{}
	t.GetIsEnabled()
	t = nil
	t.GetIsEnabled()
}

func TestUpgradeBuildpackResponse_GetAffectedComponents(tt *testing.T) {
	u := &UpgradeBuildpackResponse{}
	u.GetAffectedComponents()
	u = nil
	u.GetAffectedComponents()
}

func TestUpgradeBuildpackResponse_GetDeployment(tt *testing.T) {
	u := &UpgradeBuildpackResponse{}
	u.GetDeployment()
	u = nil
	u.GetDeployment()
}