management.gen_test.go

// Code generated by gen-methods; DO NOT EDIT.
// Please run "go generate ./..." instead.

package management

import (
	"encoding/json"
	"testing"
	"time"
)

func TestAction_GetBuiltAt(tt *testing.T) {
	var zeroValue time.Time
	a := &Action{BuiltAt: &zeroValue}
	a.GetBuiltAt()
	a = &Action{}
	a.GetBuiltAt()
	a = nil
	a.GetBuiltAt()
}

func TestAction_GetCode(tt *testing.T) {
	var zeroValue string
	a := &Action{Code: &zeroValue}
	a.GetCode()
	a = &Action{}
	a.GetCode()
	a = nil
	a.GetCode()
}

func TestAction_GetCreatedAt(tt *testing.T) {
	var zeroValue time.Time
	a := &Action{CreatedAt: &zeroValue}
	a.GetCreatedAt()
	a = &Action{}
	a.GetCreatedAt()
	a = nil
	a.GetCreatedAt()
}

func TestAction_GetDependencies(tt *testing.T) {
	var zeroValue []ActionDependency
	a := &Action{Dependencies: &zeroValue}
	a.GetDependencies()
	a = &Action{}
	a.GetDependencies()
	a = nil
	a.GetDependencies()
}

func TestAction_GetDeploy(tt *testing.T) {
	var zeroValue bool
	a := &Action{Deploy: &zeroValue}
	a.GetDeploy()
	a = &Action{}
	a.GetDeploy()
	a = nil
	a.GetDeploy()
}

func TestAction_GetDeployedVersion(tt *testing.T) {
	a := &Action{}
	a.GetDeployedVersion()
	a = nil
	a.GetDeployedVersion()
}

func TestAction_GetID(tt *testing.T) {
	var zeroValue string
	a := &Action{ID: &zeroValue}
	a.GetID()
	a = &Action{}
	a.GetID()
	a = nil
	a.GetID()
}

func TestAction_GetName(tt *testing.T) {
	var zeroValue string
	a := &Action{Name: &zeroValue}
	a.GetName()
	a = &Action{}
	a.GetName()
	a = nil
	a.GetName()
}

func TestAction_GetRuntime(tt *testing.T) {
	var zeroValue string
	a := &Action{Runtime: &zeroValue}
	a.GetRuntime()
	a = &Action{}
	a.GetRuntime()
	a = nil
	a.GetRuntime()
}

func TestAction_GetSecrets(tt *testing.T) {
	var zeroValue []ActionSecret
	a := &Action{Secrets: &zeroValue}
	a.GetSecrets()
	a = &Action{}
	a.GetSecrets()
	a = nil
	a.GetSecrets()
}

func TestAction_GetStatus(tt *testing.T) {
	var zeroValue string
	a := &Action{Status: &zeroValue}
	a.GetStatus()
	a = &Action{}
	a.GetStatus()
	a = nil
	a.GetStatus()
}

func TestAction_GetUpdatedAt(tt *testing.T) {
	var zeroValue time.Time
	a := &Action{UpdatedAt: &zeroValue}
	a.GetUpdatedAt()
	a = &Action{}
	a.GetUpdatedAt()
	a = nil
	a.GetUpdatedAt()
}

func TestAction_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &Action{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestActionBinding_GetAction(tt *testing.T) {
	a := &ActionBinding{}
	a.GetAction()
	a = nil
	a.GetAction()
}

func TestActionBinding_GetCreatedAt(tt *testing.T) {
	var zeroValue time.Time
	a := &ActionBinding{CreatedAt: &zeroValue}
	a.GetCreatedAt()
	a = &ActionBinding{}
	a.GetCreatedAt()
	a = nil
	a.GetCreatedAt()
}

func TestActionBinding_GetDisplayName(tt *testing.T) {
	var zeroValue string
	a := &ActionBinding{DisplayName: &zeroValue}
	a.GetDisplayName()
	a = &ActionBinding{}
	a.GetDisplayName()
	a = nil
	a.GetDisplayName()
}

func TestActionBinding_GetID(tt *testing.T) {
	var zeroValue string
	a := &ActionBinding{ID: &zeroValue}
	a.GetID()
	a = &ActionBinding{}
	a.GetID()
	a = nil
	a.GetID()
}

func TestActionBinding_GetRef(tt *testing.T) {
	a := &ActionBinding{}
	a.GetRef()
	a = nil
	a.GetRef()
}

func TestActionBinding_GetTriggerID(tt *testing.T) {
	var zeroValue string
	a := &ActionBinding{TriggerID: &zeroValue}
	a.GetTriggerID()
	a = &ActionBinding{}
	a.GetTriggerID()
	a = nil
	a.GetTriggerID()
}

func TestActionBinding_GetUpdatedAt(tt *testing.T) {
	var zeroValue time.Time
	a := &ActionBinding{UpdatedAt: &zeroValue}
	a.GetUpdatedAt()
	a = &ActionBinding{}
	a.GetUpdatedAt()
	a = nil
	a.GetUpdatedAt()
}

func TestActionBinding_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ActionBinding{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestActionBindingList_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ActionBindingList{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestActionBindingReference_GetType(tt *testing.T) {
	var zeroValue string
	a := &ActionBindingReference{Type: &zeroValue}
	a.GetType()
	a = &ActionBindingReference{}
	a.GetType()
	a = nil
	a.GetType()
}

func TestActionBindingReference_GetValue(tt *testing.T) {
	var zeroValue string
	a := &ActionBindingReference{Value: &zeroValue}
	a.GetValue()
	a = &ActionBindingReference{}
	a.GetValue()
	a = nil
	a.GetValue()
}

func TestActionBindingReference_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ActionBindingReference{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestActionDependency_GetName(tt *testing.T) {
	var zeroValue string
	a := &ActionDependency{Name: &zeroValue}
	a.GetName()
	a = &ActionDependency{}
	a.GetName()
	a = nil
	a.GetName()
}

func TestActionDependency_GetRegistryURL(tt *testing.T) {
	var zeroValue string
	a := &ActionDependency{RegistryURL: &zeroValue}
	a.GetRegistryURL()
	a = &ActionDependency{}
	a.GetRegistryURL()
	a = nil
	a.GetRegistryURL()
}

func TestActionDependency_GetVersion(tt *testing.T) {
	var zeroValue string
	a := &ActionDependency{Version: &zeroValue}
	a.GetVersion()
	a = &ActionDependency{}
	a.GetVersion()
	a = nil
	a.GetVersion()
}

func TestActionDependency_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ActionDependency{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestActionExecution_GetCreatedAt(tt *testing.T) {
	var zeroValue time.Time
	a := &ActionExecution{CreatedAt: &zeroValue}
	a.GetCreatedAt()
	a = &ActionExecution{}
	a.GetCreatedAt()
	a = nil
	a.GetCreatedAt()
}

func TestActionExecution_GetID(tt *testing.T) {
	var zeroValue string
	a := &ActionExecution{ID: &zeroValue}
	a.GetID()
	a = &ActionExecution{}
	a.GetID()
	a = nil
	a.GetID()
}

func TestActionExecution_GetStatus(tt *testing.T) {
	var zeroValue string
	a := &ActionExecution{Status: &zeroValue}
	a.GetStatus()
	a = &ActionExecution{}
	a.GetStatus()
	a = nil
	a.GetStatus()
}

func TestActionExecution_GetTriggerID(tt *testing.T) {
	var zeroValue string
	a := &ActionExecution{TriggerID: &zeroValue}
	a.GetTriggerID()
	a = &ActionExecution{}
	a.GetTriggerID()
	a = nil
	a.GetTriggerID()
}

func TestActionExecution_GetUpdatedAt(tt *testing.T) {
	var zeroValue time.Time
	a := &ActionExecution{UpdatedAt: &zeroValue}
	a.GetUpdatedAt()
	a = &ActionExecution{}
	a.GetUpdatedAt()
	a = nil
	a.GetUpdatedAt()
}

func TestActionExecution_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ActionExecution{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestActionExecutionResult_GetActionName(tt *testing.T) {
	var zeroValue string
	a := &ActionExecutionResult{ActionName: &zeroValue}
	a.GetActionName()
	a = &ActionExecutionResult{}
	a.GetActionName()
	a = nil
	a.GetActionName()
}

func TestActionExecutionResult_GetEndedAt(tt *testing.T) {
	var zeroValue time.Time
	a := &ActionExecutionResult{EndedAt: &zeroValue}
	a.GetEndedAt()
	a = &ActionExecutionResult{}
	a.GetEndedAt()
	a = nil
	a.GetEndedAt()
}

func TestActionExecutionResult_GetError(tt *testing.T) {
	zeroValue := map[string]interface{}{}
	a := &ActionExecutionResult{Error: zeroValue}
	a.GetError()
	a = &ActionExecutionResult{}
	a.GetError()
	a = nil
	a.GetError()
}

func TestActionExecutionResult_GetStartedAt(tt *testing.T) {
	var zeroValue time.Time
	a := &ActionExecutionResult{StartedAt: &zeroValue}
	a.GetStartedAt()
	a = &ActionExecutionResult{}
	a.GetStartedAt()
	a = nil
	a.GetStartedAt()
}

func TestActionExecutionResult_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ActionExecutionResult{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestActionList_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ActionList{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestActionSecret_GetName(tt *testing.T) {
	var zeroValue string
	a := &ActionSecret{Name: &zeroValue}
	a.GetName()
	a = &ActionSecret{}
	a.GetName()
	a = nil
	a.GetName()
}

func TestActionSecret_GetUpdatedAt(tt *testing.T) {
	var zeroValue time.Time
	a := &ActionSecret{UpdatedAt: &zeroValue}
	a.GetUpdatedAt()
	a = &ActionSecret{}
	a.GetUpdatedAt()
	a = nil
	a.GetUpdatedAt()
}

func TestActionSecret_GetValue(tt *testing.T) {
	var zeroValue string
	a := &ActionSecret{Value: &zeroValue}
	a.GetValue()
	a = &ActionSecret{}
	a.GetValue()
	a = nil
	a.GetValue()
}

func TestActionSecret_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ActionSecret{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestActionTrigger_GetID(tt *testing.T) {
	var zeroValue string
	a := &ActionTrigger{ID: &zeroValue}
	a.GetID()
	a = &ActionTrigger{}
	a.GetID()
	a = nil
	a.GetID()
}

func TestActionTrigger_GetStatus(tt *testing.T) {
	var zeroValue string
	a := &ActionTrigger{Status: &zeroValue}
	a.GetStatus()
	a = &ActionTrigger{}
	a.GetStatus()
	a = nil
	a.GetStatus()
}

func TestActionTrigger_GetVersion(tt *testing.T) {
	var zeroValue string
	a := &ActionTrigger{Version: &zeroValue}
	a.GetVersion()
	a = &ActionTrigger{}
	a.GetVersion()
	a = nil
	a.GetVersion()
}

func TestActionTrigger_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ActionTrigger{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestActionTriggerList_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ActionTriggerList{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestActionVersion_GetAction(tt *testing.T) {
	a := &ActionVersion{}
	a.GetAction()
	a = nil
	a.GetAction()
}

func TestActionVersion_GetBuiltAt(tt *testing.T) {
	var zeroValue time.Time
	a := &ActionVersion{BuiltAt: &zeroValue}
	a.GetBuiltAt()
	a = &ActionVersion{}
	a.GetBuiltAt()
	a = nil
	a.GetBuiltAt()
}

func TestActionVersion_GetCode(tt *testing.T) {
	var zeroValue string
	a := &ActionVersion{Code: &zeroValue}
	a.GetCode()
	a = &ActionVersion{}
	a.GetCode()
	a = nil
	a.GetCode()
}

func TestActionVersion_GetCreatedAt(tt *testing.T) {
	var zeroValue time.Time
	a := &ActionVersion{CreatedAt: &zeroValue}
	a.GetCreatedAt()
	a = &ActionVersion{}
	a.GetCreatedAt()
	a = nil
	a.GetCreatedAt()
}

func TestActionVersion_GetID(tt *testing.T) {
	var zeroValue string
	a := &ActionVersion{ID: &zeroValue}
	a.GetID()
	a = &ActionVersion{}
	a.GetID()
	a = nil
	a.GetID()
}

func TestActionVersion_GetStatus(tt *testing.T) {
	var zeroValue string
	a := &ActionVersion{Status: &zeroValue}
	a.GetStatus()
	a = &ActionVersion{}
	a.GetStatus()
	a = nil
	a.GetStatus()
}

func TestActionVersion_GetUpdatedAt(tt *testing.T) {
	var zeroValue time.Time
	a := &ActionVersion{UpdatedAt: &zeroValue}
	a.GetUpdatedAt()
	a = &ActionVersion{}
	a.GetUpdatedAt()
	a = nil
	a.GetUpdatedAt()
}

func TestActionVersion_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ActionVersion{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestActionVersionError_GetID(tt *testing.T) {
	var zeroValue string
	a := &ActionVersionError{ID: &zeroValue}
	a.GetID()
	a = &ActionVersionError{}
	a.GetID()
	a = nil
	a.GetID()
}

func TestActionVersionError_GetMessage(tt *testing.T) {
	var zeroValue string
	a := &ActionVersionError{Message: &zeroValue}
	a.GetMessage()
	a = &ActionVersionError{}
	a.GetMessage()
	a = nil
	a.GetMessage()
}

func TestActionVersionError_GetURL(tt *testing.T) {
	var zeroValue string
	a := &ActionVersionError{URL: &zeroValue}
	a.GetURL()
	a = &ActionVersionError{}
	a.GetURL()
	a = nil
	a.GetURL()
}

func TestActionVersionError_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ActionVersionError{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestActionVersionList_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ActionVersionList{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestAuthenticationMethod_GetAuthenticationMethods(tt *testing.T) {
	var zeroValue []AuthenticationMethodReference
	a := &AuthenticationMethod{AuthenticationMethods: &zeroValue}
	a.GetAuthenticationMethods()
	a = &AuthenticationMethod{}
	a.GetAuthenticationMethods()
	a = nil
	a.GetAuthenticationMethods()
}

func TestAuthenticationMethod_GetConfirmed(tt *testing.T) {
	var zeroValue bool
	a := &AuthenticationMethod{Confirmed: &zeroValue}
	a.GetConfirmed()
	a = &AuthenticationMethod{}
	a.GetConfirmed()
	a = nil
	a.GetConfirmed()
}

func TestAuthenticationMethod_GetCreatedAt(tt *testing.T) {
	var zeroValue time.Time
	a := &AuthenticationMethod{CreatedAt: &zeroValue}
	a.GetCreatedAt()
	a = &AuthenticationMethod{}
	a.GetCreatedAt()
	a = nil
	a.GetCreatedAt()
}

func TestAuthenticationMethod_GetCredentialBackedUp(tt *testing.T) {
	var zeroValue bool
	a := &AuthenticationMethod{CredentialBackedUp: &zeroValue}
	a.GetCredentialBackedUp()
	a = &AuthenticationMethod{}
	a.GetCredentialBackedUp()
	a = nil
	a.GetCredentialBackedUp()
}

func TestAuthenticationMethod_GetCredentialDeviceType(tt *testing.T) {
	var zeroValue string
	a := &AuthenticationMethod{CredentialDeviceType: &zeroValue}
	a.GetCredentialDeviceType()
	a = &AuthenticationMethod{}
	a.GetCredentialDeviceType()
	a = nil
	a.GetCredentialDeviceType()
}

func TestAuthenticationMethod_GetEmail(tt *testing.T) {
	var zeroValue string
	a := &AuthenticationMethod{Email: &zeroValue}
	a.GetEmail()
	a = &AuthenticationMethod{}
	a.GetEmail()
	a = nil
	a.GetEmail()
}

func TestAuthenticationMethod_GetEnrolledAt(tt *testing.T) {
	var zeroValue time.Time
	a := &AuthenticationMethod{EnrolledAt: &zeroValue}
	a.GetEnrolledAt()
	a = &AuthenticationMethod{}
	a.GetEnrolledAt()
	a = nil
	a.GetEnrolledAt()
}

func TestAuthenticationMethod_GetID(tt *testing.T) {
	var zeroValue string
	a := &AuthenticationMethod{ID: &zeroValue}
	a.GetID()
	a = &AuthenticationMethod{}
	a.GetID()
	a = nil
	a.GetID()
}

func TestAuthenticationMethod_GetIdentityUserID(tt *testing.T) {
	var zeroValue string
	a := &AuthenticationMethod{IdentityUserID: &zeroValue}
	a.GetIdentityUserID()
	a = &AuthenticationMethod{}
	a.GetIdentityUserID()
	a = nil
	a.GetIdentityUserID()
}

func TestAuthenticationMethod_GetKeyID(tt *testing.T) {
	var zeroValue string
	a := &AuthenticationMethod{KeyID: &zeroValue}
	a.GetKeyID()
	a = &AuthenticationMethod{}
	a.GetKeyID()
	a = nil
	a.GetKeyID()
}

func TestAuthenticationMethod_GetLastAuthedAt(tt *testing.T) {
	var zeroValue time.Time
	a := &AuthenticationMethod{LastAuthedAt: &zeroValue}
	a.GetLastAuthedAt()
	a = &AuthenticationMethod{}
	a.GetLastAuthedAt()
	a = nil
	a.GetLastAuthedAt()
}

func TestAuthenticationMethod_GetLinkID(tt *testing.T) {
	var zeroValue string
	a := &AuthenticationMethod{LinkID: &zeroValue}
	a.GetLinkID()
	a = &AuthenticationMethod{}
	a.GetLinkID()
	a = nil
	a.GetLinkID()
}

func TestAuthenticationMethod_GetName(tt *testing.T) {
	var zeroValue string
	a := &AuthenticationMethod{Name: &zeroValue}
	a.GetName()
	a = &AuthenticationMethod{}
	a.GetName()
	a = nil
	a.GetName()
}

func TestAuthenticationMethod_GetPhoneNumber(tt *testing.T) {
	var zeroValue string
	a := &AuthenticationMethod{PhoneNumber: &zeroValue}
	a.GetPhoneNumber()
	a = &AuthenticationMethod{}
	a.GetPhoneNumber()
	a = nil
	a.GetPhoneNumber()
}

func TestAuthenticationMethod_GetPreferredAuthenticationMethod(tt *testing.T) {
	var zeroValue string
	a := &AuthenticationMethod{PreferredAuthenticationMethod: &zeroValue}
	a.GetPreferredAuthenticationMethod()
	a = &AuthenticationMethod{}
	a.GetPreferredAuthenticationMethod()
	a = nil
	a.GetPreferredAuthenticationMethod()
}

func TestAuthenticationMethod_GetPublicKey(tt *testing.T) {
	var zeroValue string
	a := &AuthenticationMethod{PublicKey: &zeroValue}
	a.GetPublicKey()
	a = &AuthenticationMethod{}
	a.GetPublicKey()
	a = nil
	a.GetPublicKey()
}

func TestAuthenticationMethod_GetRelyingPartyIdentifier(tt *testing.T) {
	var zeroValue string
	a := &AuthenticationMethod{RelyingPartyIdentifier: &zeroValue}
	a.GetRelyingPartyIdentifier()
	a = &AuthenticationMethod{}
	a.GetRelyingPartyIdentifier()
	a = nil
	a.GetRelyingPartyIdentifier()
}

func TestAuthenticationMethod_GetTOTPSecret(tt *testing.T) {
	var zeroValue string
	a := &AuthenticationMethod{TOTPSecret: &zeroValue}
	a.GetTOTPSecret()
	a = &AuthenticationMethod{}
	a.GetTOTPSecret()
	a = nil
	a.GetTOTPSecret()
}

func TestAuthenticationMethod_GetType(tt *testing.T) {
	var zeroValue string
	a := &AuthenticationMethod{Type: &zeroValue}
	a.GetType()
	a = &AuthenticationMethod{}
	a.GetType()
	a = nil
	a.GetType()
}

func TestAuthenticationMethod_GetUserAgent(tt *testing.T) {
	var zeroValue string
	a := &AuthenticationMethod{UserAgent: &zeroValue}
	a.GetUserAgent()
	a = &AuthenticationMethod{}
	a.GetUserAgent()
	a = nil
	a.GetUserAgent()
}

func TestAuthenticationMethod_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &AuthenticationMethod{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestAuthenticationMethodList_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &AuthenticationMethodList{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestAuthenticationMethodReference_GetID(tt *testing.T) {
	var zeroValue string
	a := &AuthenticationMethodReference{ID: &zeroValue}
	a.GetID()
	a = &AuthenticationMethodReference{}
	a.GetID()
	a = nil
	a.GetID()
}

func TestAuthenticationMethodReference_GetType(tt *testing.T) {
	var zeroValue string
	a := &AuthenticationMethodReference{Type: &zeroValue}
	a.GetType()
	a = &AuthenticationMethodReference{}
	a.GetType()
	a = nil
	a.GetType()
}

func TestAuthenticationMethodReference_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &AuthenticationMethodReference{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestAuthenticationMethods_GetPasskey(tt *testing.T) {
	a := &AuthenticationMethods{}
	a.GetPasskey()
	a = nil
	a.GetPasskey()
}

func TestAuthenticationMethods_GetPassword(tt *testing.T) {
	a := &AuthenticationMethods{}
	a.GetPassword()
	a = nil
	a.GetPassword()
}

func TestAuthenticationMethods_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &AuthenticationMethods{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestAWSClientAddon_GetLifetimeInSeconds(tt *testing.T) {
	var zeroValue int
	a := &AWSClientAddon{LifetimeInSeconds: &zeroValue}
	a.GetLifetimeInSeconds()
	a = &AWSClientAddon{}
	a.GetLifetimeInSeconds()
	a = nil
	a.GetLifetimeInSeconds()
}

func TestAWSClientAddon_GetPrincipal(tt *testing.T) {
	var zeroValue string
	a := &AWSClientAddon{Principal: &zeroValue}
	a.GetPrincipal()
	a = &AWSClientAddon{}
	a.GetPrincipal()
	a = nil
	a.GetPrincipal()
}

func TestAWSClientAddon_GetRole(tt *testing.T) {
	var zeroValue string
	a := &AWSClientAddon{Role: &zeroValue}
	a.GetRole()
	a = &AWSClientAddon{}
	a.GetRole()
	a = nil
	a.GetRole()
}

func TestAWSClientAddon_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &AWSClientAddon{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestAzureBlobClientAddon_GetAccountName(tt *testing.T) {
	var zeroValue string
	a := &AzureBlobClientAddon{AccountName: &zeroValue}
	a.GetAccountName()
	a = &AzureBlobClientAddon{}
	a.GetAccountName()
	a = nil
	a.GetAccountName()
}

func TestAzureBlobClientAddon_GetBlobDelete(tt *testing.T) {
	var zeroValue bool
	a := &AzureBlobClientAddon{BlobDelete: &zeroValue}
	a.GetBlobDelete()
	a = &AzureBlobClientAddon{}
	a.GetBlobDelete()
	a = nil
	a.GetBlobDelete()
}

func TestAzureBlobClientAddon_GetBlobName(tt *testing.T) {
	var zeroValue string
	a := &AzureBlobClientAddon{BlobName: &zeroValue}
	a.GetBlobName()
	a = &AzureBlobClientAddon{}
	a.GetBlobName()
	a = nil
	a.GetBlobName()
}

func TestAzureBlobClientAddon_GetBlobRead(tt *testing.T) {
	var zeroValue bool
	a := &AzureBlobClientAddon{BlobRead: &zeroValue}
	a.GetBlobRead()
	a = &AzureBlobClientAddon{}
	a.GetBlobRead()
	a = nil
	a.GetBlobRead()
}

func TestAzureBlobClientAddon_GetBlobWrite(tt *testing.T) {
	var zeroValue bool
	a := &AzureBlobClientAddon{BlobWrite: &zeroValue}
	a.GetBlobWrite()
	a = &AzureBlobClientAddon{}
	a.GetBlobWrite()
	a = nil
	a.GetBlobWrite()
}

func TestAzureBlobClientAddon_GetContainerDelete(tt *testing.T) {
	var zeroValue bool
	a := &AzureBlobClientAddon{ContainerDelete: &zeroValue}
	a.GetContainerDelete()
	a = &AzureBlobClientAddon{}
	a.GetContainerDelete()
	a = nil
	a.GetContainerDelete()
}

func TestAzureBlobClientAddon_GetContainerList(tt *testing.T) {
	var zeroValue bool
	a := &AzureBlobClientAddon{ContainerList: &zeroValue}
	a.GetContainerList()
	a = &AzureBlobClientAddon{}
	a.GetContainerList()
	a = nil
	a.GetContainerList()
}

func TestAzureBlobClientAddon_GetContainerName(tt *testing.T) {
	var zeroValue string
	a := &AzureBlobClientAddon{ContainerName: &zeroValue}
	a.GetContainerName()
	a = &AzureBlobClientAddon{}
	a.GetContainerName()
	a = nil
	a.GetContainerName()
}

func TestAzureBlobClientAddon_GetContainerRead(tt *testing.T) {
	var zeroValue bool
	a := &AzureBlobClientAddon{ContainerRead: &zeroValue}
	a.GetContainerRead()
	a = &AzureBlobClientAddon{}
	a.GetContainerRead()
	a = nil
	a.GetContainerRead()
}

func TestAzureBlobClientAddon_GetContainerWrite(tt *testing.T) {
	var zeroValue bool
	a := &AzureBlobClientAddon{ContainerWrite: &zeroValue}
	a.GetContainerWrite()
	a = &AzureBlobClientAddon{}
	a.GetContainerWrite()
	a = nil
	a.GetContainerWrite()
}

func TestAzureBlobClientAddon_GetExpiration(tt *testing.T) {
	var zeroValue int
	a := &AzureBlobClientAddon{Expiration: &zeroValue}
	a.GetExpiration()
	a = &AzureBlobClientAddon{}
	a.GetExpiration()
	a = nil
	a.GetExpiration()
}

func TestAzureBlobClientAddon_GetSignedIdentifier(tt *testing.T) {
	var zeroValue string
	a := &AzureBlobClientAddon{SignedIdentifier: &zeroValue}
	a.GetSignedIdentifier()
	a = &AzureBlobClientAddon{}
	a.GetSignedIdentifier()
	a = nil
	a.GetSignedIdentifier()
}

func TestAzureBlobClientAddon_GetStorageAccessKey(tt *testing.T) {
	var zeroValue string
	a := &AzureBlobClientAddon{StorageAccessKey: &zeroValue}
	a.GetStorageAccessKey()
	a = &AzureBlobClientAddon{}
	a.GetStorageAccessKey()
	a = nil
	a.GetStorageAccessKey()
}

func TestAzureBlobClientAddon_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &AzureBlobClientAddon{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestAzureSBClientAddon_GetEntityPath(tt *testing.T) {
	var zeroValue string
	a := &AzureSBClientAddon{EntityPath: &zeroValue}
	a.GetEntityPath()
	a = &AzureSBClientAddon{}
	a.GetEntityPath()
	a = nil
	a.GetEntityPath()
}

func TestAzureSBClientAddon_GetExpiration(tt *testing.T) {
	var zeroValue int
	a := &AzureSBClientAddon{Expiration: &zeroValue}
	a.GetExpiration()
	a = &AzureSBClientAddon{}
	a.GetExpiration()
	a = nil
	a.GetExpiration()
}

func TestAzureSBClientAddon_GetNamespace(tt *testing.T) {
	var zeroValue string
	a := &AzureSBClientAddon{Namespace: &zeroValue}
	a.GetNamespace()
	a = &AzureSBClientAddon{}
	a.GetNamespace()
	a = nil
	a.GetNamespace()
}

func TestAzureSBClientAddon_GetSASKey(tt *testing.T) {
	var zeroValue string
	a := &AzureSBClientAddon{SASKey: &zeroValue}
	a.GetSASKey()
	a = &AzureSBClientAddon{}
	a.GetSASKey()
	a = nil
	a.GetSASKey()
}

func TestAzureSBClientAddon_GetSASKeyName(tt *testing.T) {
	var zeroValue string
	a := &AzureSBClientAddon{SASKeyName: &zeroValue}
	a.GetSASKeyName()
	a = &AzureSBClientAddon{}
	a.GetSASKeyName()
	a = nil
	a.GetSASKeyName()
}

func TestAzureSBClientAddon_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &AzureSBClientAddon{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestBackChannelLogoutInitiators_GetMode(tt *testing.T) {
	var zeroValue string
	b := &BackChannelLogoutInitiators{Mode: &zeroValue}
	b.GetMode()
	b = &BackChannelLogoutInitiators{}
	b.GetMode()
	b = nil
	b.GetMode()
}

func TestBackChannelLogoutInitiators_GetSelectedInitiators(tt *testing.T) {
	var zeroValue []string
	b := &BackChannelLogoutInitiators{SelectedInitiators: &zeroValue}
	b.GetSelectedInitiators()
	b = &BackChannelLogoutInitiators{}
	b.GetSelectedInitiators()
	b = nil
	b.GetSelectedInitiators()
}

func TestBackChannelLogoutInitiators_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &BackChannelLogoutInitiators{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestBlacklistToken_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &BlacklistToken{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestBoxClientAddon_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &BoxClientAddon{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestBranding_GetColors(tt *testing.T) {
	b := &Branding{}
	b.GetColors()
	b = nil
	b.GetColors()
}

func TestBranding_GetFaviconURL(tt *testing.T) {
	var zeroValue string
	b := &Branding{FaviconURL: &zeroValue}
	b.GetFaviconURL()
	b = &Branding{}
	b.GetFaviconURL()
	b = nil
	b.GetFaviconURL()
}

func TestBranding_GetFont(tt *testing.T) {
	b := &Branding{}
	b.GetFont()
	b = nil
	b.GetFont()
}

func TestBranding_GetLogoURL(tt *testing.T) {
	var zeroValue string
	b := &Branding{LogoURL: &zeroValue}
	b.GetLogoURL()
	b = &Branding{}
	b.GetLogoURL()
	b = nil
	b.GetLogoURL()
}

func TestBranding_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &Branding{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestBrandingColors_GetPageBackground(tt *testing.T) {
	var zeroValue string
	b := &BrandingColors{PageBackground: &zeroValue}
	b.GetPageBackground()
	b = &BrandingColors{}
	b.GetPageBackground()
	b = nil
	b.GetPageBackground()
}

func TestBrandingColors_GetPageBackgroundGradient(tt *testing.T) {
	b := &BrandingColors{}
	b.GetPageBackgroundGradient()
	b = nil
	b.GetPageBackgroundGradient()
}

func TestBrandingColors_GetPrimary(tt *testing.T) {
	var zeroValue string
	b := &BrandingColors{Primary: &zeroValue}
	b.GetPrimary()
	b = &BrandingColors{}
	b.GetPrimary()
	b = nil
	b.GetPrimary()
}

func TestBrandingColors_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &BrandingColors{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestBrandingFont_GetURL(tt *testing.T) {
	var zeroValue string
	b := &BrandingFont{URL: &zeroValue}
	b.GetURL()
	b = &BrandingFont{}
	b.GetURL()
	b = nil
	b.GetURL()
}

func TestBrandingFont_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &BrandingFont{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestBrandingPageBackgroundGradient_GetAngleDegree(tt *testing.T) {
	var zeroValue int
	b := &BrandingPageBackgroundGradient{AngleDegree: &zeroValue}
	b.GetAngleDegree()
	b = &BrandingPageBackgroundGradient{}
	b.GetAngleDegree()
	b = nil
	b.GetAngleDegree()
}

func TestBrandingPageBackgroundGradient_GetEnd(tt *testing.T) {
	var zeroValue string
	b := &BrandingPageBackgroundGradient{End: &zeroValue}
	b.GetEnd()
	b = &BrandingPageBackgroundGradient{}
	b.GetEnd()
	b = nil
	b.GetEnd()
}

func TestBrandingPageBackgroundGradient_GetStart(tt *testing.T) {
	var zeroValue string
	b := &BrandingPageBackgroundGradient{Start: &zeroValue}
	b.GetStart()
	b = &BrandingPageBackgroundGradient{}
	b.GetStart()
	b = nil
	b.GetStart()
}

func TestBrandingPageBackgroundGradient_GetType(tt *testing.T) {
	var zeroValue string
	b := &BrandingPageBackgroundGradient{Type: &zeroValue}
	b.GetType()
	b = &BrandingPageBackgroundGradient{}
	b.GetType()
	b = nil
	b.GetType()
}

func TestBrandingPageBackgroundGradient_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &BrandingPageBackgroundGradient{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestBrandingPhoneNotificationTemplate_GetChannel(tt *testing.T) {
	var zeroValue string
	b := &BrandingPhoneNotificationTemplate{Channel: &zeroValue}
	b.GetChannel()
	b = &BrandingPhoneNotificationTemplate{}
	b.GetChannel()
	b = nil
	b.GetChannel()
}

func TestBrandingPhoneNotificationTemplate_GetContent(tt *testing.T) {
	b := &BrandingPhoneNotificationTemplate{}
	b.GetContent()
	b = nil
	b.GetContent()
}

func TestBrandingPhoneNotificationTemplate_GetCustomizable(tt *testing.T) {
	var zeroValue bool
	b := &BrandingPhoneNotificationTemplate{Customizable: &zeroValue}
	b.GetCustomizable()
	b = &BrandingPhoneNotificationTemplate{}
	b.GetCustomizable()
	b = nil
	b.GetCustomizable()
}

func TestBrandingPhoneNotificationTemplate_GetDisabled(tt *testing.T) {
	var zeroValue bool
	b := &BrandingPhoneNotificationTemplate{Disabled: &zeroValue}
	b.GetDisabled()
	b = &BrandingPhoneNotificationTemplate{}
	b.GetDisabled()
	b = nil
	b.GetDisabled()
}

func TestBrandingPhoneNotificationTemplate_GetID(tt *testing.T) {
	var zeroValue string
	b := &BrandingPhoneNotificationTemplate{ID: &zeroValue}
	b.GetID()
	b = &BrandingPhoneNotificationTemplate{}
	b.GetID()
	b = nil
	b.GetID()
}

func TestBrandingPhoneNotificationTemplate_GetTenant(tt *testing.T) {
	var zeroValue string
	b := &BrandingPhoneNotificationTemplate{Tenant: &zeroValue}
	b.GetTenant()
	b = &BrandingPhoneNotificationTemplate{}
	b.GetTenant()
	b = nil
	b.GetTenant()
}

func TestBrandingPhoneNotificationTemplate_GetType(tt *testing.T) {
	var zeroValue string
	b := &BrandingPhoneNotificationTemplate{Type: &zeroValue}
	b.GetType()
	b = &BrandingPhoneNotificationTemplate{}
	b.GetType()
	b = nil
	b.GetType()
}

func TestBrandingPhoneNotificationTemplate_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &BrandingPhoneNotificationTemplate{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestBrandingPhoneNotificationTemplateContent_GetBody(tt *testing.T) {
	b := &BrandingPhoneNotificationTemplateContent{}
	b.GetBody()
	b = nil
	b.GetBody()
}

func TestBrandingPhoneNotificationTemplateContent_GetFrom(tt *testing.T) {
	var zeroValue string
	b := &BrandingPhoneNotificationTemplateContent{From: &zeroValue}
	b.GetFrom()
	b = &BrandingPhoneNotificationTemplateContent{}
	b.GetFrom()
	b = nil
	b.GetFrom()
}

func TestBrandingPhoneNotificationTemplateContent_GetSyntax(tt *testing.T) {
	var zeroValue string
	b := &BrandingPhoneNotificationTemplateContent{Syntax: &zeroValue}
	b.GetSyntax()
	b = &BrandingPhoneNotificationTemplateContent{}
	b.GetSyntax()
	b = nil
	b.GetSyntax()
}

func TestBrandingPhoneNotificationTemplateContent_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &BrandingPhoneNotificationTemplateContent{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestBrandingPhoneNotificationTemplateContentBody_GetText(tt *testing.T) {
	var zeroValue string
	b := &BrandingPhoneNotificationTemplateContentBody{Text: &zeroValue}
	b.GetText()
	b = &BrandingPhoneNotificationTemplateContentBody{}
	b.GetText()
	b = nil
	b.GetText()
}

func TestBrandingPhoneNotificationTemplateContentBody_GetVoice(tt *testing.T) {
	var zeroValue string
	b := &BrandingPhoneNotificationTemplateContentBody{Voice: &zeroValue}
	b.GetVoice()
	b = &BrandingPhoneNotificationTemplateContentBody{}
	b.GetVoice()
	b = nil
	b.GetVoice()
}

func TestBrandingPhoneNotificationTemplateContentBody_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &BrandingPhoneNotificationTemplateContentBody{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestBrandingPhoneNotificationTemplateList_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &BrandingPhoneNotificationTemplateList{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestBrandingPhoneProvider_GetChannel(tt *testing.T) {
	var zeroValue string
	b := &BrandingPhoneProvider{Channel: &zeroValue}
	b.GetChannel()
	b = &BrandingPhoneProvider{}
	b.GetChannel()
	b = nil
	b.GetChannel()
}

func TestBrandingPhoneProvider_GetConfiguration(tt *testing.T) {
	b := &BrandingPhoneProvider{}
	b.GetConfiguration()
	b = nil
	b.GetConfiguration()
}

func TestBrandingPhoneProvider_GetCredentials(tt *testing.T) {
	b := &BrandingPhoneProvider{}
	b.GetCredentials()
	b = nil
	b.GetCredentials()
}

func TestBrandingPhoneProvider_GetDisabled(tt *testing.T) {
	var zeroValue bool
	b := &BrandingPhoneProvider{Disabled: &zeroValue}
	b.GetDisabled()
	b = &BrandingPhoneProvider{}
	b.GetDisabled()
	b = nil
	b.GetDisabled()
}

func TestBrandingPhoneProvider_GetID(tt *testing.T) {
	var zeroValue string
	b := &BrandingPhoneProvider{ID: &zeroValue}
	b.GetID()
	b = &BrandingPhoneProvider{}
	b.GetID()
	b = nil
	b.GetID()
}

func TestBrandingPhoneProvider_GetName(tt *testing.T) {
	var zeroValue string
	b := &BrandingPhoneProvider{Name: &zeroValue}
	b.GetName()
	b = &BrandingPhoneProvider{}
	b.GetName()
	b = nil
	b.GetName()
}

func TestBrandingPhoneProvider_GetTenant(tt *testing.T) {
	var zeroValue string
	b := &BrandingPhoneProvider{Tenant: &zeroValue}
	b.GetTenant()
	b = &BrandingPhoneProvider{}
	b.GetTenant()
	b = nil
	b.GetTenant()
}

func TestBrandingPhoneProvider_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &BrandingPhoneProvider{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestBrandingPhoneProviderConfiguration_GetDefaultFrom(tt *testing.T) {
	var zeroValue string
	b := &BrandingPhoneProviderConfiguration{DefaultFrom: &zeroValue}
	b.GetDefaultFrom()
	b = &BrandingPhoneProviderConfiguration{}
	b.GetDefaultFrom()
	b = nil
	b.GetDefaultFrom()
}

func TestBrandingPhoneProviderConfiguration_GetDeliveryMethods(tt *testing.T) {
	var zeroValue []string
	b := &BrandingPhoneProviderConfiguration{DeliveryMethods: &zeroValue}
	b.GetDeliveryMethods()
	b = &BrandingPhoneProviderConfiguration{}
	b.GetDeliveryMethods()
	b = nil
	b.GetDeliveryMethods()
}

func TestBrandingPhoneProviderConfiguration_GetMSSID(tt *testing.T) {
	var zeroValue string
	b := &BrandingPhoneProviderConfiguration{MSSID: &zeroValue}
	b.GetMSSID()
	b = &BrandingPhoneProviderConfiguration{}
	b.GetMSSID()
	b = nil
	b.GetMSSID()
}

func TestBrandingPhoneProviderConfiguration_GetSID(tt *testing.T) {
	var zeroValue string
	b := &BrandingPhoneProviderConfiguration{SID: &zeroValue}
	b.GetSID()
	b = &BrandingPhoneProviderConfiguration{}
	b.GetSID()
	b = nil
	b.GetSID()
}

func TestBrandingPhoneProviderConfiguration_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &BrandingPhoneProviderConfiguration{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestBrandingPhoneProviderCredential_GetAuthToken(tt *testing.T) {
	var zeroValue string
	b := &BrandingPhoneProviderCredential{AuthToken: &zeroValue}
	b.GetAuthToken()
	b = &BrandingPhoneProviderCredential{}
	b.GetAuthToken()
	b = nil
	b.GetAuthToken()
}

func TestBrandingPhoneProviderCredential_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &BrandingPhoneProviderCredential{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestBrandingPhoneProviderList_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &BrandingPhoneProviderList{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestBrandingTheme_GetDisplayName(tt *testing.T) {
	var zeroValue string
	b := &BrandingTheme{DisplayName: &zeroValue}
	b.GetDisplayName()
	b = &BrandingTheme{}
	b.GetDisplayName()
	b = nil
	b.GetDisplayName()
}

func TestBrandingTheme_GetID(tt *testing.T) {
	var zeroValue string
	b := &BrandingTheme{ID: &zeroValue}
	b.GetID()
	b = &BrandingTheme{}
	b.GetID()
	b = nil
	b.GetID()
}

func TestBrandingTheme_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &BrandingTheme{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestBrandingThemeBorders_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &BrandingThemeBorders{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestBrandingThemeColors_GetBaseFocusColor(tt *testing.T) {
	var zeroValue string
	b := &BrandingThemeColors{BaseFocusColor: &zeroValue}
	b.GetBaseFocusColor()
	b = &BrandingThemeColors{}
	b.GetBaseFocusColor()
	b = nil
	b.GetBaseFocusColor()
}

func TestBrandingThemeColors_GetBaseHoverColor(tt *testing.T) {
	var zeroValue string
	b := &BrandingThemeColors{BaseHoverColor: &zeroValue}
	b.GetBaseHoverColor()
	b = &BrandingThemeColors{}
	b.GetBaseHoverColor()
	b = nil
	b.GetBaseHoverColor()
}

func TestBrandingThemeColors_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &BrandingThemeColors{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestBrandingThemeFonts_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &BrandingThemeFonts{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestBrandingThemePageBackground_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &BrandingThemePageBackground{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestBrandingThemeText_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &BrandingThemeText{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestBrandingThemeWidget_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &BrandingThemeWidget{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestBrandingTryPhoneNotificationTemplate_GetDeliveryMethod(tt *testing.T) {
	var zeroValue string
	b := &BrandingTryPhoneNotificationTemplate{DeliveryMethod: &zeroValue}
	b.GetDeliveryMethod()
	b = &BrandingTryPhoneNotificationTemplate{}
	b.GetDeliveryMethod()
	b = nil
	b.GetDeliveryMethod()
}

func TestBrandingTryPhoneNotificationTemplate_GetMessage(tt *testing.T) {
	var zeroValue string
	b := &BrandingTryPhoneNotificationTemplate{Message: &zeroValue}
	b.GetMessage()
	b = &BrandingTryPhoneNotificationTemplate{}
	b.GetMessage()
	b = nil
	b.GetMessage()
}

func TestBrandingTryPhoneNotificationTemplate_GetTo(tt *testing.T) {
	var zeroValue string
	b := &BrandingTryPhoneNotificationTemplate{To: &zeroValue}
	b.GetTo()
	b = &BrandingTryPhoneNotificationTemplate{}
	b.GetTo()
	b = nil
	b.GetTo()
}

func TestBrandingTryPhoneNotificationTemplate_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &BrandingTryPhoneNotificationTemplate{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestBrandingTryPhoneProvider_GetCode(tt *testing.T) {
	var zeroValue int
	b := &BrandingTryPhoneProvider{Code: &zeroValue}
	b.GetCode()
	b = &BrandingTryPhoneProvider{}
	b.GetCode()
	b = nil
	b.GetCode()
}

func TestBrandingTryPhoneProvider_GetDeliveryMethod(tt *testing.T) {
	var zeroValue string
	b := &BrandingTryPhoneProvider{DeliveryMethod: &zeroValue}
	b.GetDeliveryMethod()
	b = &BrandingTryPhoneProvider{}
	b.GetDeliveryMethod()
	b = nil
	b.GetDeliveryMethod()
}

func TestBrandingTryPhoneProvider_GetMessage(tt *testing.T) {
	var zeroValue string
	b := &BrandingTryPhoneProvider{Message: &zeroValue}
	b.GetMessage()
	b = &BrandingTryPhoneProvider{}
	b.GetMessage()
	b = nil
	b.GetMessage()
}

func TestBrandingTryPhoneProvider_GetTo(tt *testing.T) {
	var zeroValue string
	b := &BrandingTryPhoneProvider{To: &zeroValue}
	b.GetTo()
	b = &BrandingTryPhoneProvider{}
	b.GetTo()
	b = nil
	b.GetTo()
}

func TestBrandingTryPhoneProvider_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &BrandingTryPhoneProvider{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestBrandingUniversalLogin_GetBody(tt *testing.T) {
	var zeroValue string
	b := &BrandingUniversalLogin{Body: &zeroValue}
	b.GetBody()
	b = &BrandingUniversalLogin{}
	b.GetBody()
	b = nil
	b.GetBody()
}

func TestBrandingUniversalLogin_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &BrandingUniversalLogin{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestBreachedPasswordDetection_GetAdminNotificationFrequency(tt *testing.T) {
	var zeroValue []string
	b := &BreachedPasswordDetection{AdminNotificationFrequency: &zeroValue}
	b.GetAdminNotificationFrequency()
	b = &BreachedPasswordDetection{}
	b.GetAdminNotificationFrequency()
	b = nil
	b.GetAdminNotificationFrequency()
}

func TestBreachedPasswordDetection_GetEnabled(tt *testing.T) {
	var zeroValue bool
	b := &BreachedPasswordDetection{Enabled: &zeroValue}
	b.GetEnabled()
	b = &BreachedPasswordDetection{}
	b.GetEnabled()
	b = nil
	b.GetEnabled()
}

func TestBreachedPasswordDetection_GetMethod(tt *testing.T) {
	var zeroValue string
	b := &BreachedPasswordDetection{Method: &zeroValue}
	b.GetMethod()
	b = &BreachedPasswordDetection{}
	b.GetMethod()
	b = nil
	b.GetMethod()
}

func TestBreachedPasswordDetection_GetShields(tt *testing.T) {
	var zeroValue []string
	b := &BreachedPasswordDetection{Shields: &zeroValue}
	b.GetShields()
	b = &BreachedPasswordDetection{}
	b.GetShields()
	b = nil
	b.GetShields()
}

func TestBreachedPasswordDetection_GetStage(tt *testing.T) {
	b := &BreachedPasswordDetection{}
	b.GetStage()
	b = nil
	b.GetStage()
}

func TestBreachedPasswordDetection_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &BreachedPasswordDetection{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestBreachedPasswordDetectionPreChangePassword_GetShields(tt *testing.T) {
	var zeroValue []string
	b := &BreachedPasswordDetectionPreChangePassword{Shields: &zeroValue}
	b.GetShields()
	b = &BreachedPasswordDetectionPreChangePassword{}
	b.GetShields()
	b = nil
	b.GetShields()
}

func TestBreachedPasswordDetectionPreChangePassword_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &BreachedPasswordDetectionPreChangePassword{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestBreachedPasswordDetectionPreUserRegistration_GetShields(tt *testing.T) {
	var zeroValue []string
	b := &BreachedPasswordDetectionPreUserRegistration{Shields: &zeroValue}
	b.GetShields()
	b = &BreachedPasswordDetectionPreUserRegistration{}
	b.GetShields()
	b = nil
	b.GetShields()
}

func TestBreachedPasswordDetectionPreUserRegistration_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &BreachedPasswordDetectionPreUserRegistration{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestBreachedPasswordDetectionStage_GetPreChangePassword(tt *testing.T) {
	b := &BreachedPasswordDetectionStage{}
	b.GetPreChangePassword()
	b = nil
	b.GetPreChangePassword()
}

func TestBreachedPasswordDetectionStage_GetPreUserRegistration(tt *testing.T) {
	b := &BreachedPasswordDetectionStage{}
	b.GetPreUserRegistration()
	b = nil
	b.GetPreUserRegistration()
}

func TestBreachedPasswordDetectionStage_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &BreachedPasswordDetectionStage{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestBruteForceProtection_GetAllowList(tt *testing.T) {
	var zeroValue []string
	b := &BruteForceProtection{AllowList: &zeroValue}
	b.GetAllowList()
	b = &BruteForceProtection{}
	b.GetAllowList()
	b = nil
	b.GetAllowList()
}

func TestBruteForceProtection_GetEnabled(tt *testing.T) {
	var zeroValue bool
	b := &BruteForceProtection{Enabled: &zeroValue}
	b.GetEnabled()
	b = &BruteForceProtection{}
	b.GetEnabled()
	b = nil
	b.GetEnabled()
}

func TestBruteForceProtection_GetMaxAttempts(tt *testing.T) {
	var zeroValue int
	b := &BruteForceProtection{MaxAttempts: &zeroValue}
	b.GetMaxAttempts()
	b = &BruteForceProtection{}
	b.GetMaxAttempts()
	b = nil
	b.GetMaxAttempts()
}

func TestBruteForceProtection_GetMode(tt *testing.T) {
	var zeroValue string
	b := &BruteForceProtection{Mode: &zeroValue}
	b.GetMode()
	b = &BruteForceProtection{}
	b.GetMode()
	b = nil
	b.GetMode()
}

func TestBruteForceProtection_GetShields(tt *testing.T) {
	var zeroValue []string
	b := &BruteForceProtection{Shields: &zeroValue}
	b.GetShields()
	b = &BruteForceProtection{}
	b.GetShields()
	b = nil
	b.GetShields()
}

func TestBruteForceProtection_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &BruteForceProtection{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestClient_GetAddons(tt *testing.T) {
	c := &Client{}
	c.GetAddons()
	c = nil
	c.GetAddons()
}

func TestClient_GetAllowedClients(tt *testing.T) {
	var zeroValue []string
	c := &Client{AllowedClients: &zeroValue}
	c.GetAllowedClients()
	c = &Client{}
	c.GetAllowedClients()
	c = nil
	c.GetAllowedClients()
}

func TestClient_GetAllowedLogoutURLs(tt *testing.T) {
	var zeroValue []string
	c := &Client{AllowedLogoutURLs: &zeroValue}
	c.GetAllowedLogoutURLs()
	c = &Client{}
	c.GetAllowedLogoutURLs()
	c = nil
	c.GetAllowedLogoutURLs()
}

func TestClient_GetAllowedOrigins(tt *testing.T) {
	var zeroValue []string
	c := &Client{AllowedOrigins: &zeroValue}
	c.GetAllowedOrigins()
	c = &Client{}
	c.GetAllowedOrigins()
	c = nil
	c.GetAllowedOrigins()
}

func TestClient_GetAppType(tt *testing.T) {
	var zeroValue string
	c := &Client{AppType: &zeroValue}
	c.GetAppType()
	c = &Client{}
	c.GetAppType()
	c = nil
	c.GetAppType()
}

func TestClient_GetCallbacks(tt *testing.T) {
	var zeroValue []string
	c := &Client{Callbacks: &zeroValue}
	c.GetCallbacks()
	c = &Client{}
	c.GetCallbacks()
	c = nil
	c.GetCallbacks()
}

func TestClient_GetClientAliases(tt *testing.T) {
	var zeroValue []string
	c := &Client{ClientAliases: &zeroValue}
	c.GetClientAliases()
	c = &Client{}
	c.GetClientAliases()
	c = nil
	c.GetClientAliases()
}

func TestClient_GetClientAuthenticationMethods(tt *testing.T) {
	c := &Client{}
	c.GetClientAuthenticationMethods()
	c = nil
	c.GetClientAuthenticationMethods()
}

func TestClient_GetClientID(tt *testing.T) {
	var zeroValue string
	c := &Client{ClientID: &zeroValue}
	c.GetClientID()
	c = &Client{}
	c.GetClientID()
	c = nil
	c.GetClientID()
}

func TestClient_GetClientMetadata(tt *testing.T) {
	var zeroValue map[string]interface{}
	c := &Client{ClientMetadata: &zeroValue}
	c.GetClientMetadata()
	c = &Client{}
	c.GetClientMetadata()
	c = nil
	c.GetClientMetadata()
}

func TestClient_GetClientSecret(tt *testing.T) {
	var zeroValue string
	c := &Client{ClientSecret: &zeroValue}
	c.GetClientSecret()
	c = &Client{}
	c.GetClientSecret()
	c = nil
	c.GetClientSecret()
}

func TestClient_GetComplianceLevel(tt *testing.T) {
	var zeroValue string
	c := &Client{ComplianceLevel: &zeroValue}
	c.GetComplianceLevel()
	c = &Client{}
	c.GetComplianceLevel()
	c = nil
	c.GetComplianceLevel()
}

func TestClient_GetCrossOriginAuth(tt *testing.T) {
	var zeroValue bool
	c := &Client{CrossOriginAuth: &zeroValue}
	c.GetCrossOriginAuth()
	c = &Client{}
	c.GetCrossOriginAuth()
	c = nil
	c.GetCrossOriginAuth()
}

func TestClient_GetCrossOriginLocation(tt *testing.T) {
	var zeroValue string
	c := &Client{CrossOriginLocation: &zeroValue}
	c.GetCrossOriginLocation()
	c = &Client{}
	c.GetCrossOriginLocation()
	c = nil
	c.GetCrossOriginLocation()
}

func TestClient_GetCustomLoginPage(tt *testing.T) {
	var zeroValue string
	c := &Client{CustomLoginPage: &zeroValue}
	c.GetCustomLoginPage()
	c = &Client{}
	c.GetCustomLoginPage()
	c = nil
	c.GetCustomLoginPage()
}

func TestClient_GetCustomLoginPageOn(tt *testing.T) {
	var zeroValue bool
	c := &Client{CustomLoginPageOn: &zeroValue}
	c.GetCustomLoginPageOn()
	c = &Client{}
	c.GetCustomLoginPageOn()
	c = nil
	c.GetCustomLoginPageOn()
}

func TestClient_GetCustomLoginPagePreview(tt *testing.T) {
	var zeroValue string
	c := &Client{CustomLoginPagePreview: &zeroValue}
	c.GetCustomLoginPagePreview()
	c = &Client{}
	c.GetCustomLoginPagePreview()
	c = nil
	c.GetCustomLoginPagePreview()
}

func TestClient_GetDefaultOrganization(tt *testing.T) {
	c := &Client{}
	c.GetDefaultOrganization()
	c = nil
	c.GetDefaultOrganization()
}

func TestClient_GetDescription(tt *testing.T) {
	var zeroValue string
	c := &Client{Description: &zeroValue}
	c.GetDescription()
	c = &Client{}
	c.GetDescription()
	c = nil
	c.GetDescription()
}

func TestClient_GetEncryptionKey(tt *testing.T) {
	var zeroValue map[string]string
	c := &Client{EncryptionKey: &zeroValue}
	c.GetEncryptionKey()
	c = &Client{}
	c.GetEncryptionKey()
	c = nil
	c.GetEncryptionKey()
}

func TestClient_GetFormTemplate(tt *testing.T) {
	var zeroValue string
	c := &Client{FormTemplate: &zeroValue}
	c.GetFormTemplate()
	c = &Client{}
	c.GetFormTemplate()
	c = nil
	c.GetFormTemplate()
}

func TestClient_GetGrantTypes(tt *testing.T) {
	var zeroValue []string
	c := &Client{GrantTypes: &zeroValue}
	c.GetGrantTypes()
	c = &Client{}
	c.GetGrantTypes()
	c = nil
	c.GetGrantTypes()
}

func TestClient_GetInitiateLoginURI(tt *testing.T) {
	var zeroValue string
	c := &Client{InitiateLoginURI: &zeroValue}
	c.GetInitiateLoginURI()
	c = &Client{}
	c.GetInitiateLoginURI()
	c = nil
	c.GetInitiateLoginURI()
}

func TestClient_GetIsFirstParty(tt *testing.T) {
	var zeroValue bool
	c := &Client{IsFirstParty: &zeroValue}
	c.GetIsFirstParty()
	c = &Client{}
	c.GetIsFirstParty()
	c = nil
	c.GetIsFirstParty()
}

func TestClient_GetIsTokenEndpointIPHeaderTrusted(tt *testing.T) {
	var zeroValue bool
	c := &Client{IsTokenEndpointIPHeaderTrusted: &zeroValue}
	c.GetIsTokenEndpointIPHeaderTrusted()
	c = &Client{}
	c.GetIsTokenEndpointIPHeaderTrusted()
	c = nil
	c.GetIsTokenEndpointIPHeaderTrusted()
}

func TestClient_GetJWTConfiguration(tt *testing.T) {
	c := &Client{}
	c.GetJWTConfiguration()
	c = nil
	c.GetJWTConfiguration()
}

func TestClient_GetLogoURI(tt *testing.T) {
	var zeroValue string
	c := &Client{LogoURI: &zeroValue}
	c.GetLogoURI()
	c = &Client{}
	c.GetLogoURI()
	c = nil
	c.GetLogoURI()
}

func TestClient_GetMobile(tt *testing.T) {
	c := &Client{}
	c.GetMobile()
	c = nil
	c.GetMobile()
}

func TestClient_GetName(tt *testing.T) {
	var zeroValue string
	c := &Client{Name: &zeroValue}
	c.GetName()
	c = &Client{}
	c.GetName()
	c = nil
	c.GetName()
}

func TestClient_GetNativeSocialLogin(tt *testing.T) {
	c := &Client{}
	c.GetNativeSocialLogin()
	c = nil
	c.GetNativeSocialLogin()
}

func TestClient_GetOIDCBackchannelLogout(tt *testing.T) {
	c := &Client{}
	c.GetOIDCBackchannelLogout()
	c = nil
	c.GetOIDCBackchannelLogout()
}

func TestClient_GetOIDCConformant(tt *testing.T) {
	var zeroValue bool
	c := &Client{OIDCConformant: &zeroValue}
	c.GetOIDCConformant()
	c = &Client{}
	c.GetOIDCConformant()
	c = nil
	c.GetOIDCConformant()
}

func TestClient_GetOIDCLogout(tt *testing.T) {
	c := &Client{}
	c.GetOIDCLogout()
	c = nil
	c.GetOIDCLogout()
}

func TestClient_GetOrganizationRequireBehavior(tt *testing.T) {
	var zeroValue string
	c := &Client{OrganizationRequireBehavior: &zeroValue}
	c.GetOrganizationRequireBehavior()
	c = &Client{}
	c.GetOrganizationRequireBehavior()
	c = nil
	c.GetOrganizationRequireBehavior()
}

func TestClient_GetOrganizationUsage(tt *testing.T) {
	var zeroValue string
	c := &Client{OrganizationUsage: &zeroValue}
	c.GetOrganizationUsage()
	c = &Client{}
	c.GetOrganizationUsage()
	c = nil
	c.GetOrganizationUsage()
}

func TestClient_GetRefreshToken(tt *testing.T) {
	c := &Client{}
	c.GetRefreshToken()
	c = nil
	c.GetRefreshToken()
}

func TestClient_GetRequireProofOfPossession(tt *testing.T) {
	var zeroValue bool
	c := &Client{RequireProofOfPossession: &zeroValue}
	c.GetRequireProofOfPossession()
	c = &Client{}
	c.GetRequireProofOfPossession()
	c = nil
	c.GetRequireProofOfPossession()
}

func TestClient_GetRequirePushedAuthorizationRequests(tt *testing.T) {
	var zeroValue bool
	c := &Client{RequirePushedAuthorizationRequests: &zeroValue}
	c.GetRequirePushedAuthorizationRequests()
	c = &Client{}
	c.GetRequirePushedAuthorizationRequests()
	c = nil
	c.GetRequirePushedAuthorizationRequests()
}

func TestClient_GetSignedRequestObject(tt *testing.T) {
	c := &Client{}
	c.GetSignedRequestObject()
	c = nil
	c.GetSignedRequestObject()
}

func TestClient_GetSSO(tt *testing.T) {
	var zeroValue bool
	c := &Client{SSO: &zeroValue}
	c.GetSSO()
	c = &Client{}
	c.GetSSO()
	c = nil
	c.GetSSO()
}

func TestClient_GetSSODisabled(tt *testing.T) {
	var zeroValue bool
	c := &Client{SSODisabled: &zeroValue}
	c.GetSSODisabled()
	c = &Client{}
	c.GetSSODisabled()
	c = nil
	c.GetSSODisabled()
}

func TestClient_GetTokenEndpointAuthMethod(tt *testing.T) {
	var zeroValue string
	c := &Client{TokenEndpointAuthMethod: &zeroValue}
	c.GetTokenEndpointAuthMethod()
	c = &Client{}
	c.GetTokenEndpointAuthMethod()
	c = nil
	c.GetTokenEndpointAuthMethod()
}

func TestClient_GetTokenExchange(tt *testing.T) {
	c := &Client{}
	c.GetTokenExchange()
	c = nil
	c.GetTokenExchange()
}

func TestClient_GetWebOrigins(tt *testing.T) {
	var zeroValue []string
	c := &Client{WebOrigins: &zeroValue}
	c.GetWebOrigins()
	c = &Client{}
	c.GetWebOrigins()
	c = nil
	c.GetWebOrigins()
}

func TestClient_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &Client{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestClientAddons_GetAWS(tt *testing.T) {
	c := &ClientAddons{}
	c.GetAWS()
	c = nil
	c.GetAWS()
}

func TestClientAddons_GetAzureBlob(tt *testing.T) {
	c := &ClientAddons{}
	c.GetAzureBlob()
	c = nil
	c.GetAzureBlob()
}

func TestClientAddons_GetAzureSB(tt *testing.T) {
	c := &ClientAddons{}
	c.GetAzureSB()
	c = nil
	c.GetAzureSB()
}

func TestClientAddons_GetBox(tt *testing.T) {
	c := &ClientAddons{}
	c.GetBox()
	c = nil
	c.GetBox()
}

func TestClientAddons_GetCloudBees(tt *testing.T) {
	c := &ClientAddons{}
	c.GetCloudBees()
	c = nil
	c.GetCloudBees()
}

func TestClientAddons_GetConcur(tt *testing.T) {
	c := &ClientAddons{}
	c.GetConcur()
	c = nil
	c.GetConcur()
}

func TestClientAddons_GetDropbox(tt *testing.T) {
	c := &ClientAddons{}
	c.GetDropbox()
	c = nil
	c.GetDropbox()
}

func TestClientAddons_GetEchoSign(tt *testing.T) {
	c := &ClientAddons{}
	c.GetEchoSign()
	c = nil
	c.GetEchoSign()
}

func TestClientAddons_GetEgnyte(tt *testing.T) {
	c := &ClientAddons{}
	c.GetEgnyte()
	c = nil
	c.GetEgnyte()
}

func TestClientAddons_GetFirebase(tt *testing.T) {
	c := &ClientAddons{}
	c.GetFirebase()
	c = nil
	c.GetFirebase()
}

func TestClientAddons_GetLayer(tt *testing.T) {
	c := &ClientAddons{}
	c.GetLayer()
	c = nil
	c.GetLayer()
}

func TestClientAddons_GetMSCRM(tt *testing.T) {
	c := &ClientAddons{}
	c.GetMSCRM()
	c = nil
	c.GetMSCRM()
}

func TestClientAddons_GetNewRelic(tt *testing.T) {
	c := &ClientAddons{}
	c.GetNewRelic()
	c = nil
	c.GetNewRelic()
}

func TestClientAddons_GetOffice365(tt *testing.T) {
	c := &ClientAddons{}
	c.GetOffice365()
	c = nil
	c.GetOffice365()
}

func TestClientAddons_GetRMS(tt *testing.T) {
	c := &ClientAddons{}
	c.GetRMS()
	c = nil
	c.GetRMS()
}

func TestClientAddons_GetSalesforce(tt *testing.T) {
	c := &ClientAddons{}
	c.GetSalesforce()
	c = nil
	c.GetSalesforce()
}

func TestClientAddons_GetSalesforceAPI(tt *testing.T) {
	c := &ClientAddons{}
	c.GetSalesforceAPI()
	c = nil
	c.GetSalesforceAPI()
}

func TestClientAddons_GetSalesforceSandboxAPI(tt *testing.T) {
	c := &ClientAddons{}
	c.GetSalesforceSandboxAPI()
	c = nil
	c.GetSalesforceSandboxAPI()
}

func TestClientAddons_GetSAML2(tt *testing.T) {
	c := &ClientAddons{}
	c.GetSAML2()
	c = nil
	c.GetSAML2()
}

func TestClientAddons_GetSAPAPI(tt *testing.T) {
	c := &ClientAddons{}
	c.GetSAPAPI()
	c = nil
	c.GetSAPAPI()
}

func TestClientAddons_GetSentry(tt *testing.T) {
	c := &ClientAddons{}
	c.GetSentry()
	c = nil
	c.GetSentry()
}

func TestClientAddons_GetSharePoint(tt *testing.T) {
	c := &ClientAddons{}
	c.GetSharePoint()
	c = nil
	c.GetSharePoint()
}

func TestClientAddons_GetSlack(tt *testing.T) {
	c := &ClientAddons{}
	c.GetSlack()
	c = nil
	c.GetSlack()
}

func TestClientAddons_GetSpringCM(tt *testing.T) {
	c := &ClientAddons{}
	c.GetSpringCM()
	c = nil
	c.GetSpringCM()
}

func TestClientAddons_GetSSOIntegration(tt *testing.T) {
	c := &ClientAddons{}
	c.GetSSOIntegration()
	c = nil
	c.GetSSOIntegration()
}

func TestClientAddons_GetWAMS(tt *testing.T) {
	c := &ClientAddons{}
	c.GetWAMS()
	c = nil
	c.GetWAMS()
}

func TestClientAddons_GetWSFED(tt *testing.T) {
	c := &ClientAddons{}
	c.GetWSFED()
	c = nil
	c.GetWSFED()
}

func TestClientAddons_GetZendesk(tt *testing.T) {
	c := &ClientAddons{}
	c.GetZendesk()
	c = nil
	c.GetZendesk()
}

func TestClientAddons_GetZoom(tt *testing.T) {
	c := &ClientAddons{}
	c.GetZoom()
	c = nil
	c.GetZoom()
}

func TestClientAddons_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ClientAddons{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestClientAuthenticationMethods_GetPrivateKeyJWT(tt *testing.T) {
	c := &ClientAuthenticationMethods{}
	c.GetPrivateKeyJWT()
	c = nil
	c.GetPrivateKeyJWT()
}

func TestClientAuthenticationMethods_GetSelfSignedTLSClientAuth(tt *testing.T) {
	c := &ClientAuthenticationMethods{}
	c.GetSelfSignedTLSClientAuth()
	c = nil
	c.GetSelfSignedTLSClientAuth()
}

func TestClientAuthenticationMethods_GetTLSClientAuth(tt *testing.T) {
	c := &ClientAuthenticationMethods{}
	c.GetTLSClientAuth()
	c = nil
	c.GetTLSClientAuth()
}

func TestClientAuthenticationMethods_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ClientAuthenticationMethods{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestClientDefaultOrganization_GetFlows(tt *testing.T) {
	var zeroValue []string
	c := &ClientDefaultOrganization{Flows: &zeroValue}
	c.GetFlows()
	c = &ClientDefaultOrganization{}
	c.GetFlows()
	c = nil
	c.GetFlows()
}

func TestClientDefaultOrganization_GetOrganizationID(tt *testing.T) {
	var zeroValue string
	c := &ClientDefaultOrganization{OrganizationID: &zeroValue}
	c.GetOrganizationID()
	c = &ClientDefaultOrganization{}
	c.GetOrganizationID()
	c = nil
	c.GetOrganizationID()
}

func TestClientDefaultOrganization_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ClientDefaultOrganization{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestClientGrant_GetAllowAnyOrganization(tt *testing.T) {
	var zeroValue bool
	c := &ClientGrant{AllowAnyOrganization: &zeroValue}
	c.GetAllowAnyOrganization()
	c = &ClientGrant{}
	c.GetAllowAnyOrganization()
	c = nil
	c.GetAllowAnyOrganization()
}

func TestClientGrant_GetAudience(tt *testing.T) {
	var zeroValue string
	c := &ClientGrant{Audience: &zeroValue}
	c.GetAudience()
	c = &ClientGrant{}
	c.GetAudience()
	c = nil
	c.GetAudience()
}

func TestClientGrant_GetClientID(tt *testing.T) {
	var zeroValue string
	c := &ClientGrant{ClientID: &zeroValue}
	c.GetClientID()
	c = &ClientGrant{}
	c.GetClientID()
	c = nil
	c.GetClientID()
}

func TestClientGrant_GetID(tt *testing.T) {
	var zeroValue string
	c := &ClientGrant{ID: &zeroValue}
	c.GetID()
	c = &ClientGrant{}
	c.GetID()
	c = nil
	c.GetID()
}

func TestClientGrant_GetOrganizationUsage(tt *testing.T) {
	var zeroValue string
	c := &ClientGrant{OrganizationUsage: &zeroValue}
	c.GetOrganizationUsage()
	c = &ClientGrant{}
	c.GetOrganizationUsage()
	c = nil
	c.GetOrganizationUsage()
}

func TestClientGrant_GetScope(tt *testing.T) {
	var zeroValue []string
	c := &ClientGrant{Scope: &zeroValue}
	c.GetScope()
	c = &ClientGrant{}
	c.GetScope()
	c = nil
	c.GetScope()
}

func TestClientGrant_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ClientGrant{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestClientGrantList_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ClientGrantList{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestClientJWTConfiguration_GetAlgorithm(tt *testing.T) {
	var zeroValue string
	c := &ClientJWTConfiguration{Algorithm: &zeroValue}
	c.GetAlgorithm()
	c = &ClientJWTConfiguration{}
	c.GetAlgorithm()
	c = nil
	c.GetAlgorithm()
}

func TestClientJWTConfiguration_GetLifetimeInSeconds(tt *testing.T) {
	var zeroValue int
	c := &ClientJWTConfiguration{LifetimeInSeconds: &zeroValue}
	c.GetLifetimeInSeconds()
	c = &ClientJWTConfiguration{}
	c.GetLifetimeInSeconds()
	c = nil
	c.GetLifetimeInSeconds()
}

func TestClientJWTConfiguration_GetScopes(tt *testing.T) {
	var zeroValue map[string]string
	c := &ClientJWTConfiguration{Scopes: &zeroValue}
	c.GetScopes()
	c = &ClientJWTConfiguration{}
	c.GetScopes()
	c = nil
	c.GetScopes()
}

func TestClientJWTConfiguration_GetSecretEncoded(tt *testing.T) {
	var zeroValue bool
	c := &ClientJWTConfiguration{SecretEncoded: &zeroValue}
	c.GetSecretEncoded()
	c = &ClientJWTConfiguration{}
	c.GetSecretEncoded()
	c = nil
	c.GetSecretEncoded()
}

func TestClientJWTConfiguration_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ClientJWTConfiguration{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestClientList_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ClientList{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestClientMobile_GetAndroid(tt *testing.T) {
	c := &ClientMobile{}
	c.GetAndroid()
	c = nil
	c.GetAndroid()
}

func TestClientMobile_GetIOS(tt *testing.T) {
	c := &ClientMobile{}
	c.GetIOS()
	c = nil
	c.GetIOS()
}

func TestClientMobile_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ClientMobile{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestClientMobileAndroid_GetAppPackageName(tt *testing.T) {
	var zeroValue string
	c := &ClientMobileAndroid{AppPackageName: &zeroValue}
	c.GetAppPackageName()
	c = &ClientMobileAndroid{}
	c.GetAppPackageName()
	c = nil
	c.GetAppPackageName()
}

func TestClientMobileAndroid_GetKeyHashes(tt *testing.T) {
	var zeroValue []string
	c := &ClientMobileAndroid{KeyHashes: &zeroValue}
	c.GetKeyHashes()
	c = &ClientMobileAndroid{}
	c.GetKeyHashes()
	c = nil
	c.GetKeyHashes()
}

func TestClientMobileAndroid_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ClientMobileAndroid{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestClientMobileIOS_GetAppID(tt *testing.T) {
	var zeroValue string
	c := &ClientMobileIOS{AppID: &zeroValue}
	c.GetAppID()
	c = &ClientMobileIOS{}
	c.GetAppID()
	c = nil
	c.GetAppID()
}

func TestClientMobileIOS_GetTeamID(tt *testing.T) {
	var zeroValue string
	c := &ClientMobileIOS{TeamID: &zeroValue}
	c.GetTeamID()
	c = &ClientMobileIOS{}
	c.GetTeamID()
	c = nil
	c.GetTeamID()
}

func TestClientMobileIOS_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ClientMobileIOS{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestClientNativeSocialLogin_GetApple(tt *testing.T) {
	c := &ClientNativeSocialLogin{}
	c.GetApple()
	c = nil
	c.GetApple()
}

func TestClientNativeSocialLogin_GetFacebook(tt *testing.T) {
	c := &ClientNativeSocialLogin{}
	c.GetFacebook()
	c = nil
	c.GetFacebook()
}

func TestClientNativeSocialLogin_GetGoogle(tt *testing.T) {
	c := &ClientNativeSocialLogin{}
	c.GetGoogle()
	c = nil
	c.GetGoogle()
}

func TestClientNativeSocialLogin_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ClientNativeSocialLogin{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestClientNativeSocialLoginSupportEnabled_GetEnabled(tt *testing.T) {
	var zeroValue bool
	c := &ClientNativeSocialLoginSupportEnabled{Enabled: &zeroValue}
	c.GetEnabled()
	c = &ClientNativeSocialLoginSupportEnabled{}
	c.GetEnabled()
	c = nil
	c.GetEnabled()
}

func TestClientNativeSocialLoginSupportEnabled_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ClientNativeSocialLoginSupportEnabled{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestClientRefreshToken_GetExpirationType(tt *testing.T) {
	var zeroValue string
	c := &ClientRefreshToken{ExpirationType: &zeroValue}
	c.GetExpirationType()
	c = &ClientRefreshToken{}
	c.GetExpirationType()
	c = nil
	c.GetExpirationType()
}

func TestClientRefreshToken_GetIdleTokenLifetime(tt *testing.T) {
	var zeroValue int
	c := &ClientRefreshToken{IdleTokenLifetime: &zeroValue}
	c.GetIdleTokenLifetime()
	c = &ClientRefreshToken{}
	c.GetIdleTokenLifetime()
	c = nil
	c.GetIdleTokenLifetime()
}

func TestClientRefreshToken_GetInfiniteIdleTokenLifetime(tt *testing.T) {
	var zeroValue bool
	c := &ClientRefreshToken{InfiniteIdleTokenLifetime: &zeroValue}
	c.GetInfiniteIdleTokenLifetime()
	c = &ClientRefreshToken{}
	c.GetInfiniteIdleTokenLifetime()
	c = nil
	c.GetInfiniteIdleTokenLifetime()
}

func TestClientRefreshToken_GetInfiniteTokenLifetime(tt *testing.T) {
	var zeroValue bool
	c := &ClientRefreshToken{InfiniteTokenLifetime: &zeroValue}
	c.GetInfiniteTokenLifetime()
	c = &ClientRefreshToken{}
	c.GetInfiniteTokenLifetime()
	c = nil
	c.GetInfiniteTokenLifetime()
}

func TestClientRefreshToken_GetLeeway(tt *testing.T) {
	var zeroValue int
	c := &ClientRefreshToken{Leeway: &zeroValue}
	c.GetLeeway()
	c = &ClientRefreshToken{}
	c.GetLeeway()
	c = nil
	c.GetLeeway()
}

func TestClientRefreshToken_GetRotationType(tt *testing.T) {
	var zeroValue string
	c := &ClientRefreshToken{RotationType: &zeroValue}
	c.GetRotationType()
	c = &ClientRefreshToken{}
	c.GetRotationType()
	c = nil
	c.GetRotationType()
}

func TestClientRefreshToken_GetTokenLifetime(tt *testing.T) {
	var zeroValue int
	c := &ClientRefreshToken{TokenLifetime: &zeroValue}
	c.GetTokenLifetime()
	c = &ClientRefreshToken{}
	c.GetTokenLifetime()
	c = nil
	c.GetTokenLifetime()
}

func TestClientRefreshToken_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ClientRefreshToken{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestClientSignedRequestObject_GetCredentials(tt *testing.T) {
	var zeroValue []Credential
	c := &ClientSignedRequestObject{Credentials: &zeroValue}
	c.GetCredentials()
	c = &ClientSignedRequestObject{}
	c.GetCredentials()
	c = nil
	c.GetCredentials()
}

func TestClientSignedRequestObject_GetRequired(tt *testing.T) {
	var zeroValue bool
	c := &ClientSignedRequestObject{Required: &zeroValue}
	c.GetRequired()
	c = &ClientSignedRequestObject{}
	c.GetRequired()
	c = nil
	c.GetRequired()
}

func TestClientSignedRequestObject_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ClientSignedRequestObject{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestClientTokenExchange_GetAllowAnyProfileOfType(tt *testing.T) {
	var zeroValue []string
	c := &ClientTokenExchange{AllowAnyProfileOfType: &zeroValue}
	c.GetAllowAnyProfileOfType()
	c = &ClientTokenExchange{}
	c.GetAllowAnyProfileOfType()
	c = nil
	c.GetAllowAnyProfileOfType()
}

func TestClientTokenExchange_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ClientTokenExchange{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestCloudBeesClientAddon_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &CloudBeesClientAddon{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestConcurClientAddon_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ConcurClientAddon{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestConnection_GetDisplayName(tt *testing.T) {
	var zeroValue string
	c := &Connection{DisplayName: &zeroValue}
	c.GetDisplayName()
	c = &Connection{}
	c.GetDisplayName()
	c = nil
	c.GetDisplayName()
}

func TestConnection_GetEnabledClients(tt *testing.T) {
	var zeroValue []string
	c := &Connection{EnabledClients: &zeroValue}
	c.GetEnabledClients()
	c = &Connection{}
	c.GetEnabledClients()
	c = nil
	c.GetEnabledClients()
}

func TestConnection_GetID(tt *testing.T) {
	var zeroValue string
	c := &Connection{ID: &zeroValue}
	c.GetID()
	c = &Connection{}
	c.GetID()
	c = nil
	c.GetID()
}

func TestConnection_GetIsDomainConnection(tt *testing.T) {
	var zeroValue bool
	c := &Connection{IsDomainConnection: &zeroValue}
	c.GetIsDomainConnection()
	c = &Connection{}
	c.GetIsDomainConnection()
	c = nil
	c.GetIsDomainConnection()
}

func TestConnection_GetMetadata(tt *testing.T) {
	var zeroValue map[string]string
	c := &Connection{Metadata: &zeroValue}
	c.GetMetadata()
	c = &Connection{}
	c.GetMetadata()
	c = nil
	c.GetMetadata()
}

func TestConnection_GetName(tt *testing.T) {
	var zeroValue string
	c := &Connection{Name: &zeroValue}
	c.GetName()
	c = &Connection{}
	c.GetName()
	c = nil
	c.GetName()
}

func TestConnection_GetProvisioningTicketURL(tt *testing.T) {
	var zeroValue string
	c := &Connection{ProvisioningTicketURL: &zeroValue}
	c.GetProvisioningTicketURL()
	c = &Connection{}
	c.GetProvisioningTicketURL()
	c = nil
	c.GetProvisioningTicketURL()
}

func TestConnection_GetRealms(tt *testing.T) {
	var zeroValue []string
	c := &Connection{Realms: &zeroValue}
	c.GetRealms()
	c = &Connection{}
	c.GetRealms()
	c = nil
	c.GetRealms()
}

func TestConnection_GetShowAsButton(tt *testing.T) {
	var zeroValue bool
	c := &Connection{ShowAsButton: &zeroValue}
	c.GetShowAsButton()
	c = &Connection{}
	c.GetShowAsButton()
	c = nil
	c.GetShowAsButton()
}

func TestConnection_GetStrategy(tt *testing.T) {
	var zeroValue string
	c := &Connection{Strategy: &zeroValue}
	c.GetStrategy()
	c = &Connection{}
	c.GetStrategy()
	c = nil
	c.GetStrategy()
}

func TestConnection_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &Connection{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestConnectionGatewayAuthentication_GetAudience(tt *testing.T) {
	var zeroValue string
	c := &ConnectionGatewayAuthentication{Audience: &zeroValue}
	c.GetAudience()
	c = &ConnectionGatewayAuthentication{}
	c.GetAudience()
	c = nil
	c.GetAudience()
}

func TestConnectionGatewayAuthentication_GetMethod(tt *testing.T) {
	var zeroValue string
	c := &ConnectionGatewayAuthentication{Method: &zeroValue}
	c.GetMethod()
	c = &ConnectionGatewayAuthentication{}
	c.GetMethod()
	c = nil
	c.GetMethod()
}

func TestConnectionGatewayAuthentication_GetSecret(tt *testing.T) {
	var zeroValue string
	c := &ConnectionGatewayAuthentication{Secret: &zeroValue}
	c.GetSecret()
	c = &ConnectionGatewayAuthentication{}
	c.GetSecret()
	c = nil
	c.GetSecret()
}

func TestConnectionGatewayAuthentication_GetSecretBase64Encoded(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionGatewayAuthentication{SecretBase64Encoded: &zeroValue}
	c.GetSecretBase64Encoded()
	c = &ConnectionGatewayAuthentication{}
	c.GetSecretBase64Encoded()
	c = nil
	c.GetSecretBase64Encoded()
}

func TestConnectionGatewayAuthentication_GetSubject(tt *testing.T) {
	var zeroValue string
	c := &ConnectionGatewayAuthentication{Subject: &zeroValue}
	c.GetSubject()
	c = &ConnectionGatewayAuthentication{}
	c.GetSubject()
	c = nil
	c.GetSubject()
}

func TestConnectionGatewayAuthentication_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ConnectionGatewayAuthentication{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestConnectionList_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ConnectionList{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestConnectionOptions_GetAttributes(tt *testing.T) {
	c := &ConnectionOptions{}
	c.GetAttributes()
	c = nil
	c.GetAttributes()
}

func TestConnectionOptions_GetAuthenticationMethods(tt *testing.T) {
	c := &ConnectionOptions{}
	c.GetAuthenticationMethods()
	c = nil
	c.GetAuthenticationMethods()
}

func TestConnectionOptions_GetBruteForceProtection(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptions{BruteForceProtection: &zeroValue}
	c.GetBruteForceProtection()
	c = &ConnectionOptions{}
	c.GetBruteForceProtection()
	c = nil
	c.GetBruteForceProtection()
}

func TestConnectionOptions_GetConfiguration(tt *testing.T) {
	var zeroValue map[string]string
	c := &ConnectionOptions{Configuration: &zeroValue}
	c.GetConfiguration()
	c = &ConnectionOptions{}
	c.GetConfiguration()
	c = nil
	c.GetConfiguration()
}

func TestConnectionOptions_GetCustomScripts(tt *testing.T) {
	var zeroValue map[string]string
	c := &ConnectionOptions{CustomScripts: &zeroValue}
	c.GetCustomScripts()
	c = &ConnectionOptions{}
	c.GetCustomScripts()
	c = nil
	c.GetCustomScripts()
}

func TestConnectionOptions_GetDisableSelfServiceChangePassword(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptions{DisableSelfServiceChangePassword: &zeroValue}
	c.GetDisableSelfServiceChangePassword()
	c = &ConnectionOptions{}
	c.GetDisableSelfServiceChangePassword()
	c = nil
	c.GetDisableSelfServiceChangePassword()
}

func TestConnectionOptions_GetDisableSignup(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptions{DisableSignup: &zeroValue}
	c.GetDisableSignup()
	c = &ConnectionOptions{}
	c.GetDisableSignup()
	c = nil
	c.GetDisableSignup()
}

func TestConnectionOptions_GetEnabledDatabaseCustomization(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptions{EnabledDatabaseCustomization: &zeroValue}
	c.GetEnabledDatabaseCustomization()
	c = &ConnectionOptions{}
	c.GetEnabledDatabaseCustomization()
	c = nil
	c.GetEnabledDatabaseCustomization()
}

func TestConnectionOptions_GetEnableScriptContext(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptions{EnableScriptContext: &zeroValue}
	c.GetEnableScriptContext()
	c = &ConnectionOptions{}
	c.GetEnableScriptContext()
	c = nil
	c.GetEnableScriptContext()
}

func TestConnectionOptions_GetImportMode(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptions{ImportMode: &zeroValue}
	c.GetImportMode()
	c = &ConnectionOptions{}
	c.GetImportMode()
	c = nil
	c.GetImportMode()
}

func TestConnectionOptions_GetMFA(tt *testing.T) {
	zeroValue := map[string]interface{}{}
	c := &ConnectionOptions{MFA: zeroValue}
	c.GetMFA()
	c = &ConnectionOptions{}
	c.GetMFA()
	c = nil
	c.GetMFA()
}

func TestConnectionOptions_GetNonPersistentAttrs(tt *testing.T) {
	var zeroValue []string
	c := &ConnectionOptions{NonPersistentAttrs: &zeroValue}
	c.GetNonPersistentAttrs()
	c = &ConnectionOptions{}
	c.GetNonPersistentAttrs()
	c = nil
	c.GetNonPersistentAttrs()
}

func TestConnectionOptions_GetPasskeyOptions(tt *testing.T) {
	c := &ConnectionOptions{}
	c.GetPasskeyOptions()
	c = nil
	c.GetPasskeyOptions()
}

func TestConnectionOptions_GetPasswordComplexityOptions(tt *testing.T) {
	zeroValue := map[string]interface{}{}
	c := &ConnectionOptions{PasswordComplexityOptions: zeroValue}
	c.GetPasswordComplexityOptions()
	c = &ConnectionOptions{}
	c.GetPasswordComplexityOptions()
	c = nil
	c.GetPasswordComplexityOptions()
}

func TestConnectionOptions_GetPasswordDictionary(tt *testing.T) {
	zeroValue := map[string]interface{}{}
	c := &ConnectionOptions{PasswordDictionary: zeroValue}
	c.GetPasswordDictionary()
	c = &ConnectionOptions{}
	c.GetPasswordDictionary()
	c = nil
	c.GetPasswordDictionary()
}

func TestConnectionOptions_GetPasswordHistory(tt *testing.T) {
	zeroValue := map[string]interface{}{}
	c := &ConnectionOptions{PasswordHistory: zeroValue}
	c.GetPasswordHistory()
	c = &ConnectionOptions{}
	c.GetPasswordHistory()
	c = nil
	c.GetPasswordHistory()
}

func TestConnectionOptions_GetPasswordNoPersonalInfo(tt *testing.T) {
	zeroValue := map[string]interface{}{}
	c := &ConnectionOptions{PasswordNoPersonalInfo: zeroValue}
	c.GetPasswordNoPersonalInfo()
	c = &ConnectionOptions{}
	c.GetPasswordNoPersonalInfo()
	c = nil
	c.GetPasswordNoPersonalInfo()
}

func TestConnectionOptions_GetPasswordPolicy(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptions{PasswordPolicy: &zeroValue}
	c.GetPasswordPolicy()
	c = &ConnectionOptions{}
	c.GetPasswordPolicy()
	c = nil
	c.GetPasswordPolicy()
}

func TestConnectionOptions_GetPrecedence(tt *testing.T) {
	var zeroValue []string
	c := &ConnectionOptions{Precedence: &zeroValue}
	c.GetPrecedence()
	c = &ConnectionOptions{}
	c.GetPrecedence()
	c = nil
	c.GetPrecedence()
}

func TestConnectionOptions_GetRequiresUsername(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptions{RequiresUsername: &zeroValue}
	c.GetRequiresUsername()
	c = &ConnectionOptions{}
	c.GetRequiresUsername()
	c = nil
	c.GetRequiresUsername()
}

func TestConnectionOptions_GetSetUserAttributes(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptions{SetUserAttributes: &zeroValue}
	c.GetSetUserAttributes()
	c = &ConnectionOptions{}
	c.GetSetUserAttributes()
	c = nil
	c.GetSetUserAttributes()
}

func TestConnectionOptions_GetStrategyVersion(tt *testing.T) {
	var zeroValue int
	c := &ConnectionOptions{StrategyVersion: &zeroValue}
	c.GetStrategyVersion()
	c = &ConnectionOptions{}
	c.GetStrategyVersion()
	c = nil
	c.GetStrategyVersion()
}

func TestConnectionOptions_GetUpstreamParams(tt *testing.T) {
	zeroValue := map[string]interface{}{}
	c := &ConnectionOptions{UpstreamParams: zeroValue}
	c.GetUpstreamParams()
	c = &ConnectionOptions{}
	c.GetUpstreamParams()
	c = nil
	c.GetUpstreamParams()
}

func TestConnectionOptions_GetValidation(tt *testing.T) {
	zeroValue := map[string]interface{}{}
	c := &ConnectionOptions{Validation: zeroValue}
	c.GetValidation()
	c = &ConnectionOptions{}
	c.GetValidation()
	c = nil
	c.GetValidation()
}

func TestConnectionOptions_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ConnectionOptions{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestConnectionOptionsAD_GetAgentIP(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsAD{AgentIP: &zeroValue}
	c.GetAgentIP()
	c = &ConnectionOptionsAD{}
	c.GetAgentIP()
	c = nil
	c.GetAgentIP()
}

func TestConnectionOptionsAD_GetAgentMode(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsAD{AgentMode: &zeroValue}
	c.GetAgentMode()
	c = &ConnectionOptionsAD{}
	c.GetAgentMode()
	c = nil
	c.GetAgentMode()
}

func TestConnectionOptionsAD_GetAgentVersion(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsAD{AgentVersion: &zeroValue}
	c.GetAgentVersion()
	c = &ConnectionOptionsAD{}
	c.GetAgentVersion()
	c = nil
	c.GetAgentVersion()
}

func TestConnectionOptionsAD_GetBruteForceProtection(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsAD{BruteForceProtection: &zeroValue}
	c.GetBruteForceProtection()
	c = &ConnectionOptionsAD{}
	c.GetBruteForceProtection()
	c = nil
	c.GetBruteForceProtection()
}

func TestConnectionOptionsAD_GetCertAuth(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsAD{CertAuth: &zeroValue}
	c.GetCertAuth()
	c = &ConnectionOptionsAD{}
	c.GetCertAuth()
	c = nil
	c.GetCertAuth()
}

func TestConnectionOptionsAD_GetCerts(tt *testing.T) {
	var zeroValue []string
	c := &ConnectionOptionsAD{Certs: &zeroValue}
	c.GetCerts()
	c = &ConnectionOptionsAD{}
	c.GetCerts()
	c = nil
	c.GetCerts()
}

func TestConnectionOptionsAD_GetDisableCache(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsAD{DisableCache: &zeroValue}
	c.GetDisableCache()
	c = &ConnectionOptionsAD{}
	c.GetDisableCache()
	c = nil
	c.GetDisableCache()
}

func TestConnectionOptionsAD_GetDisableSelfServiceChangePassword(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsAD{DisableSelfServiceChangePassword: &zeroValue}
	c.GetDisableSelfServiceChangePassword()
	c = &ConnectionOptionsAD{}
	c.GetDisableSelfServiceChangePassword()
	c = nil
	c.GetDisableSelfServiceChangePassword()
}

func TestConnectionOptionsAD_GetDomainAliases(tt *testing.T) {
	var zeroValue []string
	c := &ConnectionOptionsAD{DomainAliases: &zeroValue}
	c.GetDomainAliases()
	c = &ConnectionOptionsAD{}
	c.GetDomainAliases()
	c = nil
	c.GetDomainAliases()
}

func TestConnectionOptionsAD_GetIPs(tt *testing.T) {
	var zeroValue []string
	c := &ConnectionOptionsAD{IPs: &zeroValue}
	c.GetIPs()
	c = &ConnectionOptionsAD{}
	c.GetIPs()
	c = nil
	c.GetIPs()
}

func TestConnectionOptionsAD_GetKerberos(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsAD{Kerberos: &zeroValue}
	c.GetKerberos()
	c = &ConnectionOptionsAD{}
	c.GetKerberos()
	c = nil
	c.GetKerberos()
}

func TestConnectionOptionsAD_GetLogoURL(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsAD{LogoURL: &zeroValue}
	c.GetLogoURL()
	c = &ConnectionOptionsAD{}
	c.GetLogoURL()
	c = nil
	c.GetLogoURL()
}

func TestConnectionOptionsAD_GetNonPersistentAttrs(tt *testing.T) {
	var zeroValue []string
	c := &ConnectionOptionsAD{NonPersistentAttrs: &zeroValue}
	c.GetNonPersistentAttrs()
	c = &ConnectionOptionsAD{}
	c.GetNonPersistentAttrs()
	c = nil
	c.GetNonPersistentAttrs()
}

func TestConnectionOptionsAD_GetSetUserAttributes(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsAD{SetUserAttributes: &zeroValue}
	c.GetSetUserAttributes()
	c = &ConnectionOptionsAD{}
	c.GetSetUserAttributes()
	c = nil
	c.GetSetUserAttributes()
}

func TestConnectionOptionsAD_GetStrategyVersion(tt *testing.T) {
	var zeroValue int
	c := &ConnectionOptionsAD{StrategyVersion: &zeroValue}
	c.GetStrategyVersion()
	c = &ConnectionOptionsAD{}
	c.GetStrategyVersion()
	c = nil
	c.GetStrategyVersion()
}

func TestConnectionOptionsAD_GetTenantDomain(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsAD{TenantDomain: &zeroValue}
	c.GetTenantDomain()
	c = &ConnectionOptionsAD{}
	c.GetTenantDomain()
	c = nil
	c.GetTenantDomain()
}

func TestConnectionOptionsAD_GetThumbprints(tt *testing.T) {
	var zeroValue []string
	c := &ConnectionOptionsAD{Thumbprints: &zeroValue}
	c.GetThumbprints()
	c = &ConnectionOptionsAD{}
	c.GetThumbprints()
	c = nil
	c.GetThumbprints()
}

func TestConnectionOptionsAD_GetUpstreamParams(tt *testing.T) {
	zeroValue := map[string]interface{}{}
	c := &ConnectionOptionsAD{UpstreamParams: zeroValue}
	c.GetUpstreamParams()
	c = &ConnectionOptionsAD{}
	c.GetUpstreamParams()
	c = nil
	c.GetUpstreamParams()
}

func TestConnectionOptionsAD_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ConnectionOptionsAD{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestConnectionOptionsADFS_GetADFSServer(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsADFS{ADFSServer: &zeroValue}
	c.GetADFSServer()
	c = &ConnectionOptionsADFS{}
	c.GetADFSServer()
	c = nil
	c.GetADFSServer()
}

func TestConnectionOptionsADFS_GetCertRolloverNotification(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsADFS{CertRolloverNotification: &zeroValue}
	c.GetCertRolloverNotification()
	c = &ConnectionOptionsADFS{}
	c.GetCertRolloverNotification()
	c = nil
	c.GetCertRolloverNotification()
}

func TestConnectionOptionsADFS_GetDomainAliases(tt *testing.T) {
	var zeroValue []string
	c := &ConnectionOptionsADFS{DomainAliases: &zeroValue}
	c.GetDomainAliases()
	c = &ConnectionOptionsADFS{}
	c.GetDomainAliases()
	c = nil
	c.GetDomainAliases()
}

func TestConnectionOptionsADFS_GetEnableUsersAPI(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsADFS{EnableUsersAPI: &zeroValue}
	c.GetEnableUsersAPI()
	c = &ConnectionOptionsADFS{}
	c.GetEnableUsersAPI()
	c = nil
	c.GetEnableUsersAPI()
}

func TestConnectionOptionsADFS_GetEntityID(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsADFS{EntityID: &zeroValue}
	c.GetEntityID()
	c = &ConnectionOptionsADFS{}
	c.GetEntityID()
	c = nil
	c.GetEntityID()
}

func TestConnectionOptionsADFS_GetFedMetadataXML(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsADFS{FedMetadataXML: &zeroValue}
	c.GetFedMetadataXML()
	c = &ConnectionOptionsADFS{}
	c.GetFedMetadataXML()
	c = nil
	c.GetFedMetadataXML()
}

func TestConnectionOptionsADFS_GetLogoURL(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsADFS{LogoURL: &zeroValue}
	c.GetLogoURL()
	c = &ConnectionOptionsADFS{}
	c.GetLogoURL()
	c = nil
	c.GetLogoURL()
}

func TestConnectionOptionsADFS_GetNonPersistentAttrs(tt *testing.T) {
	var zeroValue []string
	c := &ConnectionOptionsADFS{NonPersistentAttrs: &zeroValue}
	c.GetNonPersistentAttrs()
	c = &ConnectionOptionsADFS{}
	c.GetNonPersistentAttrs()
	c = nil
	c.GetNonPersistentAttrs()
}

func TestConnectionOptionsADFS_GetPreviousThumbprints(tt *testing.T) {
	var zeroValue []string
	c := &ConnectionOptionsADFS{PreviousThumbprints: &zeroValue}
	c.GetPreviousThumbprints()
	c = &ConnectionOptionsADFS{}
	c.GetPreviousThumbprints()
	c = nil
	c.GetPreviousThumbprints()
}

func TestConnectionOptionsADFS_GetSetUserAttributes(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsADFS{SetUserAttributes: &zeroValue}
	c.GetSetUserAttributes()
	c = &ConnectionOptionsADFS{}
	c.GetSetUserAttributes()
	c = nil
	c.GetSetUserAttributes()
}

func TestConnectionOptionsADFS_GetSignInEndpoint(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsADFS{SignInEndpoint: &zeroValue}
	c.GetSignInEndpoint()
	c = &ConnectionOptionsADFS{}
	c.GetSignInEndpoint()
	c = nil
	c.GetSignInEndpoint()
}

func TestConnectionOptionsADFS_GetStrategyVersion(tt *testing.T) {
	var zeroValue int
	c := &ConnectionOptionsADFS{StrategyVersion: &zeroValue}
	c.GetStrategyVersion()
	c = &ConnectionOptionsADFS{}
	c.GetStrategyVersion()
	c = nil
	c.GetStrategyVersion()
}

func TestConnectionOptionsADFS_GetTenantDomain(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsADFS{TenantDomain: &zeroValue}
	c.GetTenantDomain()
	c = &ConnectionOptionsADFS{}
	c.GetTenantDomain()
	c = nil
	c.GetTenantDomain()
}

func TestConnectionOptionsADFS_GetThumbprints(tt *testing.T) {
	var zeroValue []string
	c := &ConnectionOptionsADFS{Thumbprints: &zeroValue}
	c.GetThumbprints()
	c = &ConnectionOptionsADFS{}
	c.GetThumbprints()
	c = nil
	c.GetThumbprints()
}

func TestConnectionOptionsADFS_GetTrustEmailVerified(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsADFS{TrustEmailVerified: &zeroValue}
	c.GetTrustEmailVerified()
	c = &ConnectionOptionsADFS{}
	c.GetTrustEmailVerified()
	c = nil
	c.GetTrustEmailVerified()
}

func TestConnectionOptionsADFS_GetUpstreamParams(tt *testing.T) {
	zeroValue := map[string]interface{}{}
	c := &ConnectionOptionsADFS{UpstreamParams: zeroValue}
	c.GetUpstreamParams()
	c = &ConnectionOptionsADFS{}
	c.GetUpstreamParams()
	c = nil
	c.GetUpstreamParams()
}

func TestConnectionOptionsADFS_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ConnectionOptionsADFS{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestConnectionOptionsApple_GetClientID(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsApple{ClientID: &zeroValue}
	c.GetClientID()
	c = &ConnectionOptionsApple{}
	c.GetClientID()
	c = nil
	c.GetClientID()
}

func TestConnectionOptionsApple_GetClientSecret(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsApple{ClientSecret: &zeroValue}
	c.GetClientSecret()
	c = &ConnectionOptionsApple{}
	c.GetClientSecret()
	c = nil
	c.GetClientSecret()
}

func TestConnectionOptionsApple_GetEmail(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsApple{Email: &zeroValue}
	c.GetEmail()
	c = &ConnectionOptionsApple{}
	c.GetEmail()
	c = nil
	c.GetEmail()
}

func TestConnectionOptionsApple_GetKeyID(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsApple{KeyID: &zeroValue}
	c.GetKeyID()
	c = &ConnectionOptionsApple{}
	c.GetKeyID()
	c = nil
	c.GetKeyID()
}

func TestConnectionOptionsApple_GetName(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsApple{Name: &zeroValue}
	c.GetName()
	c = &ConnectionOptionsApple{}
	c.GetName()
	c = nil
	c.GetName()
}

func TestConnectionOptionsApple_GetNonPersistentAttrs(tt *testing.T) {
	var zeroValue []string
	c := &ConnectionOptionsApple{NonPersistentAttrs: &zeroValue}
	c.GetNonPersistentAttrs()
	c = &ConnectionOptionsApple{}
	c.GetNonPersistentAttrs()
	c = nil
	c.GetNonPersistentAttrs()
}

func TestConnectionOptionsApple_GetScope(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsApple{Scope: &zeroValue}
	c.GetScope()
	c = &ConnectionOptionsApple{}
	c.GetScope()
	c = nil
	c.GetScope()
}

func TestConnectionOptionsApple_GetSetUserAttributes(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsApple{SetUserAttributes: &zeroValue}
	c.GetSetUserAttributes()
	c = &ConnectionOptionsApple{}
	c.GetSetUserAttributes()
	c = nil
	c.GetSetUserAttributes()
}

func TestConnectionOptionsApple_GetTeamID(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsApple{TeamID: &zeroValue}
	c.GetTeamID()
	c = &ConnectionOptionsApple{}
	c.GetTeamID()
	c = nil
	c.GetTeamID()
}

func TestConnectionOptionsApple_GetUpstreamParams(tt *testing.T) {
	zeroValue := map[string]interface{}{}
	c := &ConnectionOptionsApple{UpstreamParams: zeroValue}
	c.GetUpstreamParams()
	c = &ConnectionOptionsApple{}
	c.GetUpstreamParams()
	c = nil
	c.GetUpstreamParams()
}

func TestConnectionOptionsApple_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ConnectionOptionsApple{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestConnectionOptionsAttributeAllowedTypes_GetEmail(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsAttributeAllowedTypes{Email: &zeroValue}
	c.GetEmail()
	c = &ConnectionOptionsAttributeAllowedTypes{}
	c.GetEmail()
	c = nil
	c.GetEmail()
}

func TestConnectionOptionsAttributeAllowedTypes_GetPhoneNumber(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsAttributeAllowedTypes{PhoneNumber: &zeroValue}
	c.GetPhoneNumber()
	c = &ConnectionOptionsAttributeAllowedTypes{}
	c.GetPhoneNumber()
	c = nil
	c.GetPhoneNumber()
}

func TestConnectionOptionsAttributeAllowedTypes_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ConnectionOptionsAttributeAllowedTypes{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestConnectionOptionsAttributeIdentifier_GetActive(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsAttributeIdentifier{Active: &zeroValue}
	c.GetActive()
	c = &ConnectionOptionsAttributeIdentifier{}
	c.GetActive()
	c = nil
	c.GetActive()
}

func TestConnectionOptionsAttributeIdentifier_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ConnectionOptionsAttributeIdentifier{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestConnectionOptionsAttributes_GetEmail(tt *testing.T) {
	c := &ConnectionOptionsAttributes{}
	c.GetEmail()
	c = nil
	c.GetEmail()
}

func TestConnectionOptionsAttributes_GetPhoneNumber(tt *testing.T) {
	c := &ConnectionOptionsAttributes{}
	c.GetPhoneNumber()
	c = nil
	c.GetPhoneNumber()
}

func TestConnectionOptionsAttributes_GetUsername(tt *testing.T) {
	c := &ConnectionOptionsAttributes{}
	c.GetUsername()
	c = nil
	c.GetUsername()
}

func TestConnectionOptionsAttributes_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ConnectionOptionsAttributes{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestConnectionOptionsAttributeSignup_GetStatus(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsAttributeSignup{Status: &zeroValue}
	c.GetStatus()
	c = &ConnectionOptionsAttributeSignup{}
	c.GetStatus()
	c = nil
	c.GetStatus()
}

func TestConnectionOptionsAttributeSignup_GetVerification(tt *testing.T) {
	c := &ConnectionOptionsAttributeSignup{}
	c.GetVerification()
	c = nil
	c.GetVerification()
}

func TestConnectionOptionsAttributeSignup_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ConnectionOptionsAttributeSignup{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestConnectionOptionsAttributeValidation_GetAllowedTypes(tt *testing.T) {
	c := &ConnectionOptionsAttributeValidation{}
	c.GetAllowedTypes()
	c = nil
	c.GetAllowedTypes()
}

func TestConnectionOptionsAttributeValidation_GetMaxLength(tt *testing.T) {
	var zeroValue int
	c := &ConnectionOptionsAttributeValidation{MaxLength: &zeroValue}
	c.GetMaxLength()
	c = &ConnectionOptionsAttributeValidation{}
	c.GetMaxLength()
	c = nil
	c.GetMaxLength()
}

func TestConnectionOptionsAttributeValidation_GetMinLength(tt *testing.T) {
	var zeroValue int
	c := &ConnectionOptionsAttributeValidation{MinLength: &zeroValue}
	c.GetMinLength()
	c = &ConnectionOptionsAttributeValidation{}
	c.GetMinLength()
	c = nil
	c.GetMinLength()
}

func TestConnectionOptionsAttributeValidation_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ConnectionOptionsAttributeValidation{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestConnectionOptionsAttributeVerification_GetActive(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsAttributeVerification{Active: &zeroValue}
	c.GetActive()
	c = &ConnectionOptionsAttributeVerification{}
	c.GetActive()
	c = nil
	c.GetActive()
}

func TestConnectionOptionsAttributeVerification_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ConnectionOptionsAttributeVerification{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestConnectionOptionsAzureAD_GetAdmin(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsAzureAD{Admin: &zeroValue}
	c.GetAdmin()
	c = &ConnectionOptionsAzureAD{}
	c.GetAdmin()
	c = nil
	c.GetAdmin()
}

func TestConnectionOptionsAzureAD_GetAgreedTerms(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsAzureAD{AgreedTerms: &zeroValue}
	c.GetAgreedTerms()
	c = &ConnectionOptionsAzureAD{}
	c.GetAgreedTerms()
	c = nil
	c.GetAgreedTerms()
}

func TestConnectionOptionsAzureAD_GetAppDomain(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsAzureAD{AppDomain: &zeroValue}
	c.GetAppDomain()
	c = &ConnectionOptionsAzureAD{}
	c.GetAppDomain()
	c = nil
	c.GetAppDomain()
}

func TestConnectionOptionsAzureAD_GetAppID(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsAzureAD{AppID: &zeroValue}
	c.GetAppID()
	c = &ConnectionOptionsAzureAD{}
	c.GetAppID()
	c = nil
	c.GetAppID()
}

func TestConnectionOptionsAzureAD_GetAssignedPlans(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsAzureAD{AssignedPlans: &zeroValue}
	c.GetAssignedPlans()
	c = &ConnectionOptionsAzureAD{}
	c.GetAssignedPlans()
	c = nil
	c.GetAssignedPlans()
}

func TestConnectionOptionsAzureAD_GetBasicProfile(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsAzureAD{BasicProfile: &zeroValue}
	c.GetBasicProfile()
	c = &ConnectionOptionsAzureAD{}
	c.GetBasicProfile()
	c = nil
	c.GetBasicProfile()
}

func TestConnectionOptionsAzureAD_GetCertRolloverNotification(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsAzureAD{CertRolloverNotification: &zeroValue}
	c.GetCertRolloverNotification()
	c = &ConnectionOptionsAzureAD{}
	c.GetCertRolloverNotification()
	c = nil
	c.GetCertRolloverNotification()
}

func TestConnectionOptionsAzureAD_GetClientID(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsAzureAD{ClientID: &zeroValue}
	c.GetClientID()
	c = &ConnectionOptionsAzureAD{}
	c.GetClientID()
	c = nil
	c.GetClientID()
}

func TestConnectionOptionsAzureAD_GetClientSecret(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsAzureAD{ClientSecret: &zeroValue}
	c.GetClientSecret()
	c = &ConnectionOptionsAzureAD{}
	c.GetClientSecret()
	c = nil
	c.GetClientSecret()
}

func TestConnectionOptionsAzureAD_GetDomain(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsAzureAD{Domain: &zeroValue}
	c.GetDomain()
	c = &ConnectionOptionsAzureAD{}
	c.GetDomain()
	c = nil
	c.GetDomain()
}

func TestConnectionOptionsAzureAD_GetDomainAliases(tt *testing.T) {
	var zeroValue []string
	c := &ConnectionOptionsAzureAD{DomainAliases: &zeroValue}
	c.GetDomainAliases()
	c = &ConnectionOptionsAzureAD{}
	c.GetDomainAliases()
	c = nil
	c.GetDomainAliases()
}

func TestConnectionOptionsAzureAD_GetEnableUsersAPI(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsAzureAD{EnableUsersAPI: &zeroValue}
	c.GetEnableUsersAPI()
	c = &ConnectionOptionsAzureAD{}
	c.GetEnableUsersAPI()
	c = nil
	c.GetEnableUsersAPI()
}

func TestConnectionOptionsAzureAD_GetExtendedProfile(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsAzureAD{ExtendedProfile: &zeroValue}
	c.GetExtendedProfile()
	c = &ConnectionOptionsAzureAD{}
	c.GetExtendedProfile()
	c = nil
	c.GetExtendedProfile()
}

func TestConnectionOptionsAzureAD_GetGranted(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsAzureAD{Granted: &zeroValue}
	c.GetGranted()
	c = &ConnectionOptionsAzureAD{}
	c.GetGranted()
	c = nil
	c.GetGranted()
}

func TestConnectionOptionsAzureAD_GetGroups(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsAzureAD{Groups: &zeroValue}
	c.GetGroups()
	c = &ConnectionOptionsAzureAD{}
	c.GetGroups()
	c = nil
	c.GetGroups()
}

func TestConnectionOptionsAzureAD_GetIdentityAPI(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsAzureAD{IdentityAPI: &zeroValue}
	c.GetIdentityAPI()
	c = &ConnectionOptionsAzureAD{}
	c.GetIdentityAPI()
	c = nil
	c.GetIdentityAPI()
}

func TestConnectionOptionsAzureAD_GetIsSuspended(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsAzureAD{IsSuspended: &zeroValue}
	c.GetIsSuspended()
	c = &ConnectionOptionsAzureAD{}
	c.GetIsSuspended()
	c = nil
	c.GetIsSuspended()
}

func TestConnectionOptionsAzureAD_GetLogoURL(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsAzureAD{LogoURL: &zeroValue}
	c.GetLogoURL()
	c = &ConnectionOptionsAzureAD{}
	c.GetLogoURL()
	c = nil
	c.GetLogoURL()
}

func TestConnectionOptionsAzureAD_GetMaxGroupsToRetrieve(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsAzureAD{MaxGroupsToRetrieve: &zeroValue}
	c.GetMaxGroupsToRetrieve()
	c = &ConnectionOptionsAzureAD{}
	c.GetMaxGroupsToRetrieve()
	c = nil
	c.GetMaxGroupsToRetrieve()
}

func TestConnectionOptionsAzureAD_GetNestedGroups(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsAzureAD{NestedGroups: &zeroValue}
	c.GetNestedGroups()
	c = &ConnectionOptionsAzureAD{}
	c.GetNestedGroups()
	c = nil
	c.GetNestedGroups()
}

func TestConnectionOptionsAzureAD_GetNonPersistentAttrs(tt *testing.T) {
	var zeroValue []string
	c := &ConnectionOptionsAzureAD{NonPersistentAttrs: &zeroValue}
	c.GetNonPersistentAttrs()
	c = &ConnectionOptionsAzureAD{}
	c.GetNonPersistentAttrs()
	c = nil
	c.GetNonPersistentAttrs()
}

func TestConnectionOptionsAzureAD_GetSetUserAttributes(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsAzureAD{SetUserAttributes: &zeroValue}
	c.GetSetUserAttributes()
	c = &ConnectionOptionsAzureAD{}
	c.GetSetUserAttributes()
	c = nil
	c.GetSetUserAttributes()
}

func TestConnectionOptionsAzureAD_GetStrategyVersion(tt *testing.T) {
	var zeroValue int
	c := &ConnectionOptionsAzureAD{StrategyVersion: &zeroValue}
	c.GetStrategyVersion()
	c = &ConnectionOptionsAzureAD{}
	c.GetStrategyVersion()
	c = nil
	c.GetStrategyVersion()
}

func TestConnectionOptionsAzureAD_GetTenantDomain(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsAzureAD{TenantDomain: &zeroValue}
	c.GetTenantDomain()
	c = &ConnectionOptionsAzureAD{}
	c.GetTenantDomain()
	c = nil
	c.GetTenantDomain()
}

func TestConnectionOptionsAzureAD_GetTenantID(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsAzureAD{TenantID: &zeroValue}
	c.GetTenantID()
	c = &ConnectionOptionsAzureAD{}
	c.GetTenantID()
	c = nil
	c.GetTenantID()
}

func TestConnectionOptionsAzureAD_GetThumbprints(tt *testing.T) {
	var zeroValue []string
	c := &ConnectionOptionsAzureAD{Thumbprints: &zeroValue}
	c.GetThumbprints()
	c = &ConnectionOptionsAzureAD{}
	c.GetThumbprints()
	c = nil
	c.GetThumbprints()
}

func TestConnectionOptionsAzureAD_GetTrustEmailVerified(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsAzureAD{TrustEmailVerified: &zeroValue}
	c.GetTrustEmailVerified()
	c = &ConnectionOptionsAzureAD{}
	c.GetTrustEmailVerified()
	c = nil
	c.GetTrustEmailVerified()
}

func TestConnectionOptionsAzureAD_GetUpstreamParams(tt *testing.T) {
	zeroValue := map[string]interface{}{}
	c := &ConnectionOptionsAzureAD{UpstreamParams: zeroValue}
	c.GetUpstreamParams()
	c = &ConnectionOptionsAzureAD{}
	c.GetUpstreamParams()
	c = nil
	c.GetUpstreamParams()
}

func TestConnectionOptionsAzureAD_GetUseCommonEndpoint(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsAzureAD{UseCommonEndpoint: &zeroValue}
	c.GetUseCommonEndpoint()
	c = &ConnectionOptionsAzureAD{}
	c.GetUseCommonEndpoint()
	c = nil
	c.GetUseCommonEndpoint()
}

func TestConnectionOptionsAzureAD_GetUserIDAttribute(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsAzureAD{UserIDAttribute: &zeroValue}
	c.GetUserIDAttribute()
	c = &ConnectionOptionsAzureAD{}
	c.GetUserIDAttribute()
	c = nil
	c.GetUserIDAttribute()
}

func TestConnectionOptionsAzureAD_GetUseWSFederation(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsAzureAD{UseWSFederation: &zeroValue}
	c.GetUseWSFederation()
	c = &ConnectionOptionsAzureAD{}
	c.GetUseWSFederation()
	c = nil
	c.GetUseWSFederation()
}

func TestConnectionOptionsAzureAD_GetWAADCommonEndpoint(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsAzureAD{WAADCommonEndpoint: &zeroValue}
	c.GetWAADCommonEndpoint()
	c = &ConnectionOptionsAzureAD{}
	c.GetWAADCommonEndpoint()
	c = nil
	c.GetWAADCommonEndpoint()
}

func TestConnectionOptionsAzureAD_GetWAADProtocol(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsAzureAD{WAADProtocol: &zeroValue}
	c.GetWAADProtocol()
	c = &ConnectionOptionsAzureAD{}
	c.GetWAADProtocol()
	c = nil
	c.GetWAADProtocol()
}

func TestConnectionOptionsAzureAD_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ConnectionOptionsAzureAD{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestConnectionOptionsEmail_GetBruteForceProtection(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsEmail{BruteForceProtection: &zeroValue}
	c.GetBruteForceProtection()
	c = &ConnectionOptionsEmail{}
	c.GetBruteForceProtection()
	c = nil
	c.GetBruteForceProtection()
}

func TestConnectionOptionsEmail_GetDisableSignup(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsEmail{DisableSignup: &zeroValue}
	c.GetDisableSignup()
	c = &ConnectionOptionsEmail{}
	c.GetDisableSignup()
	c = nil
	c.GetDisableSignup()
}

func TestConnectionOptionsEmail_GetEmail(tt *testing.T) {
	c := &ConnectionOptionsEmail{}
	c.GetEmail()
	c = nil
	c.GetEmail()
}

func TestConnectionOptionsEmail_GetName(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsEmail{Name: &zeroValue}
	c.GetName()
	c = &ConnectionOptionsEmail{}
	c.GetName()
	c = nil
	c.GetName()
}

func TestConnectionOptionsEmail_GetNonPersistentAttrs(tt *testing.T) {
	var zeroValue []string
	c := &ConnectionOptionsEmail{NonPersistentAttrs: &zeroValue}
	c.GetNonPersistentAttrs()
	c = &ConnectionOptionsEmail{}
	c.GetNonPersistentAttrs()
	c = nil
	c.GetNonPersistentAttrs()
}

func TestConnectionOptionsEmail_GetOTP(tt *testing.T) {
	c := &ConnectionOptionsEmail{}
	c.GetOTP()
	c = nil
	c.GetOTP()
}

func TestConnectionOptionsEmail_GetSetUserAttributes(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsEmail{SetUserAttributes: &zeroValue}
	c.GetSetUserAttributes()
	c = &ConnectionOptionsEmail{}
	c.GetSetUserAttributes()
	c = nil
	c.GetSetUserAttributes()
}

func TestConnectionOptionsEmail_GetUpstreamParams(tt *testing.T) {
	zeroValue := map[string]interface{}{}
	c := &ConnectionOptionsEmail{UpstreamParams: zeroValue}
	c.GetUpstreamParams()
	c = &ConnectionOptionsEmail{}
	c.GetUpstreamParams()
	c = nil
	c.GetUpstreamParams()
}

func TestConnectionOptionsEmail_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ConnectionOptionsEmail{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestConnectionOptionsEmailAttribute_GetIdentifier(tt *testing.T) {
	c := &ConnectionOptionsEmailAttribute{}
	c.GetIdentifier()
	c = nil
	c.GetIdentifier()
}

func TestConnectionOptionsEmailAttribute_GetProfileRequired(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsEmailAttribute{ProfileRequired: &zeroValue}
	c.GetProfileRequired()
	c = &ConnectionOptionsEmailAttribute{}
	c.GetProfileRequired()
	c = nil
	c.GetProfileRequired()
}

func TestConnectionOptionsEmailAttribute_GetSignup(tt *testing.T) {
	c := &ConnectionOptionsEmailAttribute{}
	c.GetSignup()
	c = nil
	c.GetSignup()
}

func TestConnectionOptionsEmailAttribute_GetVerificationMethod(tt *testing.T) {
	c := &ConnectionOptionsEmailAttribute{}
	c.GetVerificationMethod()
	c = nil
	c.GetVerificationMethod()
}

func TestConnectionOptionsEmailAttribute_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ConnectionOptionsEmailAttribute{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestConnectionOptionsEmailSettings_GetBody(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsEmailSettings{Body: &zeroValue}
	c.GetBody()
	c = &ConnectionOptionsEmailSettings{}
	c.GetBody()
	c = nil
	c.GetBody()
}

func TestConnectionOptionsEmailSettings_GetFrom(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsEmailSettings{From: &zeroValue}
	c.GetFrom()
	c = &ConnectionOptionsEmailSettings{}
	c.GetFrom()
	c = nil
	c.GetFrom()
}

func TestConnectionOptionsEmailSettings_GetSubject(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsEmailSettings{Subject: &zeroValue}
	c.GetSubject()
	c = &ConnectionOptionsEmailSettings{}
	c.GetSubject()
	c = nil
	c.GetSubject()
}

func TestConnectionOptionsEmailSettings_GetSyntax(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsEmailSettings{Syntax: &zeroValue}
	c.GetSyntax()
	c = &ConnectionOptionsEmailSettings{}
	c.GetSyntax()
	c = nil
	c.GetSyntax()
}

func TestConnectionOptionsEmailSettings_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ConnectionOptionsEmailSettings{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestConnectionOptionsFacebook_GetAdsManagement(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsFacebook{AdsManagement: &zeroValue}
	c.GetAdsManagement()
	c = &ConnectionOptionsFacebook{}
	c.GetAdsManagement()
	c = nil
	c.GetAdsManagement()
}

func TestConnectionOptionsFacebook_GetAdsRead(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsFacebook{AdsRead: &zeroValue}
	c.GetAdsRead()
	c = &ConnectionOptionsFacebook{}
	c.GetAdsRead()
	c = nil
	c.GetAdsRead()
}

func TestConnectionOptionsFacebook_GetAllowContextProfileField(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsFacebook{AllowContextProfileField: &zeroValue}
	c.GetAllowContextProfileField()
	c = &ConnectionOptionsFacebook{}
	c.GetAllowContextProfileField()
	c = nil
	c.GetAllowContextProfileField()
}

func TestConnectionOptionsFacebook_GetBusinessManagement(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsFacebook{BusinessManagement: &zeroValue}
	c.GetBusinessManagement()
	c = &ConnectionOptionsFacebook{}
	c.GetBusinessManagement()
	c = nil
	c.GetBusinessManagement()
}

func TestConnectionOptionsFacebook_GetClientID(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsFacebook{ClientID: &zeroValue}
	c.GetClientID()
	c = &ConnectionOptionsFacebook{}
	c.GetClientID()
	c = nil
	c.GetClientID()
}

func TestConnectionOptionsFacebook_GetClientSecret(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsFacebook{ClientSecret: &zeroValue}
	c.GetClientSecret()
	c = &ConnectionOptionsFacebook{}
	c.GetClientSecret()
	c = nil
	c.GetClientSecret()
}

func TestConnectionOptionsFacebook_GetEmail(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsFacebook{Email: &zeroValue}
	c.GetEmail()
	c = &ConnectionOptionsFacebook{}
	c.GetEmail()
	c = nil
	c.GetEmail()
}

func TestConnectionOptionsFacebook_GetGroupsAccessMemberInfo(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsFacebook{GroupsAccessMemberInfo: &zeroValue}
	c.GetGroupsAccessMemberInfo()
	c = &ConnectionOptionsFacebook{}
	c.GetGroupsAccessMemberInfo()
	c = nil
	c.GetGroupsAccessMemberInfo()
}

func TestConnectionOptionsFacebook_GetLeadsRetrieval(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsFacebook{LeadsRetrieval: &zeroValue}
	c.GetLeadsRetrieval()
	c = &ConnectionOptionsFacebook{}
	c.GetLeadsRetrieval()
	c = nil
	c.GetLeadsRetrieval()
}

func TestConnectionOptionsFacebook_GetManageNotifications(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsFacebook{ManageNotifications: &zeroValue}
	c.GetManageNotifications()
	c = &ConnectionOptionsFacebook{}
	c.GetManageNotifications()
	c = nil
	c.GetManageNotifications()
}

func TestConnectionOptionsFacebook_GetManagePages(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsFacebook{ManagePages: &zeroValue}
	c.GetManagePages()
	c = &ConnectionOptionsFacebook{}
	c.GetManagePages()
	c = nil
	c.GetManagePages()
}

func TestConnectionOptionsFacebook_GetNonPersistentAttrs(tt *testing.T) {
	var zeroValue []string
	c := &ConnectionOptionsFacebook{NonPersistentAttrs: &zeroValue}
	c.GetNonPersistentAttrs()
	c = &ConnectionOptionsFacebook{}
	c.GetNonPersistentAttrs()
	c = nil
	c.GetNonPersistentAttrs()
}

func TestConnectionOptionsFacebook_GetPagesManageCTA(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsFacebook{PagesManageCTA: &zeroValue}
	c.GetPagesManageCTA()
	c = &ConnectionOptionsFacebook{}
	c.GetPagesManageCTA()
	c = nil
	c.GetPagesManageCTA()
}

func TestConnectionOptionsFacebook_GetPagesManageInstantArticles(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsFacebook{PagesManageInstantArticles: &zeroValue}
	c.GetPagesManageInstantArticles()
	c = &ConnectionOptionsFacebook{}
	c.GetPagesManageInstantArticles()
	c = nil
	c.GetPagesManageInstantArticles()
}

func TestConnectionOptionsFacebook_GetPagesMessaging(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsFacebook{PagesMessaging: &zeroValue}
	c.GetPagesMessaging()
	c = &ConnectionOptionsFacebook{}
	c.GetPagesMessaging()
	c = nil
	c.GetPagesMessaging()
}

func TestConnectionOptionsFacebook_GetPagesMessagingPhoneNumber(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsFacebook{PagesMessagingPhoneNumber: &zeroValue}
	c.GetPagesMessagingPhoneNumber()
	c = &ConnectionOptionsFacebook{}
	c.GetPagesMessagingPhoneNumber()
	c = nil
	c.GetPagesMessagingPhoneNumber()
}

func TestConnectionOptionsFacebook_GetPagesMessagingSubscriptions(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsFacebook{PagesMessagingSubscriptions: &zeroValue}
	c.GetPagesMessagingSubscriptions()
	c = &ConnectionOptionsFacebook{}
	c.GetPagesMessagingSubscriptions()
	c = nil
	c.GetPagesMessagingSubscriptions()
}

func TestConnectionOptionsFacebook_GetPagesShowList(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsFacebook{PagesShowList: &zeroValue}
	c.GetPagesShowList()
	c = &ConnectionOptionsFacebook{}
	c.GetPagesShowList()
	c = nil
	c.GetPagesShowList()
}

func TestConnectionOptionsFacebook_GetPublicProfile(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsFacebook{PublicProfile: &zeroValue}
	c.GetPublicProfile()
	c = &ConnectionOptionsFacebook{}
	c.GetPublicProfile()
	c = nil
	c.GetPublicProfile()
}

func TestConnectionOptionsFacebook_GetPublishActions(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsFacebook{PublishActions: &zeroValue}
	c.GetPublishActions()
	c = &ConnectionOptionsFacebook{}
	c.GetPublishActions()
	c = nil
	c.GetPublishActions()
}

func TestConnectionOptionsFacebook_GetPublishPages(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsFacebook{PublishPages: &zeroValue}
	c.GetPublishPages()
	c = &ConnectionOptionsFacebook{}
	c.GetPublishPages()
	c = nil
	c.GetPublishPages()
}

func TestConnectionOptionsFacebook_GetPublishToGroups(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsFacebook{PublishToGroups: &zeroValue}
	c.GetPublishToGroups()
	c = &ConnectionOptionsFacebook{}
	c.GetPublishToGroups()
	c = nil
	c.GetPublishToGroups()
}

func TestConnectionOptionsFacebook_GetPublishVideo(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsFacebook{PublishVideo: &zeroValue}
	c.GetPublishVideo()
	c = &ConnectionOptionsFacebook{}
	c.GetPublishVideo()
	c = nil
	c.GetPublishVideo()
}

func TestConnectionOptionsFacebook_GetReadAudienceNetworkInsights(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsFacebook{ReadAudienceNetworkInsights: &zeroValue}
	c.GetReadAudienceNetworkInsights()
	c = &ConnectionOptionsFacebook{}
	c.GetReadAudienceNetworkInsights()
	c = nil
	c.GetReadAudienceNetworkInsights()
}

func TestConnectionOptionsFacebook_GetReadInsights(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsFacebook{ReadInsights: &zeroValue}
	c.GetReadInsights()
	c = &ConnectionOptionsFacebook{}
	c.GetReadInsights()
	c = nil
	c.GetReadInsights()
}

func TestConnectionOptionsFacebook_GetReadMailbox(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsFacebook{ReadMailbox: &zeroValue}
	c.GetReadMailbox()
	c = &ConnectionOptionsFacebook{}
	c.GetReadMailbox()
	c = nil
	c.GetReadMailbox()
}

func TestConnectionOptionsFacebook_GetReadPageMailboxes(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsFacebook{ReadPageMailboxes: &zeroValue}
	c.GetReadPageMailboxes()
	c = &ConnectionOptionsFacebook{}
	c.GetReadPageMailboxes()
	c = nil
	c.GetReadPageMailboxes()
}

func TestConnectionOptionsFacebook_GetReadStream(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsFacebook{ReadStream: &zeroValue}
	c.GetReadStream()
	c = &ConnectionOptionsFacebook{}
	c.GetReadStream()
	c = nil
	c.GetReadStream()
}

func TestConnectionOptionsFacebook_GetScope(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsFacebook{Scope: &zeroValue}
	c.GetScope()
	c = &ConnectionOptionsFacebook{}
	c.GetScope()
	c = nil
	c.GetScope()
}

func TestConnectionOptionsFacebook_GetSetUserAttributes(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsFacebook{SetUserAttributes: &zeroValue}
	c.GetSetUserAttributes()
	c = &ConnectionOptionsFacebook{}
	c.GetSetUserAttributes()
	c = nil
	c.GetSetUserAttributes()
}

func TestConnectionOptionsFacebook_GetUpstreamParams(tt *testing.T) {
	zeroValue := map[string]interface{}{}
	c := &ConnectionOptionsFacebook{UpstreamParams: zeroValue}
	c.GetUpstreamParams()
	c = &ConnectionOptionsFacebook{}
	c.GetUpstreamParams()
	c = nil
	c.GetUpstreamParams()
}

func TestConnectionOptionsFacebook_GetUserAgeRange(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsFacebook{UserAgeRange: &zeroValue}
	c.GetUserAgeRange()
	c = &ConnectionOptionsFacebook{}
	c.GetUserAgeRange()
	c = nil
	c.GetUserAgeRange()
}

func TestConnectionOptionsFacebook_GetUserBirthday(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsFacebook{UserBirthday: &zeroValue}
	c.GetUserBirthday()
	c = &ConnectionOptionsFacebook{}
	c.GetUserBirthday()
	c = nil
	c.GetUserBirthday()
}

func TestConnectionOptionsFacebook_GetUserEvents(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsFacebook{UserEvents: &zeroValue}
	c.GetUserEvents()
	c = &ConnectionOptionsFacebook{}
	c.GetUserEvents()
	c = nil
	c.GetUserEvents()
}

func TestConnectionOptionsFacebook_GetUserFriends(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsFacebook{UserFriends: &zeroValue}
	c.GetUserFriends()
	c = &ConnectionOptionsFacebook{}
	c.GetUserFriends()
	c = nil
	c.GetUserFriends()
}

func TestConnectionOptionsFacebook_GetUserGender(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsFacebook{UserGender: &zeroValue}
	c.GetUserGender()
	c = &ConnectionOptionsFacebook{}
	c.GetUserGender()
	c = nil
	c.GetUserGender()
}

func TestConnectionOptionsFacebook_GetUserGroups(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsFacebook{UserGroups: &zeroValue}
	c.GetUserGroups()
	c = &ConnectionOptionsFacebook{}
	c.GetUserGroups()
	c = nil
	c.GetUserGroups()
}

func TestConnectionOptionsFacebook_GetUserHometown(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsFacebook{UserHometown: &zeroValue}
	c.GetUserHometown()
	c = &ConnectionOptionsFacebook{}
	c.GetUserHometown()
	c = nil
	c.GetUserHometown()
}

func TestConnectionOptionsFacebook_GetUserLikes(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsFacebook{UserLikes: &zeroValue}
	c.GetUserLikes()
	c = &ConnectionOptionsFacebook{}
	c.GetUserLikes()
	c = nil
	c.GetUserLikes()
}

func TestConnectionOptionsFacebook_GetUserLink(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsFacebook{UserLink: &zeroValue}
	c.GetUserLink()
	c = &ConnectionOptionsFacebook{}
	c.GetUserLink()
	c = nil
	c.GetUserLink()
}

func TestConnectionOptionsFacebook_GetUserLocation(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsFacebook{UserLocation: &zeroValue}
	c.GetUserLocation()
	c = &ConnectionOptionsFacebook{}
	c.GetUserLocation()
	c = nil
	c.GetUserLocation()
}

func TestConnectionOptionsFacebook_GetUserManagedGroups(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsFacebook{UserManagedGroups: &zeroValue}
	c.GetUserManagedGroups()
	c = &ConnectionOptionsFacebook{}
	c.GetUserManagedGroups()
	c = nil
	c.GetUserManagedGroups()
}

func TestConnectionOptionsFacebook_GetUserPhotos(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsFacebook{UserPhotos: &zeroValue}
	c.GetUserPhotos()
	c = &ConnectionOptionsFacebook{}
	c.GetUserPhotos()
	c = nil
	c.GetUserPhotos()
}

func TestConnectionOptionsFacebook_GetUserPosts(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsFacebook{UserPosts: &zeroValue}
	c.GetUserPosts()
	c = &ConnectionOptionsFacebook{}
	c.GetUserPosts()
	c = nil
	c.GetUserPosts()
}

func TestConnectionOptionsFacebook_GetUserStatus(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsFacebook{UserStatus: &zeroValue}
	c.GetUserStatus()
	c = &ConnectionOptionsFacebook{}
	c.GetUserStatus()
	c = nil
	c.GetUserStatus()
}

func TestConnectionOptionsFacebook_GetUserTaggedPlaces(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsFacebook{UserTaggedPlaces: &zeroValue}
	c.GetUserTaggedPlaces()
	c = &ConnectionOptionsFacebook{}
	c.GetUserTaggedPlaces()
	c = nil
	c.GetUserTaggedPlaces()
}

func TestConnectionOptionsFacebook_GetUserVideos(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsFacebook{UserVideos: &zeroValue}
	c.GetUserVideos()
	c = &ConnectionOptionsFacebook{}
	c.GetUserVideos()
	c = nil
	c.GetUserVideos()
}

func TestConnectionOptionsFacebook_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ConnectionOptionsFacebook{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestConnectionOptionsGitHub_GetAdminOrg(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsGitHub{AdminOrg: &zeroValue}
	c.GetAdminOrg()
	c = &ConnectionOptionsGitHub{}
	c.GetAdminOrg()
	c = nil
	c.GetAdminOrg()
}

func TestConnectionOptionsGitHub_GetAdminPublicKey(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsGitHub{AdminPublicKey: &zeroValue}
	c.GetAdminPublicKey()
	c = &ConnectionOptionsGitHub{}
	c.GetAdminPublicKey()
	c = nil
	c.GetAdminPublicKey()
}

func TestConnectionOptionsGitHub_GetAdminRepoHook(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsGitHub{AdminRepoHook: &zeroValue}
	c.GetAdminRepoHook()
	c = &ConnectionOptionsGitHub{}
	c.GetAdminRepoHook()
	c = nil
	c.GetAdminRepoHook()
}

func TestConnectionOptionsGitHub_GetClientID(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsGitHub{ClientID: &zeroValue}
	c.GetClientID()
	c = &ConnectionOptionsGitHub{}
	c.GetClientID()
	c = nil
	c.GetClientID()
}

func TestConnectionOptionsGitHub_GetClientSecret(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsGitHub{ClientSecret: &zeroValue}
	c.GetClientSecret()
	c = &ConnectionOptionsGitHub{}
	c.GetClientSecret()
	c = nil
	c.GetClientSecret()
}

func TestConnectionOptionsGitHub_GetDeleteRepo(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsGitHub{DeleteRepo: &zeroValue}
	c.GetDeleteRepo()
	c = &ConnectionOptionsGitHub{}
	c.GetDeleteRepo()
	c = nil
	c.GetDeleteRepo()
}

func TestConnectionOptionsGitHub_GetEmail(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsGitHub{Email: &zeroValue}
	c.GetEmail()
	c = &ConnectionOptionsGitHub{}
	c.GetEmail()
	c = nil
	c.GetEmail()
}

func TestConnectionOptionsGitHub_GetFollow(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsGitHub{Follow: &zeroValue}
	c.GetFollow()
	c = &ConnectionOptionsGitHub{}
	c.GetFollow()
	c = nil
	c.GetFollow()
}

func TestConnectionOptionsGitHub_GetGist(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsGitHub{Gist: &zeroValue}
	c.GetGist()
	c = &ConnectionOptionsGitHub{}
	c.GetGist()
	c = nil
	c.GetGist()
}

func TestConnectionOptionsGitHub_GetNonPersistentAttrs(tt *testing.T) {
	var zeroValue []string
	c := &ConnectionOptionsGitHub{NonPersistentAttrs: &zeroValue}
	c.GetNonPersistentAttrs()
	c = &ConnectionOptionsGitHub{}
	c.GetNonPersistentAttrs()
	c = nil
	c.GetNonPersistentAttrs()
}

func TestConnectionOptionsGitHub_GetNotifications(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsGitHub{Notifications: &zeroValue}
	c.GetNotifications()
	c = &ConnectionOptionsGitHub{}
	c.GetNotifications()
	c = nil
	c.GetNotifications()
}

func TestConnectionOptionsGitHub_GetProfile(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsGitHub{Profile: &zeroValue}
	c.GetProfile()
	c = &ConnectionOptionsGitHub{}
	c.GetProfile()
	c = nil
	c.GetProfile()
}

func TestConnectionOptionsGitHub_GetPublicRepo(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsGitHub{PublicRepo: &zeroValue}
	c.GetPublicRepo()
	c = &ConnectionOptionsGitHub{}
	c.GetPublicRepo()
	c = nil
	c.GetPublicRepo()
}

func TestConnectionOptionsGitHub_GetReadOrg(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsGitHub{ReadOrg: &zeroValue}
	c.GetReadOrg()
	c = &ConnectionOptionsGitHub{}
	c.GetReadOrg()
	c = nil
	c.GetReadOrg()
}

func TestConnectionOptionsGitHub_GetReadPublicKey(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsGitHub{ReadPublicKey: &zeroValue}
	c.GetReadPublicKey()
	c = &ConnectionOptionsGitHub{}
	c.GetReadPublicKey()
	c = nil
	c.GetReadPublicKey()
}

func TestConnectionOptionsGitHub_GetReadRepoHook(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsGitHub{ReadRepoHook: &zeroValue}
	c.GetReadRepoHook()
	c = &ConnectionOptionsGitHub{}
	c.GetReadRepoHook()
	c = nil
	c.GetReadRepoHook()
}

func TestConnectionOptionsGitHub_GetReadUser(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsGitHub{ReadUser: &zeroValue}
	c.GetReadUser()
	c = &ConnectionOptionsGitHub{}
	c.GetReadUser()
	c = nil
	c.GetReadUser()
}

func TestConnectionOptionsGitHub_GetRepo(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsGitHub{Repo: &zeroValue}
	c.GetRepo()
	c = &ConnectionOptionsGitHub{}
	c.GetRepo()
	c = nil
	c.GetRepo()
}

func TestConnectionOptionsGitHub_GetRepoDeployment(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsGitHub{RepoDeployment: &zeroValue}
	c.GetRepoDeployment()
	c = &ConnectionOptionsGitHub{}
	c.GetRepoDeployment()
	c = nil
	c.GetRepoDeployment()
}

func TestConnectionOptionsGitHub_GetRepoStatus(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsGitHub{RepoStatus: &zeroValue}
	c.GetRepoStatus()
	c = &ConnectionOptionsGitHub{}
	c.GetRepoStatus()
	c = nil
	c.GetRepoStatus()
}

func TestConnectionOptionsGitHub_GetSetUserAttributes(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsGitHub{SetUserAttributes: &zeroValue}
	c.GetSetUserAttributes()
	c = &ConnectionOptionsGitHub{}
	c.GetSetUserAttributes()
	c = nil
	c.GetSetUserAttributes()
}

func TestConnectionOptionsGitHub_GetUpstreamParams(tt *testing.T) {
	zeroValue := map[string]interface{}{}
	c := &ConnectionOptionsGitHub{UpstreamParams: zeroValue}
	c.GetUpstreamParams()
	c = &ConnectionOptionsGitHub{}
	c.GetUpstreamParams()
	c = nil
	c.GetUpstreamParams()
}

func TestConnectionOptionsGitHub_GetWriteOrg(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsGitHub{WriteOrg: &zeroValue}
	c.GetWriteOrg()
	c = &ConnectionOptionsGitHub{}
	c.GetWriteOrg()
	c = nil
	c.GetWriteOrg()
}

func TestConnectionOptionsGitHub_GetWritePublicKey(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsGitHub{WritePublicKey: &zeroValue}
	c.GetWritePublicKey()
	c = &ConnectionOptionsGitHub{}
	c.GetWritePublicKey()
	c = nil
	c.GetWritePublicKey()
}

func TestConnectionOptionsGitHub_GetWriteRepoHook(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsGitHub{WriteRepoHook: &zeroValue}
	c.GetWriteRepoHook()
	c = &ConnectionOptionsGitHub{}
	c.GetWriteRepoHook()
	c = nil
	c.GetWriteRepoHook()
}

func TestConnectionOptionsGitHub_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ConnectionOptionsGitHub{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestConnectionOptionsGoogleApps_GetAdmin(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsGoogleApps{Admin: &zeroValue}
	c.GetAdmin()
	c = &ConnectionOptionsGoogleApps{}
	c.GetAdmin()
	c = nil
	c.GetAdmin()
}

func TestConnectionOptionsGoogleApps_GetAdminAccessToken(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsGoogleApps{AdminAccessToken: &zeroValue}
	c.GetAdminAccessToken()
	c = &ConnectionOptionsGoogleApps{}
	c.GetAdminAccessToken()
	c = nil
	c.GetAdminAccessToken()
}

func TestConnectionOptionsGoogleApps_GetAdminAccessTokenExpiresIn(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsGoogleApps{AdminAccessTokenExpiresIn: &zeroValue}
	c.GetAdminAccessTokenExpiresIn()
	c = &ConnectionOptionsGoogleApps{}
	c.GetAdminAccessTokenExpiresIn()
	c = nil
	c.GetAdminAccessTokenExpiresIn()
}

func TestConnectionOptionsGoogleApps_GetAdminRefreshToken(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsGoogleApps{AdminRefreshToken: &zeroValue}
	c.GetAdminRefreshToken()
	c = &ConnectionOptionsGoogleApps{}
	c.GetAdminRefreshToken()
	c = nil
	c.GetAdminRefreshToken()
}

func TestConnectionOptionsGoogleApps_GetAgreedTerms(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsGoogleApps{AgreedTerms: &zeroValue}
	c.GetAgreedTerms()
	c = &ConnectionOptionsGoogleApps{}
	c.GetAgreedTerms()
	c = nil
	c.GetAgreedTerms()
}

func TestConnectionOptionsGoogleApps_GetBasicProfile(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsGoogleApps{BasicProfile: &zeroValue}
	c.GetBasicProfile()
	c = &ConnectionOptionsGoogleApps{}
	c.GetBasicProfile()
	c = nil
	c.GetBasicProfile()
}

func TestConnectionOptionsGoogleApps_GetClientID(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsGoogleApps{ClientID: &zeroValue}
	c.GetClientID()
	c = &ConnectionOptionsGoogleApps{}
	c.GetClientID()
	c = nil
	c.GetClientID()
}

func TestConnectionOptionsGoogleApps_GetClientSecret(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsGoogleApps{ClientSecret: &zeroValue}
	c.GetClientSecret()
	c = &ConnectionOptionsGoogleApps{}
	c.GetClientSecret()
	c = nil
	c.GetClientSecret()
}

func TestConnectionOptionsGoogleApps_GetDomain(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsGoogleApps{Domain: &zeroValue}
	c.GetDomain()
	c = &ConnectionOptionsGoogleApps{}
	c.GetDomain()
	c = nil
	c.GetDomain()
}

func TestConnectionOptionsGoogleApps_GetDomainAliases(tt *testing.T) {
	var zeroValue []string
	c := &ConnectionOptionsGoogleApps{DomainAliases: &zeroValue}
	c.GetDomainAliases()
	c = &ConnectionOptionsGoogleApps{}
	c.GetDomainAliases()
	c = nil
	c.GetDomainAliases()
}

func TestConnectionOptionsGoogleApps_GetEnableUsersAPI(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsGoogleApps{EnableUsersAPI: &zeroValue}
	c.GetEnableUsersAPI()
	c = &ConnectionOptionsGoogleApps{}
	c.GetEnableUsersAPI()
	c = nil
	c.GetEnableUsersAPI()
}

func TestConnectionOptionsGoogleApps_GetExtendedProfile(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsGoogleApps{ExtendedProfile: &zeroValue}
	c.GetExtendedProfile()
	c = &ConnectionOptionsGoogleApps{}
	c.GetExtendedProfile()
	c = nil
	c.GetExtendedProfile()
}

func TestConnectionOptionsGoogleApps_GetGroups(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsGoogleApps{Groups: &zeroValue}
	c.GetGroups()
	c = &ConnectionOptionsGoogleApps{}
	c.GetGroups()
	c = nil
	c.GetGroups()
}

func TestConnectionOptionsGoogleApps_GetHandleLoginFromSocial(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsGoogleApps{HandleLoginFromSocial: &zeroValue}
	c.GetHandleLoginFromSocial()
	c = &ConnectionOptionsGoogleApps{}
	c.GetHandleLoginFromSocial()
	c = nil
	c.GetHandleLoginFromSocial()
}

func TestConnectionOptionsGoogleApps_GetIsSuspended(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsGoogleApps{IsSuspended: &zeroValue}
	c.GetIsSuspended()
	c = &ConnectionOptionsGoogleApps{}
	c.GetIsSuspended()
	c = nil
	c.GetIsSuspended()
}

func TestConnectionOptionsGoogleApps_GetLogoURL(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsGoogleApps{LogoURL: &zeroValue}
	c.GetLogoURL()
	c = &ConnectionOptionsGoogleApps{}
	c.GetLogoURL()
	c = nil
	c.GetLogoURL()
}

func TestConnectionOptionsGoogleApps_GetMapUserIDtoID(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsGoogleApps{MapUserIDtoID: &zeroValue}
	c.GetMapUserIDtoID()
	c = &ConnectionOptionsGoogleApps{}
	c.GetMapUserIDtoID()
	c = nil
	c.GetMapUserIDtoID()
}

func TestConnectionOptionsGoogleApps_GetNonPersistentAttrs(tt *testing.T) {
	var zeroValue []string
	c := &ConnectionOptionsGoogleApps{NonPersistentAttrs: &zeroValue}
	c.GetNonPersistentAttrs()
	c = &ConnectionOptionsGoogleApps{}
	c.GetNonPersistentAttrs()
	c = nil
	c.GetNonPersistentAttrs()
}

func TestConnectionOptionsGoogleApps_GetSetUserAttributes(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsGoogleApps{SetUserAttributes: &zeroValue}
	c.GetSetUserAttributes()
	c = &ConnectionOptionsGoogleApps{}
	c.GetSetUserAttributes()
	c = nil
	c.GetSetUserAttributes()
}

func TestConnectionOptionsGoogleApps_GetTenantDomain(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsGoogleApps{TenantDomain: &zeroValue}
	c.GetTenantDomain()
	c = &ConnectionOptionsGoogleApps{}
	c.GetTenantDomain()
	c = nil
	c.GetTenantDomain()
}

func TestConnectionOptionsGoogleApps_GetUpstreamParams(tt *testing.T) {
	zeroValue := map[string]interface{}{}
	c := &ConnectionOptionsGoogleApps{UpstreamParams: zeroValue}
	c.GetUpstreamParams()
	c = &ConnectionOptionsGoogleApps{}
	c.GetUpstreamParams()
	c = nil
	c.GetUpstreamParams()
}

func TestConnectionOptionsGoogleApps_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ConnectionOptionsGoogleApps{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestConnectionOptionsGoogleOAuth2_GetAdsenseManagement(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsGoogleOAuth2{AdsenseManagement: &zeroValue}
	c.GetAdsenseManagement()
	c = &ConnectionOptionsGoogleOAuth2{}
	c.GetAdsenseManagement()
	c = nil
	c.GetAdsenseManagement()
}

func TestConnectionOptionsGoogleOAuth2_GetAllowedAudiences(tt *testing.T) {
	var zeroValue []string
	c := &ConnectionOptionsGoogleOAuth2{AllowedAudiences: &zeroValue}
	c.GetAllowedAudiences()
	c = &ConnectionOptionsGoogleOAuth2{}
	c.GetAllowedAudiences()
	c = nil
	c.GetAllowedAudiences()
}

func TestConnectionOptionsGoogleOAuth2_GetAnalytics(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsGoogleOAuth2{Analytics: &zeroValue}
	c.GetAnalytics()
	c = &ConnectionOptionsGoogleOAuth2{}
	c.GetAnalytics()
	c = nil
	c.GetAnalytics()
}

func TestConnectionOptionsGoogleOAuth2_GetBlogger(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsGoogleOAuth2{Blogger: &zeroValue}
	c.GetBlogger()
	c = &ConnectionOptionsGoogleOAuth2{}
	c.GetBlogger()
	c = nil
	c.GetBlogger()
}

func TestConnectionOptionsGoogleOAuth2_GetCalendar(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsGoogleOAuth2{Calendar: &zeroValue}
	c.GetCalendar()
	c = &ConnectionOptionsGoogleOAuth2{}
	c.GetCalendar()
	c = nil
	c.GetCalendar()
}

func TestConnectionOptionsGoogleOAuth2_GetChromeWebStore(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsGoogleOAuth2{ChromeWebStore: &zeroValue}
	c.GetChromeWebStore()
	c = &ConnectionOptionsGoogleOAuth2{}
	c.GetChromeWebStore()
	c = nil
	c.GetChromeWebStore()
}

func TestConnectionOptionsGoogleOAuth2_GetClientID(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsGoogleOAuth2{ClientID: &zeroValue}
	c.GetClientID()
	c = &ConnectionOptionsGoogleOAuth2{}
	c.GetClientID()
	c = nil
	c.GetClientID()
}

func TestConnectionOptionsGoogleOAuth2_GetClientSecret(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsGoogleOAuth2{ClientSecret: &zeroValue}
	c.GetClientSecret()
	c = &ConnectionOptionsGoogleOAuth2{}
	c.GetClientSecret()
	c = nil
	c.GetClientSecret()
}

func TestConnectionOptionsGoogleOAuth2_GetContacts(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsGoogleOAuth2{Contacts: &zeroValue}
	c.GetContacts()
	c = &ConnectionOptionsGoogleOAuth2{}
	c.GetContacts()
	c = nil
	c.GetContacts()
}

func TestConnectionOptionsGoogleOAuth2_GetContentAPIForShopping(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsGoogleOAuth2{ContentAPIForShopping: &zeroValue}
	c.GetContentAPIForShopping()
	c = &ConnectionOptionsGoogleOAuth2{}
	c.GetContentAPIForShopping()
	c = nil
	c.GetContentAPIForShopping()
}

func TestConnectionOptionsGoogleOAuth2_GetCoordinate(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsGoogleOAuth2{Coordinate: &zeroValue}
	c.GetCoordinate()
	c = &ConnectionOptionsGoogleOAuth2{}
	c.GetCoordinate()
	c = nil
	c.GetCoordinate()
}

func TestConnectionOptionsGoogleOAuth2_GetCoordinateReadonly(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsGoogleOAuth2{CoordinateReadonly: &zeroValue}
	c.GetCoordinateReadonly()
	c = &ConnectionOptionsGoogleOAuth2{}
	c.GetCoordinateReadonly()
	c = nil
	c.GetCoordinateReadonly()
}

func TestConnectionOptionsGoogleOAuth2_GetDocumentList(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsGoogleOAuth2{DocumentList: &zeroValue}
	c.GetDocumentList()
	c = &ConnectionOptionsGoogleOAuth2{}
	c.GetDocumentList()
	c = nil
	c.GetDocumentList()
}

func TestConnectionOptionsGoogleOAuth2_GetEmail(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsGoogleOAuth2{Email: &zeroValue}
	c.GetEmail()
	c = &ConnectionOptionsGoogleOAuth2{}
	c.GetEmail()
	c = nil
	c.GetEmail()
}

func TestConnectionOptionsGoogleOAuth2_GetGmail(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsGoogleOAuth2{Gmail: &zeroValue}
	c.GetGmail()
	c = &ConnectionOptionsGoogleOAuth2{}
	c.GetGmail()
	c = nil
	c.GetGmail()
}

func TestConnectionOptionsGoogleOAuth2_GetGoogleAffiliateNetwork(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsGoogleOAuth2{GoogleAffiliateNetwork: &zeroValue}
	c.GetGoogleAffiliateNetwork()
	c = &ConnectionOptionsGoogleOAuth2{}
	c.GetGoogleAffiliateNetwork()
	c = nil
	c.GetGoogleAffiliateNetwork()
}

func TestConnectionOptionsGoogleOAuth2_GetGoogleBooks(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsGoogleOAuth2{GoogleBooks: &zeroValue}
	c.GetGoogleBooks()
	c = &ConnectionOptionsGoogleOAuth2{}
	c.GetGoogleBooks()
	c = nil
	c.GetGoogleBooks()
}

func TestConnectionOptionsGoogleOAuth2_GetGoogleCloudStorage(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsGoogleOAuth2{GoogleCloudStorage: &zeroValue}
	c.GetGoogleCloudStorage()
	c = &ConnectionOptionsGoogleOAuth2{}
	c.GetGoogleCloudStorage()
	c = nil
	c.GetGoogleCloudStorage()
}

func TestConnectionOptionsGoogleOAuth2_GetGoogleDrive(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsGoogleOAuth2{GoogleDrive: &zeroValue}
	c.GetGoogleDrive()
	c = &ConnectionOptionsGoogleOAuth2{}
	c.GetGoogleDrive()
	c = nil
	c.GetGoogleDrive()
}

func TestConnectionOptionsGoogleOAuth2_GetGoogleDriveFiles(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsGoogleOAuth2{GoogleDriveFiles: &zeroValue}
	c.GetGoogleDriveFiles()
	c = &ConnectionOptionsGoogleOAuth2{}
	c.GetGoogleDriveFiles()
	c = nil
	c.GetGoogleDriveFiles()
}

func TestConnectionOptionsGoogleOAuth2_GetGooglePlus(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsGoogleOAuth2{GooglePlus: &zeroValue}
	c.GetGooglePlus()
	c = &ConnectionOptionsGoogleOAuth2{}
	c.GetGooglePlus()
	c = nil
	c.GetGooglePlus()
}

func TestConnectionOptionsGoogleOAuth2_GetLatitudeBest(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsGoogleOAuth2{LatitudeBest: &zeroValue}
	c.GetLatitudeBest()
	c = &ConnectionOptionsGoogleOAuth2{}
	c.GetLatitudeBest()
	c = nil
	c.GetLatitudeBest()
}

func TestConnectionOptionsGoogleOAuth2_GetLatitudeCity(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsGoogleOAuth2{LatitudeCity: &zeroValue}
	c.GetLatitudeCity()
	c = &ConnectionOptionsGoogleOAuth2{}
	c.GetLatitudeCity()
	c = nil
	c.GetLatitudeCity()
}

func TestConnectionOptionsGoogleOAuth2_GetModerator(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsGoogleOAuth2{Moderator: &zeroValue}
	c.GetModerator()
	c = &ConnectionOptionsGoogleOAuth2{}
	c.GetModerator()
	c = nil
	c.GetModerator()
}

func TestConnectionOptionsGoogleOAuth2_GetNonPersistentAttrs(tt *testing.T) {
	var zeroValue []string
	c := &ConnectionOptionsGoogleOAuth2{NonPersistentAttrs: &zeroValue}
	c.GetNonPersistentAttrs()
	c = &ConnectionOptionsGoogleOAuth2{}
	c.GetNonPersistentAttrs()
	c = nil
	c.GetNonPersistentAttrs()
}

func TestConnectionOptionsGoogleOAuth2_GetOrkut(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsGoogleOAuth2{Orkut: &zeroValue}
	c.GetOrkut()
	c = &ConnectionOptionsGoogleOAuth2{}
	c.GetOrkut()
	c = nil
	c.GetOrkut()
}

func TestConnectionOptionsGoogleOAuth2_GetPicasaWeb(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsGoogleOAuth2{PicasaWeb: &zeroValue}
	c.GetPicasaWeb()
	c = &ConnectionOptionsGoogleOAuth2{}
	c.GetPicasaWeb()
	c = nil
	c.GetPicasaWeb()
}

func TestConnectionOptionsGoogleOAuth2_GetProfile(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsGoogleOAuth2{Profile: &zeroValue}
	c.GetProfile()
	c = &ConnectionOptionsGoogleOAuth2{}
	c.GetProfile()
	c = nil
	c.GetProfile()
}

func TestConnectionOptionsGoogleOAuth2_GetSetUserAttributes(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsGoogleOAuth2{SetUserAttributes: &zeroValue}
	c.GetSetUserAttributes()
	c = &ConnectionOptionsGoogleOAuth2{}
	c.GetSetUserAttributes()
	c = nil
	c.GetSetUserAttributes()
}

func TestConnectionOptionsGoogleOAuth2_GetSites(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsGoogleOAuth2{Sites: &zeroValue}
	c.GetSites()
	c = &ConnectionOptionsGoogleOAuth2{}
	c.GetSites()
	c = nil
	c.GetSites()
}

func TestConnectionOptionsGoogleOAuth2_GetSpreadsheets(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsGoogleOAuth2{Spreadsheets: &zeroValue}
	c.GetSpreadsheets()
	c = &ConnectionOptionsGoogleOAuth2{}
	c.GetSpreadsheets()
	c = nil
	c.GetSpreadsheets()
}

func TestConnectionOptionsGoogleOAuth2_GetTasks(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsGoogleOAuth2{Tasks: &zeroValue}
	c.GetTasks()
	c = &ConnectionOptionsGoogleOAuth2{}
	c.GetTasks()
	c = nil
	c.GetTasks()
}

func TestConnectionOptionsGoogleOAuth2_GetUpstreamParams(tt *testing.T) {
	zeroValue := map[string]interface{}{}
	c := &ConnectionOptionsGoogleOAuth2{UpstreamParams: zeroValue}
	c.GetUpstreamParams()
	c = &ConnectionOptionsGoogleOAuth2{}
	c.GetUpstreamParams()
	c = nil
	c.GetUpstreamParams()
}

func TestConnectionOptionsGoogleOAuth2_GetURLShortener(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsGoogleOAuth2{URLShortener: &zeroValue}
	c.GetURLShortener()
	c = &ConnectionOptionsGoogleOAuth2{}
	c.GetURLShortener()
	c = nil
	c.GetURLShortener()
}

func TestConnectionOptionsGoogleOAuth2_GetWebmasterTools(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsGoogleOAuth2{WebmasterTools: &zeroValue}
	c.GetWebmasterTools()
	c = &ConnectionOptionsGoogleOAuth2{}
	c.GetWebmasterTools()
	c = nil
	c.GetWebmasterTools()
}

func TestConnectionOptionsGoogleOAuth2_GetYoutube(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsGoogleOAuth2{Youtube: &zeroValue}
	c.GetYoutube()
	c = &ConnectionOptionsGoogleOAuth2{}
	c.GetYoutube()
	c = nil
	c.GetYoutube()
}

func TestConnectionOptionsGoogleOAuth2_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ConnectionOptionsGoogleOAuth2{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestConnectionOptionsLinkedin_GetBasicProfile(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsLinkedin{BasicProfile: &zeroValue}
	c.GetBasicProfile()
	c = &ConnectionOptionsLinkedin{}
	c.GetBasicProfile()
	c = nil
	c.GetBasicProfile()
}

func TestConnectionOptionsLinkedin_GetClientID(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsLinkedin{ClientID: &zeroValue}
	c.GetClientID()
	c = &ConnectionOptionsLinkedin{}
	c.GetClientID()
	c = nil
	c.GetClientID()
}

func TestConnectionOptionsLinkedin_GetClientSecret(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsLinkedin{ClientSecret: &zeroValue}
	c.GetClientSecret()
	c = &ConnectionOptionsLinkedin{}
	c.GetClientSecret()
	c = nil
	c.GetClientSecret()
}

func TestConnectionOptionsLinkedin_GetEmail(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsLinkedin{Email: &zeroValue}
	c.GetEmail()
	c = &ConnectionOptionsLinkedin{}
	c.GetEmail()
	c = nil
	c.GetEmail()
}

func TestConnectionOptionsLinkedin_GetNonPersistentAttrs(tt *testing.T) {
	var zeroValue []string
	c := &ConnectionOptionsLinkedin{NonPersistentAttrs: &zeroValue}
	c.GetNonPersistentAttrs()
	c = &ConnectionOptionsLinkedin{}
	c.GetNonPersistentAttrs()
	c = nil
	c.GetNonPersistentAttrs()
}

func TestConnectionOptionsLinkedin_GetProfile(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsLinkedin{Profile: &zeroValue}
	c.GetProfile()
	c = &ConnectionOptionsLinkedin{}
	c.GetProfile()
	c = nil
	c.GetProfile()
}

func TestConnectionOptionsLinkedin_GetSetUserAttributes(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsLinkedin{SetUserAttributes: &zeroValue}
	c.GetSetUserAttributes()
	c = &ConnectionOptionsLinkedin{}
	c.GetSetUserAttributes()
	c = nil
	c.GetSetUserAttributes()
}

func TestConnectionOptionsLinkedin_GetStrategyVersion(tt *testing.T) {
	var zeroValue int
	c := &ConnectionOptionsLinkedin{StrategyVersion: &zeroValue}
	c.GetStrategyVersion()
	c = &ConnectionOptionsLinkedin{}
	c.GetStrategyVersion()
	c = nil
	c.GetStrategyVersion()
}

func TestConnectionOptionsLinkedin_GetUpstreamParams(tt *testing.T) {
	zeroValue := map[string]interface{}{}
	c := &ConnectionOptionsLinkedin{UpstreamParams: zeroValue}
	c.GetUpstreamParams()
	c = &ConnectionOptionsLinkedin{}
	c.GetUpstreamParams()
	c = nil
	c.GetUpstreamParams()
}

func TestConnectionOptionsLinkedin_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ConnectionOptionsLinkedin{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestConnectionOptionsOAuth2_GetAuthorizationURL(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsOAuth2{AuthorizationURL: &zeroValue}
	c.GetAuthorizationURL()
	c = &ConnectionOptionsOAuth2{}
	c.GetAuthorizationURL()
	c = nil
	c.GetAuthorizationURL()
}

func TestConnectionOptionsOAuth2_GetClientID(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsOAuth2{ClientID: &zeroValue}
	c.GetClientID()
	c = &ConnectionOptionsOAuth2{}
	c.GetClientID()
	c = nil
	c.GetClientID()
}

func TestConnectionOptionsOAuth2_GetClientSecret(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsOAuth2{ClientSecret: &zeroValue}
	c.GetClientSecret()
	c = &ConnectionOptionsOAuth2{}
	c.GetClientSecret()
	c = nil
	c.GetClientSecret()
}

func TestConnectionOptionsOAuth2_GetCustomHeaders(tt *testing.T) {
	var zeroValue []map[string]string
	c := &ConnectionOptionsOAuth2{CustomHeaders: &zeroValue}
	c.GetCustomHeaders()
	c = &ConnectionOptionsOAuth2{}
	c.GetCustomHeaders()
	c = nil
	c.GetCustomHeaders()
}

func TestConnectionOptionsOAuth2_GetLogoURL(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsOAuth2{LogoURL: &zeroValue}
	c.GetLogoURL()
	c = &ConnectionOptionsOAuth2{}
	c.GetLogoURL()
	c = nil
	c.GetLogoURL()
}

func TestConnectionOptionsOAuth2_GetNonPersistentAttrs(tt *testing.T) {
	var zeroValue []string
	c := &ConnectionOptionsOAuth2{NonPersistentAttrs: &zeroValue}
	c.GetNonPersistentAttrs()
	c = &ConnectionOptionsOAuth2{}
	c.GetNonPersistentAttrs()
	c = nil
	c.GetNonPersistentAttrs()
}

func TestConnectionOptionsOAuth2_GetPKCEEnabled(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsOAuth2{PKCEEnabled: &zeroValue}
	c.GetPKCEEnabled()
	c = &ConnectionOptionsOAuth2{}
	c.GetPKCEEnabled()
	c = nil
	c.GetPKCEEnabled()
}

func TestConnectionOptionsOAuth2_GetScope(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsOAuth2{Scope: &zeroValue}
	c.GetScope()
	c = &ConnectionOptionsOAuth2{}
	c.GetScope()
	c = nil
	c.GetScope()
}

func TestConnectionOptionsOAuth2_GetScripts(tt *testing.T) {
	var zeroValue map[string]string
	c := &ConnectionOptionsOAuth2{Scripts: &zeroValue}
	c.GetScripts()
	c = &ConnectionOptionsOAuth2{}
	c.GetScripts()
	c = nil
	c.GetScripts()
}

func TestConnectionOptionsOAuth2_GetSetUserAttributes(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsOAuth2{SetUserAttributes: &zeroValue}
	c.GetSetUserAttributes()
	c = &ConnectionOptionsOAuth2{}
	c.GetSetUserAttributes()
	c = nil
	c.GetSetUserAttributes()
}

func TestConnectionOptionsOAuth2_GetStrategyVersion(tt *testing.T) {
	var zeroValue int
	c := &ConnectionOptionsOAuth2{StrategyVersion: &zeroValue}
	c.GetStrategyVersion()
	c = &ConnectionOptionsOAuth2{}
	c.GetStrategyVersion()
	c = nil
	c.GetStrategyVersion()
}

func TestConnectionOptionsOAuth2_GetTokenURL(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsOAuth2{TokenURL: &zeroValue}
	c.GetTokenURL()
	c = &ConnectionOptionsOAuth2{}
	c.GetTokenURL()
	c = nil
	c.GetTokenURL()
}

func TestConnectionOptionsOAuth2_GetUpstreamParams(tt *testing.T) {
	zeroValue := map[string]interface{}{}
	c := &ConnectionOptionsOAuth2{UpstreamParams: zeroValue}
	c.GetUpstreamParams()
	c = &ConnectionOptionsOAuth2{}
	c.GetUpstreamParams()
	c = nil
	c.GetUpstreamParams()
}

func TestConnectionOptionsOAuth2_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ConnectionOptionsOAuth2{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestConnectionOptionsOIDC_GetAttributeMap(tt *testing.T) {
	c := &ConnectionOptionsOIDC{}
	c.GetAttributeMap()
	c = nil
	c.GetAttributeMap()
}

func TestConnectionOptionsOIDC_GetAuthorizationEndpoint(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsOIDC{AuthorizationEndpoint: &zeroValue}
	c.GetAuthorizationEndpoint()
	c = &ConnectionOptionsOIDC{}
	c.GetAuthorizationEndpoint()
	c = nil
	c.GetAuthorizationEndpoint()
}

func TestConnectionOptionsOIDC_GetClientID(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsOIDC{ClientID: &zeroValue}
	c.GetClientID()
	c = &ConnectionOptionsOIDC{}
	c.GetClientID()
	c = nil
	c.GetClientID()
}

func TestConnectionOptionsOIDC_GetClientSecret(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsOIDC{ClientSecret: &zeroValue}
	c.GetClientSecret()
	c = &ConnectionOptionsOIDC{}
	c.GetClientSecret()
	c = nil
	c.GetClientSecret()
}

func TestConnectionOptionsOIDC_GetConnectionSettings(tt *testing.T) {
	c := &ConnectionOptionsOIDC{}
	c.GetConnectionSettings()
	c = nil
	c.GetConnectionSettings()
}

func TestConnectionOptionsOIDC_GetDiscoveryURL(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsOIDC{DiscoveryURL: &zeroValue}
	c.GetDiscoveryURL()
	c = &ConnectionOptionsOIDC{}
	c.GetDiscoveryURL()
	c = nil
	c.GetDiscoveryURL()
}

func TestConnectionOptionsOIDC_GetDomainAliases(tt *testing.T) {
	var zeroValue []string
	c := &ConnectionOptionsOIDC{DomainAliases: &zeroValue}
	c.GetDomainAliases()
	c = &ConnectionOptionsOIDC{}
	c.GetDomainAliases()
	c = nil
	c.GetDomainAliases()
}

func TestConnectionOptionsOIDC_GetIssuer(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsOIDC{Issuer: &zeroValue}
	c.GetIssuer()
	c = &ConnectionOptionsOIDC{}
	c.GetIssuer()
	c = nil
	c.GetIssuer()
}

func TestConnectionOptionsOIDC_GetJWKSURI(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsOIDC{JWKSURI: &zeroValue}
	c.GetJWKSURI()
	c = &ConnectionOptionsOIDC{}
	c.GetJWKSURI()
	c = nil
	c.GetJWKSURI()
}

func TestConnectionOptionsOIDC_GetLogoURL(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsOIDC{LogoURL: &zeroValue}
	c.GetLogoURL()
	c = &ConnectionOptionsOIDC{}
	c.GetLogoURL()
	c = nil
	c.GetLogoURL()
}

func TestConnectionOptionsOIDC_GetNonPersistentAttrs(tt *testing.T) {
	var zeroValue []string
	c := &ConnectionOptionsOIDC{NonPersistentAttrs: &zeroValue}
	c.GetNonPersistentAttrs()
	c = &ConnectionOptionsOIDC{}
	c.GetNonPersistentAttrs()
	c = nil
	c.GetNonPersistentAttrs()
}

func TestConnectionOptionsOIDC_GetScope(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsOIDC{Scope: &zeroValue}
	c.GetScope()
	c = &ConnectionOptionsOIDC{}
	c.GetScope()
	c = nil
	c.GetScope()
}

func TestConnectionOptionsOIDC_GetSetUserAttributes(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsOIDC{SetUserAttributes: &zeroValue}
	c.GetSetUserAttributes()
	c = &ConnectionOptionsOIDC{}
	c.GetSetUserAttributes()
	c = nil
	c.GetSetUserAttributes()
}

func TestConnectionOptionsOIDC_GetTenantDomain(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsOIDC{TenantDomain: &zeroValue}
	c.GetTenantDomain()
	c = &ConnectionOptionsOIDC{}
	c.GetTenantDomain()
	c = nil
	c.GetTenantDomain()
}

func TestConnectionOptionsOIDC_GetTokenEndpoint(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsOIDC{TokenEndpoint: &zeroValue}
	c.GetTokenEndpoint()
	c = &ConnectionOptionsOIDC{}
	c.GetTokenEndpoint()
	c = nil
	c.GetTokenEndpoint()
}

func TestConnectionOptionsOIDC_GetType(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsOIDC{Type: &zeroValue}
	c.GetType()
	c = &ConnectionOptionsOIDC{}
	c.GetType()
	c = nil
	c.GetType()
}

func TestConnectionOptionsOIDC_GetUpstreamParams(tt *testing.T) {
	zeroValue := map[string]interface{}{}
	c := &ConnectionOptionsOIDC{UpstreamParams: zeroValue}
	c.GetUpstreamParams()
	c = &ConnectionOptionsOIDC{}
	c.GetUpstreamParams()
	c = nil
	c.GetUpstreamParams()
}

func TestConnectionOptionsOIDC_GetUserInfoEndpoint(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsOIDC{UserInfoEndpoint: &zeroValue}
	c.GetUserInfoEndpoint()
	c = &ConnectionOptionsOIDC{}
	c.GetUserInfoEndpoint()
	c = nil
	c.GetUserInfoEndpoint()
}

func TestConnectionOptionsOIDC_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ConnectionOptionsOIDC{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestConnectionOptionsOIDCAttributeMap_GetAttributes(tt *testing.T) {
	zeroValue := map[string]interface{}{}
	c := &ConnectionOptionsOIDCAttributeMap{Attributes: zeroValue}
	c.GetAttributes()
	c = &ConnectionOptionsOIDCAttributeMap{}
	c.GetAttributes()
	c = nil
	c.GetAttributes()
}

func TestConnectionOptionsOIDCAttributeMap_GetMappingMode(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsOIDCAttributeMap{MappingMode: &zeroValue}
	c.GetMappingMode()
	c = &ConnectionOptionsOIDCAttributeMap{}
	c.GetMappingMode()
	c = nil
	c.GetMappingMode()
}

func TestConnectionOptionsOIDCAttributeMap_GetUserInfoScope(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsOIDCAttributeMap{UserInfoScope: &zeroValue}
	c.GetUserInfoScope()
	c = &ConnectionOptionsOIDCAttributeMap{}
	c.GetUserInfoScope()
	c = nil
	c.GetUserInfoScope()
}

func TestConnectionOptionsOIDCAttributeMap_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ConnectionOptionsOIDCAttributeMap{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestConnectionOptionsOIDCConnectionSettings_GetPKCE(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsOIDCConnectionSettings{PKCE: &zeroValue}
	c.GetPKCE()
	c = &ConnectionOptionsOIDCConnectionSettings{}
	c.GetPKCE()
	c = nil
	c.GetPKCE()
}

func TestConnectionOptionsOIDCConnectionSettings_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ConnectionOptionsOIDCConnectionSettings{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestConnectionOptionsOkta_GetAttributeMap(tt *testing.T) {
	c := &ConnectionOptionsOkta{}
	c.GetAttributeMap()
	c = nil
	c.GetAttributeMap()
}

func TestConnectionOptionsOkta_GetAuthorizationEndpoint(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsOkta{AuthorizationEndpoint: &zeroValue}
	c.GetAuthorizationEndpoint()
	c = &ConnectionOptionsOkta{}
	c.GetAuthorizationEndpoint()
	c = nil
	c.GetAuthorizationEndpoint()
}

func TestConnectionOptionsOkta_GetClientID(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsOkta{ClientID: &zeroValue}
	c.GetClientID()
	c = &ConnectionOptionsOkta{}
	c.GetClientID()
	c = nil
	c.GetClientID()
}

func TestConnectionOptionsOkta_GetClientSecret(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsOkta{ClientSecret: &zeroValue}
	c.GetClientSecret()
	c = &ConnectionOptionsOkta{}
	c.GetClientSecret()
	c = nil
	c.GetClientSecret()
}

func TestConnectionOptionsOkta_GetConnectionSettings(tt *testing.T) {
	c := &ConnectionOptionsOkta{}
	c.GetConnectionSettings()
	c = nil
	c.GetConnectionSettings()
}

func TestConnectionOptionsOkta_GetDomain(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsOkta{Domain: &zeroValue}
	c.GetDomain()
	c = &ConnectionOptionsOkta{}
	c.GetDomain()
	c = nil
	c.GetDomain()
}

func TestConnectionOptionsOkta_GetDomainAliases(tt *testing.T) {
	var zeroValue []string
	c := &ConnectionOptionsOkta{DomainAliases: &zeroValue}
	c.GetDomainAliases()
	c = &ConnectionOptionsOkta{}
	c.GetDomainAliases()
	c = nil
	c.GetDomainAliases()
}

func TestConnectionOptionsOkta_GetIssuer(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsOkta{Issuer: &zeroValue}
	c.GetIssuer()
	c = &ConnectionOptionsOkta{}
	c.GetIssuer()
	c = nil
	c.GetIssuer()
}

func TestConnectionOptionsOkta_GetJWKSURI(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsOkta{JWKSURI: &zeroValue}
	c.GetJWKSURI()
	c = &ConnectionOptionsOkta{}
	c.GetJWKSURI()
	c = nil
	c.GetJWKSURI()
}

func TestConnectionOptionsOkta_GetLogoURL(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsOkta{LogoURL: &zeroValue}
	c.GetLogoURL()
	c = &ConnectionOptionsOkta{}
	c.GetLogoURL()
	c = nil
	c.GetLogoURL()
}

func TestConnectionOptionsOkta_GetNonPersistentAttrs(tt *testing.T) {
	var zeroValue []string
	c := &ConnectionOptionsOkta{NonPersistentAttrs: &zeroValue}
	c.GetNonPersistentAttrs()
	c = &ConnectionOptionsOkta{}
	c.GetNonPersistentAttrs()
	c = nil
	c.GetNonPersistentAttrs()
}

func TestConnectionOptionsOkta_GetScope(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsOkta{Scope: &zeroValue}
	c.GetScope()
	c = &ConnectionOptionsOkta{}
	c.GetScope()
	c = nil
	c.GetScope()
}

func TestConnectionOptionsOkta_GetSetUserAttributes(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsOkta{SetUserAttributes: &zeroValue}
	c.GetSetUserAttributes()
	c = &ConnectionOptionsOkta{}
	c.GetSetUserAttributes()
	c = nil
	c.GetSetUserAttributes()
}

func TestConnectionOptionsOkta_GetTokenEndpoint(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsOkta{TokenEndpoint: &zeroValue}
	c.GetTokenEndpoint()
	c = &ConnectionOptionsOkta{}
	c.GetTokenEndpoint()
	c = nil
	c.GetTokenEndpoint()
}

func TestConnectionOptionsOkta_GetUpstreamParams(tt *testing.T) {
	zeroValue := map[string]interface{}{}
	c := &ConnectionOptionsOkta{UpstreamParams: zeroValue}
	c.GetUpstreamParams()
	c = &ConnectionOptionsOkta{}
	c.GetUpstreamParams()
	c = nil
	c.GetUpstreamParams()
}

func TestConnectionOptionsOkta_GetUserInfoEndpoint(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsOkta{UserInfoEndpoint: &zeroValue}
	c.GetUserInfoEndpoint()
	c = &ConnectionOptionsOkta{}
	c.GetUserInfoEndpoint()
	c = nil
	c.GetUserInfoEndpoint()
}

func TestConnectionOptionsOkta_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ConnectionOptionsOkta{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestConnectionOptionsOTP_GetLength(tt *testing.T) {
	var zeroValue int
	c := &ConnectionOptionsOTP{Length: &zeroValue}
	c.GetLength()
	c = &ConnectionOptionsOTP{}
	c.GetLength()
	c = nil
	c.GetLength()
}

func TestConnectionOptionsOTP_GetTimeStep(tt *testing.T) {
	var zeroValue int
	c := &ConnectionOptionsOTP{TimeStep: &zeroValue}
	c.GetTimeStep()
	c = &ConnectionOptionsOTP{}
	c.GetTimeStep()
	c = nil
	c.GetTimeStep()
}

func TestConnectionOptionsOTP_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ConnectionOptionsOTP{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestConnectionOptionsPhoneNumberAttribute_GetIdentifier(tt *testing.T) {
	c := &ConnectionOptionsPhoneNumberAttribute{}
	c.GetIdentifier()
	c = nil
	c.GetIdentifier()
}

func TestConnectionOptionsPhoneNumberAttribute_GetProfileRequired(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsPhoneNumberAttribute{ProfileRequired: &zeroValue}
	c.GetProfileRequired()
	c = &ConnectionOptionsPhoneNumberAttribute{}
	c.GetProfileRequired()
	c = nil
	c.GetProfileRequired()
}

func TestConnectionOptionsPhoneNumberAttribute_GetSignup(tt *testing.T) {
	c := &ConnectionOptionsPhoneNumberAttribute{}
	c.GetSignup()
	c = nil
	c.GetSignup()
}

func TestConnectionOptionsPhoneNumberAttribute_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ConnectionOptionsPhoneNumberAttribute{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestConnectionOptionsPingFederate_GetAgentIP(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsPingFederate{AgentIP: &zeroValue}
	c.GetAgentIP()
	c = &ConnectionOptionsPingFederate{}
	c.GetAgentIP()
	c = nil
	c.GetAgentIP()
}

func TestConnectionOptionsPingFederate_GetAgentMode(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsPingFederate{AgentMode: &zeroValue}
	c.GetAgentMode()
	c = &ConnectionOptionsPingFederate{}
	c.GetAgentMode()
	c = nil
	c.GetAgentMode()
}

func TestConnectionOptionsPingFederate_GetAgentVersion(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsPingFederate{AgentVersion: &zeroValue}
	c.GetAgentVersion()
	c = &ConnectionOptionsPingFederate{}
	c.GetAgentVersion()
	c = nil
	c.GetAgentVersion()
}

func TestConnectionOptionsPingFederate_GetAPIEnableUsers(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsPingFederate{APIEnableUsers: &zeroValue}
	c.GetAPIEnableUsers()
	c = &ConnectionOptionsPingFederate{}
	c.GetAPIEnableUsers()
	c = nil
	c.GetAPIEnableUsers()
}

func TestConnectionOptionsPingFederate_GetBindingMethod(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsPingFederate{BindingMethod: &zeroValue}
	c.GetBindingMethod()
	c = &ConnectionOptionsPingFederate{}
	c.GetBindingMethod()
	c = nil
	c.GetBindingMethod()
}

func TestConnectionOptionsPingFederate_GetCert(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsPingFederate{Cert: &zeroValue}
	c.GetCert()
	c = &ConnectionOptionsPingFederate{}
	c.GetCert()
	c = nil
	c.GetCert()
}

func TestConnectionOptionsPingFederate_GetCertRolloverNotification(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsPingFederate{CertRolloverNotification: &zeroValue}
	c.GetCertRolloverNotification()
	c = &ConnectionOptionsPingFederate{}
	c.GetCertRolloverNotification()
	c = nil
	c.GetCertRolloverNotification()
}

func TestConnectionOptionsPingFederate_GetDebug(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsPingFederate{Debug: &zeroValue}
	c.GetDebug()
	c = &ConnectionOptionsPingFederate{}
	c.GetDebug()
	c = nil
	c.GetDebug()
}

func TestConnectionOptionsPingFederate_GetDecryptionKey(tt *testing.T) {
	c := &ConnectionOptionsPingFederate{}
	c.GetDecryptionKey()
	c = nil
	c.GetDecryptionKey()
}

func TestConnectionOptionsPingFederate_GetDigestAlgorithm(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsPingFederate{DigestAlgorithm: &zeroValue}
	c.GetDigestAlgorithm()
	c = &ConnectionOptionsPingFederate{}
	c.GetDigestAlgorithm()
	c = nil
	c.GetDigestAlgorithm()
}

func TestConnectionOptionsPingFederate_GetDisableSignout(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsPingFederate{DisableSignout: &zeroValue}
	c.GetDisableSignout()
	c = &ConnectionOptionsPingFederate{}
	c.GetDisableSignout()
	c = nil
	c.GetDisableSignout()
}

func TestConnectionOptionsPingFederate_GetDomainAliases(tt *testing.T) {
	var zeroValue []string
	c := &ConnectionOptionsPingFederate{DomainAliases: &zeroValue}
	c.GetDomainAliases()
	c = &ConnectionOptionsPingFederate{}
	c.GetDomainAliases()
	c = nil
	c.GetDomainAliases()
}

func TestConnectionOptionsPingFederate_GetEntityID(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsPingFederate{EntityID: &zeroValue}
	c.GetEntityID()
	c = &ConnectionOptionsPingFederate{}
	c.GetEntityID()
	c = nil
	c.GetEntityID()
}

func TestConnectionOptionsPingFederate_GetExpires(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsPingFederate{Expires: &zeroValue}
	c.GetExpires()
	c = &ConnectionOptionsPingFederate{}
	c.GetExpires()
	c = nil
	c.GetExpires()
}

func TestConnectionOptionsPingFederate_GetExtGroups(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsPingFederate{ExtGroups: &zeroValue}
	c.GetExtGroups()
	c = &ConnectionOptionsPingFederate{}
	c.GetExtGroups()
	c = nil
	c.GetExtGroups()
}

func TestConnectionOptionsPingFederate_GetExtProfile(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsPingFederate{ExtProfile: &zeroValue}
	c.GetExtProfile()
	c = &ConnectionOptionsPingFederate{}
	c.GetExtProfile()
	c = nil
	c.GetExtProfile()
}

func TestConnectionOptionsPingFederate_GetFieldsMap(tt *testing.T) {
	zeroValue := map[string]interface{}{}
	c := &ConnectionOptionsPingFederate{FieldsMap: zeroValue}
	c.GetFieldsMap()
	c = &ConnectionOptionsPingFederate{}
	c.GetFieldsMap()
	c = nil
	c.GetFieldsMap()
}

func TestConnectionOptionsPingFederate_GetIdpInitiated(tt *testing.T) {
	c := &ConnectionOptionsPingFederate{}
	c.GetIdpInitiated()
	c = nil
	c.GetIdpInitiated()
}

func TestConnectionOptionsPingFederate_GetLogoURL(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsPingFederate{LogoURL: &zeroValue}
	c.GetLogoURL()
	c = &ConnectionOptionsPingFederate{}
	c.GetLogoURL()
	c = nil
	c.GetLogoURL()
}

func TestConnectionOptionsPingFederate_GetMetadataURL(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsPingFederate{MetadataURL: &zeroValue}
	c.GetMetadataURL()
	c = &ConnectionOptionsPingFederate{}
	c.GetMetadataURL()
	c = nil
	c.GetMetadataURL()
}

func TestConnectionOptionsPingFederate_GetMetadataXML(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsPingFederate{MetadataXML: &zeroValue}
	c.GetMetadataXML()
	c = &ConnectionOptionsPingFederate{}
	c.GetMetadataXML()
	c = nil
	c.GetMetadataXML()
}

func TestConnectionOptionsPingFederate_GetNonPersistentAttrs(tt *testing.T) {
	var zeroValue []string
	c := &ConnectionOptionsPingFederate{NonPersistentAttrs: &zeroValue}
	c.GetNonPersistentAttrs()
	c = &ConnectionOptionsPingFederate{}
	c.GetNonPersistentAttrs()
	c = nil
	c.GetNonPersistentAttrs()
}

func TestConnectionOptionsPingFederate_GetPingFederateBaseURL(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsPingFederate{PingFederateBaseURL: &zeroValue}
	c.GetPingFederateBaseURL()
	c = &ConnectionOptionsPingFederate{}
	c.GetPingFederateBaseURL()
	c = nil
	c.GetPingFederateBaseURL()
}

func TestConnectionOptionsPingFederate_GetProtocolBinding(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsPingFederate{ProtocolBinding: &zeroValue}
	c.GetProtocolBinding()
	c = &ConnectionOptionsPingFederate{}
	c.GetProtocolBinding()
	c = nil
	c.GetProtocolBinding()
}

func TestConnectionOptionsPingFederate_GetRequestTemplate(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsPingFederate{RequestTemplate: &zeroValue}
	c.GetRequestTemplate()
	c = &ConnectionOptionsPingFederate{}
	c.GetRequestTemplate()
	c = nil
	c.GetRequestTemplate()
}

func TestConnectionOptionsPingFederate_GetSetUserAttributes(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsPingFederate{SetUserAttributes: &zeroValue}
	c.GetSetUserAttributes()
	c = &ConnectionOptionsPingFederate{}
	c.GetSetUserAttributes()
	c = nil
	c.GetSetUserAttributes()
}

func TestConnectionOptionsPingFederate_GetSignatureAlgorithm(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsPingFederate{SignatureAlgorithm: &zeroValue}
	c.GetSignatureAlgorithm()
	c = &ConnectionOptionsPingFederate{}
	c.GetSignatureAlgorithm()
	c = nil
	c.GetSignatureAlgorithm()
}

func TestConnectionOptionsPingFederate_GetSignInEndpoint(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsPingFederate{SignInEndpoint: &zeroValue}
	c.GetSignInEndpoint()
	c = &ConnectionOptionsPingFederate{}
	c.GetSignInEndpoint()
	c = nil
	c.GetSignInEndpoint()
}

func TestConnectionOptionsPingFederate_GetSigningCert(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsPingFederate{SigningCert: &zeroValue}
	c.GetSigningCert()
	c = &ConnectionOptionsPingFederate{}
	c.GetSigningCert()
	c = nil
	c.GetSigningCert()
}

func TestConnectionOptionsPingFederate_GetSigningKey(tt *testing.T) {
	c := &ConnectionOptionsPingFederate{}
	c.GetSigningKey()
	c = nil
	c.GetSigningKey()
}

func TestConnectionOptionsPingFederate_GetSignOutEndpoint(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsPingFederate{SignOutEndpoint: &zeroValue}
	c.GetSignOutEndpoint()
	c = &ConnectionOptionsPingFederate{}
	c.GetSignOutEndpoint()
	c = nil
	c.GetSignOutEndpoint()
}

func TestConnectionOptionsPingFederate_GetSignSAMLRequest(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsPingFederate{SignSAMLRequest: &zeroValue}
	c.GetSignSAMLRequest()
	c = &ConnectionOptionsPingFederate{}
	c.GetSignSAMLRequest()
	c = nil
	c.GetSignSAMLRequest()
}

func TestConnectionOptionsPingFederate_GetSubject(tt *testing.T) {
	zeroValue := map[string]interface{}{}
	c := &ConnectionOptionsPingFederate{Subject: zeroValue}
	c.GetSubject()
	c = &ConnectionOptionsPingFederate{}
	c.GetSubject()
	c = nil
	c.GetSubject()
}

func TestConnectionOptionsPingFederate_GetTenantDomain(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsPingFederate{TenantDomain: &zeroValue}
	c.GetTenantDomain()
	c = &ConnectionOptionsPingFederate{}
	c.GetTenantDomain()
	c = nil
	c.GetTenantDomain()
}

func TestConnectionOptionsPingFederate_GetThumbprints(tt *testing.T) {
	var zeroValue []string
	c := &ConnectionOptionsPingFederate{Thumbprints: &zeroValue}
	c.GetThumbprints()
	c = &ConnectionOptionsPingFederate{}
	c.GetThumbprints()
	c = nil
	c.GetThumbprints()
}

func TestConnectionOptionsPingFederate_GetUpstreamParams(tt *testing.T) {
	zeroValue := map[string]interface{}{}
	c := &ConnectionOptionsPingFederate{UpstreamParams: zeroValue}
	c.GetUpstreamParams()
	c = &ConnectionOptionsPingFederate{}
	c.GetUpstreamParams()
	c = nil
	c.GetUpstreamParams()
}

func TestConnectionOptionsPingFederate_GetUserIDAttribute(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsPingFederate{UserIDAttribute: &zeroValue}
	c.GetUserIDAttribute()
	c = &ConnectionOptionsPingFederate{}
	c.GetUserIDAttribute()
	c = nil
	c.GetUserIDAttribute()
}

func TestConnectionOptionsPingFederate_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ConnectionOptionsPingFederate{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestConnectionOptionsSalesforce_GetClientID(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsSalesforce{ClientID: &zeroValue}
	c.GetClientID()
	c = &ConnectionOptionsSalesforce{}
	c.GetClientID()
	c = nil
	c.GetClientID()
}

func TestConnectionOptionsSalesforce_GetClientSecret(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsSalesforce{ClientSecret: &zeroValue}
	c.GetClientSecret()
	c = &ConnectionOptionsSalesforce{}
	c.GetClientSecret()
	c = nil
	c.GetClientSecret()
}

func TestConnectionOptionsSalesforce_GetCommunityBaseURL(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsSalesforce{CommunityBaseURL: &zeroValue}
	c.GetCommunityBaseURL()
	c = &ConnectionOptionsSalesforce{}
	c.GetCommunityBaseURL()
	c = nil
	c.GetCommunityBaseURL()
}

func TestConnectionOptionsSalesforce_GetNonPersistentAttrs(tt *testing.T) {
	var zeroValue []string
	c := &ConnectionOptionsSalesforce{NonPersistentAttrs: &zeroValue}
	c.GetNonPersistentAttrs()
	c = &ConnectionOptionsSalesforce{}
	c.GetNonPersistentAttrs()
	c = nil
	c.GetNonPersistentAttrs()
}

func TestConnectionOptionsSalesforce_GetProfile(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsSalesforce{Profile: &zeroValue}
	c.GetProfile()
	c = &ConnectionOptionsSalesforce{}
	c.GetProfile()
	c = nil
	c.GetProfile()
}

func TestConnectionOptionsSalesforce_GetSetUserAttributes(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsSalesforce{SetUserAttributes: &zeroValue}
	c.GetSetUserAttributes()
	c = &ConnectionOptionsSalesforce{}
	c.GetSetUserAttributes()
	c = nil
	c.GetSetUserAttributes()
}

func TestConnectionOptionsSalesforce_GetUpstreamParams(tt *testing.T) {
	zeroValue := map[string]interface{}{}
	c := &ConnectionOptionsSalesforce{UpstreamParams: zeroValue}
	c.GetUpstreamParams()
	c = &ConnectionOptionsSalesforce{}
	c.GetUpstreamParams()
	c = nil
	c.GetUpstreamParams()
}

func TestConnectionOptionsSalesforce_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ConnectionOptionsSalesforce{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestConnectionOptionsSAML_GetAgentIP(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsSAML{AgentIP: &zeroValue}
	c.GetAgentIP()
	c = &ConnectionOptionsSAML{}
	c.GetAgentIP()
	c = nil
	c.GetAgentIP()
}

func TestConnectionOptionsSAML_GetAgentMode(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsSAML{AgentMode: &zeroValue}
	c.GetAgentMode()
	c = &ConnectionOptionsSAML{}
	c.GetAgentMode()
	c = nil
	c.GetAgentMode()
}

func TestConnectionOptionsSAML_GetAgentVersion(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsSAML{AgentVersion: &zeroValue}
	c.GetAgentVersion()
	c = &ConnectionOptionsSAML{}
	c.GetAgentVersion()
	c = nil
	c.GetAgentVersion()
}

func TestConnectionOptionsSAML_GetBindingMethod(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsSAML{BindingMethod: &zeroValue}
	c.GetBindingMethod()
	c = &ConnectionOptionsSAML{}
	c.GetBindingMethod()
	c = nil
	c.GetBindingMethod()
}

func TestConnectionOptionsSAML_GetCert(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsSAML{Cert: &zeroValue}
	c.GetCert()
	c = &ConnectionOptionsSAML{}
	c.GetCert()
	c = nil
	c.GetCert()
}

func TestConnectionOptionsSAML_GetCertRolloverNotification(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsSAML{CertRolloverNotification: &zeroValue}
	c.GetCertRolloverNotification()
	c = &ConnectionOptionsSAML{}
	c.GetCertRolloverNotification()
	c = nil
	c.GetCertRolloverNotification()
}

func TestConnectionOptionsSAML_GetDebug(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsSAML{Debug: &zeroValue}
	c.GetDebug()
	c = &ConnectionOptionsSAML{}
	c.GetDebug()
	c = nil
	c.GetDebug()
}

func TestConnectionOptionsSAML_GetDecryptionKey(tt *testing.T) {
	c := &ConnectionOptionsSAML{}
	c.GetDecryptionKey()
	c = nil
	c.GetDecryptionKey()
}

func TestConnectionOptionsSAML_GetDigestAglorithm(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsSAML{DigestAglorithm: &zeroValue}
	c.GetDigestAglorithm()
	c = &ConnectionOptionsSAML{}
	c.GetDigestAglorithm()
	c = nil
	c.GetDigestAglorithm()
}

func TestConnectionOptionsSAML_GetDisableSignOut(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsSAML{DisableSignOut: &zeroValue}
	c.GetDisableSignOut()
	c = &ConnectionOptionsSAML{}
	c.GetDisableSignOut()
	c = nil
	c.GetDisableSignOut()
}

func TestConnectionOptionsSAML_GetDomainAliases(tt *testing.T) {
	var zeroValue []string
	c := &ConnectionOptionsSAML{DomainAliases: &zeroValue}
	c.GetDomainAliases()
	c = &ConnectionOptionsSAML{}
	c.GetDomainAliases()
	c = nil
	c.GetDomainAliases()
}

func TestConnectionOptionsSAML_GetEntityID(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsSAML{EntityID: &zeroValue}
	c.GetEntityID()
	c = &ConnectionOptionsSAML{}
	c.GetEntityID()
	c = nil
	c.GetEntityID()
}

func TestConnectionOptionsSAML_GetExpires(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsSAML{Expires: &zeroValue}
	c.GetExpires()
	c = &ConnectionOptionsSAML{}
	c.GetExpires()
	c = nil
	c.GetExpires()
}

func TestConnectionOptionsSAML_GetExtGroups(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsSAML{ExtGroups: &zeroValue}
	c.GetExtGroups()
	c = &ConnectionOptionsSAML{}
	c.GetExtGroups()
	c = nil
	c.GetExtGroups()
}

func TestConnectionOptionsSAML_GetExtProfile(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsSAML{ExtProfile: &zeroValue}
	c.GetExtProfile()
	c = &ConnectionOptionsSAML{}
	c.GetExtProfile()
	c = nil
	c.GetExtProfile()
}

func TestConnectionOptionsSAML_GetFieldsMap(tt *testing.T) {
	zeroValue := map[string]interface{}{}
	c := &ConnectionOptionsSAML{FieldsMap: zeroValue}
	c.GetFieldsMap()
	c = &ConnectionOptionsSAML{}
	c.GetFieldsMap()
	c = nil
	c.GetFieldsMap()
}

func TestConnectionOptionsSAML_GetGlobalTokenRevocationJWTIss(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsSAML{GlobalTokenRevocationJWTIss: &zeroValue}
	c.GetGlobalTokenRevocationJWTIss()
	c = &ConnectionOptionsSAML{}
	c.GetGlobalTokenRevocationJWTIss()
	c = nil
	c.GetGlobalTokenRevocationJWTIss()
}

func TestConnectionOptionsSAML_GetGlobalTokenRevocationJWTSub(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsSAML{GlobalTokenRevocationJWTSub: &zeroValue}
	c.GetGlobalTokenRevocationJWTSub()
	c = &ConnectionOptionsSAML{}
	c.GetGlobalTokenRevocationJWTSub()
	c = nil
	c.GetGlobalTokenRevocationJWTSub()
}

func TestConnectionOptionsSAML_GetIdpInitiated(tt *testing.T) {
	c := &ConnectionOptionsSAML{}
	c.GetIdpInitiated()
	c = nil
	c.GetIdpInitiated()
}

func TestConnectionOptionsSAML_GetLogoURL(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsSAML{LogoURL: &zeroValue}
	c.GetLogoURL()
	c = &ConnectionOptionsSAML{}
	c.GetLogoURL()
	c = nil
	c.GetLogoURL()
}

func TestConnectionOptionsSAML_GetMetadataURL(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsSAML{MetadataURL: &zeroValue}
	c.GetMetadataURL()
	c = &ConnectionOptionsSAML{}
	c.GetMetadataURL()
	c = nil
	c.GetMetadataURL()
}

func TestConnectionOptionsSAML_GetMetadataXML(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsSAML{MetadataXML: &zeroValue}
	c.GetMetadataXML()
	c = &ConnectionOptionsSAML{}
	c.GetMetadataXML()
	c = nil
	c.GetMetadataXML()
}

func TestConnectionOptionsSAML_GetNonPersistentAttrs(tt *testing.T) {
	var zeroValue []string
	c := &ConnectionOptionsSAML{NonPersistentAttrs: &zeroValue}
	c.GetNonPersistentAttrs()
	c = &ConnectionOptionsSAML{}
	c.GetNonPersistentAttrs()
	c = nil
	c.GetNonPersistentAttrs()
}

func TestConnectionOptionsSAML_GetProtocolBinding(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsSAML{ProtocolBinding: &zeroValue}
	c.GetProtocolBinding()
	c = &ConnectionOptionsSAML{}
	c.GetProtocolBinding()
	c = nil
	c.GetProtocolBinding()
}

func TestConnectionOptionsSAML_GetRequestTemplate(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsSAML{RequestTemplate: &zeroValue}
	c.GetRequestTemplate()
	c = &ConnectionOptionsSAML{}
	c.GetRequestTemplate()
	c = nil
	c.GetRequestTemplate()
}

func TestConnectionOptionsSAML_GetSetUserAttributes(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsSAML{SetUserAttributes: &zeroValue}
	c.GetSetUserAttributes()
	c = &ConnectionOptionsSAML{}
	c.GetSetUserAttributes()
	c = nil
	c.GetSetUserAttributes()
}

func TestConnectionOptionsSAML_GetSignatureAlgorithm(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsSAML{SignatureAlgorithm: &zeroValue}
	c.GetSignatureAlgorithm()
	c = &ConnectionOptionsSAML{}
	c.GetSignatureAlgorithm()
	c = nil
	c.GetSignatureAlgorithm()
}

func TestConnectionOptionsSAML_GetSignInEndpoint(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsSAML{SignInEndpoint: &zeroValue}
	c.GetSignInEndpoint()
	c = &ConnectionOptionsSAML{}
	c.GetSignInEndpoint()
	c = nil
	c.GetSignInEndpoint()
}

func TestConnectionOptionsSAML_GetSigningCert(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsSAML{SigningCert: &zeroValue}
	c.GetSigningCert()
	c = &ConnectionOptionsSAML{}
	c.GetSigningCert()
	c = nil
	c.GetSigningCert()
}

func TestConnectionOptionsSAML_GetSigningKey(tt *testing.T) {
	c := &ConnectionOptionsSAML{}
	c.GetSigningKey()
	c = nil
	c.GetSigningKey()
}

func TestConnectionOptionsSAML_GetSignOutEndpoint(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsSAML{SignOutEndpoint: &zeroValue}
	c.GetSignOutEndpoint()
	c = &ConnectionOptionsSAML{}
	c.GetSignOutEndpoint()
	c = nil
	c.GetSignOutEndpoint()
}

func TestConnectionOptionsSAML_GetSignSAMLRequest(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsSAML{SignSAMLRequest: &zeroValue}
	c.GetSignSAMLRequest()
	c = &ConnectionOptionsSAML{}
	c.GetSignSAMLRequest()
	c = nil
	c.GetSignSAMLRequest()
}

func TestConnectionOptionsSAML_GetStrategyVersion(tt *testing.T) {
	var zeroValue int
	c := &ConnectionOptionsSAML{StrategyVersion: &zeroValue}
	c.GetStrategyVersion()
	c = &ConnectionOptionsSAML{}
	c.GetStrategyVersion()
	c = nil
	c.GetStrategyVersion()
}

func TestConnectionOptionsSAML_GetSubject(tt *testing.T) {
	zeroValue := map[string]interface{}{}
	c := &ConnectionOptionsSAML{Subject: zeroValue}
	c.GetSubject()
	c = &ConnectionOptionsSAML{}
	c.GetSubject()
	c = nil
	c.GetSubject()
}

func TestConnectionOptionsSAML_GetTenantDomain(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsSAML{TenantDomain: &zeroValue}
	c.GetTenantDomain()
	c = &ConnectionOptionsSAML{}
	c.GetTenantDomain()
	c = nil
	c.GetTenantDomain()
}

func TestConnectionOptionsSAML_GetUpstreamParams(tt *testing.T) {
	zeroValue := map[string]interface{}{}
	c := &ConnectionOptionsSAML{UpstreamParams: zeroValue}
	c.GetUpstreamParams()
	c = &ConnectionOptionsSAML{}
	c.GetUpstreamParams()
	c = nil
	c.GetUpstreamParams()
}

func TestConnectionOptionsSAML_GetUserIDAttribute(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsSAML{UserIDAttribute: &zeroValue}
	c.GetUserIDAttribute()
	c = &ConnectionOptionsSAML{}
	c.GetUserIDAttribute()
	c = nil
	c.GetUserIDAttribute()
}

func TestConnectionOptionsSAML_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ConnectionOptionsSAML{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestConnectionOptionsSAMLDecryptionKey_GetCert(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsSAMLDecryptionKey{Cert: &zeroValue}
	c.GetCert()
	c = &ConnectionOptionsSAMLDecryptionKey{}
	c.GetCert()
	c = nil
	c.GetCert()
}

func TestConnectionOptionsSAMLDecryptionKey_GetKey(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsSAMLDecryptionKey{Key: &zeroValue}
	c.GetKey()
	c = &ConnectionOptionsSAMLDecryptionKey{}
	c.GetKey()
	c = nil
	c.GetKey()
}

func TestConnectionOptionsSAMLDecryptionKey_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ConnectionOptionsSAMLDecryptionKey{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestConnectionOptionsSAMLIdpInitiated_GetClientAuthorizeQuery(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsSAMLIdpInitiated{ClientAuthorizeQuery: &zeroValue}
	c.GetClientAuthorizeQuery()
	c = &ConnectionOptionsSAMLIdpInitiated{}
	c.GetClientAuthorizeQuery()
	c = nil
	c.GetClientAuthorizeQuery()
}

func TestConnectionOptionsSAMLIdpInitiated_GetClientID(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsSAMLIdpInitiated{ClientID: &zeroValue}
	c.GetClientID()
	c = &ConnectionOptionsSAMLIdpInitiated{}
	c.GetClientID()
	c = nil
	c.GetClientID()
}

func TestConnectionOptionsSAMLIdpInitiated_GetClientProtocol(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsSAMLIdpInitiated{ClientProtocol: &zeroValue}
	c.GetClientProtocol()
	c = &ConnectionOptionsSAMLIdpInitiated{}
	c.GetClientProtocol()
	c = nil
	c.GetClientProtocol()
}

func TestConnectionOptionsSAMLIdpInitiated_GetEnabled(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsSAMLIdpInitiated{Enabled: &zeroValue}
	c.GetEnabled()
	c = &ConnectionOptionsSAMLIdpInitiated{}
	c.GetEnabled()
	c = nil
	c.GetEnabled()
}

func TestConnectionOptionsSAMLIdpInitiated_GetNonPersistentAttrs(tt *testing.T) {
	var zeroValue []string
	c := &ConnectionOptionsSAMLIdpInitiated{NonPersistentAttrs: &zeroValue}
	c.GetNonPersistentAttrs()
	c = &ConnectionOptionsSAMLIdpInitiated{}
	c.GetNonPersistentAttrs()
	c = nil
	c.GetNonPersistentAttrs()
}

func TestConnectionOptionsSAMLIdpInitiated_GetSetUserAttributes(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsSAMLIdpInitiated{SetUserAttributes: &zeroValue}
	c.GetSetUserAttributes()
	c = &ConnectionOptionsSAMLIdpInitiated{}
	c.GetSetUserAttributes()
	c = nil
	c.GetSetUserAttributes()
}

func TestConnectionOptionsSAMLIdpInitiated_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ConnectionOptionsSAMLIdpInitiated{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestConnectionOptionsSAMLSigningKey_GetCert(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsSAMLSigningKey{Cert: &zeroValue}
	c.GetCert()
	c = &ConnectionOptionsSAMLSigningKey{}
	c.GetCert()
	c = nil
	c.GetCert()
}

func TestConnectionOptionsSAMLSigningKey_GetKey(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsSAMLSigningKey{Key: &zeroValue}
	c.GetKey()
	c = &ConnectionOptionsSAMLSigningKey{}
	c.GetKey()
	c = nil
	c.GetKey()
}

func TestConnectionOptionsSAMLSigningKey_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ConnectionOptionsSAMLSigningKey{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestConnectionOptionsSMS_GetBruteForceProtection(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsSMS{BruteForceProtection: &zeroValue}
	c.GetBruteForceProtection()
	c = &ConnectionOptionsSMS{}
	c.GetBruteForceProtection()
	c = nil
	c.GetBruteForceProtection()
}

func TestConnectionOptionsSMS_GetDisableSignup(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsSMS{DisableSignup: &zeroValue}
	c.GetDisableSignup()
	c = &ConnectionOptionsSMS{}
	c.GetDisableSignup()
	c = nil
	c.GetDisableSignup()
}

func TestConnectionOptionsSMS_GetForwardRequestInfo(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsSMS{ForwardRequestInfo: &zeroValue}
	c.GetForwardRequestInfo()
	c = &ConnectionOptionsSMS{}
	c.GetForwardRequestInfo()
	c = nil
	c.GetForwardRequestInfo()
}

func TestConnectionOptionsSMS_GetFrom(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsSMS{From: &zeroValue}
	c.GetFrom()
	c = &ConnectionOptionsSMS{}
	c.GetFrom()
	c = nil
	c.GetFrom()
}

func TestConnectionOptionsSMS_GetGatewayAuthentication(tt *testing.T) {
	c := &ConnectionOptionsSMS{}
	c.GetGatewayAuthentication()
	c = nil
	c.GetGatewayAuthentication()
}

func TestConnectionOptionsSMS_GetGatewayURL(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsSMS{GatewayURL: &zeroValue}
	c.GetGatewayURL()
	c = &ConnectionOptionsSMS{}
	c.GetGatewayURL()
	c = nil
	c.GetGatewayURL()
}

func TestConnectionOptionsSMS_GetMessagingServiceSID(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsSMS{MessagingServiceSID: &zeroValue}
	c.GetMessagingServiceSID()
	c = &ConnectionOptionsSMS{}
	c.GetMessagingServiceSID()
	c = nil
	c.GetMessagingServiceSID()
}

func TestConnectionOptionsSMS_GetName(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsSMS{Name: &zeroValue}
	c.GetName()
	c = &ConnectionOptionsSMS{}
	c.GetName()
	c = nil
	c.GetName()
}

func TestConnectionOptionsSMS_GetOTP(tt *testing.T) {
	c := &ConnectionOptionsSMS{}
	c.GetOTP()
	c = nil
	c.GetOTP()
}

func TestConnectionOptionsSMS_GetProvider(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsSMS{Provider: &zeroValue}
	c.GetProvider()
	c = &ConnectionOptionsSMS{}
	c.GetProvider()
	c = nil
	c.GetProvider()
}

func TestConnectionOptionsSMS_GetSyntax(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsSMS{Syntax: &zeroValue}
	c.GetSyntax()
	c = &ConnectionOptionsSMS{}
	c.GetSyntax()
	c = nil
	c.GetSyntax()
}

func TestConnectionOptionsSMS_GetTemplate(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsSMS{Template: &zeroValue}
	c.GetTemplate()
	c = &ConnectionOptionsSMS{}
	c.GetTemplate()
	c = nil
	c.GetTemplate()
}

func TestConnectionOptionsSMS_GetTwilioSID(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsSMS{TwilioSID: &zeroValue}
	c.GetTwilioSID()
	c = &ConnectionOptionsSMS{}
	c.GetTwilioSID()
	c = nil
	c.GetTwilioSID()
}

func TestConnectionOptionsSMS_GetTwilioToken(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsSMS{TwilioToken: &zeroValue}
	c.GetTwilioToken()
	c = &ConnectionOptionsSMS{}
	c.GetTwilioToken()
	c = nil
	c.GetTwilioToken()
}

func TestConnectionOptionsSMS_GetUpstreamParams(tt *testing.T) {
	zeroValue := map[string]interface{}{}
	c := &ConnectionOptionsSMS{UpstreamParams: zeroValue}
	c.GetUpstreamParams()
	c = &ConnectionOptionsSMS{}
	c.GetUpstreamParams()
	c = nil
	c.GetUpstreamParams()
}

func TestConnectionOptionsSMS_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ConnectionOptionsSMS{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestConnectionOptionsUsernameAttribute_GetIdentifier(tt *testing.T) {
	c := &ConnectionOptionsUsernameAttribute{}
	c.GetIdentifier()
	c = nil
	c.GetIdentifier()
}

func TestConnectionOptionsUsernameAttribute_GetProfileRequired(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsUsernameAttribute{ProfileRequired: &zeroValue}
	c.GetProfileRequired()
	c = &ConnectionOptionsUsernameAttribute{}
	c.GetProfileRequired()
	c = nil
	c.GetProfileRequired()
}

func TestConnectionOptionsUsernameAttribute_GetSignup(tt *testing.T) {
	c := &ConnectionOptionsUsernameAttribute{}
	c.GetSignup()
	c = nil
	c.GetSignup()
}

func TestConnectionOptionsUsernameAttribute_GetValidation(tt *testing.T) {
	c := &ConnectionOptionsUsernameAttribute{}
	c.GetValidation()
	c = nil
	c.GetValidation()
}

func TestConnectionOptionsUsernameAttribute_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ConnectionOptionsUsernameAttribute{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestConnectionOptionsWindowsLive_GetCalendars(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsWindowsLive{Calendars: &zeroValue}
	c.GetCalendars()
	c = &ConnectionOptionsWindowsLive{}
	c.GetCalendars()
	c = nil
	c.GetCalendars()
}

func TestConnectionOptionsWindowsLive_GetCalendarsUpdate(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsWindowsLive{CalendarsUpdate: &zeroValue}
	c.GetCalendarsUpdate()
	c = &ConnectionOptionsWindowsLive{}
	c.GetCalendarsUpdate()
	c = nil
	c.GetCalendarsUpdate()
}

func TestConnectionOptionsWindowsLive_GetClientID(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsWindowsLive{ClientID: &zeroValue}
	c.GetClientID()
	c = &ConnectionOptionsWindowsLive{}
	c.GetClientID()
	c = nil
	c.GetClientID()
}

func TestConnectionOptionsWindowsLive_GetClientSecret(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsWindowsLive{ClientSecret: &zeroValue}
	c.GetClientSecret()
	c = &ConnectionOptionsWindowsLive{}
	c.GetClientSecret()
	c = nil
	c.GetClientSecret()
}

func TestConnectionOptionsWindowsLive_GetContacts(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsWindowsLive{Contacts: &zeroValue}
	c.GetContacts()
	c = &ConnectionOptionsWindowsLive{}
	c.GetContacts()
	c = nil
	c.GetContacts()
}

func TestConnectionOptionsWindowsLive_GetContactsUpdate(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsWindowsLive{ContactsUpdate: &zeroValue}
	c.GetContactsUpdate()
	c = &ConnectionOptionsWindowsLive{}
	c.GetContactsUpdate()
	c = nil
	c.GetContactsUpdate()
}

func TestConnectionOptionsWindowsLive_GetDevice(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsWindowsLive{Device: &zeroValue}
	c.GetDevice()
	c = &ConnectionOptionsWindowsLive{}
	c.GetDevice()
	c = nil
	c.GetDevice()
}

func TestConnectionOptionsWindowsLive_GetDeviceCommand(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsWindowsLive{DeviceCommand: &zeroValue}
	c.GetDeviceCommand()
	c = &ConnectionOptionsWindowsLive{}
	c.GetDeviceCommand()
	c = nil
	c.GetDeviceCommand()
}

func TestConnectionOptionsWindowsLive_GetEmails(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsWindowsLive{Emails: &zeroValue}
	c.GetEmails()
	c = &ConnectionOptionsWindowsLive{}
	c.GetEmails()
	c = nil
	c.GetEmails()
}

func TestConnectionOptionsWindowsLive_GetEmailsUpdate(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsWindowsLive{EmailsUpdate: &zeroValue}
	c.GetEmailsUpdate()
	c = &ConnectionOptionsWindowsLive{}
	c.GetEmailsUpdate()
	c = nil
	c.GetEmailsUpdate()
}

func TestConnectionOptionsWindowsLive_GetFiles(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsWindowsLive{Files: &zeroValue}
	c.GetFiles()
	c = &ConnectionOptionsWindowsLive{}
	c.GetFiles()
	c = nil
	c.GetFiles()
}

func TestConnectionOptionsWindowsLive_GetFilesAll(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsWindowsLive{FilesAll: &zeroValue}
	c.GetFilesAll()
	c = &ConnectionOptionsWindowsLive{}
	c.GetFilesAll()
	c = nil
	c.GetFilesAll()
}

func TestConnectionOptionsWindowsLive_GetFilesAllUpdate(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsWindowsLive{FilesAllUpdate: &zeroValue}
	c.GetFilesAllUpdate()
	c = &ConnectionOptionsWindowsLive{}
	c.GetFilesAllUpdate()
	c = nil
	c.GetFilesAllUpdate()
}

func TestConnectionOptionsWindowsLive_GetFilesUpdate(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsWindowsLive{FilesUpdate: &zeroValue}
	c.GetFilesUpdate()
	c = &ConnectionOptionsWindowsLive{}
	c.GetFilesUpdate()
	c = nil
	c.GetFilesUpdate()
}

func TestConnectionOptionsWindowsLive_GetNonPersistentAttrs(tt *testing.T) {
	var zeroValue []string
	c := &ConnectionOptionsWindowsLive{NonPersistentAttrs: &zeroValue}
	c.GetNonPersistentAttrs()
	c = &ConnectionOptionsWindowsLive{}
	c.GetNonPersistentAttrs()
	c = nil
	c.GetNonPersistentAttrs()
}

func TestConnectionOptionsWindowsLive_GetNotes(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsWindowsLive{Notes: &zeroValue}
	c.GetNotes()
	c = &ConnectionOptionsWindowsLive{}
	c.GetNotes()
	c = nil
	c.GetNotes()
}

func TestConnectionOptionsWindowsLive_GetNotesCreate(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsWindowsLive{NotesCreate: &zeroValue}
	c.GetNotesCreate()
	c = &ConnectionOptionsWindowsLive{}
	c.GetNotesCreate()
	c = nil
	c.GetNotesCreate()
}

func TestConnectionOptionsWindowsLive_GetNotesUpdate(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsWindowsLive{NotesUpdate: &zeroValue}
	c.GetNotesUpdate()
	c = &ConnectionOptionsWindowsLive{}
	c.GetNotesUpdate()
	c = nil
	c.GetNotesUpdate()
}

func TestConnectionOptionsWindowsLive_GetOfflineAccess(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsWindowsLive{OfflineAccess: &zeroValue}
	c.GetOfflineAccess()
	c = &ConnectionOptionsWindowsLive{}
	c.GetOfflineAccess()
	c = nil
	c.GetOfflineAccess()
}

func TestConnectionOptionsWindowsLive_GetSetUserAttributes(tt *testing.T) {
	var zeroValue string
	c := &ConnectionOptionsWindowsLive{SetUserAttributes: &zeroValue}
	c.GetSetUserAttributes()
	c = &ConnectionOptionsWindowsLive{}
	c.GetSetUserAttributes()
	c = nil
	c.GetSetUserAttributes()
}

func TestConnectionOptionsWindowsLive_GetSignin(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsWindowsLive{Signin: &zeroValue}
	c.GetSignin()
	c = &ConnectionOptionsWindowsLive{}
	c.GetSignin()
	c = nil
	c.GetSignin()
}

func TestConnectionOptionsWindowsLive_GetStrategyVersion(tt *testing.T) {
	var zeroValue int
	c := &ConnectionOptionsWindowsLive{StrategyVersion: &zeroValue}
	c.GetStrategyVersion()
	c = &ConnectionOptionsWindowsLive{}
	c.GetStrategyVersion()
	c = nil
	c.GetStrategyVersion()
}

func TestConnectionOptionsWindowsLive_GetTasks(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsWindowsLive{Tasks: &zeroValue}
	c.GetTasks()
	c = &ConnectionOptionsWindowsLive{}
	c.GetTasks()
	c = nil
	c.GetTasks()
}

func TestConnectionOptionsWindowsLive_GetTasksUpdate(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsWindowsLive{TasksUpdate: &zeroValue}
	c.GetTasksUpdate()
	c = &ConnectionOptionsWindowsLive{}
	c.GetTasksUpdate()
	c = nil
	c.GetTasksUpdate()
}

func TestConnectionOptionsWindowsLive_GetUpstreamParams(tt *testing.T) {
	zeroValue := map[string]interface{}{}
	c := &ConnectionOptionsWindowsLive{UpstreamParams: zeroValue}
	c.GetUpstreamParams()
	c = &ConnectionOptionsWindowsLive{}
	c.GetUpstreamParams()
	c = nil
	c.GetUpstreamParams()
}

func TestConnectionOptionsWindowsLive_GetUser(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsWindowsLive{User: &zeroValue}
	c.GetUser()
	c = &ConnectionOptionsWindowsLive{}
	c.GetUser()
	c = nil
	c.GetUser()
}

func TestConnectionOptionsWindowsLive_GetUserActivity(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsWindowsLive{UserActivity: &zeroValue}
	c.GetUserActivity()
	c = &ConnectionOptionsWindowsLive{}
	c.GetUserActivity()
	c = nil
	c.GetUserActivity()
}

func TestConnectionOptionsWindowsLive_GetUserUpdate(tt *testing.T) {
	var zeroValue bool
	c := &ConnectionOptionsWindowsLive{UserUpdate: &zeroValue}
	c.GetUserUpdate()
	c = &ConnectionOptionsWindowsLive{}
	c.GetUserUpdate()
	c = nil
	c.GetUserUpdate()
}

func TestConnectionOptionsWindowsLive_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ConnectionOptionsWindowsLive{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestCreateEnrollmentTicket_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &CreateEnrollmentTicket{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestCredential_GetAlgorithm(tt *testing.T) {
	var zeroValue string
	c := &Credential{Algorithm: &zeroValue}
	c.GetAlgorithm()
	c = &Credential{}
	c.GetAlgorithm()
	c = nil
	c.GetAlgorithm()
}

func TestCredential_GetCreatedAt(tt *testing.T) {
	var zeroValue time.Time
	c := &Credential{CreatedAt: &zeroValue}
	c.GetCreatedAt()
	c = &Credential{}
	c.GetCreatedAt()
	c = nil
	c.GetCreatedAt()
}

func TestCredential_GetCredentialType(tt *testing.T) {
	var zeroValue string
	c := &Credential{CredentialType: &zeroValue}
	c.GetCredentialType()
	c = &Credential{}
	c.GetCredentialType()
	c = nil
	c.GetCredentialType()
}

func TestCredential_GetExpiresAt(tt *testing.T) {
	var zeroValue time.Time
	c := &Credential{ExpiresAt: &zeroValue}
	c.GetExpiresAt()
	c = &Credential{}
	c.GetExpiresAt()
	c = nil
	c.GetExpiresAt()
}

func TestCredential_GetID(tt *testing.T) {
	var zeroValue string
	c := &Credential{ID: &zeroValue}
	c.GetID()
	c = &Credential{}
	c.GetID()
	c = nil
	c.GetID()
}

func TestCredential_GetKeyID(tt *testing.T) {
	var zeroValue string
	c := &Credential{KeyID: &zeroValue}
	c.GetKeyID()
	c = &Credential{}
	c.GetKeyID()
	c = nil
	c.GetKeyID()
}

func TestCredential_GetName(tt *testing.T) {
	var zeroValue string
	c := &Credential{Name: &zeroValue}
	c.GetName()
	c = &Credential{}
	c.GetName()
	c = nil
	c.GetName()
}

func TestCredential_GetParseExpiryFromCert(tt *testing.T) {
	var zeroValue bool
	c := &Credential{ParseExpiryFromCert: &zeroValue}
	c.GetParseExpiryFromCert()
	c = &Credential{}
	c.GetParseExpiryFromCert()
	c = nil
	c.GetParseExpiryFromCert()
}

func TestCredential_GetPEM(tt *testing.T) {
	var zeroValue string
	c := &Credential{PEM: &zeroValue}
	c.GetPEM()
	c = &Credential{}
	c.GetPEM()
	c = nil
	c.GetPEM()
}

func TestCredential_GetSubjectDN(tt *testing.T) {
	var zeroValue string
	c := &Credential{SubjectDN: &zeroValue}
	c.GetSubjectDN()
	c = &Credential{}
	c.GetSubjectDN()
	c = nil
	c.GetSubjectDN()
}

func TestCredential_GetThumbprintSHA256(tt *testing.T) {
	var zeroValue string
	c := &Credential{ThumbprintSHA256: &zeroValue}
	c.GetThumbprintSHA256()
	c = &Credential{}
	c.GetThumbprintSHA256()
	c = nil
	c.GetThumbprintSHA256()
}

func TestCredential_GetUpdatedAt(tt *testing.T) {
	var zeroValue time.Time
	c := &Credential{UpdatedAt: &zeroValue}
	c.GetUpdatedAt()
	c = &Credential{}
	c.GetUpdatedAt()
	c = nil
	c.GetUpdatedAt()
}

func TestCredential_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &Credential{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestCustomDomain_GetCNAMEAPIKey(tt *testing.T) {
	var zeroValue string
	c := &CustomDomain{CNAMEAPIKey: &zeroValue}
	c.GetCNAMEAPIKey()
	c = &CustomDomain{}
	c.GetCNAMEAPIKey()
	c = nil
	c.GetCNAMEAPIKey()
}

func TestCustomDomain_GetCustomClientIPHeader(tt *testing.T) {
	var zeroValue string
	c := &CustomDomain{CustomClientIPHeader: &zeroValue}
	c.GetCustomClientIPHeader()
	c = &CustomDomain{}
	c.GetCustomClientIPHeader()
	c = nil
	c.GetCustomClientIPHeader()
}

func TestCustomDomain_GetDomain(tt *testing.T) {
	var zeroValue string
	c := &CustomDomain{Domain: &zeroValue}
	c.GetDomain()
	c = &CustomDomain{}
	c.GetDomain()
	c = nil
	c.GetDomain()
}

func TestCustomDomain_GetID(tt *testing.T) {
	var zeroValue string
	c := &CustomDomain{ID: &zeroValue}
	c.GetID()
	c = &CustomDomain{}
	c.GetID()
	c = nil
	c.GetID()
}

func TestCustomDomain_GetOriginDomainName(tt *testing.T) {
	var zeroValue string
	c := &CustomDomain{OriginDomainName: &zeroValue}
	c.GetOriginDomainName()
	c = &CustomDomain{}
	c.GetOriginDomainName()
	c = nil
	c.GetOriginDomainName()
}

func TestCustomDomain_GetPrimary(tt *testing.T) {
	var zeroValue bool
	c := &CustomDomain{Primary: &zeroValue}
	c.GetPrimary()
	c = &CustomDomain{}
	c.GetPrimary()
	c = nil
	c.GetPrimary()
}

func TestCustomDomain_GetStatus(tt *testing.T) {
	var zeroValue string
	c := &CustomDomain{Status: &zeroValue}
	c.GetStatus()
	c = &CustomDomain{}
	c.GetStatus()
	c = nil
	c.GetStatus()
}

func TestCustomDomain_GetTLSPolicy(tt *testing.T) {
	var zeroValue string
	c := &CustomDomain{TLSPolicy: &zeroValue}
	c.GetTLSPolicy()
	c = &CustomDomain{}
	c.GetTLSPolicy()
	c = nil
	c.GetTLSPolicy()
}

func TestCustomDomain_GetType(tt *testing.T) {
	var zeroValue string
	c := &CustomDomain{Type: &zeroValue}
	c.GetType()
	c = &CustomDomain{}
	c.GetType()
	c = nil
	c.GetType()
}

func TestCustomDomain_GetVerification(tt *testing.T) {
	c := &CustomDomain{}
	c.GetVerification()
	c = nil
	c.GetVerification()
}

func TestCustomDomain_GetVerificationMethod(tt *testing.T) {
	var zeroValue string
	c := &CustomDomain{VerificationMethod: &zeroValue}
	c.GetVerificationMethod()
	c = &CustomDomain{}
	c.GetVerificationMethod()
	c = nil
	c.GetVerificationMethod()
}

func TestCustomDomain_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &CustomDomain{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestCustomDomainVerification_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &CustomDomainVerification{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestDailyStat_GetCreatedAt(tt *testing.T) {
	var zeroValue time.Time
	d := &DailyStat{CreatedAt: &zeroValue}
	d.GetCreatedAt()
	d = &DailyStat{}
	d.GetCreatedAt()
	d = nil
	d.GetCreatedAt()
}

func TestDailyStat_GetDate(tt *testing.T) {
	var zeroValue time.Time
	d := &DailyStat{Date: &zeroValue}
	d.GetDate()
	d = &DailyStat{}
	d.GetDate()
	d = nil
	d.GetDate()
}

func TestDailyStat_GetLeakedPasswords(tt *testing.T) {
	var zeroValue int
	d := &DailyStat{LeakedPasswords: &zeroValue}
	d.GetLeakedPasswords()
	d = &DailyStat{}
	d.GetLeakedPasswords()
	d = nil
	d.GetLeakedPasswords()
}

func TestDailyStat_GetLogins(tt *testing.T) {
	var zeroValue int
	d := &DailyStat{Logins: &zeroValue}
	d.GetLogins()
	d = &DailyStat{}
	d.GetLogins()
	d = nil
	d.GetLogins()
}

func TestDailyStat_GetSignups(tt *testing.T) {
	var zeroValue int
	d := &DailyStat{Signups: &zeroValue}
	d.GetSignups()
	d = &DailyStat{}
	d.GetSignups()
	d = nil
	d.GetSignups()
}

func TestDailyStat_GetUpdatedAt(tt *testing.T) {
	var zeroValue time.Time
	d := &DailyStat{UpdatedAt: &zeroValue}
	d.GetUpdatedAt()
	d = &DailyStat{}
	d.GetUpdatedAt()
	d = nil
	d.GetUpdatedAt()
}

func TestDailyStat_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &DailyStat{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestDeviceCredential_GetClientID(tt *testing.T) {
	var zeroValue string
	d := &DeviceCredential{ClientID: &zeroValue}
	d.GetClientID()
	d = &DeviceCredential{}
	d.GetClientID()
	d = nil
	d.GetClientID()
}

func TestDeviceCredential_GetDeviceID(tt *testing.T) {
	var zeroValue string
	d := &DeviceCredential{DeviceID: &zeroValue}
	d.GetDeviceID()
	d = &DeviceCredential{}
	d.GetDeviceID()
	d = nil
	d.GetDeviceID()
}

func TestDeviceCredential_GetDeviceName(tt *testing.T) {
	var zeroValue string
	d := &DeviceCredential{DeviceName: &zeroValue}
	d.GetDeviceName()
	d = &DeviceCredential{}
	d.GetDeviceName()
	d = nil
	d.GetDeviceName()
}

func TestDeviceCredential_GetID(tt *testing.T) {
	var zeroValue string
	d := &DeviceCredential{ID: &zeroValue}
	d.GetID()
	d = &DeviceCredential{}
	d.GetID()
	d = nil
	d.GetID()
}

func TestDeviceCredential_GetType(tt *testing.T) {
	var zeroValue string
	d := &DeviceCredential{Type: &zeroValue}
	d.GetType()
	d = &DeviceCredential{}
	d.GetType()
	d = nil
	d.GetType()
}

func TestDeviceCredential_GetUserID(tt *testing.T) {
	var zeroValue string
	d := &DeviceCredential{UserID: &zeroValue}
	d.GetUserID()
	d = &DeviceCredential{}
	d.GetUserID()
	d = nil
	d.GetUserID()
}

func TestDeviceCredential_GetValue(tt *testing.T) {
	var zeroValue string
	d := &DeviceCredential{Value: &zeroValue}
	d.GetValue()
	d = &DeviceCredential{}
	d.GetValue()
	d = nil
	d.GetValue()
}

func TestDeviceCredential_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &DeviceCredential{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestDeviceCredentialList_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &DeviceCredentialList{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestDropboxClientAddon_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &DropboxClientAddon{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestEchoSignClientAddon_GetDomain(tt *testing.T) {
	var zeroValue string
	e := &EchoSignClientAddon{Domain: &zeroValue}
	e.GetDomain()
	e = &EchoSignClientAddon{}
	e.GetDomain()
	e = nil
	e.GetDomain()
}

func TestEchoSignClientAddon_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &EchoSignClientAddon{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestEgnyteClientAddon_GetDomain(tt *testing.T) {
	var zeroValue string
	e := &EgnyteClientAddon{Domain: &zeroValue}
	e.GetDomain()
	e = &EgnyteClientAddon{}
	e.GetDomain()
	e = nil
	e.GetDomain()
}

func TestEgnyteClientAddon_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &EgnyteClientAddon{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestEmailProvider_GetDefaultFromAddress(tt *testing.T) {
	var zeroValue string
	e := &EmailProvider{DefaultFromAddress: &zeroValue}
	e.GetDefaultFromAddress()
	e = &EmailProvider{}
	e.GetDefaultFromAddress()
	e = nil
	e.GetDefaultFromAddress()
}

func TestEmailProvider_GetEnabled(tt *testing.T) {
	var zeroValue bool
	e := &EmailProvider{Enabled: &zeroValue}
	e.GetEnabled()
	e = &EmailProvider{}
	e.GetEnabled()
	e = nil
	e.GetEnabled()
}

func TestEmailProvider_GetName(tt *testing.T) {
	var zeroValue string
	e := &EmailProvider{Name: &zeroValue}
	e.GetName()
	e = &EmailProvider{}
	e.GetName()
	e = nil
	e.GetName()
}

func TestEmailProvider_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &EmailProvider{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestEmailProviderCredentialsAzureCS_GetConnectionString(tt *testing.T) {
	var zeroValue string
	e := &EmailProviderCredentialsAzureCS{ConnectionString: &zeroValue}
	e.GetConnectionString()
	e = &EmailProviderCredentialsAzureCS{}
	e.GetConnectionString()
	e = nil
	e.GetConnectionString()
}

func TestEmailProviderCredentialsAzureCS_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &EmailProviderCredentialsAzureCS{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestEmailProviderCredentialsCustom_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &EmailProviderCredentialsCustom{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestEmailProviderCredentialsMailgun_GetAPIKey(tt *testing.T) {
	var zeroValue string
	e := &EmailProviderCredentialsMailgun{APIKey: &zeroValue}
	e.GetAPIKey()
	e = &EmailProviderCredentialsMailgun{}
	e.GetAPIKey()
	e = nil
	e.GetAPIKey()
}

func TestEmailProviderCredentialsMailgun_GetDomain(tt *testing.T) {
	var zeroValue string
	e := &EmailProviderCredentialsMailgun{Domain: &zeroValue}
	e.GetDomain()
	e = &EmailProviderCredentialsMailgun{}
	e.GetDomain()
	e = nil
	e.GetDomain()
}

func TestEmailProviderCredentialsMailgun_GetRegion(tt *testing.T) {
	var zeroValue string
	e := &EmailProviderCredentialsMailgun{Region: &zeroValue}
	e.GetRegion()
	e = &EmailProviderCredentialsMailgun{}
	e.GetRegion()
	e = nil
	e.GetRegion()
}

func TestEmailProviderCredentialsMailgun_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &EmailProviderCredentialsMailgun{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestEmailProviderCredentialsMandrill_GetAPIKey(tt *testing.T) {
	var zeroValue string
	e := &EmailProviderCredentialsMandrill{APIKey: &zeroValue}
	e.GetAPIKey()
	e = &EmailProviderCredentialsMandrill{}
	e.GetAPIKey()
	e = nil
	e.GetAPIKey()
}

func TestEmailProviderCredentialsMandrill_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &EmailProviderCredentialsMandrill{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestEmailProviderCredentialsMS365_GetClientID(tt *testing.T) {
	var zeroValue string
	e := &EmailProviderCredentialsMS365{ClientID: &zeroValue}
	e.GetClientID()
	e = &EmailProviderCredentialsMS365{}
	e.GetClientID()
	e = nil
	e.GetClientID()
}

func TestEmailProviderCredentialsMS365_GetClientSecret(tt *testing.T) {
	var zeroValue string
	e := &EmailProviderCredentialsMS365{ClientSecret: &zeroValue}
	e.GetClientSecret()
	e = &EmailProviderCredentialsMS365{}
	e.GetClientSecret()
	e = nil
	e.GetClientSecret()
}

func TestEmailProviderCredentialsMS365_GetTenantID(tt *testing.T) {
	var zeroValue string
	e := &EmailProviderCredentialsMS365{TenantID: &zeroValue}
	e.GetTenantID()
	e = &EmailProviderCredentialsMS365{}
	e.GetTenantID()
	e = nil
	e.GetTenantID()
}

func TestEmailProviderCredentialsMS365_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &EmailProviderCredentialsMS365{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestEmailProviderCredentialsSendGrid_GetAPIKey(tt *testing.T) {
	var zeroValue string
	e := &EmailProviderCredentialsSendGrid{APIKey: &zeroValue}
	e.GetAPIKey()
	e = &EmailProviderCredentialsSendGrid{}
	e.GetAPIKey()
	e = nil
	e.GetAPIKey()
}

func TestEmailProviderCredentialsSendGrid_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &EmailProviderCredentialsSendGrid{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestEmailProviderCredentialsSES_GetAccessKeyID(tt *testing.T) {
	var zeroValue string
	e := &EmailProviderCredentialsSES{AccessKeyID: &zeroValue}
	e.GetAccessKeyID()
	e = &EmailProviderCredentialsSES{}
	e.GetAccessKeyID()
	e = nil
	e.GetAccessKeyID()
}

func TestEmailProviderCredentialsSES_GetRegion(tt *testing.T) {
	var zeroValue string
	e := &EmailProviderCredentialsSES{Region: &zeroValue}
	e.GetRegion()
	e = &EmailProviderCredentialsSES{}
	e.GetRegion()
	e = nil
	e.GetRegion()
}

func TestEmailProviderCredentialsSES_GetSecretAccessKey(tt *testing.T) {
	var zeroValue string
	e := &EmailProviderCredentialsSES{SecretAccessKey: &zeroValue}
	e.GetSecretAccessKey()
	e = &EmailProviderCredentialsSES{}
	e.GetSecretAccessKey()
	e = nil
	e.GetSecretAccessKey()
}

func TestEmailProviderCredentialsSES_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &EmailProviderCredentialsSES{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestEmailProviderCredentialsSMTP_GetSMTPHost(tt *testing.T) {
	var zeroValue string
	e := &EmailProviderCredentialsSMTP{SMTPHost: &zeroValue}
	e.GetSMTPHost()
	e = &EmailProviderCredentialsSMTP{}
	e.GetSMTPHost()
	e = nil
	e.GetSMTPHost()
}

func TestEmailProviderCredentialsSMTP_GetSMTPPass(tt *testing.T) {
	var zeroValue string
	e := &EmailProviderCredentialsSMTP{SMTPPass: &zeroValue}
	e.GetSMTPPass()
	e = &EmailProviderCredentialsSMTP{}
	e.GetSMTPPass()
	e = nil
	e.GetSMTPPass()
}

func TestEmailProviderCredentialsSMTP_GetSMTPPort(tt *testing.T) {
	var zeroValue int
	e := &EmailProviderCredentialsSMTP{SMTPPort: &zeroValue}
	e.GetSMTPPort()
	e = &EmailProviderCredentialsSMTP{}
	e.GetSMTPPort()
	e = nil
	e.GetSMTPPort()
}

func TestEmailProviderCredentialsSMTP_GetSMTPUser(tt *testing.T) {
	var zeroValue string
	e := &EmailProviderCredentialsSMTP{SMTPUser: &zeroValue}
	e.GetSMTPUser()
	e = &EmailProviderCredentialsSMTP{}
	e.GetSMTPUser()
	e = nil
	e.GetSMTPUser()
}

func TestEmailProviderCredentialsSMTP_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &EmailProviderCredentialsSMTP{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestEmailProviderCredentialsSparkPost_GetAPIKey(tt *testing.T) {
	var zeroValue string
	e := &EmailProviderCredentialsSparkPost{APIKey: &zeroValue}
	e.GetAPIKey()
	e = &EmailProviderCredentialsSparkPost{}
	e.GetAPIKey()
	e = nil
	e.GetAPIKey()
}

func TestEmailProviderCredentialsSparkPost_GetRegion(tt *testing.T) {
	var zeroValue string
	e := &EmailProviderCredentialsSparkPost{Region: &zeroValue}
	e.GetRegion()
	e = &EmailProviderCredentialsSparkPost{}
	e.GetRegion()
	e = nil
	e.GetRegion()
}

func TestEmailProviderCredentialsSparkPost_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &EmailProviderCredentialsSparkPost{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestEmailProviderSettingsMandrill_GetMessage(tt *testing.T) {
	e := &EmailProviderSettingsMandrill{}
	e.GetMessage()
	e = nil
	e.GetMessage()
}

func TestEmailProviderSettingsMandrill_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &EmailProviderSettingsMandrill{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestEmailProviderSettingsMandrillMessage_GetViewContentLink(tt *testing.T) {
	var zeroValue bool
	e := &EmailProviderSettingsMandrillMessage{ViewContentLink: &zeroValue}
	e.GetViewContentLink()
	e = &EmailProviderSettingsMandrillMessage{}
	e.GetViewContentLink()
	e = nil
	e.GetViewContentLink()
}

func TestEmailProviderSettingsMandrillMessage_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &EmailProviderSettingsMandrillMessage{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestEmailProviderSettingsSES_GetMessage(tt *testing.T) {
	e := &EmailProviderSettingsSES{}
	e.GetMessage()
	e = nil
	e.GetMessage()
}

func TestEmailProviderSettingsSES_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &EmailProviderSettingsSES{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestEmailProviderSettingsSESMessage_GetConfigurationSetName(tt *testing.T) {
	var zeroValue string
	e := &EmailProviderSettingsSESMessage{ConfigurationSetName: &zeroValue}
	e.GetConfigurationSetName()
	e = &EmailProviderSettingsSESMessage{}
	e.GetConfigurationSetName()
	e = nil
	e.GetConfigurationSetName()
}

func TestEmailProviderSettingsSESMessage_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &EmailProviderSettingsSESMessage{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestEmailProviderSettingsSMTP_GetHeaders(tt *testing.T) {
	e := &EmailProviderSettingsSMTP{}
	e.GetHeaders()
	e = nil
	e.GetHeaders()
}

func TestEmailProviderSettingsSMTP_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &EmailProviderSettingsSMTP{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestEmailProviderSettingsSMTPHeaders_GetXMCViewContentLink(tt *testing.T) {
	var zeroValue string
	e := &EmailProviderSettingsSMTPHeaders{XMCViewContentLink: &zeroValue}
	e.GetXMCViewContentLink()
	e = &EmailProviderSettingsSMTPHeaders{}
	e.GetXMCViewContentLink()
	e = nil
	e.GetXMCViewContentLink()
}

func TestEmailProviderSettingsSMTPHeaders_GetXSESConfigurationSet(tt *testing.T) {
	var zeroValue string
	e := &EmailProviderSettingsSMTPHeaders{XSESConfigurationSet: &zeroValue}
	e.GetXSESConfigurationSet()
	e = &EmailProviderSettingsSMTPHeaders{}
	e.GetXSESConfigurationSet()
	e = nil
	e.GetXSESConfigurationSet()
}

func TestEmailProviderSettingsSMTPHeaders_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &EmailProviderSettingsSMTPHeaders{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestEmailTemplate_GetBody(tt *testing.T) {
	var zeroValue string
	e := &EmailTemplate{Body: &zeroValue}
	e.GetBody()
	e = &EmailTemplate{}
	e.GetBody()
	e = nil
	e.GetBody()
}

func TestEmailTemplate_GetEnabled(tt *testing.T) {
	var zeroValue bool
	e := &EmailTemplate{Enabled: &zeroValue}
	e.GetEnabled()
	e = &EmailTemplate{}
	e.GetEnabled()
	e = nil
	e.GetEnabled()
}

func TestEmailTemplate_GetFrom(tt *testing.T) {
	var zeroValue string
	e := &EmailTemplate{From: &zeroValue}
	e.GetFrom()
	e = &EmailTemplate{}
	e.GetFrom()
	e = nil
	e.GetFrom()
}

func TestEmailTemplate_GetIncludeEmailInRedirect(tt *testing.T) {
	var zeroValue bool
	e := &EmailTemplate{IncludeEmailInRedirect: &zeroValue}
	e.GetIncludeEmailInRedirect()
	e = &EmailTemplate{}
	e.GetIncludeEmailInRedirect()
	e = nil
	e.GetIncludeEmailInRedirect()
}

func TestEmailTemplate_GetResultURL(tt *testing.T) {
	var zeroValue string
	e := &EmailTemplate{ResultURL: &zeroValue}
	e.GetResultURL()
	e = &EmailTemplate{}
	e.GetResultURL()
	e = nil
	e.GetResultURL()
}

func TestEmailTemplate_GetSubject(tt *testing.T) {
	var zeroValue string
	e := &EmailTemplate{Subject: &zeroValue}
	e.GetSubject()
	e = &EmailTemplate{}
	e.GetSubject()
	e = nil
	e.GetSubject()
}

func TestEmailTemplate_GetSyntax(tt *testing.T) {
	var zeroValue string
	e := &EmailTemplate{Syntax: &zeroValue}
	e.GetSyntax()
	e = &EmailTemplate{}
	e.GetSyntax()
	e = nil
	e.GetSyntax()
}

func TestEmailTemplate_GetTemplate(tt *testing.T) {
	var zeroValue string
	e := &EmailTemplate{Template: &zeroValue}
	e.GetTemplate()
	e = &EmailTemplate{}
	e.GetTemplate()
	e = nil
	e.GetTemplate()
}

func TestEmailTemplate_GetURLLifetimeInSecoonds(tt *testing.T) {
	var zeroValue int
	e := &EmailTemplate{URLLifetimeInSecoonds: &zeroValue}
	e.GetURLLifetimeInSecoonds()
	e = &EmailTemplate{}
	e.GetURLLifetimeInSecoonds()
	e = nil
	e.GetURLLifetimeInSecoonds()
}

func TestEmailTemplate_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &EmailTemplate{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestEncryptionKey_GetCreatedAt(tt *testing.T) {
	var zeroValue time.Time
	e := &EncryptionKey{CreatedAt: &zeroValue}
	e.GetCreatedAt()
	e = &EncryptionKey{}
	e.GetCreatedAt()
	e = nil
	e.GetCreatedAt()
}

func TestEncryptionKey_GetKID(tt *testing.T) {
	var zeroValue string
	e := &EncryptionKey{KID: &zeroValue}
	e.GetKID()
	e = &EncryptionKey{}
	e.GetKID()
	e = nil
	e.GetKID()
}

func TestEncryptionKey_GetParentKID(tt *testing.T) {
	var zeroValue string
	e := &EncryptionKey{ParentKID: &zeroValue}
	e.GetParentKID()
	e = &EncryptionKey{}
	e.GetParentKID()
	e = nil
	e.GetParentKID()
}

func TestEncryptionKey_GetState(tt *testing.T) {
	var zeroValue string
	e := &EncryptionKey{State: &zeroValue}
	e.GetState()
	e = &EncryptionKey{}
	e.GetState()
	e = nil
	e.GetState()
}

func TestEncryptionKey_GetType(tt *testing.T) {
	var zeroValue string
	e := &EncryptionKey{Type: &zeroValue}
	e.GetType()
	e = &EncryptionKey{}
	e.GetType()
	e = nil
	e.GetType()
}

func TestEncryptionKey_GetUpdatedAt(tt *testing.T) {
	var zeroValue time.Time
	e := &EncryptionKey{UpdatedAt: &zeroValue}
	e.GetUpdatedAt()
	e = &EncryptionKey{}
	e.GetUpdatedAt()
	e = nil
	e.GetUpdatedAt()
}

func TestEncryptionKey_GetWrappedKey(tt *testing.T) {
	var zeroValue string
	e := &EncryptionKey{WrappedKey: &zeroValue}
	e.GetWrappedKey()
	e = &EncryptionKey{}
	e.GetWrappedKey()
	e = nil
	e.GetWrappedKey()
}

func TestEncryptionKey_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &EncryptionKey{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestEncryptionKeyList_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &EncryptionKeyList{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestEnrollment_GetEnrolledAt(tt *testing.T) {
	var zeroValue time.Time
	e := &Enrollment{EnrolledAt: &zeroValue}
	e.GetEnrolledAt()
	e = &Enrollment{}
	e.GetEnrolledAt()
	e = nil
	e.GetEnrolledAt()
}

func TestEnrollment_GetID(tt *testing.T) {
	var zeroValue string
	e := &Enrollment{ID: &zeroValue}
	e.GetID()
	e = &Enrollment{}
	e.GetID()
	e = nil
	e.GetID()
}

func TestEnrollment_GetIdentifier(tt *testing.T) {
	var zeroValue string
	e := &Enrollment{Identifier: &zeroValue}
	e.GetIdentifier()
	e = &Enrollment{}
	e.GetIdentifier()
	e = nil
	e.GetIdentifier()
}

func TestEnrollment_GetLastAuth(tt *testing.T) {
	var zeroValue time.Time
	e := &Enrollment{LastAuth: &zeroValue}
	e.GetLastAuth()
	e = &Enrollment{}
	e.GetLastAuth()
	e = nil
	e.GetLastAuth()
}

func TestEnrollment_GetName(tt *testing.T) {
	var zeroValue string
	e := &Enrollment{Name: &zeroValue}
	e.GetName()
	e = &Enrollment{}
	e.GetName()
	e = nil
	e.GetName()
}

func TestEnrollment_GetPhoneNumber(tt *testing.T) {
	var zeroValue string
	e := &Enrollment{PhoneNumber: &zeroValue}
	e.GetPhoneNumber()
	e = &Enrollment{}
	e.GetPhoneNumber()
	e = nil
	e.GetPhoneNumber()
}

func TestEnrollment_GetStatus(tt *testing.T) {
	var zeroValue string
	e := &Enrollment{Status: &zeroValue}
	e.GetStatus()
	e = &Enrollment{}
	e.GetStatus()
	e = nil
	e.GetStatus()
}

func TestEnrollment_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &Enrollment{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestEnrollmentTicket_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &EnrollmentTicket{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestEventStream_GetCreatedAt(tt *testing.T) {
	var zeroValue time.Time
	e := &EventStream{CreatedAt: &zeroValue}
	e.GetCreatedAt()
	e = &EventStream{}
	e.GetCreatedAt()
	e = nil
	e.GetCreatedAt()
}

func TestEventStream_GetDestination(tt *testing.T) {
	e := &EventStream{}
	e.GetDestination()
	e = nil
	e.GetDestination()
}

func TestEventStream_GetID(tt *testing.T) {
	var zeroValue string
	e := &EventStream{ID: &zeroValue}
	e.GetID()
	e = &EventStream{}
	e.GetID()
	e = nil
	e.GetID()
}

func TestEventStream_GetName(tt *testing.T) {
	var zeroValue string
	e := &EventStream{Name: &zeroValue}
	e.GetName()
	e = &EventStream{}
	e.GetName()
	e = nil
	e.GetName()
}

func TestEventStream_GetStatus(tt *testing.T) {
	var zeroValue string
	e := &EventStream{Status: &zeroValue}
	e.GetStatus()
	e = &EventStream{}
	e.GetStatus()
	e = nil
	e.GetStatus()
}

func TestEventStream_GetSubscriptions(tt *testing.T) {
	var zeroValue []EventStreamSubscription
	e := &EventStream{Subscriptions: &zeroValue}
	e.GetSubscriptions()
	e = &EventStream{}
	e.GetSubscriptions()
	e = nil
	e.GetSubscriptions()
}

func TestEventStream_GetUpdatedAt(tt *testing.T) {
	var zeroValue time.Time
	e := &EventStream{UpdatedAt: &zeroValue}
	e.GetUpdatedAt()
	e = &EventStream{}
	e.GetUpdatedAt()
	e = nil
	e.GetUpdatedAt()
}

func TestEventStream_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &EventStream{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestEventStreamDestination_GetEventStreamDestinationConfiguration(tt *testing.T) {
	zeroValue := map[string]interface{}{}
	e := &EventStreamDestination{EventStreamDestinationConfiguration: zeroValue}
	e.GetEventStreamDestinationConfiguration()
	e = &EventStreamDestination{}
	e.GetEventStreamDestinationConfiguration()
	e = nil
	e.GetEventStreamDestinationConfiguration()
}

func TestEventStreamDestination_GetEventStreamDestinationType(tt *testing.T) {
	var zeroValue string
	e := &EventStreamDestination{EventStreamDestinationType: &zeroValue}
	e.GetEventStreamDestinationType()
	e = &EventStreamDestination{}
	e.GetEventStreamDestinationType()
	e = nil
	e.GetEventStreamDestinationType()
}

func TestEventStreamDestination_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &EventStreamDestination{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestEventStreamList_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &EventStreamList{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestEventStreamSubscription_GetEventStreamSubscriptionType(tt *testing.T) {
	var zeroValue string
	e := &EventStreamSubscription{EventStreamSubscriptionType: &zeroValue}
	e.GetEventStreamSubscriptionType()
	e = &EventStreamSubscription{}
	e.GetEventStreamSubscriptionType()
	e = nil
	e.GetEventStreamSubscriptionType()
}

func TestEventStreamSubscription_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &EventStreamSubscription{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestFirebaseClientAddon_GetClientEmail(tt *testing.T) {
	var zeroValue string
	f := &FirebaseClientAddon{ClientEmail: &zeroValue}
	f.GetClientEmail()
	f = &FirebaseClientAddon{}
	f.GetClientEmail()
	f = nil
	f.GetClientEmail()
}

func TestFirebaseClientAddon_GetLifetimeInSeconds(tt *testing.T) {
	var zeroValue int
	f := &FirebaseClientAddon{LifetimeInSeconds: &zeroValue}
	f.GetLifetimeInSeconds()
	f = &FirebaseClientAddon{}
	f.GetLifetimeInSeconds()
	f = nil
	f.GetLifetimeInSeconds()
}

func TestFirebaseClientAddon_GetPrivateKey(tt *testing.T) {
	var zeroValue string
	f := &FirebaseClientAddon{PrivateKey: &zeroValue}
	f.GetPrivateKey()
	f = &FirebaseClientAddon{}
	f.GetPrivateKey()
	f = nil
	f.GetPrivateKey()
}

func TestFirebaseClientAddon_GetPrivateKeyID(tt *testing.T) {
	var zeroValue string
	f := &FirebaseClientAddon{PrivateKeyID: &zeroValue}
	f.GetPrivateKeyID()
	f = &FirebaseClientAddon{}
	f.GetPrivateKeyID()
	f = nil
	f.GetPrivateKeyID()
}

func TestFirebaseClientAddon_GetSecret(tt *testing.T) {
	var zeroValue string
	f := &FirebaseClientAddon{Secret: &zeroValue}
	f.GetSecret()
	f = &FirebaseClientAddon{}
	f.GetSecret()
	f = nil
	f.GetSecret()
}

func TestFirebaseClientAddon_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &FirebaseClientAddon{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestFlow_GetCreatedAt(tt *testing.T) {
	var zeroValue time.Time
	f := &Flow{CreatedAt: &zeroValue}
	f.GetCreatedAt()
	f = &Flow{}
	f.GetCreatedAt()
	f = nil
	f.GetCreatedAt()
}

func TestFlow_GetExecutedAt(tt *testing.T) {
	var zeroValue time.Time
	f := &Flow{ExecutedAt: &zeroValue}
	f.GetExecutedAt()
	f = &Flow{}
	f.GetExecutedAt()
	f = nil
	f.GetExecutedAt()
}

func TestFlow_GetID(tt *testing.T) {
	var zeroValue string
	f := &Flow{ID: &zeroValue}
	f.GetID()
	f = &Flow{}
	f.GetID()
	f = nil
	f.GetID()
}

func TestFlow_GetName(tt *testing.T) {
	var zeroValue string
	f := &Flow{Name: &zeroValue}
	f.GetName()
	f = &Flow{}
	f.GetName()
	f = nil
	f.GetName()
}

func TestFlow_GetUpdatedAt(tt *testing.T) {
	var zeroValue time.Time
	f := &Flow{UpdatedAt: &zeroValue}
	f.GetUpdatedAt()
	f = &Flow{}
	f.GetUpdatedAt()
	f = nil
	f.GetUpdatedAt()
}

func TestFlow_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &Flow{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestFlowList_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &FlowList{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestFlowVaultConnection_GetAccountName(tt *testing.T) {
	var zeroValue string
	f := &FlowVaultConnection{AccountName: &zeroValue}
	f.GetAccountName()
	f = &FlowVaultConnection{}
	f.GetAccountName()
	f = nil
	f.GetAccountName()
}

func TestFlowVaultConnection_GetAppID(tt *testing.T) {
	var zeroValue string
	f := &FlowVaultConnection{AppID: &zeroValue}
	f.GetAppID()
	f = &FlowVaultConnection{}
	f.GetAppID()
	f = nil
	f.GetAppID()
}

func TestFlowVaultConnection_GetCreatedAt(tt *testing.T) {
	var zeroValue time.Time
	f := &FlowVaultConnection{CreatedAt: &zeroValue}
	f.GetCreatedAt()
	f = &FlowVaultConnection{}
	f.GetCreatedAt()
	f = nil
	f.GetCreatedAt()
}

func TestFlowVaultConnection_GetEnvironment(tt *testing.T) {
	var zeroValue string
	f := &FlowVaultConnection{Environment: &zeroValue}
	f.GetEnvironment()
	f = &FlowVaultConnection{}
	f.GetEnvironment()
	f = nil
	f.GetEnvironment()
}

func TestFlowVaultConnection_GetFingerprint(tt *testing.T) {
	var zeroValue string
	f := &FlowVaultConnection{Fingerprint: &zeroValue}
	f.GetFingerprint()
	f = &FlowVaultConnection{}
	f.GetFingerprint()
	f = nil
	f.GetFingerprint()
}

func TestFlowVaultConnection_GetID(tt *testing.T) {
	var zeroValue string
	f := &FlowVaultConnection{ID: &zeroValue}
	f.GetID()
	f = &FlowVaultConnection{}
	f.GetID()
	f = nil
	f.GetID()
}

func TestFlowVaultConnection_GetName(tt *testing.T) {
	var zeroValue string
	f := &FlowVaultConnection{Name: &zeroValue}
	f.GetName()
	f = &FlowVaultConnection{}
	f.GetName()
	f = nil
	f.GetName()
}

func TestFlowVaultConnection_GetReady(tt *testing.T) {
	var zeroValue bool
	f := &FlowVaultConnection{Ready: &zeroValue}
	f.GetReady()
	f = &FlowVaultConnection{}
	f.GetReady()
	f = nil
	f.GetReady()
}

func TestFlowVaultConnection_GetRefreshedAt(tt *testing.T) {
	var zeroValue time.Time
	f := &FlowVaultConnection{RefreshedAt: &zeroValue}
	f.GetRefreshedAt()
	f = &FlowVaultConnection{}
	f.GetRefreshedAt()
	f = nil
	f.GetRefreshedAt()
}

func TestFlowVaultConnection_GetSetup(tt *testing.T) {
	var zeroValue map[string]interface{}
	f := &FlowVaultConnection{Setup: &zeroValue}
	f.GetSetup()
	f = &FlowVaultConnection{}
	f.GetSetup()
	f = nil
	f.GetSetup()
}

func TestFlowVaultConnection_GetUpdatedAt(tt *testing.T) {
	var zeroValue time.Time
	f := &FlowVaultConnection{UpdatedAt: &zeroValue}
	f.GetUpdatedAt()
	f = &FlowVaultConnection{}
	f.GetUpdatedAt()
	f = nil
	f.GetUpdatedAt()
}

func TestFlowVaultConnection_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &FlowVaultConnection{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestFlowVaultConnectionList_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &FlowVaultConnectionList{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestForm_GetCreatedAt(tt *testing.T) {
	var zeroValue time.Time
	f := &Form{CreatedAt: &zeroValue}
	f.GetCreatedAt()
	f = &Form{}
	f.GetCreatedAt()
	f = nil
	f.GetCreatedAt()
}

func TestForm_GetEmbeddedAt(tt *testing.T) {
	var zeroValue time.Time
	f := &Form{EmbeddedAt: &zeroValue}
	f.GetEmbeddedAt()
	f = &Form{}
	f.GetEmbeddedAt()
	f = nil
	f.GetEmbeddedAt()
}

func TestForm_GetEnding(tt *testing.T) {
	var zeroValue map[string]interface{}
	f := &Form{Ending: &zeroValue}
	f.GetEnding()
	f = &Form{}
	f.GetEnding()
	f = nil
	f.GetEnding()
}

func TestForm_GetID(tt *testing.T) {
	var zeroValue string
	f := &Form{ID: &zeroValue}
	f.GetID()
	f = &Form{}
	f.GetID()
	f = nil
	f.GetID()
}

func TestForm_GetLanguages(tt *testing.T) {
	f := &Form{}
	f.GetLanguages()
	f = nil
	f.GetLanguages()
}

func TestForm_GetMessages(tt *testing.T) {
	f := &Form{}
	f.GetMessages()
	f = nil
	f.GetMessages()
}

func TestForm_GetName(tt *testing.T) {
	var zeroValue string
	f := &Form{Name: &zeroValue}
	f.GetName()
	f = &Form{}
	f.GetName()
	f = nil
	f.GetName()
}

func TestForm_GetStart(tt *testing.T) {
	var zeroValue map[string]interface{}
	f := &Form{Start: &zeroValue}
	f.GetStart()
	f = &Form{}
	f.GetStart()
	f = nil
	f.GetStart()
}

func TestForm_GetStyle(tt *testing.T) {
	var zeroValue map[string]interface{}
	f := &Form{Style: &zeroValue}
	f.GetStyle()
	f = &Form{}
	f.GetStyle()
	f = nil
	f.GetStyle()
}

func TestForm_GetSubmittedAt(tt *testing.T) {
	var zeroValue time.Time
	f := &Form{SubmittedAt: &zeroValue}
	f.GetSubmittedAt()
	f = &Form{}
	f.GetSubmittedAt()
	f = nil
	f.GetSubmittedAt()
}

func TestForm_GetTranslations(tt *testing.T) {
	var zeroValue map[string]interface{}
	f := &Form{Translations: &zeroValue}
	f.GetTranslations()
	f = &Form{}
	f.GetTranslations()
	f = nil
	f.GetTranslations()
}

func TestForm_GetUpdatedAt(tt *testing.T) {
	var zeroValue time.Time
	f := &Form{UpdatedAt: &zeroValue}
	f.GetUpdatedAt()
	f = &Form{}
	f.GetUpdatedAt()
	f = nil
	f.GetUpdatedAt()
}

func TestForm_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &Form{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestFormLanguages_GetDefault(tt *testing.T) {
	var zeroValue string
	f := &FormLanguages{Default: &zeroValue}
	f.GetDefault()
	f = &FormLanguages{}
	f.GetDefault()
	f = nil
	f.GetDefault()
}

func TestFormLanguages_GetPrimary(tt *testing.T) {
	var zeroValue string
	f := &FormLanguages{Primary: &zeroValue}
	f.GetPrimary()
	f = &FormLanguages{}
	f.GetPrimary()
	f = nil
	f.GetPrimary()
}

func TestFormLanguages_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &FormLanguages{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestFormList_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &FormList{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestFormMessages_GetCustom(tt *testing.T) {
	var zeroValue map[string]interface{}
	f := &FormMessages{Custom: &zeroValue}
	f.GetCustom()
	f = &FormMessages{}
	f.GetCustom()
	f = nil
	f.GetCustom()
}

func TestFormMessages_GetErrors(tt *testing.T) {
	var zeroValue map[string]interface{}
	f := &FormMessages{Errors: &zeroValue}
	f.GetErrors()
	f = &FormMessages{}
	f.GetErrors()
	f = nil
	f.GetErrors()
}

func TestFormMessages_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &FormMessages{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestGrant_GetAudience(tt *testing.T) {
	var zeroValue string
	g := &Grant{Audience: &zeroValue}
	g.GetAudience()
	g = &Grant{}
	g.GetAudience()
	g = nil
	g.GetAudience()
}

func TestGrant_GetClientID(tt *testing.T) {
	var zeroValue string
	g := &Grant{ClientID: &zeroValue}
	g.GetClientID()
	g = &Grant{}
	g.GetClientID()
	g = nil
	g.GetClientID()
}

func TestGrant_GetID(tt *testing.T) {
	var zeroValue string
	g := &Grant{ID: &zeroValue}
	g.GetID()
	g = &Grant{}
	g.GetID()
	g = nil
	g.GetID()
}

func TestGrant_GetUserID(tt *testing.T) {
	var zeroValue string
	g := &Grant{UserID: &zeroValue}
	g.GetUserID()
	g = &Grant{}
	g.GetUserID()
	g = nil
	g.GetUserID()
}

func TestGrant_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &Grant{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestGrantList_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &GrantList{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestHook_GetDependencies(tt *testing.T) {
	var zeroValue map[string]string
	h := &Hook{Dependencies: &zeroValue}
	h.GetDependencies()
	h = &Hook{}
	h.GetDependencies()
	h = nil
	h.GetDependencies()
}

func TestHook_GetEnabled(tt *testing.T) {
	var zeroValue bool
	h := &Hook{Enabled: &zeroValue}
	h.GetEnabled()
	h = &Hook{}
	h.GetEnabled()
	h = nil
	h.GetEnabled()
}

func TestHook_GetID(tt *testing.T) {
	var zeroValue string
	h := &Hook{ID: &zeroValue}
	h.GetID()
	h = &Hook{}
	h.GetID()
	h = nil
	h.GetID()
}

func TestHook_GetName(tt *testing.T) {
	var zeroValue string
	h := &Hook{Name: &zeroValue}
	h.GetName()
	h = &Hook{}
	h.GetName()
	h = nil
	h.GetName()
}

func TestHook_GetScript(tt *testing.T) {
	var zeroValue string
	h := &Hook{Script: &zeroValue}
	h.GetScript()
	h = &Hook{}
	h.GetScript()
	h = nil
	h.GetScript()
}

func TestHook_GetTriggerID(tt *testing.T) {
	var zeroValue string
	h := &Hook{TriggerID: &zeroValue}
	h.GetTriggerID()
	h = &Hook{}
	h.GetTriggerID()
	h = nil
	h.GetTriggerID()
}

func TestHook_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &Hook{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestHookList_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &HookList{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestJob_GetClientID(tt *testing.T) {
	var zeroValue string
	j := &Job{ClientID: &zeroValue}
	j.GetClientID()
	j = &Job{}
	j.GetClientID()
	j = nil
	j.GetClientID()
}

func TestJob_GetConnectionID(tt *testing.T) {
	var zeroValue string
	j := &Job{ConnectionID: &zeroValue}
	j.GetConnectionID()
	j = &Job{}
	j.GetConnectionID()
	j = nil
	j.GetConnectionID()
}

func TestJob_GetCreatedAt(tt *testing.T) {
	var zeroValue time.Time
	j := &Job{CreatedAt: &zeroValue}
	j.GetCreatedAt()
	j = &Job{}
	j.GetCreatedAt()
	j = nil
	j.GetCreatedAt()
}

func TestJob_GetExternalID(tt *testing.T) {
	var zeroValue string
	j := &Job{ExternalID: &zeroValue}
	j.GetExternalID()
	j = &Job{}
	j.GetExternalID()
	j = nil
	j.GetExternalID()
}

func TestJob_GetFormat(tt *testing.T) {
	var zeroValue string
	j := &Job{Format: &zeroValue}
	j.GetFormat()
	j = &Job{}
	j.GetFormat()
	j = nil
	j.GetFormat()
}

func TestJob_GetID(tt *testing.T) {
	var zeroValue string
	j := &Job{ID: &zeroValue}
	j.GetID()
	j = &Job{}
	j.GetID()
	j = nil
	j.GetID()
}

func TestJob_GetIdentity(tt *testing.T) {
	j := &Job{}
	j.GetIdentity()
	j = nil
	j.GetIdentity()
}

func TestJob_GetLimit(tt *testing.T) {
	var zeroValue int
	j := &Job{Limit: &zeroValue}
	j.GetLimit()
	j = &Job{}
	j.GetLimit()
	j = nil
	j.GetLimit()
}

func TestJob_GetLocation(tt *testing.T) {
	var zeroValue string
	j := &Job{Location: &zeroValue}
	j.GetLocation()
	j = &Job{}
	j.GetLocation()
	j = nil
	j.GetLocation()
}

func TestJob_GetOrganizationID(tt *testing.T) {
	var zeroValue string
	j := &Job{OrganizationID: &zeroValue}
	j.GetOrganizationID()
	j = &Job{}
	j.GetOrganizationID()
	j = nil
	j.GetOrganizationID()
}

func TestJob_GetPercentageDone(tt *testing.T) {
	var zeroValue int
	j := &Job{PercentageDone: &zeroValue}
	j.GetPercentageDone()
	j = &Job{}
	j.GetPercentageDone()
	j = nil
	j.GetPercentageDone()
}

func TestJob_GetSendCompletionEmail(tt *testing.T) {
	var zeroValue bool
	j := &Job{SendCompletionEmail: &zeroValue}
	j.GetSendCompletionEmail()
	j = &Job{}
	j.GetSendCompletionEmail()
	j = nil
	j.GetSendCompletionEmail()
}

func TestJob_GetStatus(tt *testing.T) {
	var zeroValue string
	j := &Job{Status: &zeroValue}
	j.GetStatus()
	j = &Job{}
	j.GetStatus()
	j = nil
	j.GetStatus()
}

func TestJob_GetSummary(tt *testing.T) {
	j := &Job{}
	j.GetSummary()
	j = nil
	j.GetSummary()
}

func TestJob_GetTimeLeftSeconds(tt *testing.T) {
	var zeroValue int
	j := &Job{TimeLeftSeconds: &zeroValue}
	j.GetTimeLeftSeconds()
	j = &Job{}
	j.GetTimeLeftSeconds()
	j = nil
	j.GetTimeLeftSeconds()
}

func TestJob_GetType(tt *testing.T) {
	var zeroValue string
	j := &Job{Type: &zeroValue}
	j.GetType()
	j = &Job{}
	j.GetType()
	j = nil
	j.GetType()
}

func TestJob_GetUpsert(tt *testing.T) {
	var zeroValue bool
	j := &Job{Upsert: &zeroValue}
	j.GetUpsert()
	j = &Job{}
	j.GetUpsert()
	j = nil
	j.GetUpsert()
}

func TestJob_GetUserID(tt *testing.T) {
	var zeroValue string
	j := &Job{UserID: &zeroValue}
	j.GetUserID()
	j = &Job{}
	j.GetUserID()
	j = nil
	j.GetUserID()
}

func TestJob_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &Job{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestJobError_GetUser(tt *testing.T) {
	zeroValue := map[string]interface{}{}
	j := &JobError{User: zeroValue}
	j.GetUser()
	j = &JobError{}
	j.GetUser()
	j = nil
	j.GetUser()
}

func TestJobError_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &JobError{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestJobSummary_GetFailed(tt *testing.T) {
	var zeroValue int
	j := &JobSummary{Failed: &zeroValue}
	j.GetFailed()
	j = &JobSummary{}
	j.GetFailed()
	j = nil
	j.GetFailed()
}

func TestJobSummary_GetInserted(tt *testing.T) {
	var zeroValue int
	j := &JobSummary{Inserted: &zeroValue}
	j.GetInserted()
	j = &JobSummary{}
	j.GetInserted()
	j = nil
	j.GetInserted()
}

func TestJobSummary_GetTotal(tt *testing.T) {
	var zeroValue int
	j := &JobSummary{Total: &zeroValue}
	j.GetTotal()
	j = &JobSummary{}
	j.GetTotal()
	j = nil
	j.GetTotal()
}

func TestJobSummary_GetUpdated(tt *testing.T) {
	var zeroValue int
	j := &JobSummary{Updated: &zeroValue}
	j.GetUpdated()
	j = &JobSummary{}
	j.GetUpdated()
	j = nil
	j.GetUpdated()
}

func TestJobSummary_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &JobSummary{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestJobUserErrors_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &JobUserErrors{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestLayerClientAddon_GetExpiration(tt *testing.T) {
	var zeroValue int
	l := &LayerClientAddon{Expiration: &zeroValue}
	l.GetExpiration()
	l = &LayerClientAddon{}
	l.GetExpiration()
	l = nil
	l.GetExpiration()
}

func TestLayerClientAddon_GetKeyID(tt *testing.T) {
	var zeroValue string
	l := &LayerClientAddon{KeyID: &zeroValue}
	l.GetKeyID()
	l = &LayerClientAddon{}
	l.GetKeyID()
	l = nil
	l.GetKeyID()
}

func TestLayerClientAddon_GetPrincipal(tt *testing.T) {
	var zeroValue string
	l := &LayerClientAddon{Principal: &zeroValue}
	l.GetPrincipal()
	l = &LayerClientAddon{}
	l.GetPrincipal()
	l = nil
	l.GetPrincipal()
}

func TestLayerClientAddon_GetPrivateKey(tt *testing.T) {
	var zeroValue string
	l := &LayerClientAddon{PrivateKey: &zeroValue}
	l.GetPrivateKey()
	l = &LayerClientAddon{}
	l.GetPrivateKey()
	l = nil
	l.GetPrivateKey()
}

func TestLayerClientAddon_GetProviderID(tt *testing.T) {
	var zeroValue string
	l := &LayerClientAddon{ProviderID: &zeroValue}
	l.GetProviderID()
	l = &LayerClientAddon{}
	l.GetProviderID()
	l = nil
	l.GetProviderID()
}

func TestLayerClientAddon_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &LayerClientAddon{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestList_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &List{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestLog_GetAudience(tt *testing.T) {
	var zeroValue string
	l := &Log{Audience: &zeroValue}
	l.GetAudience()
	l = &Log{}
	l.GetAudience()
	l = nil
	l.GetAudience()
}

func TestLog_GetClientID(tt *testing.T) {
	var zeroValue string
	l := &Log{ClientID: &zeroValue}
	l.GetClientID()
	l = &Log{}
	l.GetClientID()
	l = nil
	l.GetClientID()
}

func TestLog_GetClientName(tt *testing.T) {
	var zeroValue string
	l := &Log{ClientName: &zeroValue}
	l.GetClientName()
	l = &Log{}
	l.GetClientName()
	l = nil
	l.GetClientName()
}

func TestLog_GetConnection(tt *testing.T) {
	var zeroValue string
	l := &Log{Connection: &zeroValue}
	l.GetConnection()
	l = &Log{}
	l.GetConnection()
	l = nil
	l.GetConnection()
}

func TestLog_GetConnectionID(tt *testing.T) {
	var zeroValue string
	l := &Log{ConnectionID: &zeroValue}
	l.GetConnectionID()
	l = &Log{}
	l.GetConnectionID()
	l = nil
	l.GetConnectionID()
}

func TestLog_GetDate(tt *testing.T) {
	var zeroValue time.Time
	l := &Log{Date: &zeroValue}
	l.GetDate()
	l = &Log{}
	l.GetDate()
	l = nil
	l.GetDate()
}

func TestLog_GetDescription(tt *testing.T) {
	var zeroValue string
	l := &Log{Description: &zeroValue}
	l.GetDescription()
	l = &Log{}
	l.GetDescription()
	l = nil
	l.GetDescription()
}

func TestLog_GetDetails(tt *testing.T) {
	zeroValue := map[string]interface{}{}
	l := &Log{Details: zeroValue}
	l.GetDetails()
	l = &Log{}
	l.GetDetails()
	l = nil
	l.GetDetails()
}

func TestLog_GetHostname(tt *testing.T) {
	var zeroValue string
	l := &Log{Hostname: &zeroValue}
	l.GetHostname()
	l = &Log{}
	l.GetHostname()
	l = nil
	l.GetHostname()
}

func TestLog_GetID(tt *testing.T) {
	var zeroValue string
	l := &Log{ID: &zeroValue}
	l.GetID()
	l = &Log{}
	l.GetID()
	l = nil
	l.GetID()
}

func TestLog_GetIP(tt *testing.T) {
	var zeroValue string
	l := &Log{IP: &zeroValue}
	l.GetIP()
	l = &Log{}
	l.GetIP()
	l = nil
	l.GetIP()
}

func TestLog_GetIsMobile(tt *testing.T) {
	var zeroValue bool
	l := &Log{IsMobile: &zeroValue}
	l.GetIsMobile()
	l = &Log{}
	l.GetIsMobile()
	l = nil
	l.GetIsMobile()
}

func TestLog_GetLocationInfo(tt *testing.T) {
	zeroValue := map[string]interface{}{}
	l := &Log{LocationInfo: zeroValue}
	l.GetLocationInfo()
	l = &Log{}
	l.GetLocationInfo()
	l = nil
	l.GetLocationInfo()
}

func TestLog_GetLogID(tt *testing.T) {
	var zeroValue string
	l := &Log{LogID: &zeroValue}
	l.GetLogID()
	l = &Log{}
	l.GetLogID()
	l = nil
	l.GetLogID()
}

func TestLog_GetOrganizationID(tt *testing.T) {
	var zeroValue string
	l := &Log{OrganizationID: &zeroValue}
	l.GetOrganizationID()
	l = &Log{}
	l.GetOrganizationID()
	l = nil
	l.GetOrganizationID()
}

func TestLog_GetOrganizationName(tt *testing.T) {
	var zeroValue string
	l := &Log{OrganizationName: &zeroValue}
	l.GetOrganizationName()
	l = &Log{}
	l.GetOrganizationName()
	l = nil
	l.GetOrganizationName()
}

func TestLog_GetScope(tt *testing.T) {
	var zeroValue string
	l := &Log{Scope: &zeroValue}
	l.GetScope()
	l = &Log{}
	l.GetScope()
	l = nil
	l.GetScope()
}

func TestLog_GetStrategy(tt *testing.T) {
	var zeroValue string
	l := &Log{Strategy: &zeroValue}
	l.GetStrategy()
	l = &Log{}
	l.GetStrategy()
	l = nil
	l.GetStrategy()
}

func TestLog_GetStrategyType(tt *testing.T) {
	var zeroValue string
	l := &Log{StrategyType: &zeroValue}
	l.GetStrategyType()
	l = &Log{}
	l.GetStrategyType()
	l = nil
	l.GetStrategyType()
}

func TestLog_GetType(tt *testing.T) {
	var zeroValue string
	l := &Log{Type: &zeroValue}
	l.GetType()
	l = &Log{}
	l.GetType()
	l = nil
	l.GetType()
}

func TestLog_GetUserAgent(tt *testing.T) {
	var zeroValue string
	l := &Log{UserAgent: &zeroValue}
	l.GetUserAgent()
	l = &Log{}
	l.GetUserAgent()
	l = nil
	l.GetUserAgent()
}

func TestLog_GetUserID(tt *testing.T) {
	var zeroValue string
	l := &Log{UserID: &zeroValue}
	l.GetUserID()
	l = &Log{}
	l.GetUserID()
	l = nil
	l.GetUserID()
}

func TestLog_GetUserName(tt *testing.T) {
	var zeroValue string
	l := &Log{UserName: &zeroValue}
	l.GetUserName()
	l = &Log{}
	l.GetUserName()
	l = nil
	l.GetUserName()
}

func TestLog_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &Log{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestLogStream_GetFilters(tt *testing.T) {
	var zeroValue []map[string]string
	l := &LogStream{Filters: &zeroValue}
	l.GetFilters()
	l = &LogStream{}
	l.GetFilters()
	l = nil
	l.GetFilters()
}

func TestLogStream_GetID(tt *testing.T) {
	var zeroValue string
	l := &LogStream{ID: &zeroValue}
	l.GetID()
	l = &LogStream{}
	l.GetID()
	l = nil
	l.GetID()
}

func TestLogStream_GetIsPriority(tt *testing.T) {
	var zeroValue bool
	l := &LogStream{IsPriority: &zeroValue}
	l.GetIsPriority()
	l = &LogStream{}
	l.GetIsPriority()
	l = nil
	l.GetIsPriority()
}

func TestLogStream_GetName(tt *testing.T) {
	var zeroValue string
	l := &LogStream{Name: &zeroValue}
	l.GetName()
	l = &LogStream{}
	l.GetName()
	l = nil
	l.GetName()
}

func TestLogStream_GetStatus(tt *testing.T) {
	var zeroValue string
	l := &LogStream{Status: &zeroValue}
	l.GetStatus()
	l = &LogStream{}
	l.GetStatus()
	l = nil
	l.GetStatus()
}

func TestLogStream_GetType(tt *testing.T) {
	var zeroValue string
	l := &LogStream{Type: &zeroValue}
	l.GetType()
	l = &LogStream{}
	l.GetType()
	l = nil
	l.GetType()
}

func TestLogStream_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &LogStream{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestLogStreamSinkAmazonEventBridge_GetAccountID(tt *testing.T) {
	var zeroValue string
	l := &LogStreamSinkAmazonEventBridge{AccountID: &zeroValue}
	l.GetAccountID()
	l = &LogStreamSinkAmazonEventBridge{}
	l.GetAccountID()
	l = nil
	l.GetAccountID()
}

func TestLogStreamSinkAmazonEventBridge_GetPartnerEventSource(tt *testing.T) {
	var zeroValue string
	l := &LogStreamSinkAmazonEventBridge{PartnerEventSource: &zeroValue}
	l.GetPartnerEventSource()
	l = &LogStreamSinkAmazonEventBridge{}
	l.GetPartnerEventSource()
	l = nil
	l.GetPartnerEventSource()
}

func TestLogStreamSinkAmazonEventBridge_GetRegion(tt *testing.T) {
	var zeroValue string
	l := &LogStreamSinkAmazonEventBridge{Region: &zeroValue}
	l.GetRegion()
	l = &LogStreamSinkAmazonEventBridge{}
	l.GetRegion()
	l = nil
	l.GetRegion()
}

func TestLogStreamSinkAmazonEventBridge_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &LogStreamSinkAmazonEventBridge{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestLogStreamSinkAzureEventGrid_GetPartnerTopic(tt *testing.T) {
	var zeroValue string
	l := &LogStreamSinkAzureEventGrid{PartnerTopic: &zeroValue}
	l.GetPartnerTopic()
	l = &LogStreamSinkAzureEventGrid{}
	l.GetPartnerTopic()
	l = nil
	l.GetPartnerTopic()
}

func TestLogStreamSinkAzureEventGrid_GetRegion(tt *testing.T) {
	var zeroValue string
	l := &LogStreamSinkAzureEventGrid{Region: &zeroValue}
	l.GetRegion()
	l = &LogStreamSinkAzureEventGrid{}
	l.GetRegion()
	l = nil
	l.GetRegion()
}

func TestLogStreamSinkAzureEventGrid_GetResourceGroup(tt *testing.T) {
	var zeroValue string
	l := &LogStreamSinkAzureEventGrid{ResourceGroup: &zeroValue}
	l.GetResourceGroup()
	l = &LogStreamSinkAzureEventGrid{}
	l.GetResourceGroup()
	l = nil
	l.GetResourceGroup()
}

func TestLogStreamSinkAzureEventGrid_GetSubscriptionID(tt *testing.T) {
	var zeroValue string
	l := &LogStreamSinkAzureEventGrid{SubscriptionID: &zeroValue}
	l.GetSubscriptionID()
	l = &LogStreamSinkAzureEventGrid{}
	l.GetSubscriptionID()
	l = nil
	l.GetSubscriptionID()
}

func TestLogStreamSinkAzureEventGrid_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &LogStreamSinkAzureEventGrid{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestLogStreamSinkDatadog_GetAPIKey(tt *testing.T) {
	var zeroValue string
	l := &LogStreamSinkDatadog{APIKey: &zeroValue}
	l.GetAPIKey()
	l = &LogStreamSinkDatadog{}
	l.GetAPIKey()
	l = nil
	l.GetAPIKey()
}

func TestLogStreamSinkDatadog_GetRegion(tt *testing.T) {
	var zeroValue string
	l := &LogStreamSinkDatadog{Region: &zeroValue}
	l.GetRegion()
	l = &LogStreamSinkDatadog{}
	l.GetRegion()
	l = nil
	l.GetRegion()
}

func TestLogStreamSinkDatadog_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &LogStreamSinkDatadog{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestLogStreamSinkHTTP_GetAuthorization(tt *testing.T) {
	var zeroValue string
	l := &LogStreamSinkHTTP{Authorization: &zeroValue}
	l.GetAuthorization()
	l = &LogStreamSinkHTTP{}
	l.GetAuthorization()
	l = nil
	l.GetAuthorization()
}

func TestLogStreamSinkHTTP_GetContentFormat(tt *testing.T) {
	var zeroValue string
	l := &LogStreamSinkHTTP{ContentFormat: &zeroValue}
	l.GetContentFormat()
	l = &LogStreamSinkHTTP{}
	l.GetContentFormat()
	l = nil
	l.GetContentFormat()
}

func TestLogStreamSinkHTTP_GetContentType(tt *testing.T) {
	var zeroValue string
	l := &LogStreamSinkHTTP{ContentType: &zeroValue}
	l.GetContentType()
	l = &LogStreamSinkHTTP{}
	l.GetContentType()
	l = nil
	l.GetContentType()
}

func TestLogStreamSinkHTTP_GetCustomHeaders(tt *testing.T) {
	var zeroValue []map[string]string
	l := &LogStreamSinkHTTP{CustomHeaders: &zeroValue}
	l.GetCustomHeaders()
	l = &LogStreamSinkHTTP{}
	l.GetCustomHeaders()
	l = nil
	l.GetCustomHeaders()
}

func TestLogStreamSinkHTTP_GetEndpoint(tt *testing.T) {
	var zeroValue string
	l := &LogStreamSinkHTTP{Endpoint: &zeroValue}
	l.GetEndpoint()
	l = &LogStreamSinkHTTP{}
	l.GetEndpoint()
	l = nil
	l.GetEndpoint()
}

func TestLogStreamSinkHTTP_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &LogStreamSinkHTTP{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestLogStreamSinkMixpanel_GetProjectID(tt *testing.T) {
	var zeroValue string
	l := &LogStreamSinkMixpanel{ProjectID: &zeroValue}
	l.GetProjectID()
	l = &LogStreamSinkMixpanel{}
	l.GetProjectID()
	l = nil
	l.GetProjectID()
}

func TestLogStreamSinkMixpanel_GetRegion(tt *testing.T) {
	var zeroValue string
	l := &LogStreamSinkMixpanel{Region: &zeroValue}
	l.GetRegion()
	l = &LogStreamSinkMixpanel{}
	l.GetRegion()
	l = nil
	l.GetRegion()
}

func TestLogStreamSinkMixpanel_GetServiceAccountPassword(tt *testing.T) {
	var zeroValue string
	l := &LogStreamSinkMixpanel{ServiceAccountPassword: &zeroValue}
	l.GetServiceAccountPassword()
	l = &LogStreamSinkMixpanel{}
	l.GetServiceAccountPassword()
	l = nil
	l.GetServiceAccountPassword()
}

func TestLogStreamSinkMixpanel_GetServiceAccountUsername(tt *testing.T) {
	var zeroValue string
	l := &LogStreamSinkMixpanel{ServiceAccountUsername: &zeroValue}
	l.GetServiceAccountUsername()
	l = &LogStreamSinkMixpanel{}
	l.GetServiceAccountUsername()
	l = nil
	l.GetServiceAccountUsername()
}

func TestLogStreamSinkMixpanel_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &LogStreamSinkMixpanel{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestLogStreamSinkSegment_GetWriteKey(tt *testing.T) {
	var zeroValue string
	l := &LogStreamSinkSegment{WriteKey: &zeroValue}
	l.GetWriteKey()
	l = &LogStreamSinkSegment{}
	l.GetWriteKey()
	l = nil
	l.GetWriteKey()
}

func TestLogStreamSinkSegment_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &LogStreamSinkSegment{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestLogStreamSinkSplunk_GetDomain(tt *testing.T) {
	var zeroValue string
	l := &LogStreamSinkSplunk{Domain: &zeroValue}
	l.GetDomain()
	l = &LogStreamSinkSplunk{}
	l.GetDomain()
	l = nil
	l.GetDomain()
}

func TestLogStreamSinkSplunk_GetPort(tt *testing.T) {
	var zeroValue string
	l := &LogStreamSinkSplunk{Port: &zeroValue}
	l.GetPort()
	l = &LogStreamSinkSplunk{}
	l.GetPort()
	l = nil
	l.GetPort()
}

func TestLogStreamSinkSplunk_GetSecure(tt *testing.T) {
	var zeroValue bool
	l := &LogStreamSinkSplunk{Secure: &zeroValue}
	l.GetSecure()
	l = &LogStreamSinkSplunk{}
	l.GetSecure()
	l = nil
	l.GetSecure()
}

func TestLogStreamSinkSplunk_GetToken(tt *testing.T) {
	var zeroValue string
	l := &LogStreamSinkSplunk{Token: &zeroValue}
	l.GetToken()
	l = &LogStreamSinkSplunk{}
	l.GetToken()
	l = nil
	l.GetToken()
}

func TestLogStreamSinkSplunk_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &LogStreamSinkSplunk{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestLogStreamSinkSumo_GetSourceAddress(tt *testing.T) {
	var zeroValue string
	l := &LogStreamSinkSumo{SourceAddress: &zeroValue}
	l.GetSourceAddress()
	l = &LogStreamSinkSumo{}
	l.GetSourceAddress()
	l = nil
	l.GetSourceAddress()
}

func TestLogStreamSinkSumo_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &LogStreamSinkSumo{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestMSCRMClientAddon_GetURL(tt *testing.T) {
	var zeroValue string
	m := &MSCRMClientAddon{URL: &zeroValue}
	m.GetURL()
	m = &MSCRMClientAddon{}
	m.GetURL()
	m = nil
	m.GetURL()
}

func TestMSCRMClientAddon_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &MSCRMClientAddon{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestMultiFactor_GetEnabled(tt *testing.T) {
	var zeroValue bool
	m := &MultiFactor{Enabled: &zeroValue}
	m.GetEnabled()
	m = &MultiFactor{}
	m.GetEnabled()
	m = nil
	m.GetEnabled()
}

func TestMultiFactor_GetName(tt *testing.T) {
	var zeroValue string
	m := &MultiFactor{Name: &zeroValue}
	m.GetName()
	m = &MultiFactor{}
	m.GetName()
	m = nil
	m.GetName()
}

func TestMultiFactor_GetTrialExpired(tt *testing.T) {
	var zeroValue bool
	m := &MultiFactor{TrialExpired: &zeroValue}
	m.GetTrialExpired()
	m = &MultiFactor{}
	m.GetTrialExpired()
	m = nil
	m.GetTrialExpired()
}

func TestMultiFactor_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &MultiFactor{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestMultiFactorDUOSettings_GetHostname(tt *testing.T) {
	var zeroValue string
	m := &MultiFactorDUOSettings{Hostname: &zeroValue}
	m.GetHostname()
	m = &MultiFactorDUOSettings{}
	m.GetHostname()
	m = nil
	m.GetHostname()
}

func TestMultiFactorDUOSettings_GetIntegrationKey(tt *testing.T) {
	var zeroValue string
	m := &MultiFactorDUOSettings{IntegrationKey: &zeroValue}
	m.GetIntegrationKey()
	m = &MultiFactorDUOSettings{}
	m.GetIntegrationKey()
	m = nil
	m.GetIntegrationKey()
}

func TestMultiFactorDUOSettings_GetSecretKey(tt *testing.T) {
	var zeroValue string
	m := &MultiFactorDUOSettings{SecretKey: &zeroValue}
	m.GetSecretKey()
	m = &MultiFactorDUOSettings{}
	m.GetSecretKey()
	m = nil
	m.GetSecretKey()
}

func TestMultiFactorDUOSettings_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &MultiFactorDUOSettings{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestMultiFactorProvider_GetProvider(tt *testing.T) {
	var zeroValue string
	m := &MultiFactorProvider{Provider: &zeroValue}
	m.GetProvider()
	m = &MultiFactorProvider{}
	m.GetProvider()
	m = nil
	m.GetProvider()
}

func TestMultiFactorProvider_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &MultiFactorProvider{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestMultiFactorProviderAmazonSNS_GetAccessKeyID(tt *testing.T) {
	var zeroValue string
	m := &MultiFactorProviderAmazonSNS{AccessKeyID: &zeroValue}
	m.GetAccessKeyID()
	m = &MultiFactorProviderAmazonSNS{}
	m.GetAccessKeyID()
	m = nil
	m.GetAccessKeyID()
}

func TestMultiFactorProviderAmazonSNS_GetAPNSPlatformApplicationARN(tt *testing.T) {
	var zeroValue string
	m := &MultiFactorProviderAmazonSNS{APNSPlatformApplicationARN: &zeroValue}
	m.GetAPNSPlatformApplicationARN()
	m = &MultiFactorProviderAmazonSNS{}
	m.GetAPNSPlatformApplicationARN()
	m = nil
	m.GetAPNSPlatformApplicationARN()
}

func TestMultiFactorProviderAmazonSNS_GetGCMPlatformApplicationARN(tt *testing.T) {
	var zeroValue string
	m := &MultiFactorProviderAmazonSNS{GCMPlatformApplicationARN: &zeroValue}
	m.GetGCMPlatformApplicationARN()
	m = &MultiFactorProviderAmazonSNS{}
	m.GetGCMPlatformApplicationARN()
	m = nil
	m.GetGCMPlatformApplicationARN()
}

func TestMultiFactorProviderAmazonSNS_GetRegion(tt *testing.T) {
	var zeroValue string
	m := &MultiFactorProviderAmazonSNS{Region: &zeroValue}
	m.GetRegion()
	m = &MultiFactorProviderAmazonSNS{}
	m.GetRegion()
	m = nil
	m.GetRegion()
}

func TestMultiFactorProviderAmazonSNS_GetSecretAccessKeyID(tt *testing.T) {
	var zeroValue string
	m := &MultiFactorProviderAmazonSNS{SecretAccessKeyID: &zeroValue}
	m.GetSecretAccessKeyID()
	m = &MultiFactorProviderAmazonSNS{}
	m.GetSecretAccessKeyID()
	m = nil
	m.GetSecretAccessKeyID()
}

func TestMultiFactorProviderAmazonSNS_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &MultiFactorProviderAmazonSNS{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestMultiFactorProviderTwilio_GetAuthToken(tt *testing.T) {
	var zeroValue string
	m := &MultiFactorProviderTwilio{AuthToken: &zeroValue}
	m.GetAuthToken()
	m = &MultiFactorProviderTwilio{}
	m.GetAuthToken()
	m = nil
	m.GetAuthToken()
}

func TestMultiFactorProviderTwilio_GetFrom(tt *testing.T) {
	var zeroValue string
	m := &MultiFactorProviderTwilio{From: &zeroValue}
	m.GetFrom()
	m = &MultiFactorProviderTwilio{}
	m.GetFrom()
	m = nil
	m.GetFrom()
}

func TestMultiFactorProviderTwilio_GetMessagingServiceSid(tt *testing.T) {
	var zeroValue string
	m := &MultiFactorProviderTwilio{MessagingServiceSid: &zeroValue}
	m.GetMessagingServiceSid()
	m = &MultiFactorProviderTwilio{}
	m.GetMessagingServiceSid()
	m = nil
	m.GetMessagingServiceSid()
}

func TestMultiFactorProviderTwilio_GetSID(tt *testing.T) {
	var zeroValue string
	m := &MultiFactorProviderTwilio{SID: &zeroValue}
	m.GetSID()
	m = &MultiFactorProviderTwilio{}
	m.GetSID()
	m = nil
	m.GetSID()
}

func TestMultiFactorProviderTwilio_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &MultiFactorProviderTwilio{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestMultiFactorPushCustomApp_GetAppleAppLink(tt *testing.T) {
	var zeroValue string
	m := &MultiFactorPushCustomApp{AppleAppLink: &zeroValue}
	m.GetAppleAppLink()
	m = &MultiFactorPushCustomApp{}
	m.GetAppleAppLink()
	m = nil
	m.GetAppleAppLink()
}

func TestMultiFactorPushCustomApp_GetAppName(tt *testing.T) {
	var zeroValue string
	m := &MultiFactorPushCustomApp{AppName: &zeroValue}
	m.GetAppName()
	m = &MultiFactorPushCustomApp{}
	m.GetAppName()
	m = nil
	m.GetAppName()
}

func TestMultiFactorPushCustomApp_GetGoogleAppLink(tt *testing.T) {
	var zeroValue string
	m := &MultiFactorPushCustomApp{GoogleAppLink: &zeroValue}
	m.GetGoogleAppLink()
	m = &MultiFactorPushCustomApp{}
	m.GetGoogleAppLink()
	m = nil
	m.GetGoogleAppLink()
}

func TestMultiFactorPushCustomApp_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &MultiFactorPushCustomApp{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestMultiFactorPushDirectAPNS_GetBundleID(tt *testing.T) {
	var zeroValue string
	m := &MultiFactorPushDirectAPNS{BundleID: &zeroValue}
	m.GetBundleID()
	m = &MultiFactorPushDirectAPNS{}
	m.GetBundleID()
	m = nil
	m.GetBundleID()
}

func TestMultiFactorPushDirectAPNS_GetEnabled(tt *testing.T) {
	var zeroValue bool
	m := &MultiFactorPushDirectAPNS{Enabled: &zeroValue}
	m.GetEnabled()
	m = &MultiFactorPushDirectAPNS{}
	m.GetEnabled()
	m = nil
	m.GetEnabled()
}

func TestMultiFactorPushDirectAPNS_GetP12(tt *testing.T) {
	var zeroValue string
	m := &MultiFactorPushDirectAPNS{P12: &zeroValue}
	m.GetP12()
	m = &MultiFactorPushDirectAPNS{}
	m.GetP12()
	m = nil
	m.GetP12()
}

func TestMultiFactorPushDirectAPNS_GetSandbox(tt *testing.T) {
	var zeroValue bool
	m := &MultiFactorPushDirectAPNS{Sandbox: &zeroValue}
	m.GetSandbox()
	m = &MultiFactorPushDirectAPNS{}
	m.GetSandbox()
	m = nil
	m.GetSandbox()
}

func TestMultiFactorPushDirectAPNS_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &MultiFactorPushDirectAPNS{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestMultiFactorPushDirectFCM_GetServerKey(tt *testing.T) {
	var zeroValue string
	m := &MultiFactorPushDirectFCM{ServerKey: &zeroValue}
	m.GetServerKey()
	m = &MultiFactorPushDirectFCM{}
	m.GetServerKey()
	m = nil
	m.GetServerKey()
}

func TestMultiFactorPushDirectFCM_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &MultiFactorPushDirectFCM{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestMultiFactorPushDirectFCMv1_GetServerCredentials(tt *testing.T) {
	var zeroValue string
	m := &MultiFactorPushDirectFCMv1{ServerCredentials: &zeroValue}
	m.GetServerCredentials()
	m = &MultiFactorPushDirectFCMv1{}
	m.GetServerCredentials()
	m = nil
	m.GetServerCredentials()
}

func TestMultiFactorPushDirectFCMv1_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &MultiFactorPushDirectFCMv1{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestMultiFactorSMSTemplate_GetEnrollmentMessage(tt *testing.T) {
	var zeroValue string
	m := &MultiFactorSMSTemplate{EnrollmentMessage: &zeroValue}
	m.GetEnrollmentMessage()
	m = &MultiFactorSMSTemplate{}
	m.GetEnrollmentMessage()
	m = nil
	m.GetEnrollmentMessage()
}

func TestMultiFactorSMSTemplate_GetVerificationMessage(tt *testing.T) {
	var zeroValue string
	m := &MultiFactorSMSTemplate{VerificationMessage: &zeroValue}
	m.GetVerificationMessage()
	m = &MultiFactorSMSTemplate{}
	m.GetVerificationMessage()
	m = nil
	m.GetVerificationMessage()
}

func TestMultiFactorSMSTemplate_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &MultiFactorSMSTemplate{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestMultiFactorWebAuthnSettings_GetOverrideRelyingParty(tt *testing.T) {
	var zeroValue bool
	m := &MultiFactorWebAuthnSettings{OverrideRelyingParty: &zeroValue}
	m.GetOverrideRelyingParty()
	m = &MultiFactorWebAuthnSettings{}
	m.GetOverrideRelyingParty()
	m = nil
	m.GetOverrideRelyingParty()
}

func TestMultiFactorWebAuthnSettings_GetRelyingPartyIdentifier(tt *testing.T) {
	var zeroValue string
	m := &MultiFactorWebAuthnSettings{RelyingPartyIdentifier: &zeroValue}
	m.GetRelyingPartyIdentifier()
	m = &MultiFactorWebAuthnSettings{}
	m.GetRelyingPartyIdentifier()
	m = nil
	m.GetRelyingPartyIdentifier()
}

func TestMultiFactorWebAuthnSettings_GetUserVerification(tt *testing.T) {
	var zeroValue string
	m := &MultiFactorWebAuthnSettings{UserVerification: &zeroValue}
	m.GetUserVerification()
	m = &MultiFactorWebAuthnSettings{}
	m.GetUserVerification()
	m = nil
	m.GetUserVerification()
}

func TestMultiFactorWebAuthnSettings_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &MultiFactorWebAuthnSettings{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestNetworkACL_GetActive(tt *testing.T) {
	var zeroValue bool
	n := &NetworkACL{Active: &zeroValue}
	n.GetActive()
	n = &NetworkACL{}
	n.GetActive()
	n = nil
	n.GetActive()
}

func TestNetworkACL_GetCreatedAt(tt *testing.T) {
	var zeroValue string
	n := &NetworkACL{CreatedAt: &zeroValue}
	n.GetCreatedAt()
	n = &NetworkACL{}
	n.GetCreatedAt()
	n = nil
	n.GetCreatedAt()
}

func TestNetworkACL_GetDescription(tt *testing.T) {
	var zeroValue string
	n := &NetworkACL{Description: &zeroValue}
	n.GetDescription()
	n = &NetworkACL{}
	n.GetDescription()
	n = nil
	n.GetDescription()
}

func TestNetworkACL_GetID(tt *testing.T) {
	var zeroValue string
	n := &NetworkACL{ID: &zeroValue}
	n.GetID()
	n = &NetworkACL{}
	n.GetID()
	n = nil
	n.GetID()
}

func TestNetworkACL_GetPriority(tt *testing.T) {
	var zeroValue int
	n := &NetworkACL{Priority: &zeroValue}
	n.GetPriority()
	n = &NetworkACL{}
	n.GetPriority()
	n = nil
	n.GetPriority()
}

func TestNetworkACL_GetRule(tt *testing.T) {
	n := &NetworkACL{}
	n.GetRule()
	n = nil
	n.GetRule()
}

func TestNetworkACL_GetUpdatedAt(tt *testing.T) {
	var zeroValue string
	n := &NetworkACL{UpdatedAt: &zeroValue}
	n.GetUpdatedAt()
	n = &NetworkACL{}
	n.GetUpdatedAt()
	n = nil
	n.GetUpdatedAt()
}

func TestNetworkACL_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &NetworkACL{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestNetworkACLRule_GetAction(tt *testing.T) {
	n := &NetworkACLRule{}
	n.GetAction()
	n = nil
	n.GetAction()
}

func TestNetworkACLRule_GetMatch(tt *testing.T) {
	n := &NetworkACLRule{}
	n.GetMatch()
	n = nil
	n.GetMatch()
}

func TestNetworkACLRule_GetNotMatch(tt *testing.T) {
	n := &NetworkACLRule{}
	n.GetNotMatch()
	n = nil
	n.GetNotMatch()
}

func TestNetworkACLRule_GetScope(tt *testing.T) {
	var zeroValue string
	n := &NetworkACLRule{Scope: &zeroValue}
	n.GetScope()
	n = &NetworkACLRule{}
	n.GetScope()
	n = nil
	n.GetScope()
}

func TestNetworkACLRule_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &NetworkACLRule{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestNetworkACLRuleAction_GetAllow(tt *testing.T) {
	var zeroValue bool
	n := &NetworkACLRuleAction{Allow: &zeroValue}
	n.GetAllow()
	n = &NetworkACLRuleAction{}
	n.GetAllow()
	n = nil
	n.GetAllow()
}

func TestNetworkACLRuleAction_GetBlock(tt *testing.T) {
	var zeroValue bool
	n := &NetworkACLRuleAction{Block: &zeroValue}
	n.GetBlock()
	n = &NetworkACLRuleAction{}
	n.GetBlock()
	n = nil
	n.GetBlock()
}

func TestNetworkACLRuleAction_GetLog(tt *testing.T) {
	var zeroValue bool
	n := &NetworkACLRuleAction{Log: &zeroValue}
	n.GetLog()
	n = &NetworkACLRuleAction{}
	n.GetLog()
	n = nil
	n.GetLog()
}

func TestNetworkACLRuleAction_GetRedirect(tt *testing.T) {
	var zeroValue bool
	n := &NetworkACLRuleAction{Redirect: &zeroValue}
	n.GetRedirect()
	n = &NetworkACLRuleAction{}
	n.GetRedirect()
	n = nil
	n.GetRedirect()
}

func TestNetworkACLRuleAction_GetRedirectURI(tt *testing.T) {
	var zeroValue string
	n := &NetworkACLRuleAction{RedirectURI: &zeroValue}
	n.GetRedirectURI()
	n = &NetworkACLRuleAction{}
	n.GetRedirectURI()
	n = nil
	n.GetRedirectURI()
}

func TestNetworkACLRuleAction_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &NetworkACLRuleAction{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestNetworkACLRuleMatch_GetAnonymousProxy(tt *testing.T) {
	var zeroValue bool
	n := &NetworkACLRuleMatch{AnonymousProxy: &zeroValue}
	n.GetAnonymousProxy()
	n = &NetworkACLRuleMatch{}
	n.GetAnonymousProxy()
	n = nil
	n.GetAnonymousProxy()
}

func TestNetworkACLRuleMatch_GetGeoCountryCodes(tt *testing.T) {
	var zeroValue []string
	n := &NetworkACLRuleMatch{GeoCountryCodes: &zeroValue}
	n.GetGeoCountryCodes()
	n = &NetworkACLRuleMatch{}
	n.GetGeoCountryCodes()
	n = nil
	n.GetGeoCountryCodes()
}

func TestNetworkACLRuleMatch_GetGeoSubdivisionCodes(tt *testing.T) {
	var zeroValue []string
	n := &NetworkACLRuleMatch{GeoSubdivisionCodes: &zeroValue}
	n.GetGeoSubdivisionCodes()
	n = &NetworkACLRuleMatch{}
	n.GetGeoSubdivisionCodes()
	n = nil
	n.GetGeoSubdivisionCodes()
}

func TestNetworkACLRuleMatch_GetIPv4Cidrs(tt *testing.T) {
	var zeroValue []string
	n := &NetworkACLRuleMatch{IPv4Cidrs: &zeroValue}
	n.GetIPv4Cidrs()
	n = &NetworkACLRuleMatch{}
	n.GetIPv4Cidrs()
	n = nil
	n.GetIPv4Cidrs()
}

func TestNetworkACLRuleMatch_GetIPv6Cidrs(tt *testing.T) {
	var zeroValue []string
	n := &NetworkACLRuleMatch{IPv6Cidrs: &zeroValue}
	n.GetIPv6Cidrs()
	n = &NetworkACLRuleMatch{}
	n.GetIPv6Cidrs()
	n = nil
	n.GetIPv6Cidrs()
}

func TestNetworkACLRuleMatch_GetJa3Fingerprints(tt *testing.T) {
	var zeroValue []string
	n := &NetworkACLRuleMatch{Ja3Fingerprints: &zeroValue}
	n.GetJa3Fingerprints()
	n = &NetworkACLRuleMatch{}
	n.GetJa3Fingerprints()
	n = nil
	n.GetJa3Fingerprints()
}

func TestNetworkACLRuleMatch_GetJa4Fingerprints(tt *testing.T) {
	var zeroValue []string
	n := &NetworkACLRuleMatch{Ja4Fingerprints: &zeroValue}
	n.GetJa4Fingerprints()
	n = &NetworkACLRuleMatch{}
	n.GetJa4Fingerprints()
	n = nil
	n.GetJa4Fingerprints()
}

func TestNetworkACLRuleMatch_GetUserAgents(tt *testing.T) {
	var zeroValue []string
	n := &NetworkACLRuleMatch{UserAgents: &zeroValue}
	n.GetUserAgents()
	n = &NetworkACLRuleMatch{}
	n.GetUserAgents()
	n = nil
	n.GetUserAgents()
}

func TestNetworkACLRuleMatch_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &NetworkACLRuleMatch{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestNewRelicClientAddon_GetAccount(tt *testing.T) {
	var zeroValue string
	n := &NewRelicClientAddon{Account: &zeroValue}
	n.GetAccount()
	n = &NewRelicClientAddon{}
	n.GetAccount()
	n = nil
	n.GetAccount()
}

func TestNewRelicClientAddon_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &NewRelicClientAddon{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestOffice365ClientAddon_GetConnection(tt *testing.T) {
	var zeroValue string
	o := &Office365ClientAddon{Connection: &zeroValue}
	o.GetConnection()
	o = &Office365ClientAddon{}
	o.GetConnection()
	o = nil
	o.GetConnection()
}

func TestOffice365ClientAddon_GetDomain(tt *testing.T) {
	var zeroValue string
	o := &Office365ClientAddon{Domain: &zeroValue}
	o.GetDomain()
	o = &Office365ClientAddon{}
	o.GetDomain()
	o = nil
	o.GetDomain()
}

func TestOffice365ClientAddon_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &Office365ClientAddon{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestOIDCBackchannelLogout_GetBackChannelLogoutURLs(tt *testing.T) {
	var zeroValue []string
	o := &OIDCBackchannelLogout{BackChannelLogoutURLs: &zeroValue}
	o.GetBackChannelLogoutURLs()
	o = &OIDCBackchannelLogout{}
	o.GetBackChannelLogoutURLs()
	o = nil
	o.GetBackChannelLogoutURLs()
}

func TestOIDCBackchannelLogout_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &OIDCBackchannelLogout{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestOIDCLogout_GetBackChannelLogoutInitiators(tt *testing.T) {
	o := &OIDCLogout{}
	o.GetBackChannelLogoutInitiators()
	o = nil
	o.GetBackChannelLogoutInitiators()
}

func TestOIDCLogout_GetBackChannelLogoutURLs(tt *testing.T) {
	var zeroValue []string
	o := &OIDCLogout{BackChannelLogoutURLs: &zeroValue}
	o.GetBackChannelLogoutURLs()
	o = &OIDCLogout{}
	o.GetBackChannelLogoutURLs()
	o = nil
	o.GetBackChannelLogoutURLs()
}

func TestOIDCLogout_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &OIDCLogout{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestOrganization_GetBranding(tt *testing.T) {
	o := &Organization{}
	o.GetBranding()
	o = nil
	o.GetBranding()
}

func TestOrganization_GetDisplayName(tt *testing.T) {
	var zeroValue string
	o := &Organization{DisplayName: &zeroValue}
	o.GetDisplayName()
	o = &Organization{}
	o.GetDisplayName()
	o = nil
	o.GetDisplayName()
}

func TestOrganization_GetID(tt *testing.T) {
	var zeroValue string
	o := &Organization{ID: &zeroValue}
	o.GetID()
	o = &Organization{}
	o.GetID()
	o = nil
	o.GetID()
}

func TestOrganization_GetMetadata(tt *testing.T) {
	var zeroValue map[string]string
	o := &Organization{Metadata: &zeroValue}
	o.GetMetadata()
	o = &Organization{}
	o.GetMetadata()
	o = nil
	o.GetMetadata()
}

func TestOrganization_GetName(tt *testing.T) {
	var zeroValue string
	o := &Organization{Name: &zeroValue}
	o.GetName()
	o = &Organization{}
	o.GetName()
	o = nil
	o.GetName()
}

func TestOrganization_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &Organization{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestOrganizationBranding_GetColors(tt *testing.T) {
	var zeroValue map[string]string
	o := &OrganizationBranding{Colors: &zeroValue}
	o.GetColors()
	o = &OrganizationBranding{}
	o.GetColors()
	o = nil
	o.GetColors()
}

func TestOrganizationBranding_GetLogoURL(tt *testing.T) {
	var zeroValue string
	o := &OrganizationBranding{LogoURL: &zeroValue}
	o.GetLogoURL()
	o = &OrganizationBranding{}
	o.GetLogoURL()
	o = nil
	o.GetLogoURL()
}

func TestOrganizationBranding_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &OrganizationBranding{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestOrganizationConnection_GetAssignMembershipOnLogin(tt *testing.T) {
	var zeroValue bool
	o := &OrganizationConnection{AssignMembershipOnLogin: &zeroValue}
	o.GetAssignMembershipOnLogin()
	o = &OrganizationConnection{}
	o.GetAssignMembershipOnLogin()
	o = nil
	o.GetAssignMembershipOnLogin()
}

func TestOrganizationConnection_GetConnection(tt *testing.T) {
	o := &OrganizationConnection{}
	o.GetConnection()
	o = nil
	o.GetConnection()
}

func TestOrganizationConnection_GetConnectionID(tt *testing.T) {
	var zeroValue string
	o := &OrganizationConnection{ConnectionID: &zeroValue}
	o.GetConnectionID()
	o = &OrganizationConnection{}
	o.GetConnectionID()
	o = nil
	o.GetConnectionID()
}

func TestOrganizationConnection_GetIsSignupEnabled(tt *testing.T) {
	var zeroValue bool
	o := &OrganizationConnection{IsSignupEnabled: &zeroValue}
	o.GetIsSignupEnabled()
	o = &OrganizationConnection{}
	o.GetIsSignupEnabled()
	o = nil
	o.GetIsSignupEnabled()
}

func TestOrganizationConnection_GetShowAsButton(tt *testing.T) {
	var zeroValue bool
	o := &OrganizationConnection{ShowAsButton: &zeroValue}
	o.GetShowAsButton()
	o = &OrganizationConnection{}
	o.GetShowAsButton()
	o = nil
	o.GetShowAsButton()
}

func TestOrganizationConnection_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &OrganizationConnection{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestOrganizationConnectionDetails_GetName(tt *testing.T) {
	var zeroValue string
	o := &OrganizationConnectionDetails{Name: &zeroValue}
	o.GetName()
	o = &OrganizationConnectionDetails{}
	o.GetName()
	o = nil
	o.GetName()
}

func TestOrganizationConnectionDetails_GetStrategy(tt *testing.T) {
	var zeroValue string
	o := &OrganizationConnectionDetails{Strategy: &zeroValue}
	o.GetStrategy()
	o = &OrganizationConnectionDetails{}
	o.GetStrategy()
	o = nil
	o.GetStrategy()
}

func TestOrganizationConnectionDetails_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &OrganizationConnectionDetails{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestOrganizationConnectionList_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &OrganizationConnectionList{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestOrganizationInvitation_GetAppMetadata(tt *testing.T) {
	zeroValue := map[string]interface{}{}
	o := &OrganizationInvitation{AppMetadata: zeroValue}
	o.GetAppMetadata()
	o = &OrganizationInvitation{}
	o.GetAppMetadata()
	o = nil
	o.GetAppMetadata()
}

func TestOrganizationInvitation_GetClientID(tt *testing.T) {
	var zeroValue string
	o := &OrganizationInvitation{ClientID: &zeroValue}
	o.GetClientID()
	o = &OrganizationInvitation{}
	o.GetClientID()
	o = nil
	o.GetClientID()
}

func TestOrganizationInvitation_GetConnectionID(tt *testing.T) {
	var zeroValue string
	o := &OrganizationInvitation{ConnectionID: &zeroValue}
	o.GetConnectionID()
	o = &OrganizationInvitation{}
	o.GetConnectionID()
	o = nil
	o.GetConnectionID()
}

func TestOrganizationInvitation_GetCreatedAt(tt *testing.T) {
	var zeroValue string
	o := &OrganizationInvitation{CreatedAt: &zeroValue}
	o.GetCreatedAt()
	o = &OrganizationInvitation{}
	o.GetCreatedAt()
	o = nil
	o.GetCreatedAt()
}

func TestOrganizationInvitation_GetExpiresAt(tt *testing.T) {
	var zeroValue string
	o := &OrganizationInvitation{ExpiresAt: &zeroValue}
	o.GetExpiresAt()
	o = &OrganizationInvitation{}
	o.GetExpiresAt()
	o = nil
	o.GetExpiresAt()
}

func TestOrganizationInvitation_GetID(tt *testing.T) {
	var zeroValue string
	o := &OrganizationInvitation{ID: &zeroValue}
	o.GetID()
	o = &OrganizationInvitation{}
	o.GetID()
	o = nil
	o.GetID()
}

func TestOrganizationInvitation_GetInvitationURL(tt *testing.T) {
	var zeroValue string
	o := &OrganizationInvitation{InvitationURL: &zeroValue}
	o.GetInvitationURL()
	o = &OrganizationInvitation{}
	o.GetInvitationURL()
	o = nil
	o.GetInvitationURL()
}

func TestOrganizationInvitation_GetInvitee(tt *testing.T) {
	o := &OrganizationInvitation{}
	o.GetInvitee()
	o = nil
	o.GetInvitee()
}

func TestOrganizationInvitation_GetInviter(tt *testing.T) {
	o := &OrganizationInvitation{}
	o.GetInviter()
	o = nil
	o.GetInviter()
}

func TestOrganizationInvitation_GetOrganizationID(tt *testing.T) {
	var zeroValue string
	o := &OrganizationInvitation{OrganizationID: &zeroValue}
	o.GetOrganizationID()
	o = &OrganizationInvitation{}
	o.GetOrganizationID()
	o = nil
	o.GetOrganizationID()
}

func TestOrganizationInvitation_GetSendInvitationEmail(tt *testing.T) {
	var zeroValue bool
	o := &OrganizationInvitation{SendInvitationEmail: &zeroValue}
	o.GetSendInvitationEmail()
	o = &OrganizationInvitation{}
	o.GetSendInvitationEmail()
	o = nil
	o.GetSendInvitationEmail()
}

func TestOrganizationInvitation_GetTicketID(tt *testing.T) {
	var zeroValue string
	o := &OrganizationInvitation{TicketID: &zeroValue}
	o.GetTicketID()
	o = &OrganizationInvitation{}
	o.GetTicketID()
	o = nil
	o.GetTicketID()
}

func TestOrganizationInvitation_GetTTLSec(tt *testing.T) {
	var zeroValue int
	o := &OrganizationInvitation{TTLSec: &zeroValue}
	o.GetTTLSec()
	o = &OrganizationInvitation{}
	o.GetTTLSec()
	o = nil
	o.GetTTLSec()
}

func TestOrganizationInvitation_GetUserMetadata(tt *testing.T) {
	zeroValue := map[string]interface{}{}
	o := &OrganizationInvitation{UserMetadata: zeroValue}
	o.GetUserMetadata()
	o = &OrganizationInvitation{}
	o.GetUserMetadata()
	o = nil
	o.GetUserMetadata()
}

func TestOrganizationInvitation_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &OrganizationInvitation{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestOrganizationInvitationInvitee_GetEmail(tt *testing.T) {
	var zeroValue string
	o := &OrganizationInvitationInvitee{Email: &zeroValue}
	o.GetEmail()
	o = &OrganizationInvitationInvitee{}
	o.GetEmail()
	o = nil
	o.GetEmail()
}

func TestOrganizationInvitationInvitee_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &OrganizationInvitationInvitee{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestOrganizationInvitationInviter_GetName(tt *testing.T) {
	var zeroValue string
	o := &OrganizationInvitationInviter{Name: &zeroValue}
	o.GetName()
	o = &OrganizationInvitationInviter{}
	o.GetName()
	o = nil
	o.GetName()
}

func TestOrganizationInvitationInviter_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &OrganizationInvitationInviter{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestOrganizationInvitationList_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &OrganizationInvitationList{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestOrganizationList_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &OrganizationList{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestOrganizationMember_GetEmail(tt *testing.T) {
	var zeroValue string
	o := &OrganizationMember{Email: &zeroValue}
	o.GetEmail()
	o = &OrganizationMember{}
	o.GetEmail()
	o = nil
	o.GetEmail()
}

func TestOrganizationMember_GetName(tt *testing.T) {
	var zeroValue string
	o := &OrganizationMember{Name: &zeroValue}
	o.GetName()
	o = &OrganizationMember{}
	o.GetName()
	o = nil
	o.GetName()
}

func TestOrganizationMember_GetPicture(tt *testing.T) {
	var zeroValue string
	o := &OrganizationMember{Picture: &zeroValue}
	o.GetPicture()
	o = &OrganizationMember{}
	o.GetPicture()
	o = nil
	o.GetPicture()
}

func TestOrganizationMember_GetUserID(tt *testing.T) {
	var zeroValue string
	o := &OrganizationMember{UserID: &zeroValue}
	o.GetUserID()
	o = &OrganizationMember{}
	o.GetUserID()
	o = nil
	o.GetUserID()
}

func TestOrganizationMember_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &OrganizationMember{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestOrganizationMemberList_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &OrganizationMemberList{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestOrganizationMemberListRole_GetID(tt *testing.T) {
	var zeroValue string
	o := &OrganizationMemberListRole{ID: &zeroValue}
	o.GetID()
	o = &OrganizationMemberListRole{}
	o.GetID()
	o = nil
	o.GetID()
}

func TestOrganizationMemberListRole_GetName(tt *testing.T) {
	var zeroValue string
	o := &OrganizationMemberListRole{Name: &zeroValue}
	o.GetName()
	o = &OrganizationMemberListRole{}
	o.GetName()
	o = nil
	o.GetName()
}

func TestOrganizationMemberListRole_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &OrganizationMemberListRole{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestOrganizationMemberRole_GetDescription(tt *testing.T) {
	var zeroValue string
	o := &OrganizationMemberRole{Description: &zeroValue}
	o.GetDescription()
	o = &OrganizationMemberRole{}
	o.GetDescription()
	o = nil
	o.GetDescription()
}

func TestOrganizationMemberRole_GetID(tt *testing.T) {
	var zeroValue string
	o := &OrganizationMemberRole{ID: &zeroValue}
	o.GetID()
	o = &OrganizationMemberRole{}
	o.GetID()
	o = nil
	o.GetID()
}

func TestOrganizationMemberRole_GetName(tt *testing.T) {
	var zeroValue string
	o := &OrganizationMemberRole{Name: &zeroValue}
	o.GetName()
	o = &OrganizationMemberRole{}
	o.GetName()
	o = nil
	o.GetName()
}

func TestOrganizationMemberRole_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &OrganizationMemberRole{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestOrganizationMemberRoleList_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &OrganizationMemberRoleList{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestPasskeyAuthenticationMethod_GetEnabled(tt *testing.T) {
	var zeroValue bool
	p := &PasskeyAuthenticationMethod{Enabled: &zeroValue}
	p.GetEnabled()
	p = &PasskeyAuthenticationMethod{}
	p.GetEnabled()
	p = nil
	p.GetEnabled()
}

func TestPasskeyAuthenticationMethod_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &PasskeyAuthenticationMethod{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestPasskeyOptions_GetChallengeUI(tt *testing.T) {
	var zeroValue string
	p := &PasskeyOptions{ChallengeUI: &zeroValue}
	p.GetChallengeUI()
	p = &PasskeyOptions{}
	p.GetChallengeUI()
	p = nil
	p.GetChallengeUI()
}

func TestPasskeyOptions_GetLocalEnrollmentEnabled(tt *testing.T) {
	var zeroValue bool
	p := &PasskeyOptions{LocalEnrollmentEnabled: &zeroValue}
	p.GetLocalEnrollmentEnabled()
	p = &PasskeyOptions{}
	p.GetLocalEnrollmentEnabled()
	p = nil
	p.GetLocalEnrollmentEnabled()
}

func TestPasskeyOptions_GetProgressiveEnrollmentEnabled(tt *testing.T) {
	var zeroValue bool
	p := &PasskeyOptions{ProgressiveEnrollmentEnabled: &zeroValue}
	p.GetProgressiveEnrollmentEnabled()
	p = &PasskeyOptions{}
	p.GetProgressiveEnrollmentEnabled()
	p = nil
	p.GetProgressiveEnrollmentEnabled()
}

func TestPasskeyOptions_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &PasskeyOptions{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestPasswordAuthenticationMethod_GetEnabled(tt *testing.T) {
	var zeroValue bool
	p := &PasswordAuthenticationMethod{Enabled: &zeroValue}
	p.GetEnabled()
	p = &PasswordAuthenticationMethod{}
	p.GetEnabled()
	p = nil
	p.GetEnabled()
}

func TestPasswordAuthenticationMethod_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &PasswordAuthenticationMethod{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestPermission_GetDescription(tt *testing.T) {
	var zeroValue string
	p := &Permission{Description: &zeroValue}
	p.GetDescription()
	p = &Permission{}
	p.GetDescription()
	p = nil
	p.GetDescription()
}

func TestPermission_GetName(tt *testing.T) {
	var zeroValue string
	p := &Permission{Name: &zeroValue}
	p.GetName()
	p = &Permission{}
	p.GetName()
	p = nil
	p.GetName()
}

func TestPermission_GetResourceServerIdentifier(tt *testing.T) {
	var zeroValue string
	p := &Permission{ResourceServerIdentifier: &zeroValue}
	p.GetResourceServerIdentifier()
	p = &Permission{}
	p.GetResourceServerIdentifier()
	p = nil
	p.GetResourceServerIdentifier()
}

func TestPermission_GetResourceServerName(tt *testing.T) {
	var zeroValue string
	p := &Permission{ResourceServerName: &zeroValue}
	p.GetResourceServerName()
	p = &Permission{}
	p.GetResourceServerName()
	p = nil
	p.GetResourceServerName()
}

func TestPermission_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &Permission{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestPermissionList_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &PermissionList{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestPhoneMessageTypes_GetMessageTypes(tt *testing.T) {
	var zeroValue []string
	p := &PhoneMessageTypes{MessageTypes: &zeroValue}
	p.GetMessageTypes()
	p = &PhoneMessageTypes{}
	p.GetMessageTypes()
	p = nil
	p.GetMessageTypes()
}

func TestPhoneMessageTypes_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &PhoneMessageTypes{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestPreLogin_GetMaxAttempts(tt *testing.T) {
	var zeroValue int
	p := &PreLogin{MaxAttempts: &zeroValue}
	p.GetMaxAttempts()
	p = &PreLogin{}
	p.GetMaxAttempts()
	p = nil
	p.GetMaxAttempts()
}

func TestPreLogin_GetRate(tt *testing.T) {
	var zeroValue int
	p := &PreLogin{Rate: &zeroValue}
	p.GetRate()
	p = &PreLogin{}
	p.GetRate()
	p = nil
	p.GetRate()
}

func TestPreLogin_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &PreLogin{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestPreUserRegistration_GetMaxAttempts(tt *testing.T) {
	var zeroValue int
	p := &PreUserRegistration{MaxAttempts: &zeroValue}
	p.GetMaxAttempts()
	p = &PreUserRegistration{}
	p.GetMaxAttempts()
	p = nil
	p.GetMaxAttempts()
}

func TestPreUserRegistration_GetRate(tt *testing.T) {
	var zeroValue int
	p := &PreUserRegistration{Rate: &zeroValue}
	p.GetRate()
	p = &PreUserRegistration{}
	p.GetRate()
	p = nil
	p.GetRate()
}

func TestPreUserRegistration_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &PreUserRegistration{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestPrivateKeyJWT_GetCredentials(tt *testing.T) {
	var zeroValue []Credential
	p := &PrivateKeyJWT{Credentials: &zeroValue}
	p.GetCredentials()
	p = &PrivateKeyJWT{}
	p.GetCredentials()
	p = nil
	p.GetCredentials()
}

func TestPrivateKeyJWT_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &PrivateKeyJWT{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestPrompt_GetIdentifierFirst(tt *testing.T) {
	var zeroValue bool
	p := &Prompt{IdentifierFirst: &zeroValue}
	p.GetIdentifierFirst()
	p = &Prompt{}
	p.GetIdentifierFirst()
	p = nil
	p.GetIdentifierFirst()
}

func TestPrompt_GetWebAuthnPlatformFirstFactor(tt *testing.T) {
	var zeroValue bool
	p := &Prompt{WebAuthnPlatformFirstFactor: &zeroValue}
	p.GetWebAuthnPlatformFirstFactor()
	p = &Prompt{}
	p.GetWebAuthnPlatformFirstFactor()
	p = nil
	p.GetWebAuthnPlatformFirstFactor()
}

func TestPrompt_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &Prompt{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestPromptPartials_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &PromptPartials{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestPromptRendering_GetContextConfiguration(tt *testing.T) {
	var zeroValue []string
	p := &PromptRendering{ContextConfiguration: &zeroValue}
	p.GetContextConfiguration()
	p = &PromptRendering{}
	p.GetContextConfiguration()
	p = nil
	p.GetContextConfiguration()
}

func TestPromptRendering_GetDefaultHeadTagsDisabled(tt *testing.T) {
	var zeroValue bool
	p := &PromptRendering{DefaultHeadTagsDisabled: &zeroValue}
	p.GetDefaultHeadTagsDisabled()
	p = &PromptRendering{}
	p.GetDefaultHeadTagsDisabled()
	p = nil
	p.GetDefaultHeadTagsDisabled()
}

func TestPromptRendering_GetPrompt(tt *testing.T) {
	p := &PromptRendering{}
	p.GetPrompt()
	p = nil
	p.GetPrompt()
}

func TestPromptRendering_GetRenderingMode(tt *testing.T) {
	p := &PromptRendering{}
	p.GetRenderingMode()
	p = nil
	p.GetRenderingMode()
}

func TestPromptRendering_GetScreen(tt *testing.T) {
	p := &PromptRendering{}
	p.GetScreen()
	p = nil
	p.GetScreen()
}

func TestPromptRendering_GetTenant(tt *testing.T) {
	var zeroValue string
	p := &PromptRendering{Tenant: &zeroValue}
	p.GetTenant()
	p = &PromptRendering{}
	p.GetTenant()
	p = nil
	p.GetTenant()
}

func TestPromptRendering_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &PromptRendering{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestRefreshToken_GetClientID(tt *testing.T) {
	var zeroValue string
	r := &RefreshToken{ClientID: &zeroValue}
	r.GetClientID()
	r = &RefreshToken{}
	r.GetClientID()
	r = nil
	r.GetClientID()
}

func TestRefreshToken_GetCreatedAt(tt *testing.T) {
	var zeroValue time.Time
	r := &RefreshToken{CreatedAt: &zeroValue}
	r.GetCreatedAt()
	r = &RefreshToken{}
	r.GetCreatedAt()
	r = nil
	r.GetCreatedAt()
}

func TestRefreshToken_GetDevice(tt *testing.T) {
	r := &RefreshToken{}
	r.GetDevice()
	r = nil
	r.GetDevice()
}

func TestRefreshToken_GetExpiresAt(tt *testing.T) {
	var zeroValue time.Time
	r := &RefreshToken{ExpiresAt: &zeroValue}
	r.GetExpiresAt()
	r = &RefreshToken{}
	r.GetExpiresAt()
	r = nil
	r.GetExpiresAt()
}

func TestRefreshToken_GetID(tt *testing.T) {
	var zeroValue string
	r := &RefreshToken{ID: &zeroValue}
	r.GetID()
	r = &RefreshToken{}
	r.GetID()
	r = nil
	r.GetID()
}

func TestRefreshToken_GetIdleExpiresAt(tt *testing.T) {
	var zeroValue time.Time
	r := &RefreshToken{IdleExpiresAt: &zeroValue}
	r.GetIdleExpiresAt()
	r = &RefreshToken{}
	r.GetIdleExpiresAt()
	r = nil
	r.GetIdleExpiresAt()
}

func TestRefreshToken_GetLastExchangedAt(tt *testing.T) {
	var zeroValue string
	r := &RefreshToken{LastExchangedAt: &zeroValue}
	r.GetLastExchangedAt()
	r = &RefreshToken{}
	r.GetLastExchangedAt()
	r = nil
	r.GetLastExchangedAt()
}

func TestRefreshToken_GetRotating(tt *testing.T) {
	var zeroValue bool
	r := &RefreshToken{Rotating: &zeroValue}
	r.GetRotating()
	r = &RefreshToken{}
	r.GetRotating()
	r = nil
	r.GetRotating()
}

func TestRefreshToken_GetSessionID(tt *testing.T) {
	var zeroValue string
	r := &RefreshToken{SessionID: &zeroValue}
	r.GetSessionID()
	r = &RefreshToken{}
	r.GetSessionID()
	r = nil
	r.GetSessionID()
}

func TestRefreshToken_GetUserID(tt *testing.T) {
	var zeroValue string
	r := &RefreshToken{UserID: &zeroValue}
	r.GetUserID()
	r = &RefreshToken{}
	r.GetUserID()
	r = nil
	r.GetUserID()
}

func TestRefreshToken_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &RefreshToken{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestRefreshTokenDevice_GetInitialASN(tt *testing.T) {
	var zeroValue string
	r := &RefreshTokenDevice{InitialASN: &zeroValue}
	r.GetInitialASN()
	r = &RefreshTokenDevice{}
	r.GetInitialASN()
	r = nil
	r.GetInitialASN()
}

func TestRefreshTokenDevice_GetInitialIP(tt *testing.T) {
	var zeroValue string
	r := &RefreshTokenDevice{InitialIP: &zeroValue}
	r.GetInitialIP()
	r = &RefreshTokenDevice{}
	r.GetInitialIP()
	r = nil
	r.GetInitialIP()
}

func TestRefreshTokenDevice_GetInitialUserAgent(tt *testing.T) {
	var zeroValue string
	r := &RefreshTokenDevice{InitialUserAgent: &zeroValue}
	r.GetInitialUserAgent()
	r = &RefreshTokenDevice{}
	r.GetInitialUserAgent()
	r = nil
	r.GetInitialUserAgent()
}

func TestRefreshTokenDevice_GetLastASN(tt *testing.T) {
	var zeroValue string
	r := &RefreshTokenDevice{LastASN: &zeroValue}
	r.GetLastASN()
	r = &RefreshTokenDevice{}
	r.GetLastASN()
	r = nil
	r.GetLastASN()
}

func TestRefreshTokenDevice_GetLastIP(tt *testing.T) {
	var zeroValue string
	r := &RefreshTokenDevice{LastIP: &zeroValue}
	r.GetLastIP()
	r = &RefreshTokenDevice{}
	r.GetLastIP()
	r = nil
	r.GetLastIP()
}

func TestRefreshTokenDevice_GetLastUserAgent(tt *testing.T) {
	var zeroValue string
	r := &RefreshTokenDevice{LastUserAgent: &zeroValue}
	r.GetLastUserAgent()
	r = &RefreshTokenDevice{}
	r.GetLastUserAgent()
	r = nil
	r.GetLastUserAgent()
}

func TestRefreshTokenDevice_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &RefreshTokenDevice{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestRefreshTokenList_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &RefreshTokenList{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestRefreshTokenResourceServer_GetAudience(tt *testing.T) {
	var zeroValue string
	r := &RefreshTokenResourceServer{Audience: &zeroValue}
	r.GetAudience()
	r = &RefreshTokenResourceServer{}
	r.GetAudience()
	r = nil
	r.GetAudience()
}

func TestRefreshTokenResourceServer_GetScopes(tt *testing.T) {
	var zeroValue string
	r := &RefreshTokenResourceServer{Scopes: &zeroValue}
	r.GetScopes()
	r = &RefreshTokenResourceServer{}
	r.GetScopes()
	r = nil
	r.GetScopes()
}

func TestRefreshTokenResourceServer_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &RefreshTokenResourceServer{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestResourceServer_GetAllowOfflineAccess(tt *testing.T) {
	var zeroValue bool
	r := &ResourceServer{AllowOfflineAccess: &zeroValue}
	r.GetAllowOfflineAccess()
	r = &ResourceServer{}
	r.GetAllowOfflineAccess()
	r = nil
	r.GetAllowOfflineAccess()
}

func TestResourceServer_GetAuthorizationDetails(tt *testing.T) {
	var zeroValue []ResourceServerAuthorizationDetails
	r := &ResourceServer{AuthorizationDetails: &zeroValue}
	r.GetAuthorizationDetails()
	r = &ResourceServer{}
	r.GetAuthorizationDetails()
	r = nil
	r.GetAuthorizationDetails()
}

func TestResourceServer_GetConsentPolicy(tt *testing.T) {
	var zeroValue string
	r := &ResourceServer{ConsentPolicy: &zeroValue}
	r.GetConsentPolicy()
	r = &ResourceServer{}
	r.GetConsentPolicy()
	r = nil
	r.GetConsentPolicy()
}

func TestResourceServer_GetEnforcePolicies(tt *testing.T) {
	var zeroValue bool
	r := &ResourceServer{EnforcePolicies: &zeroValue}
	r.GetEnforcePolicies()
	r = &ResourceServer{}
	r.GetEnforcePolicies()
	r = nil
	r.GetEnforcePolicies()
}

func TestResourceServer_GetID(tt *testing.T) {
	var zeroValue string
	r := &ResourceServer{ID: &zeroValue}
	r.GetID()
	r = &ResourceServer{}
	r.GetID()
	r = nil
	r.GetID()
}

func TestResourceServer_GetIdentifier(tt *testing.T) {
	var zeroValue string
	r := &ResourceServer{Identifier: &zeroValue}
	r.GetIdentifier()
	r = &ResourceServer{}
	r.GetIdentifier()
	r = nil
	r.GetIdentifier()
}

func TestResourceServer_GetName(tt *testing.T) {
	var zeroValue string
	r := &ResourceServer{Name: &zeroValue}
	r.GetName()
	r = &ResourceServer{}
	r.GetName()
	r = nil
	r.GetName()
}

func TestResourceServer_GetOptions(tt *testing.T) {
	var zeroValue map[string]string
	r := &ResourceServer{Options: &zeroValue}
	r.GetOptions()
	r = &ResourceServer{}
	r.GetOptions()
	r = nil
	r.GetOptions()
}

func TestResourceServer_GetProofOfPossession(tt *testing.T) {
	r := &ResourceServer{}
	r.GetProofOfPossession()
	r = nil
	r.GetProofOfPossession()
}

func TestResourceServer_GetScopes(tt *testing.T) {
	var zeroValue []ResourceServerScope
	r := &ResourceServer{Scopes: &zeroValue}
	r.GetScopes()
	r = &ResourceServer{}
	r.GetScopes()
	r = nil
	r.GetScopes()
}

func TestResourceServer_GetSigningAlgorithm(tt *testing.T) {
	var zeroValue string
	r := &ResourceServer{SigningAlgorithm: &zeroValue}
	r.GetSigningAlgorithm()
	r = &ResourceServer{}
	r.GetSigningAlgorithm()
	r = nil
	r.GetSigningAlgorithm()
}

func TestResourceServer_GetSigningSecret(tt *testing.T) {
	var zeroValue string
	r := &ResourceServer{SigningSecret: &zeroValue}
	r.GetSigningSecret()
	r = &ResourceServer{}
	r.GetSigningSecret()
	r = nil
	r.GetSigningSecret()
}

func TestResourceServer_GetSkipConsentForVerifiableFirstPartyClients(tt *testing.T) {
	var zeroValue bool
	r := &ResourceServer{SkipConsentForVerifiableFirstPartyClients: &zeroValue}
	r.GetSkipConsentForVerifiableFirstPartyClients()
	r = &ResourceServer{}
	r.GetSkipConsentForVerifiableFirstPartyClients()
	r = nil
	r.GetSkipConsentForVerifiableFirstPartyClients()
}

func TestResourceServer_GetTokenDialect(tt *testing.T) {
	var zeroValue string
	r := &ResourceServer{TokenDialect: &zeroValue}
	r.GetTokenDialect()
	r = &ResourceServer{}
	r.GetTokenDialect()
	r = nil
	r.GetTokenDialect()
}

func TestResourceServer_GetTokenEncryption(tt *testing.T) {
	r := &ResourceServer{}
	r.GetTokenEncryption()
	r = nil
	r.GetTokenEncryption()
}

func TestResourceServer_GetTokenLifetime(tt *testing.T) {
	var zeroValue int
	r := &ResourceServer{TokenLifetime: &zeroValue}
	r.GetTokenLifetime()
	r = &ResourceServer{}
	r.GetTokenLifetime()
	r = nil
	r.GetTokenLifetime()
}

func TestResourceServer_GetTokenLifetimeForWeb(tt *testing.T) {
	var zeroValue int
	r := &ResourceServer{TokenLifetimeForWeb: &zeroValue}
	r.GetTokenLifetimeForWeb()
	r = &ResourceServer{}
	r.GetTokenLifetimeForWeb()
	r = nil
	r.GetTokenLifetimeForWeb()
}

func TestResourceServer_GetVerificationLocation(tt *testing.T) {
	var zeroValue string
	r := &ResourceServer{VerificationLocation: &zeroValue}
	r.GetVerificationLocation()
	r = &ResourceServer{}
	r.GetVerificationLocation()
	r = nil
	r.GetVerificationLocation()
}

func TestResourceServer_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ResourceServer{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestResourceServerAuthorizationDetails_GetType(tt *testing.T) {
	var zeroValue string
	r := &ResourceServerAuthorizationDetails{Type: &zeroValue}
	r.GetType()
	r = &ResourceServerAuthorizationDetails{}
	r.GetType()
	r = nil
	r.GetType()
}

func TestResourceServerAuthorizationDetails_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ResourceServerAuthorizationDetails{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestResourceServerList_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ResourceServerList{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestResourceServerProofOfPossession_GetMechanism(tt *testing.T) {
	var zeroValue string
	r := &ResourceServerProofOfPossession{Mechanism: &zeroValue}
	r.GetMechanism()
	r = &ResourceServerProofOfPossession{}
	r.GetMechanism()
	r = nil
	r.GetMechanism()
}

func TestResourceServerProofOfPossession_GetRequired(tt *testing.T) {
	var zeroValue bool
	r := &ResourceServerProofOfPossession{Required: &zeroValue}
	r.GetRequired()
	r = &ResourceServerProofOfPossession{}
	r.GetRequired()
	r = nil
	r.GetRequired()
}

func TestResourceServerProofOfPossession_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ResourceServerProofOfPossession{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestResourceServerScope_GetDescription(tt *testing.T) {
	var zeroValue string
	r := &ResourceServerScope{Description: &zeroValue}
	r.GetDescription()
	r = &ResourceServerScope{}
	r.GetDescription()
	r = nil
	r.GetDescription()
}

func TestResourceServerScope_GetValue(tt *testing.T) {
	var zeroValue string
	r := &ResourceServerScope{Value: &zeroValue}
	r.GetValue()
	r = &ResourceServerScope{}
	r.GetValue()
	r = nil
	r.GetValue()
}

func TestResourceServerScope_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ResourceServerScope{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestResourceServerTokenEncryption_GetEncryptionKey(tt *testing.T) {
	r := &ResourceServerTokenEncryption{}
	r.GetEncryptionKey()
	r = nil
	r.GetEncryptionKey()
}

func TestResourceServerTokenEncryption_GetFormat(tt *testing.T) {
	var zeroValue string
	r := &ResourceServerTokenEncryption{Format: &zeroValue}
	r.GetFormat()
	r = &ResourceServerTokenEncryption{}
	r.GetFormat()
	r = nil
	r.GetFormat()
}

func TestResourceServerTokenEncryption_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ResourceServerTokenEncryption{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestResourceServerTokenEncryptionKey_GetAlg(tt *testing.T) {
	var zeroValue string
	r := &ResourceServerTokenEncryptionKey{Alg: &zeroValue}
	r.GetAlg()
	r = &ResourceServerTokenEncryptionKey{}
	r.GetAlg()
	r = nil
	r.GetAlg()
}

func TestResourceServerTokenEncryptionKey_GetKid(tt *testing.T) {
	var zeroValue string
	r := &ResourceServerTokenEncryptionKey{Kid: &zeroValue}
	r.GetKid()
	r = &ResourceServerTokenEncryptionKey{}
	r.GetKid()
	r = nil
	r.GetKid()
}

func TestResourceServerTokenEncryptionKey_GetName(tt *testing.T) {
	var zeroValue string
	r := &ResourceServerTokenEncryptionKey{Name: &zeroValue}
	r.GetName()
	r = &ResourceServerTokenEncryptionKey{}
	r.GetName()
	r = nil
	r.GetName()
}

func TestResourceServerTokenEncryptionKey_GetPem(tt *testing.T) {
	var zeroValue string
	r := &ResourceServerTokenEncryptionKey{Pem: &zeroValue}
	r.GetPem()
	r = &ResourceServerTokenEncryptionKey{}
	r.GetPem()
	r = nil
	r.GetPem()
}

func TestResourceServerTokenEncryptionKey_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ResourceServerTokenEncryptionKey{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestRMSClientAddon_GetURL(tt *testing.T) {
	var zeroValue string
	r := &RMSClientAddon{URL: &zeroValue}
	r.GetURL()
	r = &RMSClientAddon{}
	r.GetURL()
	r = nil
	r.GetURL()
}

func TestRMSClientAddon_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &RMSClientAddon{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestRole_GetDescription(tt *testing.T) {
	var zeroValue string
	r := &Role{Description: &zeroValue}
	r.GetDescription()
	r = &Role{}
	r.GetDescription()
	r = nil
	r.GetDescription()
}

func TestRole_GetID(tt *testing.T) {
	var zeroValue string
	r := &Role{ID: &zeroValue}
	r.GetID()
	r = &Role{}
	r.GetID()
	r = nil
	r.GetID()
}

func TestRole_GetName(tt *testing.T) {
	var zeroValue string
	r := &Role{Name: &zeroValue}
	r.GetName()
	r = &Role{}
	r.GetName()
	r = nil
	r.GetName()
}

func TestRole_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &Role{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestRoleList_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &RoleList{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestRule_GetEnabled(tt *testing.T) {
	var zeroValue bool
	r := &Rule{Enabled: &zeroValue}
	r.GetEnabled()
	r = &Rule{}
	r.GetEnabled()
	r = nil
	r.GetEnabled()
}

func TestRule_GetID(tt *testing.T) {
	var zeroValue string
	r := &Rule{ID: &zeroValue}
	r.GetID()
	r = &Rule{}
	r.GetID()
	r = nil
	r.GetID()
}

func TestRule_GetName(tt *testing.T) {
	var zeroValue string
	r := &Rule{Name: &zeroValue}
	r.GetName()
	r = &Rule{}
	r.GetName()
	r = nil
	r.GetName()
}

func TestRule_GetOrder(tt *testing.T) {
	var zeroValue int
	r := &Rule{Order: &zeroValue}
	r.GetOrder()
	r = &Rule{}
	r.GetOrder()
	r = nil
	r.GetOrder()
}

func TestRule_GetScript(tt *testing.T) {
	var zeroValue string
	r := &Rule{Script: &zeroValue}
	r.GetScript()
	r = &Rule{}
	r.GetScript()
	r = nil
	r.GetScript()
}

func TestRule_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &Rule{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestRuleConfig_GetKey(tt *testing.T) {
	var zeroValue string
	r := &RuleConfig{Key: &zeroValue}
	r.GetKey()
	r = &RuleConfig{}
	r.GetKey()
	r = nil
	r.GetKey()
}

func TestRuleConfig_GetValue(tt *testing.T) {
	var zeroValue string
	r := &RuleConfig{Value: &zeroValue}
	r.GetValue()
	r = &RuleConfig{}
	r.GetValue()
	r = nil
	r.GetValue()
}

func TestRuleConfig_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &RuleConfig{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestRuleList_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &RuleList{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestSalesforceAPIClientAddon_GetClientID(tt *testing.T) {
	var zeroValue string
	s := &SalesforceAPIClientAddon{ClientID: &zeroValue}
	s.GetClientID()
	s = &SalesforceAPIClientAddon{}
	s.GetClientID()
	s = nil
	s.GetClientID()
}

func TestSalesforceAPIClientAddon_GetCommunityName(tt *testing.T) {
	var zeroValue string
	s := &SalesforceAPIClientAddon{CommunityName: &zeroValue}
	s.GetCommunityName()
	s = &SalesforceAPIClientAddon{}
	s.GetCommunityName()
	s = nil
	s.GetCommunityName()
}

func TestSalesforceAPIClientAddon_GetCommunityURLSection(tt *testing.T) {
	var zeroValue string
	s := &SalesforceAPIClientAddon{CommunityURLSection: &zeroValue}
	s.GetCommunityURLSection()
	s = &SalesforceAPIClientAddon{}
	s.GetCommunityURLSection()
	s = nil
	s.GetCommunityURLSection()
}

func TestSalesforceAPIClientAddon_GetPrincipal(tt *testing.T) {
	var zeroValue string
	s := &SalesforceAPIClientAddon{Principal: &zeroValue}
	s.GetPrincipal()
	s = &SalesforceAPIClientAddon{}
	s.GetPrincipal()
	s = nil
	s.GetPrincipal()
}

func TestSalesforceAPIClientAddon_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &SalesforceAPIClientAddon{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestSalesforceClientAddon_GetEntityID(tt *testing.T) {
	var zeroValue string
	s := &SalesforceClientAddon{EntityID: &zeroValue}
	s.GetEntityID()
	s = &SalesforceClientAddon{}
	s.GetEntityID()
	s = nil
	s.GetEntityID()
}

func TestSalesforceClientAddon_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &SalesforceClientAddon{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestSalesforceSandboxAPIClientAddon_GetClientID(tt *testing.T) {
	var zeroValue string
	s := &SalesforceSandboxAPIClientAddon{ClientID: &zeroValue}
	s.GetClientID()
	s = &SalesforceSandboxAPIClientAddon{}
	s.GetClientID()
	s = nil
	s.GetClientID()
}

func TestSalesforceSandboxAPIClientAddon_GetCommunityName(tt *testing.T) {
	var zeroValue string
	s := &SalesforceSandboxAPIClientAddon{CommunityName: &zeroValue}
	s.GetCommunityName()
	s = &SalesforceSandboxAPIClientAddon{}
	s.GetCommunityName()
	s = nil
	s.GetCommunityName()
}

func TestSalesforceSandboxAPIClientAddon_GetCommunityURLSection(tt *testing.T) {
	var zeroValue string
	s := &SalesforceSandboxAPIClientAddon{CommunityURLSection: &zeroValue}
	s.GetCommunityURLSection()
	s = &SalesforceSandboxAPIClientAddon{}
	s.GetCommunityURLSection()
	s = nil
	s.GetCommunityURLSection()
}

func TestSalesforceSandboxAPIClientAddon_GetPrincipal(tt *testing.T) {
	var zeroValue string
	s := &SalesforceSandboxAPIClientAddon{Principal: &zeroValue}
	s.GetPrincipal()
	s = &SalesforceSandboxAPIClientAddon{}
	s.GetPrincipal()
	s = nil
	s.GetPrincipal()
}

func TestSalesforceSandboxAPIClientAddon_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &SalesforceSandboxAPIClientAddon{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestSAML2ClientAddon_GetAudience(tt *testing.T) {
	var zeroValue string
	s := &SAML2ClientAddon{Audience: &zeroValue}
	s.GetAudience()
	s = &SAML2ClientAddon{}
	s.GetAudience()
	s = nil
	s.GetAudience()
}

func TestSAML2ClientAddon_GetAuthnContextClassRef(tt *testing.T) {
	var zeroValue string
	s := &SAML2ClientAddon{AuthnContextClassRef: &zeroValue}
	s.GetAuthnContextClassRef()
	s = &SAML2ClientAddon{}
	s.GetAuthnContextClassRef()
	s = nil
	s.GetAuthnContextClassRef()
}

func TestSAML2ClientAddon_GetBinding(tt *testing.T) {
	var zeroValue string
	s := &SAML2ClientAddon{Binding: &zeroValue}
	s.GetBinding()
	s = &SAML2ClientAddon{}
	s.GetBinding()
	s = nil
	s.GetBinding()
}

func TestSAML2ClientAddon_GetCreateUPNClaim(tt *testing.T) {
	var zeroValue bool
	s := &SAML2ClientAddon{CreateUPNClaim: &zeroValue}
	s.GetCreateUPNClaim()
	s = &SAML2ClientAddon{}
	s.GetCreateUPNClaim()
	s = nil
	s.GetCreateUPNClaim()
}

func TestSAML2ClientAddon_GetDestination(tt *testing.T) {
	var zeroValue string
	s := &SAML2ClientAddon{Destination: &zeroValue}
	s.GetDestination()
	s = &SAML2ClientAddon{}
	s.GetDestination()
	s = nil
	s.GetDestination()
}

func TestSAML2ClientAddon_GetDigestAlgorithm(tt *testing.T) {
	var zeroValue string
	s := &SAML2ClientAddon{DigestAlgorithm: &zeroValue}
	s.GetDigestAlgorithm()
	s = &SAML2ClientAddon{}
	s.GetDigestAlgorithm()
	s = nil
	s.GetDigestAlgorithm()
}

func TestSAML2ClientAddon_GetIncludeAttributeNameFormat(tt *testing.T) {
	var zeroValue bool
	s := &SAML2ClientAddon{IncludeAttributeNameFormat: &zeroValue}
	s.GetIncludeAttributeNameFormat()
	s = &SAML2ClientAddon{}
	s.GetIncludeAttributeNameFormat()
	s = nil
	s.GetIncludeAttributeNameFormat()
}

func TestSAML2ClientAddon_GetIssuer(tt *testing.T) {
	var zeroValue string
	s := &SAML2ClientAddon{Issuer: &zeroValue}
	s.GetIssuer()
	s = &SAML2ClientAddon{}
	s.GetIssuer()
	s = nil
	s.GetIssuer()
}

func TestSAML2ClientAddon_GetLifetimeInSeconds(tt *testing.T) {
	var zeroValue int
	s := &SAML2ClientAddon{LifetimeInSeconds: &zeroValue}
	s.GetLifetimeInSeconds()
	s = &SAML2ClientAddon{}
	s.GetLifetimeInSeconds()
	s = nil
	s.GetLifetimeInSeconds()
}

func TestSAML2ClientAddon_GetLogout(tt *testing.T) {
	s := &SAML2ClientAddon{}
	s.GetLogout()
	s = nil
	s.GetLogout()
}

func TestSAML2ClientAddon_GetMapIdentities(tt *testing.T) {
	var zeroValue bool
	s := &SAML2ClientAddon{MapIdentities: &zeroValue}
	s.GetMapIdentities()
	s = &SAML2ClientAddon{}
	s.GetMapIdentities()
	s = nil
	s.GetMapIdentities()
}

func TestSAML2ClientAddon_GetMappings(tt *testing.T) {
	var zeroValue map[string]string
	s := &SAML2ClientAddon{Mappings: &zeroValue}
	s.GetMappings()
	s = &SAML2ClientAddon{}
	s.GetMappings()
	s = nil
	s.GetMappings()
}

func TestSAML2ClientAddon_GetMapUnknownClaimsAsIs(tt *testing.T) {
	var zeroValue bool
	s := &SAML2ClientAddon{MapUnknownClaimsAsIs: &zeroValue}
	s.GetMapUnknownClaimsAsIs()
	s = &SAML2ClientAddon{}
	s.GetMapUnknownClaimsAsIs()
	s = nil
	s.GetMapUnknownClaimsAsIs()
}

func TestSAML2ClientAddon_GetNameIdentifierFormat(tt *testing.T) {
	var zeroValue string
	s := &SAML2ClientAddon{NameIdentifierFormat: &zeroValue}
	s.GetNameIdentifierFormat()
	s = &SAML2ClientAddon{}
	s.GetNameIdentifierFormat()
	s = nil
	s.GetNameIdentifierFormat()
}

func TestSAML2ClientAddon_GetNameIdentifierProbes(tt *testing.T) {
	var zeroValue []string
	s := &SAML2ClientAddon{NameIdentifierProbes: &zeroValue}
	s.GetNameIdentifierProbes()
	s = &SAML2ClientAddon{}
	s.GetNameIdentifierProbes()
	s = nil
	s.GetNameIdentifierProbes()
}

func TestSAML2ClientAddon_GetPassthroughClaimsWithNoMapping(tt *testing.T) {
	var zeroValue bool
	s := &SAML2ClientAddon{PassthroughClaimsWithNoMapping: &zeroValue}
	s.GetPassthroughClaimsWithNoMapping()
	s = &SAML2ClientAddon{}
	s.GetPassthroughClaimsWithNoMapping()
	s = nil
	s.GetPassthroughClaimsWithNoMapping()
}

func TestSAML2ClientAddon_GetRecipient(tt *testing.T) {
	var zeroValue string
	s := &SAML2ClientAddon{Recipient: &zeroValue}
	s.GetRecipient()
	s = &SAML2ClientAddon{}
	s.GetRecipient()
	s = nil
	s.GetRecipient()
}

func TestSAML2ClientAddon_GetSignatureAlgorithm(tt *testing.T) {
	var zeroValue string
	s := &SAML2ClientAddon{SignatureAlgorithm: &zeroValue}
	s.GetSignatureAlgorithm()
	s = &SAML2ClientAddon{}
	s.GetSignatureAlgorithm()
	s = nil
	s.GetSignatureAlgorithm()
}

func TestSAML2ClientAddon_GetSigningCert(tt *testing.T) {
	var zeroValue string
	s := &SAML2ClientAddon{SigningCert: &zeroValue}
	s.GetSigningCert()
	s = &SAML2ClientAddon{}
	s.GetSigningCert()
	s = nil
	s.GetSigningCert()
}

func TestSAML2ClientAddon_GetSignResponse(tt *testing.T) {
	var zeroValue bool
	s := &SAML2ClientAddon{SignResponse: &zeroValue}
	s.GetSignResponse()
	s = &SAML2ClientAddon{}
	s.GetSignResponse()
	s = nil
	s.GetSignResponse()
}

func TestSAML2ClientAddon_GetTypedAttributes(tt *testing.T) {
	var zeroValue bool
	s := &SAML2ClientAddon{TypedAttributes: &zeroValue}
	s.GetTypedAttributes()
	s = &SAML2ClientAddon{}
	s.GetTypedAttributes()
	s = nil
	s.GetTypedAttributes()
}

func TestSAML2ClientAddon_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &SAML2ClientAddon{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestSAML2ClientAddonLogout_GetCallback(tt *testing.T) {
	var zeroValue string
	s := &SAML2ClientAddonLogout{Callback: &zeroValue}
	s.GetCallback()
	s = &SAML2ClientAddonLogout{}
	s.GetCallback()
	s = nil
	s.GetCallback()
}

func TestSAML2ClientAddonLogout_GetSLOEnabled(tt *testing.T) {
	var zeroValue bool
	s := &SAML2ClientAddonLogout{SLOEnabled: &zeroValue}
	s.GetSLOEnabled()
	s = &SAML2ClientAddonLogout{}
	s.GetSLOEnabled()
	s = nil
	s.GetSLOEnabled()
}

func TestSAML2ClientAddonLogout_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &SAML2ClientAddonLogout{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestSAPAPIClientAddon_GetClientID(tt *testing.T) {
	var zeroValue string
	s := &SAPAPIClientAddon{ClientID: &zeroValue}
	s.GetClientID()
	s = &SAPAPIClientAddon{}
	s.GetClientID()
	s = nil
	s.GetClientID()
}

func TestSAPAPIClientAddon_GetNameIdentifierFormat(tt *testing.T) {
	var zeroValue string
	s := &SAPAPIClientAddon{NameIdentifierFormat: &zeroValue}
	s.GetNameIdentifierFormat()
	s = &SAPAPIClientAddon{}
	s.GetNameIdentifierFormat()
	s = nil
	s.GetNameIdentifierFormat()
}

func TestSAPAPIClientAddon_GetScope(tt *testing.T) {
	var zeroValue string
	s := &SAPAPIClientAddon{Scope: &zeroValue}
	s.GetScope()
	s = &SAPAPIClientAddon{}
	s.GetScope()
	s = nil
	s.GetScope()
}

func TestSAPAPIClientAddon_GetServicePassword(tt *testing.T) {
	var zeroValue string
	s := &SAPAPIClientAddon{ServicePassword: &zeroValue}
	s.GetServicePassword()
	s = &SAPAPIClientAddon{}
	s.GetServicePassword()
	s = nil
	s.GetServicePassword()
}

func TestSAPAPIClientAddon_GetTokenEndpointURL(tt *testing.T) {
	var zeroValue string
	s := &SAPAPIClientAddon{TokenEndpointURL: &zeroValue}
	s.GetTokenEndpointURL()
	s = &SAPAPIClientAddon{}
	s.GetTokenEndpointURL()
	s = nil
	s.GetTokenEndpointURL()
}

func TestSAPAPIClientAddon_GetUsernameAttribute(tt *testing.T) {
	var zeroValue string
	s := &SAPAPIClientAddon{UsernameAttribute: &zeroValue}
	s.GetUsernameAttribute()
	s = &SAPAPIClientAddon{}
	s.GetUsernameAttribute()
	s = nil
	s.GetUsernameAttribute()
}

func TestSAPAPIClientAddon_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &SAPAPIClientAddon{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestSCIMConfiguration_GetConnectionID(tt *testing.T) {
	var zeroValue string
	s := &SCIMConfiguration{ConnectionID: &zeroValue}
	s.GetConnectionID()
	s = &SCIMConfiguration{}
	s.GetConnectionID()
	s = nil
	s.GetConnectionID()
}

func TestSCIMConfiguration_GetConnectionName(tt *testing.T) {
	var zeroValue string
	s := &SCIMConfiguration{ConnectionName: &zeroValue}
	s.GetConnectionName()
	s = &SCIMConfiguration{}
	s.GetConnectionName()
	s = nil
	s.GetConnectionName()
}

func TestSCIMConfiguration_GetCreatedAt(tt *testing.T) {
	var zeroValue string
	s := &SCIMConfiguration{CreatedAt: &zeroValue}
	s.GetCreatedAt()
	s = &SCIMConfiguration{}
	s.GetCreatedAt()
	s = nil
	s.GetCreatedAt()
}

func TestSCIMConfiguration_GetMapping(tt *testing.T) {
	var zeroValue []SCIMConfigurationMapping
	s := &SCIMConfiguration{Mapping: &zeroValue}
	s.GetMapping()
	s = &SCIMConfiguration{}
	s.GetMapping()
	s = nil
	s.GetMapping()
}

func TestSCIMConfiguration_GetStrategy(tt *testing.T) {
	var zeroValue string
	s := &SCIMConfiguration{Strategy: &zeroValue}
	s.GetStrategy()
	s = &SCIMConfiguration{}
	s.GetStrategy()
	s = nil
	s.GetStrategy()
}

func TestSCIMConfiguration_GetTenantName(tt *testing.T) {
	var zeroValue string
	s := &SCIMConfiguration{TenantName: &zeroValue}
	s.GetTenantName()
	s = &SCIMConfiguration{}
	s.GetTenantName()
	s = nil
	s.GetTenantName()
}

func TestSCIMConfiguration_GetUpdatedAt(tt *testing.T) {
	var zeroValue string
	s := &SCIMConfiguration{UpdatedAt: &zeroValue}
	s.GetUpdatedAt()
	s = &SCIMConfiguration{}
	s.GetUpdatedAt()
	s = nil
	s.GetUpdatedAt()
}

func TestSCIMConfiguration_GetUserIDAttribute(tt *testing.T) {
	var zeroValue string
	s := &SCIMConfiguration{UserIDAttribute: &zeroValue}
	s.GetUserIDAttribute()
	s = &SCIMConfiguration{}
	s.GetUserIDAttribute()
	s = nil
	s.GetUserIDAttribute()
}

func TestSCIMConfiguration_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &SCIMConfiguration{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestSCIMConfigurationMapping_GetAuth0(tt *testing.T) {
	var zeroValue string
	s := &SCIMConfigurationMapping{Auth0: &zeroValue}
	s.GetAuth0()
	s = &SCIMConfigurationMapping{}
	s.GetAuth0()
	s = nil
	s.GetAuth0()
}

func TestSCIMConfigurationMapping_GetSCIM(tt *testing.T) {
	var zeroValue string
	s := &SCIMConfigurationMapping{SCIM: &zeroValue}
	s.GetSCIM()
	s = &SCIMConfigurationMapping{}
	s.GetSCIM()
	s = nil
	s.GetSCIM()
}

func TestSCIMConfigurationMapping_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &SCIMConfigurationMapping{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestSCIMToken_GetCreatedAt(tt *testing.T) {
	var zeroValue string
	s := &SCIMToken{CreatedAt: &zeroValue}
	s.GetCreatedAt()
	s = &SCIMToken{}
	s.GetCreatedAt()
	s = nil
	s.GetCreatedAt()
}

func TestSCIMToken_GetLastUsedAt(tt *testing.T) {
	var zeroValue string
	s := &SCIMToken{LastUsedAt: &zeroValue}
	s.GetLastUsedAt()
	s = &SCIMToken{}
	s.GetLastUsedAt()
	s = nil
	s.GetLastUsedAt()
}

func TestSCIMToken_GetScopes(tt *testing.T) {
	var zeroValue []string
	s := &SCIMToken{Scopes: &zeroValue}
	s.GetScopes()
	s = &SCIMToken{}
	s.GetScopes()
	s = nil
	s.GetScopes()
}

func TestSCIMToken_GetToken(tt *testing.T) {
	var zeroValue string
	s := &SCIMToken{Token: &zeroValue}
	s.GetToken()
	s = &SCIMToken{}
	s.GetToken()
	s = nil
	s.GetToken()
}

func TestSCIMToken_GetTokenID(tt *testing.T) {
	var zeroValue string
	s := &SCIMToken{TokenID: &zeroValue}
	s.GetTokenID()
	s = &SCIMToken{}
	s.GetTokenID()
	s = nil
	s.GetTokenID()
}

func TestSCIMToken_GetTokenLifeTime(tt *testing.T) {
	var zeroValue int
	s := &SCIMToken{TokenLifeTime: &zeroValue}
	s.GetTokenLifeTime()
	s = &SCIMToken{}
	s.GetTokenLifeTime()
	s = nil
	s.GetTokenLifeTime()
}

func TestSCIMToken_GetValidUntil(tt *testing.T) {
	var zeroValue string
	s := &SCIMToken{ValidUntil: &zeroValue}
	s.GetValidUntil()
	s = &SCIMToken{}
	s.GetValidUntil()
	s = nil
	s.GetValidUntil()
}

func TestSCIMToken_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &SCIMToken{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestScreenPartials_GetContent(tt *testing.T) {
	zeroValue := map[InsertionPoint]string{}
	s := &ScreenPartials{Content: zeroValue}
	s.GetContent()
	s = &ScreenPartials{}
	s.GetContent()
	s = nil
	s.GetContent()
}

func TestScreenPartials_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ScreenPartials{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestSelfServiceProfile_GetAllowedStrategies(tt *testing.T) {
	var zeroValue []string
	s := &SelfServiceProfile{AllowedStrategies: &zeroValue}
	s.GetAllowedStrategies()
	s = &SelfServiceProfile{}
	s.GetAllowedStrategies()
	s = nil
	s.GetAllowedStrategies()
}

func TestSelfServiceProfile_GetBranding(tt *testing.T) {
	s := &SelfServiceProfile{}
	s.GetBranding()
	s = nil
	s.GetBranding()
}

func TestSelfServiceProfile_GetCreatedAt(tt *testing.T) {
	var zeroValue time.Time
	s := &SelfServiceProfile{CreatedAt: &zeroValue}
	s.GetCreatedAt()
	s = &SelfServiceProfile{}
	s.GetCreatedAt()
	s = nil
	s.GetCreatedAt()
}

func TestSelfServiceProfile_GetDescription(tt *testing.T) {
	var zeroValue string
	s := &SelfServiceProfile{Description: &zeroValue}
	s.GetDescription()
	s = &SelfServiceProfile{}
	s.GetDescription()
	s = nil
	s.GetDescription()
}

func TestSelfServiceProfile_GetID(tt *testing.T) {
	var zeroValue string
	s := &SelfServiceProfile{ID: &zeroValue}
	s.GetID()
	s = &SelfServiceProfile{}
	s.GetID()
	s = nil
	s.GetID()
}

func TestSelfServiceProfile_GetName(tt *testing.T) {
	var zeroValue string
	s := &SelfServiceProfile{Name: &zeroValue}
	s.GetName()
	s = &SelfServiceProfile{}
	s.GetName()
	s = nil
	s.GetName()
}

func TestSelfServiceProfile_GetUpdatedAt(tt *testing.T) {
	var zeroValue time.Time
	s := &SelfServiceProfile{UpdatedAt: &zeroValue}
	s.GetUpdatedAt()
	s = &SelfServiceProfile{}
	s.GetUpdatedAt()
	s = nil
	s.GetUpdatedAt()
}

func TestSelfServiceProfile_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &SelfServiceProfile{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestSelfServiceProfileList_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &SelfServiceProfileList{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestSelfServiceProfileTicket_GetConnectionConfig(tt *testing.T) {
	s := &SelfServiceProfileTicket{}
	s.GetConnectionConfig()
	s = nil
	s.GetConnectionConfig()
}

func TestSelfServiceProfileTicket_GetConnectionID(tt *testing.T) {
	var zeroValue string
	s := &SelfServiceProfileTicket{ConnectionID: &zeroValue}
	s.GetConnectionID()
	s = &SelfServiceProfileTicket{}
	s.GetConnectionID()
	s = nil
	s.GetConnectionID()
}

func TestSelfServiceProfileTicket_GetDomainAliasesConfig(tt *testing.T) {
	s := &SelfServiceProfileTicket{}
	s.GetDomainAliasesConfig()
	s = nil
	s.GetDomainAliasesConfig()
}

func TestSelfServiceProfileTicket_GetEnabledClients(tt *testing.T) {
	var zeroValue []string
	s := &SelfServiceProfileTicket{EnabledClients: &zeroValue}
	s.GetEnabledClients()
	s = &SelfServiceProfileTicket{}
	s.GetEnabledClients()
	s = nil
	s.GetEnabledClients()
}

func TestSelfServiceProfileTicket_GetTicket(tt *testing.T) {
	var zeroValue string
	s := &SelfServiceProfileTicket{Ticket: &zeroValue}
	s.GetTicket()
	s = &SelfServiceProfileTicket{}
	s.GetTicket()
	s = nil
	s.GetTicket()
}

func TestSelfServiceProfileTicket_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &SelfServiceProfileTicket{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestSelfServiceProfileTicketConnectionConfig_GetDisplayName(tt *testing.T) {
	var zeroValue string
	s := &SelfServiceProfileTicketConnectionConfig{DisplayName: &zeroValue}
	s.GetDisplayName()
	s = &SelfServiceProfileTicketConnectionConfig{}
	s.GetDisplayName()
	s = nil
	s.GetDisplayName()
}

func TestSelfServiceProfileTicketConnectionConfig_GetIsDomainConnection(tt *testing.T) {
	var zeroValue bool
	s := &SelfServiceProfileTicketConnectionConfig{IsDomainConnection: &zeroValue}
	s.GetIsDomainConnection()
	s = &SelfServiceProfileTicketConnectionConfig{}
	s.GetIsDomainConnection()
	s = nil
	s.GetIsDomainConnection()
}

func TestSelfServiceProfileTicketConnectionConfig_GetMetadata(tt *testing.T) {
	var zeroValue map[string]interface{}
	s := &SelfServiceProfileTicketConnectionConfig{Metadata: &zeroValue}
	s.GetMetadata()
	s = &SelfServiceProfileTicketConnectionConfig{}
	s.GetMetadata()
	s = nil
	s.GetMetadata()
}

func TestSelfServiceProfileTicketConnectionConfig_GetName(tt *testing.T) {
	var zeroValue string
	s := &SelfServiceProfileTicketConnectionConfig{Name: &zeroValue}
	s.GetName()
	s = &SelfServiceProfileTicketConnectionConfig{}
	s.GetName()
	s = nil
	s.GetName()
}

func TestSelfServiceProfileTicketConnectionConfig_GetOptions(tt *testing.T) {
	s := &SelfServiceProfileTicketConnectionConfig{}
	s.GetOptions()
	s = nil
	s.GetOptions()
}

func TestSelfServiceProfileTicketConnectionConfig_GetShowAsButton(tt *testing.T) {
	var zeroValue bool
	s := &SelfServiceProfileTicketConnectionConfig{ShowAsButton: &zeroValue}
	s.GetShowAsButton()
	s = &SelfServiceProfileTicketConnectionConfig{}
	s.GetShowAsButton()
	s = nil
	s.GetShowAsButton()
}

func TestSelfServiceProfileTicketConnectionConfig_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &SelfServiceProfileTicketConnectionConfig{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestSelfServiceProfileTicketConnectionConfigOptions_GetDomainAliases(tt *testing.T) {
	var zeroValue []string
	s := &SelfServiceProfileTicketConnectionConfigOptions{DomainAliases: &zeroValue}
	s.GetDomainAliases()
	s = &SelfServiceProfileTicketConnectionConfigOptions{}
	s.GetDomainAliases()
	s = nil
	s.GetDomainAliases()
}

func TestSelfServiceProfileTicketConnectionConfigOptions_GetIconURL(tt *testing.T) {
	var zeroValue string
	s := &SelfServiceProfileTicketConnectionConfigOptions{IconURL: &zeroValue}
	s.GetIconURL()
	s = &SelfServiceProfileTicketConnectionConfigOptions{}
	s.GetIconURL()
	s = nil
	s.GetIconURL()
}

func TestSelfServiceProfileTicketConnectionConfigOptions_GetIDPInitiated(tt *testing.T) {
	s := &SelfServiceProfileTicketConnectionConfigOptions{}
	s.GetIDPInitiated()
	s = nil
	s.GetIDPInitiated()
}

func TestSelfServiceProfileTicketConnectionConfigOptions_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &SelfServiceProfileTicketConnectionConfigOptions{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestSelfServiceProfileTicketConnectionConfigOptionsIDPInitiated_GetClientAuthorizeQuery(tt *testing.T) {
	var zeroValue string
	s := &SelfServiceProfileTicketConnectionConfigOptionsIDPInitiated{ClientAuthorizeQuery: &zeroValue}
	s.GetClientAuthorizeQuery()
	s = &SelfServiceProfileTicketConnectionConfigOptionsIDPInitiated{}
	s.GetClientAuthorizeQuery()
	s = nil
	s.GetClientAuthorizeQuery()
}

func TestSelfServiceProfileTicketConnectionConfigOptionsIDPInitiated_GetClientID(tt *testing.T) {
	var zeroValue string
	s := &SelfServiceProfileTicketConnectionConfigOptionsIDPInitiated{ClientID: &zeroValue}
	s.GetClientID()
	s = &SelfServiceProfileTicketConnectionConfigOptionsIDPInitiated{}
	s.GetClientID()
	s = nil
	s.GetClientID()
}

func TestSelfServiceProfileTicketConnectionConfigOptionsIDPInitiated_GetClientProtocol(tt *testing.T) {
	var zeroValue string
	s := &SelfServiceProfileTicketConnectionConfigOptionsIDPInitiated{ClientProtocol: &zeroValue}
	s.GetClientProtocol()
	s = &SelfServiceProfileTicketConnectionConfigOptionsIDPInitiated{}
	s.GetClientProtocol()
	s = nil
	s.GetClientProtocol()
}

func TestSelfServiceProfileTicketConnectionConfigOptionsIDPInitiated_GetEnabled(tt *testing.T) {
	var zeroValue bool
	s := &SelfServiceProfileTicketConnectionConfigOptionsIDPInitiated{Enabled: &zeroValue}
	s.GetEnabled()
	s = &SelfServiceProfileTicketConnectionConfigOptionsIDPInitiated{}
	s.GetEnabled()
	s = nil
	s.GetEnabled()
}

func TestSelfServiceProfileTicketConnectionConfigOptionsIDPInitiated_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &SelfServiceProfileTicketConnectionConfigOptionsIDPInitiated{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestSelfServiceProfileTicketDomainAliasesConfig_GetDomainVerification(tt *testing.T) {
	var zeroValue string
	s := &SelfServiceProfileTicketDomainAliasesConfig{DomainVerification: &zeroValue}
	s.GetDomainVerification()
	s = &SelfServiceProfileTicketDomainAliasesConfig{}
	s.GetDomainVerification()
	s = nil
	s.GetDomainVerification()
}

func TestSelfServiceProfileTicketDomainAliasesConfig_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &SelfServiceProfileTicketDomainAliasesConfig{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestSelfServiceProfileTicketEnabledOrganizations_GetAssignMembershipOnLogin(tt *testing.T) {
	var zeroValue bool
	s := &SelfServiceProfileTicketEnabledOrganizations{AssignMembershipOnLogin: &zeroValue}
	s.GetAssignMembershipOnLogin()
	s = &SelfServiceProfileTicketEnabledOrganizations{}
	s.GetAssignMembershipOnLogin()
	s = nil
	s.GetAssignMembershipOnLogin()
}

func TestSelfServiceProfileTicketEnabledOrganizations_GetOrganizationID(tt *testing.T) {
	var zeroValue string
	s := &SelfServiceProfileTicketEnabledOrganizations{OrganizationID: &zeroValue}
	s.GetOrganizationID()
	s = &SelfServiceProfileTicketEnabledOrganizations{}
	s.GetOrganizationID()
	s = nil
	s.GetOrganizationID()
}

func TestSelfServiceProfileTicketEnabledOrganizations_GetShowAsButton(tt *testing.T) {
	var zeroValue bool
	s := &SelfServiceProfileTicketEnabledOrganizations{ShowAsButton: &zeroValue}
	s.GetShowAsButton()
	s = &SelfServiceProfileTicketEnabledOrganizations{}
	s.GetShowAsButton()
	s = nil
	s.GetShowAsButton()
}

func TestSelfServiceProfileTicketEnabledOrganizations_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &SelfServiceProfileTicketEnabledOrganizations{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestSelfServiceProfileUserAttributes_GetDescription(tt *testing.T) {
	var zeroValue string
	s := &SelfServiceProfileUserAttributes{Description: &zeroValue}
	s.GetDescription()
	s = &SelfServiceProfileUserAttributes{}
	s.GetDescription()
	s = nil
	s.GetDescription()
}

func TestSelfServiceProfileUserAttributes_GetIsOptional(tt *testing.T) {
	var zeroValue bool
	s := &SelfServiceProfileUserAttributes{IsOptional: &zeroValue}
	s.GetIsOptional()
	s = &SelfServiceProfileUserAttributes{}
	s.GetIsOptional()
	s = nil
	s.GetIsOptional()
}

func TestSelfServiceProfileUserAttributes_GetName(tt *testing.T) {
	var zeroValue string
	s := &SelfServiceProfileUserAttributes{Name: &zeroValue}
	s.GetName()
	s = &SelfServiceProfileUserAttributes{}
	s.GetName()
	s = nil
	s.GetName()
}

func TestSelfServiceProfileUserAttributes_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &SelfServiceProfileUserAttributes{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestSelfSignedTLSClientAuth_GetCredentials(tt *testing.T) {
	var zeroValue []Credential
	s := &SelfSignedTLSClientAuth{Credentials: &zeroValue}
	s.GetCredentials()
	s = &SelfSignedTLSClientAuth{}
	s.GetCredentials()
	s = nil
	s.GetCredentials()
}

func TestSelfSignedTLSClientAuth_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &SelfSignedTLSClientAuth{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestSentryClientAddon_GetBaseURL(tt *testing.T) {
	var zeroValue string
	s := &SentryClientAddon{BaseURL: &zeroValue}
	s.GetBaseURL()
	s = &SentryClientAddon{}
	s.GetBaseURL()
	s = nil
	s.GetBaseURL()
}

func TestSentryClientAddon_GetOrgSlug(tt *testing.T) {
	var zeroValue string
	s := &SentryClientAddon{OrgSlug: &zeroValue}
	s.GetOrgSlug()
	s = &SentryClientAddon{}
	s.GetOrgSlug()
	s = nil
	s.GetOrgSlug()
}

func TestSentryClientAddon_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &SentryClientAddon{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestSession_GetAuthenticatedAt(tt *testing.T) {
	var zeroValue string
	s := &Session{AuthenticatedAt: &zeroValue}
	s.GetAuthenticatedAt()
	s = &Session{}
	s.GetAuthenticatedAt()
	s = nil
	s.GetAuthenticatedAt()
}

func TestSession_GetAuthentication(tt *testing.T) {
	s := &Session{}
	s.GetAuthentication()
	s = nil
	s.GetAuthentication()
}

func TestSession_GetCreatedAt(tt *testing.T) {
	var zeroValue string
	s := &Session{CreatedAt: &zeroValue}
	s.GetCreatedAt()
	s = &Session{}
	s.GetCreatedAt()
	s = nil
	s.GetCreatedAt()
}

func TestSession_GetDevice(tt *testing.T) {
	s := &Session{}
	s.GetDevice()
	s = nil
	s.GetDevice()
}

func TestSession_GetExpiresAt(tt *testing.T) {
	var zeroValue string
	s := &Session{ExpiresAt: &zeroValue}
	s.GetExpiresAt()
	s = &Session{}
	s.GetExpiresAt()
	s = nil
	s.GetExpiresAt()
}

func TestSession_GetID(tt *testing.T) {
	var zeroValue string
	s := &Session{ID: &zeroValue}
	s.GetID()
	s = &Session{}
	s.GetID()
	s = nil
	s.GetID()
}

func TestSession_GetIdleExpiresAt(tt *testing.T) {
	var zeroValue string
	s := &Session{IdleExpiresAt: &zeroValue}
	s.GetIdleExpiresAt()
	s = &Session{}
	s.GetIdleExpiresAt()
	s = nil
	s.GetIdleExpiresAt()
}

func TestSession_GetLastInteractedAt(tt *testing.T) {
	var zeroValue string
	s := &Session{LastInteractedAt: &zeroValue}
	s.GetLastInteractedAt()
	s = &Session{}
	s.GetLastInteractedAt()
	s = nil
	s.GetLastInteractedAt()
}

func TestSession_GetUpdatedAt(tt *testing.T) {
	var zeroValue string
	s := &Session{UpdatedAt: &zeroValue}
	s.GetUpdatedAt()
	s = &Session{}
	s.GetUpdatedAt()
	s = nil
	s.GetUpdatedAt()
}

func TestSession_GetUserID(tt *testing.T) {
	var zeroValue string
	s := &Session{UserID: &zeroValue}
	s.GetUserID()
	s = &Session{}
	s.GetUserID()
	s = nil
	s.GetUserID()
}

func TestSession_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &Session{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestSessionAuthentication_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &SessionAuthentication{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestSessionAuthenticationMethod_GetName(tt *testing.T) {
	var zeroValue string
	s := &SessionAuthenticationMethod{Name: &zeroValue}
	s.GetName()
	s = &SessionAuthenticationMethod{}
	s.GetName()
	s = nil
	s.GetName()
}

func TestSessionAuthenticationMethod_GetTimestamp(tt *testing.T) {
	var zeroValue string
	s := &SessionAuthenticationMethod{Timestamp: &zeroValue}
	s.GetTimestamp()
	s = &SessionAuthenticationMethod{}
	s.GetTimestamp()
	s = nil
	s.GetTimestamp()
}

func TestSessionAuthenticationMethod_GetType(tt *testing.T) {
	var zeroValue string
	s := &SessionAuthenticationMethod{Type: &zeroValue}
	s.GetType()
	s = &SessionAuthenticationMethod{}
	s.GetType()
	s = nil
	s.GetType()
}

func TestSessionAuthenticationMethod_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &SessionAuthenticationMethod{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestSessionClient_GetClientID(tt *testing.T) {
	var zeroValue string
	s := &SessionClient{ClientID: &zeroValue}
	s.GetClientID()
	s = &SessionClient{}
	s.GetClientID()
	s = nil
	s.GetClientID()
}

func TestSessionClient_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &SessionClient{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestSessionDevice_GetInitialASN(tt *testing.T) {
	var zeroValue string
	s := &SessionDevice{InitialASN: &zeroValue}
	s.GetInitialASN()
	s = &SessionDevice{}
	s.GetInitialASN()
	s = nil
	s.GetInitialASN()
}

func TestSessionDevice_GetInitialIP(tt *testing.T) {
	var zeroValue string
	s := &SessionDevice{InitialIP: &zeroValue}
	s.GetInitialIP()
	s = &SessionDevice{}
	s.GetInitialIP()
	s = nil
	s.GetInitialIP()
}

func TestSessionDevice_GetInitialUserAgent(tt *testing.T) {
	var zeroValue string
	s := &SessionDevice{InitialUserAgent: &zeroValue}
	s.GetInitialUserAgent()
	s = &SessionDevice{}
	s.GetInitialUserAgent()
	s = nil
	s.GetInitialUserAgent()
}

func TestSessionDevice_GetLastASN(tt *testing.T) {
	var zeroValue string
	s := &SessionDevice{LastASN: &zeroValue}
	s.GetLastASN()
	s = &SessionDevice{}
	s.GetLastASN()
	s = nil
	s.GetLastASN()
}

func TestSessionDevice_GetLastIP(tt *testing.T) {
	var zeroValue string
	s := &SessionDevice{LastIP: &zeroValue}
	s.GetLastIP()
	s = &SessionDevice{}
	s.GetLastIP()
	s = nil
	s.GetLastIP()
}

func TestSessionDevice_GetLastUserAgent(tt *testing.T) {
	var zeroValue string
	s := &SessionDevice{LastUserAgent: &zeroValue}
	s.GetLastUserAgent()
	s = &SessionDevice{}
	s.GetLastUserAgent()
	s = nil
	s.GetLastUserAgent()
}

func TestSessionDevice_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &SessionDevice{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestSharePointClientAddon_GetExternalURL(tt *testing.T) {
	var zeroValue []string
	s := &SharePointClientAddon{ExternalURL: &zeroValue}
	s.GetExternalURL()
	s = &SharePointClientAddon{}
	s.GetExternalURL()
	s = nil
	s.GetExternalURL()
}

func TestSharePointClientAddon_GetURL(tt *testing.T) {
	var zeroValue string
	s := &SharePointClientAddon{URL: &zeroValue}
	s.GetURL()
	s = &SharePointClientAddon{}
	s.GetURL()
	s = nil
	s.GetURL()
}

func TestSharePointClientAddon_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &SharePointClientAddon{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestSigningKey_GetCert(tt *testing.T) {
	var zeroValue string
	s := &SigningKey{Cert: &zeroValue}
	s.GetCert()
	s = &SigningKey{}
	s.GetCert()
	s = nil
	s.GetCert()
}

func TestSigningKey_GetCurrent(tt *testing.T) {
	var zeroValue bool
	s := &SigningKey{Current: &zeroValue}
	s.GetCurrent()
	s = &SigningKey{}
	s.GetCurrent()
	s = nil
	s.GetCurrent()
}

func TestSigningKey_GetCurrentSince(tt *testing.T) {
	var zeroValue time.Time
	s := &SigningKey{CurrentSince: &zeroValue}
	s.GetCurrentSince()
	s = &SigningKey{}
	s.GetCurrentSince()
	s = nil
	s.GetCurrentSince()
}

func TestSigningKey_GetCurrentUntil(tt *testing.T) {
	var zeroValue time.Time
	s := &SigningKey{CurrentUntil: &zeroValue}
	s.GetCurrentUntil()
	s = &SigningKey{}
	s.GetCurrentUntil()
	s = nil
	s.GetCurrentUntil()
}

func TestSigningKey_GetFingerprint(tt *testing.T) {
	var zeroValue string
	s := &SigningKey{Fingerprint: &zeroValue}
	s.GetFingerprint()
	s = &SigningKey{}
	s.GetFingerprint()
	s = nil
	s.GetFingerprint()
}

func TestSigningKey_GetKID(tt *testing.T) {
	var zeroValue string
	s := &SigningKey{KID: &zeroValue}
	s.GetKID()
	s = &SigningKey{}
	s.GetKID()
	s = nil
	s.GetKID()
}

func TestSigningKey_GetNext(tt *testing.T) {
	var zeroValue bool
	s := &SigningKey{Next: &zeroValue}
	s.GetNext()
	s = &SigningKey{}
	s.GetNext()
	s = nil
	s.GetNext()
}

func TestSigningKey_GetPKCS7(tt *testing.T) {
	var zeroValue string
	s := &SigningKey{PKCS7: &zeroValue}
	s.GetPKCS7()
	s = &SigningKey{}
	s.GetPKCS7()
	s = nil
	s.GetPKCS7()
}

func TestSigningKey_GetPrevious(tt *testing.T) {
	var zeroValue bool
	s := &SigningKey{Previous: &zeroValue}
	s.GetPrevious()
	s = &SigningKey{}
	s.GetPrevious()
	s = nil
	s.GetPrevious()
}

func TestSigningKey_GetRevoked(tt *testing.T) {
	var zeroValue bool
	s := &SigningKey{Revoked: &zeroValue}
	s.GetRevoked()
	s = &SigningKey{}
	s.GetRevoked()
	s = nil
	s.GetRevoked()
}

func TestSigningKey_GetRevokedAt(tt *testing.T) {
	var zeroValue time.Time
	s := &SigningKey{RevokedAt: &zeroValue}
	s.GetRevokedAt()
	s = &SigningKey{}
	s.GetRevokedAt()
	s = nil
	s.GetRevokedAt()
}

func TestSigningKey_GetThumbprint(tt *testing.T) {
	var zeroValue string
	s := &SigningKey{Thumbprint: &zeroValue}
	s.GetThumbprint()
	s = &SigningKey{}
	s.GetThumbprint()
	s = nil
	s.GetThumbprint()
}

func TestSigningKey_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &SigningKey{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestSlackClientAddon_GetTeam(tt *testing.T) {
	var zeroValue string
	s := &SlackClientAddon{Team: &zeroValue}
	s.GetTeam()
	s = &SlackClientAddon{}
	s.GetTeam()
	s = nil
	s.GetTeam()
}

func TestSlackClientAddon_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &SlackClientAddon{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestSpringCMClientAddon_GetACSURL(tt *testing.T) {
	var zeroValue string
	s := &SpringCMClientAddon{ACSURL: &zeroValue}
	s.GetACSURL()
	s = &SpringCMClientAddon{}
	s.GetACSURL()
	s = nil
	s.GetACSURL()
}

func TestSpringCMClientAddon_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &SpringCMClientAddon{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestSSOIntegrationClientAddon_GetName(tt *testing.T) {
	var zeroValue string
	s := &SSOIntegrationClientAddon{Name: &zeroValue}
	s.GetName()
	s = &SSOIntegrationClientAddon{}
	s.GetName()
	s = nil
	s.GetName()
}

func TestSSOIntegrationClientAddon_GetVersion(tt *testing.T) {
	var zeroValue string
	s := &SSOIntegrationClientAddon{Version: &zeroValue}
	s.GetVersion()
	s = &SSOIntegrationClientAddon{}
	s.GetVersion()
	s = nil
	s.GetVersion()
}

func TestSSOIntegrationClientAddon_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &SSOIntegrationClientAddon{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestStage_GetPreLogin(tt *testing.T) {
	s := &Stage{}
	s.GetPreLogin()
	s = nil
	s.GetPreLogin()
}

func TestStage_GetPreUserRegistration(tt *testing.T) {
	s := &Stage{}
	s.GetPreUserRegistration()
	s = nil
	s.GetPreUserRegistration()
}

func TestStage_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &Stage{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestSuspiciousIPThrottling_GetAllowList(tt *testing.T) {
	var zeroValue []string
	s := &SuspiciousIPThrottling{AllowList: &zeroValue}
	s.GetAllowList()
	s = &SuspiciousIPThrottling{}
	s.GetAllowList()
	s = nil
	s.GetAllowList()
}

func TestSuspiciousIPThrottling_GetEnabled(tt *testing.T) {
	var zeroValue bool
	s := &SuspiciousIPThrottling{Enabled: &zeroValue}
	s.GetEnabled()
	s = &SuspiciousIPThrottling{}
	s.GetEnabled()
	s = nil
	s.GetEnabled()
}

func TestSuspiciousIPThrottling_GetShields(tt *testing.T) {
	var zeroValue []string
	s := &SuspiciousIPThrottling{Shields: &zeroValue}
	s.GetShields()
	s = &SuspiciousIPThrottling{}
	s.GetShields()
	s = nil
	s.GetShields()
}

func TestSuspiciousIPThrottling_GetStage(tt *testing.T) {
	s := &SuspiciousIPThrottling{}
	s.GetStage()
	s = nil
	s.GetStage()
}

func TestSuspiciousIPThrottling_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &SuspiciousIPThrottling{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestTenant_GetACRValuesSupported(tt *testing.T) {
	var zeroValue []string
	t := &Tenant{ACRValuesSupported: &zeroValue}
	t.GetACRValuesSupported()
	t = &Tenant{}
	t.GetACRValuesSupported()
	t = nil
	t.GetACRValuesSupported()
}

func TestTenant_GetAllowedLogoutURLs(tt *testing.T) {
	var zeroValue []string
	t := &Tenant{AllowedLogoutURLs: &zeroValue}
	t.GetAllowedLogoutURLs()
	t = &Tenant{}
	t.GetAllowedLogoutURLs()
	t = nil
	t.GetAllowedLogoutURLs()
}

func TestTenant_GetAllowOrgNameInAuthAPI(tt *testing.T) {
	var zeroValue bool
	t := &Tenant{AllowOrgNameInAuthAPI: &zeroValue}
	t.GetAllowOrgNameInAuthAPI()
	t = &Tenant{}
	t.GetAllowOrgNameInAuthAPI()
	t = nil
	t.GetAllowOrgNameInAuthAPI()
}

func TestTenant_GetChangePassword(tt *testing.T) {
	t := &Tenant{}
	t.GetChangePassword()
	t = nil
	t.GetChangePassword()
}

func TestTenant_GetCustomizeMFAInPostLoginAction(tt *testing.T) {
	var zeroValue bool
	t := &Tenant{CustomizeMFAInPostLoginAction: &zeroValue}
	t.GetCustomizeMFAInPostLoginAction()
	t = &Tenant{}
	t.GetCustomizeMFAInPostLoginAction()
	t = nil
	t.GetCustomizeMFAInPostLoginAction()
}

func TestTenant_GetDefaultAudience(tt *testing.T) {
	var zeroValue string
	t := &Tenant{DefaultAudience: &zeroValue}
	t.GetDefaultAudience()
	t = &Tenant{}
	t.GetDefaultAudience()
	t = nil
	t.GetDefaultAudience()
}

func TestTenant_GetDefaultDirectory(tt *testing.T) {
	var zeroValue string
	t := &Tenant{DefaultDirectory: &zeroValue}
	t.GetDefaultDirectory()
	t = &Tenant{}
	t.GetDefaultDirectory()
	t = nil
	t.GetDefaultDirectory()
}

func TestTenant_GetDefaultRedirectionURI(tt *testing.T) {
	var zeroValue string
	t := &Tenant{DefaultRedirectionURI: &zeroValue}
	t.GetDefaultRedirectionURI()
	t = &Tenant{}
	t.GetDefaultRedirectionURI()
	t = nil
	t.GetDefaultRedirectionURI()
}

func TestTenant_GetDeviceFlow(tt *testing.T) {
	t := &Tenant{}
	t.GetDeviceFlow()
	t = nil
	t.GetDeviceFlow()
}

func TestTenant_GetEnabledLocales(tt *testing.T) {
	var zeroValue []string
	t := &Tenant{EnabledLocales: &zeroValue}
	t.GetEnabledLocales()
	t = &Tenant{}
	t.GetEnabledLocales()
	t = nil
	t.GetEnabledLocales()
}

func TestTenant_GetErrorPage(tt *testing.T) {
	t := &Tenant{}
	t.GetErrorPage()
	t = nil
	t.GetErrorPage()
}

func TestTenant_GetFlags(tt *testing.T) {
	t := &Tenant{}
	t.GetFlags()
	t = nil
	t.GetFlags()
}

func TestTenant_GetFriendlyName(tt *testing.T) {
	var zeroValue string
	t := &Tenant{FriendlyName: &zeroValue}
	t.GetFriendlyName()
	t = &Tenant{}
	t.GetFriendlyName()
	t = nil
	t.GetFriendlyName()
}

func TestTenant_GetGuardianMFAPage(tt *testing.T) {
	t := &Tenant{}
	t.GetGuardianMFAPage()
	t = nil
	t.GetGuardianMFAPage()
}

func TestTenant_GetIdleSessionLifetime(tt *testing.T) {
	var zeroValue float64
	t := &Tenant{IdleSessionLifetime: &zeroValue}
	t.GetIdleSessionLifetime()
	t = &Tenant{}
	t.GetIdleSessionLifetime()
	t = nil
	t.GetIdleSessionLifetime()
}

func TestTenant_GetMTLS(tt *testing.T) {
	t := &Tenant{}
	t.GetMTLS()
	t = nil
	t.GetMTLS()
}

func TestTenant_GetOIDCLogout(tt *testing.T) {
	t := &Tenant{}
	t.GetOIDCLogout()
	t = nil
	t.GetOIDCLogout()
}

func TestTenant_GetPictureURL(tt *testing.T) {
	var zeroValue string
	t := &Tenant{PictureURL: &zeroValue}
	t.GetPictureURL()
	t = &Tenant{}
	t.GetPictureURL()
	t = nil
	t.GetPictureURL()
}

func TestTenant_GetPushedAuthorizationRequestsSupported(tt *testing.T) {
	var zeroValue bool
	t := &Tenant{PushedAuthorizationRequestsSupported: &zeroValue}
	t.GetPushedAuthorizationRequestsSupported()
	t = &Tenant{}
	t.GetPushedAuthorizationRequestsSupported()
	t = nil
	t.GetPushedAuthorizationRequestsSupported()
}

func TestTenant_GetSandboxVersion(tt *testing.T) {
	var zeroValue string
	t := &Tenant{SandboxVersion: &zeroValue}
	t.GetSandboxVersion()
	t = &Tenant{}
	t.GetSandboxVersion()
	t = nil
	t.GetSandboxVersion()
}

func TestTenant_GetSandboxVersionAvailable(tt *testing.T) {
	var zeroValue []string
	t := &Tenant{SandboxVersionAvailable: &zeroValue}
	t.GetSandboxVersionAvailable()
	t = &Tenant{}
	t.GetSandboxVersionAvailable()
	t = nil
	t.GetSandboxVersionAvailable()
}

func TestTenant_GetSessionCookie(tt *testing.T) {
	t := &Tenant{}
	t.GetSessionCookie()
	t = nil
	t.GetSessionCookie()
}

func TestTenant_GetSessionLifetime(tt *testing.T) {
	var zeroValue float64
	t := &Tenant{SessionLifetime: &zeroValue}
	t.GetSessionLifetime()
	t = &Tenant{}
	t.GetSessionLifetime()
	t = nil
	t.GetSessionLifetime()
}

func TestTenant_GetSessions(tt *testing.T) {
	t := &Tenant{}
	t.GetSessions()
	t = nil
	t.GetSessions()
}

func TestTenant_GetSupportEmail(tt *testing.T) {
	var zeroValue string
	t := &Tenant{SupportEmail: &zeroValue}
	t.GetSupportEmail()
	t = &Tenant{}
	t.GetSupportEmail()
	t = nil
	t.GetSupportEmail()
}

func TestTenant_GetSupportURL(tt *testing.T) {
	var zeroValue string
	t := &Tenant{SupportURL: &zeroValue}
	t.GetSupportURL()
	t = &Tenant{}
	t.GetSupportURL()
	t = nil
	t.GetSupportURL()
}

func TestTenant_GetUniversalLogin(tt *testing.T) {
	t := &Tenant{}
	t.GetUniversalLogin()
	t = nil
	t.GetUniversalLogin()
}

func TestTenant_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &Tenant{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestTenantChangePassword_GetEnabled(tt *testing.T) {
	var zeroValue bool
	t := &TenantChangePassword{Enabled: &zeroValue}
	t.GetEnabled()
	t = &TenantChangePassword{}
	t.GetEnabled()
	t = nil
	t.GetEnabled()
}

func TestTenantChangePassword_GetHTML(tt *testing.T) {
	var zeroValue string
	t := &TenantChangePassword{HTML: &zeroValue}
	t.GetHTML()
	t = &TenantChangePassword{}
	t.GetHTML()
	t = nil
	t.GetHTML()
}

func TestTenantChangePassword_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &TenantChangePassword{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestTenantDeviceFlow_GetCharset(tt *testing.T) {
	var zeroValue string
	t := &TenantDeviceFlow{Charset: &zeroValue}
	t.GetCharset()
	t = &TenantDeviceFlow{}
	t.GetCharset()
	t = nil
	t.GetCharset()
}

func TestTenantDeviceFlow_GetMask(tt *testing.T) {
	var zeroValue string
	t := &TenantDeviceFlow{Mask: &zeroValue}
	t.GetMask()
	t = &TenantDeviceFlow{}
	t.GetMask()
	t = nil
	t.GetMask()
}

func TestTenantDeviceFlow_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &TenantDeviceFlow{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestTenantErrorPage_GetHTML(tt *testing.T) {
	var zeroValue string
	t := &TenantErrorPage{HTML: &zeroValue}
	t.GetHTML()
	t = &TenantErrorPage{}
	t.GetHTML()
	t = nil
	t.GetHTML()
}

func TestTenantErrorPage_GetShowLogLink(tt *testing.T) {
	var zeroValue bool
	t := &TenantErrorPage{ShowLogLink: &zeroValue}
	t.GetShowLogLink()
	t = &TenantErrorPage{}
	t.GetShowLogLink()
	t = nil
	t.GetShowLogLink()
}

func TestTenantErrorPage_GetURL(tt *testing.T) {
	var zeroValue string
	t := &TenantErrorPage{URL: &zeroValue}
	t.GetURL()
	t = &TenantErrorPage{}
	t.GetURL()
	t = nil
	t.GetURL()
}

func TestTenantErrorPage_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &TenantErrorPage{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestTenantFlags_GetAllowChangingEnableSSO(tt *testing.T) {
	var zeroValue bool
	t := &TenantFlags{AllowChangingEnableSSO: &zeroValue}
	t.GetAllowChangingEnableSSO()
	t = &TenantFlags{}
	t.GetAllowChangingEnableSSO()
	t = nil
	t.GetAllowChangingEnableSSO()
}

func TestTenantFlags_GetAllowLegacyDelegationGrantTypes(tt *testing.T) {
	var zeroValue bool
	t := &TenantFlags{AllowLegacyDelegationGrantTypes: &zeroValue}
	t.GetAllowLegacyDelegationGrantTypes()
	t = &TenantFlags{}
	t.GetAllowLegacyDelegationGrantTypes()
	t = nil
	t.GetAllowLegacyDelegationGrantTypes()
}

func TestTenantFlags_GetAllowLegacyROGrantTypes(tt *testing.T) {
	var zeroValue bool
	t := &TenantFlags{AllowLegacyROGrantTypes: &zeroValue}
	t.GetAllowLegacyROGrantTypes()
	t = &TenantFlags{}
	t.GetAllowLegacyROGrantTypes()
	t = nil
	t.GetAllowLegacyROGrantTypes()
}

func TestTenantFlags_GetAllowLegacyTokenInfoEndpoint(tt *testing.T) {
	var zeroValue bool
	t := &TenantFlags{AllowLegacyTokenInfoEndpoint: &zeroValue}
	t.GetAllowLegacyTokenInfoEndpoint()
	t = &TenantFlags{}
	t.GetAllowLegacyTokenInfoEndpoint()
	t = nil
	t.GetAllowLegacyTokenInfoEndpoint()
}

func TestTenantFlags_GetDashboardInsightsView(tt *testing.T) {
	var zeroValue bool
	t := &TenantFlags{DashboardInsightsView: &zeroValue}
	t.GetDashboardInsightsView()
	t = &TenantFlags{}
	t.GetDashboardInsightsView()
	t = nil
	t.GetDashboardInsightsView()
}

func TestTenantFlags_GetDashboardLogStreams(tt *testing.T) {
	var zeroValue bool
	t := &TenantFlags{DashboardLogStreams: &zeroValue}
	t.GetDashboardLogStreams()
	t = &TenantFlags{}
	t.GetDashboardLogStreams()
	t = nil
	t.GetDashboardLogStreams()
}

func TestTenantFlags_GetDisableClickjackProtectionHeaders(tt *testing.T) {
	var zeroValue bool
	t := &TenantFlags{DisableClickjackProtectionHeaders: &zeroValue}
	t.GetDisableClickjackProtectionHeaders()
	t = &TenantFlags{}
	t.GetDisableClickjackProtectionHeaders()
	t = nil
	t.GetDisableClickjackProtectionHeaders()
}

func TestTenantFlags_GetDisableFieldsMapFix(tt *testing.T) {
	var zeroValue bool
	t := &TenantFlags{DisableFieldsMapFix: &zeroValue}
	t.GetDisableFieldsMapFix()
	t = &TenantFlags{}
	t.GetDisableFieldsMapFix()
	t = nil
	t.GetDisableFieldsMapFix()
}

func TestTenantFlags_GetDisableImpersonation(tt *testing.T) {
	var zeroValue bool
	t := &TenantFlags{DisableImpersonation: &zeroValue}
	t.GetDisableImpersonation()
	t = &TenantFlags{}
	t.GetDisableImpersonation()
	t = nil
	t.GetDisableImpersonation()
}

func TestTenantFlags_GetDisableManagementAPISMSObfuscation(tt *testing.T) {
	var zeroValue bool
	t := &TenantFlags{DisableManagementAPISMSObfuscation: &zeroValue}
	t.GetDisableManagementAPISMSObfuscation()
	t = &TenantFlags{}
	t.GetDisableManagementAPISMSObfuscation()
	t = nil
	t.GetDisableManagementAPISMSObfuscation()
}

func TestTenantFlags_GetEnableADFSWAADEmailVerification(tt *testing.T) {
	var zeroValue bool
	t := &TenantFlags{EnableADFSWAADEmailVerification: &zeroValue}
	t.GetEnableADFSWAADEmailVerification()
	t = &TenantFlags{}
	t.GetEnableADFSWAADEmailVerification()
	t = nil
	t.GetEnableADFSWAADEmailVerification()
}

func TestTenantFlags_GetEnableAPIsSection(tt *testing.T) {
	var zeroValue bool
	t := &TenantFlags{EnableAPIsSection: &zeroValue}
	t.GetEnableAPIsSection()
	t = &TenantFlags{}
	t.GetEnableAPIsSection()
	t = nil
	t.GetEnableAPIsSection()
}

func TestTenantFlags_GetEnableClientConnections(tt *testing.T) {
	var zeroValue bool
	t := &TenantFlags{EnableClientConnections: &zeroValue}
	t.GetEnableClientConnections()
	t = &TenantFlags{}
	t.GetEnableClientConnections()
	t = nil
	t.GetEnableClientConnections()
}

func TestTenantFlags_GetEnableCustomDomainInEmails(tt *testing.T) {
	var zeroValue bool
	t := &TenantFlags{EnableCustomDomainInEmails: &zeroValue}
	t.GetEnableCustomDomainInEmails()
	t = &TenantFlags{}
	t.GetEnableCustomDomainInEmails()
	t = nil
	t.GetEnableCustomDomainInEmails()
}

func TestTenantFlags_GetEnableDynamicClientRegistration(tt *testing.T) {
	var zeroValue bool
	t := &TenantFlags{EnableDynamicClientRegistration: &zeroValue}
	t.GetEnableDynamicClientRegistration()
	t = &TenantFlags{}
	t.GetEnableDynamicClientRegistration()
	t = nil
	t.GetEnableDynamicClientRegistration()
}

func TestTenantFlags_GetEnableIDTokenAPI2(tt *testing.T) {
	var zeroValue bool
	t := &TenantFlags{EnableIDTokenAPI2: &zeroValue}
	t.GetEnableIDTokenAPI2()
	t = &TenantFlags{}
	t.GetEnableIDTokenAPI2()
	t = nil
	t.GetEnableIDTokenAPI2()
}

func TestTenantFlags_GetEnableLegacyLogsSearchV2(tt *testing.T) {
	var zeroValue bool
	t := &TenantFlags{EnableLegacyLogsSearchV2: &zeroValue}
	t.GetEnableLegacyLogsSearchV2()
	t = &TenantFlags{}
	t.GetEnableLegacyLogsSearchV2()
	t = nil
	t.GetEnableLegacyLogsSearchV2()
}

func TestTenantFlags_GetEnableLegacyProfile(tt *testing.T) {
	var zeroValue bool
	t := &TenantFlags{EnableLegacyProfile: &zeroValue}
	t.GetEnableLegacyProfile()
	t = &TenantFlags{}
	t.GetEnableLegacyProfile()
	t = nil
	t.GetEnableLegacyProfile()
}

func TestTenantFlags_GetEnablePipeline2(tt *testing.T) {
	var zeroValue bool
	t := &TenantFlags{EnablePipeline2: &zeroValue}
	t.GetEnablePipeline2()
	t = &TenantFlags{}
	t.GetEnablePipeline2()
	t = nil
	t.GetEnablePipeline2()
}

func TestTenantFlags_GetEnablePublicSignupUserExistsError(tt *testing.T) {
	var zeroValue bool
	t := &TenantFlags{EnablePublicSignupUserExistsError: &zeroValue}
	t.GetEnablePublicSignupUserExistsError()
	t = &TenantFlags{}
	t.GetEnablePublicSignupUserExistsError()
	t = nil
	t.GetEnablePublicSignupUserExistsError()
}

func TestTenantFlags_GetEnableSSO(tt *testing.T) {
	var zeroValue bool
	t := &TenantFlags{EnableSSO: &zeroValue}
	t.GetEnableSSO()
	t = &TenantFlags{}
	t.GetEnableSSO()
	t = nil
	t.GetEnableSSO()
}

func TestTenantFlags_GetMFAShowFactorListOnEnrollment(tt *testing.T) {
	var zeroValue bool
	t := &TenantFlags{MFAShowFactorListOnEnrollment: &zeroValue}
	t.GetMFAShowFactorListOnEnrollment()
	t = &TenantFlags{}
	t.GetMFAShowFactorListOnEnrollment()
	t = nil
	t.GetMFAShowFactorListOnEnrollment()
}

func TestTenantFlags_GetNoDisclosureEnterpriseConnections(tt *testing.T) {
	var zeroValue bool
	t := &TenantFlags{NoDisclosureEnterpriseConnections: &zeroValue}
	t.GetNoDisclosureEnterpriseConnections()
	t = &TenantFlags{}
	t.GetNoDisclosureEnterpriseConnections()
	t = nil
	t.GetNoDisclosureEnterpriseConnections()
}

func TestTenantFlags_GetRemoveAlgFromJWKS(tt *testing.T) {
	var zeroValue bool
	t := &TenantFlags{RemoveAlgFromJWKS: &zeroValue}
	t.GetRemoveAlgFromJWKS()
	t = &TenantFlags{}
	t.GetRemoveAlgFromJWKS()
	t = nil
	t.GetRemoveAlgFromJWKS()
}

func TestTenantFlags_GetRequirePushedAuthorizationRequests(tt *testing.T) {
	var zeroValue bool
	t := &TenantFlags{RequirePushedAuthorizationRequests: &zeroValue}
	t.GetRequirePushedAuthorizationRequests()
	t = &TenantFlags{}
	t.GetRequirePushedAuthorizationRequests()
	t = nil
	t.GetRequirePushedAuthorizationRequests()
}

func TestTenantFlags_GetRevokeRefreshTokenGrant(tt *testing.T) {
	var zeroValue bool
	t := &TenantFlags{RevokeRefreshTokenGrant: &zeroValue}
	t.GetRevokeRefreshTokenGrant()
	t = &TenantFlags{}
	t.GetRevokeRefreshTokenGrant()
	t = nil
	t.GetRevokeRefreshTokenGrant()
}

func TestTenantFlags_GetUniversalLogin(tt *testing.T) {
	var zeroValue bool
	t := &TenantFlags{UniversalLogin: &zeroValue}
	t.GetUniversalLogin()
	t = &TenantFlags{}
	t.GetUniversalLogin()
	t = nil
	t.GetUniversalLogin()
}

func TestTenantFlags_GetUseScopeDescriptionsForConsent(tt *testing.T) {
	var zeroValue bool
	t := &TenantFlags{UseScopeDescriptionsForConsent: &zeroValue}
	t.GetUseScopeDescriptionsForConsent()
	t = &TenantFlags{}
	t.GetUseScopeDescriptionsForConsent()
	t = nil
	t.GetUseScopeDescriptionsForConsent()
}

func TestTenantFlags_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &TenantFlags{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestTenantGuardianMFAPage_GetEnabled(tt *testing.T) {
	var zeroValue bool
	t := &TenantGuardianMFAPage{Enabled: &zeroValue}
	t.GetEnabled()
	t = &TenantGuardianMFAPage{}
	t.GetEnabled()
	t = nil
	t.GetEnabled()
}

func TestTenantGuardianMFAPage_GetHTML(tt *testing.T) {
	var zeroValue string
	t := &TenantGuardianMFAPage{HTML: &zeroValue}
	t.GetHTML()
	t = &TenantGuardianMFAPage{}
	t.GetHTML()
	t = nil
	t.GetHTML()
}

func TestTenantGuardianMFAPage_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &TenantGuardianMFAPage{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestTenantMTLSConfiguration_GetEnableEndpointAliases(tt *testing.T) {
	var zeroValue bool
	t := &TenantMTLSConfiguration{EnableEndpointAliases: &zeroValue}
	t.GetEnableEndpointAliases()
	t = &TenantMTLSConfiguration{}
	t.GetEnableEndpointAliases()
	t = nil
	t.GetEnableEndpointAliases()
}

func TestTenantMTLSConfiguration_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &TenantMTLSConfiguration{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestTenantOIDCLogout_GetOIDCResourceProviderLogoutEndSessionEndpointDiscovery(tt *testing.T) {
	var zeroValue bool
	t := &TenantOIDCLogout{OIDCResourceProviderLogoutEndSessionEndpointDiscovery: &zeroValue}
	t.GetOIDCResourceProviderLogoutEndSessionEndpointDiscovery()
	t = &TenantOIDCLogout{}
	t.GetOIDCResourceProviderLogoutEndSessionEndpointDiscovery()
	t = nil
	t.GetOIDCResourceProviderLogoutEndSessionEndpointDiscovery()
}

func TestTenantOIDCLogout_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &TenantOIDCLogout{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestTenantSessionCookie_GetMode(tt *testing.T) {
	var zeroValue string
	t := &TenantSessionCookie{Mode: &zeroValue}
	t.GetMode()
	t = &TenantSessionCookie{}
	t.GetMode()
	t = nil
	t.GetMode()
}

func TestTenantSessionCookie_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &TenantSessionCookie{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestTenantSessions_GetOIDCLogoutPromptEnabled(tt *testing.T) {
	var zeroValue bool
	t := &TenantSessions{OIDCLogoutPromptEnabled: &zeroValue}
	t.GetOIDCLogoutPromptEnabled()
	t = &TenantSessions{}
	t.GetOIDCLogoutPromptEnabled()
	t = nil
	t.GetOIDCLogoutPromptEnabled()
}

func TestTenantSessions_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &TenantSessions{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestTenantUniversalLogin_GetColors(tt *testing.T) {
	t := &TenantUniversalLogin{}
	t.GetColors()
	t = nil
	t.GetColors()
}

func TestTenantUniversalLogin_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &TenantUniversalLogin{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestTenantUniversalLoginColors_GetPageBackground(tt *testing.T) {
	var zeroValue string
	t := &TenantUniversalLoginColors{PageBackground: &zeroValue}
	t.GetPageBackground()
	t = &TenantUniversalLoginColors{}
	t.GetPageBackground()
	t = nil
	t.GetPageBackground()
}

func TestTenantUniversalLoginColors_GetPageBackgroundGradient(tt *testing.T) {
	t := &TenantUniversalLoginColors{}
	t.GetPageBackgroundGradient()
	t = nil
	t.GetPageBackgroundGradient()
}

func TestTenantUniversalLoginColors_GetPrimary(tt *testing.T) {
	var zeroValue string
	t := &TenantUniversalLoginColors{Primary: &zeroValue}
	t.GetPrimary()
	t = &TenantUniversalLoginColors{}
	t.GetPrimary()
	t = nil
	t.GetPrimary()
}

func TestTenantUniversalLoginColors_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &TenantUniversalLoginColors{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestTicket_GetClientID(tt *testing.T) {
	var zeroValue string
	t := &Ticket{ClientID: &zeroValue}
	t.GetClientID()
	t = &Ticket{}
	t.GetClientID()
	t = nil
	t.GetClientID()
}

func TestTicket_GetConnectionID(tt *testing.T) {
	var zeroValue string
	t := &Ticket{ConnectionID: &zeroValue}
	t.GetConnectionID()
	t = &Ticket{}
	t.GetConnectionID()
	t = nil
	t.GetConnectionID()
}

func TestTicket_GetEmail(tt *testing.T) {
	var zeroValue string
	t := &Ticket{Email: &zeroValue}
	t.GetEmail()
	t = &Ticket{}
	t.GetEmail()
	t = nil
	t.GetEmail()
}

func TestTicket_GetIncludeEmailInRedirect(tt *testing.T) {
	var zeroValue bool
	t := &Ticket{IncludeEmailInRedirect: &zeroValue}
	t.GetIncludeEmailInRedirect()
	t = &Ticket{}
	t.GetIncludeEmailInRedirect()
	t = nil
	t.GetIncludeEmailInRedirect()
}

func TestTicket_GetMarkEmailAsVerified(tt *testing.T) {
	var zeroValue bool
	t := &Ticket{MarkEmailAsVerified: &zeroValue}
	t.GetMarkEmailAsVerified()
	t = &Ticket{}
	t.GetMarkEmailAsVerified()
	t = nil
	t.GetMarkEmailAsVerified()
}

func TestTicket_GetOrganizationID(tt *testing.T) {
	var zeroValue string
	t := &Ticket{OrganizationID: &zeroValue}
	t.GetOrganizationID()
	t = &Ticket{}
	t.GetOrganizationID()
	t = nil
	t.GetOrganizationID()
}

func TestTicket_GetResultURL(tt *testing.T) {
	var zeroValue string
	t := &Ticket{ResultURL: &zeroValue}
	t.GetResultURL()
	t = &Ticket{}
	t.GetResultURL()
	t = nil
	t.GetResultURL()
}

func TestTicket_GetTicket(tt *testing.T) {
	var zeroValue string
	t := &Ticket{Ticket: &zeroValue}
	t.GetTicket()
	t = &Ticket{}
	t.GetTicket()
	t = nil
	t.GetTicket()
}

func TestTicket_GetTTLSec(tt *testing.T) {
	var zeroValue int
	t := &Ticket{TTLSec: &zeroValue}
	t.GetTTLSec()
	t = &Ticket{}
	t.GetTTLSec()
	t = nil
	t.GetTTLSec()
}

func TestTicket_GetUserID(tt *testing.T) {
	var zeroValue string
	t := &Ticket{UserID: &zeroValue}
	t.GetUserID()
	t = &Ticket{}
	t.GetUserID()
	t = nil
	t.GetUserID()
}

func TestTicket_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &Ticket{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestTLSClientAuth_GetCredentials(tt *testing.T) {
	var zeroValue []Credential
	t := &TLSClientAuth{Credentials: &zeroValue}
	t.GetCredentials()
	t = &TLSClientAuth{}
	t.GetCredentials()
	t = nil
	t.GetCredentials()
}

func TestTLSClientAuth_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &TLSClientAuth{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestTokenExchangeProfile_GetActionID(tt *testing.T) {
	var zeroValue string
	t := &TokenExchangeProfile{ActionID: &zeroValue}
	t.GetActionID()
	t = &TokenExchangeProfile{}
	t.GetActionID()
	t = nil
	t.GetActionID()
}

func TestTokenExchangeProfile_GetCreatedAt(tt *testing.T) {
	var zeroValue time.Time
	t := &TokenExchangeProfile{CreatedAt: &zeroValue}
	t.GetCreatedAt()
	t = &TokenExchangeProfile{}
	t.GetCreatedAt()
	t = nil
	t.GetCreatedAt()
}

func TestTokenExchangeProfile_GetID(tt *testing.T) {
	var zeroValue string
	t := &TokenExchangeProfile{ID: &zeroValue}
	t.GetID()
	t = &TokenExchangeProfile{}
	t.GetID()
	t = nil
	t.GetID()
}

func TestTokenExchangeProfile_GetName(tt *testing.T) {
	var zeroValue string
	t := &TokenExchangeProfile{Name: &zeroValue}
	t.GetName()
	t = &TokenExchangeProfile{}
	t.GetName()
	t = nil
	t.GetName()
}

func TestTokenExchangeProfile_GetSubjectTokenType(tt *testing.T) {
	var zeroValue string
	t := &TokenExchangeProfile{SubjectTokenType: &zeroValue}
	t.GetSubjectTokenType()
	t = &TokenExchangeProfile{}
	t.GetSubjectTokenType()
	t = nil
	t.GetSubjectTokenType()
}

func TestTokenExchangeProfile_GetType(tt *testing.T) {
	var zeroValue string
	t := &TokenExchangeProfile{Type: &zeroValue}
	t.GetType()
	t = &TokenExchangeProfile{}
	t.GetType()
	t = nil
	t.GetType()
}

func TestTokenExchangeProfile_GetUpdatedAt(tt *testing.T) {
	var zeroValue time.Time
	t := &TokenExchangeProfile{UpdatedAt: &zeroValue}
	t.GetUpdatedAt()
	t = &TokenExchangeProfile{}
	t.GetUpdatedAt()
	t = nil
	t.GetUpdatedAt()
}

func TestTokenExchangeProfile_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &TokenExchangeProfile{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestTokenExchangeProfileList_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &TokenExchangeProfileList{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestUser_GetAppMetadata(tt *testing.T) {
	var zeroValue map[string]interface{}
	u := &User{AppMetadata: &zeroValue}
	u.GetAppMetadata()
	u = &User{}
	u.GetAppMetadata()
	u = nil
	u.GetAppMetadata()
}

func TestUser_GetBlocked(tt *testing.T) {
	var zeroValue bool
	u := &User{Blocked: &zeroValue}
	u.GetBlocked()
	u = &User{}
	u.GetBlocked()
	u = nil
	u.GetBlocked()
}

func TestUser_GetClientID(tt *testing.T) {
	var zeroValue string
	u := &User{ClientID: &zeroValue}
	u.GetClientID()
	u = &User{}
	u.GetClientID()
	u = nil
	u.GetClientID()
}

func TestUser_GetConnection(tt *testing.T) {
	var zeroValue string
	u := &User{Connection: &zeroValue}
	u.GetConnection()
	u = &User{}
	u.GetConnection()
	u = nil
	u.GetConnection()
}

func TestUser_GetCreatedAt(tt *testing.T) {
	var zeroValue time.Time
	u := &User{CreatedAt: &zeroValue}
	u.GetCreatedAt()
	u = &User{}
	u.GetCreatedAt()
	u = nil
	u.GetCreatedAt()
}

func TestUser_GetDescription(tt *testing.T) {
	var zeroValue string
	u := &User{Description: &zeroValue}
	u.GetDescription()
	u = &User{}
	u.GetDescription()
	u = nil
	u.GetDescription()
}

func TestUser_GetEmail(tt *testing.T) {
	var zeroValue string
	u := &User{Email: &zeroValue}
	u.GetEmail()
	u = &User{}
	u.GetEmail()
	u = nil
	u.GetEmail()
}

func TestUser_GetEmailVerified(tt *testing.T) {
	var zeroValue bool
	u := &User{EmailVerified: &zeroValue}
	u.GetEmailVerified()
	u = &User{}
	u.GetEmailVerified()
	u = nil
	u.GetEmailVerified()
}

func TestUser_GetFamilyName(tt *testing.T) {
	var zeroValue string
	u := &User{FamilyName: &zeroValue}
	u.GetFamilyName()
	u = &User{}
	u.GetFamilyName()
	u = nil
	u.GetFamilyName()
}

func TestUser_GetGivenName(tt *testing.T) {
	var zeroValue string
	u := &User{GivenName: &zeroValue}
	u.GetGivenName()
	u = &User{}
	u.GetGivenName()
	u = nil
	u.GetGivenName()
}

func TestUser_GetID(tt *testing.T) {
	var zeroValue string
	u := &User{ID: &zeroValue}
	u.GetID()
	u = &User{}
	u.GetID()
	u = nil
	u.GetID()
}

func TestUser_GetLastIP(tt *testing.T) {
	var zeroValue string
	u := &User{LastIP: &zeroValue}
	u.GetLastIP()
	u = &User{}
	u.GetLastIP()
	u = nil
	u.GetLastIP()
}

func TestUser_GetLastLogin(tt *testing.T) {
	var zeroValue time.Time
	u := &User{LastLogin: &zeroValue}
	u.GetLastLogin()
	u = &User{}
	u.GetLastLogin()
	u = nil
	u.GetLastLogin()
}

func TestUser_GetLastPasswordReset(tt *testing.T) {
	var zeroValue time.Time
	u := &User{LastPasswordReset: &zeroValue}
	u.GetLastPasswordReset()
	u = &User{}
	u.GetLastPasswordReset()
	u = nil
	u.GetLastPasswordReset()
}

func TestUser_GetLocation(tt *testing.T) {
	var zeroValue string
	u := &User{Location: &zeroValue}
	u.GetLocation()
	u = &User{}
	u.GetLocation()
	u = nil
	u.GetLocation()
}

func TestUser_GetLoginsCount(tt *testing.T) {
	var zeroValue int64
	u := &User{LoginsCount: &zeroValue}
	u.GetLoginsCount()
	u = &User{}
	u.GetLoginsCount()
	u = nil
	u.GetLoginsCount()
}

func TestUser_GetMultifactor(tt *testing.T) {
	var zeroValue []string
	u := &User{Multifactor: &zeroValue}
	u.GetMultifactor()
	u = &User{}
	u.GetMultifactor()
	u = nil
	u.GetMultifactor()
}

func TestUser_GetName(tt *testing.T) {
	var zeroValue string
	u := &User{Name: &zeroValue}
	u.GetName()
	u = &User{}
	u.GetName()
	u = nil
	u.GetName()
}

func TestUser_GetNickname(tt *testing.T) {
	var zeroValue string
	u := &User{Nickname: &zeroValue}
	u.GetNickname()
	u = &User{}
	u.GetNickname()
	u = nil
	u.GetNickname()
}

func TestUser_GetPassword(tt *testing.T) {
	var zeroValue string
	u := &User{Password: &zeroValue}
	u.GetPassword()
	u = &User{}
	u.GetPassword()
	u = nil
	u.GetPassword()
}

func TestUser_GetPhoneNumber(tt *testing.T) {
	var zeroValue string
	u := &User{PhoneNumber: &zeroValue}
	u.GetPhoneNumber()
	u = &User{}
	u.GetPhoneNumber()
	u = nil
	u.GetPhoneNumber()
}

func TestUser_GetPhoneVerified(tt *testing.T) {
	var zeroValue bool
	u := &User{PhoneVerified: &zeroValue}
	u.GetPhoneVerified()
	u = &User{}
	u.GetPhoneVerified()
	u = nil
	u.GetPhoneVerified()
}

func TestUser_GetPicture(tt *testing.T) {
	var zeroValue string
	u := &User{Picture: &zeroValue}
	u.GetPicture()
	u = &User{}
	u.GetPicture()
	u = nil
	u.GetPicture()
}

func TestUser_GetScreenName(tt *testing.T) {
	var zeroValue string
	u := &User{ScreenName: &zeroValue}
	u.GetScreenName()
	u = &User{}
	u.GetScreenName()
	u = nil
	u.GetScreenName()
}

func TestUser_GetUpdatedAt(tt *testing.T) {
	var zeroValue time.Time
	u := &User{UpdatedAt: &zeroValue}
	u.GetUpdatedAt()
	u = &User{}
	u.GetUpdatedAt()
	u = nil
	u.GetUpdatedAt()
}

func TestUser_GetURL(tt *testing.T) {
	var zeroValue string
	u := &User{URL: &zeroValue}
	u.GetURL()
	u = &User{}
	u.GetURL()
	u = nil
	u.GetURL()
}

func TestUser_GetUserMetadata(tt *testing.T) {
	var zeroValue map[string]interface{}
	u := &User{UserMetadata: &zeroValue}
	u.GetUserMetadata()
	u = &User{}
	u.GetUserMetadata()
	u = nil
	u.GetUserMetadata()
}

func TestUser_GetUsername(tt *testing.T) {
	var zeroValue string
	u := &User{Username: &zeroValue}
	u.GetUsername()
	u = &User{}
	u.GetUsername()
	u = nil
	u.GetUsername()
}

func TestUser_GetVerifyEmail(tt *testing.T) {
	var zeroValue bool
	u := &User{VerifyEmail: &zeroValue}
	u.GetVerifyEmail()
	u = &User{}
	u.GetVerifyEmail()
	u = nil
	u.GetVerifyEmail()
}

func TestUser_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &User{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestUserBlock_GetIdentifier(tt *testing.T) {
	var zeroValue string
	u := &UserBlock{Identifier: &zeroValue}
	u.GetIdentifier()
	u = &UserBlock{}
	u.GetIdentifier()
	u = nil
	u.GetIdentifier()
}

func TestUserBlock_GetIP(tt *testing.T) {
	var zeroValue string
	u := &UserBlock{IP: &zeroValue}
	u.GetIP()
	u = &UserBlock{}
	u.GetIP()
	u = nil
	u.GetIP()
}

func TestUserBlock_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &UserBlock{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestUserEnrollment_GetAuthMethod(tt *testing.T) {
	var zeroValue string
	u := &UserEnrollment{AuthMethod: &zeroValue}
	u.GetAuthMethod()
	u = &UserEnrollment{}
	u.GetAuthMethod()
	u = nil
	u.GetAuthMethod()
}

func TestUserEnrollment_GetEnrolledAt(tt *testing.T) {
	var zeroValue time.Time
	u := &UserEnrollment{EnrolledAt: &zeroValue}
	u.GetEnrolledAt()
	u = &UserEnrollment{}
	u.GetEnrolledAt()
	u = nil
	u.GetEnrolledAt()
}

func TestUserEnrollment_GetID(tt *testing.T) {
	var zeroValue string
	u := &UserEnrollment{ID: &zeroValue}
	u.GetID()
	u = &UserEnrollment{}
	u.GetID()
	u = nil
	u.GetID()
}

func TestUserEnrollment_GetIdentifier(tt *testing.T) {
	var zeroValue string
	u := &UserEnrollment{Identifier: &zeroValue}
	u.GetIdentifier()
	u = &UserEnrollment{}
	u.GetIdentifier()
	u = nil
	u.GetIdentifier()
}

func TestUserEnrollment_GetLastAuth(tt *testing.T) {
	var zeroValue time.Time
	u := &UserEnrollment{LastAuth: &zeroValue}
	u.GetLastAuth()
	u = &UserEnrollment{}
	u.GetLastAuth()
	u = nil
	u.GetLastAuth()
}

func TestUserEnrollment_GetName(tt *testing.T) {
	var zeroValue string
	u := &UserEnrollment{Name: &zeroValue}
	u.GetName()
	u = &UserEnrollment{}
	u.GetName()
	u = nil
	u.GetName()
}

func TestUserEnrollment_GetPhoneNumber(tt *testing.T) {
	var zeroValue string
	u := &UserEnrollment{PhoneNumber: &zeroValue}
	u.GetPhoneNumber()
	u = &UserEnrollment{}
	u.GetPhoneNumber()
	u = nil
	u.GetPhoneNumber()
}

func TestUserEnrollment_GetStatus(tt *testing.T) {
	var zeroValue string
	u := &UserEnrollment{Status: &zeroValue}
	u.GetStatus()
	u = &UserEnrollment{}
	u.GetStatus()
	u = nil
	u.GetStatus()
}

func TestUserEnrollment_GetType(tt *testing.T) {
	var zeroValue string
	u := &UserEnrollment{Type: &zeroValue}
	u.GetType()
	u = &UserEnrollment{}
	u.GetType()
	u = nil
	u.GetType()
}

func TestUserEnrollment_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &UserEnrollment{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestUserIdentity_GetAccessToken(tt *testing.T) {
	var zeroValue string
	u := &UserIdentity{AccessToken: &zeroValue}
	u.GetAccessToken()
	u = &UserIdentity{}
	u.GetAccessToken()
	u = nil
	u.GetAccessToken()
}

func TestUserIdentity_GetAccessTokenSecret(tt *testing.T) {
	var zeroValue string
	u := &UserIdentity{AccessTokenSecret: &zeroValue}
	u.GetAccessTokenSecret()
	u = &UserIdentity{}
	u.GetAccessTokenSecret()
	u = nil
	u.GetAccessTokenSecret()
}

func TestUserIdentity_GetConnection(tt *testing.T) {
	var zeroValue string
	u := &UserIdentity{Connection: &zeroValue}
	u.GetConnection()
	u = &UserIdentity{}
	u.GetConnection()
	u = nil
	u.GetConnection()
}

func TestUserIdentity_GetIsSocial(tt *testing.T) {
	var zeroValue bool
	u := &UserIdentity{IsSocial: &zeroValue}
	u.GetIsSocial()
	u = &UserIdentity{}
	u.GetIsSocial()
	u = nil
	u.GetIsSocial()
}

func TestUserIdentity_GetProfileData(tt *testing.T) {
	var zeroValue map[string]interface{}
	u := &UserIdentity{ProfileData: &zeroValue}
	u.GetProfileData()
	u = &UserIdentity{}
	u.GetProfileData()
	u = nil
	u.GetProfileData()
}

func TestUserIdentity_GetProvider(tt *testing.T) {
	var zeroValue string
	u := &UserIdentity{Provider: &zeroValue}
	u.GetProvider()
	u = &UserIdentity{}
	u.GetProvider()
	u = nil
	u.GetProvider()
}

func TestUserIdentity_GetRefreshToken(tt *testing.T) {
	var zeroValue string
	u := &UserIdentity{RefreshToken: &zeroValue}
	u.GetRefreshToken()
	u = &UserIdentity{}
	u.GetRefreshToken()
	u = nil
	u.GetRefreshToken()
}

func TestUserIdentity_GetUserID(tt *testing.T) {
	var zeroValue string
	u := &UserIdentity{UserID: &zeroValue}
	u.GetUserID()
	u = &UserIdentity{}
	u.GetUserID()
	u = nil
	u.GetUserID()
}

func TestUserIdentity_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &UserIdentity{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestUserIdentityLink_GetConnectionID(tt *testing.T) {
	var zeroValue string
	u := &UserIdentityLink{ConnectionID: &zeroValue}
	u.GetConnectionID()
	u = &UserIdentityLink{}
	u.GetConnectionID()
	u = nil
	u.GetConnectionID()
}

func TestUserIdentityLink_GetLinkWith(tt *testing.T) {
	var zeroValue string
	u := &UserIdentityLink{LinkWith: &zeroValue}
	u.GetLinkWith()
	u = &UserIdentityLink{}
	u.GetLinkWith()
	u = nil
	u.GetLinkWith()
}

func TestUserIdentityLink_GetProvider(tt *testing.T) {
	var zeroValue string
	u := &UserIdentityLink{Provider: &zeroValue}
	u.GetProvider()
	u = &UserIdentityLink{}
	u.GetProvider()
	u = nil
	u.GetProvider()
}

func TestUserIdentityLink_GetUserID(tt *testing.T) {
	var zeroValue string
	u := &UserIdentityLink{UserID: &zeroValue}
	u.GetUserID()
	u = &UserIdentityLink{}
	u.GetUserID()
	u = nil
	u.GetUserID()
}

func TestUserIdentityLink_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &UserIdentityLink{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestUserList_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &UserList{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestUserRecoveryCode_GetRecoveryCode(tt *testing.T) {
	var zeroValue string
	u := &UserRecoveryCode{RecoveryCode: &zeroValue}
	u.GetRecoveryCode()
	u = &UserRecoveryCode{}
	u.GetRecoveryCode()
	u = nil
	u.GetRecoveryCode()
}

func TestUserRecoveryCode_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &UserRecoveryCode{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestUserSession_GetAuthenticatedAt(tt *testing.T) {
	var zeroValue string
	u := &UserSession{AuthenticatedAt: &zeroValue}
	u.GetAuthenticatedAt()
	u = &UserSession{}
	u.GetAuthenticatedAt()
	u = nil
	u.GetAuthenticatedAt()
}

func TestUserSession_GetAuthentication(tt *testing.T) {
	u := &UserSession{}
	u.GetAuthentication()
	u = nil
	u.GetAuthentication()
}

func TestUserSession_GetCreatedAt(tt *testing.T) {
	var zeroValue string
	u := &UserSession{CreatedAt: &zeroValue}
	u.GetCreatedAt()
	u = &UserSession{}
	u.GetCreatedAt()
	u = nil
	u.GetCreatedAt()
}

func TestUserSession_GetDevice(tt *testing.T) {
	u := &UserSession{}
	u.GetDevice()
	u = nil
	u.GetDevice()
}

func TestUserSession_GetExpiresAt(tt *testing.T) {
	var zeroValue string
	u := &UserSession{ExpiresAt: &zeroValue}
	u.GetExpiresAt()
	u = &UserSession{}
	u.GetExpiresAt()
	u = nil
	u.GetExpiresAt()
}

func TestUserSession_GetID(tt *testing.T) {
	var zeroValue string
	u := &UserSession{ID: &zeroValue}
	u.GetID()
	u = &UserSession{}
	u.GetID()
	u = nil
	u.GetID()
}

func TestUserSession_GetIdleExpiresAt(tt *testing.T) {
	var zeroValue string
	u := &UserSession{IdleExpiresAt: &zeroValue}
	u.GetIdleExpiresAt()
	u = &UserSession{}
	u.GetIdleExpiresAt()
	u = nil
	u.GetIdleExpiresAt()
}

func TestUserSession_GetLastInteractedAt(tt *testing.T) {
	var zeroValue string
	u := &UserSession{LastInteractedAt: &zeroValue}
	u.GetLastInteractedAt()
	u = &UserSession{}
	u.GetLastInteractedAt()
	u = nil
	u.GetLastInteractedAt()
}

func TestUserSession_GetUpdatedAt(tt *testing.T) {
	var zeroValue string
	u := &UserSession{UpdatedAt: &zeroValue}
	u.GetUpdatedAt()
	u = &UserSession{}
	u.GetUpdatedAt()
	u = nil
	u.GetUpdatedAt()
}

func TestUserSession_GetUserID(tt *testing.T) {
	var zeroValue string
	u := &UserSession{UserID: &zeroValue}
	u.GetUserID()
	u = &UserSession{}
	u.GetUserID()
	u = nil
	u.GetUserID()
}

func TestUserSession_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &UserSession{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestUserSessionAuthentication_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &UserSessionAuthentication{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestUserSessionAuthenticationMethod_GetName(tt *testing.T) {
	var zeroValue string
	u := &UserSessionAuthenticationMethod{Name: &zeroValue}
	u.GetName()
	u = &UserSessionAuthenticationMethod{}
	u.GetName()
	u = nil
	u.GetName()
}

func TestUserSessionAuthenticationMethod_GetTimestamp(tt *testing.T) {
	var zeroValue string
	u := &UserSessionAuthenticationMethod{Timestamp: &zeroValue}
	u.GetTimestamp()
	u = &UserSessionAuthenticationMethod{}
	u.GetTimestamp()
	u = nil
	u.GetTimestamp()
}

func TestUserSessionAuthenticationMethod_GetType(tt *testing.T) {
	var zeroValue string
	u := &UserSessionAuthenticationMethod{Type: &zeroValue}
	u.GetType()
	u = &UserSessionAuthenticationMethod{}
	u.GetType()
	u = nil
	u.GetType()
}

func TestUserSessionAuthenticationMethod_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &UserSessionAuthenticationMethod{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestUserSessionClient_GetClientID(tt *testing.T) {
	var zeroValue string
	u := &UserSessionClient{ClientID: &zeroValue}
	u.GetClientID()
	u = &UserSessionClient{}
	u.GetClientID()
	u = nil
	u.GetClientID()
}

func TestUserSessionClient_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &UserSessionClient{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestUserSessionDevice_GetInitialASN(tt *testing.T) {
	var zeroValue string
	u := &UserSessionDevice{InitialASN: &zeroValue}
	u.GetInitialASN()
	u = &UserSessionDevice{}
	u.GetInitialASN()
	u = nil
	u.GetInitialASN()
}

func TestUserSessionDevice_GetInitialIP(tt *testing.T) {
	var zeroValue string
	u := &UserSessionDevice{InitialIP: &zeroValue}
	u.GetInitialIP()
	u = &UserSessionDevice{}
	u.GetInitialIP()
	u = nil
	u.GetInitialIP()
}

func TestUserSessionDevice_GetInitialUserAgent(tt *testing.T) {
	var zeroValue string
	u := &UserSessionDevice{InitialUserAgent: &zeroValue}
	u.GetInitialUserAgent()
	u = &UserSessionDevice{}
	u.GetInitialUserAgent()
	u = nil
	u.GetInitialUserAgent()
}

func TestUserSessionDevice_GetLastASN(tt *testing.T) {
	var zeroValue string
	u := &UserSessionDevice{LastASN: &zeroValue}
	u.GetLastASN()
	u = &UserSessionDevice{}
	u.GetLastASN()
	u = nil
	u.GetLastASN()
}

func TestUserSessionDevice_GetLastIP(tt *testing.T) {
	var zeroValue string
	u := &UserSessionDevice{LastIP: &zeroValue}
	u.GetLastIP()
	u = &UserSessionDevice{}
	u.GetLastIP()
	u = nil
	u.GetLastIP()
}

func TestUserSessionDevice_GetLastUserAgent(tt *testing.T) {
	var zeroValue string
	u := &UserSessionDevice{LastUserAgent: &zeroValue}
	u.GetLastUserAgent()
	u = &UserSessionDevice{}
	u.GetLastUserAgent()
	u = nil
	u.GetLastUserAgent()
}

func TestUserSessionDevice_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &UserSessionDevice{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestUserSessionList_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &UserSessionList{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestWAMSClientAddon_GetMasterkey(tt *testing.T) {
	var zeroValue string
	w := &WAMSClientAddon{Masterkey: &zeroValue}
	w.GetMasterkey()
	w = &WAMSClientAddon{}
	w.GetMasterkey()
	w = nil
	w.GetMasterkey()
}

func TestWAMSClientAddon_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &WAMSClientAddon{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestWrappingKey_GetAlgorithm(tt *testing.T) {
	var zeroValue string
	w := &WrappingKey{Algorithm: &zeroValue}
	w.GetAlgorithm()
	w = &WrappingKey{}
	w.GetAlgorithm()
	w = nil
	w.GetAlgorithm()
}

func TestWrappingKey_GetPublicKey(tt *testing.T) {
	var zeroValue string
	w := &WrappingKey{PublicKey: &zeroValue}
	w.GetPublicKey()
	w = &WrappingKey{}
	w.GetPublicKey()
	w = nil
	w.GetPublicKey()
}

func TestWrappingKey_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &WrappingKey{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestWSFEDClientAddon_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &WSFEDClientAddon{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestZendeskClientAddon_GetAccountName(tt *testing.T) {
	var zeroValue string
	z := &ZendeskClientAddon{AccountName: &zeroValue}
	z.GetAccountName()
	z = &ZendeskClientAddon{}
	z.GetAccountName()
	z = nil
	z.GetAccountName()
}

func TestZendeskClientAddon_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ZendeskClientAddon{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}

func TestZoomClientAddon_GetAccount(tt *testing.T) {
	var zeroValue string
	z := &ZoomClientAddon{Account: &zeroValue}
	z.GetAccount()
	z = &ZoomClientAddon{}
	z.GetAccount()
	z = nil
	z.GetAccount()
}

func TestZoomClientAddon_String(t *testing.T) {
	var rawJSON json.RawMessage
	v := &ZoomClientAddon{}
	if err := json.Unmarshal([]byte(v.String()), &rawJSON); err != nil {
		t.Errorf("failed to produce a valid json")
	}
}