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

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

package github

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

func TestAbuseRateLimitError_GetMessage(tt *testing.T) {
	tt.Parallel()
	a := &AbuseRateLimitError{}
	a.GetMessage()
	a = nil
	a.GetMessage()
}

func TestAbuseRateLimitError_GetRetryAfter(tt *testing.T) {
	tt.Parallel()
	var zeroValue time.Duration
	a := &AbuseRateLimitError{RetryAfter: &zeroValue}
	a.GetRetryAfter()
	a = &AbuseRateLimitError{}
	a.GetRetryAfter()
	a = nil
	a.GetRetryAfter()
}

func TestAcceptedAssignment_GetAssignment(tt *testing.T) {
	tt.Parallel()
	a := &AcceptedAssignment{}
	a.GetAssignment()
	a = nil
	a.GetAssignment()
}

func TestAcceptedAssignment_GetCommitCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	a := &AcceptedAssignment{CommitCount: &zeroValue}
	a.GetCommitCount()
	a = &AcceptedAssignment{}
	a.GetCommitCount()
	a = nil
	a.GetCommitCount()
}

func TestAcceptedAssignment_GetGrade(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &AcceptedAssignment{Grade: &zeroValue}
	a.GetGrade()
	a = &AcceptedAssignment{}
	a.GetGrade()
	a = nil
	a.GetGrade()
}

func TestAcceptedAssignment_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	a := &AcceptedAssignment{ID: &zeroValue}
	a.GetID()
	a = &AcceptedAssignment{}
	a.GetID()
	a = nil
	a.GetID()
}

func TestAcceptedAssignment_GetPassing(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	a := &AcceptedAssignment{Passing: &zeroValue}
	a.GetPassing()
	a = &AcceptedAssignment{}
	a.GetPassing()
	a = nil
	a.GetPassing()
}

func TestAcceptedAssignment_GetRepository(tt *testing.T) {
	tt.Parallel()
	a := &AcceptedAssignment{}
	a.GetRepository()
	a = nil
	a.GetRepository()
}

func TestAcceptedAssignment_GetStudents(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*ClassroomUser{}
	a := &AcceptedAssignment{Students: zeroValue}
	a.GetStudents()
	a = &AcceptedAssignment{}
	a.GetStudents()
	a = nil
	a.GetStudents()
}

func TestAcceptedAssignment_GetSubmitted(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	a := &AcceptedAssignment{Submitted: &zeroValue}
	a.GetSubmitted()
	a = &AcceptedAssignment{}
	a.GetSubmitted()
	a = nil
	a.GetSubmitted()
}

func TestAcceptedError_GetRaw(tt *testing.T) {
	tt.Parallel()
	zeroValue := []byte{}
	a := &AcceptedError{Raw: zeroValue}
	a.GetRaw()
	a = &AcceptedError{}
	a.GetRaw()
	a = nil
	a.GetRaw()
}

func TestAccessibleRepository_GetFullName(tt *testing.T) {
	tt.Parallel()
	a := &AccessibleRepository{}
	a.GetFullName()
	a = nil
	a.GetFullName()
}

func TestAccessibleRepository_GetID(tt *testing.T) {
	tt.Parallel()
	a := &AccessibleRepository{}
	a.GetID()
	a = nil
	a.GetID()
}

func TestAccessibleRepository_GetName(tt *testing.T) {
	tt.Parallel()
	a := &AccessibleRepository{}
	a.GetName()
	a = nil
	a.GetName()
}

func TestActionsAllowed_GetGithubOwnedAllowed(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	a := &ActionsAllowed{GithubOwnedAllowed: &zeroValue}
	a.GetGithubOwnedAllowed()
	a = &ActionsAllowed{}
	a.GetGithubOwnedAllowed()
	a = nil
	a.GetGithubOwnedAllowed()
}

func TestActionsAllowed_GetPatternsAllowed(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	a := &ActionsAllowed{PatternsAllowed: zeroValue}
	a.GetPatternsAllowed()
	a = &ActionsAllowed{}
	a.GetPatternsAllowed()
	a = nil
	a.GetPatternsAllowed()
}

func TestActionsAllowed_GetVerifiedAllowed(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	a := &ActionsAllowed{VerifiedAllowed: &zeroValue}
	a.GetVerifiedAllowed()
	a = &ActionsAllowed{}
	a.GetVerifiedAllowed()
	a = nil
	a.GetVerifiedAllowed()
}

func TestActionsCache_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	a := &ActionsCache{CreatedAt: &zeroValue}
	a.GetCreatedAt()
	a = &ActionsCache{}
	a.GetCreatedAt()
	a = nil
	a.GetCreatedAt()
}

func TestActionsCache_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	a := &ActionsCache{ID: &zeroValue}
	a.GetID()
	a = &ActionsCache{}
	a.GetID()
	a = nil
	a.GetID()
}

func TestActionsCache_GetKey(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &ActionsCache{Key: &zeroValue}
	a.GetKey()
	a = &ActionsCache{}
	a.GetKey()
	a = nil
	a.GetKey()
}

func TestActionsCache_GetLastAccessedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	a := &ActionsCache{LastAccessedAt: &zeroValue}
	a.GetLastAccessedAt()
	a = &ActionsCache{}
	a.GetLastAccessedAt()
	a = nil
	a.GetLastAccessedAt()
}

func TestActionsCache_GetRef(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &ActionsCache{Ref: &zeroValue}
	a.GetRef()
	a = &ActionsCache{}
	a.GetRef()
	a = nil
	a.GetRef()
}

func TestActionsCache_GetSizeInBytes(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	a := &ActionsCache{SizeInBytes: &zeroValue}
	a.GetSizeInBytes()
	a = &ActionsCache{}
	a.GetSizeInBytes()
	a = nil
	a.GetSizeInBytes()
}

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

func TestActionsCacheList_GetActionsCaches(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*ActionsCache{}
	a := &ActionsCacheList{ActionsCaches: zeroValue}
	a.GetActionsCaches()
	a = &ActionsCacheList{}
	a.GetActionsCaches()
	a = nil
	a.GetActionsCaches()
}

func TestActionsCacheList_GetTotalCount(tt *testing.T) {
	tt.Parallel()
	a := &ActionsCacheList{}
	a.GetTotalCount()
	a = nil
	a.GetTotalCount()
}

func TestActionsCacheListOptions_GetDirection(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &ActionsCacheListOptions{Direction: &zeroValue}
	a.GetDirection()
	a = &ActionsCacheListOptions{}
	a.GetDirection()
	a = nil
	a.GetDirection()
}

func TestActionsCacheListOptions_GetKey(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &ActionsCacheListOptions{Key: &zeroValue}
	a.GetKey()
	a = &ActionsCacheListOptions{}
	a.GetKey()
	a = nil
	a.GetKey()
}

func TestActionsCacheListOptions_GetRef(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &ActionsCacheListOptions{Ref: &zeroValue}
	a.GetRef()
	a = &ActionsCacheListOptions{}
	a.GetRef()
	a = nil
	a.GetRef()
}

func TestActionsCacheListOptions_GetSort(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &ActionsCacheListOptions{Sort: &zeroValue}
	a.GetSort()
	a = &ActionsCacheListOptions{}
	a.GetSort()
	a = nil
	a.GetSort()
}

func TestActionsCacheUsage_GetActiveCachesCount(tt *testing.T) {
	tt.Parallel()
	a := &ActionsCacheUsage{}
	a.GetActiveCachesCount()
	a = nil
	a.GetActiveCachesCount()
}

func TestActionsCacheUsage_GetActiveCachesSizeInBytes(tt *testing.T) {
	tt.Parallel()
	a := &ActionsCacheUsage{}
	a.GetActiveCachesSizeInBytes()
	a = nil
	a.GetActiveCachesSizeInBytes()
}

func TestActionsCacheUsage_GetFullName(tt *testing.T) {
	tt.Parallel()
	a := &ActionsCacheUsage{}
	a.GetFullName()
	a = nil
	a.GetFullName()
}

func TestActionsCacheUsageList_GetRepoCacheUsage(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*ActionsCacheUsage{}
	a := &ActionsCacheUsageList{RepoCacheUsage: zeroValue}
	a.GetRepoCacheUsage()
	a = &ActionsCacheUsageList{}
	a.GetRepoCacheUsage()
	a = nil
	a.GetRepoCacheUsage()
}

func TestActionsCacheUsageList_GetTotalCount(tt *testing.T) {
	tt.Parallel()
	a := &ActionsCacheUsageList{}
	a.GetTotalCount()
	a = nil
	a.GetTotalCount()
}

func TestActionsCreateOrgVariableRequest_GetName(tt *testing.T) {
	tt.Parallel()
	a := &ActionsCreateOrgVariableRequest{}
	a.GetName()
	a = nil
	a.GetName()
}

func TestActionsCreateOrgVariableRequest_GetSelectedRepositoryIDs(tt *testing.T) {
	tt.Parallel()
	zeroValue := []int64{}
	a := &ActionsCreateOrgVariableRequest{SelectedRepositoryIDs: zeroValue}
	a.GetSelectedRepositoryIDs()
	a = &ActionsCreateOrgVariableRequest{}
	a.GetSelectedRepositoryIDs()
	a = nil
	a.GetSelectedRepositoryIDs()
}

func TestActionsCreateOrgVariableRequest_GetValue(tt *testing.T) {
	tt.Parallel()
	a := &ActionsCreateOrgVariableRequest{}
	a.GetValue()
	a = nil
	a.GetValue()
}

func TestActionsCreateOrgVariableRequest_GetVisibility(tt *testing.T) {
	tt.Parallel()
	a := &ActionsCreateOrgVariableRequest{}
	a.GetVisibility()
	a = nil
	a.GetVisibility()
}

func TestActionsCreateVariableRequest_GetName(tt *testing.T) {
	tt.Parallel()
	a := &ActionsCreateVariableRequest{}
	a.GetName()
	a = nil
	a.GetName()
}

func TestActionsCreateVariableRequest_GetValue(tt *testing.T) {
	tt.Parallel()
	a := &ActionsCreateVariableRequest{}
	a.GetValue()
	a = nil
	a.GetValue()
}

func TestActionsEnabledOnEnterpriseRepos_GetOrganizations(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*Organization{}
	a := &ActionsEnabledOnEnterpriseRepos{Organizations: zeroValue}
	a.GetOrganizations()
	a = &ActionsEnabledOnEnterpriseRepos{}
	a.GetOrganizations()
	a = nil
	a.GetOrganizations()
}

func TestActionsEnabledOnEnterpriseRepos_GetTotalCount(tt *testing.T) {
	tt.Parallel()
	a := &ActionsEnabledOnEnterpriseRepos{}
	a.GetTotalCount()
	a = nil
	a.GetTotalCount()
}

func TestActionsEnabledOnOrgRepos_GetRepositories(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*Repository{}
	a := &ActionsEnabledOnOrgRepos{Repositories: zeroValue}
	a.GetRepositories()
	a = &ActionsEnabledOnOrgRepos{}
	a.GetRepositories()
	a = nil
	a.GetRepositories()
}

func TestActionsEnabledOnOrgRepos_GetTotalCount(tt *testing.T) {
	tt.Parallel()
	a := &ActionsEnabledOnOrgRepos{}
	a.GetTotalCount()
	a = nil
	a.GetTotalCount()
}

func TestActionsInboundDomains_GetFullDomains(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	a := &ActionsInboundDomains{FullDomains: zeroValue}
	a.GetFullDomains()
	a = &ActionsInboundDomains{}
	a.GetFullDomains()
	a = nil
	a.GetFullDomains()
}

func TestActionsInboundDomains_GetWildcardDomains(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	a := &ActionsInboundDomains{WildcardDomains: zeroValue}
	a.GetWildcardDomains()
	a = &ActionsInboundDomains{}
	a.GetWildcardDomains()
	a = nil
	a.GetWildcardDomains()
}

func TestActionsPermissions_GetAllowedActions(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &ActionsPermissions{AllowedActions: &zeroValue}
	a.GetAllowedActions()
	a = &ActionsPermissions{}
	a.GetAllowedActions()
	a = nil
	a.GetAllowedActions()
}

func TestActionsPermissions_GetEnabledRepositories(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &ActionsPermissions{EnabledRepositories: &zeroValue}
	a.GetEnabledRepositories()
	a = &ActionsPermissions{}
	a.GetEnabledRepositories()
	a = nil
	a.GetEnabledRepositories()
}

func TestActionsPermissions_GetSelectedActionsURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &ActionsPermissions{SelectedActionsURL: &zeroValue}
	a.GetSelectedActionsURL()
	a = &ActionsPermissions{}
	a.GetSelectedActionsURL()
	a = nil
	a.GetSelectedActionsURL()
}

func TestActionsPermissions_GetSHAPinningRequired(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	a := &ActionsPermissions{SHAPinningRequired: &zeroValue}
	a.GetSHAPinningRequired()
	a = &ActionsPermissions{}
	a.GetSHAPinningRequired()
	a = nil
	a.GetSHAPinningRequired()
}

func TestActionsPermissionsEnterprise_GetAllowedActions(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &ActionsPermissionsEnterprise{AllowedActions: &zeroValue}
	a.GetAllowedActions()
	a = &ActionsPermissionsEnterprise{}
	a.GetAllowedActions()
	a = nil
	a.GetAllowedActions()
}

func TestActionsPermissionsEnterprise_GetEnabledOrganizations(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &ActionsPermissionsEnterprise{EnabledOrganizations: &zeroValue}
	a.GetEnabledOrganizations()
	a = &ActionsPermissionsEnterprise{}
	a.GetEnabledOrganizations()
	a = nil
	a.GetEnabledOrganizations()
}

func TestActionsPermissionsEnterprise_GetSelectedActionsURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &ActionsPermissionsEnterprise{SelectedActionsURL: &zeroValue}
	a.GetSelectedActionsURL()
	a = &ActionsPermissionsEnterprise{}
	a.GetSelectedActionsURL()
	a = nil
	a.GetSelectedActionsURL()
}

func TestActionsPermissionsRepository_GetAllowedActions(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &ActionsPermissionsRepository{AllowedActions: &zeroValue}
	a.GetAllowedActions()
	a = &ActionsPermissionsRepository{}
	a.GetAllowedActions()
	a = nil
	a.GetAllowedActions()
}

func TestActionsPermissionsRepository_GetEnabled(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	a := &ActionsPermissionsRepository{Enabled: &zeroValue}
	a.GetEnabled()
	a = &ActionsPermissionsRepository{}
	a.GetEnabled()
	a = nil
	a.GetEnabled()
}

func TestActionsPermissionsRepository_GetSelectedActionsURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &ActionsPermissionsRepository{SelectedActionsURL: &zeroValue}
	a.GetSelectedActionsURL()
	a = &ActionsPermissionsRepository{}
	a.GetSelectedActionsURL()
	a = nil
	a.GetSelectedActionsURL()
}

func TestActionsPermissionsRepository_GetSHAPinningRequired(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	a := &ActionsPermissionsRepository{SHAPinningRequired: &zeroValue}
	a.GetSHAPinningRequired()
	a = &ActionsPermissionsRepository{}
	a.GetSHAPinningRequired()
	a = nil
	a.GetSHAPinningRequired()
}

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

func TestActionsUpdateOrgVariableRequest_GetSelectedRepositoryIDs(tt *testing.T) {
	tt.Parallel()
	zeroValue := []int64{}
	a := &ActionsUpdateOrgVariableRequest{SelectedRepositoryIDs: zeroValue}
	a.GetSelectedRepositoryIDs()
	a = &ActionsUpdateOrgVariableRequest{}
	a.GetSelectedRepositoryIDs()
	a = nil
	a.GetSelectedRepositoryIDs()
}

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

func TestActionsUpdateOrgVariableRequest_GetVisibility(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &ActionsUpdateOrgVariableRequest{Visibility: &zeroValue}
	a.GetVisibility()
	a = &ActionsUpdateOrgVariableRequest{}
	a.GetVisibility()
	a = nil
	a.GetVisibility()
}

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

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

func TestActionsVariable_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	a := &ActionsVariable{CreatedAt: &zeroValue}
	a.GetCreatedAt()
	a = &ActionsVariable{}
	a.GetCreatedAt()
	a = nil
	a.GetCreatedAt()
}

func TestActionsVariable_GetName(tt *testing.T) {
	tt.Parallel()
	a := &ActionsVariable{}
	a.GetName()
	a = nil
	a.GetName()
}

func TestActionsVariable_GetSelectedRepositoriesURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &ActionsVariable{SelectedRepositoriesURL: &zeroValue}
	a.GetSelectedRepositoriesURL()
	a = &ActionsVariable{}
	a.GetSelectedRepositoriesURL()
	a = nil
	a.GetSelectedRepositoriesURL()
}

func TestActionsVariable_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	a := &ActionsVariable{UpdatedAt: &zeroValue}
	a.GetUpdatedAt()
	a = &ActionsVariable{}
	a.GetUpdatedAt()
	a = nil
	a.GetUpdatedAt()
}

func TestActionsVariable_GetValue(tt *testing.T) {
	tt.Parallel()
	a := &ActionsVariable{}
	a.GetValue()
	a = nil
	a.GetValue()
}

func TestActionsVariable_GetVisibility(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &ActionsVariable{Visibility: &zeroValue}
	a.GetVisibility()
	a = &ActionsVariable{}
	a.GetVisibility()
	a = nil
	a.GetVisibility()
}

func TestActionsVariables_GetTotalCount(tt *testing.T) {
	tt.Parallel()
	a := &ActionsVariables{}
	a.GetTotalCount()
	a = nil
	a.GetTotalCount()
}

func TestActionsVariables_GetVariables(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*ActionsVariable{}
	a := &ActionsVariables{Variables: zeroValue}
	a.GetVariables()
	a = &ActionsVariables{}
	a.GetVariables()
	a = nil
	a.GetVariables()
}

func TestActiveCommitters_GetMaximumAdvancedSecurityCommitters(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	a := &ActiveCommitters{MaximumAdvancedSecurityCommitters: &zeroValue}
	a.GetMaximumAdvancedSecurityCommitters()
	a = &ActiveCommitters{}
	a.GetMaximumAdvancedSecurityCommitters()
	a = nil
	a.GetMaximumAdvancedSecurityCommitters()
}

func TestActiveCommitters_GetPurchasedAdvancedSecurityCommitters(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	a := &ActiveCommitters{PurchasedAdvancedSecurityCommitters: &zeroValue}
	a.GetPurchasedAdvancedSecurityCommitters()
	a = &ActiveCommitters{}
	a.GetPurchasedAdvancedSecurityCommitters()
	a = nil
	a.GetPurchasedAdvancedSecurityCommitters()
}

func TestActiveCommitters_GetRepositories(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*RepositoryActiveCommitters{}
	a := &ActiveCommitters{Repositories: zeroValue}
	a.GetRepositories()
	a = &ActiveCommitters{}
	a.GetRepositories()
	a = nil
	a.GetRepositories()
}

func TestActiveCommitters_GetTotalAdvancedSecurityCommitters(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	a := &ActiveCommitters{TotalAdvancedSecurityCommitters: &zeroValue}
	a.GetTotalAdvancedSecurityCommitters()
	a = &ActiveCommitters{}
	a.GetTotalAdvancedSecurityCommitters()
	a = nil
	a.GetTotalAdvancedSecurityCommitters()
}

func TestActiveCommitters_GetTotalCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	a := &ActiveCommitters{TotalCount: &zeroValue}
	a.GetTotalCount()
	a = &ActiveCommitters{}
	a.GetTotalCount()
	a = nil
	a.GetTotalCount()
}

func TestActiveCommittersListOptions_GetAdvancedSecurityProduct(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &ActiveCommittersListOptions{AdvancedSecurityProduct: &zeroValue}
	a.GetAdvancedSecurityProduct()
	a = &ActiveCommittersListOptions{}
	a.GetAdvancedSecurityProduct()
	a = nil
	a.GetAdvancedSecurityProduct()
}

func TestActivityListStarredOptions_GetDirection(tt *testing.T) {
	tt.Parallel()
	a := &ActivityListStarredOptions{}
	a.GetDirection()
	a = nil
	a.GetDirection()
}

func TestActivityListStarredOptions_GetSort(tt *testing.T) {
	tt.Parallel()
	a := &ActivityListStarredOptions{}
	a.GetSort()
	a = nil
	a.GetSort()
}

func TestActorLocation_GetCountryCode(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &ActorLocation{CountryCode: &zeroValue}
	a.GetCountryCode()
	a = &ActorLocation{}
	a.GetCountryCode()
	a = nil
	a.GetCountryCode()
}

func TestAddProjectItemOptions_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	a := &AddProjectItemOptions{ID: &zeroValue}
	a.GetID()
	a = &AddProjectItemOptions{}
	a.GetID()
	a = nil
	a.GetID()
}

func TestAddProjectItemOptions_GetType(tt *testing.T) {
	tt.Parallel()
	a := &AddProjectItemOptions{}
	a.GetType()
	a = nil
	a.GetType()
}

func TestAddProjectV2FieldRequest_GetDataType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &AddProjectV2FieldRequest{DataType: &zeroValue}
	a.GetDataType()
	a = &AddProjectV2FieldRequest{}
	a.GetDataType()
	a = nil
	a.GetDataType()
}

func TestAddProjectV2FieldRequest_GetIssueFieldID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	a := &AddProjectV2FieldRequest{IssueFieldID: &zeroValue}
	a.GetIssueFieldID()
	a = &AddProjectV2FieldRequest{}
	a.GetIssueFieldID()
	a = nil
	a.GetIssueFieldID()
}

func TestAddProjectV2FieldRequest_GetIterationConfiguration(tt *testing.T) {
	tt.Parallel()
	a := &AddProjectV2FieldRequest{}
	a.GetIterationConfiguration()
	a = nil
	a.GetIterationConfiguration()
}

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

func TestAddProjectV2FieldRequest_GetSingleSelectOptions(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*ProjectV2FieldSingleSelectOption{}
	a := &AddProjectV2FieldRequest{SingleSelectOptions: zeroValue}
	a.GetSingleSelectOptions()
	a = &AddProjectV2FieldRequest{}
	a.GetSingleSelectOptions()
	a = nil
	a.GetSingleSelectOptions()
}

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

func TestAddResourcesToCostCenterResponse_GetReassignedResources(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*ReassignedResource{}
	a := &AddResourcesToCostCenterResponse{ReassignedResources: zeroValue}
	a.GetReassignedResources()
	a = &AddResourcesToCostCenterResponse{}
	a.GetReassignedResources()
	a = nil
	a.GetReassignedResources()
}

func TestAdminEnforcedChanges_GetFrom(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	a := &AdminEnforcedChanges{From: &zeroValue}
	a.GetFrom()
	a = &AdminEnforcedChanges{}
	a.GetFrom()
	a = nil
	a.GetFrom()
}

func TestAdminEnforcement_GetEnabled(tt *testing.T) {
	tt.Parallel()
	a := &AdminEnforcement{}
	a.GetEnabled()
	a = nil
	a.GetEnabled()
}

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

func TestAdminStats_GetComments(tt *testing.T) {
	tt.Parallel()
	a := &AdminStats{}
	a.GetComments()
	a = nil
	a.GetComments()
}

func TestAdminStats_GetGists(tt *testing.T) {
	tt.Parallel()
	a := &AdminStats{}
	a.GetGists()
	a = nil
	a.GetGists()
}

func TestAdminStats_GetHooks(tt *testing.T) {
	tt.Parallel()
	a := &AdminStats{}
	a.GetHooks()
	a = nil
	a.GetHooks()
}

func TestAdminStats_GetIssues(tt *testing.T) {
	tt.Parallel()
	a := &AdminStats{}
	a.GetIssues()
	a = nil
	a.GetIssues()
}

func TestAdminStats_GetMilestones(tt *testing.T) {
	tt.Parallel()
	a := &AdminStats{}
	a.GetMilestones()
	a = nil
	a.GetMilestones()
}

func TestAdminStats_GetOrgs(tt *testing.T) {
	tt.Parallel()
	a := &AdminStats{}
	a.GetOrgs()
	a = nil
	a.GetOrgs()
}

func TestAdminStats_GetPages(tt *testing.T) {
	tt.Parallel()
	a := &AdminStats{}
	a.GetPages()
	a = nil
	a.GetPages()
}

func TestAdminStats_GetPulls(tt *testing.T) {
	tt.Parallel()
	a := &AdminStats{}
	a.GetPulls()
	a = nil
	a.GetPulls()
}

func TestAdminStats_GetRepos(tt *testing.T) {
	tt.Parallel()
	a := &AdminStats{}
	a.GetRepos()
	a = nil
	a.GetRepos()
}

func TestAdminStats_GetUsers(tt *testing.T) {
	tt.Parallel()
	a := &AdminStats{}
	a.GetUsers()
	a = nil
	a.GetUsers()
}

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

func TestAdvancedSecurityCommittersBreakdown_GetLastPushedDate(tt *testing.T) {
	tt.Parallel()
	a := &AdvancedSecurityCommittersBreakdown{}
	a.GetLastPushedDate()
	a = nil
	a.GetLastPushedDate()
}

func TestAdvancedSecurityCommittersBreakdown_GetLastPushedEmail(tt *testing.T) {
	tt.Parallel()
	a := &AdvancedSecurityCommittersBreakdown{}
	a.GetLastPushedEmail()
	a = nil
	a.GetLastPushedEmail()
}

func TestAdvancedSecurityCommittersBreakdown_GetUserLogin(tt *testing.T) {
	tt.Parallel()
	a := &AdvancedSecurityCommittersBreakdown{}
	a.GetUserLogin()
	a = nil
	a.GetUserLogin()
}

func TestAdvisoryCVSS_GetScore(tt *testing.T) {
	tt.Parallel()
	var zeroValue float64
	a := &AdvisoryCVSS{Score: &zeroValue}
	a.GetScore()
	a = &AdvisoryCVSS{}
	a.GetScore()
	a = nil
	a.GetScore()
}

func TestAdvisoryCVSS_GetVectorString(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &AdvisoryCVSS{VectorString: &zeroValue}
	a.GetVectorString()
	a = &AdvisoryCVSS{}
	a.GetVectorString()
	a = nil
	a.GetVectorString()
}

func TestAdvisoryCVSSSeverities_GetCVSSV3(tt *testing.T) {
	tt.Parallel()
	a := &AdvisoryCVSSSeverities{}
	a.GetCVSSV3()
	a = nil
	a.GetCVSSV3()
}

func TestAdvisoryCVSSSeverities_GetCVSSV4(tt *testing.T) {
	tt.Parallel()
	a := &AdvisoryCVSSSeverities{}
	a.GetCVSSV4()
	a = nil
	a.GetCVSSV4()
}

func TestAdvisoryCWEs_GetCWEID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &AdvisoryCWEs{CWEID: &zeroValue}
	a.GetCWEID()
	a = &AdvisoryCWEs{}
	a.GetCWEID()
	a = nil
	a.GetCWEID()
}

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

func TestAdvisoryEPSS_GetPercentage(tt *testing.T) {
	tt.Parallel()
	a := &AdvisoryEPSS{}
	a.GetPercentage()
	a = nil
	a.GetPercentage()
}

func TestAdvisoryEPSS_GetPercentile(tt *testing.T) {
	tt.Parallel()
	a := &AdvisoryEPSS{}
	a.GetPercentile()
	a = nil
	a.GetPercentile()
}

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

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

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

func TestAdvisoryVulnerability_GetFirstPatchedVersion(tt *testing.T) {
	tt.Parallel()
	a := &AdvisoryVulnerability{}
	a.GetFirstPatchedVersion()
	a = nil
	a.GetFirstPatchedVersion()
}

func TestAdvisoryVulnerability_GetPackage(tt *testing.T) {
	tt.Parallel()
	a := &AdvisoryVulnerability{}
	a.GetPackage()
	a = nil
	a.GetPackage()
}

func TestAdvisoryVulnerability_GetPatchedVersions(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &AdvisoryVulnerability{PatchedVersions: &zeroValue}
	a.GetPatchedVersions()
	a = &AdvisoryVulnerability{}
	a.GetPatchedVersions()
	a = nil
	a.GetPatchedVersions()
}

func TestAdvisoryVulnerability_GetSeverity(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &AdvisoryVulnerability{Severity: &zeroValue}
	a.GetSeverity()
	a = &AdvisoryVulnerability{}
	a.GetSeverity()
	a = nil
	a.GetSeverity()
}

func TestAdvisoryVulnerability_GetVulnerableFunctions(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	a := &AdvisoryVulnerability{VulnerableFunctions: zeroValue}
	a.GetVulnerableFunctions()
	a = &AdvisoryVulnerability{}
	a.GetVulnerableFunctions()
	a = nil
	a.GetVulnerableFunctions()
}

func TestAdvisoryVulnerability_GetVulnerableVersionRange(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &AdvisoryVulnerability{VulnerableVersionRange: &zeroValue}
	a.GetVulnerableVersionRange()
	a = &AdvisoryVulnerability{}
	a.GetVulnerableVersionRange()
	a = nil
	a.GetVulnerableVersionRange()
}

func TestAlert_GetClosedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	a := &Alert{ClosedAt: &zeroValue}
	a.GetClosedAt()
	a = &Alert{}
	a.GetClosedAt()
	a = nil
	a.GetClosedAt()
}

func TestAlert_GetClosedBy(tt *testing.T) {
	tt.Parallel()
	a := &Alert{}
	a.GetClosedBy()
	a = nil
	a.GetClosedBy()
}

func TestAlert_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	a := &Alert{CreatedAt: &zeroValue}
	a.GetCreatedAt()
	a = &Alert{}
	a.GetCreatedAt()
	a = nil
	a.GetCreatedAt()
}

func TestAlert_GetDismissedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	a := &Alert{DismissedAt: &zeroValue}
	a.GetDismissedAt()
	a = &Alert{}
	a.GetDismissedAt()
	a = nil
	a.GetDismissedAt()
}

func TestAlert_GetDismissedBy(tt *testing.T) {
	tt.Parallel()
	a := &Alert{}
	a.GetDismissedBy()
	a = nil
	a.GetDismissedBy()
}

func TestAlert_GetDismissedComment(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &Alert{DismissedComment: &zeroValue}
	a.GetDismissedComment()
	a = &Alert{}
	a.GetDismissedComment()
	a = nil
	a.GetDismissedComment()
}

func TestAlert_GetDismissedReason(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &Alert{DismissedReason: &zeroValue}
	a.GetDismissedReason()
	a = &Alert{}
	a.GetDismissedReason()
	a = nil
	a.GetDismissedReason()
}

func TestAlert_GetFixedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	a := &Alert{FixedAt: &zeroValue}
	a.GetFixedAt()
	a = &Alert{}
	a.GetFixedAt()
	a = nil
	a.GetFixedAt()
}

func TestAlert_GetHTMLURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &Alert{HTMLURL: &zeroValue}
	a.GetHTMLURL()
	a = &Alert{}
	a.GetHTMLURL()
	a = nil
	a.GetHTMLURL()
}

func TestAlert_GetInstances(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*MostRecentInstance{}
	a := &Alert{Instances: zeroValue}
	a.GetInstances()
	a = &Alert{}
	a.GetInstances()
	a = nil
	a.GetInstances()
}

func TestAlert_GetInstancesURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &Alert{InstancesURL: &zeroValue}
	a.GetInstancesURL()
	a = &Alert{}
	a.GetInstancesURL()
	a = nil
	a.GetInstancesURL()
}

func TestAlert_GetMostRecentInstance(tt *testing.T) {
	tt.Parallel()
	a := &Alert{}
	a.GetMostRecentInstance()
	a = nil
	a.GetMostRecentInstance()
}

func TestAlert_GetNumber(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	a := &Alert{Number: &zeroValue}
	a.GetNumber()
	a = &Alert{}
	a.GetNumber()
	a = nil
	a.GetNumber()
}

func TestAlert_GetRepository(tt *testing.T) {
	tt.Parallel()
	a := &Alert{}
	a.GetRepository()
	a = nil
	a.GetRepository()
}

func TestAlert_GetRule(tt *testing.T) {
	tt.Parallel()
	a := &Alert{}
	a.GetRule()
	a = nil
	a.GetRule()
}

func TestAlert_GetRuleDescription(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &Alert{RuleDescription: &zeroValue}
	a.GetRuleDescription()
	a = &Alert{}
	a.GetRuleDescription()
	a = nil
	a.GetRuleDescription()
}

func TestAlert_GetRuleID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &Alert{RuleID: &zeroValue}
	a.GetRuleID()
	a = &Alert{}
	a.GetRuleID()
	a = nil
	a.GetRuleID()
}

func TestAlert_GetRuleSeverity(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &Alert{RuleSeverity: &zeroValue}
	a.GetRuleSeverity()
	a = &Alert{}
	a.GetRuleSeverity()
	a = nil
	a.GetRuleSeverity()
}

func TestAlert_GetState(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &Alert{State: &zeroValue}
	a.GetState()
	a = &Alert{}
	a.GetState()
	a = nil
	a.GetState()
}

func TestAlert_GetTool(tt *testing.T) {
	tt.Parallel()
	a := &Alert{}
	a.GetTool()
	a = nil
	a.GetTool()
}

func TestAlert_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	a := &Alert{UpdatedAt: &zeroValue}
	a.GetUpdatedAt()
	a = &Alert{}
	a.GetUpdatedAt()
	a = nil
	a.GetUpdatedAt()
}

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

func TestAlertInstancesListOptions_GetRef(tt *testing.T) {
	tt.Parallel()
	a := &AlertInstancesListOptions{}
	a.GetRef()
	a = nil
	a.GetRef()
}

func TestAlertListOptions_GetDirection(tt *testing.T) {
	tt.Parallel()
	a := &AlertListOptions{}
	a.GetDirection()
	a = nil
	a.GetDirection()
}

func TestAlertListOptions_GetRef(tt *testing.T) {
	tt.Parallel()
	a := &AlertListOptions{}
	a.GetRef()
	a = nil
	a.GetRef()
}

func TestAlertListOptions_GetSeverity(tt *testing.T) {
	tt.Parallel()
	a := &AlertListOptions{}
	a.GetSeverity()
	a = nil
	a.GetSeverity()
}

func TestAlertListOptions_GetSort(tt *testing.T) {
	tt.Parallel()
	a := &AlertListOptions{}
	a.GetSort()
	a = nil
	a.GetSort()
}

func TestAlertListOptions_GetState(tt *testing.T) {
	tt.Parallel()
	a := &AlertListOptions{}
	a.GetState()
	a = nil
	a.GetState()
}

func TestAlertListOptions_GetToolGUID(tt *testing.T) {
	tt.Parallel()
	a := &AlertListOptions{}
	a.GetToolGUID()
	a = nil
	a.GetToolGUID()
}

func TestAlertListOptions_GetToolName(tt *testing.T) {
	tt.Parallel()
	a := &AlertListOptions{}
	a.GetToolName()
	a = nil
	a.GetToolName()
}

func TestAllowDeletions_GetEnabled(tt *testing.T) {
	tt.Parallel()
	a := &AllowDeletions{}
	a.GetEnabled()
	a = nil
	a.GetEnabled()
}

func TestAllowDeletionsEnforcementLevelChanges_GetFrom(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &AllowDeletionsEnforcementLevelChanges{From: &zeroValue}
	a.GetFrom()
	a = &AllowDeletionsEnforcementLevelChanges{}
	a.GetFrom()
	a = nil
	a.GetFrom()
}

func TestAllowForcePushes_GetEnabled(tt *testing.T) {
	tt.Parallel()
	a := &AllowForcePushes{}
	a.GetEnabled()
	a = nil
	a.GetEnabled()
}

func TestAllowForkSyncing_GetEnabled(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	a := &AllowForkSyncing{Enabled: &zeroValue}
	a.GetEnabled()
	a = &AllowForkSyncing{}
	a.GetEnabled()
	a = nil
	a.GetEnabled()
}

func TestAmazonS3AccessKeysConfig_GetAuthenticationType(tt *testing.T) {
	tt.Parallel()
	a := &AmazonS3AccessKeysConfig{}
	a.GetAuthenticationType()
	a = nil
	a.GetAuthenticationType()
}

func TestAmazonS3AccessKeysConfig_GetBucket(tt *testing.T) {
	tt.Parallel()
	a := &AmazonS3AccessKeysConfig{}
	a.GetBucket()
	a = nil
	a.GetBucket()
}

func TestAmazonS3AccessKeysConfig_GetEncryptedAccessKeyID(tt *testing.T) {
	tt.Parallel()
	a := &AmazonS3AccessKeysConfig{}
	a.GetEncryptedAccessKeyID()
	a = nil
	a.GetEncryptedAccessKeyID()
}

func TestAmazonS3AccessKeysConfig_GetEncryptedSecretKey(tt *testing.T) {
	tt.Parallel()
	a := &AmazonS3AccessKeysConfig{}
	a.GetEncryptedSecretKey()
	a = nil
	a.GetEncryptedSecretKey()
}

func TestAmazonS3AccessKeysConfig_GetKeyID(tt *testing.T) {
	tt.Parallel()
	a := &AmazonS3AccessKeysConfig{}
	a.GetKeyID()
	a = nil
	a.GetKeyID()
}

func TestAmazonS3AccessKeysConfig_GetRegion(tt *testing.T) {
	tt.Parallel()
	a := &AmazonS3AccessKeysConfig{}
	a.GetRegion()
	a = nil
	a.GetRegion()
}

func TestAmazonS3OIDCConfig_GetArnRole(tt *testing.T) {
	tt.Parallel()
	a := &AmazonS3OIDCConfig{}
	a.GetArnRole()
	a = nil
	a.GetArnRole()
}

func TestAmazonS3OIDCConfig_GetAuthenticationType(tt *testing.T) {
	tt.Parallel()
	a := &AmazonS3OIDCConfig{}
	a.GetAuthenticationType()
	a = nil
	a.GetAuthenticationType()
}

func TestAmazonS3OIDCConfig_GetBucket(tt *testing.T) {
	tt.Parallel()
	a := &AmazonS3OIDCConfig{}
	a.GetBucket()
	a = nil
	a.GetBucket()
}

func TestAmazonS3OIDCConfig_GetKeyID(tt *testing.T) {
	tt.Parallel()
	a := &AmazonS3OIDCConfig{}
	a.GetKeyID()
	a = nil
	a.GetKeyID()
}

func TestAmazonS3OIDCConfig_GetRegion(tt *testing.T) {
	tt.Parallel()
	a := &AmazonS3OIDCConfig{}
	a.GetRegion()
	a = nil
	a.GetRegion()
}

func TestAnalysesListOptions_GetRef(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &AnalysesListOptions{Ref: &zeroValue}
	a.GetRef()
	a = &AnalysesListOptions{}
	a.GetRef()
	a = nil
	a.GetRef()
}

func TestAnalysesListOptions_GetSarifID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &AnalysesListOptions{SarifID: &zeroValue}
	a.GetSarifID()
	a = &AnalysesListOptions{}
	a.GetSarifID()
	a = nil
	a.GetSarifID()
}

func TestAPIMeta_GetActions(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	a := &APIMeta{Actions: zeroValue}
	a.GetActions()
	a = &APIMeta{}
	a.GetActions()
	a = nil
	a.GetActions()
}

func TestAPIMeta_GetActionsMacos(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	a := &APIMeta{ActionsMacos: zeroValue}
	a.GetActionsMacos()
	a = &APIMeta{}
	a.GetActionsMacos()
	a = nil
	a.GetActionsMacos()
}

func TestAPIMeta_GetAPI(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	a := &APIMeta{API: zeroValue}
	a.GetAPI()
	a = &APIMeta{}
	a.GetAPI()
	a = nil
	a.GetAPI()
}

func TestAPIMeta_GetCodespaces(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	a := &APIMeta{Codespaces: zeroValue}
	a.GetCodespaces()
	a = &APIMeta{}
	a.GetCodespaces()
	a = nil
	a.GetCodespaces()
}

func TestAPIMeta_GetCopilot(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	a := &APIMeta{Copilot: zeroValue}
	a.GetCopilot()
	a = &APIMeta{}
	a.GetCopilot()
	a = nil
	a.GetCopilot()
}

func TestAPIMeta_GetDependabot(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	a := &APIMeta{Dependabot: zeroValue}
	a.GetDependabot()
	a = &APIMeta{}
	a.GetDependabot()
	a = nil
	a.GetDependabot()
}

func TestAPIMeta_GetDomains(tt *testing.T) {
	tt.Parallel()
	a := &APIMeta{}
	a.GetDomains()
	a = nil
	a.GetDomains()
}

func TestAPIMeta_GetGit(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	a := &APIMeta{Git: zeroValue}
	a.GetGit()
	a = &APIMeta{}
	a.GetGit()
	a = nil
	a.GetGit()
}

func TestAPIMeta_GetGithubEnterpriseImporter(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	a := &APIMeta{GithubEnterpriseImporter: zeroValue}
	a.GetGithubEnterpriseImporter()
	a = &APIMeta{}
	a.GetGithubEnterpriseImporter()
	a = nil
	a.GetGithubEnterpriseImporter()
}

func TestAPIMeta_GetHooks(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	a := &APIMeta{Hooks: zeroValue}
	a.GetHooks()
	a = &APIMeta{}
	a.GetHooks()
	a = nil
	a.GetHooks()
}

func TestAPIMeta_GetImporter(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	a := &APIMeta{Importer: zeroValue}
	a.GetImporter()
	a = &APIMeta{}
	a.GetImporter()
	a = nil
	a.GetImporter()
}

func TestAPIMeta_GetPackages(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	a := &APIMeta{Packages: zeroValue}
	a.GetPackages()
	a = &APIMeta{}
	a.GetPackages()
	a = nil
	a.GetPackages()
}

func TestAPIMeta_GetPages(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	a := &APIMeta{Pages: zeroValue}
	a.GetPages()
	a = &APIMeta{}
	a.GetPages()
	a = nil
	a.GetPages()
}

func TestAPIMeta_GetSSHKeyFingerprints(tt *testing.T) {
	tt.Parallel()
	zeroValue := map[string]string{}
	a := &APIMeta{SSHKeyFingerprints: zeroValue}
	a.GetSSHKeyFingerprints()
	a = &APIMeta{}
	a.GetSSHKeyFingerprints()
	a = nil
	a.GetSSHKeyFingerprints()
}

func TestAPIMeta_GetSSHKeys(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	a := &APIMeta{SSHKeys: zeroValue}
	a.GetSSHKeys()
	a = &APIMeta{}
	a.GetSSHKeys()
	a = nil
	a.GetSSHKeys()
}

func TestAPIMeta_GetVerifiablePasswordAuthentication(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	a := &APIMeta{VerifiablePasswordAuthentication: &zeroValue}
	a.GetVerifiablePasswordAuthentication()
	a = &APIMeta{}
	a.GetVerifiablePasswordAuthentication()
	a = nil
	a.GetVerifiablePasswordAuthentication()
}

func TestAPIMeta_GetWeb(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	a := &APIMeta{Web: zeroValue}
	a.GetWeb()
	a = &APIMeta{}
	a.GetWeb()
	a = nil
	a.GetWeb()
}

func TestAPIMetaArtifactAttestations_GetServices(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	a := &APIMetaArtifactAttestations{Services: zeroValue}
	a.GetServices()
	a = &APIMetaArtifactAttestations{}
	a.GetServices()
	a = nil
	a.GetServices()
}

func TestAPIMetaArtifactAttestations_GetTrustDomain(tt *testing.T) {
	tt.Parallel()
	a := &APIMetaArtifactAttestations{}
	a.GetTrustDomain()
	a = nil
	a.GetTrustDomain()
}

func TestAPIMetaDomains_GetActions(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	a := &APIMetaDomains{Actions: zeroValue}
	a.GetActions()
	a = &APIMetaDomains{}
	a.GetActions()
	a = nil
	a.GetActions()
}

func TestAPIMetaDomains_GetActionsInbound(tt *testing.T) {
	tt.Parallel()
	a := &APIMetaDomains{}
	a.GetActionsInbound()
	a = nil
	a.GetActionsInbound()
}

func TestAPIMetaDomains_GetArtifactAttestations(tt *testing.T) {
	tt.Parallel()
	a := &APIMetaDomains{}
	a.GetArtifactAttestations()
	a = nil
	a.GetArtifactAttestations()
}

func TestAPIMetaDomains_GetCodespaces(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	a := &APIMetaDomains{Codespaces: zeroValue}
	a.GetCodespaces()
	a = &APIMetaDomains{}
	a.GetCodespaces()
	a = nil
	a.GetCodespaces()
}

func TestAPIMetaDomains_GetCopilot(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	a := &APIMetaDomains{Copilot: zeroValue}
	a.GetCopilot()
	a = &APIMetaDomains{}
	a.GetCopilot()
	a = nil
	a.GetCopilot()
}

func TestAPIMetaDomains_GetPackages(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	a := &APIMetaDomains{Packages: zeroValue}
	a.GetPackages()
	a = &APIMetaDomains{}
	a.GetPackages()
	a = nil
	a.GetPackages()
}

func TestAPIMetaDomains_GetWebsite(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	a := &APIMetaDomains{Website: zeroValue}
	a.GetWebsite()
	a = &APIMetaDomains{}
	a.GetWebsite()
	a = nil
	a.GetWebsite()
}

func TestApp_GetClientID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &App{ClientID: &zeroValue}
	a.GetClientID()
	a = &App{}
	a.GetClientID()
	a = nil
	a.GetClientID()
}

func TestApp_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	a := &App{CreatedAt: &zeroValue}
	a.GetCreatedAt()
	a = &App{}
	a.GetCreatedAt()
	a = nil
	a.GetCreatedAt()
}

func TestApp_GetDescription(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &App{Description: &zeroValue}
	a.GetDescription()
	a = &App{}
	a.GetDescription()
	a = nil
	a.GetDescription()
}

func TestApp_GetEvents(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	a := &App{Events: zeroValue}
	a.GetEvents()
	a = &App{}
	a.GetEvents()
	a = nil
	a.GetEvents()
}

func TestApp_GetExternalURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &App{ExternalURL: &zeroValue}
	a.GetExternalURL()
	a = &App{}
	a.GetExternalURL()
	a = nil
	a.GetExternalURL()
}

func TestApp_GetHTMLURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &App{HTMLURL: &zeroValue}
	a.GetHTMLURL()
	a = &App{}
	a.GetHTMLURL()
	a = nil
	a.GetHTMLURL()
}

func TestApp_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	a := &App{ID: &zeroValue}
	a.GetID()
	a = &App{}
	a.GetID()
	a = nil
	a.GetID()
}

func TestApp_GetInstallationsCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	a := &App{InstallationsCount: &zeroValue}
	a.GetInstallationsCount()
	a = &App{}
	a.GetInstallationsCount()
	a = nil
	a.GetInstallationsCount()
}

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

func TestApp_GetNodeID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &App{NodeID: &zeroValue}
	a.GetNodeID()
	a = &App{}
	a.GetNodeID()
	a = nil
	a.GetNodeID()
}

func TestApp_GetOwner(tt *testing.T) {
	tt.Parallel()
	a := &App{}
	a.GetOwner()
	a = nil
	a.GetOwner()
}

func TestApp_GetPermissions(tt *testing.T) {
	tt.Parallel()
	a := &App{}
	a.GetPermissions()
	a = nil
	a.GetPermissions()
}

func TestApp_GetSlug(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &App{Slug: &zeroValue}
	a.GetSlug()
	a = &App{}
	a.GetSlug()
	a = nil
	a.GetSlug()
}

func TestApp_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	a := &App{UpdatedAt: &zeroValue}
	a.GetUpdatedAt()
	a = &App{}
	a.GetUpdatedAt()
	a = nil
	a.GetUpdatedAt()
}

func TestAppConfig_GetClientID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &AppConfig{ClientID: &zeroValue}
	a.GetClientID()
	a = &AppConfig{}
	a.GetClientID()
	a = nil
	a.GetClientID()
}

func TestAppConfig_GetClientSecret(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &AppConfig{ClientSecret: &zeroValue}
	a.GetClientSecret()
	a = &AppConfig{}
	a.GetClientSecret()
	a = nil
	a.GetClientSecret()
}

func TestAppConfig_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	a := &AppConfig{CreatedAt: &zeroValue}
	a.GetCreatedAt()
	a = &AppConfig{}
	a.GetCreatedAt()
	a = nil
	a.GetCreatedAt()
}

func TestAppConfig_GetDescription(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &AppConfig{Description: &zeroValue}
	a.GetDescription()
	a = &AppConfig{}
	a.GetDescription()
	a = nil
	a.GetDescription()
}

func TestAppConfig_GetExternalURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &AppConfig{ExternalURL: &zeroValue}
	a.GetExternalURL()
	a = &AppConfig{}
	a.GetExternalURL()
	a = nil
	a.GetExternalURL()
}

func TestAppConfig_GetHTMLURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &AppConfig{HTMLURL: &zeroValue}
	a.GetHTMLURL()
	a = &AppConfig{}
	a.GetHTMLURL()
	a = nil
	a.GetHTMLURL()
}

func TestAppConfig_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	a := &AppConfig{ID: &zeroValue}
	a.GetID()
	a = &AppConfig{}
	a.GetID()
	a = nil
	a.GetID()
}

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

func TestAppConfig_GetNodeID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &AppConfig{NodeID: &zeroValue}
	a.GetNodeID()
	a = &AppConfig{}
	a.GetNodeID()
	a = nil
	a.GetNodeID()
}

func TestAppConfig_GetOwner(tt *testing.T) {
	tt.Parallel()
	a := &AppConfig{}
	a.GetOwner()
	a = nil
	a.GetOwner()
}

func TestAppConfig_GetPEM(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &AppConfig{PEM: &zeroValue}
	a.GetPEM()
	a = &AppConfig{}
	a.GetPEM()
	a = nil
	a.GetPEM()
}

func TestAppConfig_GetSlug(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &AppConfig{Slug: &zeroValue}
	a.GetSlug()
	a = &AppConfig{}
	a.GetSlug()
	a = nil
	a.GetSlug()
}

func TestAppConfig_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	a := &AppConfig{UpdatedAt: &zeroValue}
	a.GetUpdatedAt()
	a = &AppConfig{}
	a.GetUpdatedAt()
	a = nil
	a.GetUpdatedAt()
}

func TestAppConfig_GetWebhookSecret(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &AppConfig{WebhookSecret: &zeroValue}
	a.GetWebhookSecret()
	a = &AppConfig{}
	a.GetWebhookSecret()
	a = nil
	a.GetWebhookSecret()
}

func TestAppInstallationRepositoriesRequest_GetRepositories(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	a := &AppInstallationRepositoriesRequest{Repositories: zeroValue}
	a.GetRepositories()
	a = &AppInstallationRepositoriesRequest{}
	a.GetRepositories()
	a = nil
	a.GetRepositories()
}

func TestArchivedAt_GetFrom(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	a := &ArchivedAt{From: &zeroValue}
	a.GetFrom()
	a = &ArchivedAt{}
	a.GetFrom()
	a = nil
	a.GetFrom()
}

func TestArchivedAt_GetTo(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	a := &ArchivedAt{To: &zeroValue}
	a.GetTo()
	a = &ArchivedAt{}
	a.GetTo()
	a = nil
	a.GetTo()
}

func TestArtifact_GetArchiveDownloadURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &Artifact{ArchiveDownloadURL: &zeroValue}
	a.GetArchiveDownloadURL()
	a = &Artifact{}
	a.GetArchiveDownloadURL()
	a = nil
	a.GetArchiveDownloadURL()
}

func TestArtifact_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	a := &Artifact{CreatedAt: &zeroValue}
	a.GetCreatedAt()
	a = &Artifact{}
	a.GetCreatedAt()
	a = nil
	a.GetCreatedAt()
}

func TestArtifact_GetDigest(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &Artifact{Digest: &zeroValue}
	a.GetDigest()
	a = &Artifact{}
	a.GetDigest()
	a = nil
	a.GetDigest()
}

func TestArtifact_GetExpired(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	a := &Artifact{Expired: &zeroValue}
	a.GetExpired()
	a = &Artifact{}
	a.GetExpired()
	a = nil
	a.GetExpired()
}

func TestArtifact_GetExpiresAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	a := &Artifact{ExpiresAt: &zeroValue}
	a.GetExpiresAt()
	a = &Artifact{}
	a.GetExpiresAt()
	a = nil
	a.GetExpiresAt()
}

func TestArtifact_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	a := &Artifact{ID: &zeroValue}
	a.GetID()
	a = &Artifact{}
	a.GetID()
	a = nil
	a.GetID()
}

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

func TestArtifact_GetNodeID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &Artifact{NodeID: &zeroValue}
	a.GetNodeID()
	a = &Artifact{}
	a.GetNodeID()
	a = nil
	a.GetNodeID()
}

func TestArtifact_GetSizeInBytes(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	a := &Artifact{SizeInBytes: &zeroValue}
	a.GetSizeInBytes()
	a = &Artifact{}
	a.GetSizeInBytes()
	a = nil
	a.GetSizeInBytes()
}

func TestArtifact_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	a := &Artifact{UpdatedAt: &zeroValue}
	a.GetUpdatedAt()
	a = &Artifact{}
	a.GetUpdatedAt()
	a = nil
	a.GetUpdatedAt()
}

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

func TestArtifact_GetWorkflowRun(tt *testing.T) {
	tt.Parallel()
	a := &Artifact{}
	a.GetWorkflowRun()
	a = nil
	a.GetWorkflowRun()
}

func TestArtifactDeploymentRecord_GetAttestationID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	a := &ArtifactDeploymentRecord{AttestationID: &zeroValue}
	a.GetAttestationID()
	a = &ArtifactDeploymentRecord{}
	a.GetAttestationID()
	a = nil
	a.GetAttestationID()
}

func TestArtifactDeploymentRecord_GetCluster(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &ArtifactDeploymentRecord{Cluster: &zeroValue}
	a.GetCluster()
	a = &ArtifactDeploymentRecord{}
	a.GetCluster()
	a = nil
	a.GetCluster()
}

func TestArtifactDeploymentRecord_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	a := &ArtifactDeploymentRecord{CreatedAt: &zeroValue}
	a.GetCreatedAt()
	a = &ArtifactDeploymentRecord{}
	a.GetCreatedAt()
	a = nil
	a.GetCreatedAt()
}

func TestArtifactDeploymentRecord_GetDeploymentName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &ArtifactDeploymentRecord{DeploymentName: &zeroValue}
	a.GetDeploymentName()
	a = &ArtifactDeploymentRecord{}
	a.GetDeploymentName()
	a = nil
	a.GetDeploymentName()
}

func TestArtifactDeploymentRecord_GetDigest(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &ArtifactDeploymentRecord{Digest: &zeroValue}
	a.GetDigest()
	a = &ArtifactDeploymentRecord{}
	a.GetDigest()
	a = nil
	a.GetDigest()
}

func TestArtifactDeploymentRecord_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	a := &ArtifactDeploymentRecord{ID: &zeroValue}
	a.GetID()
	a = &ArtifactDeploymentRecord{}
	a.GetID()
	a = nil
	a.GetID()
}

func TestArtifactDeploymentRecord_GetLogicalEnvironment(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &ArtifactDeploymentRecord{LogicalEnvironment: &zeroValue}
	a.GetLogicalEnvironment()
	a = &ArtifactDeploymentRecord{}
	a.GetLogicalEnvironment()
	a = nil
	a.GetLogicalEnvironment()
}

func TestArtifactDeploymentRecord_GetPhysicalEnvironment(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &ArtifactDeploymentRecord{PhysicalEnvironment: &zeroValue}
	a.GetPhysicalEnvironment()
	a = &ArtifactDeploymentRecord{}
	a.GetPhysicalEnvironment()
	a = nil
	a.GetPhysicalEnvironment()
}

func TestArtifactDeploymentRecord_GetRuntimeRisks(tt *testing.T) {
	tt.Parallel()
	zeroValue := []DeploymentRuntimeRisk{}
	a := &ArtifactDeploymentRecord{RuntimeRisks: zeroValue}
	a.GetRuntimeRisks()
	a = &ArtifactDeploymentRecord{}
	a.GetRuntimeRisks()
	a = nil
	a.GetRuntimeRisks()
}

func TestArtifactDeploymentRecord_GetTags(tt *testing.T) {
	tt.Parallel()
	zeroValue := map[string]string{}
	a := &ArtifactDeploymentRecord{Tags: zeroValue}
	a.GetTags()
	a = &ArtifactDeploymentRecord{}
	a.GetTags()
	a = nil
	a.GetTags()
}

func TestArtifactDeploymentRecord_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	a := &ArtifactDeploymentRecord{UpdatedAt: &zeroValue}
	a.GetUpdatedAt()
	a = &ArtifactDeploymentRecord{}
	a.GetUpdatedAt()
	a = nil
	a.GetUpdatedAt()
}

func TestArtifactDeploymentResponse_GetDeploymentRecords(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*ArtifactDeploymentRecord{}
	a := &ArtifactDeploymentResponse{DeploymentRecords: zeroValue}
	a.GetDeploymentRecords()
	a = &ArtifactDeploymentResponse{}
	a.GetDeploymentRecords()
	a = nil
	a.GetDeploymentRecords()
}

func TestArtifactDeploymentResponse_GetTotalCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	a := &ArtifactDeploymentResponse{TotalCount: &zeroValue}
	a.GetTotalCount()
	a = &ArtifactDeploymentResponse{}
	a.GetTotalCount()
	a = nil
	a.GetTotalCount()
}

func TestArtifactList_GetArtifacts(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*Artifact{}
	a := &ArtifactList{Artifacts: zeroValue}
	a.GetArtifacts()
	a = &ArtifactList{}
	a.GetArtifacts()
	a = nil
	a.GetArtifacts()
}

func TestArtifactList_GetTotalCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	a := &ArtifactList{TotalCount: &zeroValue}
	a.GetTotalCount()
	a = &ArtifactList{}
	a.GetTotalCount()
	a = nil
	a.GetTotalCount()
}

func TestArtifactPeriod_GetDays(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	a := &ArtifactPeriod{Days: &zeroValue}
	a.GetDays()
	a = &ArtifactPeriod{}
	a.GetDays()
	a = nil
	a.GetDays()
}

func TestArtifactPeriod_GetMaximumAllowedDays(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	a := &ArtifactPeriod{MaximumAllowedDays: &zeroValue}
	a.GetMaximumAllowedDays()
	a = &ArtifactPeriod{}
	a.GetMaximumAllowedDays()
	a = nil
	a.GetMaximumAllowedDays()
}

func TestArtifactPeriodOpt_GetDays(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	a := &ArtifactPeriodOpt{Days: &zeroValue}
	a.GetDays()
	a = &ArtifactPeriodOpt{}
	a.GetDays()
	a = nil
	a.GetDays()
}

func TestArtifactStorageRecord_GetArtifactURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &ArtifactStorageRecord{ArtifactURL: &zeroValue}
	a.GetArtifactURL()
	a = &ArtifactStorageRecord{}
	a.GetArtifactURL()
	a = nil
	a.GetArtifactURL()
}

func TestArtifactStorageRecord_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	a := &ArtifactStorageRecord{CreatedAt: &zeroValue}
	a.GetCreatedAt()
	a = &ArtifactStorageRecord{}
	a.GetCreatedAt()
	a = nil
	a.GetCreatedAt()
}

func TestArtifactStorageRecord_GetDigest(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &ArtifactStorageRecord{Digest: &zeroValue}
	a.GetDigest()
	a = &ArtifactStorageRecord{}
	a.GetDigest()
	a = nil
	a.GetDigest()
}

func TestArtifactStorageRecord_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	a := &ArtifactStorageRecord{ID: &zeroValue}
	a.GetID()
	a = &ArtifactStorageRecord{}
	a.GetID()
	a = nil
	a.GetID()
}

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

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

func TestArtifactStorageRecord_GetRepository(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &ArtifactStorageRecord{Repository: &zeroValue}
	a.GetRepository()
	a = &ArtifactStorageRecord{}
	a.GetRepository()
	a = nil
	a.GetRepository()
}

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

func TestArtifactStorageRecord_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	a := &ArtifactStorageRecord{UpdatedAt: &zeroValue}
	a.GetUpdatedAt()
	a = &ArtifactStorageRecord{}
	a.GetUpdatedAt()
	a = nil
	a.GetUpdatedAt()
}

func TestArtifactStorageResponse_GetStorageRecords(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*ArtifactStorageRecord{}
	a := &ArtifactStorageResponse{StorageRecords: zeroValue}
	a.GetStorageRecords()
	a = &ArtifactStorageResponse{}
	a.GetStorageRecords()
	a = nil
	a.GetStorageRecords()
}

func TestArtifactStorageResponse_GetTotalCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	a := &ArtifactStorageResponse{TotalCount: &zeroValue}
	a.GetTotalCount()
	a = &ArtifactStorageResponse{}
	a.GetTotalCount()
	a = nil
	a.GetTotalCount()
}

func TestArtifactWorkflowRun_GetHeadBranch(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &ArtifactWorkflowRun{HeadBranch: &zeroValue}
	a.GetHeadBranch()
	a = &ArtifactWorkflowRun{}
	a.GetHeadBranch()
	a = nil
	a.GetHeadBranch()
}

func TestArtifactWorkflowRun_GetHeadRepositoryID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	a := &ArtifactWorkflowRun{HeadRepositoryID: &zeroValue}
	a.GetHeadRepositoryID()
	a = &ArtifactWorkflowRun{}
	a.GetHeadRepositoryID()
	a = nil
	a.GetHeadRepositoryID()
}

func TestArtifactWorkflowRun_GetHeadSHA(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &ArtifactWorkflowRun{HeadSHA: &zeroValue}
	a.GetHeadSHA()
	a = &ArtifactWorkflowRun{}
	a.GetHeadSHA()
	a = nil
	a.GetHeadSHA()
}

func TestArtifactWorkflowRun_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	a := &ArtifactWorkflowRun{ID: &zeroValue}
	a.GetID()
	a = &ArtifactWorkflowRun{}
	a.GetID()
	a = nil
	a.GetID()
}

func TestArtifactWorkflowRun_GetRepositoryID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	a := &ArtifactWorkflowRun{RepositoryID: &zeroValue}
	a.GetRepositoryID()
	a = &ArtifactWorkflowRun{}
	a.GetRepositoryID()
	a = nil
	a.GetRepositoryID()
}

func TestAssignmentGrade_GetAssignmentName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &AssignmentGrade{AssignmentName: &zeroValue}
	a.GetAssignmentName()
	a = &AssignmentGrade{}
	a.GetAssignmentName()
	a = nil
	a.GetAssignmentName()
}

func TestAssignmentGrade_GetAssignmentURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &AssignmentGrade{AssignmentURL: &zeroValue}
	a.GetAssignmentURL()
	a = &AssignmentGrade{}
	a.GetAssignmentURL()
	a = nil
	a.GetAssignmentURL()
}

func TestAssignmentGrade_GetGithubUsername(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &AssignmentGrade{GithubUsername: &zeroValue}
	a.GetGithubUsername()
	a = &AssignmentGrade{}
	a.GetGithubUsername()
	a = nil
	a.GetGithubUsername()
}

func TestAssignmentGrade_GetGroupName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &AssignmentGrade{GroupName: &zeroValue}
	a.GetGroupName()
	a = &AssignmentGrade{}
	a.GetGroupName()
	a = nil
	a.GetGroupName()
}

func TestAssignmentGrade_GetPointsAvailable(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	a := &AssignmentGrade{PointsAvailable: &zeroValue}
	a.GetPointsAvailable()
	a = &AssignmentGrade{}
	a.GetPointsAvailable()
	a = nil
	a.GetPointsAvailable()
}

func TestAssignmentGrade_GetPointsAwarded(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	a := &AssignmentGrade{PointsAwarded: &zeroValue}
	a.GetPointsAwarded()
	a = &AssignmentGrade{}
	a.GetPointsAwarded()
	a = nil
	a.GetPointsAwarded()
}

func TestAssignmentGrade_GetRosterIdentifier(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &AssignmentGrade{RosterIdentifier: &zeroValue}
	a.GetRosterIdentifier()
	a = &AssignmentGrade{}
	a.GetRosterIdentifier()
	a = nil
	a.GetRosterIdentifier()
}

func TestAssignmentGrade_GetStarterCodeURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &AssignmentGrade{StarterCodeURL: &zeroValue}
	a.GetStarterCodeURL()
	a = &AssignmentGrade{}
	a.GetStarterCodeURL()
	a = nil
	a.GetStarterCodeURL()
}

func TestAssignmentGrade_GetStudentRepositoryName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &AssignmentGrade{StudentRepositoryName: &zeroValue}
	a.GetStudentRepositoryName()
	a = &AssignmentGrade{}
	a.GetStudentRepositoryName()
	a = nil
	a.GetStudentRepositoryName()
}

func TestAssignmentGrade_GetStudentRepositoryURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &AssignmentGrade{StudentRepositoryURL: &zeroValue}
	a.GetStudentRepositoryURL()
	a = &AssignmentGrade{}
	a.GetStudentRepositoryURL()
	a = nil
	a.GetStudentRepositoryURL()
}

func TestAssignmentGrade_GetSubmissionTimestamp(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	a := &AssignmentGrade{SubmissionTimestamp: &zeroValue}
	a.GetSubmissionTimestamp()
	a = &AssignmentGrade{}
	a.GetSubmissionTimestamp()
	a = nil
	a.GetSubmissionTimestamp()
}

func TestAttachment_GetBody(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &Attachment{Body: &zeroValue}
	a.GetBody()
	a = &Attachment{}
	a.GetBody()
	a = nil
	a.GetBody()
}

func TestAttachment_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	a := &Attachment{ID: &zeroValue}
	a.GetID()
	a = &Attachment{}
	a.GetID()
	a = nil
	a.GetID()
}

func TestAttachment_GetTitle(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &Attachment{Title: &zeroValue}
	a.GetTitle()
	a = &Attachment{}
	a.GetTitle()
	a = nil
	a.GetTitle()
}

func TestAttestation_GetBundle(tt *testing.T) {
	tt.Parallel()
	a := &Attestation{}
	a.GetBundle()
	a = nil
	a.GetBundle()
}

func TestAttestation_GetRepositoryID(tt *testing.T) {
	tt.Parallel()
	a := &Attestation{}
	a.GetRepositoryID()
	a = nil
	a.GetRepositoryID()
}

func TestAttestationsResponse_GetAttestations(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*Attestation{}
	a := &AttestationsResponse{Attestations: zeroValue}
	a.GetAttestations()
	a = &AttestationsResponse{}
	a.GetAttestations()
	a = nil
	a.GetAttestations()
}

func TestAuditEntry_GetAction(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &AuditEntry{Action: &zeroValue}
	a.GetAction()
	a = &AuditEntry{}
	a.GetAction()
	a = nil
	a.GetAction()
}

func TestAuditEntry_GetActor(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &AuditEntry{Actor: &zeroValue}
	a.GetActor()
	a = &AuditEntry{}
	a.GetActor()
	a = nil
	a.GetActor()
}

func TestAuditEntry_GetActorID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	a := &AuditEntry{ActorID: &zeroValue}
	a.GetActorID()
	a = &AuditEntry{}
	a.GetActorID()
	a = nil
	a.GetActorID()
}

func TestAuditEntry_GetActorLocation(tt *testing.T) {
	tt.Parallel()
	a := &AuditEntry{}
	a.GetActorLocation()
	a = nil
	a.GetActorLocation()
}

func TestAuditEntry_GetAdditionalFields(tt *testing.T) {
	tt.Parallel()
	zeroValue := map[string]any{}
	a := &AuditEntry{AdditionalFields: zeroValue}
	a.GetAdditionalFields()
	a = &AuditEntry{}
	a.GetAdditionalFields()
	a = nil
	a.GetAdditionalFields()
}

func TestAuditEntry_GetBusiness(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &AuditEntry{Business: &zeroValue}
	a.GetBusiness()
	a = &AuditEntry{}
	a.GetBusiness()
	a = nil
	a.GetBusiness()
}

func TestAuditEntry_GetBusinessID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	a := &AuditEntry{BusinessID: &zeroValue}
	a.GetBusinessID()
	a = &AuditEntry{}
	a.GetBusinessID()
	a = nil
	a.GetBusinessID()
}

func TestAuditEntry_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	a := &AuditEntry{CreatedAt: &zeroValue}
	a.GetCreatedAt()
	a = &AuditEntry{}
	a.GetCreatedAt()
	a = nil
	a.GetCreatedAt()
}

func TestAuditEntry_GetData(tt *testing.T) {
	tt.Parallel()
	zeroValue := map[string]any{}
	a := &AuditEntry{Data: zeroValue}
	a.GetData()
	a = &AuditEntry{}
	a.GetData()
	a = nil
	a.GetData()
}

func TestAuditEntry_GetDocumentID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &AuditEntry{DocumentID: &zeroValue}
	a.GetDocumentID()
	a = &AuditEntry{}
	a.GetDocumentID()
	a = nil
	a.GetDocumentID()
}

func TestAuditEntry_GetExternalIdentityNameID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &AuditEntry{ExternalIdentityNameID: &zeroValue}
	a.GetExternalIdentityNameID()
	a = &AuditEntry{}
	a.GetExternalIdentityNameID()
	a = nil
	a.GetExternalIdentityNameID()
}

func TestAuditEntry_GetExternalIdentityUsername(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &AuditEntry{ExternalIdentityUsername: &zeroValue}
	a.GetExternalIdentityUsername()
	a = &AuditEntry{}
	a.GetExternalIdentityUsername()
	a = nil
	a.GetExternalIdentityUsername()
}

func TestAuditEntry_GetHashedToken(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &AuditEntry{HashedToken: &zeroValue}
	a.GetHashedToken()
	a = &AuditEntry{}
	a.GetHashedToken()
	a = nil
	a.GetHashedToken()
}

func TestAuditEntry_GetOrg(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &AuditEntry{Org: &zeroValue}
	a.GetOrg()
	a = &AuditEntry{}
	a.GetOrg()
	a = nil
	a.GetOrg()
}

func TestAuditEntry_GetOrgID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	a := &AuditEntry{OrgID: &zeroValue}
	a.GetOrgID()
	a = &AuditEntry{}
	a.GetOrgID()
	a = nil
	a.GetOrgID()
}

func TestAuditEntry_GetTimestamp(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	a := &AuditEntry{Timestamp: &zeroValue}
	a.GetTimestamp()
	a = &AuditEntry{}
	a.GetTimestamp()
	a = nil
	a.GetTimestamp()
}

func TestAuditEntry_GetTokenID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	a := &AuditEntry{TokenID: &zeroValue}
	a.GetTokenID()
	a = &AuditEntry{}
	a.GetTokenID()
	a = nil
	a.GetTokenID()
}

func TestAuditEntry_GetTokenScopes(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &AuditEntry{TokenScopes: &zeroValue}
	a.GetTokenScopes()
	a = &AuditEntry{}
	a.GetTokenScopes()
	a = nil
	a.GetTokenScopes()
}

func TestAuditEntry_GetUser(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &AuditEntry{User: &zeroValue}
	a.GetUser()
	a = &AuditEntry{}
	a.GetUser()
	a = nil
	a.GetUser()
}

func TestAuditEntry_GetUserID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	a := &AuditEntry{UserID: &zeroValue}
	a.GetUserID()
	a = &AuditEntry{}
	a.GetUserID()
	a = nil
	a.GetUserID()
}

func TestAuditLogStream_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	a := &AuditLogStream{}
	a.GetCreatedAt()
	a = nil
	a.GetCreatedAt()
}

func TestAuditLogStream_GetEnabled(tt *testing.T) {
	tt.Parallel()
	a := &AuditLogStream{}
	a.GetEnabled()
	a = nil
	a.GetEnabled()
}

func TestAuditLogStream_GetID(tt *testing.T) {
	tt.Parallel()
	a := &AuditLogStream{}
	a.GetID()
	a = nil
	a.GetID()
}

func TestAuditLogStream_GetPausedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	a := &AuditLogStream{PausedAt: &zeroValue}
	a.GetPausedAt()
	a = &AuditLogStream{}
	a.GetPausedAt()
	a = nil
	a.GetPausedAt()
}

func TestAuditLogStream_GetStreamDetails(tt *testing.T) {
	tt.Parallel()
	a := &AuditLogStream{}
	a.GetStreamDetails()
	a = nil
	a.GetStreamDetails()
}

func TestAuditLogStream_GetStreamType(tt *testing.T) {
	tt.Parallel()
	a := &AuditLogStream{}
	a.GetStreamType()
	a = nil
	a.GetStreamType()
}

func TestAuditLogStream_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	a := &AuditLogStream{}
	a.GetUpdatedAt()
	a = nil
	a.GetUpdatedAt()
}

func TestAuditLogStreamConfig_GetEnabled(tt *testing.T) {
	tt.Parallel()
	a := &AuditLogStreamConfig{}
	a.GetEnabled()
	a = nil
	a.GetEnabled()
}

func TestAuditLogStreamConfig_GetStreamType(tt *testing.T) {
	tt.Parallel()
	a := &AuditLogStreamConfig{}
	a.GetStreamType()
	a = nil
	a.GetStreamType()
}

func TestAuditLogStreamConfig_GetVendorSpecific(tt *testing.T) {
	tt.Parallel()
	a := &AuditLogStreamConfig{}
	a.GetVendorSpecific()
	a = nil
	a.GetVendorSpecific()
}

func TestAuditLogStreamKey_GetKey(tt *testing.T) {
	tt.Parallel()
	a := &AuditLogStreamKey{}
	a.GetKey()
	a = nil
	a.GetKey()
}

func TestAuditLogStreamKey_GetKeyID(tt *testing.T) {
	tt.Parallel()
	a := &AuditLogStreamKey{}
	a.GetKeyID()
	a = nil
	a.GetKeyID()
}

func TestAuthorization_GetApp(tt *testing.T) {
	tt.Parallel()
	a := &Authorization{}
	a.GetApp()
	a = nil
	a.GetApp()
}

func TestAuthorization_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	a := &Authorization{CreatedAt: &zeroValue}
	a.GetCreatedAt()
	a = &Authorization{}
	a.GetCreatedAt()
	a = nil
	a.GetCreatedAt()
}

func TestAuthorization_GetFingerprint(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &Authorization{Fingerprint: &zeroValue}
	a.GetFingerprint()
	a = &Authorization{}
	a.GetFingerprint()
	a = nil
	a.GetFingerprint()
}

func TestAuthorization_GetHashedToken(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &Authorization{HashedToken: &zeroValue}
	a.GetHashedToken()
	a = &Authorization{}
	a.GetHashedToken()
	a = nil
	a.GetHashedToken()
}

func TestAuthorization_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	a := &Authorization{ID: &zeroValue}
	a.GetID()
	a = &Authorization{}
	a.GetID()
	a = nil
	a.GetID()
}

func TestAuthorization_GetNote(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &Authorization{Note: &zeroValue}
	a.GetNote()
	a = &Authorization{}
	a.GetNote()
	a = nil
	a.GetNote()
}

func TestAuthorization_GetNoteURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &Authorization{NoteURL: &zeroValue}
	a.GetNoteURL()
	a = &Authorization{}
	a.GetNoteURL()
	a = nil
	a.GetNoteURL()
}

func TestAuthorization_GetScopes(tt *testing.T) {
	tt.Parallel()
	zeroValue := []Scope{}
	a := &Authorization{Scopes: zeroValue}
	a.GetScopes()
	a = &Authorization{}
	a.GetScopes()
	a = nil
	a.GetScopes()
}

func TestAuthorization_GetToken(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &Authorization{Token: &zeroValue}
	a.GetToken()
	a = &Authorization{}
	a.GetToken()
	a = nil
	a.GetToken()
}

func TestAuthorization_GetTokenLastEight(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &Authorization{TokenLastEight: &zeroValue}
	a.GetTokenLastEight()
	a = &Authorization{}
	a.GetTokenLastEight()
	a = nil
	a.GetTokenLastEight()
}

func TestAuthorization_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	a := &Authorization{UpdatedAt: &zeroValue}
	a.GetUpdatedAt()
	a = &Authorization{}
	a.GetUpdatedAt()
	a = nil
	a.GetUpdatedAt()
}

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

func TestAuthorization_GetUser(tt *testing.T) {
	tt.Parallel()
	a := &Authorization{}
	a.GetUser()
	a = nil
	a.GetUser()
}

func TestAuthorizationApp_GetClientID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &AuthorizationApp{ClientID: &zeroValue}
	a.GetClientID()
	a = &AuthorizationApp{}
	a.GetClientID()
	a = nil
	a.GetClientID()
}

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

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

func TestAuthorizationRequest_GetClientID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &AuthorizationRequest{ClientID: &zeroValue}
	a.GetClientID()
	a = &AuthorizationRequest{}
	a.GetClientID()
	a = nil
	a.GetClientID()
}

func TestAuthorizationRequest_GetClientSecret(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &AuthorizationRequest{ClientSecret: &zeroValue}
	a.GetClientSecret()
	a = &AuthorizationRequest{}
	a.GetClientSecret()
	a = nil
	a.GetClientSecret()
}

func TestAuthorizationRequest_GetFingerprint(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &AuthorizationRequest{Fingerprint: &zeroValue}
	a.GetFingerprint()
	a = &AuthorizationRequest{}
	a.GetFingerprint()
	a = nil
	a.GetFingerprint()
}

func TestAuthorizationRequest_GetNote(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &AuthorizationRequest{Note: &zeroValue}
	a.GetNote()
	a = &AuthorizationRequest{}
	a.GetNote()
	a = nil
	a.GetNote()
}

func TestAuthorizationRequest_GetNoteURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &AuthorizationRequest{NoteURL: &zeroValue}
	a.GetNoteURL()
	a = &AuthorizationRequest{}
	a.GetNoteURL()
	a = nil
	a.GetNoteURL()
}

func TestAuthorizationRequest_GetScopes(tt *testing.T) {
	tt.Parallel()
	zeroValue := []Scope{}
	a := &AuthorizationRequest{Scopes: zeroValue}
	a.GetScopes()
	a = &AuthorizationRequest{}
	a.GetScopes()
	a = nil
	a.GetScopes()
}

func TestAuthorizationUpdateRequest_GetAddScopes(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	a := &AuthorizationUpdateRequest{AddScopes: zeroValue}
	a.GetAddScopes()
	a = &AuthorizationUpdateRequest{}
	a.GetAddScopes()
	a = nil
	a.GetAddScopes()
}

func TestAuthorizationUpdateRequest_GetFingerprint(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &AuthorizationUpdateRequest{Fingerprint: &zeroValue}
	a.GetFingerprint()
	a = &AuthorizationUpdateRequest{}
	a.GetFingerprint()
	a = nil
	a.GetFingerprint()
}

func TestAuthorizationUpdateRequest_GetNote(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &AuthorizationUpdateRequest{Note: &zeroValue}
	a.GetNote()
	a = &AuthorizationUpdateRequest{}
	a.GetNote()
	a = nil
	a.GetNote()
}

func TestAuthorizationUpdateRequest_GetNoteURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &AuthorizationUpdateRequest{NoteURL: &zeroValue}
	a.GetNoteURL()
	a = &AuthorizationUpdateRequest{}
	a.GetNoteURL()
	a = nil
	a.GetNoteURL()
}

func TestAuthorizationUpdateRequest_GetRemoveScopes(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	a := &AuthorizationUpdateRequest{RemoveScopes: zeroValue}
	a.GetRemoveScopes()
	a = &AuthorizationUpdateRequest{}
	a.GetRemoveScopes()
	a = nil
	a.GetRemoveScopes()
}

func TestAuthorizationUpdateRequest_GetScopes(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	a := &AuthorizationUpdateRequest{Scopes: zeroValue}
	a.GetScopes()
	a = &AuthorizationUpdateRequest{}
	a.GetScopes()
	a = nil
	a.GetScopes()
}

func TestAuthorizedActorNames_GetFrom(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	a := &AuthorizedActorNames{From: zeroValue}
	a.GetFrom()
	a = &AuthorizedActorNames{}
	a.GetFrom()
	a = nil
	a.GetFrom()
}

func TestAuthorizedActorsOnly_GetFrom(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	a := &AuthorizedActorsOnly{From: &zeroValue}
	a.GetFrom()
	a = &AuthorizedActorsOnly{}
	a.GetFrom()
	a = nil
	a.GetFrom()
}

func TestAuthorizedDismissalActorsOnlyChanges_GetFrom(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	a := &AuthorizedDismissalActorsOnlyChanges{From: &zeroValue}
	a.GetFrom()
	a = &AuthorizedDismissalActorsOnlyChanges{}
	a.GetFrom()
	a = nil
	a.GetFrom()
}

func TestAutolink_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	a := &Autolink{ID: &zeroValue}
	a.GetID()
	a = &Autolink{}
	a.GetID()
	a = nil
	a.GetID()
}

func TestAutolink_GetIsAlphanumeric(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	a := &Autolink{IsAlphanumeric: &zeroValue}
	a.GetIsAlphanumeric()
	a = &Autolink{}
	a.GetIsAlphanumeric()
	a = nil
	a.GetIsAlphanumeric()
}

func TestAutolink_GetKeyPrefix(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &Autolink{KeyPrefix: &zeroValue}
	a.GetKeyPrefix()
	a = &Autolink{}
	a.GetKeyPrefix()
	a = nil
	a.GetKeyPrefix()
}

func TestAutolink_GetURLTemplate(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	a := &Autolink{URLTemplate: &zeroValue}
	a.GetURLTemplate()
	a = &Autolink{}
	a.GetURLTemplate()
	a = nil
	a.GetURLTemplate()
}

func TestAutomatedSecurityFixes_GetEnabled(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	a := &AutomatedSecurityFixes{Enabled: &zeroValue}
	a.GetEnabled()
	a = &AutomatedSecurityFixes{}
	a.GetEnabled()
	a = nil
	a.GetEnabled()
}

func TestAutomatedSecurityFixes_GetPaused(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	a := &AutomatedSecurityFixes{Paused: &zeroValue}
	a.GetPaused()
	a = &AutomatedSecurityFixes{}
	a.GetPaused()
	a = nil
	a.GetPaused()
}

func TestAutoTriggerCheck_GetAppID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	a := &AutoTriggerCheck{AppID: &zeroValue}
	a.GetAppID()
	a = &AutoTriggerCheck{}
	a.GetAppID()
	a = nil
	a.GetAppID()
}

func TestAutoTriggerCheck_GetSetting(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	a := &AutoTriggerCheck{Setting: &zeroValue}
	a.GetSetting()
	a = &AutoTriggerCheck{}
	a.GetSetting()
	a = nil
	a.GetSetting()
}

func TestAzureBlobConfig_GetContainer(tt *testing.T) {
	tt.Parallel()
	a := &AzureBlobConfig{}
	a.GetContainer()
	a = nil
	a.GetContainer()
}

func TestAzureBlobConfig_GetEncryptedSASURL(tt *testing.T) {
	tt.Parallel()
	a := &AzureBlobConfig{}
	a.GetEncryptedSASURL()
	a = nil
	a.GetEncryptedSASURL()
}

func TestAzureBlobConfig_GetKeyID(tt *testing.T) {
	tt.Parallel()
	a := &AzureBlobConfig{}
	a.GetKeyID()
	a = nil
	a.GetKeyID()
}

func TestAzureHubConfig_GetEncryptedConnstring(tt *testing.T) {
	tt.Parallel()
	a := &AzureHubConfig{}
	a.GetEncryptedConnstring()
	a = nil
	a.GetEncryptedConnstring()
}

func TestAzureHubConfig_GetKeyID(tt *testing.T) {
	tt.Parallel()
	a := &AzureHubConfig{}
	a.GetKeyID()
	a = nil
	a.GetKeyID()
}

func TestAzureHubConfig_GetName(tt *testing.T) {
	tt.Parallel()
	a := &AzureHubConfig{}
	a.GetName()
	a = nil
	a.GetName()
}

func TestBasicAuthTransport_GetOTP(tt *testing.T) {
	tt.Parallel()
	b := &BasicAuthTransport{}
	b.GetOTP()
	b = nil
	b.GetOTP()
}

func TestBasicAuthTransport_GetPassword(tt *testing.T) {
	tt.Parallel()
	b := &BasicAuthTransport{}
	b.GetPassword()
	b = nil
	b.GetPassword()
}

func TestBasicAuthTransport_GetUsername(tt *testing.T) {
	tt.Parallel()
	b := &BasicAuthTransport{}
	b.GetUsername()
	b = nil
	b.GetUsername()
}

func TestBillingCostCenter_GetID(tt *testing.T) {
	tt.Parallel()
	b := &BillingCostCenter{}
	b.GetID()
	b = nil
	b.GetID()
}

func TestBillingCostCenter_GetName(tt *testing.T) {
	tt.Parallel()
	b := &BillingCostCenter{}
	b.GetName()
	b = nil
	b.GetName()
}

func TestBlob_GetContent(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	b := &Blob{Content: &zeroValue}
	b.GetContent()
	b = &Blob{}
	b.GetContent()
	b = nil
	b.GetContent()
}

func TestBlob_GetEncoding(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	b := &Blob{Encoding: &zeroValue}
	b.GetEncoding()
	b = &Blob{}
	b.GetEncoding()
	b = nil
	b.GetEncoding()
}

func TestBlob_GetNodeID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	b := &Blob{NodeID: &zeroValue}
	b.GetNodeID()
	b = &Blob{}
	b.GetNodeID()
	b = nil
	b.GetNodeID()
}

func TestBlob_GetSHA(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	b := &Blob{SHA: &zeroValue}
	b.GetSHA()
	b = &Blob{}
	b.GetSHA()
	b = nil
	b.GetSHA()
}

func TestBlob_GetSize(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	b := &Blob{Size: &zeroValue}
	b.GetSize()
	b = &Blob{}
	b.GetSize()
	b = nil
	b.GetSize()
}

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

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

func TestBranch_GetCommit(tt *testing.T) {
	tt.Parallel()
	b := &Branch{}
	b.GetCommit()
	b = nil
	b.GetCommit()
}

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

func TestBranch_GetProtected(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	b := &Branch{Protected: &zeroValue}
	b.GetProtected()
	b = &Branch{}
	b.GetProtected()
	b = nil
	b.GetProtected()
}

func TestBranch_GetProtection(tt *testing.T) {
	tt.Parallel()
	b := &Branch{}
	b.GetProtection()
	b = nil
	b.GetProtection()
}

func TestBranch_GetProtectionURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	b := &Branch{ProtectionURL: &zeroValue}
	b.GetProtectionURL()
	b = &Branch{}
	b.GetProtectionURL()
	b = nil
	b.GetProtectionURL()
}

func TestBranchCommit_GetCommit(tt *testing.T) {
	tt.Parallel()
	b := &BranchCommit{}
	b.GetCommit()
	b = nil
	b.GetCommit()
}

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

func TestBranchCommit_GetProtected(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	b := &BranchCommit{Protected: &zeroValue}
	b.GetProtected()
	b = &BranchCommit{}
	b.GetProtected()
	b = nil
	b.GetProtected()
}

func TestBranchListOptions_GetProtected(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	b := &BranchListOptions{Protected: &zeroValue}
	b.GetProtected()
	b = &BranchListOptions{}
	b.GetProtected()
	b = nil
	b.GetProtected()
}

func TestBranchPolicy_GetCustomBranchPolicies(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	b := &BranchPolicy{CustomBranchPolicies: &zeroValue}
	b.GetCustomBranchPolicies()
	b = &BranchPolicy{}
	b.GetCustomBranchPolicies()
	b = nil
	b.GetCustomBranchPolicies()
}

func TestBranchPolicy_GetProtectedBranches(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	b := &BranchPolicy{ProtectedBranches: &zeroValue}
	b.GetProtectedBranches()
	b = &BranchPolicy{}
	b.GetProtectedBranches()
	b = nil
	b.GetProtectedBranches()
}

func TestBranchProtectionConfigurationEvent_GetAction(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	b := &BranchProtectionConfigurationEvent{Action: &zeroValue}
	b.GetAction()
	b = &BranchProtectionConfigurationEvent{}
	b.GetAction()
	b = nil
	b.GetAction()
}

func TestBranchProtectionConfigurationEvent_GetEnterprise(tt *testing.T) {
	tt.Parallel()
	b := &BranchProtectionConfigurationEvent{}
	b.GetEnterprise()
	b = nil
	b.GetEnterprise()
}

func TestBranchProtectionConfigurationEvent_GetInstallation(tt *testing.T) {
	tt.Parallel()
	b := &BranchProtectionConfigurationEvent{}
	b.GetInstallation()
	b = nil
	b.GetInstallation()
}

func TestBranchProtectionConfigurationEvent_GetOrg(tt *testing.T) {
	tt.Parallel()
	b := &BranchProtectionConfigurationEvent{}
	b.GetOrg()
	b = nil
	b.GetOrg()
}

func TestBranchProtectionConfigurationEvent_GetRepo(tt *testing.T) {
	tt.Parallel()
	b := &BranchProtectionConfigurationEvent{}
	b.GetRepo()
	b = nil
	b.GetRepo()
}

func TestBranchProtectionConfigurationEvent_GetSender(tt *testing.T) {
	tt.Parallel()
	b := &BranchProtectionConfigurationEvent{}
	b.GetSender()
	b = nil
	b.GetSender()
}

func TestBranchProtectionRule_GetAdminEnforced(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	b := &BranchProtectionRule{AdminEnforced: &zeroValue}
	b.GetAdminEnforced()
	b = &BranchProtectionRule{}
	b.GetAdminEnforced()
	b = nil
	b.GetAdminEnforced()
}

func TestBranchProtectionRule_GetAllowDeletionsEnforcementLevel(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	b := &BranchProtectionRule{AllowDeletionsEnforcementLevel: &zeroValue}
	b.GetAllowDeletionsEnforcementLevel()
	b = &BranchProtectionRule{}
	b.GetAllowDeletionsEnforcementLevel()
	b = nil
	b.GetAllowDeletionsEnforcementLevel()
}

func TestBranchProtectionRule_GetAllowForcePushesEnforcementLevel(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	b := &BranchProtectionRule{AllowForcePushesEnforcementLevel: &zeroValue}
	b.GetAllowForcePushesEnforcementLevel()
	b = &BranchProtectionRule{}
	b.GetAllowForcePushesEnforcementLevel()
	b = nil
	b.GetAllowForcePushesEnforcementLevel()
}

func TestBranchProtectionRule_GetAuthorizedActorNames(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	b := &BranchProtectionRule{AuthorizedActorNames: zeroValue}
	b.GetAuthorizedActorNames()
	b = &BranchProtectionRule{}
	b.GetAuthorizedActorNames()
	b = nil
	b.GetAuthorizedActorNames()
}

func TestBranchProtectionRule_GetAuthorizedActorsOnly(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	b := &BranchProtectionRule{AuthorizedActorsOnly: &zeroValue}
	b.GetAuthorizedActorsOnly()
	b = &BranchProtectionRule{}
	b.GetAuthorizedActorsOnly()
	b = nil
	b.GetAuthorizedActorsOnly()
}

func TestBranchProtectionRule_GetAuthorizedDismissalActorsOnly(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	b := &BranchProtectionRule{AuthorizedDismissalActorsOnly: &zeroValue}
	b.GetAuthorizedDismissalActorsOnly()
	b = &BranchProtectionRule{}
	b.GetAuthorizedDismissalActorsOnly()
	b = nil
	b.GetAuthorizedDismissalActorsOnly()
}

func TestBranchProtectionRule_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	b := &BranchProtectionRule{CreatedAt: &zeroValue}
	b.GetCreatedAt()
	b = &BranchProtectionRule{}
	b.GetCreatedAt()
	b = nil
	b.GetCreatedAt()
}

func TestBranchProtectionRule_GetDismissStaleReviewsOnPush(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	b := &BranchProtectionRule{DismissStaleReviewsOnPush: &zeroValue}
	b.GetDismissStaleReviewsOnPush()
	b = &BranchProtectionRule{}
	b.GetDismissStaleReviewsOnPush()
	b = nil
	b.GetDismissStaleReviewsOnPush()
}

func TestBranchProtectionRule_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	b := &BranchProtectionRule{ID: &zeroValue}
	b.GetID()
	b = &BranchProtectionRule{}
	b.GetID()
	b = nil
	b.GetID()
}

func TestBranchProtectionRule_GetIgnoreApprovalsFromContributors(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	b := &BranchProtectionRule{IgnoreApprovalsFromContributors: &zeroValue}
	b.GetIgnoreApprovalsFromContributors()
	b = &BranchProtectionRule{}
	b.GetIgnoreApprovalsFromContributors()
	b = nil
	b.GetIgnoreApprovalsFromContributors()
}

func TestBranchProtectionRule_GetLinearHistoryRequirementEnforcementLevel(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	b := &BranchProtectionRule{LinearHistoryRequirementEnforcementLevel: &zeroValue}
	b.GetLinearHistoryRequirementEnforcementLevel()
	b = &BranchProtectionRule{}
	b.GetLinearHistoryRequirementEnforcementLevel()
	b = nil
	b.GetLinearHistoryRequirementEnforcementLevel()
}

func TestBranchProtectionRule_GetMergeQueueEnforcementLevel(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	b := &BranchProtectionRule{MergeQueueEnforcementLevel: &zeroValue}
	b.GetMergeQueueEnforcementLevel()
	b = &BranchProtectionRule{}
	b.GetMergeQueueEnforcementLevel()
	b = nil
	b.GetMergeQueueEnforcementLevel()
}

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

func TestBranchProtectionRule_GetPullRequestReviewsEnforcementLevel(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	b := &BranchProtectionRule{PullRequestReviewsEnforcementLevel: &zeroValue}
	b.GetPullRequestReviewsEnforcementLevel()
	b = &BranchProtectionRule{}
	b.GetPullRequestReviewsEnforcementLevel()
	b = nil
	b.GetPullRequestReviewsEnforcementLevel()
}

func TestBranchProtectionRule_GetRepositoryID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	b := &BranchProtectionRule{RepositoryID: &zeroValue}
	b.GetRepositoryID()
	b = &BranchProtectionRule{}
	b.GetRepositoryID()
	b = nil
	b.GetRepositoryID()
}

func TestBranchProtectionRule_GetRequireCodeOwnerReview(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	b := &BranchProtectionRule{RequireCodeOwnerReview: &zeroValue}
	b.GetRequireCodeOwnerReview()
	b = &BranchProtectionRule{}
	b.GetRequireCodeOwnerReview()
	b = nil
	b.GetRequireCodeOwnerReview()
}

func TestBranchProtectionRule_GetRequiredApprovingReviewCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	b := &BranchProtectionRule{RequiredApprovingReviewCount: &zeroValue}
	b.GetRequiredApprovingReviewCount()
	b = &BranchProtectionRule{}
	b.GetRequiredApprovingReviewCount()
	b = nil
	b.GetRequiredApprovingReviewCount()
}

func TestBranchProtectionRule_GetRequiredConversationResolutionLevel(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	b := &BranchProtectionRule{RequiredConversationResolutionLevel: &zeroValue}
	b.GetRequiredConversationResolutionLevel()
	b = &BranchProtectionRule{}
	b.GetRequiredConversationResolutionLevel()
	b = nil
	b.GetRequiredConversationResolutionLevel()
}

func TestBranchProtectionRule_GetRequiredDeploymentsEnforcementLevel(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	b := &BranchProtectionRule{RequiredDeploymentsEnforcementLevel: &zeroValue}
	b.GetRequiredDeploymentsEnforcementLevel()
	b = &BranchProtectionRule{}
	b.GetRequiredDeploymentsEnforcementLevel()
	b = nil
	b.GetRequiredDeploymentsEnforcementLevel()
}

func TestBranchProtectionRule_GetRequiredStatusChecks(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	b := &BranchProtectionRule{RequiredStatusChecks: zeroValue}
	b.GetRequiredStatusChecks()
	b = &BranchProtectionRule{}
	b.GetRequiredStatusChecks()
	b = nil
	b.GetRequiredStatusChecks()
}

func TestBranchProtectionRule_GetRequiredStatusChecksEnforcementLevel(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	b := &BranchProtectionRule{RequiredStatusChecksEnforcementLevel: &zeroValue}
	b.GetRequiredStatusChecksEnforcementLevel()
	b = &BranchProtectionRule{}
	b.GetRequiredStatusChecksEnforcementLevel()
	b = nil
	b.GetRequiredStatusChecksEnforcementLevel()
}

func TestBranchProtectionRule_GetRequireLastPushApproval(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	b := &BranchProtectionRule{RequireLastPushApproval: &zeroValue}
	b.GetRequireLastPushApproval()
	b = &BranchProtectionRule{}
	b.GetRequireLastPushApproval()
	b = nil
	b.GetRequireLastPushApproval()
}

func TestBranchProtectionRule_GetSignatureRequirementEnforcementLevel(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	b := &BranchProtectionRule{SignatureRequirementEnforcementLevel: &zeroValue}
	b.GetSignatureRequirementEnforcementLevel()
	b = &BranchProtectionRule{}
	b.GetSignatureRequirementEnforcementLevel()
	b = nil
	b.GetSignatureRequirementEnforcementLevel()
}

func TestBranchProtectionRule_GetStrictRequiredStatusChecksPolicy(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	b := &BranchProtectionRule{StrictRequiredStatusChecksPolicy: &zeroValue}
	b.GetStrictRequiredStatusChecksPolicy()
	b = &BranchProtectionRule{}
	b.GetStrictRequiredStatusChecksPolicy()
	b = nil
	b.GetStrictRequiredStatusChecksPolicy()
}

func TestBranchProtectionRule_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	b := &BranchProtectionRule{UpdatedAt: &zeroValue}
	b.GetUpdatedAt()
	b = &BranchProtectionRule{}
	b.GetUpdatedAt()
	b = nil
	b.GetUpdatedAt()
}

func TestBranchProtectionRuleEvent_GetAction(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	b := &BranchProtectionRuleEvent{Action: &zeroValue}
	b.GetAction()
	b = &BranchProtectionRuleEvent{}
	b.GetAction()
	b = nil
	b.GetAction()
}

func TestBranchProtectionRuleEvent_GetChanges(tt *testing.T) {
	tt.Parallel()
	b := &BranchProtectionRuleEvent{}
	b.GetChanges()
	b = nil
	b.GetChanges()
}

func TestBranchProtectionRuleEvent_GetInstallation(tt *testing.T) {
	tt.Parallel()
	b := &BranchProtectionRuleEvent{}
	b.GetInstallation()
	b = nil
	b.GetInstallation()
}

func TestBranchProtectionRuleEvent_GetOrg(tt *testing.T) {
	tt.Parallel()
	b := &BranchProtectionRuleEvent{}
	b.GetOrg()
	b = nil
	b.GetOrg()
}

func TestBranchProtectionRuleEvent_GetRepo(tt *testing.T) {
	tt.Parallel()
	b := &BranchProtectionRuleEvent{}
	b.GetRepo()
	b = nil
	b.GetRepo()
}

func TestBranchProtectionRuleEvent_GetRule(tt *testing.T) {
	tt.Parallel()
	b := &BranchProtectionRuleEvent{}
	b.GetRule()
	b = nil
	b.GetRule()
}

func TestBranchProtectionRuleEvent_GetSender(tt *testing.T) {
	tt.Parallel()
	b := &BranchProtectionRuleEvent{}
	b.GetSender()
	b = nil
	b.GetSender()
}

func TestBranchRestrictions_GetApps(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*App{}
	b := &BranchRestrictions{Apps: zeroValue}
	b.GetApps()
	b = &BranchRestrictions{}
	b.GetApps()
	b = nil
	b.GetApps()
}

func TestBranchRestrictions_GetTeams(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*Team{}
	b := &BranchRestrictions{Teams: zeroValue}
	b.GetTeams()
	b = &BranchRestrictions{}
	b.GetTeams()
	b = nil
	b.GetTeams()
}

func TestBranchRestrictions_GetUsers(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*User{}
	b := &BranchRestrictions{Users: zeroValue}
	b.GetUsers()
	b = &BranchRestrictions{}
	b.GetUsers()
	b = nil
	b.GetUsers()
}

func TestBranchRestrictionsRequest_GetApps(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	b := &BranchRestrictionsRequest{Apps: zeroValue}
	b.GetApps()
	b = &BranchRestrictionsRequest{}
	b.GetApps()
	b = nil
	b.GetApps()
}

func TestBranchRestrictionsRequest_GetTeams(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	b := &BranchRestrictionsRequest{Teams: zeroValue}
	b.GetTeams()
	b = &BranchRestrictionsRequest{}
	b.GetTeams()
	b = nil
	b.GetTeams()
}

func TestBranchRestrictionsRequest_GetUsers(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	b := &BranchRestrictionsRequest{Users: zeroValue}
	b.GetUsers()
	b = &BranchRestrictionsRequest{}
	b.GetUsers()
	b = nil
	b.GetUsers()
}

func TestBranchRuleMetadata_GetRulesetID(tt *testing.T) {
	tt.Parallel()
	b := &BranchRuleMetadata{}
	b.GetRulesetID()
	b = nil
	b.GetRulesetID()
}

func TestBranchRuleMetadata_GetRulesetSource(tt *testing.T) {
	tt.Parallel()
	b := &BranchRuleMetadata{}
	b.GetRulesetSource()
	b = nil
	b.GetRulesetSource()
}

func TestBranchRuleMetadata_GetRulesetSourceType(tt *testing.T) {
	tt.Parallel()
	b := &BranchRuleMetadata{}
	b.GetRulesetSourceType()
	b = nil
	b.GetRulesetSourceType()
}

func TestBranchRules_GetBranchNamePattern(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*PatternBranchRule{}
	b := &BranchRules{BranchNamePattern: zeroValue}
	b.GetBranchNamePattern()
	b = &BranchRules{}
	b.GetBranchNamePattern()
	b = nil
	b.GetBranchNamePattern()
}

func TestBranchRules_GetCodeScanning(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*CodeScanningBranchRule{}
	b := &BranchRules{CodeScanning: zeroValue}
	b.GetCodeScanning()
	b = &BranchRules{}
	b.GetCodeScanning()
	b = nil
	b.GetCodeScanning()
}

func TestBranchRules_GetCommitAuthorEmailPattern(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*PatternBranchRule{}
	b := &BranchRules{CommitAuthorEmailPattern: zeroValue}
	b.GetCommitAuthorEmailPattern()
	b = &BranchRules{}
	b.GetCommitAuthorEmailPattern()
	b = nil
	b.GetCommitAuthorEmailPattern()
}

func TestBranchRules_GetCommitMessagePattern(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*PatternBranchRule{}
	b := &BranchRules{CommitMessagePattern: zeroValue}
	b.GetCommitMessagePattern()
	b = &BranchRules{}
	b.GetCommitMessagePattern()
	b = nil
	b.GetCommitMessagePattern()
}

func TestBranchRules_GetCommitterEmailPattern(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*PatternBranchRule{}
	b := &BranchRules{CommitterEmailPattern: zeroValue}
	b.GetCommitterEmailPattern()
	b = &BranchRules{}
	b.GetCommitterEmailPattern()
	b = nil
	b.GetCommitterEmailPattern()
}

func TestBranchRules_GetCopilotCodeReview(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*CopilotCodeReviewBranchRule{}
	b := &BranchRules{CopilotCodeReview: zeroValue}
	b.GetCopilotCodeReview()
	b = &BranchRules{}
	b.GetCopilotCodeReview()
	b = nil
	b.GetCopilotCodeReview()
}

func TestBranchRules_GetCreation(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*BranchRuleMetadata{}
	b := &BranchRules{Creation: zeroValue}
	b.GetCreation()
	b = &BranchRules{}
	b.GetCreation()
	b = nil
	b.GetCreation()
}

func TestBranchRules_GetDeletion(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*BranchRuleMetadata{}
	b := &BranchRules{Deletion: zeroValue}
	b.GetDeletion()
	b = &BranchRules{}
	b.GetDeletion()
	b = nil
	b.GetDeletion()
}

func TestBranchRules_GetFileExtensionRestriction(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*FileExtensionRestrictionBranchRule{}
	b := &BranchRules{FileExtensionRestriction: zeroValue}
	b.GetFileExtensionRestriction()
	b = &BranchRules{}
	b.GetFileExtensionRestriction()
	b = nil
	b.GetFileExtensionRestriction()
}

func TestBranchRules_GetFilePathRestriction(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*FilePathRestrictionBranchRule{}
	b := &BranchRules{FilePathRestriction: zeroValue}
	b.GetFilePathRestriction()
	b = &BranchRules{}
	b.GetFilePathRestriction()
	b = nil
	b.GetFilePathRestriction()
}

func TestBranchRules_GetMaxFilePathLength(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*MaxFilePathLengthBranchRule{}
	b := &BranchRules{MaxFilePathLength: zeroValue}
	b.GetMaxFilePathLength()
	b = &BranchRules{}
	b.GetMaxFilePathLength()
	b = nil
	b.GetMaxFilePathLength()
}

func TestBranchRules_GetMaxFileSize(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*MaxFileSizeBranchRule{}
	b := &BranchRules{MaxFileSize: zeroValue}
	b.GetMaxFileSize()
	b = &BranchRules{}
	b.GetMaxFileSize()
	b = nil
	b.GetMaxFileSize()
}

func TestBranchRules_GetMergeQueue(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*MergeQueueBranchRule{}
	b := &BranchRules{MergeQueue: zeroValue}
	b.GetMergeQueue()
	b = &BranchRules{}
	b.GetMergeQueue()
	b = nil
	b.GetMergeQueue()
}

func TestBranchRules_GetNonFastForward(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*BranchRuleMetadata{}
	b := &BranchRules{NonFastForward: zeroValue}
	b.GetNonFastForward()
	b = &BranchRules{}
	b.GetNonFastForward()
	b = nil
	b.GetNonFastForward()
}

func TestBranchRules_GetPullRequest(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*PullRequestBranchRule{}
	b := &BranchRules{PullRequest: zeroValue}
	b.GetPullRequest()
	b = &BranchRules{}
	b.GetPullRequest()
	b = nil
	b.GetPullRequest()
}

func TestBranchRules_GetRequiredDeployments(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*RequiredDeploymentsBranchRule{}
	b := &BranchRules{RequiredDeployments: zeroValue}
	b.GetRequiredDeployments()
	b = &BranchRules{}
	b.GetRequiredDeployments()
	b = nil
	b.GetRequiredDeployments()
}

func TestBranchRules_GetRequiredLinearHistory(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*BranchRuleMetadata{}
	b := &BranchRules{RequiredLinearHistory: zeroValue}
	b.GetRequiredLinearHistory()
	b = &BranchRules{}
	b.GetRequiredLinearHistory()
	b = nil
	b.GetRequiredLinearHistory()
}

func TestBranchRules_GetRequiredSignatures(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*BranchRuleMetadata{}
	b := &BranchRules{RequiredSignatures: zeroValue}
	b.GetRequiredSignatures()
	b = &BranchRules{}
	b.GetRequiredSignatures()
	b = nil
	b.GetRequiredSignatures()
}

func TestBranchRules_GetRequiredStatusChecks(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*RequiredStatusChecksBranchRule{}
	b := &BranchRules{RequiredStatusChecks: zeroValue}
	b.GetRequiredStatusChecks()
	b = &BranchRules{}
	b.GetRequiredStatusChecks()
	b = nil
	b.GetRequiredStatusChecks()
}

func TestBranchRules_GetTagNamePattern(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*PatternBranchRule{}
	b := &BranchRules{TagNamePattern: zeroValue}
	b.GetTagNamePattern()
	b = &BranchRules{}
	b.GetTagNamePattern()
	b = nil
	b.GetTagNamePattern()
}

func TestBranchRules_GetUpdate(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*UpdateBranchRule{}
	b := &BranchRules{Update: zeroValue}
	b.GetUpdate()
	b = &BranchRules{}
	b.GetUpdate()
	b = nil
	b.GetUpdate()
}

func TestBranchRules_GetWorkflows(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*WorkflowsBranchRule{}
	b := &BranchRules{Workflows: zeroValue}
	b.GetWorkflows()
	b = &BranchRules{}
	b.GetWorkflows()
	b = nil
	b.GetWorkflows()
}

func TestBypassActor_GetActorID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	b := &BypassActor{ActorID: &zeroValue}
	b.GetActorID()
	b = &BypassActor{}
	b.GetActorID()
	b = nil
	b.GetActorID()
}

func TestBypassActor_GetActorType(tt *testing.T) {
	tt.Parallel()
	b := &BypassActor{}
	b.GetActorType()
	b = nil
	b.GetActorType()
}

func TestBypassActor_GetBypassMode(tt *testing.T) {
	tt.Parallel()
	b := &BypassActor{}
	b.GetBypassMode()
	b = nil
	b.GetBypassMode()
}

func TestBypassPullRequestAllowances_GetApps(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*App{}
	b := &BypassPullRequestAllowances{Apps: zeroValue}
	b.GetApps()
	b = &BypassPullRequestAllowances{}
	b.GetApps()
	b = nil
	b.GetApps()
}

func TestBypassPullRequestAllowances_GetTeams(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*Team{}
	b := &BypassPullRequestAllowances{Teams: zeroValue}
	b.GetTeams()
	b = &BypassPullRequestAllowances{}
	b.GetTeams()
	b = nil
	b.GetTeams()
}

func TestBypassPullRequestAllowances_GetUsers(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*User{}
	b := &BypassPullRequestAllowances{Users: zeroValue}
	b.GetUsers()
	b = &BypassPullRequestAllowances{}
	b.GetUsers()
	b = nil
	b.GetUsers()
}

func TestBypassPullRequestAllowancesRequest_GetApps(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	b := &BypassPullRequestAllowancesRequest{Apps: zeroValue}
	b.GetApps()
	b = &BypassPullRequestAllowancesRequest{}
	b.GetApps()
	b = nil
	b.GetApps()
}

func TestBypassPullRequestAllowancesRequest_GetTeams(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	b := &BypassPullRequestAllowancesRequest{Teams: zeroValue}
	b.GetTeams()
	b = &BypassPullRequestAllowancesRequest{}
	b.GetTeams()
	b = nil
	b.GetTeams()
}

func TestBypassPullRequestAllowancesRequest_GetUsers(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	b := &BypassPullRequestAllowancesRequest{Users: zeroValue}
	b.GetUsers()
	b = &BypassPullRequestAllowancesRequest{}
	b.GetUsers()
	b = nil
	b.GetUsers()
}

func TestBypassReviewer_GetReviewerID(tt *testing.T) {
	tt.Parallel()
	b := &BypassReviewer{}
	b.GetReviewerID()
	b = nil
	b.GetReviewerID()
}

func TestBypassReviewer_GetReviewerType(tt *testing.T) {
	tt.Parallel()
	b := &BypassReviewer{}
	b.GetReviewerType()
	b = nil
	b.GetReviewerType()
}

func TestBypassReviewer_GetSecurityConfigurationID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	b := &BypassReviewer{SecurityConfigurationID: &zeroValue}
	b.GetSecurityConfigurationID()
	b = &BypassReviewer{}
	b.GetSecurityConfigurationID()
	b = nil
	b.GetSecurityConfigurationID()
}

func TestCheckRun_GetApp(tt *testing.T) {
	tt.Parallel()
	c := &CheckRun{}
	c.GetApp()
	c = nil
	c.GetApp()
}

func TestCheckRun_GetCheckSuite(tt *testing.T) {
	tt.Parallel()
	c := &CheckRun{}
	c.GetCheckSuite()
	c = nil
	c.GetCheckSuite()
}

func TestCheckRun_GetCompletedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	c := &CheckRun{CompletedAt: &zeroValue}
	c.GetCompletedAt()
	c = &CheckRun{}
	c.GetCompletedAt()
	c = nil
	c.GetCompletedAt()
}

func TestCheckRun_GetConclusion(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CheckRun{Conclusion: &zeroValue}
	c.GetConclusion()
	c = &CheckRun{}
	c.GetConclusion()
	c = nil
	c.GetConclusion()
}

func TestCheckRun_GetDetailsURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CheckRun{DetailsURL: &zeroValue}
	c.GetDetailsURL()
	c = &CheckRun{}
	c.GetDetailsURL()
	c = nil
	c.GetDetailsURL()
}

func TestCheckRun_GetExternalID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CheckRun{ExternalID: &zeroValue}
	c.GetExternalID()
	c = &CheckRun{}
	c.GetExternalID()
	c = nil
	c.GetExternalID()
}

func TestCheckRun_GetHeadSHA(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CheckRun{HeadSHA: &zeroValue}
	c.GetHeadSHA()
	c = &CheckRun{}
	c.GetHeadSHA()
	c = nil
	c.GetHeadSHA()
}

func TestCheckRun_GetHTMLURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CheckRun{HTMLURL: &zeroValue}
	c.GetHTMLURL()
	c = &CheckRun{}
	c.GetHTMLURL()
	c = nil
	c.GetHTMLURL()
}

func TestCheckRun_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	c := &CheckRun{ID: &zeroValue}
	c.GetID()
	c = &CheckRun{}
	c.GetID()
	c = nil
	c.GetID()
}

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

func TestCheckRun_GetNodeID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CheckRun{NodeID: &zeroValue}
	c.GetNodeID()
	c = &CheckRun{}
	c.GetNodeID()
	c = nil
	c.GetNodeID()
}

func TestCheckRun_GetOutput(tt *testing.T) {
	tt.Parallel()
	c := &CheckRun{}
	c.GetOutput()
	c = nil
	c.GetOutput()
}

func TestCheckRun_GetPullRequests(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*PullRequest{}
	c := &CheckRun{PullRequests: zeroValue}
	c.GetPullRequests()
	c = &CheckRun{}
	c.GetPullRequests()
	c = nil
	c.GetPullRequests()
}

func TestCheckRun_GetStartedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	c := &CheckRun{StartedAt: &zeroValue}
	c.GetStartedAt()
	c = &CheckRun{}
	c.GetStartedAt()
	c = nil
	c.GetStartedAt()
}

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

func TestCheckRun_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CheckRun{URL: &zeroValue}
	c.GetURL()
	c = &CheckRun{}
	c.GetURL()
	c = nil
	c.GetURL()
}

func TestCheckRunAction_GetDescription(tt *testing.T) {
	tt.Parallel()
	c := &CheckRunAction{}
	c.GetDescription()
	c = nil
	c.GetDescription()
}

func TestCheckRunAction_GetIdentifier(tt *testing.T) {
	tt.Parallel()
	c := &CheckRunAction{}
	c.GetIdentifier()
	c = nil
	c.GetIdentifier()
}

func TestCheckRunAction_GetLabel(tt *testing.T) {
	tt.Parallel()
	c := &CheckRunAction{}
	c.GetLabel()
	c = nil
	c.GetLabel()
}

func TestCheckRunAnnotation_GetAnnotationLevel(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CheckRunAnnotation{AnnotationLevel: &zeroValue}
	c.GetAnnotationLevel()
	c = &CheckRunAnnotation{}
	c.GetAnnotationLevel()
	c = nil
	c.GetAnnotationLevel()
}

func TestCheckRunAnnotation_GetEndColumn(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CheckRunAnnotation{EndColumn: &zeroValue}
	c.GetEndColumn()
	c = &CheckRunAnnotation{}
	c.GetEndColumn()
	c = nil
	c.GetEndColumn()
}

func TestCheckRunAnnotation_GetEndLine(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CheckRunAnnotation{EndLine: &zeroValue}
	c.GetEndLine()
	c = &CheckRunAnnotation{}
	c.GetEndLine()
	c = nil
	c.GetEndLine()
}

func TestCheckRunAnnotation_GetMessage(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CheckRunAnnotation{Message: &zeroValue}
	c.GetMessage()
	c = &CheckRunAnnotation{}
	c.GetMessage()
	c = nil
	c.GetMessage()
}

func TestCheckRunAnnotation_GetPath(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CheckRunAnnotation{Path: &zeroValue}
	c.GetPath()
	c = &CheckRunAnnotation{}
	c.GetPath()
	c = nil
	c.GetPath()
}

func TestCheckRunAnnotation_GetRawDetails(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CheckRunAnnotation{RawDetails: &zeroValue}
	c.GetRawDetails()
	c = &CheckRunAnnotation{}
	c.GetRawDetails()
	c = nil
	c.GetRawDetails()
}

func TestCheckRunAnnotation_GetStartColumn(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CheckRunAnnotation{StartColumn: &zeroValue}
	c.GetStartColumn()
	c = &CheckRunAnnotation{}
	c.GetStartColumn()
	c = nil
	c.GetStartColumn()
}

func TestCheckRunAnnotation_GetStartLine(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CheckRunAnnotation{StartLine: &zeroValue}
	c.GetStartLine()
	c = &CheckRunAnnotation{}
	c.GetStartLine()
	c = nil
	c.GetStartLine()
}

func TestCheckRunAnnotation_GetTitle(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CheckRunAnnotation{Title: &zeroValue}
	c.GetTitle()
	c = &CheckRunAnnotation{}
	c.GetTitle()
	c = nil
	c.GetTitle()
}

func TestCheckRunEvent_GetAction(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CheckRunEvent{Action: &zeroValue}
	c.GetAction()
	c = &CheckRunEvent{}
	c.GetAction()
	c = nil
	c.GetAction()
}

func TestCheckRunEvent_GetCheckRun(tt *testing.T) {
	tt.Parallel()
	c := &CheckRunEvent{}
	c.GetCheckRun()
	c = nil
	c.GetCheckRun()
}

func TestCheckRunEvent_GetInstallation(tt *testing.T) {
	tt.Parallel()
	c := &CheckRunEvent{}
	c.GetInstallation()
	c = nil
	c.GetInstallation()
}

func TestCheckRunEvent_GetOrg(tt *testing.T) {
	tt.Parallel()
	c := &CheckRunEvent{}
	c.GetOrg()
	c = nil
	c.GetOrg()
}

func TestCheckRunEvent_GetRepo(tt *testing.T) {
	tt.Parallel()
	c := &CheckRunEvent{}
	c.GetRepo()
	c = nil
	c.GetRepo()
}

func TestCheckRunEvent_GetRequestedAction(tt *testing.T) {
	tt.Parallel()
	c := &CheckRunEvent{}
	c.GetRequestedAction()
	c = nil
	c.GetRequestedAction()
}

func TestCheckRunEvent_GetSender(tt *testing.T) {
	tt.Parallel()
	c := &CheckRunEvent{}
	c.GetSender()
	c = nil
	c.GetSender()
}

func TestCheckRunImage_GetAlt(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CheckRunImage{Alt: &zeroValue}
	c.GetAlt()
	c = &CheckRunImage{}
	c.GetAlt()
	c = nil
	c.GetAlt()
}

func TestCheckRunImage_GetCaption(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CheckRunImage{Caption: &zeroValue}
	c.GetCaption()
	c = &CheckRunImage{}
	c.GetCaption()
	c = nil
	c.GetCaption()
}

func TestCheckRunImage_GetImageURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CheckRunImage{ImageURL: &zeroValue}
	c.GetImageURL()
	c = &CheckRunImage{}
	c.GetImageURL()
	c = nil
	c.GetImageURL()
}

func TestCheckRunOutput_GetAnnotations(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*CheckRunAnnotation{}
	c := &CheckRunOutput{Annotations: zeroValue}
	c.GetAnnotations()
	c = &CheckRunOutput{}
	c.GetAnnotations()
	c = nil
	c.GetAnnotations()
}

func TestCheckRunOutput_GetAnnotationsCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CheckRunOutput{AnnotationsCount: &zeroValue}
	c.GetAnnotationsCount()
	c = &CheckRunOutput{}
	c.GetAnnotationsCount()
	c = nil
	c.GetAnnotationsCount()
}

func TestCheckRunOutput_GetAnnotationsURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CheckRunOutput{AnnotationsURL: &zeroValue}
	c.GetAnnotationsURL()
	c = &CheckRunOutput{}
	c.GetAnnotationsURL()
	c = nil
	c.GetAnnotationsURL()
}

func TestCheckRunOutput_GetImages(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*CheckRunImage{}
	c := &CheckRunOutput{Images: zeroValue}
	c.GetImages()
	c = &CheckRunOutput{}
	c.GetImages()
	c = nil
	c.GetImages()
}

func TestCheckRunOutput_GetSummary(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CheckRunOutput{Summary: &zeroValue}
	c.GetSummary()
	c = &CheckRunOutput{}
	c.GetSummary()
	c = nil
	c.GetSummary()
}

func TestCheckRunOutput_GetText(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CheckRunOutput{Text: &zeroValue}
	c.GetText()
	c = &CheckRunOutput{}
	c.GetText()
	c = nil
	c.GetText()
}

func TestCheckRunOutput_GetTitle(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CheckRunOutput{Title: &zeroValue}
	c.GetTitle()
	c = &CheckRunOutput{}
	c.GetTitle()
	c = nil
	c.GetTitle()
}

func TestCheckSuite_GetAfterSHA(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CheckSuite{AfterSHA: &zeroValue}
	c.GetAfterSHA()
	c = &CheckSuite{}
	c.GetAfterSHA()
	c = nil
	c.GetAfterSHA()
}

func TestCheckSuite_GetApp(tt *testing.T) {
	tt.Parallel()
	c := &CheckSuite{}
	c.GetApp()
	c = nil
	c.GetApp()
}

func TestCheckSuite_GetBeforeSHA(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CheckSuite{BeforeSHA: &zeroValue}
	c.GetBeforeSHA()
	c = &CheckSuite{}
	c.GetBeforeSHA()
	c = nil
	c.GetBeforeSHA()
}

func TestCheckSuite_GetConclusion(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CheckSuite{Conclusion: &zeroValue}
	c.GetConclusion()
	c = &CheckSuite{}
	c.GetConclusion()
	c = nil
	c.GetConclusion()
}

func TestCheckSuite_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	c := &CheckSuite{CreatedAt: &zeroValue}
	c.GetCreatedAt()
	c = &CheckSuite{}
	c.GetCreatedAt()
	c = nil
	c.GetCreatedAt()
}

func TestCheckSuite_GetHeadBranch(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CheckSuite{HeadBranch: &zeroValue}
	c.GetHeadBranch()
	c = &CheckSuite{}
	c.GetHeadBranch()
	c = nil
	c.GetHeadBranch()
}

func TestCheckSuite_GetHeadCommit(tt *testing.T) {
	tt.Parallel()
	c := &CheckSuite{}
	c.GetHeadCommit()
	c = nil
	c.GetHeadCommit()
}

func TestCheckSuite_GetHeadSHA(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CheckSuite{HeadSHA: &zeroValue}
	c.GetHeadSHA()
	c = &CheckSuite{}
	c.GetHeadSHA()
	c = nil
	c.GetHeadSHA()
}

func TestCheckSuite_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	c := &CheckSuite{ID: &zeroValue}
	c.GetID()
	c = &CheckSuite{}
	c.GetID()
	c = nil
	c.GetID()
}

func TestCheckSuite_GetLatestCheckRunsCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	c := &CheckSuite{LatestCheckRunsCount: &zeroValue}
	c.GetLatestCheckRunsCount()
	c = &CheckSuite{}
	c.GetLatestCheckRunsCount()
	c = nil
	c.GetLatestCheckRunsCount()
}

func TestCheckSuite_GetNodeID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CheckSuite{NodeID: &zeroValue}
	c.GetNodeID()
	c = &CheckSuite{}
	c.GetNodeID()
	c = nil
	c.GetNodeID()
}

func TestCheckSuite_GetPullRequests(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*PullRequest{}
	c := &CheckSuite{PullRequests: zeroValue}
	c.GetPullRequests()
	c = &CheckSuite{}
	c.GetPullRequests()
	c = nil
	c.GetPullRequests()
}

func TestCheckSuite_GetRepository(tt *testing.T) {
	tt.Parallel()
	c := &CheckSuite{}
	c.GetRepository()
	c = nil
	c.GetRepository()
}

func TestCheckSuite_GetRerequestable(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &CheckSuite{Rerequestable: &zeroValue}
	c.GetRerequestable()
	c = &CheckSuite{}
	c.GetRerequestable()
	c = nil
	c.GetRerequestable()
}

func TestCheckSuite_GetRunsRerequestable(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &CheckSuite{RunsRerequestable: &zeroValue}
	c.GetRunsRerequestable()
	c = &CheckSuite{}
	c.GetRunsRerequestable()
	c = nil
	c.GetRunsRerequestable()
}

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

func TestCheckSuite_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	c := &CheckSuite{UpdatedAt: &zeroValue}
	c.GetUpdatedAt()
	c = &CheckSuite{}
	c.GetUpdatedAt()
	c = nil
	c.GetUpdatedAt()
}

func TestCheckSuite_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CheckSuite{URL: &zeroValue}
	c.GetURL()
	c = &CheckSuite{}
	c.GetURL()
	c = nil
	c.GetURL()
}

func TestCheckSuiteEvent_GetAction(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CheckSuiteEvent{Action: &zeroValue}
	c.GetAction()
	c = &CheckSuiteEvent{}
	c.GetAction()
	c = nil
	c.GetAction()
}

func TestCheckSuiteEvent_GetCheckSuite(tt *testing.T) {
	tt.Parallel()
	c := &CheckSuiteEvent{}
	c.GetCheckSuite()
	c = nil
	c.GetCheckSuite()
}

func TestCheckSuiteEvent_GetInstallation(tt *testing.T) {
	tt.Parallel()
	c := &CheckSuiteEvent{}
	c.GetInstallation()
	c = nil
	c.GetInstallation()
}

func TestCheckSuiteEvent_GetOrg(tt *testing.T) {
	tt.Parallel()
	c := &CheckSuiteEvent{}
	c.GetOrg()
	c = nil
	c.GetOrg()
}

func TestCheckSuiteEvent_GetRepo(tt *testing.T) {
	tt.Parallel()
	c := &CheckSuiteEvent{}
	c.GetRepo()
	c = nil
	c.GetRepo()
}

func TestCheckSuiteEvent_GetSender(tt *testing.T) {
	tt.Parallel()
	c := &CheckSuiteEvent{}
	c.GetSender()
	c = nil
	c.GetSender()
}

func TestCheckSuitePreferenceOptions_GetAutoTriggerChecks(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*AutoTriggerCheck{}
	c := &CheckSuitePreferenceOptions{AutoTriggerChecks: zeroValue}
	c.GetAutoTriggerChecks()
	c = &CheckSuitePreferenceOptions{}
	c.GetAutoTriggerChecks()
	c = nil
	c.GetAutoTriggerChecks()
}

func TestCheckSuitePreferenceResults_GetPreferences(tt *testing.T) {
	tt.Parallel()
	c := &CheckSuitePreferenceResults{}
	c.GetPreferences()
	c = nil
	c.GetPreferences()
}

func TestCheckSuitePreferenceResults_GetRepository(tt *testing.T) {
	tt.Parallel()
	c := &CheckSuitePreferenceResults{}
	c.GetRepository()
	c = nil
	c.GetRepository()
}

func TestClassroom_GetArchived(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &Classroom{Archived: &zeroValue}
	c.GetArchived()
	c = &Classroom{}
	c.GetArchived()
	c = nil
	c.GetArchived()
}

func TestClassroom_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	c := &Classroom{ID: &zeroValue}
	c.GetID()
	c = &Classroom{}
	c.GetID()
	c = nil
	c.GetID()
}

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

func TestClassroom_GetOrganization(tt *testing.T) {
	tt.Parallel()
	c := &Classroom{}
	c.GetOrganization()
	c = nil
	c.GetOrganization()
}

func TestClassroom_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &Classroom{URL: &zeroValue}
	c.GetURL()
	c = &Classroom{}
	c.GetURL()
	c = nil
	c.GetURL()
}

func TestClassroomAssignment_GetAccepted(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &ClassroomAssignment{Accepted: &zeroValue}
	c.GetAccepted()
	c = &ClassroomAssignment{}
	c.GetAccepted()
	c = nil
	c.GetAccepted()
}

func TestClassroomAssignment_GetClassroom(tt *testing.T) {
	tt.Parallel()
	c := &ClassroomAssignment{}
	c.GetClassroom()
	c = nil
	c.GetClassroom()
}

func TestClassroomAssignment_GetDeadline(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	c := &ClassroomAssignment{Deadline: &zeroValue}
	c.GetDeadline()
	c = &ClassroomAssignment{}
	c.GetDeadline()
	c = nil
	c.GetDeadline()
}

func TestClassroomAssignment_GetEditor(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ClassroomAssignment{Editor: &zeroValue}
	c.GetEditor()
	c = &ClassroomAssignment{}
	c.GetEditor()
	c = nil
	c.GetEditor()
}

func TestClassroomAssignment_GetFeedbackPullRequestsEnabled(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &ClassroomAssignment{FeedbackPullRequestsEnabled: &zeroValue}
	c.GetFeedbackPullRequestsEnabled()
	c = &ClassroomAssignment{}
	c.GetFeedbackPullRequestsEnabled()
	c = nil
	c.GetFeedbackPullRequestsEnabled()
}

func TestClassroomAssignment_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	c := &ClassroomAssignment{ID: &zeroValue}
	c.GetID()
	c = &ClassroomAssignment{}
	c.GetID()
	c = nil
	c.GetID()
}

func TestClassroomAssignment_GetInvitationsEnabled(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &ClassroomAssignment{InvitationsEnabled: &zeroValue}
	c.GetInvitationsEnabled()
	c = &ClassroomAssignment{}
	c.GetInvitationsEnabled()
	c = nil
	c.GetInvitationsEnabled()
}

func TestClassroomAssignment_GetInviteLink(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ClassroomAssignment{InviteLink: &zeroValue}
	c.GetInviteLink()
	c = &ClassroomAssignment{}
	c.GetInviteLink()
	c = nil
	c.GetInviteLink()
}

func TestClassroomAssignment_GetLanguage(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ClassroomAssignment{Language: &zeroValue}
	c.GetLanguage()
	c = &ClassroomAssignment{}
	c.GetLanguage()
	c = nil
	c.GetLanguage()
}

func TestClassroomAssignment_GetMaxMembers(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &ClassroomAssignment{MaxMembers: &zeroValue}
	c.GetMaxMembers()
	c = &ClassroomAssignment{}
	c.GetMaxMembers()
	c = nil
	c.GetMaxMembers()
}

func TestClassroomAssignment_GetMaxTeams(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &ClassroomAssignment{MaxTeams: &zeroValue}
	c.GetMaxTeams()
	c = &ClassroomAssignment{}
	c.GetMaxTeams()
	c = nil
	c.GetMaxTeams()
}

func TestClassroomAssignment_GetPassing(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &ClassroomAssignment{Passing: &zeroValue}
	c.GetPassing()
	c = &ClassroomAssignment{}
	c.GetPassing()
	c = nil
	c.GetPassing()
}

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

func TestClassroomAssignment_GetSlug(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ClassroomAssignment{Slug: &zeroValue}
	c.GetSlug()
	c = &ClassroomAssignment{}
	c.GetSlug()
	c = nil
	c.GetSlug()
}

func TestClassroomAssignment_GetStarterCodeRepository(tt *testing.T) {
	tt.Parallel()
	c := &ClassroomAssignment{}
	c.GetStarterCodeRepository()
	c = nil
	c.GetStarterCodeRepository()
}

func TestClassroomAssignment_GetStudentsAreRepoAdmins(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &ClassroomAssignment{StudentsAreRepoAdmins: &zeroValue}
	c.GetStudentsAreRepoAdmins()
	c = &ClassroomAssignment{}
	c.GetStudentsAreRepoAdmins()
	c = nil
	c.GetStudentsAreRepoAdmins()
}

func TestClassroomAssignment_GetSubmitted(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &ClassroomAssignment{Submitted: &zeroValue}
	c.GetSubmitted()
	c = &ClassroomAssignment{}
	c.GetSubmitted()
	c = nil
	c.GetSubmitted()
}

func TestClassroomAssignment_GetTitle(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ClassroomAssignment{Title: &zeroValue}
	c.GetTitle()
	c = &ClassroomAssignment{}
	c.GetTitle()
	c = nil
	c.GetTitle()
}

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

func TestClassroomUser_GetAvatarURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ClassroomUser{AvatarURL: &zeroValue}
	c.GetAvatarURL()
	c = &ClassroomUser{}
	c.GetAvatarURL()
	c = nil
	c.GetAvatarURL()
}

func TestClassroomUser_GetHTMLURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ClassroomUser{HTMLURL: &zeroValue}
	c.GetHTMLURL()
	c = &ClassroomUser{}
	c.GetHTMLURL()
	c = nil
	c.GetHTMLURL()
}

func TestClassroomUser_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	c := &ClassroomUser{ID: &zeroValue}
	c.GetID()
	c = &ClassroomUser{}
	c.GetID()
	c = nil
	c.GetID()
}

func TestClassroomUser_GetLogin(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ClassroomUser{Login: &zeroValue}
	c.GetLogin()
	c = &ClassroomUser{}
	c.GetLogin()
	c = nil
	c.GetLogin()
}

func TestClusterArtifactDeployment_GetDeploymentName(tt *testing.T) {
	tt.Parallel()
	c := &ClusterArtifactDeployment{}
	c.GetDeploymentName()
	c = nil
	c.GetDeploymentName()
}

func TestClusterArtifactDeployment_GetDigest(tt *testing.T) {
	tt.Parallel()
	c := &ClusterArtifactDeployment{}
	c.GetDigest()
	c = nil
	c.GetDigest()
}

func TestClusterArtifactDeployment_GetGithubRepository(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ClusterArtifactDeployment{GithubRepository: &zeroValue}
	c.GetGithubRepository()
	c = &ClusterArtifactDeployment{}
	c.GetGithubRepository()
	c = nil
	c.GetGithubRepository()
}

func TestClusterArtifactDeployment_GetName(tt *testing.T) {
	tt.Parallel()
	c := &ClusterArtifactDeployment{}
	c.GetName()
	c = nil
	c.GetName()
}

func TestClusterArtifactDeployment_GetRuntimeRisks(tt *testing.T) {
	tt.Parallel()
	zeroValue := []DeploymentRuntimeRisk{}
	c := &ClusterArtifactDeployment{RuntimeRisks: zeroValue}
	c.GetRuntimeRisks()
	c = &ClusterArtifactDeployment{}
	c.GetRuntimeRisks()
	c = nil
	c.GetRuntimeRisks()
}

func TestClusterArtifactDeployment_GetStatus(tt *testing.T) {
	tt.Parallel()
	c := &ClusterArtifactDeployment{}
	c.GetStatus()
	c = nil
	c.GetStatus()
}

func TestClusterArtifactDeployment_GetTags(tt *testing.T) {
	tt.Parallel()
	zeroValue := map[string]string{}
	c := &ClusterArtifactDeployment{Tags: zeroValue}
	c.GetTags()
	c = &ClusterArtifactDeployment{}
	c.GetTags()
	c = nil
	c.GetTags()
}

func TestClusterArtifactDeployment_GetVersion(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ClusterArtifactDeployment{Version: &zeroValue}
	c.GetVersion()
	c = &ClusterArtifactDeployment{}
	c.GetVersion()
	c = nil
	c.GetVersion()
}

func TestClusterDeploymentRecordsRequest_GetDeployments(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*ClusterArtifactDeployment{}
	c := &ClusterDeploymentRecordsRequest{Deployments: zeroValue}
	c.GetDeployments()
	c = &ClusterDeploymentRecordsRequest{}
	c.GetDeployments()
	c = nil
	c.GetDeployments()
}

func TestClusterDeploymentRecordsRequest_GetLogicalEnvironment(tt *testing.T) {
	tt.Parallel()
	c := &ClusterDeploymentRecordsRequest{}
	c.GetLogicalEnvironment()
	c = nil
	c.GetLogicalEnvironment()
}

func TestClusterDeploymentRecordsRequest_GetPhysicalEnvironment(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ClusterDeploymentRecordsRequest{PhysicalEnvironment: &zeroValue}
	c.GetPhysicalEnvironment()
	c = &ClusterDeploymentRecordsRequest{}
	c.GetPhysicalEnvironment()
	c = nil
	c.GetPhysicalEnvironment()
}

func TestClusterSSHKey_GetFingerprint(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ClusterSSHKey{Fingerprint: &zeroValue}
	c.GetFingerprint()
	c = &ClusterSSHKey{}
	c.GetFingerprint()
	c = nil
	c.GetFingerprint()
}

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

func TestClusterStatus_GetNodes(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*ClusterStatusNode{}
	c := &ClusterStatus{Nodes: zeroValue}
	c.GetNodes()
	c = &ClusterStatus{}
	c.GetNodes()
	c = nil
	c.GetNodes()
}

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

func TestClusterStatusNode_GetHostname(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ClusterStatusNode{Hostname: &zeroValue}
	c.GetHostname()
	c = &ClusterStatusNode{}
	c.GetHostname()
	c = nil
	c.GetHostname()
}

func TestClusterStatusNode_GetServices(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*ClusterStatusNodeServiceItem{}
	c := &ClusterStatusNode{Services: zeroValue}
	c.GetServices()
	c = &ClusterStatusNode{}
	c.GetServices()
	c = nil
	c.GetServices()
}

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

func TestClusterStatusNodeServiceItem_GetDetails(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ClusterStatusNodeServiceItem{Details: &zeroValue}
	c.GetDetails()
	c = &ClusterStatusNodeServiceItem{}
	c.GetDetails()
	c = nil
	c.GetDetails()
}

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

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

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

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

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

func TestCodeOfConduct_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CodeOfConduct{URL: &zeroValue}
	c.GetURL()
	c = &CodeOfConduct{}
	c.GetURL()
	c = nil
	c.GetURL()
}

func TestCodeownersError_GetColumn(tt *testing.T) {
	tt.Parallel()
	c := &CodeownersError{}
	c.GetColumn()
	c = nil
	c.GetColumn()
}

func TestCodeownersError_GetKind(tt *testing.T) {
	tt.Parallel()
	c := &CodeownersError{}
	c.GetKind()
	c = nil
	c.GetKind()
}

func TestCodeownersError_GetLine(tt *testing.T) {
	tt.Parallel()
	c := &CodeownersError{}
	c.GetLine()
	c = nil
	c.GetLine()
}

func TestCodeownersError_GetMessage(tt *testing.T) {
	tt.Parallel()
	c := &CodeownersError{}
	c.GetMessage()
	c = nil
	c.GetMessage()
}

func TestCodeownersError_GetPath(tt *testing.T) {
	tt.Parallel()
	c := &CodeownersError{}
	c.GetPath()
	c = nil
	c.GetPath()
}

func TestCodeownersError_GetSource(tt *testing.T) {
	tt.Parallel()
	c := &CodeownersError{}
	c.GetSource()
	c = nil
	c.GetSource()
}

func TestCodeownersError_GetSuggestion(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CodeownersError{Suggestion: &zeroValue}
	c.GetSuggestion()
	c = &CodeownersError{}
	c.GetSuggestion()
	c = nil
	c.GetSuggestion()
}

func TestCodeownersErrors_GetErrors(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*CodeownersError{}
	c := &CodeownersErrors{Errors: zeroValue}
	c.GetErrors()
	c = &CodeownersErrors{}
	c.GetErrors()
	c = nil
	c.GetErrors()
}

func TestCodeQLDatabase_GetContentType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CodeQLDatabase{ContentType: &zeroValue}
	c.GetContentType()
	c = &CodeQLDatabase{}
	c.GetContentType()
	c = nil
	c.GetContentType()
}

func TestCodeQLDatabase_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	c := &CodeQLDatabase{CreatedAt: &zeroValue}
	c.GetCreatedAt()
	c = &CodeQLDatabase{}
	c.GetCreatedAt()
	c = nil
	c.GetCreatedAt()
}

func TestCodeQLDatabase_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	c := &CodeQLDatabase{ID: &zeroValue}
	c.GetID()
	c = &CodeQLDatabase{}
	c.GetID()
	c = nil
	c.GetID()
}

func TestCodeQLDatabase_GetLanguage(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CodeQLDatabase{Language: &zeroValue}
	c.GetLanguage()
	c = &CodeQLDatabase{}
	c.GetLanguage()
	c = nil
	c.GetLanguage()
}

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

func TestCodeQLDatabase_GetSize(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	c := &CodeQLDatabase{Size: &zeroValue}
	c.GetSize()
	c = &CodeQLDatabase{}
	c.GetSize()
	c = nil
	c.GetSize()
}

func TestCodeQLDatabase_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	c := &CodeQLDatabase{UpdatedAt: &zeroValue}
	c.GetUpdatedAt()
	c = &CodeQLDatabase{}
	c.GetUpdatedAt()
	c = nil
	c.GetUpdatedAt()
}

func TestCodeQLDatabase_GetUploader(tt *testing.T) {
	tt.Parallel()
	c := &CodeQLDatabase{}
	c.GetUploader()
	c = nil
	c.GetUploader()
}

func TestCodeQLDatabase_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CodeQLDatabase{URL: &zeroValue}
	c.GetURL()
	c = &CodeQLDatabase{}
	c.GetURL()
	c = nil
	c.GetURL()
}

func TestCodeQualityFinding_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	c := &CodeQualityFinding{CreatedAt: &zeroValue}
	c.GetCreatedAt()
	c = &CodeQualityFinding{}
	c.GetCreatedAt()
	c = nil
	c.GetCreatedAt()
}

func TestCodeQualityFinding_GetLocation(tt *testing.T) {
	tt.Parallel()
	c := &CodeQualityFinding{}
	c.GetLocation()
	c = nil
	c.GetLocation()
}

func TestCodeQualityFinding_GetMessage(tt *testing.T) {
	tt.Parallel()
	c := &CodeQualityFinding{}
	c.GetMessage()
	c = nil
	c.GetMessage()
}

func TestCodeQualityFinding_GetNumber(tt *testing.T) {
	tt.Parallel()
	c := &CodeQualityFinding{}
	c.GetNumber()
	c = nil
	c.GetNumber()
}

func TestCodeQualityFinding_GetRule(tt *testing.T) {
	tt.Parallel()
	c := &CodeQualityFinding{}
	c.GetRule()
	c = nil
	c.GetRule()
}

func TestCodeQualityFinding_GetState(tt *testing.T) {
	tt.Parallel()
	c := &CodeQualityFinding{}
	c.GetState()
	c = nil
	c.GetState()
}

func TestCodeQualityFinding_GetURL(tt *testing.T) {
	tt.Parallel()
	c := &CodeQualityFinding{}
	c.GetURL()
	c = nil
	c.GetURL()
}

func TestCodeQualityFindingLocation_GetEndColumn(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CodeQualityFindingLocation{EndColumn: &zeroValue}
	c.GetEndColumn()
	c = &CodeQualityFindingLocation{}
	c.GetEndColumn()
	c = nil
	c.GetEndColumn()
}

func TestCodeQualityFindingLocation_GetEndLine(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CodeQualityFindingLocation{EndLine: &zeroValue}
	c.GetEndLine()
	c = &CodeQualityFindingLocation{}
	c.GetEndLine()
	c = nil
	c.GetEndLine()
}

func TestCodeQualityFindingLocation_GetPath(tt *testing.T) {
	tt.Parallel()
	c := &CodeQualityFindingLocation{}
	c.GetPath()
	c = nil
	c.GetPath()
}

func TestCodeQualityFindingLocation_GetStartColumn(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CodeQualityFindingLocation{StartColumn: &zeroValue}
	c.GetStartColumn()
	c = &CodeQualityFindingLocation{}
	c.GetStartColumn()
	c = nil
	c.GetStartColumn()
}

func TestCodeQualityFindingLocation_GetStartLine(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CodeQualityFindingLocation{StartLine: &zeroValue}
	c.GetStartLine()
	c = &CodeQualityFindingLocation{}
	c.GetStartLine()
	c = nil
	c.GetStartLine()
}

func TestCodeQualityFindingMessage_GetMarkdown(tt *testing.T) {
	tt.Parallel()
	c := &CodeQualityFindingMessage{}
	c.GetMarkdown()
	c = nil
	c.GetMarkdown()
}

func TestCodeQualityFindingMessage_GetText(tt *testing.T) {
	tt.Parallel()
	c := &CodeQualityFindingMessage{}
	c.GetText()
	c = nil
	c.GetText()
}

func TestCodeQualityFindingRule_GetCategory(tt *testing.T) {
	tt.Parallel()
	c := &CodeQualityFindingRule{}
	c.GetCategory()
	c = nil
	c.GetCategory()
}

func TestCodeQualityFindingRule_GetDescription(tt *testing.T) {
	tt.Parallel()
	c := &CodeQualityFindingRule{}
	c.GetDescription()
	c = nil
	c.GetDescription()
}

func TestCodeQualityFindingRule_GetHelp(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CodeQualityFindingRule{Help: &zeroValue}
	c.GetHelp()
	c = &CodeQualityFindingRule{}
	c.GetHelp()
	c = nil
	c.GetHelp()
}

func TestCodeQualityFindingRule_GetID(tt *testing.T) {
	tt.Parallel()
	c := &CodeQualityFindingRule{}
	c.GetID()
	c = nil
	c.GetID()
}

func TestCodeQualityFindingRule_GetSeverity(tt *testing.T) {
	tt.Parallel()
	c := &CodeQualityFindingRule{}
	c.GetSeverity()
	c = nil
	c.GetSeverity()
}

func TestCodeQualityFindingRule_GetTitle(tt *testing.T) {
	tt.Parallel()
	c := &CodeQualityFindingRule{}
	c.GetTitle()
	c = nil
	c.GetTitle()
}

func TestCodeQualitySetupConfiguration_GetLanguages(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	c := &CodeQualitySetupConfiguration{Languages: zeroValue}
	c.GetLanguages()
	c = &CodeQualitySetupConfiguration{}
	c.GetLanguages()
	c = nil
	c.GetLanguages()
}

func TestCodeQualitySetupConfiguration_GetRunnerLabel(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CodeQualitySetupConfiguration{RunnerLabel: &zeroValue}
	c.GetRunnerLabel()
	c = &CodeQualitySetupConfiguration{}
	c.GetRunnerLabel()
	c = nil
	c.GetRunnerLabel()
}

func TestCodeQualitySetupConfiguration_GetRunnerType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CodeQualitySetupConfiguration{RunnerType: &zeroValue}
	c.GetRunnerType()
	c = &CodeQualitySetupConfiguration{}
	c.GetRunnerType()
	c = nil
	c.GetRunnerType()
}

func TestCodeQualitySetupConfiguration_GetSchedule(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CodeQualitySetupConfiguration{Schedule: &zeroValue}
	c.GetSchedule()
	c = &CodeQualitySetupConfiguration{}
	c.GetSchedule()
	c = nil
	c.GetSchedule()
}

func TestCodeQualitySetupConfiguration_GetState(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CodeQualitySetupConfiguration{State: &zeroValue}
	c.GetState()
	c = &CodeQualitySetupConfiguration{}
	c.GetState()
	c = nil
	c.GetState()
}

func TestCodeQualitySetupConfiguration_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	c := &CodeQualitySetupConfiguration{UpdatedAt: &zeroValue}
	c.GetUpdatedAt()
	c = &CodeQualitySetupConfiguration{}
	c.GetUpdatedAt()
	c = nil
	c.GetUpdatedAt()
}

func TestCodeQualityUpdateSetupRequest_GetLanguages(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	c := &CodeQualityUpdateSetupRequest{Languages: zeroValue}
	c.GetLanguages()
	c = &CodeQualityUpdateSetupRequest{}
	c.GetLanguages()
	c = nil
	c.GetLanguages()
}

func TestCodeQualityUpdateSetupRequest_GetRunnerLabel(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CodeQualityUpdateSetupRequest{RunnerLabel: &zeroValue}
	c.GetRunnerLabel()
	c = &CodeQualityUpdateSetupRequest{}
	c.GetRunnerLabel()
	c = nil
	c.GetRunnerLabel()
}

func TestCodeQualityUpdateSetupRequest_GetRunnerType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CodeQualityUpdateSetupRequest{RunnerType: &zeroValue}
	c.GetRunnerType()
	c = &CodeQualityUpdateSetupRequest{}
	c.GetRunnerType()
	c = nil
	c.GetRunnerType()
}

func TestCodeQualityUpdateSetupRequest_GetState(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CodeQualityUpdateSetupRequest{State: &zeroValue}
	c.GetState()
	c = &CodeQualityUpdateSetupRequest{}
	c.GetState()
	c = nil
	c.GetState()
}

func TestCodeQualityUpdateSetupResponse_GetRunID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	c := &CodeQualityUpdateSetupResponse{RunID: &zeroValue}
	c.GetRunID()
	c = &CodeQualityUpdateSetupResponse{}
	c.GetRunID()
	c = nil
	c.GetRunID()
}

func TestCodeQualityUpdateSetupResponse_GetRunURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CodeQualityUpdateSetupResponse{RunURL: &zeroValue}
	c.GetRunURL()
	c = &CodeQualityUpdateSetupResponse{}
	c.GetRunURL()
	c = nil
	c.GetRunURL()
}

func TestCodeResult_GetHTMLURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CodeResult{HTMLURL: &zeroValue}
	c.GetHTMLURL()
	c = &CodeResult{}
	c.GetHTMLURL()
	c = nil
	c.GetHTMLURL()
}

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

func TestCodeResult_GetPath(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CodeResult{Path: &zeroValue}
	c.GetPath()
	c = &CodeResult{}
	c.GetPath()
	c = nil
	c.GetPath()
}

func TestCodeResult_GetRepository(tt *testing.T) {
	tt.Parallel()
	c := &CodeResult{}
	c.GetRepository()
	c = nil
	c.GetRepository()
}

func TestCodeResult_GetSHA(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CodeResult{SHA: &zeroValue}
	c.GetSHA()
	c = &CodeResult{}
	c.GetSHA()
	c = nil
	c.GetSHA()
}

func TestCodeResult_GetTextMatches(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*TextMatch{}
	c := &CodeResult{TextMatches: zeroValue}
	c.GetTextMatches()
	c = &CodeResult{}
	c.GetTextMatches()
	c = nil
	c.GetTextMatches()
}

func TestCodeScanningAlertEvent_GetAction(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CodeScanningAlertEvent{Action: &zeroValue}
	c.GetAction()
	c = &CodeScanningAlertEvent{}
	c.GetAction()
	c = nil
	c.GetAction()
}

func TestCodeScanningAlertEvent_GetAlert(tt *testing.T) {
	tt.Parallel()
	c := &CodeScanningAlertEvent{}
	c.GetAlert()
	c = nil
	c.GetAlert()
}

func TestCodeScanningAlertEvent_GetCommitOID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CodeScanningAlertEvent{CommitOID: &zeroValue}
	c.GetCommitOID()
	c = &CodeScanningAlertEvent{}
	c.GetCommitOID()
	c = nil
	c.GetCommitOID()
}

func TestCodeScanningAlertEvent_GetInstallation(tt *testing.T) {
	tt.Parallel()
	c := &CodeScanningAlertEvent{}
	c.GetInstallation()
	c = nil
	c.GetInstallation()
}

func TestCodeScanningAlertEvent_GetOrg(tt *testing.T) {
	tt.Parallel()
	c := &CodeScanningAlertEvent{}
	c.GetOrg()
	c = nil
	c.GetOrg()
}

func TestCodeScanningAlertEvent_GetRef(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CodeScanningAlertEvent{Ref: &zeroValue}
	c.GetRef()
	c = &CodeScanningAlertEvent{}
	c.GetRef()
	c = nil
	c.GetRef()
}

func TestCodeScanningAlertEvent_GetRepo(tt *testing.T) {
	tt.Parallel()
	c := &CodeScanningAlertEvent{}
	c.GetRepo()
	c = nil
	c.GetRepo()
}

func TestCodeScanningAlertEvent_GetSender(tt *testing.T) {
	tt.Parallel()
	c := &CodeScanningAlertEvent{}
	c.GetSender()
	c = nil
	c.GetSender()
}

func TestCodeScanningAlertState_GetDismissedComment(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CodeScanningAlertState{DismissedComment: &zeroValue}
	c.GetDismissedComment()
	c = &CodeScanningAlertState{}
	c.GetDismissedComment()
	c = nil
	c.GetDismissedComment()
}

func TestCodeScanningAlertState_GetDismissedReason(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CodeScanningAlertState{DismissedReason: &zeroValue}
	c.GetDismissedReason()
	c = &CodeScanningAlertState{}
	c.GetDismissedReason()
	c = nil
	c.GetDismissedReason()
}

func TestCodeScanningAlertState_GetState(tt *testing.T) {
	tt.Parallel()
	c := &CodeScanningAlertState{}
	c.GetState()
	c = nil
	c.GetState()
}

func TestCodeScanningBranchRule_GetParameters(tt *testing.T) {
	tt.Parallel()
	c := &CodeScanningBranchRule{}
	c.GetParameters()
	c = nil
	c.GetParameters()
}

func TestCodeScanningDefaultSetupOptions_GetRunnerLabel(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CodeScanningDefaultSetupOptions{RunnerLabel: &zeroValue}
	c.GetRunnerLabel()
	c = &CodeScanningDefaultSetupOptions{}
	c.GetRunnerLabel()
	c = nil
	c.GetRunnerLabel()
}

func TestCodeScanningDefaultSetupOptions_GetRunnerType(tt *testing.T) {
	tt.Parallel()
	c := &CodeScanningDefaultSetupOptions{}
	c.GetRunnerType()
	c = nil
	c.GetRunnerType()
}

func TestCodeScanningOptions_GetAllowAdvanced(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &CodeScanningOptions{AllowAdvanced: &zeroValue}
	c.GetAllowAdvanced()
	c = &CodeScanningOptions{}
	c.GetAllowAdvanced()
	c = nil
	c.GetAllowAdvanced()
}

func TestCodeScanningRuleParameters_GetCodeScanningTools(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*RuleCodeScanningTool{}
	c := &CodeScanningRuleParameters{CodeScanningTools: zeroValue}
	c.GetCodeScanningTools()
	c = &CodeScanningRuleParameters{}
	c.GetCodeScanningTools()
	c = nil
	c.GetCodeScanningTools()
}

func TestCodeSearchResult_GetCodeResults(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*CodeResult{}
	c := &CodeSearchResult{CodeResults: zeroValue}
	c.GetCodeResults()
	c = &CodeSearchResult{}
	c.GetCodeResults()
	c = nil
	c.GetCodeResults()
}

func TestCodeSearchResult_GetIncompleteResults(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &CodeSearchResult{IncompleteResults: &zeroValue}
	c.GetIncompleteResults()
	c = &CodeSearchResult{}
	c.GetIncompleteResults()
	c = nil
	c.GetIncompleteResults()
}

func TestCodeSearchResult_GetTotal(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CodeSearchResult{Total: &zeroValue}
	c.GetTotal()
	c = &CodeSearchResult{}
	c.GetTotal()
	c = nil
	c.GetTotal()
}

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

func TestCodeSecurityConfiguration_GetAdvancedSecurity(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CodeSecurityConfiguration{AdvancedSecurity: &zeroValue}
	c.GetAdvancedSecurity()
	c = &CodeSecurityConfiguration{}
	c.GetAdvancedSecurity()
	c = nil
	c.GetAdvancedSecurity()
}

func TestCodeSecurityConfiguration_GetCodeScanningDefaultSetup(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CodeSecurityConfiguration{CodeScanningDefaultSetup: &zeroValue}
	c.GetCodeScanningDefaultSetup()
	c = &CodeSecurityConfiguration{}
	c.GetCodeScanningDefaultSetup()
	c = nil
	c.GetCodeScanningDefaultSetup()
}

func TestCodeSecurityConfiguration_GetCodeScanningDefaultSetupOptions(tt *testing.T) {
	tt.Parallel()
	c := &CodeSecurityConfiguration{}
	c.GetCodeScanningDefaultSetupOptions()
	c = nil
	c.GetCodeScanningDefaultSetupOptions()
}

func TestCodeSecurityConfiguration_GetCodeScanningDelegatedAlertDismissal(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CodeSecurityConfiguration{CodeScanningDelegatedAlertDismissal: &zeroValue}
	c.GetCodeScanningDelegatedAlertDismissal()
	c = &CodeSecurityConfiguration{}
	c.GetCodeScanningDelegatedAlertDismissal()
	c = nil
	c.GetCodeScanningDelegatedAlertDismissal()
}

func TestCodeSecurityConfiguration_GetCodeScanningOptions(tt *testing.T) {
	tt.Parallel()
	c := &CodeSecurityConfiguration{}
	c.GetCodeScanningOptions()
	c = nil
	c.GetCodeScanningOptions()
}

func TestCodeSecurityConfiguration_GetCodeSecurity(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CodeSecurityConfiguration{CodeSecurity: &zeroValue}
	c.GetCodeSecurity()
	c = &CodeSecurityConfiguration{}
	c.GetCodeSecurity()
	c = nil
	c.GetCodeSecurity()
}

func TestCodeSecurityConfiguration_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	c := &CodeSecurityConfiguration{CreatedAt: &zeroValue}
	c.GetCreatedAt()
	c = &CodeSecurityConfiguration{}
	c.GetCreatedAt()
	c = nil
	c.GetCreatedAt()
}

func TestCodeSecurityConfiguration_GetDependabotAlerts(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CodeSecurityConfiguration{DependabotAlerts: &zeroValue}
	c.GetDependabotAlerts()
	c = &CodeSecurityConfiguration{}
	c.GetDependabotAlerts()
	c = nil
	c.GetDependabotAlerts()
}

func TestCodeSecurityConfiguration_GetDependabotDelegatedAlertDismissal(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CodeSecurityConfiguration{DependabotDelegatedAlertDismissal: &zeroValue}
	c.GetDependabotDelegatedAlertDismissal()
	c = &CodeSecurityConfiguration{}
	c.GetDependabotDelegatedAlertDismissal()
	c = nil
	c.GetDependabotDelegatedAlertDismissal()
}

func TestCodeSecurityConfiguration_GetDependabotSecurityUpdates(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CodeSecurityConfiguration{DependabotSecurityUpdates: &zeroValue}
	c.GetDependabotSecurityUpdates()
	c = &CodeSecurityConfiguration{}
	c.GetDependabotSecurityUpdates()
	c = nil
	c.GetDependabotSecurityUpdates()
}

func TestCodeSecurityConfiguration_GetDependencyGraph(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CodeSecurityConfiguration{DependencyGraph: &zeroValue}
	c.GetDependencyGraph()
	c = &CodeSecurityConfiguration{}
	c.GetDependencyGraph()
	c = nil
	c.GetDependencyGraph()
}

func TestCodeSecurityConfiguration_GetDependencyGraphAutosubmitAction(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CodeSecurityConfiguration{DependencyGraphAutosubmitAction: &zeroValue}
	c.GetDependencyGraphAutosubmitAction()
	c = &CodeSecurityConfiguration{}
	c.GetDependencyGraphAutosubmitAction()
	c = nil
	c.GetDependencyGraphAutosubmitAction()
}

func TestCodeSecurityConfiguration_GetDependencyGraphAutosubmitActionOptions(tt *testing.T) {
	tt.Parallel()
	c := &CodeSecurityConfiguration{}
	c.GetDependencyGraphAutosubmitActionOptions()
	c = nil
	c.GetDependencyGraphAutosubmitActionOptions()
}

func TestCodeSecurityConfiguration_GetDescription(tt *testing.T) {
	tt.Parallel()
	c := &CodeSecurityConfiguration{}
	c.GetDescription()
	c = nil
	c.GetDescription()
}

func TestCodeSecurityConfiguration_GetEnforcement(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CodeSecurityConfiguration{Enforcement: &zeroValue}
	c.GetEnforcement()
	c = &CodeSecurityConfiguration{}
	c.GetEnforcement()
	c = nil
	c.GetEnforcement()
}

func TestCodeSecurityConfiguration_GetHTMLURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CodeSecurityConfiguration{HTMLURL: &zeroValue}
	c.GetHTMLURL()
	c = &CodeSecurityConfiguration{}
	c.GetHTMLURL()
	c = nil
	c.GetHTMLURL()
}

func TestCodeSecurityConfiguration_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	c := &CodeSecurityConfiguration{ID: &zeroValue}
	c.GetID()
	c = &CodeSecurityConfiguration{}
	c.GetID()
	c = nil
	c.GetID()
}

func TestCodeSecurityConfiguration_GetName(tt *testing.T) {
	tt.Parallel()
	c := &CodeSecurityConfiguration{}
	c.GetName()
	c = nil
	c.GetName()
}

func TestCodeSecurityConfiguration_GetPrivateVulnerabilityReporting(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CodeSecurityConfiguration{PrivateVulnerabilityReporting: &zeroValue}
	c.GetPrivateVulnerabilityReporting()
	c = &CodeSecurityConfiguration{}
	c.GetPrivateVulnerabilityReporting()
	c = nil
	c.GetPrivateVulnerabilityReporting()
}

func TestCodeSecurityConfiguration_GetSecretProtection(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CodeSecurityConfiguration{SecretProtection: &zeroValue}
	c.GetSecretProtection()
	c = &CodeSecurityConfiguration{}
	c.GetSecretProtection()
	c = nil
	c.GetSecretProtection()
}

func TestCodeSecurityConfiguration_GetSecretScanning(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CodeSecurityConfiguration{SecretScanning: &zeroValue}
	c.GetSecretScanning()
	c = &CodeSecurityConfiguration{}
	c.GetSecretScanning()
	c = nil
	c.GetSecretScanning()
}

func TestCodeSecurityConfiguration_GetSecretScanningDelegatedAlertDismissal(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CodeSecurityConfiguration{SecretScanningDelegatedAlertDismissal: &zeroValue}
	c.GetSecretScanningDelegatedAlertDismissal()
	c = &CodeSecurityConfiguration{}
	c.GetSecretScanningDelegatedAlertDismissal()
	c = nil
	c.GetSecretScanningDelegatedAlertDismissal()
}

func TestCodeSecurityConfiguration_GetSecretScanningDelegatedBypass(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CodeSecurityConfiguration{SecretScanningDelegatedBypass: &zeroValue}
	c.GetSecretScanningDelegatedBypass()
	c = &CodeSecurityConfiguration{}
	c.GetSecretScanningDelegatedBypass()
	c = nil
	c.GetSecretScanningDelegatedBypass()
}

func TestCodeSecurityConfiguration_GetSecretScanningDelegatedBypassOptions(tt *testing.T) {
	tt.Parallel()
	c := &CodeSecurityConfiguration{}
	c.GetSecretScanningDelegatedBypassOptions()
	c = nil
	c.GetSecretScanningDelegatedBypassOptions()
}

func TestCodeSecurityConfiguration_GetSecretScanningExtendedMetadata(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CodeSecurityConfiguration{SecretScanningExtendedMetadata: &zeroValue}
	c.GetSecretScanningExtendedMetadata()
	c = &CodeSecurityConfiguration{}
	c.GetSecretScanningExtendedMetadata()
	c = nil
	c.GetSecretScanningExtendedMetadata()
}

func TestCodeSecurityConfiguration_GetSecretScanningGenericSecrets(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CodeSecurityConfiguration{SecretScanningGenericSecrets: &zeroValue}
	c.GetSecretScanningGenericSecrets()
	c = &CodeSecurityConfiguration{}
	c.GetSecretScanningGenericSecrets()
	c = nil
	c.GetSecretScanningGenericSecrets()
}

func TestCodeSecurityConfiguration_GetSecretScanningNonProviderPatterns(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CodeSecurityConfiguration{SecretScanningNonProviderPatterns: &zeroValue}
	c.GetSecretScanningNonProviderPatterns()
	c = &CodeSecurityConfiguration{}
	c.GetSecretScanningNonProviderPatterns()
	c = nil
	c.GetSecretScanningNonProviderPatterns()
}

func TestCodeSecurityConfiguration_GetSecretScanningPushProtection(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CodeSecurityConfiguration{SecretScanningPushProtection: &zeroValue}
	c.GetSecretScanningPushProtection()
	c = &CodeSecurityConfiguration{}
	c.GetSecretScanningPushProtection()
	c = nil
	c.GetSecretScanningPushProtection()
}

func TestCodeSecurityConfiguration_GetSecretScanningValidityChecks(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CodeSecurityConfiguration{SecretScanningValidityChecks: &zeroValue}
	c.GetSecretScanningValidityChecks()
	c = &CodeSecurityConfiguration{}
	c.GetSecretScanningValidityChecks()
	c = nil
	c.GetSecretScanningValidityChecks()
}

func TestCodeSecurityConfiguration_GetTargetType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CodeSecurityConfiguration{TargetType: &zeroValue}
	c.GetTargetType()
	c = &CodeSecurityConfiguration{}
	c.GetTargetType()
	c = nil
	c.GetTargetType()
}

func TestCodeSecurityConfiguration_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	c := &CodeSecurityConfiguration{UpdatedAt: &zeroValue}
	c.GetUpdatedAt()
	c = &CodeSecurityConfiguration{}
	c.GetUpdatedAt()
	c = nil
	c.GetUpdatedAt()
}

func TestCodeSecurityConfiguration_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CodeSecurityConfiguration{URL: &zeroValue}
	c.GetURL()
	c = &CodeSecurityConfiguration{}
	c.GetURL()
	c = nil
	c.GetURL()
}

func TestCodeSecurityConfigurationWithDefaultForNewRepos_GetConfiguration(tt *testing.T) {
	tt.Parallel()
	c := &CodeSecurityConfigurationWithDefaultForNewRepos{}
	c.GetConfiguration()
	c = nil
	c.GetConfiguration()
}

func TestCodeSecurityConfigurationWithDefaultForNewRepos_GetDefaultForNewRepos(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CodeSecurityConfigurationWithDefaultForNewRepos{DefaultForNewRepos: &zeroValue}
	c.GetDefaultForNewRepos()
	c = &CodeSecurityConfigurationWithDefaultForNewRepos{}
	c.GetDefaultForNewRepos()
	c = nil
	c.GetDefaultForNewRepos()
}

func TestCodespace_GetBillableOwner(tt *testing.T) {
	tt.Parallel()
	c := &Codespace{}
	c.GetBillableOwner()
	c = nil
	c.GetBillableOwner()
}

func TestCodespace_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	c := &Codespace{CreatedAt: &zeroValue}
	c.GetCreatedAt()
	c = &Codespace{}
	c.GetCreatedAt()
	c = nil
	c.GetCreatedAt()
}

func TestCodespace_GetDevcontainerPath(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &Codespace{DevcontainerPath: &zeroValue}
	c.GetDevcontainerPath()
	c = &Codespace{}
	c.GetDevcontainerPath()
	c = nil
	c.GetDevcontainerPath()
}

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

func TestCodespace_GetEnvironmentID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &Codespace{EnvironmentID: &zeroValue}
	c.GetEnvironmentID()
	c = &Codespace{}
	c.GetEnvironmentID()
	c = nil
	c.GetEnvironmentID()
}

func TestCodespace_GetGitStatus(tt *testing.T) {
	tt.Parallel()
	c := &Codespace{}
	c.GetGitStatus()
	c = nil
	c.GetGitStatus()
}

func TestCodespace_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	c := &Codespace{ID: &zeroValue}
	c.GetID()
	c = &Codespace{}
	c.GetID()
	c = nil
	c.GetID()
}

func TestCodespace_GetIdleTimeoutMinutes(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &Codespace{IdleTimeoutMinutes: &zeroValue}
	c.GetIdleTimeoutMinutes()
	c = &Codespace{}
	c.GetIdleTimeoutMinutes()
	c = nil
	c.GetIdleTimeoutMinutes()
}

func TestCodespace_GetIdleTimeoutNotice(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &Codespace{IdleTimeoutNotice: &zeroValue}
	c.GetIdleTimeoutNotice()
	c = &Codespace{}
	c.GetIdleTimeoutNotice()
	c = nil
	c.GetIdleTimeoutNotice()
}

func TestCodespace_GetLastKnownStopNotice(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &Codespace{LastKnownStopNotice: &zeroValue}
	c.GetLastKnownStopNotice()
	c = &Codespace{}
	c.GetLastKnownStopNotice()
	c = nil
	c.GetLastKnownStopNotice()
}

func TestCodespace_GetLastUsedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	c := &Codespace{LastUsedAt: &zeroValue}
	c.GetLastUsedAt()
	c = &Codespace{}
	c.GetLastUsedAt()
	c = nil
	c.GetLastUsedAt()
}

func TestCodespace_GetLocation(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &Codespace{Location: &zeroValue}
	c.GetLocation()
	c = &Codespace{}
	c.GetLocation()
	c = nil
	c.GetLocation()
}

func TestCodespace_GetMachine(tt *testing.T) {
	tt.Parallel()
	c := &Codespace{}
	c.GetMachine()
	c = nil
	c.GetMachine()
}

func TestCodespace_GetMachinesURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &Codespace{MachinesURL: &zeroValue}
	c.GetMachinesURL()
	c = &Codespace{}
	c.GetMachinesURL()
	c = nil
	c.GetMachinesURL()
}

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

func TestCodespace_GetOwner(tt *testing.T) {
	tt.Parallel()
	c := &Codespace{}
	c.GetOwner()
	c = nil
	c.GetOwner()
}

func TestCodespace_GetPendingOperation(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &Codespace{PendingOperation: &zeroValue}
	c.GetPendingOperation()
	c = &Codespace{}
	c.GetPendingOperation()
	c = nil
	c.GetPendingOperation()
}

func TestCodespace_GetPendingOperationDisabledReason(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &Codespace{PendingOperationDisabledReason: &zeroValue}
	c.GetPendingOperationDisabledReason()
	c = &Codespace{}
	c.GetPendingOperationDisabledReason()
	c = nil
	c.GetPendingOperationDisabledReason()
}

func TestCodespace_GetPrebuild(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &Codespace{Prebuild: &zeroValue}
	c.GetPrebuild()
	c = &Codespace{}
	c.GetPrebuild()
	c = nil
	c.GetPrebuild()
}

func TestCodespace_GetPullsURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &Codespace{PullsURL: &zeroValue}
	c.GetPullsURL()
	c = &Codespace{}
	c.GetPullsURL()
	c = nil
	c.GetPullsURL()
}

func TestCodespace_GetRecentFolders(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	c := &Codespace{RecentFolders: zeroValue}
	c.GetRecentFolders()
	c = &Codespace{}
	c.GetRecentFolders()
	c = nil
	c.GetRecentFolders()
}

func TestCodespace_GetRepository(tt *testing.T) {
	tt.Parallel()
	c := &Codespace{}
	c.GetRepository()
	c = nil
	c.GetRepository()
}

func TestCodespace_GetRetentionExpiresAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	c := &Codespace{RetentionExpiresAt: &zeroValue}
	c.GetRetentionExpiresAt()
	c = &Codespace{}
	c.GetRetentionExpiresAt()
	c = nil
	c.GetRetentionExpiresAt()
}

func TestCodespace_GetRetentionPeriodMinutes(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &Codespace{RetentionPeriodMinutes: &zeroValue}
	c.GetRetentionPeriodMinutes()
	c = &Codespace{}
	c.GetRetentionPeriodMinutes()
	c = nil
	c.GetRetentionPeriodMinutes()
}

func TestCodespace_GetRuntimeConstraints(tt *testing.T) {
	tt.Parallel()
	c := &Codespace{}
	c.GetRuntimeConstraints()
	c = nil
	c.GetRuntimeConstraints()
}

func TestCodespace_GetStartURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &Codespace{StartURL: &zeroValue}
	c.GetStartURL()
	c = &Codespace{}
	c.GetStartURL()
	c = nil
	c.GetStartURL()
}

func TestCodespace_GetState(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &Codespace{State: &zeroValue}
	c.GetState()
	c = &Codespace{}
	c.GetState()
	c = nil
	c.GetState()
}

func TestCodespace_GetStopURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &Codespace{StopURL: &zeroValue}
	c.GetStopURL()
	c = &Codespace{}
	c.GetStopURL()
	c = nil
	c.GetStopURL()
}

func TestCodespace_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	c := &Codespace{UpdatedAt: &zeroValue}
	c.GetUpdatedAt()
	c = &Codespace{}
	c.GetUpdatedAt()
	c = nil
	c.GetUpdatedAt()
}

func TestCodespace_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &Codespace{URL: &zeroValue}
	c.GetURL()
	c = &Codespace{}
	c.GetURL()
	c = nil
	c.GetURL()
}

func TestCodespace_GetWebURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &Codespace{WebURL: &zeroValue}
	c.GetWebURL()
	c = &Codespace{}
	c.GetWebURL()
	c = nil
	c.GetWebURL()
}

func TestCodespaceCreateForUserOptions_GetClientIP(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CodespaceCreateForUserOptions{ClientIP: &zeroValue}
	c.GetClientIP()
	c = &CodespaceCreateForUserOptions{}
	c.GetClientIP()
	c = nil
	c.GetClientIP()
}

func TestCodespaceCreateForUserOptions_GetDevcontainerPath(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CodespaceCreateForUserOptions{DevcontainerPath: &zeroValue}
	c.GetDevcontainerPath()
	c = &CodespaceCreateForUserOptions{}
	c.GetDevcontainerPath()
	c = nil
	c.GetDevcontainerPath()
}

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

func TestCodespaceCreateForUserOptions_GetGeo(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CodespaceCreateForUserOptions{Geo: &zeroValue}
	c.GetGeo()
	c = &CodespaceCreateForUserOptions{}
	c.GetGeo()
	c = nil
	c.GetGeo()
}

func TestCodespaceCreateForUserOptions_GetIdleTimeoutMinutes(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CodespaceCreateForUserOptions{IdleTimeoutMinutes: &zeroValue}
	c.GetIdleTimeoutMinutes()
	c = &CodespaceCreateForUserOptions{}
	c.GetIdleTimeoutMinutes()
	c = nil
	c.GetIdleTimeoutMinutes()
}

func TestCodespaceCreateForUserOptions_GetLocation(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CodespaceCreateForUserOptions{Location: &zeroValue}
	c.GetLocation()
	c = &CodespaceCreateForUserOptions{}
	c.GetLocation()
	c = nil
	c.GetLocation()
}

func TestCodespaceCreateForUserOptions_GetMachine(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CodespaceCreateForUserOptions{Machine: &zeroValue}
	c.GetMachine()
	c = &CodespaceCreateForUserOptions{}
	c.GetMachine()
	c = nil
	c.GetMachine()
}

func TestCodespaceCreateForUserOptions_GetMultiRepoPermissionsOptOut(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &CodespaceCreateForUserOptions{MultiRepoPermissionsOptOut: &zeroValue}
	c.GetMultiRepoPermissionsOptOut()
	c = &CodespaceCreateForUserOptions{}
	c.GetMultiRepoPermissionsOptOut()
	c = nil
	c.GetMultiRepoPermissionsOptOut()
}

func TestCodespaceCreateForUserOptions_GetPullRequest(tt *testing.T) {
	tt.Parallel()
	c := &CodespaceCreateForUserOptions{}
	c.GetPullRequest()
	c = nil
	c.GetPullRequest()
}

func TestCodespaceCreateForUserOptions_GetRef(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CodespaceCreateForUserOptions{Ref: &zeroValue}
	c.GetRef()
	c = &CodespaceCreateForUserOptions{}
	c.GetRef()
	c = nil
	c.GetRef()
}

func TestCodespaceCreateForUserOptions_GetRepositoryID(tt *testing.T) {
	tt.Parallel()
	c := &CodespaceCreateForUserOptions{}
	c.GetRepositoryID()
	c = nil
	c.GetRepositoryID()
}

func TestCodespaceCreateForUserOptions_GetRetentionPeriodMinutes(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CodespaceCreateForUserOptions{RetentionPeriodMinutes: &zeroValue}
	c.GetRetentionPeriodMinutes()
	c = &CodespaceCreateForUserOptions{}
	c.GetRetentionPeriodMinutes()
	c = nil
	c.GetRetentionPeriodMinutes()
}

func TestCodespaceCreateForUserOptions_GetWorkingDirectory(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CodespaceCreateForUserOptions{WorkingDirectory: &zeroValue}
	c.GetWorkingDirectory()
	c = &CodespaceCreateForUserOptions{}
	c.GetWorkingDirectory()
	c = nil
	c.GetWorkingDirectory()
}

func TestCodespaceDefaultAttributes_GetBillableOwner(tt *testing.T) {
	tt.Parallel()
	c := &CodespaceDefaultAttributes{}
	c.GetBillableOwner()
	c = nil
	c.GetBillableOwner()
}

func TestCodespaceDefaultAttributes_GetDefaults(tt *testing.T) {
	tt.Parallel()
	c := &CodespaceDefaultAttributes{}
	c.GetDefaults()
	c = nil
	c.GetDefaults()
}

func TestCodespaceDefaults_GetDevcontainerPath(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CodespaceDefaults{DevcontainerPath: &zeroValue}
	c.GetDevcontainerPath()
	c = &CodespaceDefaults{}
	c.GetDevcontainerPath()
	c = nil
	c.GetDevcontainerPath()
}

func TestCodespaceDefaults_GetLocation(tt *testing.T) {
	tt.Parallel()
	c := &CodespaceDefaults{}
	c.GetLocation()
	c = nil
	c.GetLocation()
}

func TestCodespaceExport_GetBranch(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CodespaceExport{Branch: &zeroValue}
	c.GetBranch()
	c = &CodespaceExport{}
	c.GetBranch()
	c = nil
	c.GetBranch()
}

func TestCodespaceExport_GetCompletedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	c := &CodespaceExport{CompletedAt: &zeroValue}
	c.GetCompletedAt()
	c = &CodespaceExport{}
	c.GetCompletedAt()
	c = nil
	c.GetCompletedAt()
}

func TestCodespaceExport_GetExportURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CodespaceExport{ExportURL: &zeroValue}
	c.GetExportURL()
	c = &CodespaceExport{}
	c.GetExportURL()
	c = nil
	c.GetExportURL()
}

func TestCodespaceExport_GetHTMLURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CodespaceExport{HTMLURL: &zeroValue}
	c.GetHTMLURL()
	c = &CodespaceExport{}
	c.GetHTMLURL()
	c = nil
	c.GetHTMLURL()
}

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

func TestCodespaceExport_GetSHA(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CodespaceExport{SHA: &zeroValue}
	c.GetSHA()
	c = &CodespaceExport{}
	c.GetSHA()
	c = nil
	c.GetSHA()
}

func TestCodespaceExport_GetState(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CodespaceExport{State: &zeroValue}
	c.GetState()
	c = &CodespaceExport{}
	c.GetState()
	c = nil
	c.GetState()
}

func TestCodespaceGetDefaultAttributesOptions_GetClientIP(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CodespaceGetDefaultAttributesOptions{ClientIP: &zeroValue}
	c.GetClientIP()
	c = &CodespaceGetDefaultAttributesOptions{}
	c.GetClientIP()
	c = nil
	c.GetClientIP()
}

func TestCodespaceGetDefaultAttributesOptions_GetRef(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CodespaceGetDefaultAttributesOptions{Ref: &zeroValue}
	c.GetRef()
	c = &CodespaceGetDefaultAttributesOptions{}
	c.GetRef()
	c = nil
	c.GetRef()
}

func TestCodespacePermissions_GetAccepted(tt *testing.T) {
	tt.Parallel()
	c := &CodespacePermissions{}
	c.GetAccepted()
	c = nil
	c.GetAccepted()
}

func TestCodespacePullRequestOptions_GetPullRequestNumber(tt *testing.T) {
	tt.Parallel()
	c := &CodespacePullRequestOptions{}
	c.GetPullRequestNumber()
	c = nil
	c.GetPullRequestNumber()
}

func TestCodespacePullRequestOptions_GetRepositoryID(tt *testing.T) {
	tt.Parallel()
	c := &CodespacePullRequestOptions{}
	c.GetRepositoryID()
	c = nil
	c.GetRepositoryID()
}

func TestCodespacesGitStatus_GetAhead(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CodespacesGitStatus{Ahead: &zeroValue}
	c.GetAhead()
	c = &CodespacesGitStatus{}
	c.GetAhead()
	c = nil
	c.GetAhead()
}

func TestCodespacesGitStatus_GetBehind(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CodespacesGitStatus{Behind: &zeroValue}
	c.GetBehind()
	c = &CodespacesGitStatus{}
	c.GetBehind()
	c = nil
	c.GetBehind()
}

func TestCodespacesGitStatus_GetHasUncommittedChanges(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &CodespacesGitStatus{HasUncommittedChanges: &zeroValue}
	c.GetHasUncommittedChanges()
	c = &CodespacesGitStatus{}
	c.GetHasUncommittedChanges()
	c = nil
	c.GetHasUncommittedChanges()
}

func TestCodespacesGitStatus_GetHasUnpushedChanges(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &CodespacesGitStatus{HasUnpushedChanges: &zeroValue}
	c.GetHasUnpushedChanges()
	c = &CodespacesGitStatus{}
	c.GetHasUnpushedChanges()
	c = nil
	c.GetHasUnpushedChanges()
}

func TestCodespacesGitStatus_GetRef(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CodespacesGitStatus{Ref: &zeroValue}
	c.GetRef()
	c = &CodespacesGitStatus{}
	c.GetRef()
	c = nil
	c.GetRef()
}

func TestCodespacesMachine_GetCPUs(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CodespacesMachine{CPUs: &zeroValue}
	c.GetCPUs()
	c = &CodespacesMachine{}
	c.GetCPUs()
	c = nil
	c.GetCPUs()
}

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

func TestCodespacesMachine_GetMemoryInBytes(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	c := &CodespacesMachine{MemoryInBytes: &zeroValue}
	c.GetMemoryInBytes()
	c = &CodespacesMachine{}
	c.GetMemoryInBytes()
	c = nil
	c.GetMemoryInBytes()
}

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

func TestCodespacesMachine_GetOperatingSystem(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CodespacesMachine{OperatingSystem: &zeroValue}
	c.GetOperatingSystem()
	c = &CodespacesMachine{}
	c.GetOperatingSystem()
	c = nil
	c.GetOperatingSystem()
}

func TestCodespacesMachine_GetPrebuildAvailability(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CodespacesMachine{PrebuildAvailability: &zeroValue}
	c.GetPrebuildAvailability()
	c = &CodespacesMachine{}
	c.GetPrebuildAvailability()
	c = nil
	c.GetPrebuildAvailability()
}

func TestCodespacesMachine_GetStorageInBytes(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	c := &CodespacesMachine{StorageInBytes: &zeroValue}
	c.GetStorageInBytes()
	c = &CodespacesMachine{}
	c.GetStorageInBytes()
	c = nil
	c.GetStorageInBytes()
}

func TestCodespacesMachines_GetMachines(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*CodespacesMachine{}
	c := &CodespacesMachines{Machines: zeroValue}
	c.GetMachines()
	c = &CodespacesMachines{}
	c.GetMachines()
	c = nil
	c.GetMachines()
}

func TestCodespacesMachines_GetTotalCount(tt *testing.T) {
	tt.Parallel()
	c := &CodespacesMachines{}
	c.GetTotalCount()
	c = nil
	c.GetTotalCount()
}

func TestCodespacesOrgAccessControlRequest_GetSelectedUsernames(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	c := &CodespacesOrgAccessControlRequest{SelectedUsernames: zeroValue}
	c.GetSelectedUsernames()
	c = &CodespacesOrgAccessControlRequest{}
	c.GetSelectedUsernames()
	c = nil
	c.GetSelectedUsernames()
}

func TestCodespacesOrgAccessControlRequest_GetVisibility(tt *testing.T) {
	tt.Parallel()
	c := &CodespacesOrgAccessControlRequest{}
	c.GetVisibility()
	c = nil
	c.GetVisibility()
}

func TestCodespacesRuntimeConstraints_GetAllowedPortPrivacySettings(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	c := &CodespacesRuntimeConstraints{AllowedPortPrivacySettings: zeroValue}
	c.GetAllowedPortPrivacySettings()
	c = &CodespacesRuntimeConstraints{}
	c.GetAllowedPortPrivacySettings()
	c = nil
	c.GetAllowedPortPrivacySettings()
}

func TestCollaboratorInvitation_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	c := &CollaboratorInvitation{CreatedAt: &zeroValue}
	c.GetCreatedAt()
	c = &CollaboratorInvitation{}
	c.GetCreatedAt()
	c = nil
	c.GetCreatedAt()
}

func TestCollaboratorInvitation_GetHTMLURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CollaboratorInvitation{HTMLURL: &zeroValue}
	c.GetHTMLURL()
	c = &CollaboratorInvitation{}
	c.GetHTMLURL()
	c = nil
	c.GetHTMLURL()
}

func TestCollaboratorInvitation_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	c := &CollaboratorInvitation{ID: &zeroValue}
	c.GetID()
	c = &CollaboratorInvitation{}
	c.GetID()
	c = nil
	c.GetID()
}

func TestCollaboratorInvitation_GetInvitee(tt *testing.T) {
	tt.Parallel()
	c := &CollaboratorInvitation{}
	c.GetInvitee()
	c = nil
	c.GetInvitee()
}

func TestCollaboratorInvitation_GetInviter(tt *testing.T) {
	tt.Parallel()
	c := &CollaboratorInvitation{}
	c.GetInviter()
	c = nil
	c.GetInviter()
}

func TestCollaboratorInvitation_GetPermissions(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CollaboratorInvitation{Permissions: &zeroValue}
	c.GetPermissions()
	c = &CollaboratorInvitation{}
	c.GetPermissions()
	c = nil
	c.GetPermissions()
}

func TestCollaboratorInvitation_GetRepo(tt *testing.T) {
	tt.Parallel()
	c := &CollaboratorInvitation{}
	c.GetRepo()
	c = nil
	c.GetRepo()
}

func TestCollaboratorInvitation_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CollaboratorInvitation{URL: &zeroValue}
	c.GetURL()
	c = &CollaboratorInvitation{}
	c.GetURL()
	c = nil
	c.GetURL()
}

func TestCombinedStatus_GetCommitURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CombinedStatus{CommitURL: &zeroValue}
	c.GetCommitURL()
	c = &CombinedStatus{}
	c.GetCommitURL()
	c = nil
	c.GetCommitURL()
}

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

func TestCombinedStatus_GetRepositoryURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CombinedStatus{RepositoryURL: &zeroValue}
	c.GetRepositoryURL()
	c = &CombinedStatus{}
	c.GetRepositoryURL()
	c = nil
	c.GetRepositoryURL()
}

func TestCombinedStatus_GetSHA(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CombinedStatus{SHA: &zeroValue}
	c.GetSHA()
	c = &CombinedStatus{}
	c.GetSHA()
	c = nil
	c.GetSHA()
}

func TestCombinedStatus_GetState(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CombinedStatus{State: &zeroValue}
	c.GetState()
	c = &CombinedStatus{}
	c.GetState()
	c = nil
	c.GetState()
}

func TestCombinedStatus_GetStatuses(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*RepoStatus{}
	c := &CombinedStatus{Statuses: zeroValue}
	c.GetStatuses()
	c = &CombinedStatus{}
	c.GetStatuses()
	c = nil
	c.GetStatuses()
}

func TestCombinedStatus_GetTotalCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CombinedStatus{TotalCount: &zeroValue}
	c.GetTotalCount()
	c = &CombinedStatus{}
	c.GetTotalCount()
	c = nil
	c.GetTotalCount()
}

func TestComment_GetBody(tt *testing.T) {
	tt.Parallel()
	c := &Comment{}
	c.GetBody()
	c = nil
	c.GetBody()
}

func TestComment_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	c := &Comment{CreatedAt: &zeroValue}
	c.GetCreatedAt()
	c = &Comment{}
	c.GetCreatedAt()
	c = nil
	c.GetCreatedAt()
}

func TestCommentDiscussion_GetAuthorAssociation(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CommentDiscussion{AuthorAssociation: &zeroValue}
	c.GetAuthorAssociation()
	c = &CommentDiscussion{}
	c.GetAuthorAssociation()
	c = nil
	c.GetAuthorAssociation()
}

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

func TestCommentDiscussion_GetChildCommentCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CommentDiscussion{ChildCommentCount: &zeroValue}
	c.GetChildCommentCount()
	c = &CommentDiscussion{}
	c.GetChildCommentCount()
	c = nil
	c.GetChildCommentCount()
}

func TestCommentDiscussion_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	c := &CommentDiscussion{CreatedAt: &zeroValue}
	c.GetCreatedAt()
	c = &CommentDiscussion{}
	c.GetCreatedAt()
	c = nil
	c.GetCreatedAt()
}

func TestCommentDiscussion_GetDiscussionID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	c := &CommentDiscussion{DiscussionID: &zeroValue}
	c.GetDiscussionID()
	c = &CommentDiscussion{}
	c.GetDiscussionID()
	c = nil
	c.GetDiscussionID()
}

func TestCommentDiscussion_GetHTMLURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CommentDiscussion{HTMLURL: &zeroValue}
	c.GetHTMLURL()
	c = &CommentDiscussion{}
	c.GetHTMLURL()
	c = nil
	c.GetHTMLURL()
}

func TestCommentDiscussion_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	c := &CommentDiscussion{ID: &zeroValue}
	c.GetID()
	c = &CommentDiscussion{}
	c.GetID()
	c = nil
	c.GetID()
}

func TestCommentDiscussion_GetNodeID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CommentDiscussion{NodeID: &zeroValue}
	c.GetNodeID()
	c = &CommentDiscussion{}
	c.GetNodeID()
	c = nil
	c.GetNodeID()
}

func TestCommentDiscussion_GetParentID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	c := &CommentDiscussion{ParentID: &zeroValue}
	c.GetParentID()
	c = &CommentDiscussion{}
	c.GetParentID()
	c = nil
	c.GetParentID()
}

func TestCommentDiscussion_GetReactions(tt *testing.T) {
	tt.Parallel()
	c := &CommentDiscussion{}
	c.GetReactions()
	c = nil
	c.GetReactions()
}

func TestCommentDiscussion_GetRepositoryURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CommentDiscussion{RepositoryURL: &zeroValue}
	c.GetRepositoryURL()
	c = &CommentDiscussion{}
	c.GetRepositoryURL()
	c = nil
	c.GetRepositoryURL()
}

func TestCommentDiscussion_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	c := &CommentDiscussion{UpdatedAt: &zeroValue}
	c.GetUpdatedAt()
	c = &CommentDiscussion{}
	c.GetUpdatedAt()
	c = nil
	c.GetUpdatedAt()
}

func TestCommentDiscussion_GetUser(tt *testing.T) {
	tt.Parallel()
	c := &CommentDiscussion{}
	c.GetUser()
	c = nil
	c.GetUser()
}

func TestCommentStats_GetTotalCommitComments(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CommentStats{TotalCommitComments: &zeroValue}
	c.GetTotalCommitComments()
	c = &CommentStats{}
	c.GetTotalCommitComments()
	c = nil
	c.GetTotalCommitComments()
}

func TestCommentStats_GetTotalGistComments(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CommentStats{TotalGistComments: &zeroValue}
	c.GetTotalGistComments()
	c = &CommentStats{}
	c.GetTotalGistComments()
	c = nil
	c.GetTotalGistComments()
}

func TestCommentStats_GetTotalIssueComments(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CommentStats{TotalIssueComments: &zeroValue}
	c.GetTotalIssueComments()
	c = &CommentStats{}
	c.GetTotalIssueComments()
	c = nil
	c.GetTotalIssueComments()
}

func TestCommentStats_GetTotalPullRequestComments(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CommentStats{TotalPullRequestComments: &zeroValue}
	c.GetTotalPullRequestComments()
	c = &CommentStats{}
	c.GetTotalPullRequestComments()
	c = nil
	c.GetTotalPullRequestComments()
}

func TestCommit_GetAuthor(tt *testing.T) {
	tt.Parallel()
	c := &Commit{}
	c.GetAuthor()
	c = nil
	c.GetAuthor()
}

func TestCommit_GetCommentCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &Commit{CommentCount: &zeroValue}
	c.GetCommentCount()
	c = &Commit{}
	c.GetCommentCount()
	c = nil
	c.GetCommentCount()
}

func TestCommit_GetCommitter(tt *testing.T) {
	tt.Parallel()
	c := &Commit{}
	c.GetCommitter()
	c = nil
	c.GetCommitter()
}

func TestCommit_GetHTMLURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &Commit{HTMLURL: &zeroValue}
	c.GetHTMLURL()
	c = &Commit{}
	c.GetHTMLURL()
	c = nil
	c.GetHTMLURL()
}

func TestCommit_GetMessage(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &Commit{Message: &zeroValue}
	c.GetMessage()
	c = &Commit{}
	c.GetMessage()
	c = nil
	c.GetMessage()
}

func TestCommit_GetNodeID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &Commit{NodeID: &zeroValue}
	c.GetNodeID()
	c = &Commit{}
	c.GetNodeID()
	c = nil
	c.GetNodeID()
}

func TestCommit_GetParents(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*Commit{}
	c := &Commit{Parents: zeroValue}
	c.GetParents()
	c = &Commit{}
	c.GetParents()
	c = nil
	c.GetParents()
}

func TestCommit_GetSHA(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &Commit{SHA: &zeroValue}
	c.GetSHA()
	c = &Commit{}
	c.GetSHA()
	c = nil
	c.GetSHA()
}

func TestCommit_GetTree(tt *testing.T) {
	tt.Parallel()
	c := &Commit{}
	c.GetTree()
	c = nil
	c.GetTree()
}

func TestCommit_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &Commit{URL: &zeroValue}
	c.GetURL()
	c = &Commit{}
	c.GetURL()
	c = nil
	c.GetURL()
}

func TestCommit_GetVerification(tt *testing.T) {
	tt.Parallel()
	c := &Commit{}
	c.GetVerification()
	c = nil
	c.GetVerification()
}

func TestCommitAuthor_GetDate(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	c := &CommitAuthor{Date: &zeroValue}
	c.GetDate()
	c = &CommitAuthor{}
	c.GetDate()
	c = nil
	c.GetDate()
}

func TestCommitAuthor_GetEmail(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CommitAuthor{Email: &zeroValue}
	c.GetEmail()
	c = &CommitAuthor{}
	c.GetEmail()
	c = nil
	c.GetEmail()
}

func TestCommitAuthor_GetLogin(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CommitAuthor{Login: &zeroValue}
	c.GetLogin()
	c = &CommitAuthor{}
	c.GetLogin()
	c = nil
	c.GetLogin()
}

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

func TestCommitCommentEvent_GetAction(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CommitCommentEvent{Action: &zeroValue}
	c.GetAction()
	c = &CommitCommentEvent{}
	c.GetAction()
	c = nil
	c.GetAction()
}

func TestCommitCommentEvent_GetComment(tt *testing.T) {
	tt.Parallel()
	c := &CommitCommentEvent{}
	c.GetComment()
	c = nil
	c.GetComment()
}

func TestCommitCommentEvent_GetInstallation(tt *testing.T) {
	tt.Parallel()
	c := &CommitCommentEvent{}
	c.GetInstallation()
	c = nil
	c.GetInstallation()
}

func TestCommitCommentEvent_GetOrg(tt *testing.T) {
	tt.Parallel()
	c := &CommitCommentEvent{}
	c.GetOrg()
	c = nil
	c.GetOrg()
}

func TestCommitCommentEvent_GetRepo(tt *testing.T) {
	tt.Parallel()
	c := &CommitCommentEvent{}
	c.GetRepo()
	c = nil
	c.GetRepo()
}

func TestCommitCommentEvent_GetSender(tt *testing.T) {
	tt.Parallel()
	c := &CommitCommentEvent{}
	c.GetSender()
	c = nil
	c.GetSender()
}

func TestCommitFile_GetAdditions(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CommitFile{Additions: &zeroValue}
	c.GetAdditions()
	c = &CommitFile{}
	c.GetAdditions()
	c = nil
	c.GetAdditions()
}

func TestCommitFile_GetBlobURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CommitFile{BlobURL: &zeroValue}
	c.GetBlobURL()
	c = &CommitFile{}
	c.GetBlobURL()
	c = nil
	c.GetBlobURL()
}

func TestCommitFile_GetChanges(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CommitFile{Changes: &zeroValue}
	c.GetChanges()
	c = &CommitFile{}
	c.GetChanges()
	c = nil
	c.GetChanges()
}

func TestCommitFile_GetContentsURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CommitFile{ContentsURL: &zeroValue}
	c.GetContentsURL()
	c = &CommitFile{}
	c.GetContentsURL()
	c = nil
	c.GetContentsURL()
}

func TestCommitFile_GetDeletions(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CommitFile{Deletions: &zeroValue}
	c.GetDeletions()
	c = &CommitFile{}
	c.GetDeletions()
	c = nil
	c.GetDeletions()
}

func TestCommitFile_GetFilename(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CommitFile{Filename: &zeroValue}
	c.GetFilename()
	c = &CommitFile{}
	c.GetFilename()
	c = nil
	c.GetFilename()
}

func TestCommitFile_GetPatch(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CommitFile{Patch: &zeroValue}
	c.GetPatch()
	c = &CommitFile{}
	c.GetPatch()
	c = nil
	c.GetPatch()
}

func TestCommitFile_GetPreviousFilename(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CommitFile{PreviousFilename: &zeroValue}
	c.GetPreviousFilename()
	c = &CommitFile{}
	c.GetPreviousFilename()
	c = nil
	c.GetPreviousFilename()
}

func TestCommitFile_GetRawURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CommitFile{RawURL: &zeroValue}
	c.GetRawURL()
	c = &CommitFile{}
	c.GetRawURL()
	c = nil
	c.GetRawURL()
}

func TestCommitFile_GetSHA(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CommitFile{SHA: &zeroValue}
	c.GetSHA()
	c = &CommitFile{}
	c.GetSHA()
	c = nil
	c.GetSHA()
}

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

func TestCommitResult_GetAuthor(tt *testing.T) {
	tt.Parallel()
	c := &CommitResult{}
	c.GetAuthor()
	c = nil
	c.GetAuthor()
}

func TestCommitResult_GetCommentsURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CommitResult{CommentsURL: &zeroValue}
	c.GetCommentsURL()
	c = &CommitResult{}
	c.GetCommentsURL()
	c = nil
	c.GetCommentsURL()
}

func TestCommitResult_GetCommit(tt *testing.T) {
	tt.Parallel()
	c := &CommitResult{}
	c.GetCommit()
	c = nil
	c.GetCommit()
}

func TestCommitResult_GetCommitter(tt *testing.T) {
	tt.Parallel()
	c := &CommitResult{}
	c.GetCommitter()
	c = nil
	c.GetCommitter()
}

func TestCommitResult_GetHTMLURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CommitResult{HTMLURL: &zeroValue}
	c.GetHTMLURL()
	c = &CommitResult{}
	c.GetHTMLURL()
	c = nil
	c.GetHTMLURL()
}

func TestCommitResult_GetParents(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*Commit{}
	c := &CommitResult{Parents: zeroValue}
	c.GetParents()
	c = &CommitResult{}
	c.GetParents()
	c = nil
	c.GetParents()
}

func TestCommitResult_GetRepository(tt *testing.T) {
	tt.Parallel()
	c := &CommitResult{}
	c.GetRepository()
	c = nil
	c.GetRepository()
}

func TestCommitResult_GetScore(tt *testing.T) {
	tt.Parallel()
	var zeroValue float64
	c := &CommitResult{Score: &zeroValue}
	c.GetScore()
	c = &CommitResult{}
	c.GetScore()
	c = nil
	c.GetScore()
}

func TestCommitResult_GetSHA(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CommitResult{SHA: &zeroValue}
	c.GetSHA()
	c = &CommitResult{}
	c.GetSHA()
	c = nil
	c.GetSHA()
}

func TestCommitResult_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CommitResult{URL: &zeroValue}
	c.GetURL()
	c = &CommitResult{}
	c.GetURL()
	c = nil
	c.GetURL()
}

func TestCommitsComparison_GetAheadBy(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CommitsComparison{AheadBy: &zeroValue}
	c.GetAheadBy()
	c = &CommitsComparison{}
	c.GetAheadBy()
	c = nil
	c.GetAheadBy()
}

func TestCommitsComparison_GetBaseCommit(tt *testing.T) {
	tt.Parallel()
	c := &CommitsComparison{}
	c.GetBaseCommit()
	c = nil
	c.GetBaseCommit()
}

func TestCommitsComparison_GetBehindBy(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CommitsComparison{BehindBy: &zeroValue}
	c.GetBehindBy()
	c = &CommitsComparison{}
	c.GetBehindBy()
	c = nil
	c.GetBehindBy()
}

func TestCommitsComparison_GetCommits(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*RepositoryCommit{}
	c := &CommitsComparison{Commits: zeroValue}
	c.GetCommits()
	c = &CommitsComparison{}
	c.GetCommits()
	c = nil
	c.GetCommits()
}

func TestCommitsComparison_GetDiffURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CommitsComparison{DiffURL: &zeroValue}
	c.GetDiffURL()
	c = &CommitsComparison{}
	c.GetDiffURL()
	c = nil
	c.GetDiffURL()
}

func TestCommitsComparison_GetFiles(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*CommitFile{}
	c := &CommitsComparison{Files: zeroValue}
	c.GetFiles()
	c = &CommitsComparison{}
	c.GetFiles()
	c = nil
	c.GetFiles()
}

func TestCommitsComparison_GetHTMLURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CommitsComparison{HTMLURL: &zeroValue}
	c.GetHTMLURL()
	c = &CommitsComparison{}
	c.GetHTMLURL()
	c = nil
	c.GetHTMLURL()
}

func TestCommitsComparison_GetMergeBaseCommit(tt *testing.T) {
	tt.Parallel()
	c := &CommitsComparison{}
	c.GetMergeBaseCommit()
	c = nil
	c.GetMergeBaseCommit()
}

func TestCommitsComparison_GetPatchURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CommitsComparison{PatchURL: &zeroValue}
	c.GetPatchURL()
	c = &CommitsComparison{}
	c.GetPatchURL()
	c = nil
	c.GetPatchURL()
}

func TestCommitsComparison_GetPermalinkURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CommitsComparison{PermalinkURL: &zeroValue}
	c.GetPermalinkURL()
	c = &CommitsComparison{}
	c.GetPermalinkURL()
	c = nil
	c.GetPermalinkURL()
}

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

func TestCommitsComparison_GetTotalCommits(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CommitsComparison{TotalCommits: &zeroValue}
	c.GetTotalCommits()
	c = &CommitsComparison{}
	c.GetTotalCommits()
	c = nil
	c.GetTotalCommits()
}

func TestCommitsComparison_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CommitsComparison{URL: &zeroValue}
	c.GetURL()
	c = &CommitsComparison{}
	c.GetURL()
	c = nil
	c.GetURL()
}

func TestCommitsListOptions_GetAuthor(tt *testing.T) {
	tt.Parallel()
	c := &CommitsListOptions{}
	c.GetAuthor()
	c = nil
	c.GetAuthor()
}

func TestCommitsListOptions_GetPath(tt *testing.T) {
	tt.Parallel()
	c := &CommitsListOptions{}
	c.GetPath()
	c = nil
	c.GetPath()
}

func TestCommitsListOptions_GetSHA(tt *testing.T) {
	tt.Parallel()
	c := &CommitsListOptions{}
	c.GetSHA()
	c = nil
	c.GetSHA()
}

func TestCommitsListOptions_GetSince(tt *testing.T) {
	tt.Parallel()
	c := &CommitsListOptions{}
	c.GetSince()
	c = nil
	c.GetSince()
}

func TestCommitsListOptions_GetUntil(tt *testing.T) {
	tt.Parallel()
	c := &CommitsListOptions{}
	c.GetUntil()
	c = nil
	c.GetUntil()
}

func TestCommitsSearchResult_GetCommits(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*CommitResult{}
	c := &CommitsSearchResult{Commits: zeroValue}
	c.GetCommits()
	c = &CommitsSearchResult{}
	c.GetCommits()
	c = nil
	c.GetCommits()
}

func TestCommitsSearchResult_GetIncompleteResults(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &CommitsSearchResult{IncompleteResults: &zeroValue}
	c.GetIncompleteResults()
	c = &CommitsSearchResult{}
	c.GetIncompleteResults()
	c = nil
	c.GetIncompleteResults()
}

func TestCommitsSearchResult_GetTotal(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CommitsSearchResult{Total: &zeroValue}
	c.GetTotal()
	c = &CommitsSearchResult{}
	c.GetTotal()
	c = nil
	c.GetTotal()
}

func TestCommitStats_GetAdditions(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CommitStats{Additions: &zeroValue}
	c.GetAdditions()
	c = &CommitStats{}
	c.GetAdditions()
	c = nil
	c.GetAdditions()
}

func TestCommitStats_GetDeletions(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CommitStats{Deletions: &zeroValue}
	c.GetDeletions()
	c = &CommitStats{}
	c.GetDeletions()
	c = nil
	c.GetDeletions()
}

func TestCommitStats_GetTotal(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CommitStats{Total: &zeroValue}
	c.GetTotal()
	c = &CommitStats{}
	c.GetTotal()
	c = nil
	c.GetTotal()
}

func TestCommunityHealthFiles_GetCodeOfConduct(tt *testing.T) {
	tt.Parallel()
	c := &CommunityHealthFiles{}
	c.GetCodeOfConduct()
	c = nil
	c.GetCodeOfConduct()
}

func TestCommunityHealthFiles_GetCodeOfConductFile(tt *testing.T) {
	tt.Parallel()
	c := &CommunityHealthFiles{}
	c.GetCodeOfConductFile()
	c = nil
	c.GetCodeOfConductFile()
}

func TestCommunityHealthFiles_GetContributing(tt *testing.T) {
	tt.Parallel()
	c := &CommunityHealthFiles{}
	c.GetContributing()
	c = nil
	c.GetContributing()
}

func TestCommunityHealthFiles_GetIssueTemplate(tt *testing.T) {
	tt.Parallel()
	c := &CommunityHealthFiles{}
	c.GetIssueTemplate()
	c = nil
	c.GetIssueTemplate()
}

func TestCommunityHealthFiles_GetLicense(tt *testing.T) {
	tt.Parallel()
	c := &CommunityHealthFiles{}
	c.GetLicense()
	c = nil
	c.GetLicense()
}

func TestCommunityHealthFiles_GetPullRequestTemplate(tt *testing.T) {
	tt.Parallel()
	c := &CommunityHealthFiles{}
	c.GetPullRequestTemplate()
	c = nil
	c.GetPullRequestTemplate()
}

func TestCommunityHealthFiles_GetReadme(tt *testing.T) {
	tt.Parallel()
	c := &CommunityHealthFiles{}
	c.GetReadme()
	c = nil
	c.GetReadme()
}

func TestCommunityHealthMetrics_GetContentReportsEnabled(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &CommunityHealthMetrics{ContentReportsEnabled: &zeroValue}
	c.GetContentReportsEnabled()
	c = &CommunityHealthMetrics{}
	c.GetContentReportsEnabled()
	c = nil
	c.GetContentReportsEnabled()
}

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

func TestCommunityHealthMetrics_GetDocumentation(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CommunityHealthMetrics{Documentation: &zeroValue}
	c.GetDocumentation()
	c = &CommunityHealthMetrics{}
	c.GetDocumentation()
	c = nil
	c.GetDocumentation()
}

func TestCommunityHealthMetrics_GetFiles(tt *testing.T) {
	tt.Parallel()
	c := &CommunityHealthMetrics{}
	c.GetFiles()
	c = nil
	c.GetFiles()
}

func TestCommunityHealthMetrics_GetHealthPercentage(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CommunityHealthMetrics{HealthPercentage: &zeroValue}
	c.GetHealthPercentage()
	c = &CommunityHealthMetrics{}
	c.GetHealthPercentage()
	c = nil
	c.GetHealthPercentage()
}

func TestCommunityHealthMetrics_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	c := &CommunityHealthMetrics{UpdatedAt: &zeroValue}
	c.GetUpdatedAt()
	c = &CommunityHealthMetrics{}
	c.GetUpdatedAt()
	c = nil
	c.GetUpdatedAt()
}

func TestConfigApplyEvents_GetNodes(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*ConfigApplyEventsNode{}
	c := &ConfigApplyEvents{Nodes: zeroValue}
	c.GetNodes()
	c = &ConfigApplyEvents{}
	c.GetNodes()
	c = nil
	c.GetNodes()
}

func TestConfigApplyEventsNode_GetEvents(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*ConfigApplyEventsNodeEvent{}
	c := &ConfigApplyEventsNode{Events: zeroValue}
	c.GetEvents()
	c = &ConfigApplyEventsNode{}
	c.GetEvents()
	c = nil
	c.GetEvents()
}

func TestConfigApplyEventsNode_GetLastRequestID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ConfigApplyEventsNode{LastRequestID: &zeroValue}
	c.GetLastRequestID()
	c = &ConfigApplyEventsNode{}
	c.GetLastRequestID()
	c = nil
	c.GetLastRequestID()
}

func TestConfigApplyEventsNode_GetNode(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ConfigApplyEventsNode{Node: &zeroValue}
	c.GetNode()
	c = &ConfigApplyEventsNode{}
	c.GetNode()
	c = nil
	c.GetNode()
}

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

func TestConfigApplyEventsNodeEvent_GetConfigRunID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ConfigApplyEventsNodeEvent{ConfigRunID: &zeroValue}
	c.GetConfigRunID()
	c = &ConfigApplyEventsNodeEvent{}
	c.GetConfigRunID()
	c = nil
	c.GetConfigRunID()
}

func TestConfigApplyEventsNodeEvent_GetEventName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ConfigApplyEventsNodeEvent{EventName: &zeroValue}
	c.GetEventName()
	c = &ConfigApplyEventsNodeEvent{}
	c.GetEventName()
	c = nil
	c.GetEventName()
}

func TestConfigApplyEventsNodeEvent_GetHostname(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ConfigApplyEventsNodeEvent{Hostname: &zeroValue}
	c.GetHostname()
	c = &ConfigApplyEventsNodeEvent{}
	c.GetHostname()
	c = nil
	c.GetHostname()
}

func TestConfigApplyEventsNodeEvent_GetSeverityText(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ConfigApplyEventsNodeEvent{SeverityText: &zeroValue}
	c.GetSeverityText()
	c = &ConfigApplyEventsNodeEvent{}
	c.GetSeverityText()
	c = nil
	c.GetSeverityText()
}

func TestConfigApplyEventsNodeEvent_GetSpanDepth(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &ConfigApplyEventsNodeEvent{SpanDepth: &zeroValue}
	c.GetSpanDepth()
	c = &ConfigApplyEventsNodeEvent{}
	c.GetSpanDepth()
	c = nil
	c.GetSpanDepth()
}

func TestConfigApplyEventsNodeEvent_GetSpanID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ConfigApplyEventsNodeEvent{SpanID: &zeroValue}
	c.GetSpanID()
	c = &ConfigApplyEventsNodeEvent{}
	c.GetSpanID()
	c = nil
	c.GetSpanID()
}

func TestConfigApplyEventsNodeEvent_GetSpanParentID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	c := &ConfigApplyEventsNodeEvent{SpanParentID: &zeroValue}
	c.GetSpanParentID()
	c = &ConfigApplyEventsNodeEvent{}
	c.GetSpanParentID()
	c = nil
	c.GetSpanParentID()
}

func TestConfigApplyEventsNodeEvent_GetTimestamp(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	c := &ConfigApplyEventsNodeEvent{Timestamp: &zeroValue}
	c.GetTimestamp()
	c = &ConfigApplyEventsNodeEvent{}
	c.GetTimestamp()
	c = nil
	c.GetTimestamp()
}

func TestConfigApplyEventsNodeEvent_GetTopology(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ConfigApplyEventsNodeEvent{Topology: &zeroValue}
	c.GetTopology()
	c = &ConfigApplyEventsNodeEvent{}
	c.GetTopology()
	c = nil
	c.GetTopology()
}

func TestConfigApplyEventsNodeEvent_GetTraceID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ConfigApplyEventsNodeEvent{TraceID: &zeroValue}
	c.GetTraceID()
	c = &ConfigApplyEventsNodeEvent{}
	c.GetTraceID()
	c = nil
	c.GetTraceID()
}

func TestConfigApplyEventsOptions_GetLastRequestID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ConfigApplyEventsOptions{LastRequestID: &zeroValue}
	c.GetLastRequestID()
	c = &ConfigApplyEventsOptions{}
	c.GetLastRequestID()
	c = nil
	c.GetLastRequestID()
}

func TestConfigApplyOptions_GetRunID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ConfigApplyOptions{RunID: &zeroValue}
	c.GetRunID()
	c = &ConfigApplyOptions{}
	c.GetRunID()
	c = nil
	c.GetRunID()
}

func TestConfigApplyStatus_GetNodes(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*ConfigApplyStatusNode{}
	c := &ConfigApplyStatus{Nodes: zeroValue}
	c.GetNodes()
	c = &ConfigApplyStatus{}
	c.GetNodes()
	c = nil
	c.GetNodes()
}

func TestConfigApplyStatus_GetRunning(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &ConfigApplyStatus{Running: &zeroValue}
	c.GetRunning()
	c = &ConfigApplyStatus{}
	c.GetRunning()
	c = nil
	c.GetRunning()
}

func TestConfigApplyStatus_GetSuccessful(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &ConfigApplyStatus{Successful: &zeroValue}
	c.GetSuccessful()
	c = &ConfigApplyStatus{}
	c.GetSuccessful()
	c = nil
	c.GetSuccessful()
}

func TestConfigApplyStatusNode_GetHostname(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ConfigApplyStatusNode{Hostname: &zeroValue}
	c.GetHostname()
	c = &ConfigApplyStatusNode{}
	c.GetHostname()
	c = nil
	c.GetHostname()
}

func TestConfigApplyStatusNode_GetRunID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ConfigApplyStatusNode{RunID: &zeroValue}
	c.GetRunID()
	c = &ConfigApplyStatusNode{}
	c.GetRunID()
	c = nil
	c.GetRunID()
}

func TestConfigApplyStatusNode_GetRunning(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &ConfigApplyStatusNode{Running: &zeroValue}
	c.GetRunning()
	c = &ConfigApplyStatusNode{}
	c.GetRunning()
	c = nil
	c.GetRunning()
}

func TestConfigApplyStatusNode_GetSuccessful(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &ConfigApplyStatusNode{Successful: &zeroValue}
	c.GetSuccessful()
	c = &ConfigApplyStatusNode{}
	c.GetSuccessful()
	c = nil
	c.GetSuccessful()
}

func TestConfigSettings_GetAdminPassword(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ConfigSettings{AdminPassword: &zeroValue}
	c.GetAdminPassword()
	c = &ConfigSettings{}
	c.GetAdminPassword()
	c = nil
	c.GetAdminPassword()
}

func TestConfigSettings_GetAssets(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ConfigSettings{Assets: &zeroValue}
	c.GetAssets()
	c = &ConfigSettings{}
	c.GetAssets()
	c = nil
	c.GetAssets()
}

func TestConfigSettings_GetAuthMode(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ConfigSettings{AuthMode: &zeroValue}
	c.GetAuthMode()
	c = &ConfigSettings{}
	c.GetAuthMode()
	c = nil
	c.GetAuthMode()
}

func TestConfigSettings_GetAvatar(tt *testing.T) {
	tt.Parallel()
	c := &ConfigSettings{}
	c.GetAvatar()
	c = nil
	c.GetAvatar()
}

func TestConfigSettings_GetCAS(tt *testing.T) {
	tt.Parallel()
	c := &ConfigSettings{}
	c.GetCAS()
	c = nil
	c.GetCAS()
}

func TestConfigSettings_GetCollectd(tt *testing.T) {
	tt.Parallel()
	c := &ConfigSettings{}
	c.GetCollectd()
	c = nil
	c.GetCollectd()
}

func TestConfigSettings_GetConfigurationID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	c := &ConfigSettings{ConfigurationID: &zeroValue}
	c.GetConfigurationID()
	c = &ConfigSettings{}
	c.GetConfigurationID()
	c = nil
	c.GetConfigurationID()
}

func TestConfigSettings_GetConfigurationRunCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &ConfigSettings{ConfigurationRunCount: &zeroValue}
	c.GetConfigurationRunCount()
	c = &ConfigSettings{}
	c.GetConfigurationRunCount()
	c = nil
	c.GetConfigurationRunCount()
}

func TestConfigSettings_GetCustomer(tt *testing.T) {
	tt.Parallel()
	c := &ConfigSettings{}
	c.GetCustomer()
	c = nil
	c.GetCustomer()
}

func TestConfigSettings_GetExpireSessions(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &ConfigSettings{ExpireSessions: &zeroValue}
	c.GetExpireSessions()
	c = &ConfigSettings{}
	c.GetExpireSessions()
	c = nil
	c.GetExpireSessions()
}

func TestConfigSettings_GetGithubHostname(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ConfigSettings{GithubHostname: &zeroValue}
	c.GetGithubHostname()
	c = &ConfigSettings{}
	c.GetGithubHostname()
	c = nil
	c.GetGithubHostname()
}

func TestConfigSettings_GetGithubOAuth(tt *testing.T) {
	tt.Parallel()
	c := &ConfigSettings{}
	c.GetGithubOAuth()
	c = nil
	c.GetGithubOAuth()
}

func TestConfigSettings_GetGithubSSL(tt *testing.T) {
	tt.Parallel()
	c := &ConfigSettings{}
	c.GetGithubSSL()
	c = nil
	c.GetGithubSSL()
}

func TestConfigSettings_GetHTTPProxy(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ConfigSettings{HTTPProxy: &zeroValue}
	c.GetHTTPProxy()
	c = &ConfigSettings{}
	c.GetHTTPProxy()
	c = nil
	c.GetHTTPProxy()
}

func TestConfigSettings_GetIdenticonsHost(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ConfigSettings{IdenticonsHost: &zeroValue}
	c.GetIdenticonsHost()
	c = &ConfigSettings{}
	c.GetIdenticonsHost()
	c = nil
	c.GetIdenticonsHost()
}

func TestConfigSettings_GetLDAP(tt *testing.T) {
	tt.Parallel()
	c := &ConfigSettings{}
	c.GetLDAP()
	c = nil
	c.GetLDAP()
}

func TestConfigSettings_GetLicense(tt *testing.T) {
	tt.Parallel()
	c := &ConfigSettings{}
	c.GetLicense()
	c = nil
	c.GetLicense()
}

func TestConfigSettings_GetLoadBalancer(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ConfigSettings{LoadBalancer: &zeroValue}
	c.GetLoadBalancer()
	c = &ConfigSettings{}
	c.GetLoadBalancer()
	c = nil
	c.GetLoadBalancer()
}

func TestConfigSettings_GetMapping(tt *testing.T) {
	tt.Parallel()
	c := &ConfigSettings{}
	c.GetMapping()
	c = nil
	c.GetMapping()
}

func TestConfigSettings_GetNTP(tt *testing.T) {
	tt.Parallel()
	c := &ConfigSettings{}
	c.GetNTP()
	c = nil
	c.GetNTP()
}

func TestConfigSettings_GetPages(tt *testing.T) {
	tt.Parallel()
	c := &ConfigSettings{}
	c.GetPages()
	c = nil
	c.GetPages()
}

func TestConfigSettings_GetPrivateMode(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &ConfigSettings{PrivateMode: &zeroValue}
	c.GetPrivateMode()
	c = &ConfigSettings{}
	c.GetPrivateMode()
	c = nil
	c.GetPrivateMode()
}

func TestConfigSettings_GetPublicPages(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &ConfigSettings{PublicPages: &zeroValue}
	c.GetPublicPages()
	c = &ConfigSettings{}
	c.GetPublicPages()
	c = nil
	c.GetPublicPages()
}

func TestConfigSettings_GetSAML(tt *testing.T) {
	tt.Parallel()
	c := &ConfigSettings{}
	c.GetSAML()
	c = nil
	c.GetSAML()
}

func TestConfigSettings_GetSignupEnabled(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &ConfigSettings{SignupEnabled: &zeroValue}
	c.GetSignupEnabled()
	c = &ConfigSettings{}
	c.GetSignupEnabled()
	c = nil
	c.GetSignupEnabled()
}

func TestConfigSettings_GetSMTP(tt *testing.T) {
	tt.Parallel()
	c := &ConfigSettings{}
	c.GetSMTP()
	c = nil
	c.GetSMTP()
}

func TestConfigSettings_GetSNMP(tt *testing.T) {
	tt.Parallel()
	c := &ConfigSettings{}
	c.GetSNMP()
	c = nil
	c.GetSNMP()
}

func TestConfigSettings_GetSubdomainIsolation(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &ConfigSettings{SubdomainIsolation: &zeroValue}
	c.GetSubdomainIsolation()
	c = &ConfigSettings{}
	c.GetSubdomainIsolation()
	c = nil
	c.GetSubdomainIsolation()
}

func TestConfigSettings_GetSyslog(tt *testing.T) {
	tt.Parallel()
	c := &ConfigSettings{}
	c.GetSyslog()
	c = nil
	c.GetSyslog()
}

func TestConfigSettings_GetTimezone(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ConfigSettings{Timezone: &zeroValue}
	c.GetTimezone()
	c = &ConfigSettings{}
	c.GetTimezone()
	c = nil
	c.GetTimezone()
}

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

func TestConfigSettingsAvatar_GetURI(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ConfigSettingsAvatar{URI: &zeroValue}
	c.GetURI()
	c = &ConfigSettingsAvatar{}
	c.GetURI()
	c = nil
	c.GetURI()
}

func TestConfigSettingsCAS_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ConfigSettingsCAS{URL: &zeroValue}
	c.GetURL()
	c = &ConfigSettingsCAS{}
	c.GetURL()
	c = nil
	c.GetURL()
}

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

func TestConfigSettingsCollectd_GetEncryption(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ConfigSettingsCollectd{Encryption: &zeroValue}
	c.GetEncryption()
	c = &ConfigSettingsCollectd{}
	c.GetEncryption()
	c = nil
	c.GetEncryption()
}

func TestConfigSettingsCollectd_GetPassword(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ConfigSettingsCollectd{Password: &zeroValue}
	c.GetPassword()
	c = &ConfigSettingsCollectd{}
	c.GetPassword()
	c = nil
	c.GetPassword()
}

func TestConfigSettingsCollectd_GetPort(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &ConfigSettingsCollectd{Port: &zeroValue}
	c.GetPort()
	c = &ConfigSettingsCollectd{}
	c.GetPort()
	c = nil
	c.GetPort()
}

func TestConfigSettingsCollectd_GetServer(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ConfigSettingsCollectd{Server: &zeroValue}
	c.GetServer()
	c = &ConfigSettingsCollectd{}
	c.GetServer()
	c = nil
	c.GetServer()
}

func TestConfigSettingsCollectd_GetUsername(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ConfigSettingsCollectd{Username: &zeroValue}
	c.GetUsername()
	c = &ConfigSettingsCollectd{}
	c.GetUsername()
	c = nil
	c.GetUsername()
}

func TestConfigSettingsCustomer_GetEmail(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ConfigSettingsCustomer{Email: &zeroValue}
	c.GetEmail()
	c = &ConfigSettingsCustomer{}
	c.GetEmail()
	c = nil
	c.GetEmail()
}

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

func TestConfigSettingsCustomer_GetPublicKeyData(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ConfigSettingsCustomer{PublicKeyData: &zeroValue}
	c.GetPublicKeyData()
	c = &ConfigSettingsCustomer{}
	c.GetPublicKeyData()
	c = nil
	c.GetPublicKeyData()
}

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

func TestConfigSettingsCustomer_GetUUID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ConfigSettingsCustomer{UUID: &zeroValue}
	c.GetUUID()
	c = &ConfigSettingsCustomer{}
	c.GetUUID()
	c = nil
	c.GetUUID()
}

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

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

func TestConfigSettingsGithubOAuth_GetOrganizationName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ConfigSettingsGithubOAuth{OrganizationName: &zeroValue}
	c.GetOrganizationName()
	c = &ConfigSettingsGithubOAuth{}
	c.GetOrganizationName()
	c = nil
	c.GetOrganizationName()
}

func TestConfigSettingsGithubOAuth_GetOrganizationTeam(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ConfigSettingsGithubOAuth{OrganizationTeam: &zeroValue}
	c.GetOrganizationTeam()
	c = &ConfigSettingsGithubOAuth{}
	c.GetOrganizationTeam()
	c = nil
	c.GetOrganizationTeam()
}

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

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

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

func TestConfigSettingsLDAP_GetAdminGroup(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ConfigSettingsLDAP{AdminGroup: &zeroValue}
	c.GetAdminGroup()
	c = &ConfigSettingsLDAP{}
	c.GetAdminGroup()
	c = nil
	c.GetAdminGroup()
}

func TestConfigSettingsLDAP_GetBase(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	c := &ConfigSettingsLDAP{Base: zeroValue}
	c.GetBase()
	c = &ConfigSettingsLDAP{}
	c.GetBase()
	c = nil
	c.GetBase()
}

func TestConfigSettingsLDAP_GetBindDN(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ConfigSettingsLDAP{BindDN: &zeroValue}
	c.GetBindDN()
	c = &ConfigSettingsLDAP{}
	c.GetBindDN()
	c = nil
	c.GetBindDN()
}

func TestConfigSettingsLDAP_GetHost(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ConfigSettingsLDAP{Host: &zeroValue}
	c.GetHost()
	c = &ConfigSettingsLDAP{}
	c.GetHost()
	c = nil
	c.GetHost()
}

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

func TestConfigSettingsLDAP_GetPassword(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ConfigSettingsLDAP{Password: &zeroValue}
	c.GetPassword()
	c = &ConfigSettingsLDAP{}
	c.GetPassword()
	c = nil
	c.GetPassword()
}

func TestConfigSettingsLDAP_GetPort(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &ConfigSettingsLDAP{Port: &zeroValue}
	c.GetPort()
	c = &ConfigSettingsLDAP{}
	c.GetPort()
	c = nil
	c.GetPort()
}

func TestConfigSettingsLDAP_GetPosixSupport(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &ConfigSettingsLDAP{PosixSupport: &zeroValue}
	c.GetPosixSupport()
	c = &ConfigSettingsLDAP{}
	c.GetPosixSupport()
	c = nil
	c.GetPosixSupport()
}

func TestConfigSettingsLDAP_GetProfile(tt *testing.T) {
	tt.Parallel()
	c := &ConfigSettingsLDAP{}
	c.GetProfile()
	c = nil
	c.GetProfile()
}

func TestConfigSettingsLDAP_GetReconciliation(tt *testing.T) {
	tt.Parallel()
	c := &ConfigSettingsLDAP{}
	c.GetReconciliation()
	c = nil
	c.GetReconciliation()
}

func TestConfigSettingsLDAP_GetRecursiveGroupSearch(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &ConfigSettingsLDAP{RecursiveGroupSearch: &zeroValue}
	c.GetRecursiveGroupSearch()
	c = &ConfigSettingsLDAP{}
	c.GetRecursiveGroupSearch()
	c = nil
	c.GetRecursiveGroupSearch()
}

func TestConfigSettingsLDAP_GetSearchStrategy(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ConfigSettingsLDAP{SearchStrategy: &zeroValue}
	c.GetSearchStrategy()
	c = &ConfigSettingsLDAP{}
	c.GetSearchStrategy()
	c = nil
	c.GetSearchStrategy()
}

func TestConfigSettingsLDAP_GetSyncEnabled(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &ConfigSettingsLDAP{SyncEnabled: &zeroValue}
	c.GetSyncEnabled()
	c = &ConfigSettingsLDAP{}
	c.GetSyncEnabled()
	c = nil
	c.GetSyncEnabled()
}

func TestConfigSettingsLDAP_GetTeamSyncInterval(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &ConfigSettingsLDAP{TeamSyncInterval: &zeroValue}
	c.GetTeamSyncInterval()
	c = &ConfigSettingsLDAP{}
	c.GetTeamSyncInterval()
	c = nil
	c.GetTeamSyncInterval()
}

func TestConfigSettingsLDAP_GetUID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ConfigSettingsLDAP{UID: &zeroValue}
	c.GetUID()
	c = &ConfigSettingsLDAP{}
	c.GetUID()
	c = nil
	c.GetUID()
}

func TestConfigSettingsLDAP_GetUserGroups(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	c := &ConfigSettingsLDAP{UserGroups: zeroValue}
	c.GetUserGroups()
	c = &ConfigSettingsLDAP{}
	c.GetUserGroups()
	c = nil
	c.GetUserGroups()
}

func TestConfigSettingsLDAP_GetUserSyncEmails(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &ConfigSettingsLDAP{UserSyncEmails: &zeroValue}
	c.GetUserSyncEmails()
	c = &ConfigSettingsLDAP{}
	c.GetUserSyncEmails()
	c = nil
	c.GetUserSyncEmails()
}

func TestConfigSettingsLDAP_GetUserSyncInterval(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &ConfigSettingsLDAP{UserSyncInterval: &zeroValue}
	c.GetUserSyncInterval()
	c = &ConfigSettingsLDAP{}
	c.GetUserSyncInterval()
	c = nil
	c.GetUserSyncInterval()
}

func TestConfigSettingsLDAP_GetUserSyncKeys(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &ConfigSettingsLDAP{UserSyncKeys: &zeroValue}
	c.GetUserSyncKeys()
	c = &ConfigSettingsLDAP{}
	c.GetUserSyncKeys()
	c = nil
	c.GetUserSyncKeys()
}

func TestConfigSettingsLDAP_GetVirtualAttributeEnabled(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &ConfigSettingsLDAP{VirtualAttributeEnabled: &zeroValue}
	c.GetVirtualAttributeEnabled()
	c = &ConfigSettingsLDAP{}
	c.GetVirtualAttributeEnabled()
	c = nil
	c.GetVirtualAttributeEnabled()
}

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

func TestConfigSettingsLDAPProfile_GetMail(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ConfigSettingsLDAPProfile{Mail: &zeroValue}
	c.GetMail()
	c = &ConfigSettingsLDAPProfile{}
	c.GetMail()
	c = nil
	c.GetMail()
}

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

func TestConfigSettingsLDAPProfile_GetUID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ConfigSettingsLDAPProfile{UID: &zeroValue}
	c.GetUID()
	c = &ConfigSettingsLDAPProfile{}
	c.GetUID()
	c = nil
	c.GetUID()
}

func TestConfigSettingsLDAPReconciliation_GetOrg(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ConfigSettingsLDAPReconciliation{Org: &zeroValue}
	c.GetOrg()
	c = &ConfigSettingsLDAPReconciliation{}
	c.GetOrg()
	c = nil
	c.GetOrg()
}

func TestConfigSettingsLDAPReconciliation_GetUser(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ConfigSettingsLDAPReconciliation{User: &zeroValue}
	c.GetUser()
	c = &ConfigSettingsLDAPReconciliation{}
	c.GetUser()
	c = nil
	c.GetUser()
}

func TestConfigSettingsLicenseSettings_GetClusterSupport(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &ConfigSettingsLicenseSettings{ClusterSupport: &zeroValue}
	c.GetClusterSupport()
	c = &ConfigSettingsLicenseSettings{}
	c.GetClusterSupport()
	c = nil
	c.GetClusterSupport()
}

func TestConfigSettingsLicenseSettings_GetEvaluation(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &ConfigSettingsLicenseSettings{Evaluation: &zeroValue}
	c.GetEvaluation()
	c = &ConfigSettingsLicenseSettings{}
	c.GetEvaluation()
	c = nil
	c.GetEvaluation()
}

func TestConfigSettingsLicenseSettings_GetExpireAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	c := &ConfigSettingsLicenseSettings{ExpireAt: &zeroValue}
	c.GetExpireAt()
	c = &ConfigSettingsLicenseSettings{}
	c.GetExpireAt()
	c = nil
	c.GetExpireAt()
}

func TestConfigSettingsLicenseSettings_GetPerpetual(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &ConfigSettingsLicenseSettings{Perpetual: &zeroValue}
	c.GetPerpetual()
	c = &ConfigSettingsLicenseSettings{}
	c.GetPerpetual()
	c = nil
	c.GetPerpetual()
}

func TestConfigSettingsLicenseSettings_GetSeats(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &ConfigSettingsLicenseSettings{Seats: &zeroValue}
	c.GetSeats()
	c = &ConfigSettingsLicenseSettings{}
	c.GetSeats()
	c = nil
	c.GetSeats()
}

func TestConfigSettingsLicenseSettings_GetSSHAllowed(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &ConfigSettingsLicenseSettings{SSHAllowed: &zeroValue}
	c.GetSSHAllowed()
	c = &ConfigSettingsLicenseSettings{}
	c.GetSSHAllowed()
	c = nil
	c.GetSSHAllowed()
}

func TestConfigSettingsLicenseSettings_GetSupportKey(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ConfigSettingsLicenseSettings{SupportKey: &zeroValue}
	c.GetSupportKey()
	c = &ConfigSettingsLicenseSettings{}
	c.GetSupportKey()
	c = nil
	c.GetSupportKey()
}

func TestConfigSettingsLicenseSettings_GetUnlimitedSeating(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &ConfigSettingsLicenseSettings{UnlimitedSeating: &zeroValue}
	c.GetUnlimitedSeating()
	c = &ConfigSettingsLicenseSettings{}
	c.GetUnlimitedSeating()
	c = nil
	c.GetUnlimitedSeating()
}

func TestConfigSettingsMapping_GetBasemap(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ConfigSettingsMapping{Basemap: &zeroValue}
	c.GetBasemap()
	c = &ConfigSettingsMapping{}
	c.GetBasemap()
	c = nil
	c.GetBasemap()
}

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

func TestConfigSettingsMapping_GetTileserver(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ConfigSettingsMapping{Tileserver: &zeroValue}
	c.GetTileserver()
	c = &ConfigSettingsMapping{}
	c.GetTileserver()
	c = nil
	c.GetTileserver()
}

func TestConfigSettingsMapping_GetToken(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ConfigSettingsMapping{Token: &zeroValue}
	c.GetToken()
	c = &ConfigSettingsMapping{}
	c.GetToken()
	c = nil
	c.GetToken()
}

func TestConfigSettingsNTP_GetPrimaryServer(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ConfigSettingsNTP{PrimaryServer: &zeroValue}
	c.GetPrimaryServer()
	c = &ConfigSettingsNTP{}
	c.GetPrimaryServer()
	c = nil
	c.GetPrimaryServer()
}

func TestConfigSettingsNTP_GetSecondaryServer(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ConfigSettingsNTP{SecondaryServer: &zeroValue}
	c.GetSecondaryServer()
	c = &ConfigSettingsNTP{}
	c.GetSecondaryServer()
	c = nil
	c.GetSecondaryServer()
}

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

func TestConfigSettingsSAML_GetCertificate(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ConfigSettingsSAML{Certificate: &zeroValue}
	c.GetCertificate()
	c = &ConfigSettingsSAML{}
	c.GetCertificate()
	c = nil
	c.GetCertificate()
}

func TestConfigSettingsSAML_GetCertificatePath(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ConfigSettingsSAML{CertificatePath: &zeroValue}
	c.GetCertificatePath()
	c = &ConfigSettingsSAML{}
	c.GetCertificatePath()
	c = nil
	c.GetCertificatePath()
}

func TestConfigSettingsSAML_GetDisableAdminDemote(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &ConfigSettingsSAML{DisableAdminDemote: &zeroValue}
	c.GetDisableAdminDemote()
	c = &ConfigSettingsSAML{}
	c.GetDisableAdminDemote()
	c = nil
	c.GetDisableAdminDemote()
}

func TestConfigSettingsSAML_GetIDPInitiatedSSO(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &ConfigSettingsSAML{IDPInitiatedSSO: &zeroValue}
	c.GetIDPInitiatedSSO()
	c = &ConfigSettingsSAML{}
	c.GetIDPInitiatedSSO()
	c = nil
	c.GetIDPInitiatedSSO()
}

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

func TestConfigSettingsSAML_GetSSOURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ConfigSettingsSAML{SSOURL: &zeroValue}
	c.GetSSOURL()
	c = &ConfigSettingsSAML{}
	c.GetSSOURL()
	c = nil
	c.GetSSOURL()
}

func TestConfigSettingsSMTP_GetAddress(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ConfigSettingsSMTP{Address: &zeroValue}
	c.GetAddress()
	c = &ConfigSettingsSMTP{}
	c.GetAddress()
	c = nil
	c.GetAddress()
}

func TestConfigSettingsSMTP_GetAuthentication(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ConfigSettingsSMTP{Authentication: &zeroValue}
	c.GetAuthentication()
	c = &ConfigSettingsSMTP{}
	c.GetAuthentication()
	c = nil
	c.GetAuthentication()
}

func TestConfigSettingsSMTP_GetDiscardToNoreplyAddress(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &ConfigSettingsSMTP{DiscardToNoreplyAddress: &zeroValue}
	c.GetDiscardToNoreplyAddress()
	c = &ConfigSettingsSMTP{}
	c.GetDiscardToNoreplyAddress()
	c = nil
	c.GetDiscardToNoreplyAddress()
}

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

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

func TestConfigSettingsSMTP_GetEnableStarttlsAuto(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &ConfigSettingsSMTP{EnableStarttlsAuto: &zeroValue}
	c.GetEnableStarttlsAuto()
	c = &ConfigSettingsSMTP{}
	c.GetEnableStarttlsAuto()
	c = nil
	c.GetEnableStarttlsAuto()
}

func TestConfigSettingsSMTP_GetNoreplyAddress(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ConfigSettingsSMTP{NoreplyAddress: &zeroValue}
	c.GetNoreplyAddress()
	c = &ConfigSettingsSMTP{}
	c.GetNoreplyAddress()
	c = nil
	c.GetNoreplyAddress()
}

func TestConfigSettingsSMTP_GetPassword(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ConfigSettingsSMTP{Password: &zeroValue}
	c.GetPassword()
	c = &ConfigSettingsSMTP{}
	c.GetPassword()
	c = nil
	c.GetPassword()
}

func TestConfigSettingsSMTP_GetPort(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ConfigSettingsSMTP{Port: &zeroValue}
	c.GetPort()
	c = &ConfigSettingsSMTP{}
	c.GetPort()
	c = nil
	c.GetPort()
}

func TestConfigSettingsSMTP_GetSupportAddress(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ConfigSettingsSMTP{SupportAddress: &zeroValue}
	c.GetSupportAddress()
	c = &ConfigSettingsSMTP{}
	c.GetSupportAddress()
	c = nil
	c.GetSupportAddress()
}

func TestConfigSettingsSMTP_GetSupportAddressType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ConfigSettingsSMTP{SupportAddressType: &zeroValue}
	c.GetSupportAddressType()
	c = &ConfigSettingsSMTP{}
	c.GetSupportAddressType()
	c = nil
	c.GetSupportAddressType()
}

func TestConfigSettingsSMTP_GetUsername(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ConfigSettingsSMTP{Username: &zeroValue}
	c.GetUsername()
	c = &ConfigSettingsSMTP{}
	c.GetUsername()
	c = nil
	c.GetUsername()
}

func TestConfigSettingsSMTP_GetUserName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ConfigSettingsSMTP{UserName: &zeroValue}
	c.GetUserName()
	c = &ConfigSettingsSMTP{}
	c.GetUserName()
	c = nil
	c.GetUserName()
}

func TestConfigSettingsSNMP_GetCommunity(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ConfigSettingsSNMP{Community: &zeroValue}
	c.GetCommunity()
	c = &ConfigSettingsSNMP{}
	c.GetCommunity()
	c = nil
	c.GetCommunity()
}

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

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

func TestConfigSettingsSyslog_GetProtocolName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ConfigSettingsSyslog{ProtocolName: &zeroValue}
	c.GetProtocolName()
	c = &ConfigSettingsSyslog{}
	c.GetProtocolName()
	c = nil
	c.GetProtocolName()
}

func TestConfigSettingsSyslog_GetServer(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ConfigSettingsSyslog{Server: &zeroValue}
	c.GetServer()
	c = &ConfigSettingsSyslog{}
	c.GetServer()
	c = nil
	c.GetServer()
}

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

func TestConnectionServiceItem_GetNumber(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &ConnectionServiceItem{Number: &zeroValue}
	c.GetNumber()
	c = &ConnectionServiceItem{}
	c.GetNumber()
	c = nil
	c.GetNumber()
}

func TestContentReference_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	c := &ContentReference{ID: &zeroValue}
	c.GetID()
	c = &ContentReference{}
	c.GetID()
	c = nil
	c.GetID()
}

func TestContentReference_GetNodeID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ContentReference{NodeID: &zeroValue}
	c.GetNodeID()
	c = &ContentReference{}
	c.GetNodeID()
	c = nil
	c.GetNodeID()
}

func TestContentReference_GetReference(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ContentReference{Reference: &zeroValue}
	c.GetReference()
	c = &ContentReference{}
	c.GetReference()
	c = nil
	c.GetReference()
}

func TestContentReferenceEvent_GetAction(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &ContentReferenceEvent{Action: &zeroValue}
	c.GetAction()
	c = &ContentReferenceEvent{}
	c.GetAction()
	c = nil
	c.GetAction()
}

func TestContentReferenceEvent_GetContentReference(tt *testing.T) {
	tt.Parallel()
	c := &ContentReferenceEvent{}
	c.GetContentReference()
	c = nil
	c.GetContentReference()
}

func TestContentReferenceEvent_GetInstallation(tt *testing.T) {
	tt.Parallel()
	c := &ContentReferenceEvent{}
	c.GetInstallation()
	c = nil
	c.GetInstallation()
}

func TestContentReferenceEvent_GetRepo(tt *testing.T) {
	tt.Parallel()
	c := &ContentReferenceEvent{}
	c.GetRepo()
	c = nil
	c.GetRepo()
}

func TestContentReferenceEvent_GetSender(tt *testing.T) {
	tt.Parallel()
	c := &ContentReferenceEvent{}
	c.GetSender()
	c = nil
	c.GetSender()
}

func TestContributor_GetAvatarURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &Contributor{AvatarURL: &zeroValue}
	c.GetAvatarURL()
	c = &Contributor{}
	c.GetAvatarURL()
	c = nil
	c.GetAvatarURL()
}

func TestContributor_GetContributions(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &Contributor{Contributions: &zeroValue}
	c.GetContributions()
	c = &Contributor{}
	c.GetContributions()
	c = nil
	c.GetContributions()
}

func TestContributor_GetEmail(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &Contributor{Email: &zeroValue}
	c.GetEmail()
	c = &Contributor{}
	c.GetEmail()
	c = nil
	c.GetEmail()
}

func TestContributor_GetEventsURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &Contributor{EventsURL: &zeroValue}
	c.GetEventsURL()
	c = &Contributor{}
	c.GetEventsURL()
	c = nil
	c.GetEventsURL()
}

func TestContributor_GetFollowersURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &Contributor{FollowersURL: &zeroValue}
	c.GetFollowersURL()
	c = &Contributor{}
	c.GetFollowersURL()
	c = nil
	c.GetFollowersURL()
}

func TestContributor_GetFollowingURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &Contributor{FollowingURL: &zeroValue}
	c.GetFollowingURL()
	c = &Contributor{}
	c.GetFollowingURL()
	c = nil
	c.GetFollowingURL()
}

func TestContributor_GetGistsURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &Contributor{GistsURL: &zeroValue}
	c.GetGistsURL()
	c = &Contributor{}
	c.GetGistsURL()
	c = nil
	c.GetGistsURL()
}

func TestContributor_GetGravatarID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &Contributor{GravatarID: &zeroValue}
	c.GetGravatarID()
	c = &Contributor{}
	c.GetGravatarID()
	c = nil
	c.GetGravatarID()
}

func TestContributor_GetHTMLURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &Contributor{HTMLURL: &zeroValue}
	c.GetHTMLURL()
	c = &Contributor{}
	c.GetHTMLURL()
	c = nil
	c.GetHTMLURL()
}

func TestContributor_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	c := &Contributor{ID: &zeroValue}
	c.GetID()
	c = &Contributor{}
	c.GetID()
	c = nil
	c.GetID()
}

func TestContributor_GetLogin(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &Contributor{Login: &zeroValue}
	c.GetLogin()
	c = &Contributor{}
	c.GetLogin()
	c = nil
	c.GetLogin()
}

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

func TestContributor_GetNodeID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &Contributor{NodeID: &zeroValue}
	c.GetNodeID()
	c = &Contributor{}
	c.GetNodeID()
	c = nil
	c.GetNodeID()
}

func TestContributor_GetOrganizationsURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &Contributor{OrganizationsURL: &zeroValue}
	c.GetOrganizationsURL()
	c = &Contributor{}
	c.GetOrganizationsURL()
	c = nil
	c.GetOrganizationsURL()
}

func TestContributor_GetReceivedEventsURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &Contributor{ReceivedEventsURL: &zeroValue}
	c.GetReceivedEventsURL()
	c = &Contributor{}
	c.GetReceivedEventsURL()
	c = nil
	c.GetReceivedEventsURL()
}

func TestContributor_GetReposURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &Contributor{ReposURL: &zeroValue}
	c.GetReposURL()
	c = &Contributor{}
	c.GetReposURL()
	c = nil
	c.GetReposURL()
}

func TestContributor_GetSiteAdmin(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &Contributor{SiteAdmin: &zeroValue}
	c.GetSiteAdmin()
	c = &Contributor{}
	c.GetSiteAdmin()
	c = nil
	c.GetSiteAdmin()
}

func TestContributor_GetStarredURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &Contributor{StarredURL: &zeroValue}
	c.GetStarredURL()
	c = &Contributor{}
	c.GetStarredURL()
	c = nil
	c.GetStarredURL()
}

func TestContributor_GetSubscriptionsURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &Contributor{SubscriptionsURL: &zeroValue}
	c.GetSubscriptionsURL()
	c = &Contributor{}
	c.GetSubscriptionsURL()
	c = nil
	c.GetSubscriptionsURL()
}

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

func TestContributor_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &Contributor{URL: &zeroValue}
	c.GetURL()
	c = &Contributor{}
	c.GetURL()
	c = nil
	c.GetURL()
}

func TestContributorApprovalPermissions_GetApprovalPolicy(tt *testing.T) {
	tt.Parallel()
	c := &ContributorApprovalPermissions{}
	c.GetApprovalPolicy()
	c = nil
	c.GetApprovalPolicy()
}

func TestContributorStats_GetAuthor(tt *testing.T) {
	tt.Parallel()
	c := &ContributorStats{}
	c.GetAuthor()
	c = nil
	c.GetAuthor()
}

func TestContributorStats_GetTotal(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &ContributorStats{Total: &zeroValue}
	c.GetTotal()
	c = &ContributorStats{}
	c.GetTotal()
	c = nil
	c.GetTotal()
}

func TestContributorStats_GetWeeks(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*WeeklyStats{}
	c := &ContributorStats{Weeks: zeroValue}
	c.GetWeeks()
	c = &ContributorStats{}
	c.GetWeeks()
	c = nil
	c.GetWeeks()
}

func TestCopilotCloudAgentConfiguration_GetCustomAllowlist(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	c := &CopilotCloudAgentConfiguration{CustomAllowlist: zeroValue}
	c.GetCustomAllowlist()
	c = &CopilotCloudAgentConfiguration{}
	c.GetCustomAllowlist()
	c = nil
	c.GetCustomAllowlist()
}

func TestCopilotCloudAgentConfiguration_GetEnabledTools(tt *testing.T) {
	tt.Parallel()
	c := &CopilotCloudAgentConfiguration{}
	c.GetEnabledTools()
	c = nil
	c.GetEnabledTools()
}

func TestCopilotCloudAgentConfiguration_GetIsFirewallEnabled(tt *testing.T) {
	tt.Parallel()
	c := &CopilotCloudAgentConfiguration{}
	c.GetIsFirewallEnabled()
	c = nil
	c.GetIsFirewallEnabled()
}

func TestCopilotCloudAgentConfiguration_GetIsFirewallRecommendedAllowlistEnabled(tt *testing.T) {
	tt.Parallel()
	c := &CopilotCloudAgentConfiguration{}
	c.GetIsFirewallRecommendedAllowlistEnabled()
	c = nil
	c.GetIsFirewallRecommendedAllowlistEnabled()
}

func TestCopilotCloudAgentConfiguration_GetMCPConfiguration(tt *testing.T) {
	tt.Parallel()
	c := &CopilotCloudAgentConfiguration{}
	c.GetMCPConfiguration()
	c = nil
	c.GetMCPConfiguration()
}

func TestCopilotCloudAgentConfiguration_GetRequireActionsWorkflowApproval(tt *testing.T) {
	tt.Parallel()
	c := &CopilotCloudAgentConfiguration{}
	c.GetRequireActionsWorkflowApproval()
	c = nil
	c.GetRequireActionsWorkflowApproval()
}

func TestCopilotCloudAgentEnabledTools_GetCodeql(tt *testing.T) {
	tt.Parallel()
	c := &CopilotCloudAgentEnabledTools{}
	c.GetCodeql()
	c = nil
	c.GetCodeql()
}

func TestCopilotCloudAgentEnabledTools_GetCopilotCodeReview(tt *testing.T) {
	tt.Parallel()
	c := &CopilotCloudAgentEnabledTools{}
	c.GetCopilotCodeReview()
	c = nil
	c.GetCopilotCodeReview()
}

func TestCopilotCloudAgentEnabledTools_GetDependencyVulnerabilityChecks(tt *testing.T) {
	tt.Parallel()
	c := &CopilotCloudAgentEnabledTools{}
	c.GetDependencyVulnerabilityChecks()
	c = nil
	c.GetDependencyVulnerabilityChecks()
}

func TestCopilotCloudAgentEnabledTools_GetSecretScanning(tt *testing.T) {
	tt.Parallel()
	c := &CopilotCloudAgentEnabledTools{}
	c.GetSecretScanning()
	c = nil
	c.GetSecretScanning()
}

func TestCopilotCodeReviewBranchRule_GetParameters(tt *testing.T) {
	tt.Parallel()
	c := &CopilotCodeReviewBranchRule{}
	c.GetParameters()
	c = nil
	c.GetParameters()
}

func TestCopilotCodeReviewRuleParameters_GetReviewDraftPullRequests(tt *testing.T) {
	tt.Parallel()
	c := &CopilotCodeReviewRuleParameters{}
	c.GetReviewDraftPullRequests()
	c = nil
	c.GetReviewDraftPullRequests()
}

func TestCopilotCodeReviewRuleParameters_GetReviewOnPush(tt *testing.T) {
	tt.Parallel()
	c := &CopilotCodeReviewRuleParameters{}
	c.GetReviewOnPush()
	c = nil
	c.GetReviewOnPush()
}

func TestCopilotDailyMetrics_GetCodeAcceptanceActivityCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CopilotDailyMetrics{CodeAcceptanceActivityCount: &zeroValue}
	c.GetCodeAcceptanceActivityCount()
	c = &CopilotDailyMetrics{}
	c.GetCodeAcceptanceActivityCount()
	c = nil
	c.GetCodeAcceptanceActivityCount()
}

func TestCopilotDailyMetrics_GetCodeGenerationActivityCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CopilotDailyMetrics{CodeGenerationActivityCount: &zeroValue}
	c.GetCodeGenerationActivityCount()
	c = &CopilotDailyMetrics{}
	c.GetCodeGenerationActivityCount()
	c = nil
	c.GetCodeGenerationActivityCount()
}

func TestCopilotDailyMetrics_GetDailyActiveCLIUsers(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CopilotDailyMetrics{DailyActiveCLIUsers: &zeroValue}
	c.GetDailyActiveCLIUsers()
	c = &CopilotDailyMetrics{}
	c.GetDailyActiveCLIUsers()
	c = nil
	c.GetDailyActiveCLIUsers()
}

func TestCopilotDailyMetrics_GetDailyActiveCopilotCloudAgentUsers(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CopilotDailyMetrics{DailyActiveCopilotCloudAgentUsers: &zeroValue}
	c.GetDailyActiveCopilotCloudAgentUsers()
	c = &CopilotDailyMetrics{}
	c.GetDailyActiveCopilotCloudAgentUsers()
	c = nil
	c.GetDailyActiveCopilotCloudAgentUsers()
}

func TestCopilotDailyMetrics_GetDailyActiveUsers(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CopilotDailyMetrics{DailyActiveUsers: &zeroValue}
	c.GetDailyActiveUsers()
	c = &CopilotDailyMetrics{}
	c.GetDailyActiveUsers()
	c = nil
	c.GetDailyActiveUsers()
}

func TestCopilotDailyMetrics_GetDay(tt *testing.T) {
	tt.Parallel()
	c := &CopilotDailyMetrics{}
	c.GetDay()
	c = nil
	c.GetDay()
}

func TestCopilotDailyMetrics_GetEnterpriseID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CopilotDailyMetrics{EnterpriseID: &zeroValue}
	c.GetEnterpriseID()
	c = &CopilotDailyMetrics{}
	c.GetEnterpriseID()
	c = nil
	c.GetEnterpriseID()
}

func TestCopilotDailyMetrics_GetLOCAddedSum(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CopilotDailyMetrics{LOCAddedSum: &zeroValue}
	c.GetLOCAddedSum()
	c = &CopilotDailyMetrics{}
	c.GetLOCAddedSum()
	c = nil
	c.GetLOCAddedSum()
}

func TestCopilotDailyMetrics_GetLOCDeletedSum(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CopilotDailyMetrics{LOCDeletedSum: &zeroValue}
	c.GetLOCDeletedSum()
	c = &CopilotDailyMetrics{}
	c.GetLOCDeletedSum()
	c = nil
	c.GetLOCDeletedSum()
}

func TestCopilotDailyMetrics_GetLOCSuggestedToAddSum(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CopilotDailyMetrics{LOCSuggestedToAddSum: &zeroValue}
	c.GetLOCSuggestedToAddSum()
	c = &CopilotDailyMetrics{}
	c.GetLOCSuggestedToAddSum()
	c = nil
	c.GetLOCSuggestedToAddSum()
}

func TestCopilotDailyMetrics_GetLOCSuggestedToDeleteSum(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CopilotDailyMetrics{LOCSuggestedToDeleteSum: &zeroValue}
	c.GetLOCSuggestedToDeleteSum()
	c = &CopilotDailyMetrics{}
	c.GetLOCSuggestedToDeleteSum()
	c = nil
	c.GetLOCSuggestedToDeleteSum()
}

func TestCopilotDailyMetrics_GetMonthlyActiveAgentUsers(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CopilotDailyMetrics{MonthlyActiveAgentUsers: &zeroValue}
	c.GetMonthlyActiveAgentUsers()
	c = &CopilotDailyMetrics{}
	c.GetMonthlyActiveAgentUsers()
	c = nil
	c.GetMonthlyActiveAgentUsers()
}

func TestCopilotDailyMetrics_GetMonthlyActiveChatUsers(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CopilotDailyMetrics{MonthlyActiveChatUsers: &zeroValue}
	c.GetMonthlyActiveChatUsers()
	c = &CopilotDailyMetrics{}
	c.GetMonthlyActiveChatUsers()
	c = nil
	c.GetMonthlyActiveChatUsers()
}

func TestCopilotDailyMetrics_GetMonthlyActiveCopilotCloudAgentUsers(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CopilotDailyMetrics{MonthlyActiveCopilotCloudAgentUsers: &zeroValue}
	c.GetMonthlyActiveCopilotCloudAgentUsers()
	c = &CopilotDailyMetrics{}
	c.GetMonthlyActiveCopilotCloudAgentUsers()
	c = nil
	c.GetMonthlyActiveCopilotCloudAgentUsers()
}

func TestCopilotDailyMetrics_GetMonthlyActiveUsers(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CopilotDailyMetrics{MonthlyActiveUsers: &zeroValue}
	c.GetMonthlyActiveUsers()
	c = &CopilotDailyMetrics{}
	c.GetMonthlyActiveUsers()
	c = nil
	c.GetMonthlyActiveUsers()
}

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

func TestCopilotDailyMetrics_GetPullRequests(tt *testing.T) {
	tt.Parallel()
	c := &CopilotDailyMetrics{}
	c.GetPullRequests()
	c = nil
	c.GetPullRequests()
}

func TestCopilotDailyMetrics_GetTotalsByCLI(tt *testing.T) {
	tt.Parallel()
	c := &CopilotDailyMetrics{}
	c.GetTotalsByCLI()
	c = nil
	c.GetTotalsByCLI()
}

func TestCopilotDailyMetrics_GetTotalsByFeature(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*CopilotMetricsFeature{}
	c := &CopilotDailyMetrics{TotalsByFeature: zeroValue}
	c.GetTotalsByFeature()
	c = &CopilotDailyMetrics{}
	c.GetTotalsByFeature()
	c = nil
	c.GetTotalsByFeature()
}

func TestCopilotDailyMetrics_GetTotalsByIDE(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*CopilotMetricsIDE{}
	c := &CopilotDailyMetrics{TotalsByIDE: zeroValue}
	c.GetTotalsByIDE()
	c = &CopilotDailyMetrics{}
	c.GetTotalsByIDE()
	c = nil
	c.GetTotalsByIDE()
}

func TestCopilotDailyMetrics_GetTotalsByLanguageFeature(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*CopilotMetricsLanguageFeature{}
	c := &CopilotDailyMetrics{TotalsByLanguageFeature: zeroValue}
	c.GetTotalsByLanguageFeature()
	c = &CopilotDailyMetrics{}
	c.GetTotalsByLanguageFeature()
	c = nil
	c.GetTotalsByLanguageFeature()
}

func TestCopilotDailyMetrics_GetTotalsByLanguageModel(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*CopilotMetricsLanguageModel{}
	c := &CopilotDailyMetrics{TotalsByLanguageModel: zeroValue}
	c.GetTotalsByLanguageModel()
	c = &CopilotDailyMetrics{}
	c.GetTotalsByLanguageModel()
	c = nil
	c.GetTotalsByLanguageModel()
}

func TestCopilotDailyMetrics_GetTotalsByModelFeature(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*CopilotMetricsModelFeature{}
	c := &CopilotDailyMetrics{TotalsByModelFeature: zeroValue}
	c.GetTotalsByModelFeature()
	c = &CopilotDailyMetrics{}
	c.GetTotalsByModelFeature()
	c = nil
	c.GetTotalsByModelFeature()
}

func TestCopilotDailyMetrics_GetUserInitiatedInteractionCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CopilotDailyMetrics{UserInitiatedInteractionCount: &zeroValue}
	c.GetUserInitiatedInteractionCount()
	c = &CopilotDailyMetrics{}
	c.GetUserInitiatedInteractionCount()
	c = nil
	c.GetUserInitiatedInteractionCount()
}

func TestCopilotDailyMetrics_GetWeeklyActiveCopilotCloudAgentUsers(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CopilotDailyMetrics{WeeklyActiveCopilotCloudAgentUsers: &zeroValue}
	c.GetWeeklyActiveCopilotCloudAgentUsers()
	c = &CopilotDailyMetrics{}
	c.GetWeeklyActiveCopilotCloudAgentUsers()
	c = nil
	c.GetWeeklyActiveCopilotCloudAgentUsers()
}

func TestCopilotDailyMetrics_GetWeeklyActiveUsers(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CopilotDailyMetrics{WeeklyActiveUsers: &zeroValue}
	c.GetWeeklyActiveUsers()
	c = &CopilotDailyMetrics{}
	c.GetWeeklyActiveUsers()
	c = nil
	c.GetWeeklyActiveUsers()
}

func TestCopilotDailyMetricsReport_GetDownloadLinks(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	c := &CopilotDailyMetricsReport{DownloadLinks: zeroValue}
	c.GetDownloadLinks()
	c = &CopilotDailyMetricsReport{}
	c.GetDownloadLinks()
	c = nil
	c.GetDownloadLinks()
}

func TestCopilotDailyMetricsReport_GetReportDay(tt *testing.T) {
	tt.Parallel()
	c := &CopilotDailyMetricsReport{}
	c.GetReportDay()
	c = nil
	c.GetReportDay()
}

func TestCopilotDotcomChat_GetModels(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*CopilotDotcomChatModel{}
	c := &CopilotDotcomChat{Models: zeroValue}
	c.GetModels()
	c = &CopilotDotcomChat{}
	c.GetModels()
	c = nil
	c.GetModels()
}

func TestCopilotDotcomChat_GetTotalEngagedUsers(tt *testing.T) {
	tt.Parallel()
	c := &CopilotDotcomChat{}
	c.GetTotalEngagedUsers()
	c = nil
	c.GetTotalEngagedUsers()
}

func TestCopilotDotcomChatModel_GetCustomModelTrainingDate(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CopilotDotcomChatModel{CustomModelTrainingDate: &zeroValue}
	c.GetCustomModelTrainingDate()
	c = &CopilotDotcomChatModel{}
	c.GetCustomModelTrainingDate()
	c = nil
	c.GetCustomModelTrainingDate()
}

func TestCopilotDotcomChatModel_GetIsCustomModel(tt *testing.T) {
	tt.Parallel()
	c := &CopilotDotcomChatModel{}
	c.GetIsCustomModel()
	c = nil
	c.GetIsCustomModel()
}

func TestCopilotDotcomChatModel_GetName(tt *testing.T) {
	tt.Parallel()
	c := &CopilotDotcomChatModel{}
	c.GetName()
	c = nil
	c.GetName()
}

func TestCopilotDotcomChatModel_GetTotalChats(tt *testing.T) {
	tt.Parallel()
	c := &CopilotDotcomChatModel{}
	c.GetTotalChats()
	c = nil
	c.GetTotalChats()
}

func TestCopilotDotcomChatModel_GetTotalEngagedUsers(tt *testing.T) {
	tt.Parallel()
	c := &CopilotDotcomChatModel{}
	c.GetTotalEngagedUsers()
	c = nil
	c.GetTotalEngagedUsers()
}

func TestCopilotDotcomPullRequests_GetRepositories(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*CopilotDotcomPullRequestsRepository{}
	c := &CopilotDotcomPullRequests{Repositories: zeroValue}
	c.GetRepositories()
	c = &CopilotDotcomPullRequests{}
	c.GetRepositories()
	c = nil
	c.GetRepositories()
}

func TestCopilotDotcomPullRequests_GetTotalEngagedUsers(tt *testing.T) {
	tt.Parallel()
	c := &CopilotDotcomPullRequests{}
	c.GetTotalEngagedUsers()
	c = nil
	c.GetTotalEngagedUsers()
}

func TestCopilotDotcomPullRequestsModel_GetCustomModelTrainingDate(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CopilotDotcomPullRequestsModel{CustomModelTrainingDate: &zeroValue}
	c.GetCustomModelTrainingDate()
	c = &CopilotDotcomPullRequestsModel{}
	c.GetCustomModelTrainingDate()
	c = nil
	c.GetCustomModelTrainingDate()
}

func TestCopilotDotcomPullRequestsModel_GetIsCustomModel(tt *testing.T) {
	tt.Parallel()
	c := &CopilotDotcomPullRequestsModel{}
	c.GetIsCustomModel()
	c = nil
	c.GetIsCustomModel()
}

func TestCopilotDotcomPullRequestsModel_GetName(tt *testing.T) {
	tt.Parallel()
	c := &CopilotDotcomPullRequestsModel{}
	c.GetName()
	c = nil
	c.GetName()
}

func TestCopilotDotcomPullRequestsModel_GetTotalEngagedUsers(tt *testing.T) {
	tt.Parallel()
	c := &CopilotDotcomPullRequestsModel{}
	c.GetTotalEngagedUsers()
	c = nil
	c.GetTotalEngagedUsers()
}

func TestCopilotDotcomPullRequestsModel_GetTotalPRSummariesCreated(tt *testing.T) {
	tt.Parallel()
	c := &CopilotDotcomPullRequestsModel{}
	c.GetTotalPRSummariesCreated()
	c = nil
	c.GetTotalPRSummariesCreated()
}

func TestCopilotDotcomPullRequestsRepository_GetModels(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*CopilotDotcomPullRequestsModel{}
	c := &CopilotDotcomPullRequestsRepository{Models: zeroValue}
	c.GetModels()
	c = &CopilotDotcomPullRequestsRepository{}
	c.GetModels()
	c = nil
	c.GetModels()
}

func TestCopilotDotcomPullRequestsRepository_GetName(tt *testing.T) {
	tt.Parallel()
	c := &CopilotDotcomPullRequestsRepository{}
	c.GetName()
	c = nil
	c.GetName()
}

func TestCopilotDotcomPullRequestsRepository_GetTotalEngagedUsers(tt *testing.T) {
	tt.Parallel()
	c := &CopilotDotcomPullRequestsRepository{}
	c.GetTotalEngagedUsers()
	c = nil
	c.GetTotalEngagedUsers()
}

func TestCopilotIDEChat_GetEditors(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*CopilotIDEChatEditor{}
	c := &CopilotIDEChat{Editors: zeroValue}
	c.GetEditors()
	c = &CopilotIDEChat{}
	c.GetEditors()
	c = nil
	c.GetEditors()
}

func TestCopilotIDEChat_GetTotalEngagedUsers(tt *testing.T) {
	tt.Parallel()
	c := &CopilotIDEChat{}
	c.GetTotalEngagedUsers()
	c = nil
	c.GetTotalEngagedUsers()
}

func TestCopilotIDEChatEditor_GetModels(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*CopilotIDEChatModel{}
	c := &CopilotIDEChatEditor{Models: zeroValue}
	c.GetModels()
	c = &CopilotIDEChatEditor{}
	c.GetModels()
	c = nil
	c.GetModels()
}

func TestCopilotIDEChatEditor_GetName(tt *testing.T) {
	tt.Parallel()
	c := &CopilotIDEChatEditor{}
	c.GetName()
	c = nil
	c.GetName()
}

func TestCopilotIDEChatEditor_GetTotalEngagedUsers(tt *testing.T) {
	tt.Parallel()
	c := &CopilotIDEChatEditor{}
	c.GetTotalEngagedUsers()
	c = nil
	c.GetTotalEngagedUsers()
}

func TestCopilotIDEChatModel_GetCustomModelTrainingDate(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CopilotIDEChatModel{CustomModelTrainingDate: &zeroValue}
	c.GetCustomModelTrainingDate()
	c = &CopilotIDEChatModel{}
	c.GetCustomModelTrainingDate()
	c = nil
	c.GetCustomModelTrainingDate()
}

func TestCopilotIDEChatModel_GetIsCustomModel(tt *testing.T) {
	tt.Parallel()
	c := &CopilotIDEChatModel{}
	c.GetIsCustomModel()
	c = nil
	c.GetIsCustomModel()
}

func TestCopilotIDEChatModel_GetName(tt *testing.T) {
	tt.Parallel()
	c := &CopilotIDEChatModel{}
	c.GetName()
	c = nil
	c.GetName()
}

func TestCopilotIDEChatModel_GetTotalChatCopyEvents(tt *testing.T) {
	tt.Parallel()
	c := &CopilotIDEChatModel{}
	c.GetTotalChatCopyEvents()
	c = nil
	c.GetTotalChatCopyEvents()
}

func TestCopilotIDEChatModel_GetTotalChatInsertionEvents(tt *testing.T) {
	tt.Parallel()
	c := &CopilotIDEChatModel{}
	c.GetTotalChatInsertionEvents()
	c = nil
	c.GetTotalChatInsertionEvents()
}

func TestCopilotIDEChatModel_GetTotalChats(tt *testing.T) {
	tt.Parallel()
	c := &CopilotIDEChatModel{}
	c.GetTotalChats()
	c = nil
	c.GetTotalChats()
}

func TestCopilotIDEChatModel_GetTotalEngagedUsers(tt *testing.T) {
	tt.Parallel()
	c := &CopilotIDEChatModel{}
	c.GetTotalEngagedUsers()
	c = nil
	c.GetTotalEngagedUsers()
}

func TestCopilotIDECodeCompletions_GetEditors(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*CopilotIDECodeCompletionsEditor{}
	c := &CopilotIDECodeCompletions{Editors: zeroValue}
	c.GetEditors()
	c = &CopilotIDECodeCompletions{}
	c.GetEditors()
	c = nil
	c.GetEditors()
}

func TestCopilotIDECodeCompletions_GetLanguages(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*CopilotIDECodeCompletionsLanguage{}
	c := &CopilotIDECodeCompletions{Languages: zeroValue}
	c.GetLanguages()
	c = &CopilotIDECodeCompletions{}
	c.GetLanguages()
	c = nil
	c.GetLanguages()
}

func TestCopilotIDECodeCompletions_GetTotalEngagedUsers(tt *testing.T) {
	tt.Parallel()
	c := &CopilotIDECodeCompletions{}
	c.GetTotalEngagedUsers()
	c = nil
	c.GetTotalEngagedUsers()
}

func TestCopilotIDECodeCompletionsEditor_GetModels(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*CopilotIDECodeCompletionsModel{}
	c := &CopilotIDECodeCompletionsEditor{Models: zeroValue}
	c.GetModels()
	c = &CopilotIDECodeCompletionsEditor{}
	c.GetModels()
	c = nil
	c.GetModels()
}

func TestCopilotIDECodeCompletionsEditor_GetName(tt *testing.T) {
	tt.Parallel()
	c := &CopilotIDECodeCompletionsEditor{}
	c.GetName()
	c = nil
	c.GetName()
}

func TestCopilotIDECodeCompletionsEditor_GetTotalEngagedUsers(tt *testing.T) {
	tt.Parallel()
	c := &CopilotIDECodeCompletionsEditor{}
	c.GetTotalEngagedUsers()
	c = nil
	c.GetTotalEngagedUsers()
}

func TestCopilotIDECodeCompletionsLanguage_GetName(tt *testing.T) {
	tt.Parallel()
	c := &CopilotIDECodeCompletionsLanguage{}
	c.GetName()
	c = nil
	c.GetName()
}

func TestCopilotIDECodeCompletionsLanguage_GetTotalEngagedUsers(tt *testing.T) {
	tt.Parallel()
	c := &CopilotIDECodeCompletionsLanguage{}
	c.GetTotalEngagedUsers()
	c = nil
	c.GetTotalEngagedUsers()
}

func TestCopilotIDECodeCompletionsModel_GetCustomModelTrainingDate(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CopilotIDECodeCompletionsModel{CustomModelTrainingDate: &zeroValue}
	c.GetCustomModelTrainingDate()
	c = &CopilotIDECodeCompletionsModel{}
	c.GetCustomModelTrainingDate()
	c = nil
	c.GetCustomModelTrainingDate()
}

func TestCopilotIDECodeCompletionsModel_GetIsCustomModel(tt *testing.T) {
	tt.Parallel()
	c := &CopilotIDECodeCompletionsModel{}
	c.GetIsCustomModel()
	c = nil
	c.GetIsCustomModel()
}

func TestCopilotIDECodeCompletionsModel_GetLanguages(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*CopilotIDECodeCompletionsModelLanguage{}
	c := &CopilotIDECodeCompletionsModel{Languages: zeroValue}
	c.GetLanguages()
	c = &CopilotIDECodeCompletionsModel{}
	c.GetLanguages()
	c = nil
	c.GetLanguages()
}

func TestCopilotIDECodeCompletionsModel_GetName(tt *testing.T) {
	tt.Parallel()
	c := &CopilotIDECodeCompletionsModel{}
	c.GetName()
	c = nil
	c.GetName()
}

func TestCopilotIDECodeCompletionsModel_GetTotalEngagedUsers(tt *testing.T) {
	tt.Parallel()
	c := &CopilotIDECodeCompletionsModel{}
	c.GetTotalEngagedUsers()
	c = nil
	c.GetTotalEngagedUsers()
}

func TestCopilotIDECodeCompletionsModelLanguage_GetName(tt *testing.T) {
	tt.Parallel()
	c := &CopilotIDECodeCompletionsModelLanguage{}
	c.GetName()
	c = nil
	c.GetName()
}

func TestCopilotIDECodeCompletionsModelLanguage_GetTotalCodeAcceptances(tt *testing.T) {
	tt.Parallel()
	c := &CopilotIDECodeCompletionsModelLanguage{}
	c.GetTotalCodeAcceptances()
	c = nil
	c.GetTotalCodeAcceptances()
}

func TestCopilotIDECodeCompletionsModelLanguage_GetTotalCodeLinesAccepted(tt *testing.T) {
	tt.Parallel()
	c := &CopilotIDECodeCompletionsModelLanguage{}
	c.GetTotalCodeLinesAccepted()
	c = nil
	c.GetTotalCodeLinesAccepted()
}

func TestCopilotIDECodeCompletionsModelLanguage_GetTotalCodeLinesSuggested(tt *testing.T) {
	tt.Parallel()
	c := &CopilotIDECodeCompletionsModelLanguage{}
	c.GetTotalCodeLinesSuggested()
	c = nil
	c.GetTotalCodeLinesSuggested()
}

func TestCopilotIDECodeCompletionsModelLanguage_GetTotalCodeSuggestions(tt *testing.T) {
	tt.Parallel()
	c := &CopilotIDECodeCompletionsModelLanguage{}
	c.GetTotalCodeSuggestions()
	c = nil
	c.GetTotalCodeSuggestions()
}

func TestCopilotIDECodeCompletionsModelLanguage_GetTotalEngagedUsers(tt *testing.T) {
	tt.Parallel()
	c := &CopilotIDECodeCompletionsModelLanguage{}
	c.GetTotalEngagedUsers()
	c = nil
	c.GetTotalEngagedUsers()
}

func TestCopilotMetrics_GetCopilotDotcomChat(tt *testing.T) {
	tt.Parallel()
	c := &CopilotMetrics{}
	c.GetCopilotDotcomChat()
	c = nil
	c.GetCopilotDotcomChat()
}

func TestCopilotMetrics_GetCopilotDotcomPullRequests(tt *testing.T) {
	tt.Parallel()
	c := &CopilotMetrics{}
	c.GetCopilotDotcomPullRequests()
	c = nil
	c.GetCopilotDotcomPullRequests()
}

func TestCopilotMetrics_GetCopilotIDEChat(tt *testing.T) {
	tt.Parallel()
	c := &CopilotMetrics{}
	c.GetCopilotIDEChat()
	c = nil
	c.GetCopilotIDEChat()
}

func TestCopilotMetrics_GetCopilotIDECodeCompletions(tt *testing.T) {
	tt.Parallel()
	c := &CopilotMetrics{}
	c.GetCopilotIDECodeCompletions()
	c = nil
	c.GetCopilotIDECodeCompletions()
}

func TestCopilotMetrics_GetDate(tt *testing.T) {
	tt.Parallel()
	c := &CopilotMetrics{}
	c.GetDate()
	c = nil
	c.GetDate()
}

func TestCopilotMetrics_GetTotalActiveUsers(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CopilotMetrics{TotalActiveUsers: &zeroValue}
	c.GetTotalActiveUsers()
	c = &CopilotMetrics{}
	c.GetTotalActiveUsers()
	c = nil
	c.GetTotalActiveUsers()
}

func TestCopilotMetrics_GetTotalEngagedUsers(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CopilotMetrics{TotalEngagedUsers: &zeroValue}
	c.GetTotalEngagedUsers()
	c = &CopilotMetrics{}
	c.GetTotalEngagedUsers()
	c = nil
	c.GetTotalEngagedUsers()
}

func TestCopilotMetricsChatPanel_GetChatPanelAgentMode(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CopilotMetricsChatPanel{ChatPanelAgentMode: &zeroValue}
	c.GetChatPanelAgentMode()
	c = &CopilotMetricsChatPanel{}
	c.GetChatPanelAgentMode()
	c = nil
	c.GetChatPanelAgentMode()
}

func TestCopilotMetricsChatPanel_GetChatPanelAskMode(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CopilotMetricsChatPanel{ChatPanelAskMode: &zeroValue}
	c.GetChatPanelAskMode()
	c = &CopilotMetricsChatPanel{}
	c.GetChatPanelAskMode()
	c = nil
	c.GetChatPanelAskMode()
}

func TestCopilotMetricsChatPanel_GetChatPanelCustomMode(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CopilotMetricsChatPanel{ChatPanelCustomMode: &zeroValue}
	c.GetChatPanelCustomMode()
	c = &CopilotMetricsChatPanel{}
	c.GetChatPanelCustomMode()
	c = nil
	c.GetChatPanelCustomMode()
}

func TestCopilotMetricsChatPanel_GetChatPanelEditMode(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CopilotMetricsChatPanel{ChatPanelEditMode: &zeroValue}
	c.GetChatPanelEditMode()
	c = &CopilotMetricsChatPanel{}
	c.GetChatPanelEditMode()
	c = nil
	c.GetChatPanelEditMode()
}

func TestCopilotMetricsChatPanel_GetChatPanelUnknownMode(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CopilotMetricsChatPanel{ChatPanelUnknownMode: &zeroValue}
	c.GetChatPanelUnknownMode()
	c = &CopilotMetricsChatPanel{}
	c.GetChatPanelUnknownMode()
	c = nil
	c.GetChatPanelUnknownMode()
}

func TestCopilotMetricsCLI_GetLastKnownCLIVersion(tt *testing.T) {
	tt.Parallel()
	c := &CopilotMetricsCLI{}
	c.GetLastKnownCLIVersion()
	c = nil
	c.GetLastKnownCLIVersion()
}

func TestCopilotMetricsCLI_GetPromptCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CopilotMetricsCLI{PromptCount: &zeroValue}
	c.GetPromptCount()
	c = &CopilotMetricsCLI{}
	c.GetPromptCount()
	c = nil
	c.GetPromptCount()
}

func TestCopilotMetricsCLI_GetRequestCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CopilotMetricsCLI{RequestCount: &zeroValue}
	c.GetRequestCount()
	c = &CopilotMetricsCLI{}
	c.GetRequestCount()
	c = nil
	c.GetRequestCount()
}

func TestCopilotMetricsCLI_GetSessionCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CopilotMetricsCLI{SessionCount: &zeroValue}
	c.GetSessionCount()
	c = &CopilotMetricsCLI{}
	c.GetSessionCount()
	c = nil
	c.GetSessionCount()
}

func TestCopilotMetricsCLI_GetTokenUsage(tt *testing.T) {
	tt.Parallel()
	c := &CopilotMetricsCLI{}
	c.GetTokenUsage()
	c = nil
	c.GetTokenUsage()
}

func TestCopilotMetricsCLITokenUsage_GetAvgTokensPerRequest(tt *testing.T) {
	tt.Parallel()
	var zeroValue float64
	c := &CopilotMetricsCLITokenUsage{AvgTokensPerRequest: &zeroValue}
	c.GetAvgTokensPerRequest()
	c = &CopilotMetricsCLITokenUsage{}
	c.GetAvgTokensPerRequest()
	c = nil
	c.GetAvgTokensPerRequest()
}

func TestCopilotMetricsCLITokenUsage_GetOutputTokensSum(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CopilotMetricsCLITokenUsage{OutputTokensSum: &zeroValue}
	c.GetOutputTokensSum()
	c = &CopilotMetricsCLITokenUsage{}
	c.GetOutputTokensSum()
	c = nil
	c.GetOutputTokensSum()
}

func TestCopilotMetricsCLITokenUsage_GetPromptTokensSum(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CopilotMetricsCLITokenUsage{PromptTokensSum: &zeroValue}
	c.GetPromptTokensSum()
	c = &CopilotMetricsCLITokenUsage{}
	c.GetPromptTokensSum()
	c = nil
	c.GetPromptTokensSum()
}

func TestCopilotMetricsCLIVersion_GetCLIVersion(tt *testing.T) {
	tt.Parallel()
	c := &CopilotMetricsCLIVersion{}
	c.GetCLIVersion()
	c = nil
	c.GetCLIVersion()
}

func TestCopilotMetricsCLIVersion_GetSampledAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	c := &CopilotMetricsCLIVersion{SampledAt: &zeroValue}
	c.GetSampledAt()
	c = &CopilotMetricsCLIVersion{}
	c.GetSampledAt()
	c = nil
	c.GetSampledAt()
}

func TestCopilotMetricsCodeActivity_GetCodeAcceptanceActivityCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CopilotMetricsCodeActivity{CodeAcceptanceActivityCount: &zeroValue}
	c.GetCodeAcceptanceActivityCount()
	c = &CopilotMetricsCodeActivity{}
	c.GetCodeAcceptanceActivityCount()
	c = nil
	c.GetCodeAcceptanceActivityCount()
}

func TestCopilotMetricsCodeActivity_GetCodeGenerationActivityCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CopilotMetricsCodeActivity{CodeGenerationActivityCount: &zeroValue}
	c.GetCodeGenerationActivityCount()
	c = &CopilotMetricsCodeActivity{}
	c.GetCodeGenerationActivityCount()
	c = nil
	c.GetCodeGenerationActivityCount()
}

func TestCopilotMetricsCodeActivity_GetLOCAddedSum(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CopilotMetricsCodeActivity{LOCAddedSum: &zeroValue}
	c.GetLOCAddedSum()
	c = &CopilotMetricsCodeActivity{}
	c.GetLOCAddedSum()
	c = nil
	c.GetLOCAddedSum()
}

func TestCopilotMetricsCodeActivity_GetLOCDeletedSum(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CopilotMetricsCodeActivity{LOCDeletedSum: &zeroValue}
	c.GetLOCDeletedSum()
	c = &CopilotMetricsCodeActivity{}
	c.GetLOCDeletedSum()
	c = nil
	c.GetLOCDeletedSum()
}

func TestCopilotMetricsCodeActivity_GetLOCSuggestedToAddSum(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CopilotMetricsCodeActivity{LOCSuggestedToAddSum: &zeroValue}
	c.GetLOCSuggestedToAddSum()
	c = &CopilotMetricsCodeActivity{}
	c.GetLOCSuggestedToAddSum()
	c = nil
	c.GetLOCSuggestedToAddSum()
}

func TestCopilotMetricsCodeActivity_GetLOCSuggestedToDeleteSum(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CopilotMetricsCodeActivity{LOCSuggestedToDeleteSum: &zeroValue}
	c.GetLOCSuggestedToDeleteSum()
	c = &CopilotMetricsCodeActivity{}
	c.GetLOCSuggestedToDeleteSum()
	c = nil
	c.GetLOCSuggestedToDeleteSum()
}

func TestCopilotMetricsFeature_GetFeature(tt *testing.T) {
	tt.Parallel()
	c := &CopilotMetricsFeature{}
	c.GetFeature()
	c = nil
	c.GetFeature()
}

func TestCopilotMetricsFeature_GetUserInitiatedInteractionCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CopilotMetricsFeature{UserInitiatedInteractionCount: &zeroValue}
	c.GetUserInitiatedInteractionCount()
	c = &CopilotMetricsFeature{}
	c.GetUserInitiatedInteractionCount()
	c = nil
	c.GetUserInitiatedInteractionCount()
}

func TestCopilotMetricsIDE_GetIDE(tt *testing.T) {
	tt.Parallel()
	c := &CopilotMetricsIDE{}
	c.GetIDE()
	c = nil
	c.GetIDE()
}

func TestCopilotMetricsIDE_GetUserInitiatedInteractionCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CopilotMetricsIDE{UserInitiatedInteractionCount: &zeroValue}
	c.GetUserInitiatedInteractionCount()
	c = &CopilotMetricsIDE{}
	c.GetUserInitiatedInteractionCount()
	c = nil
	c.GetUserInitiatedInteractionCount()
}

func TestCopilotMetricsLanguageFeature_GetFeature(tt *testing.T) {
	tt.Parallel()
	c := &CopilotMetricsLanguageFeature{}
	c.GetFeature()
	c = nil
	c.GetFeature()
}

func TestCopilotMetricsLanguageFeature_GetLanguage(tt *testing.T) {
	tt.Parallel()
	c := &CopilotMetricsLanguageFeature{}
	c.GetLanguage()
	c = nil
	c.GetLanguage()
}

func TestCopilotMetricsLanguageModel_GetLanguage(tt *testing.T) {
	tt.Parallel()
	c := &CopilotMetricsLanguageModel{}
	c.GetLanguage()
	c = nil
	c.GetLanguage()
}

func TestCopilotMetricsLanguageModel_GetModel(tt *testing.T) {
	tt.Parallel()
	c := &CopilotMetricsLanguageModel{}
	c.GetModel()
	c = nil
	c.GetModel()
}

func TestCopilotMetricsListOptions_GetSince(tt *testing.T) {
	tt.Parallel()
	var zeroValue time.Time
	c := &CopilotMetricsListOptions{Since: &zeroValue}
	c.GetSince()
	c = &CopilotMetricsListOptions{}
	c.GetSince()
	c = nil
	c.GetSince()
}

func TestCopilotMetricsListOptions_GetUntil(tt *testing.T) {
	tt.Parallel()
	var zeroValue time.Time
	c := &CopilotMetricsListOptions{Until: &zeroValue}
	c.GetUntil()
	c = &CopilotMetricsListOptions{}
	c.GetUntil()
	c = nil
	c.GetUntil()
}

func TestCopilotMetricsModelFeature_GetFeature(tt *testing.T) {
	tt.Parallel()
	c := &CopilotMetricsModelFeature{}
	c.GetFeature()
	c = nil
	c.GetFeature()
}

func TestCopilotMetricsModelFeature_GetModel(tt *testing.T) {
	tt.Parallel()
	c := &CopilotMetricsModelFeature{}
	c.GetModel()
	c = nil
	c.GetModel()
}

func TestCopilotMetricsModelFeature_GetUserInitiatedInteractionCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CopilotMetricsModelFeature{UserInitiatedInteractionCount: &zeroValue}
	c.GetUserInitiatedInteractionCount()
	c = &CopilotMetricsModelFeature{}
	c.GetUserInitiatedInteractionCount()
	c = nil
	c.GetUserInitiatedInteractionCount()
}

func TestCopilotMetricsPullRequests_GetMedianMinutesToMerge(tt *testing.T) {
	tt.Parallel()
	var zeroValue float64
	c := &CopilotMetricsPullRequests{MedianMinutesToMerge: &zeroValue}
	c.GetMedianMinutesToMerge()
	c = &CopilotMetricsPullRequests{}
	c.GetMedianMinutesToMerge()
	c = nil
	c.GetMedianMinutesToMerge()
}

func TestCopilotMetricsPullRequests_GetMedianMinutesToMergeCopilotAuthored(tt *testing.T) {
	tt.Parallel()
	var zeroValue float64
	c := &CopilotMetricsPullRequests{MedianMinutesToMergeCopilotAuthored: &zeroValue}
	c.GetMedianMinutesToMergeCopilotAuthored()
	c = &CopilotMetricsPullRequests{}
	c.GetMedianMinutesToMergeCopilotAuthored()
	c = nil
	c.GetMedianMinutesToMergeCopilotAuthored()
}

func TestCopilotMetricsPullRequests_GetMedianMinutesToMergeCopilotReviewed(tt *testing.T) {
	tt.Parallel()
	var zeroValue float64
	c := &CopilotMetricsPullRequests{MedianMinutesToMergeCopilotReviewed: &zeroValue}
	c.GetMedianMinutesToMergeCopilotReviewed()
	c = &CopilotMetricsPullRequests{}
	c.GetMedianMinutesToMergeCopilotReviewed()
	c = nil
	c.GetMedianMinutesToMergeCopilotReviewed()
}

func TestCopilotMetricsPullRequests_GetTotalAppliedSuggestions(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CopilotMetricsPullRequests{TotalAppliedSuggestions: &zeroValue}
	c.GetTotalAppliedSuggestions()
	c = &CopilotMetricsPullRequests{}
	c.GetTotalAppliedSuggestions()
	c = nil
	c.GetTotalAppliedSuggestions()
}

func TestCopilotMetricsPullRequests_GetTotalCopilotAppliedSuggestions(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CopilotMetricsPullRequests{TotalCopilotAppliedSuggestions: &zeroValue}
	c.GetTotalCopilotAppliedSuggestions()
	c = &CopilotMetricsPullRequests{}
	c.GetTotalCopilotAppliedSuggestions()
	c = nil
	c.GetTotalCopilotAppliedSuggestions()
}

func TestCopilotMetricsPullRequests_GetTotalCopilotSuggestions(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CopilotMetricsPullRequests{TotalCopilotSuggestions: &zeroValue}
	c.GetTotalCopilotSuggestions()
	c = &CopilotMetricsPullRequests{}
	c.GetTotalCopilotSuggestions()
	c = nil
	c.GetTotalCopilotSuggestions()
}

func TestCopilotMetricsPullRequests_GetTotalCreated(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CopilotMetricsPullRequests{TotalCreated: &zeroValue}
	c.GetTotalCreated()
	c = &CopilotMetricsPullRequests{}
	c.GetTotalCreated()
	c = nil
	c.GetTotalCreated()
}

func TestCopilotMetricsPullRequests_GetTotalCreatedByCopilot(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CopilotMetricsPullRequests{TotalCreatedByCopilot: &zeroValue}
	c.GetTotalCreatedByCopilot()
	c = &CopilotMetricsPullRequests{}
	c.GetTotalCreatedByCopilot()
	c = nil
	c.GetTotalCreatedByCopilot()
}

func TestCopilotMetricsPullRequests_GetTotalMerged(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CopilotMetricsPullRequests{TotalMerged: &zeroValue}
	c.GetTotalMerged()
	c = &CopilotMetricsPullRequests{}
	c.GetTotalMerged()
	c = nil
	c.GetTotalMerged()
}

func TestCopilotMetricsPullRequests_GetTotalMergedCreatedByCopilot(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CopilotMetricsPullRequests{TotalMergedCreatedByCopilot: &zeroValue}
	c.GetTotalMergedCreatedByCopilot()
	c = &CopilotMetricsPullRequests{}
	c.GetTotalMergedCreatedByCopilot()
	c = nil
	c.GetTotalMergedCreatedByCopilot()
}

func TestCopilotMetricsPullRequests_GetTotalMergedReviewedByCopilot(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CopilotMetricsPullRequests{TotalMergedReviewedByCopilot: &zeroValue}
	c.GetTotalMergedReviewedByCopilot()
	c = &CopilotMetricsPullRequests{}
	c.GetTotalMergedReviewedByCopilot()
	c = nil
	c.GetTotalMergedReviewedByCopilot()
}

func TestCopilotMetricsPullRequests_GetTotalReviewed(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CopilotMetricsPullRequests{TotalReviewed: &zeroValue}
	c.GetTotalReviewed()
	c = &CopilotMetricsPullRequests{}
	c.GetTotalReviewed()
	c = nil
	c.GetTotalReviewed()
}

func TestCopilotMetricsPullRequests_GetTotalReviewedByCopilot(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CopilotMetricsPullRequests{TotalReviewedByCopilot: &zeroValue}
	c.GetTotalReviewedByCopilot()
	c = &CopilotMetricsPullRequests{}
	c.GetTotalReviewedByCopilot()
	c = nil
	c.GetTotalReviewedByCopilot()
}

func TestCopilotMetricsPullRequests_GetTotalSuggestions(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CopilotMetricsPullRequests{TotalSuggestions: &zeroValue}
	c.GetTotalSuggestions()
	c = &CopilotMetricsPullRequests{}
	c.GetTotalSuggestions()
	c = nil
	c.GetTotalSuggestions()
}

func TestCopilotMetricsReport_GetDownloadLinks(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	c := &CopilotMetricsReport{DownloadLinks: zeroValue}
	c.GetDownloadLinks()
	c = &CopilotMetricsReport{}
	c.GetDownloadLinks()
	c = nil
	c.GetDownloadLinks()
}

func TestCopilotMetricsReport_GetReportEndDay(tt *testing.T) {
	tt.Parallel()
	c := &CopilotMetricsReport{}
	c.GetReportEndDay()
	c = nil
	c.GetReportEndDay()
}

func TestCopilotMetricsReport_GetReportStartDay(tt *testing.T) {
	tt.Parallel()
	c := &CopilotMetricsReport{}
	c.GetReportStartDay()
	c = nil
	c.GetReportStartDay()
}

func TestCopilotMetricsReportOptions_GetDay(tt *testing.T) {
	tt.Parallel()
	c := &CopilotMetricsReportOptions{}
	c.GetDay()
	c = nil
	c.GetDay()
}

func TestCopilotOrganizationDetails_GetCopilotChat(tt *testing.T) {
	tt.Parallel()
	c := &CopilotOrganizationDetails{}
	c.GetCopilotChat()
	c = nil
	c.GetCopilotChat()
}

func TestCopilotOrganizationDetails_GetPublicCodeSuggestions(tt *testing.T) {
	tt.Parallel()
	c := &CopilotOrganizationDetails{}
	c.GetPublicCodeSuggestions()
	c = nil
	c.GetPublicCodeSuggestions()
}

func TestCopilotOrganizationDetails_GetSeatBreakdown(tt *testing.T) {
	tt.Parallel()
	c := &CopilotOrganizationDetails{}
	c.GetSeatBreakdown()
	c = nil
	c.GetSeatBreakdown()
}

func TestCopilotOrganizationDetails_GetSeatManagementSetting(tt *testing.T) {
	tt.Parallel()
	c := &CopilotOrganizationDetails{}
	c.GetSeatManagementSetting()
	c = nil
	c.GetSeatManagementSetting()
}

func TestCopilotPeriodicMetrics_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	c := &CopilotPeriodicMetrics{CreatedAt: &zeroValue}
	c.GetCreatedAt()
	c = &CopilotPeriodicMetrics{}
	c.GetCreatedAt()
	c = nil
	c.GetCreatedAt()
}

func TestCopilotPeriodicMetrics_GetDayTotals(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*CopilotDailyMetrics{}
	c := &CopilotPeriodicMetrics{DayTotals: zeroValue}
	c.GetDayTotals()
	c = &CopilotPeriodicMetrics{}
	c.GetDayTotals()
	c = nil
	c.GetDayTotals()
}

func TestCopilotPeriodicMetrics_GetEnterpriseID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CopilotPeriodicMetrics{EnterpriseID: &zeroValue}
	c.GetEnterpriseID()
	c = &CopilotPeriodicMetrics{}
	c.GetEnterpriseID()
	c = nil
	c.GetEnterpriseID()
}

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

func TestCopilotPeriodicMetrics_GetReportEndDay(tt *testing.T) {
	tt.Parallel()
	c := &CopilotPeriodicMetrics{}
	c.GetReportEndDay()
	c = nil
	c.GetReportEndDay()
}

func TestCopilotPeriodicMetrics_GetReportStartDay(tt *testing.T) {
	tt.Parallel()
	c := &CopilotPeriodicMetrics{}
	c.GetReportStartDay()
	c = nil
	c.GetReportStartDay()
}

func TestCopilotSeatBreakdown_GetActiveThisCycle(tt *testing.T) {
	tt.Parallel()
	c := &CopilotSeatBreakdown{}
	c.GetActiveThisCycle()
	c = nil
	c.GetActiveThisCycle()
}

func TestCopilotSeatBreakdown_GetAddedThisCycle(tt *testing.T) {
	tt.Parallel()
	c := &CopilotSeatBreakdown{}
	c.GetAddedThisCycle()
	c = nil
	c.GetAddedThisCycle()
}

func TestCopilotSeatBreakdown_GetInactiveThisCycle(tt *testing.T) {
	tt.Parallel()
	c := &CopilotSeatBreakdown{}
	c.GetInactiveThisCycle()
	c = nil
	c.GetInactiveThisCycle()
}

func TestCopilotSeatBreakdown_GetPendingCancellation(tt *testing.T) {
	tt.Parallel()
	c := &CopilotSeatBreakdown{}
	c.GetPendingCancellation()
	c = nil
	c.GetPendingCancellation()
}

func TestCopilotSeatBreakdown_GetPendingInvitation(tt *testing.T) {
	tt.Parallel()
	c := &CopilotSeatBreakdown{}
	c.GetPendingInvitation()
	c = nil
	c.GetPendingInvitation()
}

func TestCopilotSeatBreakdown_GetTotal(tt *testing.T) {
	tt.Parallel()
	c := &CopilotSeatBreakdown{}
	c.GetTotal()
	c = nil
	c.GetTotal()
}

func TestCopilotSeatDetails_GetAssignee(tt *testing.T) {
	tt.Parallel()
	c := &CopilotSeatDetails{}
	c.GetAssignee()
	c = nil
	c.GetAssignee()
}

func TestCopilotSeatDetails_GetAssigningTeam(tt *testing.T) {
	tt.Parallel()
	c := &CopilotSeatDetails{}
	c.GetAssigningTeam()
	c = nil
	c.GetAssigningTeam()
}

func TestCopilotSeatDetails_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	c := &CopilotSeatDetails{CreatedAt: &zeroValue}
	c.GetCreatedAt()
	c = &CopilotSeatDetails{}
	c.GetCreatedAt()
	c = nil
	c.GetCreatedAt()
}

func TestCopilotSeatDetails_GetLastActivityAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	c := &CopilotSeatDetails{LastActivityAt: &zeroValue}
	c.GetLastActivityAt()
	c = &CopilotSeatDetails{}
	c.GetLastActivityAt()
	c = nil
	c.GetLastActivityAt()
}

func TestCopilotSeatDetails_GetLastActivityEditor(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CopilotSeatDetails{LastActivityEditor: &zeroValue}
	c.GetLastActivityEditor()
	c = &CopilotSeatDetails{}
	c.GetLastActivityEditor()
	c = nil
	c.GetLastActivityEditor()
}

func TestCopilotSeatDetails_GetPendingCancellationDate(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CopilotSeatDetails{PendingCancellationDate: &zeroValue}
	c.GetPendingCancellationDate()
	c = &CopilotSeatDetails{}
	c.GetPendingCancellationDate()
	c = nil
	c.GetPendingCancellationDate()
}

func TestCopilotSeatDetails_GetPlanType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CopilotSeatDetails{PlanType: &zeroValue}
	c.GetPlanType()
	c = &CopilotSeatDetails{}
	c.GetPlanType()
	c = nil
	c.GetPlanType()
}

func TestCopilotSeatDetails_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	c := &CopilotSeatDetails{UpdatedAt: &zeroValue}
	c.GetUpdatedAt()
	c = &CopilotSeatDetails{}
	c.GetUpdatedAt()
	c = nil
	c.GetUpdatedAt()
}

func TestCopilotUserDailyMetrics_GetCodeAcceptanceActivityCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CopilotUserDailyMetrics{CodeAcceptanceActivityCount: &zeroValue}
	c.GetCodeAcceptanceActivityCount()
	c = &CopilotUserDailyMetrics{}
	c.GetCodeAcceptanceActivityCount()
	c = nil
	c.GetCodeAcceptanceActivityCount()
}

func TestCopilotUserDailyMetrics_GetCodeGenerationActivityCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CopilotUserDailyMetrics{CodeGenerationActivityCount: &zeroValue}
	c.GetCodeGenerationActivityCount()
	c = &CopilotUserDailyMetrics{}
	c.GetCodeGenerationActivityCount()
	c = nil
	c.GetCodeGenerationActivityCount()
}

func TestCopilotUserDailyMetrics_GetDay(tt *testing.T) {
	tt.Parallel()
	c := &CopilotUserDailyMetrics{}
	c.GetDay()
	c = nil
	c.GetDay()
}

func TestCopilotUserDailyMetrics_GetEnterpriseID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CopilotUserDailyMetrics{EnterpriseID: &zeroValue}
	c.GetEnterpriseID()
	c = &CopilotUserDailyMetrics{}
	c.GetEnterpriseID()
	c = nil
	c.GetEnterpriseID()
}

func TestCopilotUserDailyMetrics_GetLOCAddedSum(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CopilotUserDailyMetrics{LOCAddedSum: &zeroValue}
	c.GetLOCAddedSum()
	c = &CopilotUserDailyMetrics{}
	c.GetLOCAddedSum()
	c = nil
	c.GetLOCAddedSum()
}

func TestCopilotUserDailyMetrics_GetLOCDeletedSum(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CopilotUserDailyMetrics{LOCDeletedSum: &zeroValue}
	c.GetLOCDeletedSum()
	c = &CopilotUserDailyMetrics{}
	c.GetLOCDeletedSum()
	c = nil
	c.GetLOCDeletedSum()
}

func TestCopilotUserDailyMetrics_GetLOCSuggestedToAddSum(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CopilotUserDailyMetrics{LOCSuggestedToAddSum: &zeroValue}
	c.GetLOCSuggestedToAddSum()
	c = &CopilotUserDailyMetrics{}
	c.GetLOCSuggestedToAddSum()
	c = nil
	c.GetLOCSuggestedToAddSum()
}

func TestCopilotUserDailyMetrics_GetLOCSuggestedToDeleteSum(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CopilotUserDailyMetrics{LOCSuggestedToDeleteSum: &zeroValue}
	c.GetLOCSuggestedToDeleteSum()
	c = &CopilotUserDailyMetrics{}
	c.GetLOCSuggestedToDeleteSum()
	c = nil
	c.GetLOCSuggestedToDeleteSum()
}

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

func TestCopilotUserDailyMetrics_GetTotalsByCLI(tt *testing.T) {
	tt.Parallel()
	c := &CopilotUserDailyMetrics{}
	c.GetTotalsByCLI()
	c = nil
	c.GetTotalsByCLI()
}

func TestCopilotUserDailyMetrics_GetTotalsByFeature(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*CopilotMetricsFeature{}
	c := &CopilotUserDailyMetrics{TotalsByFeature: zeroValue}
	c.GetTotalsByFeature()
	c = &CopilotUserDailyMetrics{}
	c.GetTotalsByFeature()
	c = nil
	c.GetTotalsByFeature()
}

func TestCopilotUserDailyMetrics_GetTotalsByIDE(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*CopilotUserMetricsIDE{}
	c := &CopilotUserDailyMetrics{TotalsByIDE: zeroValue}
	c.GetTotalsByIDE()
	c = &CopilotUserDailyMetrics{}
	c.GetTotalsByIDE()
	c = nil
	c.GetTotalsByIDE()
}

func TestCopilotUserDailyMetrics_GetTotalsByLanguageFeature(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*CopilotMetricsLanguageFeature{}
	c := &CopilotUserDailyMetrics{TotalsByLanguageFeature: zeroValue}
	c.GetTotalsByLanguageFeature()
	c = &CopilotUserDailyMetrics{}
	c.GetTotalsByLanguageFeature()
	c = nil
	c.GetTotalsByLanguageFeature()
}

func TestCopilotUserDailyMetrics_GetTotalsByLanguageModel(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*CopilotMetricsLanguageModel{}
	c := &CopilotUserDailyMetrics{TotalsByLanguageModel: zeroValue}
	c.GetTotalsByLanguageModel()
	c = &CopilotUserDailyMetrics{}
	c.GetTotalsByLanguageModel()
	c = nil
	c.GetTotalsByLanguageModel()
}

func TestCopilotUserDailyMetrics_GetTotalsByModelFeature(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*CopilotMetricsModelFeature{}
	c := &CopilotUserDailyMetrics{TotalsByModelFeature: zeroValue}
	c.GetTotalsByModelFeature()
	c = &CopilotUserDailyMetrics{}
	c.GetTotalsByModelFeature()
	c = nil
	c.GetTotalsByModelFeature()
}

func TestCopilotUserDailyMetrics_GetUsedAgent(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &CopilotUserDailyMetrics{UsedAgent: &zeroValue}
	c.GetUsedAgent()
	c = &CopilotUserDailyMetrics{}
	c.GetUsedAgent()
	c = nil
	c.GetUsedAgent()
}

func TestCopilotUserDailyMetrics_GetUsedChat(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &CopilotUserDailyMetrics{UsedChat: &zeroValue}
	c.GetUsedChat()
	c = &CopilotUserDailyMetrics{}
	c.GetUsedChat()
	c = nil
	c.GetUsedChat()
}

func TestCopilotUserDailyMetrics_GetUsedCLI(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &CopilotUserDailyMetrics{UsedCLI: &zeroValue}
	c.GetUsedCLI()
	c = &CopilotUserDailyMetrics{}
	c.GetUsedCLI()
	c = nil
	c.GetUsedCLI()
}

func TestCopilotUserDailyMetrics_GetUsedCopilotCodeReviewActive(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &CopilotUserDailyMetrics{UsedCopilotCodeReviewActive: &zeroValue}
	c.GetUsedCopilotCodeReviewActive()
	c = &CopilotUserDailyMetrics{}
	c.GetUsedCopilotCodeReviewActive()
	c = nil
	c.GetUsedCopilotCodeReviewActive()
}

func TestCopilotUserDailyMetrics_GetUsedCopilotCodeReviewPassive(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &CopilotUserDailyMetrics{UsedCopilotCodeReviewPassive: &zeroValue}
	c.GetUsedCopilotCodeReviewPassive()
	c = &CopilotUserDailyMetrics{}
	c.GetUsedCopilotCodeReviewPassive()
	c = nil
	c.GetUsedCopilotCodeReviewPassive()
}

func TestCopilotUserDailyMetrics_GetUsedCopilotCodingAgent(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &CopilotUserDailyMetrics{UsedCopilotCodingAgent: &zeroValue}
	c.GetUsedCopilotCodingAgent()
	c = &CopilotUserDailyMetrics{}
	c.GetUsedCopilotCodingAgent()
	c = nil
	c.GetUsedCopilotCodingAgent()
}

func TestCopilotUserDailyMetrics_GetUserID(tt *testing.T) {
	tt.Parallel()
	c := &CopilotUserDailyMetrics{}
	c.GetUserID()
	c = nil
	c.GetUserID()
}

func TestCopilotUserDailyMetrics_GetUserInitiatedInteractionCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CopilotUserDailyMetrics{UserInitiatedInteractionCount: &zeroValue}
	c.GetUserInitiatedInteractionCount()
	c = &CopilotUserDailyMetrics{}
	c.GetUserInitiatedInteractionCount()
	c = nil
	c.GetUserInitiatedInteractionCount()
}

func TestCopilotUserDailyMetrics_GetUserLogin(tt *testing.T) {
	tt.Parallel()
	c := &CopilotUserDailyMetrics{}
	c.GetUserLogin()
	c = nil
	c.GetUserLogin()
}

func TestCopilotUserMetricsIDE_GetIDE(tt *testing.T) {
	tt.Parallel()
	c := &CopilotUserMetricsIDE{}
	c.GetIDE()
	c = nil
	c.GetIDE()
}

func TestCopilotUserMetricsIDE_GetLastKnownIDEVersion(tt *testing.T) {
	tt.Parallel()
	c := &CopilotUserMetricsIDE{}
	c.GetLastKnownIDEVersion()
	c = nil
	c.GetLastKnownIDEVersion()
}

func TestCopilotUserMetricsIDE_GetLastKnownPluginVersion(tt *testing.T) {
	tt.Parallel()
	c := &CopilotUserMetricsIDE{}
	c.GetLastKnownPluginVersion()
	c = nil
	c.GetLastKnownPluginVersion()
}

func TestCopilotUserMetricsIDE_GetUserInitiatedInteractionCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CopilotUserMetricsIDE{UserInitiatedInteractionCount: &zeroValue}
	c.GetUserInitiatedInteractionCount()
	c = &CopilotUserMetricsIDE{}
	c.GetUserInitiatedInteractionCount()
	c = nil
	c.GetUserInitiatedInteractionCount()
}

func TestCopilotUserMetricsIDEVersion_GetIDEVersion(tt *testing.T) {
	tt.Parallel()
	c := &CopilotUserMetricsIDEVersion{}
	c.GetIDEVersion()
	c = nil
	c.GetIDEVersion()
}

func TestCopilotUserMetricsIDEVersion_GetSampledAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	c := &CopilotUserMetricsIDEVersion{SampledAt: &zeroValue}
	c.GetSampledAt()
	c = &CopilotUserMetricsIDEVersion{}
	c.GetSampledAt()
	c = nil
	c.GetSampledAt()
}

func TestCopilotUserMetricsPluginVersion_GetPlugin(tt *testing.T) {
	tt.Parallel()
	c := &CopilotUserMetricsPluginVersion{}
	c.GetPlugin()
	c = nil
	c.GetPlugin()
}

func TestCopilotUserMetricsPluginVersion_GetPluginVersion(tt *testing.T) {
	tt.Parallel()
	c := &CopilotUserMetricsPluginVersion{}
	c.GetPluginVersion()
	c = nil
	c.GetPluginVersion()
}

func TestCopilotUserMetricsPluginVersion_GetSampledAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	c := &CopilotUserMetricsPluginVersion{SampledAt: &zeroValue}
	c.GetSampledAt()
	c = &CopilotUserMetricsPluginVersion{}
	c.GetSampledAt()
	c = nil
	c.GetSampledAt()
}

func TestCopilotUserPeriodicMetrics_GetCodeAcceptanceActivityCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CopilotUserPeriodicMetrics{CodeAcceptanceActivityCount: &zeroValue}
	c.GetCodeAcceptanceActivityCount()
	c = &CopilotUserPeriodicMetrics{}
	c.GetCodeAcceptanceActivityCount()
	c = nil
	c.GetCodeAcceptanceActivityCount()
}

func TestCopilotUserPeriodicMetrics_GetCodeGenerationActivityCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CopilotUserPeriodicMetrics{CodeGenerationActivityCount: &zeroValue}
	c.GetCodeGenerationActivityCount()
	c = &CopilotUserPeriodicMetrics{}
	c.GetCodeGenerationActivityCount()
	c = nil
	c.GetCodeGenerationActivityCount()
}

func TestCopilotUserPeriodicMetrics_GetDay(tt *testing.T) {
	tt.Parallel()
	c := &CopilotUserPeriodicMetrics{}
	c.GetDay()
	c = nil
	c.GetDay()
}

func TestCopilotUserPeriodicMetrics_GetEnterpriseID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CopilotUserPeriodicMetrics{EnterpriseID: &zeroValue}
	c.GetEnterpriseID()
	c = &CopilotUserPeriodicMetrics{}
	c.GetEnterpriseID()
	c = nil
	c.GetEnterpriseID()
}

func TestCopilotUserPeriodicMetrics_GetLOCAddedSum(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CopilotUserPeriodicMetrics{LOCAddedSum: &zeroValue}
	c.GetLOCAddedSum()
	c = &CopilotUserPeriodicMetrics{}
	c.GetLOCAddedSum()
	c = nil
	c.GetLOCAddedSum()
}

func TestCopilotUserPeriodicMetrics_GetLOCDeletedSum(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CopilotUserPeriodicMetrics{LOCDeletedSum: &zeroValue}
	c.GetLOCDeletedSum()
	c = &CopilotUserPeriodicMetrics{}
	c.GetLOCDeletedSum()
	c = nil
	c.GetLOCDeletedSum()
}

func TestCopilotUserPeriodicMetrics_GetLOCSuggestedToAddSum(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CopilotUserPeriodicMetrics{LOCSuggestedToAddSum: &zeroValue}
	c.GetLOCSuggestedToAddSum()
	c = &CopilotUserPeriodicMetrics{}
	c.GetLOCSuggestedToAddSum()
	c = nil
	c.GetLOCSuggestedToAddSum()
}

func TestCopilotUserPeriodicMetrics_GetLOCSuggestedToDeleteSum(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CopilotUserPeriodicMetrics{LOCSuggestedToDeleteSum: &zeroValue}
	c.GetLOCSuggestedToDeleteSum()
	c = &CopilotUserPeriodicMetrics{}
	c.GetLOCSuggestedToDeleteSum()
	c = nil
	c.GetLOCSuggestedToDeleteSum()
}

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

func TestCopilotUserPeriodicMetrics_GetReportEndDay(tt *testing.T) {
	tt.Parallel()
	c := &CopilotUserPeriodicMetrics{}
	c.GetReportEndDay()
	c = nil
	c.GetReportEndDay()
}

func TestCopilotUserPeriodicMetrics_GetReportStartDay(tt *testing.T) {
	tt.Parallel()
	c := &CopilotUserPeriodicMetrics{}
	c.GetReportStartDay()
	c = nil
	c.GetReportStartDay()
}

func TestCopilotUserPeriodicMetrics_GetTotalsByCLI(tt *testing.T) {
	tt.Parallel()
	c := &CopilotUserPeriodicMetrics{}
	c.GetTotalsByCLI()
	c = nil
	c.GetTotalsByCLI()
}

func TestCopilotUserPeriodicMetrics_GetTotalsByFeature(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*CopilotMetricsFeature{}
	c := &CopilotUserPeriodicMetrics{TotalsByFeature: zeroValue}
	c.GetTotalsByFeature()
	c = &CopilotUserPeriodicMetrics{}
	c.GetTotalsByFeature()
	c = nil
	c.GetTotalsByFeature()
}

func TestCopilotUserPeriodicMetrics_GetTotalsByIDE(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*CopilotUserMetricsIDE{}
	c := &CopilotUserPeriodicMetrics{TotalsByIDE: zeroValue}
	c.GetTotalsByIDE()
	c = &CopilotUserPeriodicMetrics{}
	c.GetTotalsByIDE()
	c = nil
	c.GetTotalsByIDE()
}

func TestCopilotUserPeriodicMetrics_GetTotalsByLanguageFeature(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*CopilotMetricsLanguageFeature{}
	c := &CopilotUserPeriodicMetrics{TotalsByLanguageFeature: zeroValue}
	c.GetTotalsByLanguageFeature()
	c = &CopilotUserPeriodicMetrics{}
	c.GetTotalsByLanguageFeature()
	c = nil
	c.GetTotalsByLanguageFeature()
}

func TestCopilotUserPeriodicMetrics_GetTotalsByLanguageModel(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*CopilotMetricsLanguageModel{}
	c := &CopilotUserPeriodicMetrics{TotalsByLanguageModel: zeroValue}
	c.GetTotalsByLanguageModel()
	c = &CopilotUserPeriodicMetrics{}
	c.GetTotalsByLanguageModel()
	c = nil
	c.GetTotalsByLanguageModel()
}

func TestCopilotUserPeriodicMetrics_GetTotalsByModelFeature(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*CopilotMetricsModelFeature{}
	c := &CopilotUserPeriodicMetrics{TotalsByModelFeature: zeroValue}
	c.GetTotalsByModelFeature()
	c = &CopilotUserPeriodicMetrics{}
	c.GetTotalsByModelFeature()
	c = nil
	c.GetTotalsByModelFeature()
}

func TestCopilotUserPeriodicMetrics_GetUsedAgent(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &CopilotUserPeriodicMetrics{UsedAgent: &zeroValue}
	c.GetUsedAgent()
	c = &CopilotUserPeriodicMetrics{}
	c.GetUsedAgent()
	c = nil
	c.GetUsedAgent()
}

func TestCopilotUserPeriodicMetrics_GetUsedChat(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &CopilotUserPeriodicMetrics{UsedChat: &zeroValue}
	c.GetUsedChat()
	c = &CopilotUserPeriodicMetrics{}
	c.GetUsedChat()
	c = nil
	c.GetUsedChat()
}

func TestCopilotUserPeriodicMetrics_GetUsedCLI(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &CopilotUserPeriodicMetrics{UsedCLI: &zeroValue}
	c.GetUsedCLI()
	c = &CopilotUserPeriodicMetrics{}
	c.GetUsedCLI()
	c = nil
	c.GetUsedCLI()
}

func TestCopilotUserPeriodicMetrics_GetUsedCopilotCodeReviewActive(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &CopilotUserPeriodicMetrics{UsedCopilotCodeReviewActive: &zeroValue}
	c.GetUsedCopilotCodeReviewActive()
	c = &CopilotUserPeriodicMetrics{}
	c.GetUsedCopilotCodeReviewActive()
	c = nil
	c.GetUsedCopilotCodeReviewActive()
}

func TestCopilotUserPeriodicMetrics_GetUsedCopilotCodeReviewPassive(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &CopilotUserPeriodicMetrics{UsedCopilotCodeReviewPassive: &zeroValue}
	c.GetUsedCopilotCodeReviewPassive()
	c = &CopilotUserPeriodicMetrics{}
	c.GetUsedCopilotCodeReviewPassive()
	c = nil
	c.GetUsedCopilotCodeReviewPassive()
}

func TestCopilotUserPeriodicMetrics_GetUsedCopilotCodingAgent(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &CopilotUserPeriodicMetrics{UsedCopilotCodingAgent: &zeroValue}
	c.GetUsedCopilotCodingAgent()
	c = &CopilotUserPeriodicMetrics{}
	c.GetUsedCopilotCodingAgent()
	c = nil
	c.GetUsedCopilotCodingAgent()
}

func TestCopilotUserPeriodicMetrics_GetUserID(tt *testing.T) {
	tt.Parallel()
	c := &CopilotUserPeriodicMetrics{}
	c.GetUserID()
	c = nil
	c.GetUserID()
}

func TestCopilotUserPeriodicMetrics_GetUserInitiatedInteractionCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CopilotUserPeriodicMetrics{UserInitiatedInteractionCount: &zeroValue}
	c.GetUserInitiatedInteractionCount()
	c = &CopilotUserPeriodicMetrics{}
	c.GetUserInitiatedInteractionCount()
	c = nil
	c.GetUserInitiatedInteractionCount()
}

func TestCopilotUserPeriodicMetrics_GetUserLogin(tt *testing.T) {
	tt.Parallel()
	c := &CopilotUserPeriodicMetrics{}
	c.GetUserLogin()
	c = nil
	c.GetUserLogin()
}

func TestCostCenter_GetAzureSubscription(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CostCenter{AzureSubscription: &zeroValue}
	c.GetAzureSubscription()
	c = &CostCenter{}
	c.GetAzureSubscription()
	c = nil
	c.GetAzureSubscription()
}

func TestCostCenter_GetID(tt *testing.T) {
	tt.Parallel()
	c := &CostCenter{}
	c.GetID()
	c = nil
	c.GetID()
}

func TestCostCenter_GetName(tt *testing.T) {
	tt.Parallel()
	c := &CostCenter{}
	c.GetName()
	c = nil
	c.GetName()
}

func TestCostCenter_GetResources(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*CostCenterResource{}
	c := &CostCenter{Resources: zeroValue}
	c.GetResources()
	c = &CostCenter{}
	c.GetResources()
	c = nil
	c.GetResources()
}

func TestCostCenter_GetState(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CostCenter{State: &zeroValue}
	c.GetState()
	c = &CostCenter{}
	c.GetState()
	c = nil
	c.GetState()
}

func TestCostCenterRequest_GetName(tt *testing.T) {
	tt.Parallel()
	c := &CostCenterRequest{}
	c.GetName()
	c = nil
	c.GetName()
}

func TestCostCenterResource_GetName(tt *testing.T) {
	tt.Parallel()
	c := &CostCenterResource{}
	c.GetName()
	c = nil
	c.GetName()
}

func TestCostCenterResource_GetType(tt *testing.T) {
	tt.Parallel()
	c := &CostCenterResource{}
	c.GetType()
	c = nil
	c.GetType()
}

func TestCostCenterResourceRequest_GetOrganizations(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	c := &CostCenterResourceRequest{Organizations: zeroValue}
	c.GetOrganizations()
	c = &CostCenterResourceRequest{}
	c.GetOrganizations()
	c = nil
	c.GetOrganizations()
}

func TestCostCenterResourceRequest_GetRepositories(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	c := &CostCenterResourceRequest{Repositories: zeroValue}
	c.GetRepositories()
	c = &CostCenterResourceRequest{}
	c.GetRepositories()
	c = nil
	c.GetRepositories()
}

func TestCostCenterResourceRequest_GetUsers(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	c := &CostCenterResourceRequest{Users: zeroValue}
	c.GetUsers()
	c = &CostCenterResourceRequest{}
	c.GetUsers()
	c = nil
	c.GetUsers()
}

func TestCostCenters_GetCostCenters(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*CostCenter{}
	c := &CostCenters{CostCenters: zeroValue}
	c.GetCostCenters()
	c = &CostCenters{}
	c.GetCostCenters()
	c = nil
	c.GetCostCenters()
}

func TestCreateArtifactDeploymentRequest_GetCluster(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CreateArtifactDeploymentRequest{Cluster: &zeroValue}
	c.GetCluster()
	c = &CreateArtifactDeploymentRequest{}
	c.GetCluster()
	c = nil
	c.GetCluster()
}

func TestCreateArtifactDeploymentRequest_GetDeploymentName(tt *testing.T) {
	tt.Parallel()
	c := &CreateArtifactDeploymentRequest{}
	c.GetDeploymentName()
	c = nil
	c.GetDeploymentName()
}

func TestCreateArtifactDeploymentRequest_GetDigest(tt *testing.T) {
	tt.Parallel()
	c := &CreateArtifactDeploymentRequest{}
	c.GetDigest()
	c = nil
	c.GetDigest()
}

func TestCreateArtifactDeploymentRequest_GetGithubRepository(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CreateArtifactDeploymentRequest{GithubRepository: &zeroValue}
	c.GetGithubRepository()
	c = &CreateArtifactDeploymentRequest{}
	c.GetGithubRepository()
	c = nil
	c.GetGithubRepository()
}

func TestCreateArtifactDeploymentRequest_GetLogicalEnvironment(tt *testing.T) {
	tt.Parallel()
	c := &CreateArtifactDeploymentRequest{}
	c.GetLogicalEnvironment()
	c = nil
	c.GetLogicalEnvironment()
}

func TestCreateArtifactDeploymentRequest_GetName(tt *testing.T) {
	tt.Parallel()
	c := &CreateArtifactDeploymentRequest{}
	c.GetName()
	c = nil
	c.GetName()
}

func TestCreateArtifactDeploymentRequest_GetPhysicalEnvironment(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CreateArtifactDeploymentRequest{PhysicalEnvironment: &zeroValue}
	c.GetPhysicalEnvironment()
	c = &CreateArtifactDeploymentRequest{}
	c.GetPhysicalEnvironment()
	c = nil
	c.GetPhysicalEnvironment()
}

func TestCreateArtifactDeploymentRequest_GetRuntimeRisks(tt *testing.T) {
	tt.Parallel()
	zeroValue := []DeploymentRuntimeRisk{}
	c := &CreateArtifactDeploymentRequest{RuntimeRisks: zeroValue}
	c.GetRuntimeRisks()
	c = &CreateArtifactDeploymentRequest{}
	c.GetRuntimeRisks()
	c = nil
	c.GetRuntimeRisks()
}

func TestCreateArtifactDeploymentRequest_GetStatus(tt *testing.T) {
	tt.Parallel()
	c := &CreateArtifactDeploymentRequest{}
	c.GetStatus()
	c = nil
	c.GetStatus()
}

func TestCreateArtifactDeploymentRequest_GetTags(tt *testing.T) {
	tt.Parallel()
	zeroValue := map[string]string{}
	c := &CreateArtifactDeploymentRequest{Tags: zeroValue}
	c.GetTags()
	c = &CreateArtifactDeploymentRequest{}
	c.GetTags()
	c = nil
	c.GetTags()
}

func TestCreateArtifactDeploymentRequest_GetVersion(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CreateArtifactDeploymentRequest{Version: &zeroValue}
	c.GetVersion()
	c = &CreateArtifactDeploymentRequest{}
	c.GetVersion()
	c = nil
	c.GetVersion()
}

func TestCreateArtifactStorageRequest_GetArtifactURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CreateArtifactStorageRequest{ArtifactURL: &zeroValue}
	c.GetArtifactURL()
	c = &CreateArtifactStorageRequest{}
	c.GetArtifactURL()
	c = nil
	c.GetArtifactURL()
}

func TestCreateArtifactStorageRequest_GetDigest(tt *testing.T) {
	tt.Parallel()
	c := &CreateArtifactStorageRequest{}
	c.GetDigest()
	c = nil
	c.GetDigest()
}

func TestCreateArtifactStorageRequest_GetGithubRepository(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CreateArtifactStorageRequest{GithubRepository: &zeroValue}
	c.GetGithubRepository()
	c = &CreateArtifactStorageRequest{}
	c.GetGithubRepository()
	c = nil
	c.GetGithubRepository()
}

func TestCreateArtifactStorageRequest_GetName(tt *testing.T) {
	tt.Parallel()
	c := &CreateArtifactStorageRequest{}
	c.GetName()
	c = nil
	c.GetName()
}

func TestCreateArtifactStorageRequest_GetPath(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CreateArtifactStorageRequest{Path: &zeroValue}
	c.GetPath()
	c = &CreateArtifactStorageRequest{}
	c.GetPath()
	c = nil
	c.GetPath()
}

func TestCreateArtifactStorageRequest_GetRegistryURL(tt *testing.T) {
	tt.Parallel()
	c := &CreateArtifactStorageRequest{}
	c.GetRegistryURL()
	c = nil
	c.GetRegistryURL()
}

func TestCreateArtifactStorageRequest_GetRepository(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CreateArtifactStorageRequest{Repository: &zeroValue}
	c.GetRepository()
	c = &CreateArtifactStorageRequest{}
	c.GetRepository()
	c = nil
	c.GetRepository()
}

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

func TestCreateArtifactStorageRequest_GetVersion(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CreateArtifactStorageRequest{Version: &zeroValue}
	c.GetVersion()
	c = &CreateArtifactStorageRequest{}
	c.GetVersion()
	c = nil
	c.GetVersion()
}

func TestCreateAutolinkRequest_GetIsAlphanumeric(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &CreateAutolinkRequest{IsAlphanumeric: &zeroValue}
	c.GetIsAlphanumeric()
	c = &CreateAutolinkRequest{}
	c.GetIsAlphanumeric()
	c = nil
	c.GetIsAlphanumeric()
}

func TestCreateAutolinkRequest_GetKeyPrefix(tt *testing.T) {
	tt.Parallel()
	c := &CreateAutolinkRequest{}
	c.GetKeyPrefix()
	c = nil
	c.GetKeyPrefix()
}

func TestCreateAutolinkRequest_GetURLTemplate(tt *testing.T) {
	tt.Parallel()
	c := &CreateAutolinkRequest{}
	c.GetURLTemplate()
	c = nil
	c.GetURLTemplate()
}

func TestCreateCheckRunOptions_GetActions(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*CheckRunAction{}
	c := &CreateCheckRunOptions{Actions: zeroValue}
	c.GetActions()
	c = &CreateCheckRunOptions{}
	c.GetActions()
	c = nil
	c.GetActions()
}

func TestCreateCheckRunOptions_GetCompletedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	c := &CreateCheckRunOptions{CompletedAt: &zeroValue}
	c.GetCompletedAt()
	c = &CreateCheckRunOptions{}
	c.GetCompletedAt()
	c = nil
	c.GetCompletedAt()
}

func TestCreateCheckRunOptions_GetConclusion(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CreateCheckRunOptions{Conclusion: &zeroValue}
	c.GetConclusion()
	c = &CreateCheckRunOptions{}
	c.GetConclusion()
	c = nil
	c.GetConclusion()
}

func TestCreateCheckRunOptions_GetDetailsURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CreateCheckRunOptions{DetailsURL: &zeroValue}
	c.GetDetailsURL()
	c = &CreateCheckRunOptions{}
	c.GetDetailsURL()
	c = nil
	c.GetDetailsURL()
}

func TestCreateCheckRunOptions_GetExternalID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CreateCheckRunOptions{ExternalID: &zeroValue}
	c.GetExternalID()
	c = &CreateCheckRunOptions{}
	c.GetExternalID()
	c = nil
	c.GetExternalID()
}

func TestCreateCheckRunOptions_GetHeadSHA(tt *testing.T) {
	tt.Parallel()
	c := &CreateCheckRunOptions{}
	c.GetHeadSHA()
	c = nil
	c.GetHeadSHA()
}

func TestCreateCheckRunOptions_GetName(tt *testing.T) {
	tt.Parallel()
	c := &CreateCheckRunOptions{}
	c.GetName()
	c = nil
	c.GetName()
}

func TestCreateCheckRunOptions_GetOutput(tt *testing.T) {
	tt.Parallel()
	c := &CreateCheckRunOptions{}
	c.GetOutput()
	c = nil
	c.GetOutput()
}

func TestCreateCheckRunOptions_GetStartedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	c := &CreateCheckRunOptions{StartedAt: &zeroValue}
	c.GetStartedAt()
	c = &CreateCheckRunOptions{}
	c.GetStartedAt()
	c = nil
	c.GetStartedAt()
}

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

func TestCreateCheckSuiteOptions_GetHeadBranch(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CreateCheckSuiteOptions{HeadBranch: &zeroValue}
	c.GetHeadBranch()
	c = &CreateCheckSuiteOptions{}
	c.GetHeadBranch()
	c = nil
	c.GetHeadBranch()
}

func TestCreateCheckSuiteOptions_GetHeadSHA(tt *testing.T) {
	tt.Parallel()
	c := &CreateCheckSuiteOptions{}
	c.GetHeadSHA()
	c = nil
	c.GetHeadSHA()
}

func TestCreateCodespaceOptions_GetClientIP(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CreateCodespaceOptions{ClientIP: &zeroValue}
	c.GetClientIP()
	c = &CreateCodespaceOptions{}
	c.GetClientIP()
	c = nil
	c.GetClientIP()
}

func TestCreateCodespaceOptions_GetDevcontainerPath(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CreateCodespaceOptions{DevcontainerPath: &zeroValue}
	c.GetDevcontainerPath()
	c = &CreateCodespaceOptions{}
	c.GetDevcontainerPath()
	c = nil
	c.GetDevcontainerPath()
}

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

func TestCreateCodespaceOptions_GetGeo(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CreateCodespaceOptions{Geo: &zeroValue}
	c.GetGeo()
	c = &CreateCodespaceOptions{}
	c.GetGeo()
	c = nil
	c.GetGeo()
}

func TestCreateCodespaceOptions_GetIdleTimeoutMinutes(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CreateCodespaceOptions{IdleTimeoutMinutes: &zeroValue}
	c.GetIdleTimeoutMinutes()
	c = &CreateCodespaceOptions{}
	c.GetIdleTimeoutMinutes()
	c = nil
	c.GetIdleTimeoutMinutes()
}

func TestCreateCodespaceOptions_GetLocation(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CreateCodespaceOptions{Location: &zeroValue}
	c.GetLocation()
	c = &CreateCodespaceOptions{}
	c.GetLocation()
	c = nil
	c.GetLocation()
}

func TestCreateCodespaceOptions_GetMachine(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CreateCodespaceOptions{Machine: &zeroValue}
	c.GetMachine()
	c = &CreateCodespaceOptions{}
	c.GetMachine()
	c = nil
	c.GetMachine()
}

func TestCreateCodespaceOptions_GetMultiRepoPermissionsOptOut(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &CreateCodespaceOptions{MultiRepoPermissionsOptOut: &zeroValue}
	c.GetMultiRepoPermissionsOptOut()
	c = &CreateCodespaceOptions{}
	c.GetMultiRepoPermissionsOptOut()
	c = nil
	c.GetMultiRepoPermissionsOptOut()
}

func TestCreateCodespaceOptions_GetRef(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CreateCodespaceOptions{Ref: &zeroValue}
	c.GetRef()
	c = &CreateCodespaceOptions{}
	c.GetRef()
	c = nil
	c.GetRef()
}

func TestCreateCodespaceOptions_GetRetentionPeriodMinutes(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CreateCodespaceOptions{RetentionPeriodMinutes: &zeroValue}
	c.GetRetentionPeriodMinutes()
	c = &CreateCodespaceOptions{}
	c.GetRetentionPeriodMinutes()
	c = nil
	c.GetRetentionPeriodMinutes()
}

func TestCreateCodespaceOptions_GetWorkingDirectory(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CreateCodespaceOptions{WorkingDirectory: &zeroValue}
	c.GetWorkingDirectory()
	c = &CreateCodespaceOptions{}
	c.GetWorkingDirectory()
	c = nil
	c.GetWorkingDirectory()
}

func TestCreateCommitOptions_GetSigner(tt *testing.T) {
	tt.Parallel()
	c := &CreateCommitOptions{}
	c.GetSigner()
	c = nil
	c.GetSigner()
}

func TestCreateCustomOrgRoleRequest_GetBaseRole(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CreateCustomOrgRoleRequest{BaseRole: &zeroValue}
	c.GetBaseRole()
	c = &CreateCustomOrgRoleRequest{}
	c.GetBaseRole()
	c = nil
	c.GetBaseRole()
}

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

func TestCreateCustomOrgRoleRequest_GetName(tt *testing.T) {
	tt.Parallel()
	c := &CreateCustomOrgRoleRequest{}
	c.GetName()
	c = nil
	c.GetName()
}

func TestCreateCustomOrgRoleRequest_GetPermissions(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	c := &CreateCustomOrgRoleRequest{Permissions: zeroValue}
	c.GetPermissions()
	c = &CreateCustomOrgRoleRequest{}
	c.GetPermissions()
	c = nil
	c.GetPermissions()
}

func TestCreateCustomRepoRoleRequest_GetBaseRole(tt *testing.T) {
	tt.Parallel()
	c := &CreateCustomRepoRoleRequest{}
	c.GetBaseRole()
	c = nil
	c.GetBaseRole()
}

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

func TestCreateCustomRepoRoleRequest_GetName(tt *testing.T) {
	tt.Parallel()
	c := &CreateCustomRepoRoleRequest{}
	c.GetName()
	c = nil
	c.GetName()
}

func TestCreateCustomRepoRoleRequest_GetPermissions(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	c := &CreateCustomRepoRoleRequest{Permissions: zeroValue}
	c.GetPermissions()
	c = &CreateCustomRepoRoleRequest{}
	c.GetPermissions()
	c = nil
	c.GetPermissions()
}

func TestCreateDeploymentBranchPolicyRequest_GetName(tt *testing.T) {
	tt.Parallel()
	c := &CreateDeploymentBranchPolicyRequest{}
	c.GetName()
	c = nil
	c.GetName()
}

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

func TestCreateEnterpriseRunnerGroupRequest_GetAllowsPublicRepositories(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &CreateEnterpriseRunnerGroupRequest{AllowsPublicRepositories: &zeroValue}
	c.GetAllowsPublicRepositories()
	c = &CreateEnterpriseRunnerGroupRequest{}
	c.GetAllowsPublicRepositories()
	c = nil
	c.GetAllowsPublicRepositories()
}

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

func TestCreateEnterpriseRunnerGroupRequest_GetNetworkConfigurationID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CreateEnterpriseRunnerGroupRequest{NetworkConfigurationID: &zeroValue}
	c.GetNetworkConfigurationID()
	c = &CreateEnterpriseRunnerGroupRequest{}
	c.GetNetworkConfigurationID()
	c = nil
	c.GetNetworkConfigurationID()
}

func TestCreateEnterpriseRunnerGroupRequest_GetRestrictedToWorkflows(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &CreateEnterpriseRunnerGroupRequest{RestrictedToWorkflows: &zeroValue}
	c.GetRestrictedToWorkflows()
	c = &CreateEnterpriseRunnerGroupRequest{}
	c.GetRestrictedToWorkflows()
	c = nil
	c.GetRestrictedToWorkflows()
}

func TestCreateEnterpriseRunnerGroupRequest_GetRunners(tt *testing.T) {
	tt.Parallel()
	zeroValue := []int64{}
	c := &CreateEnterpriseRunnerGroupRequest{Runners: zeroValue}
	c.GetRunners()
	c = &CreateEnterpriseRunnerGroupRequest{}
	c.GetRunners()
	c = nil
	c.GetRunners()
}

func TestCreateEnterpriseRunnerGroupRequest_GetSelectedOrganizationIDs(tt *testing.T) {
	tt.Parallel()
	zeroValue := []int64{}
	c := &CreateEnterpriseRunnerGroupRequest{SelectedOrganizationIDs: zeroValue}
	c.GetSelectedOrganizationIDs()
	c = &CreateEnterpriseRunnerGroupRequest{}
	c.GetSelectedOrganizationIDs()
	c = nil
	c.GetSelectedOrganizationIDs()
}

func TestCreateEnterpriseRunnerGroupRequest_GetSelectedWorkflows(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	c := &CreateEnterpriseRunnerGroupRequest{SelectedWorkflows: zeroValue}
	c.GetSelectedWorkflows()
	c = &CreateEnterpriseRunnerGroupRequest{}
	c.GetSelectedWorkflows()
	c = nil
	c.GetSelectedWorkflows()
}

func TestCreateEnterpriseRunnerGroupRequest_GetVisibility(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CreateEnterpriseRunnerGroupRequest{Visibility: &zeroValue}
	c.GetVisibility()
	c = &CreateEnterpriseRunnerGroupRequest{}
	c.GetVisibility()
	c = nil
	c.GetVisibility()
}

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

func TestCreateEvent_GetInstallation(tt *testing.T) {
	tt.Parallel()
	c := &CreateEvent{}
	c.GetInstallation()
	c = nil
	c.GetInstallation()
}

func TestCreateEvent_GetMasterBranch(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CreateEvent{MasterBranch: &zeroValue}
	c.GetMasterBranch()
	c = &CreateEvent{}
	c.GetMasterBranch()
	c = nil
	c.GetMasterBranch()
}

func TestCreateEvent_GetOrg(tt *testing.T) {
	tt.Parallel()
	c := &CreateEvent{}
	c.GetOrg()
	c = nil
	c.GetOrg()
}

func TestCreateEvent_GetPusherType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CreateEvent{PusherType: &zeroValue}
	c.GetPusherType()
	c = &CreateEvent{}
	c.GetPusherType()
	c = nil
	c.GetPusherType()
}

func TestCreateEvent_GetRef(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CreateEvent{Ref: &zeroValue}
	c.GetRef()
	c = &CreateEvent{}
	c.GetRef()
	c = nil
	c.GetRef()
}

func TestCreateEvent_GetRefType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CreateEvent{RefType: &zeroValue}
	c.GetRefType()
	c = &CreateEvent{}
	c.GetRefType()
	c = nil
	c.GetRefType()
}

func TestCreateEvent_GetRepo(tt *testing.T) {
	tt.Parallel()
	c := &CreateEvent{}
	c.GetRepo()
	c = nil
	c.GetRepo()
}

func TestCreateEvent_GetSender(tt *testing.T) {
	tt.Parallel()
	c := &CreateEvent{}
	c.GetSender()
	c = nil
	c.GetSender()
}

func TestCreateGistCommentRequest_GetBody(tt *testing.T) {
	tt.Parallel()
	c := &CreateGistCommentRequest{}
	c.GetBody()
	c = nil
	c.GetBody()
}

func TestCreateGistFile_GetContent(tt *testing.T) {
	tt.Parallel()
	c := &CreateGistFile{}
	c.GetContent()
	c = nil
	c.GetContent()
}

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

func TestCreateGistRequest_GetPublic(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &CreateGistRequest{Public: &zeroValue}
	c.GetPublic()
	c = &CreateGistRequest{}
	c.GetPublic()
	c = nil
	c.GetPublic()
}

func TestCreateHostedRunnerRequest_GetEnableStaticIP(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &CreateHostedRunnerRequest{EnableStaticIP: &zeroValue}
	c.GetEnableStaticIP()
	c = &CreateHostedRunnerRequest{}
	c.GetEnableStaticIP()
	c = nil
	c.GetEnableStaticIP()
}

func TestCreateHostedRunnerRequest_GetImage(tt *testing.T) {
	tt.Parallel()
	c := &CreateHostedRunnerRequest{}
	c.GetImage()
	c = nil
	c.GetImage()
}

func TestCreateHostedRunnerRequest_GetImageGen(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &CreateHostedRunnerRequest{ImageGen: &zeroValue}
	c.GetImageGen()
	c = &CreateHostedRunnerRequest{}
	c.GetImageGen()
	c = nil
	c.GetImageGen()
}

func TestCreateHostedRunnerRequest_GetMaximumRunners(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	c := &CreateHostedRunnerRequest{MaximumRunners: &zeroValue}
	c.GetMaximumRunners()
	c = &CreateHostedRunnerRequest{}
	c.GetMaximumRunners()
	c = nil
	c.GetMaximumRunners()
}

func TestCreateHostedRunnerRequest_GetName(tt *testing.T) {
	tt.Parallel()
	c := &CreateHostedRunnerRequest{}
	c.GetName()
	c = nil
	c.GetName()
}

func TestCreateHostedRunnerRequest_GetRunnerGroupID(tt *testing.T) {
	tt.Parallel()
	c := &CreateHostedRunnerRequest{}
	c.GetRunnerGroupID()
	c = nil
	c.GetRunnerGroupID()
}

func TestCreateHostedRunnerRequest_GetSize(tt *testing.T) {
	tt.Parallel()
	c := &CreateHostedRunnerRequest{}
	c.GetSize()
	c = nil
	c.GetSize()
}

func TestCreateIssueLabelRequest_GetColor(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CreateIssueLabelRequest{Color: &zeroValue}
	c.GetColor()
	c = &CreateIssueLabelRequest{}
	c.GetColor()
	c = nil
	c.GetColor()
}

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

func TestCreateIssueLabelRequest_GetName(tt *testing.T) {
	tt.Parallel()
	c := &CreateIssueLabelRequest{}
	c.GetName()
	c = nil
	c.GetName()
}

func TestCreateIssueRequest_GetAssignee(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CreateIssueRequest{Assignee: &zeroValue}
	c.GetAssignee()
	c = &CreateIssueRequest{}
	c.GetAssignee()
	c = nil
	c.GetAssignee()
}

func TestCreateIssueRequest_GetAssignees(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	c := &CreateIssueRequest{Assignees: zeroValue}
	c.GetAssignees()
	c = &CreateIssueRequest{}
	c.GetAssignees()
	c = nil
	c.GetAssignees()
}

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

func TestCreateIssueRequest_GetIssueFieldValues(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*IssueRequestFieldValue{}
	c := &CreateIssueRequest{IssueFieldValues: zeroValue}
	c.GetIssueFieldValues()
	c = &CreateIssueRequest{}
	c.GetIssueFieldValues()
	c = nil
	c.GetIssueFieldValues()
}

func TestCreateIssueRequest_GetLabels(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	c := &CreateIssueRequest{Labels: zeroValue}
	c.GetLabels()
	c = &CreateIssueRequest{}
	c.GetLabels()
	c = nil
	c.GetLabels()
}

func TestCreateIssueRequest_GetMilestone(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CreateIssueRequest{Milestone: &zeroValue}
	c.GetMilestone()
	c = &CreateIssueRequest{}
	c.GetMilestone()
	c = nil
	c.GetMilestone()
}

func TestCreateIssueRequest_GetTitle(tt *testing.T) {
	tt.Parallel()
	c := &CreateIssueRequest{}
	c.GetTitle()
	c = nil
	c.GetTitle()
}

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

func TestCreateJITConfigRequest_GetLabels(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	c := &CreateJITConfigRequest{Labels: zeroValue}
	c.GetLabels()
	c = &CreateJITConfigRequest{}
	c.GetLabels()
	c = nil
	c.GetLabels()
}

func TestCreateJITConfigRequest_GetName(tt *testing.T) {
	tt.Parallel()
	c := &CreateJITConfigRequest{}
	c.GetName()
	c = nil
	c.GetName()
}

func TestCreateJITConfigRequest_GetRunnerGroupID(tt *testing.T) {
	tt.Parallel()
	c := &CreateJITConfigRequest{}
	c.GetRunnerGroupID()
	c = nil
	c.GetRunnerGroupID()
}

func TestCreateJITConfigRequest_GetWorkFolder(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CreateJITConfigRequest{WorkFolder: &zeroValue}
	c.GetWorkFolder()
	c = &CreateJITConfigRequest{}
	c.GetWorkFolder()
	c = nil
	c.GetWorkFolder()
}

func TestCreateOrganizationPrivateRegistry_GetAccountID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CreateOrganizationPrivateRegistry{AccountID: &zeroValue}
	c.GetAccountID()
	c = &CreateOrganizationPrivateRegistry{}
	c.GetAccountID()
	c = nil
	c.GetAccountID()
}

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

func TestCreateOrganizationPrivateRegistry_GetAuthType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CreateOrganizationPrivateRegistry{AuthType: &zeroValue}
	c.GetAuthType()
	c = &CreateOrganizationPrivateRegistry{}
	c.GetAuthType()
	c = nil
	c.GetAuthType()
}

func TestCreateOrganizationPrivateRegistry_GetAWSRegion(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CreateOrganizationPrivateRegistry{AWSRegion: &zeroValue}
	c.GetAWSRegion()
	c = &CreateOrganizationPrivateRegistry{}
	c.GetAWSRegion()
	c = nil
	c.GetAWSRegion()
}

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

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

func TestCreateOrganizationPrivateRegistry_GetDomainOwner(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CreateOrganizationPrivateRegistry{DomainOwner: &zeroValue}
	c.GetDomainOwner()
	c = &CreateOrganizationPrivateRegistry{}
	c.GetDomainOwner()
	c = nil
	c.GetDomainOwner()
}

func TestCreateOrganizationPrivateRegistry_GetEncryptedValue(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CreateOrganizationPrivateRegistry{EncryptedValue: &zeroValue}
	c.GetEncryptedValue()
	c = &CreateOrganizationPrivateRegistry{}
	c.GetEncryptedValue()
	c = nil
	c.GetEncryptedValue()
}

func TestCreateOrganizationPrivateRegistry_GetIdentityMappingName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CreateOrganizationPrivateRegistry{IdentityMappingName: &zeroValue}
	c.GetIdentityMappingName()
	c = &CreateOrganizationPrivateRegistry{}
	c.GetIdentityMappingName()
	c = nil
	c.GetIdentityMappingName()
}

func TestCreateOrganizationPrivateRegistry_GetJFrogOIDCProviderName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CreateOrganizationPrivateRegistry{JFrogOIDCProviderName: &zeroValue}
	c.GetJFrogOIDCProviderName()
	c = &CreateOrganizationPrivateRegistry{}
	c.GetJFrogOIDCProviderName()
	c = nil
	c.GetJFrogOIDCProviderName()
}

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

func TestCreateOrganizationPrivateRegistry_GetRegistryType(tt *testing.T) {
	tt.Parallel()
	c := &CreateOrganizationPrivateRegistry{}
	c.GetRegistryType()
	c = nil
	c.GetRegistryType()
}

func TestCreateOrganizationPrivateRegistry_GetReplacesBase(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &CreateOrganizationPrivateRegistry{ReplacesBase: &zeroValue}
	c.GetReplacesBase()
	c = &CreateOrganizationPrivateRegistry{}
	c.GetReplacesBase()
	c = nil
	c.GetReplacesBase()
}

func TestCreateOrganizationPrivateRegistry_GetRoleName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CreateOrganizationPrivateRegistry{RoleName: &zeroValue}
	c.GetRoleName()
	c = &CreateOrganizationPrivateRegistry{}
	c.GetRoleName()
	c = nil
	c.GetRoleName()
}

func TestCreateOrganizationPrivateRegistry_GetSelectedRepositoryIDs(tt *testing.T) {
	tt.Parallel()
	zeroValue := []int64{}
	c := &CreateOrganizationPrivateRegistry{SelectedRepositoryIDs: zeroValue}
	c.GetSelectedRepositoryIDs()
	c = &CreateOrganizationPrivateRegistry{}
	c.GetSelectedRepositoryIDs()
	c = nil
	c.GetSelectedRepositoryIDs()
}

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

func TestCreateOrganizationPrivateRegistry_GetURL(tt *testing.T) {
	tt.Parallel()
	c := &CreateOrganizationPrivateRegistry{}
	c.GetURL()
	c = nil
	c.GetURL()
}

func TestCreateOrganizationPrivateRegistry_GetUsername(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CreateOrganizationPrivateRegistry{Username: &zeroValue}
	c.GetUsername()
	c = &CreateOrganizationPrivateRegistry{}
	c.GetUsername()
	c = nil
	c.GetUsername()
}

func TestCreateOrganizationPrivateRegistry_GetVisibility(tt *testing.T) {
	tt.Parallel()
	c := &CreateOrganizationPrivateRegistry{}
	c.GetVisibility()
	c = nil
	c.GetVisibility()
}

func TestCreateOrgInvitationOptions_GetEmail(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CreateOrgInvitationOptions{Email: &zeroValue}
	c.GetEmail()
	c = &CreateOrgInvitationOptions{}
	c.GetEmail()
	c = nil
	c.GetEmail()
}

func TestCreateOrgInvitationOptions_GetInviteeID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	c := &CreateOrgInvitationOptions{InviteeID: &zeroValue}
	c.GetInviteeID()
	c = &CreateOrgInvitationOptions{}
	c.GetInviteeID()
	c = nil
	c.GetInviteeID()
}

func TestCreateOrgInvitationOptions_GetRole(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CreateOrgInvitationOptions{Role: &zeroValue}
	c.GetRole()
	c = &CreateOrgInvitationOptions{}
	c.GetRole()
	c = nil
	c.GetRole()
}

func TestCreateOrgInvitationOptions_GetTeamID(tt *testing.T) {
	tt.Parallel()
	zeroValue := []int64{}
	c := &CreateOrgInvitationOptions{TeamID: zeroValue}
	c.GetTeamID()
	c = &CreateOrgInvitationOptions{}
	c.GetTeamID()
	c = nil
	c.GetTeamID()
}

func TestCreateOrUpdateIssueTypesOptions_GetColor(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CreateOrUpdateIssueTypesOptions{Color: &zeroValue}
	c.GetColor()
	c = &CreateOrUpdateIssueTypesOptions{}
	c.GetColor()
	c = nil
	c.GetColor()
}

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

func TestCreateOrUpdateIssueTypesOptions_GetIsEnabled(tt *testing.T) {
	tt.Parallel()
	c := &CreateOrUpdateIssueTypesOptions{}
	c.GetIsEnabled()
	c = nil
	c.GetIsEnabled()
}

func TestCreateOrUpdateIssueTypesOptions_GetIsPrivate(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &CreateOrUpdateIssueTypesOptions{IsPrivate: &zeroValue}
	c.GetIsPrivate()
	c = &CreateOrUpdateIssueTypesOptions{}
	c.GetIsPrivate()
	c = nil
	c.GetIsPrivate()
}

func TestCreateOrUpdateIssueTypesOptions_GetName(tt *testing.T) {
	tt.Parallel()
	c := &CreateOrUpdateIssueTypesOptions{}
	c.GetName()
	c = nil
	c.GetName()
}

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

func TestCreateProjectV2DraftItemRequest_GetTitle(tt *testing.T) {
	tt.Parallel()
	c := &CreateProjectV2DraftItemRequest{}
	c.GetTitle()
	c = nil
	c.GetTitle()
}

func TestCreateProjectV2ViewRequest_GetFilter(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CreateProjectV2ViewRequest{Filter: &zeroValue}
	c.GetFilter()
	c = &CreateProjectV2ViewRequest{}
	c.GetFilter()
	c = nil
	c.GetFilter()
}

func TestCreateProjectV2ViewRequest_GetLayout(tt *testing.T) {
	tt.Parallel()
	c := &CreateProjectV2ViewRequest{}
	c.GetLayout()
	c = nil
	c.GetLayout()
}

func TestCreateProjectV2ViewRequest_GetName(tt *testing.T) {
	tt.Parallel()
	c := &CreateProjectV2ViewRequest{}
	c.GetName()
	c = nil
	c.GetName()
}

func TestCreateProjectV2ViewRequest_GetVisibleFields(tt *testing.T) {
	tt.Parallel()
	zeroValue := []int64{}
	c := &CreateProjectV2ViewRequest{VisibleFields: zeroValue}
	c.GetVisibleFields()
	c = &CreateProjectV2ViewRequest{}
	c.GetVisibleFields()
	c = nil
	c.GetVisibleFields()
}

func TestCreateProtectedChanges_GetFrom(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &CreateProtectedChanges{From: &zeroValue}
	c.GetFrom()
	c = &CreateProtectedChanges{}
	c.GetFrom()
	c = nil
	c.GetFrom()
}

func TestCreatePullRequest_GetBase(tt *testing.T) {
	tt.Parallel()
	c := &CreatePullRequest{}
	c.GetBase()
	c = nil
	c.GetBase()
}

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

func TestCreatePullRequest_GetDraft(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &CreatePullRequest{Draft: &zeroValue}
	c.GetDraft()
	c = &CreatePullRequest{}
	c.GetDraft()
	c = nil
	c.GetDraft()
}

func TestCreatePullRequest_GetHead(tt *testing.T) {
	tt.Parallel()
	c := &CreatePullRequest{}
	c.GetHead()
	c = nil
	c.GetHead()
}

func TestCreatePullRequest_GetHeadRepo(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CreatePullRequest{HeadRepo: &zeroValue}
	c.GetHeadRepo()
	c = &CreatePullRequest{}
	c.GetHeadRepo()
	c = nil
	c.GetHeadRepo()
}

func TestCreatePullRequest_GetIssue(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CreatePullRequest{Issue: &zeroValue}
	c.GetIssue()
	c = &CreatePullRequest{}
	c.GetIssue()
	c = nil
	c.GetIssue()
}

func TestCreatePullRequest_GetMaintainerCanModify(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &CreatePullRequest{MaintainerCanModify: &zeroValue}
	c.GetMaintainerCanModify()
	c = &CreatePullRequest{}
	c.GetMaintainerCanModify()
	c = nil
	c.GetMaintainerCanModify()
}

func TestCreatePullRequest_GetTitle(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CreatePullRequest{Title: &zeroValue}
	c.GetTitle()
	c = &CreatePullRequest{}
	c.GetTitle()
	c = nil
	c.GetTitle()
}

func TestCreateRef_GetRef(tt *testing.T) {
	tt.Parallel()
	c := &CreateRef{}
	c.GetRef()
	c = nil
	c.GetRef()
}

func TestCreateRef_GetSHA(tt *testing.T) {
	tt.Parallel()
	c := &CreateRef{}
	c.GetSHA()
	c = nil
	c.GetSHA()
}

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

func TestCreateReleaseRequest_GetDiscussionCategoryName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CreateReleaseRequest{DiscussionCategoryName: &zeroValue}
	c.GetDiscussionCategoryName()
	c = &CreateReleaseRequest{}
	c.GetDiscussionCategoryName()
	c = nil
	c.GetDiscussionCategoryName()
}

func TestCreateReleaseRequest_GetDraft(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &CreateReleaseRequest{Draft: &zeroValue}
	c.GetDraft()
	c = &CreateReleaseRequest{}
	c.GetDraft()
	c = nil
	c.GetDraft()
}

func TestCreateReleaseRequest_GetGenerateReleaseNotes(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &CreateReleaseRequest{GenerateReleaseNotes: &zeroValue}
	c.GetGenerateReleaseNotes()
	c = &CreateReleaseRequest{}
	c.GetGenerateReleaseNotes()
	c = nil
	c.GetGenerateReleaseNotes()
}

func TestCreateReleaseRequest_GetMakeLatest(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CreateReleaseRequest{MakeLatest: &zeroValue}
	c.GetMakeLatest()
	c = &CreateReleaseRequest{}
	c.GetMakeLatest()
	c = nil
	c.GetMakeLatest()
}

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

func TestCreateReleaseRequest_GetPrerelease(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &CreateReleaseRequest{Prerelease: &zeroValue}
	c.GetPrerelease()
	c = &CreateReleaseRequest{}
	c.GetPrerelease()
	c = nil
	c.GetPrerelease()
}

func TestCreateReleaseRequest_GetTagName(tt *testing.T) {
	tt.Parallel()
	c := &CreateReleaseRequest{}
	c.GetTagName()
	c = nil
	c.GetTagName()
}

func TestCreateReleaseRequest_GetTargetCommitish(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CreateReleaseRequest{TargetCommitish: &zeroValue}
	c.GetTargetCommitish()
	c = &CreateReleaseRequest{}
	c.GetTargetCommitish()
	c = nil
	c.GetTargetCommitish()
}

func TestCreateRunnerGroupRequest_GetAllowsPublicRepositories(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &CreateRunnerGroupRequest{AllowsPublicRepositories: &zeroValue}
	c.GetAllowsPublicRepositories()
	c = &CreateRunnerGroupRequest{}
	c.GetAllowsPublicRepositories()
	c = nil
	c.GetAllowsPublicRepositories()
}

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

func TestCreateRunnerGroupRequest_GetNetworkConfigurationID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CreateRunnerGroupRequest{NetworkConfigurationID: &zeroValue}
	c.GetNetworkConfigurationID()
	c = &CreateRunnerGroupRequest{}
	c.GetNetworkConfigurationID()
	c = nil
	c.GetNetworkConfigurationID()
}

func TestCreateRunnerGroupRequest_GetRestrictedToWorkflows(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &CreateRunnerGroupRequest{RestrictedToWorkflows: &zeroValue}
	c.GetRestrictedToWorkflows()
	c = &CreateRunnerGroupRequest{}
	c.GetRestrictedToWorkflows()
	c = nil
	c.GetRestrictedToWorkflows()
}

func TestCreateRunnerGroupRequest_GetRunners(tt *testing.T) {
	tt.Parallel()
	zeroValue := []int64{}
	c := &CreateRunnerGroupRequest{Runners: zeroValue}
	c.GetRunners()
	c = &CreateRunnerGroupRequest{}
	c.GetRunners()
	c = nil
	c.GetRunners()
}

func TestCreateRunnerGroupRequest_GetSelectedRepositoryIDs(tt *testing.T) {
	tt.Parallel()
	zeroValue := []int64{}
	c := &CreateRunnerGroupRequest{SelectedRepositoryIDs: zeroValue}
	c.GetSelectedRepositoryIDs()
	c = &CreateRunnerGroupRequest{}
	c.GetSelectedRepositoryIDs()
	c = nil
	c.GetSelectedRepositoryIDs()
}

func TestCreateRunnerGroupRequest_GetSelectedWorkflows(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	c := &CreateRunnerGroupRequest{SelectedWorkflows: zeroValue}
	c.GetSelectedWorkflows()
	c = &CreateRunnerGroupRequest{}
	c.GetSelectedWorkflows()
	c = nil
	c.GetSelectedWorkflows()
}

func TestCreateRunnerGroupRequest_GetVisibility(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CreateRunnerGroupRequest{Visibility: &zeroValue}
	c.GetVisibility()
	c = &CreateRunnerGroupRequest{}
	c.GetVisibility()
	c = nil
	c.GetVisibility()
}

func TestCreateTag_GetMessage(tt *testing.T) {
	tt.Parallel()
	c := &CreateTag{}
	c.GetMessage()
	c = nil
	c.GetMessage()
}

func TestCreateTag_GetObject(tt *testing.T) {
	tt.Parallel()
	c := &CreateTag{}
	c.GetObject()
	c = nil
	c.GetObject()
}

func TestCreateTag_GetTag(tt *testing.T) {
	tt.Parallel()
	c := &CreateTag{}
	c.GetTag()
	c = nil
	c.GetTag()
}

func TestCreateTag_GetTagger(tt *testing.T) {
	tt.Parallel()
	c := &CreateTag{}
	c.GetTagger()
	c = nil
	c.GetTagger()
}

func TestCreateTag_GetType(tt *testing.T) {
	tt.Parallel()
	c := &CreateTag{}
	c.GetType()
	c = nil
	c.GetType()
}

func TestCreateUpdateEnvironment_GetCanAdminsBypass(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &CreateUpdateEnvironment{CanAdminsBypass: &zeroValue}
	c.GetCanAdminsBypass()
	c = &CreateUpdateEnvironment{}
	c.GetCanAdminsBypass()
	c = nil
	c.GetCanAdminsBypass()
}

func TestCreateUpdateEnvironment_GetDeploymentBranchPolicy(tt *testing.T) {
	tt.Parallel()
	c := &CreateUpdateEnvironment{}
	c.GetDeploymentBranchPolicy()
	c = nil
	c.GetDeploymentBranchPolicy()
}

func TestCreateUpdateEnvironment_GetPreventSelfReview(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &CreateUpdateEnvironment{PreventSelfReview: &zeroValue}
	c.GetPreventSelfReview()
	c = &CreateUpdateEnvironment{}
	c.GetPreventSelfReview()
	c = nil
	c.GetPreventSelfReview()
}

func TestCreateUpdateEnvironment_GetReviewers(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*EnvReviewers{}
	c := &CreateUpdateEnvironment{Reviewers: zeroValue}
	c.GetReviewers()
	c = &CreateUpdateEnvironment{}
	c.GetReviewers()
	c = nil
	c.GetReviewers()
}

func TestCreateUpdateEnvironment_GetWaitTimer(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	c := &CreateUpdateEnvironment{WaitTimer: &zeroValue}
	c.GetWaitTimer()
	c = &CreateUpdateEnvironment{}
	c.GetWaitTimer()
	c = nil
	c.GetWaitTimer()
}

func TestCreateUserRequest_GetEmail(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CreateUserRequest{Email: &zeroValue}
	c.GetEmail()
	c = &CreateUserRequest{}
	c.GetEmail()
	c = nil
	c.GetEmail()
}

func TestCreateUserRequest_GetLogin(tt *testing.T) {
	tt.Parallel()
	c := &CreateUserRequest{}
	c.GetLogin()
	c = nil
	c.GetLogin()
}

func TestCreateUserRequest_GetSuspended(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &CreateUserRequest{Suspended: &zeroValue}
	c.GetSuspended()
	c = &CreateUserRequest{}
	c.GetSuspended()
	c = nil
	c.GetSuspended()
}

func TestCreateWorkflowDispatchEventRequest_GetInputs(tt *testing.T) {
	tt.Parallel()
	zeroValue := map[string]any{}
	c := &CreateWorkflowDispatchEventRequest{Inputs: zeroValue}
	c.GetInputs()
	c = &CreateWorkflowDispatchEventRequest{}
	c.GetInputs()
	c = nil
	c.GetInputs()
}

func TestCreateWorkflowDispatchEventRequest_GetRef(tt *testing.T) {
	tt.Parallel()
	c := &CreateWorkflowDispatchEventRequest{}
	c.GetRef()
	c = nil
	c.GetRef()
}

func TestCreateWorkflowDispatchEventRequest_GetReturnRunDetails(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	c := &CreateWorkflowDispatchEventRequest{ReturnRunDetails: &zeroValue}
	c.GetReturnRunDetails()
	c = &CreateWorkflowDispatchEventRequest{}
	c.GetReturnRunDetails()
	c = nil
	c.GetReturnRunDetails()
}

func TestCreationInfo_GetCreated(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	c := &CreationInfo{Created: &zeroValue}
	c.GetCreated()
	c = &CreationInfo{}
	c.GetCreated()
	c = nil
	c.GetCreated()
}

func TestCreationInfo_GetCreators(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	c := &CreationInfo{Creators: zeroValue}
	c.GetCreators()
	c = &CreationInfo{}
	c.GetCreators()
	c = nil
	c.GetCreators()
}

func TestCredentialAuthorization_GetAuthorizedCredentialExpiresAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	c := &CredentialAuthorization{AuthorizedCredentialExpiresAt: &zeroValue}
	c.GetAuthorizedCredentialExpiresAt()
	c = &CredentialAuthorization{}
	c.GetAuthorizedCredentialExpiresAt()
	c = nil
	c.GetAuthorizedCredentialExpiresAt()
}

func TestCredentialAuthorization_GetAuthorizedCredentialID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	c := &CredentialAuthorization{AuthorizedCredentialID: &zeroValue}
	c.GetAuthorizedCredentialID()
	c = &CredentialAuthorization{}
	c.GetAuthorizedCredentialID()
	c = nil
	c.GetAuthorizedCredentialID()
}

func TestCredentialAuthorization_GetAuthorizedCredentialNote(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CredentialAuthorization{AuthorizedCredentialNote: &zeroValue}
	c.GetAuthorizedCredentialNote()
	c = &CredentialAuthorization{}
	c.GetAuthorizedCredentialNote()
	c = nil
	c.GetAuthorizedCredentialNote()
}

func TestCredentialAuthorization_GetAuthorizedCredentialTitle(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CredentialAuthorization{AuthorizedCredentialTitle: &zeroValue}
	c.GetAuthorizedCredentialTitle()
	c = &CredentialAuthorization{}
	c.GetAuthorizedCredentialTitle()
	c = nil
	c.GetAuthorizedCredentialTitle()
}

func TestCredentialAuthorization_GetCredentialAccessedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	c := &CredentialAuthorization{CredentialAccessedAt: &zeroValue}
	c.GetCredentialAccessedAt()
	c = &CredentialAuthorization{}
	c.GetCredentialAccessedAt()
	c = nil
	c.GetCredentialAccessedAt()
}

func TestCredentialAuthorization_GetCredentialAuthorizedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	c := &CredentialAuthorization{CredentialAuthorizedAt: &zeroValue}
	c.GetCredentialAuthorizedAt()
	c = &CredentialAuthorization{}
	c.GetCredentialAuthorizedAt()
	c = nil
	c.GetCredentialAuthorizedAt()
}

func TestCredentialAuthorization_GetCredentialID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	c := &CredentialAuthorization{CredentialID: &zeroValue}
	c.GetCredentialID()
	c = &CredentialAuthorization{}
	c.GetCredentialID()
	c = nil
	c.GetCredentialID()
}

func TestCredentialAuthorization_GetCredentialType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CredentialAuthorization{CredentialType: &zeroValue}
	c.GetCredentialType()
	c = &CredentialAuthorization{}
	c.GetCredentialType()
	c = nil
	c.GetCredentialType()
}

func TestCredentialAuthorization_GetFingerprint(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CredentialAuthorization{Fingerprint: &zeroValue}
	c.GetFingerprint()
	c = &CredentialAuthorization{}
	c.GetFingerprint()
	c = nil
	c.GetFingerprint()
}

func TestCredentialAuthorization_GetLogin(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CredentialAuthorization{Login: &zeroValue}
	c.GetLogin()
	c = &CredentialAuthorization{}
	c.GetLogin()
	c = nil
	c.GetLogin()
}

func TestCredentialAuthorization_GetScopes(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	c := &CredentialAuthorization{Scopes: zeroValue}
	c.GetScopes()
	c = &CredentialAuthorization{}
	c.GetScopes()
	c = nil
	c.GetScopes()
}

func TestCredentialAuthorization_GetTokenLastEight(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CredentialAuthorization{TokenLastEight: &zeroValue}
	c.GetTokenLastEight()
	c = &CredentialAuthorization{}
	c.GetTokenLastEight()
	c = nil
	c.GetTokenLastEight()
}

func TestCredentialAuthorizationsListOptions_GetLogin(tt *testing.T) {
	tt.Parallel()
	c := &CredentialAuthorizationsListOptions{}
	c.GetLogin()
	c = nil
	c.GetLogin()
}

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

func TestCredit_GetUser(tt *testing.T) {
	tt.Parallel()
	c := &Credit{}
	c.GetUser()
	c = nil
	c.GetUser()
}

func TestCustomDeploymentProtectionRule_GetApp(tt *testing.T) {
	tt.Parallel()
	c := &CustomDeploymentProtectionRule{}
	c.GetApp()
	c = nil
	c.GetApp()
}

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

func TestCustomDeploymentProtectionRule_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	c := &CustomDeploymentProtectionRule{ID: &zeroValue}
	c.GetID()
	c = &CustomDeploymentProtectionRule{}
	c.GetID()
	c = nil
	c.GetID()
}

func TestCustomDeploymentProtectionRule_GetNodeID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CustomDeploymentProtectionRule{NodeID: &zeroValue}
	c.GetNodeID()
	c = &CustomDeploymentProtectionRule{}
	c.GetNodeID()
	c = nil
	c.GetNodeID()
}

func TestCustomDeploymentProtectionRuleApp_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	c := &CustomDeploymentProtectionRuleApp{ID: &zeroValue}
	c.GetID()
	c = &CustomDeploymentProtectionRuleApp{}
	c.GetID()
	c = nil
	c.GetID()
}

func TestCustomDeploymentProtectionRuleApp_GetIntegrationURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CustomDeploymentProtectionRuleApp{IntegrationURL: &zeroValue}
	c.GetIntegrationURL()
	c = &CustomDeploymentProtectionRuleApp{}
	c.GetIntegrationURL()
	c = nil
	c.GetIntegrationURL()
}

func TestCustomDeploymentProtectionRuleApp_GetNodeID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CustomDeploymentProtectionRuleApp{NodeID: &zeroValue}
	c.GetNodeID()
	c = &CustomDeploymentProtectionRuleApp{}
	c.GetNodeID()
	c = nil
	c.GetNodeID()
}

func TestCustomDeploymentProtectionRuleApp_GetSlug(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CustomDeploymentProtectionRuleApp{Slug: &zeroValue}
	c.GetSlug()
	c = &CustomDeploymentProtectionRuleApp{}
	c.GetSlug()
	c = nil
	c.GetSlug()
}

func TestCustomDeploymentProtectionRuleRequest_GetIntegrationID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	c := &CustomDeploymentProtectionRuleRequest{IntegrationID: &zeroValue}
	c.GetIntegrationID()
	c = &CustomDeploymentProtectionRuleRequest{}
	c.GetIntegrationID()
	c = nil
	c.GetIntegrationID()
}

func TestCustomOrgRole_GetBaseRole(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CustomOrgRole{BaseRole: &zeroValue}
	c.GetBaseRole()
	c = &CustomOrgRole{}
	c.GetBaseRole()
	c = nil
	c.GetBaseRole()
}

func TestCustomOrgRole_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	c := &CustomOrgRole{CreatedAt: &zeroValue}
	c.GetCreatedAt()
	c = &CustomOrgRole{}
	c.GetCreatedAt()
	c = nil
	c.GetCreatedAt()
}

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

func TestCustomOrgRole_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	c := &CustomOrgRole{ID: &zeroValue}
	c.GetID()
	c = &CustomOrgRole{}
	c.GetID()
	c = nil
	c.GetID()
}

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

func TestCustomOrgRole_GetOrg(tt *testing.T) {
	tt.Parallel()
	c := &CustomOrgRole{}
	c.GetOrg()
	c = nil
	c.GetOrg()
}

func TestCustomOrgRole_GetPermissions(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	c := &CustomOrgRole{Permissions: zeroValue}
	c.GetPermissions()
	c = &CustomOrgRole{}
	c.GetPermissions()
	c = nil
	c.GetPermissions()
}

func TestCustomOrgRole_GetSource(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CustomOrgRole{Source: &zeroValue}
	c.GetSource()
	c = &CustomOrgRole{}
	c.GetSource()
	c = nil
	c.GetSource()
}

func TestCustomOrgRole_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	c := &CustomOrgRole{UpdatedAt: &zeroValue}
	c.GetUpdatedAt()
	c = &CustomOrgRole{}
	c.GetUpdatedAt()
	c = nil
	c.GetUpdatedAt()
}

func TestCustomPatternBackfillScan_GetPatternScope(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CustomPatternBackfillScan{PatternScope: &zeroValue}
	c.GetPatternScope()
	c = &CustomPatternBackfillScan{}
	c.GetPatternScope()
	c = nil
	c.GetPatternScope()
}

func TestCustomPatternBackfillScan_GetPatternSlug(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CustomPatternBackfillScan{PatternSlug: &zeroValue}
	c.GetPatternSlug()
	c = &CustomPatternBackfillScan{}
	c.GetPatternSlug()
	c = nil
	c.GetPatternSlug()
}

func TestCustomProperty_GetAllowedValues(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	c := &CustomProperty{AllowedValues: zeroValue}
	c.GetAllowedValues()
	c = &CustomProperty{}
	c.GetAllowedValues()
	c = nil
	c.GetAllowedValues()
}

func TestCustomProperty_GetDefaultValue(tt *testing.T) {
	tt.Parallel()
	c := &CustomProperty{}
	c.GetDefaultValue()
	c = nil
	c.GetDefaultValue()
}

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

func TestCustomProperty_GetPropertyName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CustomProperty{PropertyName: &zeroValue}
	c.GetPropertyName()
	c = &CustomProperty{}
	c.GetPropertyName()
	c = nil
	c.GetPropertyName()
}

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

func TestCustomProperty_GetSourceType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CustomProperty{SourceType: &zeroValue}
	c.GetSourceType()
	c = &CustomProperty{}
	c.GetSourceType()
	c = nil
	c.GetSourceType()
}

func TestCustomProperty_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CustomProperty{URL: &zeroValue}
	c.GetURL()
	c = &CustomProperty{}
	c.GetURL()
	c = nil
	c.GetURL()
}

func TestCustomProperty_GetValuesEditableBy(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CustomProperty{ValuesEditableBy: &zeroValue}
	c.GetValuesEditableBy()
	c = &CustomProperty{}
	c.GetValuesEditableBy()
	c = nil
	c.GetValuesEditableBy()
}

func TestCustomProperty_GetValueType(tt *testing.T) {
	tt.Parallel()
	c := &CustomProperty{}
	c.GetValueType()
	c = nil
	c.GetValueType()
}

func TestCustomPropertyEvent_GetAction(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CustomPropertyEvent{Action: &zeroValue}
	c.GetAction()
	c = &CustomPropertyEvent{}
	c.GetAction()
	c = nil
	c.GetAction()
}

func TestCustomPropertyEvent_GetDefinition(tt *testing.T) {
	tt.Parallel()
	c := &CustomPropertyEvent{}
	c.GetDefinition()
	c = nil
	c.GetDefinition()
}

func TestCustomPropertyEvent_GetEnterprise(tt *testing.T) {
	tt.Parallel()
	c := &CustomPropertyEvent{}
	c.GetEnterprise()
	c = nil
	c.GetEnterprise()
}

func TestCustomPropertyEvent_GetInstallation(tt *testing.T) {
	tt.Parallel()
	c := &CustomPropertyEvent{}
	c.GetInstallation()
	c = nil
	c.GetInstallation()
}

func TestCustomPropertyEvent_GetOrg(tt *testing.T) {
	tt.Parallel()
	c := &CustomPropertyEvent{}
	c.GetOrg()
	c = nil
	c.GetOrg()
}

func TestCustomPropertyEvent_GetSender(tt *testing.T) {
	tt.Parallel()
	c := &CustomPropertyEvent{}
	c.GetSender()
	c = nil
	c.GetSender()
}

func TestCustomPropertyValue_GetPropertyName(tt *testing.T) {
	tt.Parallel()
	c := &CustomPropertyValue{}
	c.GetPropertyName()
	c = nil
	c.GetPropertyName()
}

func TestCustomPropertyValue_GetValue(tt *testing.T) {
	tt.Parallel()
	c := &CustomPropertyValue{}
	c.GetValue()
	c = nil
	c.GetValue()
}

func TestCustomPropertyValuesEvent_GetAction(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CustomPropertyValuesEvent{Action: &zeroValue}
	c.GetAction()
	c = &CustomPropertyValuesEvent{}
	c.GetAction()
	c = nil
	c.GetAction()
}

func TestCustomPropertyValuesEvent_GetEnterprise(tt *testing.T) {
	tt.Parallel()
	c := &CustomPropertyValuesEvent{}
	c.GetEnterprise()
	c = nil
	c.GetEnterprise()
}

func TestCustomPropertyValuesEvent_GetInstallation(tt *testing.T) {
	tt.Parallel()
	c := &CustomPropertyValuesEvent{}
	c.GetInstallation()
	c = nil
	c.GetInstallation()
}

func TestCustomPropertyValuesEvent_GetNewPropertyValues(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*CustomPropertyValue{}
	c := &CustomPropertyValuesEvent{NewPropertyValues: zeroValue}
	c.GetNewPropertyValues()
	c = &CustomPropertyValuesEvent{}
	c.GetNewPropertyValues()
	c = nil
	c.GetNewPropertyValues()
}

func TestCustomPropertyValuesEvent_GetOldPropertyValues(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*CustomPropertyValue{}
	c := &CustomPropertyValuesEvent{OldPropertyValues: zeroValue}
	c.GetOldPropertyValues()
	c = &CustomPropertyValuesEvent{}
	c.GetOldPropertyValues()
	c = nil
	c.GetOldPropertyValues()
}

func TestCustomPropertyValuesEvent_GetOrg(tt *testing.T) {
	tt.Parallel()
	c := &CustomPropertyValuesEvent{}
	c.GetOrg()
	c = nil
	c.GetOrg()
}

func TestCustomPropertyValuesEvent_GetRepo(tt *testing.T) {
	tt.Parallel()
	c := &CustomPropertyValuesEvent{}
	c.GetRepo()
	c = nil
	c.GetRepo()
}

func TestCustomPropertyValuesEvent_GetSender(tt *testing.T) {
	tt.Parallel()
	c := &CustomPropertyValuesEvent{}
	c.GetSender()
	c = nil
	c.GetSender()
}

func TestCustomRepoRoles_GetBaseRole(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	c := &CustomRepoRoles{BaseRole: &zeroValue}
	c.GetBaseRole()
	c = &CustomRepoRoles{}
	c.GetBaseRole()
	c = nil
	c.GetBaseRole()
}

func TestCustomRepoRoles_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	c := &CustomRepoRoles{CreatedAt: &zeroValue}
	c.GetCreatedAt()
	c = &CustomRepoRoles{}
	c.GetCreatedAt()
	c = nil
	c.GetCreatedAt()
}

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

func TestCustomRepoRoles_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	c := &CustomRepoRoles{ID: &zeroValue}
	c.GetID()
	c = &CustomRepoRoles{}
	c.GetID()
	c = nil
	c.GetID()
}

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

func TestCustomRepoRoles_GetOrg(tt *testing.T) {
	tt.Parallel()
	c := &CustomRepoRoles{}
	c.GetOrg()
	c = nil
	c.GetOrg()
}

func TestCustomRepoRoles_GetPermissions(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	c := &CustomRepoRoles{Permissions: zeroValue}
	c.GetPermissions()
	c = &CustomRepoRoles{}
	c.GetPermissions()
	c = nil
	c.GetPermissions()
}

func TestCustomRepoRoles_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	c := &CustomRepoRoles{UpdatedAt: &zeroValue}
	c.GetUpdatedAt()
	c = &CustomRepoRoles{}
	c.GetUpdatedAt()
	c = nil
	c.GetUpdatedAt()
}

func TestDatadogConfig_GetEncryptedToken(tt *testing.T) {
	tt.Parallel()
	d := &DatadogConfig{}
	d.GetEncryptedToken()
	d = nil
	d.GetEncryptedToken()
}

func TestDatadogConfig_GetKeyID(tt *testing.T) {
	tt.Parallel()
	d := &DatadogConfig{}
	d.GetKeyID()
	d = nil
	d.GetKeyID()
}

func TestDatadogConfig_GetSite(tt *testing.T) {
	tt.Parallel()
	d := &DatadogConfig{}
	d.GetSite()
	d = nil
	d.GetSite()
}

func TestDefaultSetupConfiguration_GetLanguages(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	d := &DefaultSetupConfiguration{Languages: zeroValue}
	d.GetLanguages()
	d = &DefaultSetupConfiguration{}
	d.GetLanguages()
	d = nil
	d.GetLanguages()
}

func TestDefaultSetupConfiguration_GetQuerySuite(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DefaultSetupConfiguration{QuerySuite: &zeroValue}
	d.GetQuerySuite()
	d = &DefaultSetupConfiguration{}
	d.GetQuerySuite()
	d = nil
	d.GetQuerySuite()
}

func TestDefaultSetupConfiguration_GetState(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DefaultSetupConfiguration{State: &zeroValue}
	d.GetState()
	d = &DefaultSetupConfiguration{}
	d.GetState()
	d = nil
	d.GetState()
}

func TestDefaultSetupConfiguration_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	d := &DefaultSetupConfiguration{UpdatedAt: &zeroValue}
	d.GetUpdatedAt()
	d = &DefaultSetupConfiguration{}
	d.GetUpdatedAt()
	d = nil
	d.GetUpdatedAt()
}

func TestDefaultWorkflowPermissionEnterprise_GetCanApprovePullRequestReviews(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	d := &DefaultWorkflowPermissionEnterprise{CanApprovePullRequestReviews: &zeroValue}
	d.GetCanApprovePullRequestReviews()
	d = &DefaultWorkflowPermissionEnterprise{}
	d.GetCanApprovePullRequestReviews()
	d = nil
	d.GetCanApprovePullRequestReviews()
}

func TestDefaultWorkflowPermissionEnterprise_GetDefaultWorkflowPermissions(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DefaultWorkflowPermissionEnterprise{DefaultWorkflowPermissions: &zeroValue}
	d.GetDefaultWorkflowPermissions()
	d = &DefaultWorkflowPermissionEnterprise{}
	d.GetDefaultWorkflowPermissions()
	d = nil
	d.GetDefaultWorkflowPermissions()
}

func TestDefaultWorkflowPermissionOrganization_GetCanApprovePullRequestReviews(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	d := &DefaultWorkflowPermissionOrganization{CanApprovePullRequestReviews: &zeroValue}
	d.GetCanApprovePullRequestReviews()
	d = &DefaultWorkflowPermissionOrganization{}
	d.GetCanApprovePullRequestReviews()
	d = nil
	d.GetCanApprovePullRequestReviews()
}

func TestDefaultWorkflowPermissionOrganization_GetDefaultWorkflowPermissions(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DefaultWorkflowPermissionOrganization{DefaultWorkflowPermissions: &zeroValue}
	d.GetDefaultWorkflowPermissions()
	d = &DefaultWorkflowPermissionOrganization{}
	d.GetDefaultWorkflowPermissions()
	d = nil
	d.GetDefaultWorkflowPermissions()
}

func TestDefaultWorkflowPermissionRepository_GetCanApprovePullRequestReviews(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	d := &DefaultWorkflowPermissionRepository{CanApprovePullRequestReviews: &zeroValue}
	d.GetCanApprovePullRequestReviews()
	d = &DefaultWorkflowPermissionRepository{}
	d.GetCanApprovePullRequestReviews()
	d = nil
	d.GetCanApprovePullRequestReviews()
}

func TestDefaultWorkflowPermissionRepository_GetDefaultWorkflowPermissions(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DefaultWorkflowPermissionRepository{DefaultWorkflowPermissions: &zeroValue}
	d.GetDefaultWorkflowPermissions()
	d = &DefaultWorkflowPermissionRepository{}
	d.GetDefaultWorkflowPermissions()
	d = nil
	d.GetDefaultWorkflowPermissions()
}

func TestDeleteAnalysis_GetConfirmDeleteURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DeleteAnalysis{ConfirmDeleteURL: &zeroValue}
	d.GetConfirmDeleteURL()
	d = &DeleteAnalysis{}
	d.GetConfirmDeleteURL()
	d = nil
	d.GetConfirmDeleteURL()
}

func TestDeleteAnalysis_GetNextAnalysisURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DeleteAnalysis{NextAnalysisURL: &zeroValue}
	d.GetNextAnalysisURL()
	d = &DeleteAnalysis{}
	d.GetNextAnalysisURL()
	d = nil
	d.GetNextAnalysisURL()
}

func TestDeleteCostCenterResponse_GetCostCenterState(tt *testing.T) {
	tt.Parallel()
	d := &DeleteCostCenterResponse{}
	d.GetCostCenterState()
	d = nil
	d.GetCostCenterState()
}

func TestDeleteCostCenterResponse_GetID(tt *testing.T) {
	tt.Parallel()
	d := &DeleteCostCenterResponse{}
	d.GetID()
	d = nil
	d.GetID()
}

func TestDeleteCostCenterResponse_GetMessage(tt *testing.T) {
	tt.Parallel()
	d := &DeleteCostCenterResponse{}
	d.GetMessage()
	d = nil
	d.GetMessage()
}

func TestDeleteCostCenterResponse_GetName(tt *testing.T) {
	tt.Parallel()
	d := &DeleteCostCenterResponse{}
	d.GetName()
	d = nil
	d.GetName()
}

func TestDeleteEvent_GetInstallation(tt *testing.T) {
	tt.Parallel()
	d := &DeleteEvent{}
	d.GetInstallation()
	d = nil
	d.GetInstallation()
}

func TestDeleteEvent_GetOrg(tt *testing.T) {
	tt.Parallel()
	d := &DeleteEvent{}
	d.GetOrg()
	d = nil
	d.GetOrg()
}

func TestDeleteEvent_GetPusherType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DeleteEvent{PusherType: &zeroValue}
	d.GetPusherType()
	d = &DeleteEvent{}
	d.GetPusherType()
	d = nil
	d.GetPusherType()
}

func TestDeleteEvent_GetRef(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DeleteEvent{Ref: &zeroValue}
	d.GetRef()
	d = &DeleteEvent{}
	d.GetRef()
	d = nil
	d.GetRef()
}

func TestDeleteEvent_GetRefType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DeleteEvent{RefType: &zeroValue}
	d.GetRefType()
	d = &DeleteEvent{}
	d.GetRefType()
	d = nil
	d.GetRefType()
}

func TestDeleteEvent_GetRepo(tt *testing.T) {
	tt.Parallel()
	d := &DeleteEvent{}
	d.GetRepo()
	d = nil
	d.GetRepo()
}

func TestDeleteEvent_GetSender(tt *testing.T) {
	tt.Parallel()
	d := &DeleteEvent{}
	d.GetSender()
	d = nil
	d.GetSender()
}

func TestDependabotAlert_GetAutoDismissedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	d := &DependabotAlert{AutoDismissedAt: &zeroValue}
	d.GetAutoDismissedAt()
	d = &DependabotAlert{}
	d.GetAutoDismissedAt()
	d = nil
	d.GetAutoDismissedAt()
}

func TestDependabotAlert_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	d := &DependabotAlert{CreatedAt: &zeroValue}
	d.GetCreatedAt()
	d = &DependabotAlert{}
	d.GetCreatedAt()
	d = nil
	d.GetCreatedAt()
}

func TestDependabotAlert_GetDependency(tt *testing.T) {
	tt.Parallel()
	d := &DependabotAlert{}
	d.GetDependency()
	d = nil
	d.GetDependency()
}

func TestDependabotAlert_GetDismissedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	d := &DependabotAlert{DismissedAt: &zeroValue}
	d.GetDismissedAt()
	d = &DependabotAlert{}
	d.GetDismissedAt()
	d = nil
	d.GetDismissedAt()
}

func TestDependabotAlert_GetDismissedBy(tt *testing.T) {
	tt.Parallel()
	d := &DependabotAlert{}
	d.GetDismissedBy()
	d = nil
	d.GetDismissedBy()
}

func TestDependabotAlert_GetDismissedComment(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DependabotAlert{DismissedComment: &zeroValue}
	d.GetDismissedComment()
	d = &DependabotAlert{}
	d.GetDismissedComment()
	d = nil
	d.GetDismissedComment()
}

func TestDependabotAlert_GetDismissedReason(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DependabotAlert{DismissedReason: &zeroValue}
	d.GetDismissedReason()
	d = &DependabotAlert{}
	d.GetDismissedReason()
	d = nil
	d.GetDismissedReason()
}

func TestDependabotAlert_GetFixedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	d := &DependabotAlert{FixedAt: &zeroValue}
	d.GetFixedAt()
	d = &DependabotAlert{}
	d.GetFixedAt()
	d = nil
	d.GetFixedAt()
}

func TestDependabotAlert_GetHTMLURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DependabotAlert{HTMLURL: &zeroValue}
	d.GetHTMLURL()
	d = &DependabotAlert{}
	d.GetHTMLURL()
	d = nil
	d.GetHTMLURL()
}

func TestDependabotAlert_GetNumber(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	d := &DependabotAlert{Number: &zeroValue}
	d.GetNumber()
	d = &DependabotAlert{}
	d.GetNumber()
	d = nil
	d.GetNumber()
}

func TestDependabotAlert_GetRepository(tt *testing.T) {
	tt.Parallel()
	d := &DependabotAlert{}
	d.GetRepository()
	d = nil
	d.GetRepository()
}

func TestDependabotAlert_GetSecurityAdvisory(tt *testing.T) {
	tt.Parallel()
	d := &DependabotAlert{}
	d.GetSecurityAdvisory()
	d = nil
	d.GetSecurityAdvisory()
}

func TestDependabotAlert_GetSecurityVulnerability(tt *testing.T) {
	tt.Parallel()
	d := &DependabotAlert{}
	d.GetSecurityVulnerability()
	d = nil
	d.GetSecurityVulnerability()
}

func TestDependabotAlert_GetState(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DependabotAlert{State: &zeroValue}
	d.GetState()
	d = &DependabotAlert{}
	d.GetState()
	d = nil
	d.GetState()
}

func TestDependabotAlert_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	d := &DependabotAlert{UpdatedAt: &zeroValue}
	d.GetUpdatedAt()
	d = &DependabotAlert{}
	d.GetUpdatedAt()
	d = nil
	d.GetUpdatedAt()
}

func TestDependabotAlert_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DependabotAlert{URL: &zeroValue}
	d.GetURL()
	d = &DependabotAlert{}
	d.GetURL()
	d = nil
	d.GetURL()
}

func TestDependabotAlertEvent_GetAction(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DependabotAlertEvent{Action: &zeroValue}
	d.GetAction()
	d = &DependabotAlertEvent{}
	d.GetAction()
	d = nil
	d.GetAction()
}

func TestDependabotAlertEvent_GetAlert(tt *testing.T) {
	tt.Parallel()
	d := &DependabotAlertEvent{}
	d.GetAlert()
	d = nil
	d.GetAlert()
}

func TestDependabotAlertEvent_GetEnterprise(tt *testing.T) {
	tt.Parallel()
	d := &DependabotAlertEvent{}
	d.GetEnterprise()
	d = nil
	d.GetEnterprise()
}

func TestDependabotAlertEvent_GetInstallation(tt *testing.T) {
	tt.Parallel()
	d := &DependabotAlertEvent{}
	d.GetInstallation()
	d = nil
	d.GetInstallation()
}

func TestDependabotAlertEvent_GetOrganization(tt *testing.T) {
	tt.Parallel()
	d := &DependabotAlertEvent{}
	d.GetOrganization()
	d = nil
	d.GetOrganization()
}

func TestDependabotAlertEvent_GetRepo(tt *testing.T) {
	tt.Parallel()
	d := &DependabotAlertEvent{}
	d.GetRepo()
	d = nil
	d.GetRepo()
}

func TestDependabotAlertEvent_GetSender(tt *testing.T) {
	tt.Parallel()
	d := &DependabotAlertEvent{}
	d.GetSender()
	d = nil
	d.GetSender()
}

func TestDependabotAlertState_GetDismissedComment(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DependabotAlertState{DismissedComment: &zeroValue}
	d.GetDismissedComment()
	d = &DependabotAlertState{}
	d.GetDismissedComment()
	d = nil
	d.GetDismissedComment()
}

func TestDependabotAlertState_GetDismissedReason(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DependabotAlertState{DismissedReason: &zeroValue}
	d.GetDismissedReason()
	d = &DependabotAlertState{}
	d.GetDismissedReason()
	d = nil
	d.GetDismissedReason()
}

func TestDependabotAlertState_GetState(tt *testing.T) {
	tt.Parallel()
	d := &DependabotAlertState{}
	d.GetState()
	d = nil
	d.GetState()
}

func TestDependabotSecurityAdvisory_GetClassification(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DependabotSecurityAdvisory{Classification: &zeroValue}
	d.GetClassification()
	d = &DependabotSecurityAdvisory{}
	d.GetClassification()
	d = nil
	d.GetClassification()
}

func TestDependabotSecurityAdvisory_GetCVEID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DependabotSecurityAdvisory{CVEID: &zeroValue}
	d.GetCVEID()
	d = &DependabotSecurityAdvisory{}
	d.GetCVEID()
	d = nil
	d.GetCVEID()
}

func TestDependabotSecurityAdvisory_GetCVSS(tt *testing.T) {
	tt.Parallel()
	d := &DependabotSecurityAdvisory{}
	d.GetCVSS()
	d = nil
	d.GetCVSS()
}

func TestDependabotSecurityAdvisory_GetCVSSSeverities(tt *testing.T) {
	tt.Parallel()
	d := &DependabotSecurityAdvisory{}
	d.GetCVSSSeverities()
	d = nil
	d.GetCVSSSeverities()
}

func TestDependabotSecurityAdvisory_GetCWEs(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*AdvisoryCWEs{}
	d := &DependabotSecurityAdvisory{CWEs: zeroValue}
	d.GetCWEs()
	d = &DependabotSecurityAdvisory{}
	d.GetCWEs()
	d = nil
	d.GetCWEs()
}

func TestDependabotSecurityAdvisory_GetDescription(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DependabotSecurityAdvisory{Description: &zeroValue}
	d.GetDescription()
	d = &DependabotSecurityAdvisory{}
	d.GetDescription()
	d = nil
	d.GetDescription()
}

func TestDependabotSecurityAdvisory_GetEPSS(tt *testing.T) {
	tt.Parallel()
	d := &DependabotSecurityAdvisory{}
	d.GetEPSS()
	d = nil
	d.GetEPSS()
}

func TestDependabotSecurityAdvisory_GetGHSAID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DependabotSecurityAdvisory{GHSAID: &zeroValue}
	d.GetGHSAID()
	d = &DependabotSecurityAdvisory{}
	d.GetGHSAID()
	d = nil
	d.GetGHSAID()
}

func TestDependabotSecurityAdvisory_GetIdentifiers(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*AdvisoryIdentifier{}
	d := &DependabotSecurityAdvisory{Identifiers: zeroValue}
	d.GetIdentifiers()
	d = &DependabotSecurityAdvisory{}
	d.GetIdentifiers()
	d = nil
	d.GetIdentifiers()
}

func TestDependabotSecurityAdvisory_GetPublishedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	d := &DependabotSecurityAdvisory{PublishedAt: &zeroValue}
	d.GetPublishedAt()
	d = &DependabotSecurityAdvisory{}
	d.GetPublishedAt()
	d = nil
	d.GetPublishedAt()
}

func TestDependabotSecurityAdvisory_GetReferences(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*AdvisoryReference{}
	d := &DependabotSecurityAdvisory{References: zeroValue}
	d.GetReferences()
	d = &DependabotSecurityAdvisory{}
	d.GetReferences()
	d = nil
	d.GetReferences()
}

func TestDependabotSecurityAdvisory_GetSeverity(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DependabotSecurityAdvisory{Severity: &zeroValue}
	d.GetSeverity()
	d = &DependabotSecurityAdvisory{}
	d.GetSeverity()
	d = nil
	d.GetSeverity()
}

func TestDependabotSecurityAdvisory_GetSummary(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DependabotSecurityAdvisory{Summary: &zeroValue}
	d.GetSummary()
	d = &DependabotSecurityAdvisory{}
	d.GetSummary()
	d = nil
	d.GetSummary()
}

func TestDependabotSecurityAdvisory_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	d := &DependabotSecurityAdvisory{UpdatedAt: &zeroValue}
	d.GetUpdatedAt()
	d = &DependabotSecurityAdvisory{}
	d.GetUpdatedAt()
	d = nil
	d.GetUpdatedAt()
}

func TestDependabotSecurityAdvisory_GetVulnerabilities(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*AdvisoryVulnerability{}
	d := &DependabotSecurityAdvisory{Vulnerabilities: zeroValue}
	d.GetVulnerabilities()
	d = &DependabotSecurityAdvisory{}
	d.GetVulnerabilities()
	d = nil
	d.GetVulnerabilities()
}

func TestDependabotSecurityAdvisory_GetWithdrawnAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	d := &DependabotSecurityAdvisory{WithdrawnAt: &zeroValue}
	d.GetWithdrawnAt()
	d = &DependabotSecurityAdvisory{}
	d.GetWithdrawnAt()
	d = nil
	d.GetWithdrawnAt()
}

func TestDependabotSecurityUpdates_GetStatus(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DependabotSecurityUpdates{Status: &zeroValue}
	d.GetStatus()
	d = &DependabotSecurityUpdates{}
	d.GetStatus()
	d = nil
	d.GetStatus()
}

func TestDependency_GetManifestPath(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &Dependency{ManifestPath: &zeroValue}
	d.GetManifestPath()
	d = &Dependency{}
	d.GetManifestPath()
	d = nil
	d.GetManifestPath()
}

func TestDependency_GetPackage(tt *testing.T) {
	tt.Parallel()
	d := &Dependency{}
	d.GetPackage()
	d = nil
	d.GetPackage()
}

func TestDependency_GetScope(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &Dependency{Scope: &zeroValue}
	d.GetScope()
	d = &Dependency{}
	d.GetScope()
	d = nil
	d.GetScope()
}

func TestDependencyGraphAutosubmitActionOptions_GetLabeledRunners(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	d := &DependencyGraphAutosubmitActionOptions{LabeledRunners: &zeroValue}
	d.GetLabeledRunners()
	d = &DependencyGraphAutosubmitActionOptions{}
	d.GetLabeledRunners()
	d = nil
	d.GetLabeledRunners()
}

func TestDependencyGraphSnapshot_GetDetector(tt *testing.T) {
	tt.Parallel()
	d := &DependencyGraphSnapshot{}
	d.GetDetector()
	d = nil
	d.GetDetector()
}

func TestDependencyGraphSnapshot_GetJob(tt *testing.T) {
	tt.Parallel()
	d := &DependencyGraphSnapshot{}
	d.GetJob()
	d = nil
	d.GetJob()
}

func TestDependencyGraphSnapshot_GetMetadata(tt *testing.T) {
	tt.Parallel()
	zeroValue := map[string]any{}
	d := &DependencyGraphSnapshot{Metadata: zeroValue}
	d.GetMetadata()
	d = &DependencyGraphSnapshot{}
	d.GetMetadata()
	d = nil
	d.GetMetadata()
}

func TestDependencyGraphSnapshot_GetRef(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DependencyGraphSnapshot{Ref: &zeroValue}
	d.GetRef()
	d = &DependencyGraphSnapshot{}
	d.GetRef()
	d = nil
	d.GetRef()
}

func TestDependencyGraphSnapshot_GetScanned(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	d := &DependencyGraphSnapshot{Scanned: &zeroValue}
	d.GetScanned()
	d = &DependencyGraphSnapshot{}
	d.GetScanned()
	d = nil
	d.GetScanned()
}

func TestDependencyGraphSnapshot_GetSha(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DependencyGraphSnapshot{Sha: &zeroValue}
	d.GetSha()
	d = &DependencyGraphSnapshot{}
	d.GetSha()
	d = nil
	d.GetSha()
}

func TestDependencyGraphSnapshot_GetVersion(tt *testing.T) {
	tt.Parallel()
	d := &DependencyGraphSnapshot{}
	d.GetVersion()
	d = nil
	d.GetVersion()
}

func TestDependencyGraphSnapshotCreationData_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	d := &DependencyGraphSnapshotCreationData{CreatedAt: &zeroValue}
	d.GetCreatedAt()
	d = &DependencyGraphSnapshotCreationData{}
	d.GetCreatedAt()
	d = nil
	d.GetCreatedAt()
}

func TestDependencyGraphSnapshotCreationData_GetID(tt *testing.T) {
	tt.Parallel()
	d := &DependencyGraphSnapshotCreationData{}
	d.GetID()
	d = nil
	d.GetID()
}

func TestDependencyGraphSnapshotCreationData_GetMessage(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DependencyGraphSnapshotCreationData{Message: &zeroValue}
	d.GetMessage()
	d = &DependencyGraphSnapshotCreationData{}
	d.GetMessage()
	d = nil
	d.GetMessage()
}

func TestDependencyGraphSnapshotCreationData_GetResult(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DependencyGraphSnapshotCreationData{Result: &zeroValue}
	d.GetResult()
	d = &DependencyGraphSnapshotCreationData{}
	d.GetResult()
	d = nil
	d.GetResult()
}

func TestDependencyGraphSnapshotDetector_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DependencyGraphSnapshotDetector{Name: &zeroValue}
	d.GetName()
	d = &DependencyGraphSnapshotDetector{}
	d.GetName()
	d = nil
	d.GetName()
}

func TestDependencyGraphSnapshotDetector_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DependencyGraphSnapshotDetector{URL: &zeroValue}
	d.GetURL()
	d = &DependencyGraphSnapshotDetector{}
	d.GetURL()
	d = nil
	d.GetURL()
}

func TestDependencyGraphSnapshotDetector_GetVersion(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DependencyGraphSnapshotDetector{Version: &zeroValue}
	d.GetVersion()
	d = &DependencyGraphSnapshotDetector{}
	d.GetVersion()
	d = nil
	d.GetVersion()
}

func TestDependencyGraphSnapshotJob_GetCorrelator(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DependencyGraphSnapshotJob{Correlator: &zeroValue}
	d.GetCorrelator()
	d = &DependencyGraphSnapshotJob{}
	d.GetCorrelator()
	d = nil
	d.GetCorrelator()
}

func TestDependencyGraphSnapshotJob_GetHTMLURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DependencyGraphSnapshotJob{HTMLURL: &zeroValue}
	d.GetHTMLURL()
	d = &DependencyGraphSnapshotJob{}
	d.GetHTMLURL()
	d = nil
	d.GetHTMLURL()
}

func TestDependencyGraphSnapshotJob_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DependencyGraphSnapshotJob{ID: &zeroValue}
	d.GetID()
	d = &DependencyGraphSnapshotJob{}
	d.GetID()
	d = nil
	d.GetID()
}

func TestDependencyGraphSnapshotManifest_GetFile(tt *testing.T) {
	tt.Parallel()
	d := &DependencyGraphSnapshotManifest{}
	d.GetFile()
	d = nil
	d.GetFile()
}

func TestDependencyGraphSnapshotManifest_GetMetadata(tt *testing.T) {
	tt.Parallel()
	zeroValue := map[string]any{}
	d := &DependencyGraphSnapshotManifest{Metadata: zeroValue}
	d.GetMetadata()
	d = &DependencyGraphSnapshotManifest{}
	d.GetMetadata()
	d = nil
	d.GetMetadata()
}

func TestDependencyGraphSnapshotManifest_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DependencyGraphSnapshotManifest{Name: &zeroValue}
	d.GetName()
	d = &DependencyGraphSnapshotManifest{}
	d.GetName()
	d = nil
	d.GetName()
}

func TestDependencyGraphSnapshotManifestFile_GetSourceLocation(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DependencyGraphSnapshotManifestFile{SourceLocation: &zeroValue}
	d.GetSourceLocation()
	d = &DependencyGraphSnapshotManifestFile{}
	d.GetSourceLocation()
	d = nil
	d.GetSourceLocation()
}

func TestDependencyGraphSnapshotResolvedDependency_GetDependencies(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	d := &DependencyGraphSnapshotResolvedDependency{Dependencies: zeroValue}
	d.GetDependencies()
	d = &DependencyGraphSnapshotResolvedDependency{}
	d.GetDependencies()
	d = nil
	d.GetDependencies()
}

func TestDependencyGraphSnapshotResolvedDependency_GetMetadata(tt *testing.T) {
	tt.Parallel()
	zeroValue := map[string]any{}
	d := &DependencyGraphSnapshotResolvedDependency{Metadata: zeroValue}
	d.GetMetadata()
	d = &DependencyGraphSnapshotResolvedDependency{}
	d.GetMetadata()
	d = nil
	d.GetMetadata()
}

func TestDependencyGraphSnapshotResolvedDependency_GetPackageURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DependencyGraphSnapshotResolvedDependency{PackageURL: &zeroValue}
	d.GetPackageURL()
	d = &DependencyGraphSnapshotResolvedDependency{}
	d.GetPackageURL()
	d = nil
	d.GetPackageURL()
}

func TestDependencyGraphSnapshotResolvedDependency_GetRelationship(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DependencyGraphSnapshotResolvedDependency{Relationship: &zeroValue}
	d.GetRelationship()
	d = &DependencyGraphSnapshotResolvedDependency{}
	d.GetRelationship()
	d = nil
	d.GetRelationship()
}

func TestDependencyGraphSnapshotResolvedDependency_GetScope(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DependencyGraphSnapshotResolvedDependency{Scope: &zeroValue}
	d.GetScope()
	d = &DependencyGraphSnapshotResolvedDependency{}
	d.GetScope()
	d = nil
	d.GetScope()
}

func TestDeployKeyEvent_GetAction(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DeployKeyEvent{Action: &zeroValue}
	d.GetAction()
	d = &DeployKeyEvent{}
	d.GetAction()
	d = nil
	d.GetAction()
}

func TestDeployKeyEvent_GetInstallation(tt *testing.T) {
	tt.Parallel()
	d := &DeployKeyEvent{}
	d.GetInstallation()
	d = nil
	d.GetInstallation()
}

func TestDeployKeyEvent_GetKey(tt *testing.T) {
	tt.Parallel()
	d := &DeployKeyEvent{}
	d.GetKey()
	d = nil
	d.GetKey()
}

func TestDeployKeyEvent_GetOrganization(tt *testing.T) {
	tt.Parallel()
	d := &DeployKeyEvent{}
	d.GetOrganization()
	d = nil
	d.GetOrganization()
}

func TestDeployKeyEvent_GetRepo(tt *testing.T) {
	tt.Parallel()
	d := &DeployKeyEvent{}
	d.GetRepo()
	d = nil
	d.GetRepo()
}

func TestDeployKeyEvent_GetSender(tt *testing.T) {
	tt.Parallel()
	d := &DeployKeyEvent{}
	d.GetSender()
	d = nil
	d.GetSender()
}

func TestDeployment_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	d := &Deployment{CreatedAt: &zeroValue}
	d.GetCreatedAt()
	d = &Deployment{}
	d.GetCreatedAt()
	d = nil
	d.GetCreatedAt()
}

func TestDeployment_GetCreator(tt *testing.T) {
	tt.Parallel()
	d := &Deployment{}
	d.GetCreator()
	d = nil
	d.GetCreator()
}

func TestDeployment_GetDescription(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &Deployment{Description: &zeroValue}
	d.GetDescription()
	d = &Deployment{}
	d.GetDescription()
	d = nil
	d.GetDescription()
}

func TestDeployment_GetEnvironment(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &Deployment{Environment: &zeroValue}
	d.GetEnvironment()
	d = &Deployment{}
	d.GetEnvironment()
	d = nil
	d.GetEnvironment()
}

func TestDeployment_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	d := &Deployment{ID: &zeroValue}
	d.GetID()
	d = &Deployment{}
	d.GetID()
	d = nil
	d.GetID()
}

func TestDeployment_GetNodeID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &Deployment{NodeID: &zeroValue}
	d.GetNodeID()
	d = &Deployment{}
	d.GetNodeID()
	d = nil
	d.GetNodeID()
}

func TestDeployment_GetPayload(tt *testing.T) {
	tt.Parallel()
	d := &Deployment{}
	d.GetPayload()
	d = nil
	d.GetPayload()
}

func TestDeployment_GetRef(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &Deployment{Ref: &zeroValue}
	d.GetRef()
	d = &Deployment{}
	d.GetRef()
	d = nil
	d.GetRef()
}

func TestDeployment_GetRepositoryURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &Deployment{RepositoryURL: &zeroValue}
	d.GetRepositoryURL()
	d = &Deployment{}
	d.GetRepositoryURL()
	d = nil
	d.GetRepositoryURL()
}

func TestDeployment_GetSHA(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &Deployment{SHA: &zeroValue}
	d.GetSHA()
	d = &Deployment{}
	d.GetSHA()
	d = nil
	d.GetSHA()
}

func TestDeployment_GetStatusesURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &Deployment{StatusesURL: &zeroValue}
	d.GetStatusesURL()
	d = &Deployment{}
	d.GetStatusesURL()
	d = nil
	d.GetStatusesURL()
}

func TestDeployment_GetTask(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &Deployment{Task: &zeroValue}
	d.GetTask()
	d = &Deployment{}
	d.GetTask()
	d = nil
	d.GetTask()
}

func TestDeployment_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	d := &Deployment{UpdatedAt: &zeroValue}
	d.GetUpdatedAt()
	d = &Deployment{}
	d.GetUpdatedAt()
	d = nil
	d.GetUpdatedAt()
}

func TestDeployment_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &Deployment{URL: &zeroValue}
	d.GetURL()
	d = &Deployment{}
	d.GetURL()
	d = nil
	d.GetURL()
}

func TestDeploymentBranchPolicy_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	d := &DeploymentBranchPolicy{ID: &zeroValue}
	d.GetID()
	d = &DeploymentBranchPolicy{}
	d.GetID()
	d = nil
	d.GetID()
}

func TestDeploymentBranchPolicy_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DeploymentBranchPolicy{Name: &zeroValue}
	d.GetName()
	d = &DeploymentBranchPolicy{}
	d.GetName()
	d = nil
	d.GetName()
}

func TestDeploymentBranchPolicy_GetNodeID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DeploymentBranchPolicy{NodeID: &zeroValue}
	d.GetNodeID()
	d = &DeploymentBranchPolicy{}
	d.GetNodeID()
	d = nil
	d.GetNodeID()
}

func TestDeploymentBranchPolicy_GetType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DeploymentBranchPolicy{Type: &zeroValue}
	d.GetType()
	d = &DeploymentBranchPolicy{}
	d.GetType()
	d = nil
	d.GetType()
}

func TestDeploymentBranchPolicyResponse_GetBranchPolicies(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*DeploymentBranchPolicy{}
	d := &DeploymentBranchPolicyResponse{BranchPolicies: zeroValue}
	d.GetBranchPolicies()
	d = &DeploymentBranchPolicyResponse{}
	d.GetBranchPolicies()
	d = nil
	d.GetBranchPolicies()
}

func TestDeploymentBranchPolicyResponse_GetTotalCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	d := &DeploymentBranchPolicyResponse{TotalCount: &zeroValue}
	d.GetTotalCount()
	d = &DeploymentBranchPolicyResponse{}
	d.GetTotalCount()
	d = nil
	d.GetTotalCount()
}

func TestDeploymentEvent_GetDeployment(tt *testing.T) {
	tt.Parallel()
	d := &DeploymentEvent{}
	d.GetDeployment()
	d = nil
	d.GetDeployment()
}

func TestDeploymentEvent_GetInstallation(tt *testing.T) {
	tt.Parallel()
	d := &DeploymentEvent{}
	d.GetInstallation()
	d = nil
	d.GetInstallation()
}

func TestDeploymentEvent_GetOrg(tt *testing.T) {
	tt.Parallel()
	d := &DeploymentEvent{}
	d.GetOrg()
	d = nil
	d.GetOrg()
}

func TestDeploymentEvent_GetRepo(tt *testing.T) {
	tt.Parallel()
	d := &DeploymentEvent{}
	d.GetRepo()
	d = nil
	d.GetRepo()
}

func TestDeploymentEvent_GetSender(tt *testing.T) {
	tt.Parallel()
	d := &DeploymentEvent{}
	d.GetSender()
	d = nil
	d.GetSender()
}

func TestDeploymentEvent_GetWorkflow(tt *testing.T) {
	tt.Parallel()
	d := &DeploymentEvent{}
	d.GetWorkflow()
	d = nil
	d.GetWorkflow()
}

func TestDeploymentEvent_GetWorkflowRun(tt *testing.T) {
	tt.Parallel()
	d := &DeploymentEvent{}
	d.GetWorkflowRun()
	d = nil
	d.GetWorkflowRun()
}

func TestDeploymentProtectionRuleEvent_GetAction(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DeploymentProtectionRuleEvent{Action: &zeroValue}
	d.GetAction()
	d = &DeploymentProtectionRuleEvent{}
	d.GetAction()
	d = nil
	d.GetAction()
}

func TestDeploymentProtectionRuleEvent_GetDeployment(tt *testing.T) {
	tt.Parallel()
	d := &DeploymentProtectionRuleEvent{}
	d.GetDeployment()
	d = nil
	d.GetDeployment()
}

func TestDeploymentProtectionRuleEvent_GetDeploymentCallbackURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DeploymentProtectionRuleEvent{DeploymentCallbackURL: &zeroValue}
	d.GetDeploymentCallbackURL()
	d = &DeploymentProtectionRuleEvent{}
	d.GetDeploymentCallbackURL()
	d = nil
	d.GetDeploymentCallbackURL()
}

func TestDeploymentProtectionRuleEvent_GetEnvironment(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DeploymentProtectionRuleEvent{Environment: &zeroValue}
	d.GetEnvironment()
	d = &DeploymentProtectionRuleEvent{}
	d.GetEnvironment()
	d = nil
	d.GetEnvironment()
}

func TestDeploymentProtectionRuleEvent_GetEvent(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DeploymentProtectionRuleEvent{Event: &zeroValue}
	d.GetEvent()
	d = &DeploymentProtectionRuleEvent{}
	d.GetEvent()
	d = nil
	d.GetEvent()
}

func TestDeploymentProtectionRuleEvent_GetInstallation(tt *testing.T) {
	tt.Parallel()
	d := &DeploymentProtectionRuleEvent{}
	d.GetInstallation()
	d = nil
	d.GetInstallation()
}

func TestDeploymentProtectionRuleEvent_GetOrganization(tt *testing.T) {
	tt.Parallel()
	d := &DeploymentProtectionRuleEvent{}
	d.GetOrganization()
	d = nil
	d.GetOrganization()
}

func TestDeploymentProtectionRuleEvent_GetPullRequests(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*PullRequest{}
	d := &DeploymentProtectionRuleEvent{PullRequests: zeroValue}
	d.GetPullRequests()
	d = &DeploymentProtectionRuleEvent{}
	d.GetPullRequests()
	d = nil
	d.GetPullRequests()
}

func TestDeploymentProtectionRuleEvent_GetRepo(tt *testing.T) {
	tt.Parallel()
	d := &DeploymentProtectionRuleEvent{}
	d.GetRepo()
	d = nil
	d.GetRepo()
}

func TestDeploymentProtectionRuleEvent_GetSender(tt *testing.T) {
	tt.Parallel()
	d := &DeploymentProtectionRuleEvent{}
	d.GetSender()
	d = nil
	d.GetSender()
}

func TestDeploymentRequest_GetAutoMerge(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	d := &DeploymentRequest{AutoMerge: &zeroValue}
	d.GetAutoMerge()
	d = &DeploymentRequest{}
	d.GetAutoMerge()
	d = nil
	d.GetAutoMerge()
}

func TestDeploymentRequest_GetDescription(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DeploymentRequest{Description: &zeroValue}
	d.GetDescription()
	d = &DeploymentRequest{}
	d.GetDescription()
	d = nil
	d.GetDescription()
}

func TestDeploymentRequest_GetEnvironment(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DeploymentRequest{Environment: &zeroValue}
	d.GetEnvironment()
	d = &DeploymentRequest{}
	d.GetEnvironment()
	d = nil
	d.GetEnvironment()
}

func TestDeploymentRequest_GetPayload(tt *testing.T) {
	tt.Parallel()
	d := &DeploymentRequest{}
	d.GetPayload()
	d = nil
	d.GetPayload()
}

func TestDeploymentRequest_GetProductionEnvironment(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	d := &DeploymentRequest{ProductionEnvironment: &zeroValue}
	d.GetProductionEnvironment()
	d = &DeploymentRequest{}
	d.GetProductionEnvironment()
	d = nil
	d.GetProductionEnvironment()
}

func TestDeploymentRequest_GetRef(tt *testing.T) {
	tt.Parallel()
	d := &DeploymentRequest{}
	d.GetRef()
	d = nil
	d.GetRef()
}

func TestDeploymentRequest_GetRequiredContexts(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	d := &DeploymentRequest{RequiredContexts: zeroValue}
	d.GetRequiredContexts()
	d = &DeploymentRequest{}
	d.GetRequiredContexts()
	d = nil
	d.GetRequiredContexts()
}

func TestDeploymentRequest_GetTask(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DeploymentRequest{Task: &zeroValue}
	d.GetTask()
	d = &DeploymentRequest{}
	d.GetTask()
	d = nil
	d.GetTask()
}

func TestDeploymentRequest_GetTransientEnvironment(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	d := &DeploymentRequest{TransientEnvironment: &zeroValue}
	d.GetTransientEnvironment()
	d = &DeploymentRequest{}
	d.GetTransientEnvironment()
	d = nil
	d.GetTransientEnvironment()
}

func TestDeploymentReviewEvent_GetAction(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DeploymentReviewEvent{Action: &zeroValue}
	d.GetAction()
	d = &DeploymentReviewEvent{}
	d.GetAction()
	d = nil
	d.GetAction()
}

func TestDeploymentReviewEvent_GetApprover(tt *testing.T) {
	tt.Parallel()
	d := &DeploymentReviewEvent{}
	d.GetApprover()
	d = nil
	d.GetApprover()
}

func TestDeploymentReviewEvent_GetComment(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DeploymentReviewEvent{Comment: &zeroValue}
	d.GetComment()
	d = &DeploymentReviewEvent{}
	d.GetComment()
	d = nil
	d.GetComment()
}

func TestDeploymentReviewEvent_GetEnterprise(tt *testing.T) {
	tt.Parallel()
	d := &DeploymentReviewEvent{}
	d.GetEnterprise()
	d = nil
	d.GetEnterprise()
}

func TestDeploymentReviewEvent_GetEnvironment(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DeploymentReviewEvent{Environment: &zeroValue}
	d.GetEnvironment()
	d = &DeploymentReviewEvent{}
	d.GetEnvironment()
	d = nil
	d.GetEnvironment()
}

func TestDeploymentReviewEvent_GetInstallation(tt *testing.T) {
	tt.Parallel()
	d := &DeploymentReviewEvent{}
	d.GetInstallation()
	d = nil
	d.GetInstallation()
}

func TestDeploymentReviewEvent_GetOrganization(tt *testing.T) {
	tt.Parallel()
	d := &DeploymentReviewEvent{}
	d.GetOrganization()
	d = nil
	d.GetOrganization()
}

func TestDeploymentReviewEvent_GetRepo(tt *testing.T) {
	tt.Parallel()
	d := &DeploymentReviewEvent{}
	d.GetRepo()
	d = nil
	d.GetRepo()
}

func TestDeploymentReviewEvent_GetRequester(tt *testing.T) {
	tt.Parallel()
	d := &DeploymentReviewEvent{}
	d.GetRequester()
	d = nil
	d.GetRequester()
}

func TestDeploymentReviewEvent_GetReviewers(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*RequiredReviewer{}
	d := &DeploymentReviewEvent{Reviewers: zeroValue}
	d.GetReviewers()
	d = &DeploymentReviewEvent{}
	d.GetReviewers()
	d = nil
	d.GetReviewers()
}

func TestDeploymentReviewEvent_GetSender(tt *testing.T) {
	tt.Parallel()
	d := &DeploymentReviewEvent{}
	d.GetSender()
	d = nil
	d.GetSender()
}

func TestDeploymentReviewEvent_GetSince(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DeploymentReviewEvent{Since: &zeroValue}
	d.GetSince()
	d = &DeploymentReviewEvent{}
	d.GetSince()
	d = nil
	d.GetSince()
}

func TestDeploymentReviewEvent_GetWorkflowJobRun(tt *testing.T) {
	tt.Parallel()
	d := &DeploymentReviewEvent{}
	d.GetWorkflowJobRun()
	d = nil
	d.GetWorkflowJobRun()
}

func TestDeploymentReviewEvent_GetWorkflowJobRuns(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*WorkflowJobRun{}
	d := &DeploymentReviewEvent{WorkflowJobRuns: zeroValue}
	d.GetWorkflowJobRuns()
	d = &DeploymentReviewEvent{}
	d.GetWorkflowJobRuns()
	d = nil
	d.GetWorkflowJobRuns()
}

func TestDeploymentReviewEvent_GetWorkflowRun(tt *testing.T) {
	tt.Parallel()
	d := &DeploymentReviewEvent{}
	d.GetWorkflowRun()
	d = nil
	d.GetWorkflowRun()
}

func TestDeploymentsListOptions_GetEnvironment(tt *testing.T) {
	tt.Parallel()
	d := &DeploymentsListOptions{}
	d.GetEnvironment()
	d = nil
	d.GetEnvironment()
}

func TestDeploymentsListOptions_GetRef(tt *testing.T) {
	tt.Parallel()
	d := &DeploymentsListOptions{}
	d.GetRef()
	d = nil
	d.GetRef()
}

func TestDeploymentsListOptions_GetSHA(tt *testing.T) {
	tt.Parallel()
	d := &DeploymentsListOptions{}
	d.GetSHA()
	d = nil
	d.GetSHA()
}

func TestDeploymentsListOptions_GetTask(tt *testing.T) {
	tt.Parallel()
	d := &DeploymentsListOptions{}
	d.GetTask()
	d = nil
	d.GetTask()
}

func TestDeploymentStatus_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	d := &DeploymentStatus{CreatedAt: &zeroValue}
	d.GetCreatedAt()
	d = &DeploymentStatus{}
	d.GetCreatedAt()
	d = nil
	d.GetCreatedAt()
}

func TestDeploymentStatus_GetCreator(tt *testing.T) {
	tt.Parallel()
	d := &DeploymentStatus{}
	d.GetCreator()
	d = nil
	d.GetCreator()
}

func TestDeploymentStatus_GetDeploymentURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DeploymentStatus{DeploymentURL: &zeroValue}
	d.GetDeploymentURL()
	d = &DeploymentStatus{}
	d.GetDeploymentURL()
	d = nil
	d.GetDeploymentURL()
}

func TestDeploymentStatus_GetDescription(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DeploymentStatus{Description: &zeroValue}
	d.GetDescription()
	d = &DeploymentStatus{}
	d.GetDescription()
	d = nil
	d.GetDescription()
}

func TestDeploymentStatus_GetEnvironment(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DeploymentStatus{Environment: &zeroValue}
	d.GetEnvironment()
	d = &DeploymentStatus{}
	d.GetEnvironment()
	d = nil
	d.GetEnvironment()
}

func TestDeploymentStatus_GetEnvironmentURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DeploymentStatus{EnvironmentURL: &zeroValue}
	d.GetEnvironmentURL()
	d = &DeploymentStatus{}
	d.GetEnvironmentURL()
	d = nil
	d.GetEnvironmentURL()
}

func TestDeploymentStatus_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	d := &DeploymentStatus{ID: &zeroValue}
	d.GetID()
	d = &DeploymentStatus{}
	d.GetID()
	d = nil
	d.GetID()
}

func TestDeploymentStatus_GetLogURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DeploymentStatus{LogURL: &zeroValue}
	d.GetLogURL()
	d = &DeploymentStatus{}
	d.GetLogURL()
	d = nil
	d.GetLogURL()
}

func TestDeploymentStatus_GetNodeID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DeploymentStatus{NodeID: &zeroValue}
	d.GetNodeID()
	d = &DeploymentStatus{}
	d.GetNodeID()
	d = nil
	d.GetNodeID()
}

func TestDeploymentStatus_GetRepositoryURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DeploymentStatus{RepositoryURL: &zeroValue}
	d.GetRepositoryURL()
	d = &DeploymentStatus{}
	d.GetRepositoryURL()
	d = nil
	d.GetRepositoryURL()
}

func TestDeploymentStatus_GetState(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DeploymentStatus{State: &zeroValue}
	d.GetState()
	d = &DeploymentStatus{}
	d.GetState()
	d = nil
	d.GetState()
}

func TestDeploymentStatus_GetTargetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DeploymentStatus{TargetURL: &zeroValue}
	d.GetTargetURL()
	d = &DeploymentStatus{}
	d.GetTargetURL()
	d = nil
	d.GetTargetURL()
}

func TestDeploymentStatus_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	d := &DeploymentStatus{UpdatedAt: &zeroValue}
	d.GetUpdatedAt()
	d = &DeploymentStatus{}
	d.GetUpdatedAt()
	d = nil
	d.GetUpdatedAt()
}

func TestDeploymentStatus_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DeploymentStatus{URL: &zeroValue}
	d.GetURL()
	d = &DeploymentStatus{}
	d.GetURL()
	d = nil
	d.GetURL()
}

func TestDeploymentStatusEvent_GetAction(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DeploymentStatusEvent{Action: &zeroValue}
	d.GetAction()
	d = &DeploymentStatusEvent{}
	d.GetAction()
	d = nil
	d.GetAction()
}

func TestDeploymentStatusEvent_GetDeployment(tt *testing.T) {
	tt.Parallel()
	d := &DeploymentStatusEvent{}
	d.GetDeployment()
	d = nil
	d.GetDeployment()
}

func TestDeploymentStatusEvent_GetDeploymentStatus(tt *testing.T) {
	tt.Parallel()
	d := &DeploymentStatusEvent{}
	d.GetDeploymentStatus()
	d = nil
	d.GetDeploymentStatus()
}

func TestDeploymentStatusEvent_GetInstallation(tt *testing.T) {
	tt.Parallel()
	d := &DeploymentStatusEvent{}
	d.GetInstallation()
	d = nil
	d.GetInstallation()
}

func TestDeploymentStatusEvent_GetOrg(tt *testing.T) {
	tt.Parallel()
	d := &DeploymentStatusEvent{}
	d.GetOrg()
	d = nil
	d.GetOrg()
}

func TestDeploymentStatusEvent_GetRepo(tt *testing.T) {
	tt.Parallel()
	d := &DeploymentStatusEvent{}
	d.GetRepo()
	d = nil
	d.GetRepo()
}

func TestDeploymentStatusEvent_GetSender(tt *testing.T) {
	tt.Parallel()
	d := &DeploymentStatusEvent{}
	d.GetSender()
	d = nil
	d.GetSender()
}

func TestDeploymentStatusRequest_GetAutoInactive(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	d := &DeploymentStatusRequest{AutoInactive: &zeroValue}
	d.GetAutoInactive()
	d = &DeploymentStatusRequest{}
	d.GetAutoInactive()
	d = nil
	d.GetAutoInactive()
}

func TestDeploymentStatusRequest_GetDescription(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DeploymentStatusRequest{Description: &zeroValue}
	d.GetDescription()
	d = &DeploymentStatusRequest{}
	d.GetDescription()
	d = nil
	d.GetDescription()
}

func TestDeploymentStatusRequest_GetEnvironment(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DeploymentStatusRequest{Environment: &zeroValue}
	d.GetEnvironment()
	d = &DeploymentStatusRequest{}
	d.GetEnvironment()
	d = nil
	d.GetEnvironment()
}

func TestDeploymentStatusRequest_GetEnvironmentURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DeploymentStatusRequest{EnvironmentURL: &zeroValue}
	d.GetEnvironmentURL()
	d = &DeploymentStatusRequest{}
	d.GetEnvironmentURL()
	d = nil
	d.GetEnvironmentURL()
}

func TestDeploymentStatusRequest_GetLogURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DeploymentStatusRequest{LogURL: &zeroValue}
	d.GetLogURL()
	d = &DeploymentStatusRequest{}
	d.GetLogURL()
	d = nil
	d.GetLogURL()
}

func TestDeploymentStatusRequest_GetState(tt *testing.T) {
	tt.Parallel()
	d := &DeploymentStatusRequest{}
	d.GetState()
	d = nil
	d.GetState()
}

func TestDeploymentStatusRequest_GetTargetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DeploymentStatusRequest{TargetURL: &zeroValue}
	d.GetTargetURL()
	d = &DeploymentStatusRequest{}
	d.GetTargetURL()
	d = nil
	d.GetTargetURL()
}

func TestDevContainer_GetDisplayName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DevContainer{DisplayName: &zeroValue}
	d.GetDisplayName()
	d = &DevContainer{}
	d.GetDisplayName()
	d = nil
	d.GetDisplayName()
}

func TestDevContainer_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DevContainer{Name: &zeroValue}
	d.GetName()
	d = &DevContainer{}
	d.GetName()
	d = nil
	d.GetName()
}

func TestDevContainer_GetPath(tt *testing.T) {
	tt.Parallel()
	d := &DevContainer{}
	d.GetPath()
	d = nil
	d.GetPath()
}

func TestDevContainerConfigurations_GetDevcontainers(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*DevContainer{}
	d := &DevContainerConfigurations{Devcontainers: zeroValue}
	d.GetDevcontainers()
	d = &DevContainerConfigurations{}
	d.GetDevcontainers()
	d = nil
	d.GetDevcontainers()
}

func TestDevContainerConfigurations_GetTotalCount(tt *testing.T) {
	tt.Parallel()
	d := &DevContainerConfigurations{}
	d.GetTotalCount()
	d = nil
	d.GetTotalCount()
}

func TestDiscussion_GetActiveLockReason(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &Discussion{ActiveLockReason: &zeroValue}
	d.GetActiveLockReason()
	d = &Discussion{}
	d.GetActiveLockReason()
	d = nil
	d.GetActiveLockReason()
}

func TestDiscussion_GetAnswerChosenAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	d := &Discussion{AnswerChosenAt: &zeroValue}
	d.GetAnswerChosenAt()
	d = &Discussion{}
	d.GetAnswerChosenAt()
	d = nil
	d.GetAnswerChosenAt()
}

func TestDiscussion_GetAnswerChosenBy(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &Discussion{AnswerChosenBy: &zeroValue}
	d.GetAnswerChosenBy()
	d = &Discussion{}
	d.GetAnswerChosenBy()
	d = nil
	d.GetAnswerChosenBy()
}

func TestDiscussion_GetAnswerHTMLURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &Discussion{AnswerHTMLURL: &zeroValue}
	d.GetAnswerHTMLURL()
	d = &Discussion{}
	d.GetAnswerHTMLURL()
	d = nil
	d.GetAnswerHTMLURL()
}

func TestDiscussion_GetAuthorAssociation(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &Discussion{AuthorAssociation: &zeroValue}
	d.GetAuthorAssociation()
	d = &Discussion{}
	d.GetAuthorAssociation()
	d = nil
	d.GetAuthorAssociation()
}

func TestDiscussion_GetBody(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &Discussion{Body: &zeroValue}
	d.GetBody()
	d = &Discussion{}
	d.GetBody()
	d = nil
	d.GetBody()
}

func TestDiscussion_GetComments(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	d := &Discussion{Comments: &zeroValue}
	d.GetComments()
	d = &Discussion{}
	d.GetComments()
	d = nil
	d.GetComments()
}

func TestDiscussion_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	d := &Discussion{CreatedAt: &zeroValue}
	d.GetCreatedAt()
	d = &Discussion{}
	d.GetCreatedAt()
	d = nil
	d.GetCreatedAt()
}

func TestDiscussion_GetDiscussionCategory(tt *testing.T) {
	tt.Parallel()
	d := &Discussion{}
	d.GetDiscussionCategory()
	d = nil
	d.GetDiscussionCategory()
}

func TestDiscussion_GetHTMLURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &Discussion{HTMLURL: &zeroValue}
	d.GetHTMLURL()
	d = &Discussion{}
	d.GetHTMLURL()
	d = nil
	d.GetHTMLURL()
}

func TestDiscussion_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	d := &Discussion{ID: &zeroValue}
	d.GetID()
	d = &Discussion{}
	d.GetID()
	d = nil
	d.GetID()
}

func TestDiscussion_GetLocked(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	d := &Discussion{Locked: &zeroValue}
	d.GetLocked()
	d = &Discussion{}
	d.GetLocked()
	d = nil
	d.GetLocked()
}

func TestDiscussion_GetNodeID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &Discussion{NodeID: &zeroValue}
	d.GetNodeID()
	d = &Discussion{}
	d.GetNodeID()
	d = nil
	d.GetNodeID()
}

func TestDiscussion_GetNumber(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	d := &Discussion{Number: &zeroValue}
	d.GetNumber()
	d = &Discussion{}
	d.GetNumber()
	d = nil
	d.GetNumber()
}

func TestDiscussion_GetRepositoryURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &Discussion{RepositoryURL: &zeroValue}
	d.GetRepositoryURL()
	d = &Discussion{}
	d.GetRepositoryURL()
	d = nil
	d.GetRepositoryURL()
}

func TestDiscussion_GetState(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &Discussion{State: &zeroValue}
	d.GetState()
	d = &Discussion{}
	d.GetState()
	d = nil
	d.GetState()
}

func TestDiscussion_GetTitle(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &Discussion{Title: &zeroValue}
	d.GetTitle()
	d = &Discussion{}
	d.GetTitle()
	d = nil
	d.GetTitle()
}

func TestDiscussion_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	d := &Discussion{UpdatedAt: &zeroValue}
	d.GetUpdatedAt()
	d = &Discussion{}
	d.GetUpdatedAt()
	d = nil
	d.GetUpdatedAt()
}

func TestDiscussion_GetUser(tt *testing.T) {
	tt.Parallel()
	d := &Discussion{}
	d.GetUser()
	d = nil
	d.GetUser()
}

func TestDiscussionCategory_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	d := &DiscussionCategory{CreatedAt: &zeroValue}
	d.GetCreatedAt()
	d = &DiscussionCategory{}
	d.GetCreatedAt()
	d = nil
	d.GetCreatedAt()
}

func TestDiscussionCategory_GetDescription(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DiscussionCategory{Description: &zeroValue}
	d.GetDescription()
	d = &DiscussionCategory{}
	d.GetDescription()
	d = nil
	d.GetDescription()
}

func TestDiscussionCategory_GetEmoji(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DiscussionCategory{Emoji: &zeroValue}
	d.GetEmoji()
	d = &DiscussionCategory{}
	d.GetEmoji()
	d = nil
	d.GetEmoji()
}

func TestDiscussionCategory_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	d := &DiscussionCategory{ID: &zeroValue}
	d.GetID()
	d = &DiscussionCategory{}
	d.GetID()
	d = nil
	d.GetID()
}

func TestDiscussionCategory_GetIsAnswerable(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	d := &DiscussionCategory{IsAnswerable: &zeroValue}
	d.GetIsAnswerable()
	d = &DiscussionCategory{}
	d.GetIsAnswerable()
	d = nil
	d.GetIsAnswerable()
}

func TestDiscussionCategory_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DiscussionCategory{Name: &zeroValue}
	d.GetName()
	d = &DiscussionCategory{}
	d.GetName()
	d = nil
	d.GetName()
}

func TestDiscussionCategory_GetNodeID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DiscussionCategory{NodeID: &zeroValue}
	d.GetNodeID()
	d = &DiscussionCategory{}
	d.GetNodeID()
	d = nil
	d.GetNodeID()
}

func TestDiscussionCategory_GetRepositoryID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	d := &DiscussionCategory{RepositoryID: &zeroValue}
	d.GetRepositoryID()
	d = &DiscussionCategory{}
	d.GetRepositoryID()
	d = nil
	d.GetRepositoryID()
}

func TestDiscussionCategory_GetSlug(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DiscussionCategory{Slug: &zeroValue}
	d.GetSlug()
	d = &DiscussionCategory{}
	d.GetSlug()
	d = nil
	d.GetSlug()
}

func TestDiscussionCategory_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	d := &DiscussionCategory{UpdatedAt: &zeroValue}
	d.GetUpdatedAt()
	d = &DiscussionCategory{}
	d.GetUpdatedAt()
	d = nil
	d.GetUpdatedAt()
}

func TestDiscussionComment_GetAuthor(tt *testing.T) {
	tt.Parallel()
	d := &DiscussionComment{}
	d.GetAuthor()
	d = nil
	d.GetAuthor()
}

func TestDiscussionComment_GetBody(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DiscussionComment{Body: &zeroValue}
	d.GetBody()
	d = &DiscussionComment{}
	d.GetBody()
	d = nil
	d.GetBody()
}

func TestDiscussionComment_GetBodyHTML(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DiscussionComment{BodyHTML: &zeroValue}
	d.GetBodyHTML()
	d = &DiscussionComment{}
	d.GetBodyHTML()
	d = nil
	d.GetBodyHTML()
}

func TestDiscussionComment_GetBodyVersion(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DiscussionComment{BodyVersion: &zeroValue}
	d.GetBodyVersion()
	d = &DiscussionComment{}
	d.GetBodyVersion()
	d = nil
	d.GetBodyVersion()
}

func TestDiscussionComment_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	d := &DiscussionComment{CreatedAt: &zeroValue}
	d.GetCreatedAt()
	d = &DiscussionComment{}
	d.GetCreatedAt()
	d = nil
	d.GetCreatedAt()
}

func TestDiscussionComment_GetDiscussionURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DiscussionComment{DiscussionURL: &zeroValue}
	d.GetDiscussionURL()
	d = &DiscussionComment{}
	d.GetDiscussionURL()
	d = nil
	d.GetDiscussionURL()
}

func TestDiscussionComment_GetHTMLURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DiscussionComment{HTMLURL: &zeroValue}
	d.GetHTMLURL()
	d = &DiscussionComment{}
	d.GetHTMLURL()
	d = nil
	d.GetHTMLURL()
}

func TestDiscussionComment_GetLastEditedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	d := &DiscussionComment{LastEditedAt: &zeroValue}
	d.GetLastEditedAt()
	d = &DiscussionComment{}
	d.GetLastEditedAt()
	d = nil
	d.GetLastEditedAt()
}

func TestDiscussionComment_GetNodeID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DiscussionComment{NodeID: &zeroValue}
	d.GetNodeID()
	d = &DiscussionComment{}
	d.GetNodeID()
	d = nil
	d.GetNodeID()
}

func TestDiscussionComment_GetNumber(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	d := &DiscussionComment{Number: &zeroValue}
	d.GetNumber()
	d = &DiscussionComment{}
	d.GetNumber()
	d = nil
	d.GetNumber()
}

func TestDiscussionComment_GetReactions(tt *testing.T) {
	tt.Parallel()
	d := &DiscussionComment{}
	d.GetReactions()
	d = nil
	d.GetReactions()
}

func TestDiscussionComment_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	d := &DiscussionComment{UpdatedAt: &zeroValue}
	d.GetUpdatedAt()
	d = &DiscussionComment{}
	d.GetUpdatedAt()
	d = nil
	d.GetUpdatedAt()
}

func TestDiscussionComment_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DiscussionComment{URL: &zeroValue}
	d.GetURL()
	d = &DiscussionComment{}
	d.GetURL()
	d = nil
	d.GetURL()
}

func TestDiscussionCommentEvent_GetAction(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DiscussionCommentEvent{Action: &zeroValue}
	d.GetAction()
	d = &DiscussionCommentEvent{}
	d.GetAction()
	d = nil
	d.GetAction()
}

func TestDiscussionCommentEvent_GetComment(tt *testing.T) {
	tt.Parallel()
	d := &DiscussionCommentEvent{}
	d.GetComment()
	d = nil
	d.GetComment()
}

func TestDiscussionCommentEvent_GetDiscussion(tt *testing.T) {
	tt.Parallel()
	d := &DiscussionCommentEvent{}
	d.GetDiscussion()
	d = nil
	d.GetDiscussion()
}

func TestDiscussionCommentEvent_GetInstallation(tt *testing.T) {
	tt.Parallel()
	d := &DiscussionCommentEvent{}
	d.GetInstallation()
	d = nil
	d.GetInstallation()
}

func TestDiscussionCommentEvent_GetOrg(tt *testing.T) {
	tt.Parallel()
	d := &DiscussionCommentEvent{}
	d.GetOrg()
	d = nil
	d.GetOrg()
}

func TestDiscussionCommentEvent_GetRepo(tt *testing.T) {
	tt.Parallel()
	d := &DiscussionCommentEvent{}
	d.GetRepo()
	d = nil
	d.GetRepo()
}

func TestDiscussionCommentEvent_GetSender(tt *testing.T) {
	tt.Parallel()
	d := &DiscussionCommentEvent{}
	d.GetSender()
	d = nil
	d.GetSender()
}

func TestDiscussionCommentListOptions_GetDirection(tt *testing.T) {
	tt.Parallel()
	d := &DiscussionCommentListOptions{}
	d.GetDirection()
	d = nil
	d.GetDirection()
}

func TestDiscussionEvent_GetAction(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DiscussionEvent{Action: &zeroValue}
	d.GetAction()
	d = &DiscussionEvent{}
	d.GetAction()
	d = nil
	d.GetAction()
}

func TestDiscussionEvent_GetDiscussion(tt *testing.T) {
	tt.Parallel()
	d := &DiscussionEvent{}
	d.GetDiscussion()
	d = nil
	d.GetDiscussion()
}

func TestDiscussionEvent_GetInstallation(tt *testing.T) {
	tt.Parallel()
	d := &DiscussionEvent{}
	d.GetInstallation()
	d = nil
	d.GetInstallation()
}

func TestDiscussionEvent_GetOrg(tt *testing.T) {
	tt.Parallel()
	d := &DiscussionEvent{}
	d.GetOrg()
	d = nil
	d.GetOrg()
}

func TestDiscussionEvent_GetRepo(tt *testing.T) {
	tt.Parallel()
	d := &DiscussionEvent{}
	d.GetRepo()
	d = nil
	d.GetRepo()
}

func TestDiscussionEvent_GetSender(tt *testing.T) {
	tt.Parallel()
	d := &DiscussionEvent{}
	d.GetSender()
	d = nil
	d.GetSender()
}

func TestDiscussionListOptions_GetDirection(tt *testing.T) {
	tt.Parallel()
	d := &DiscussionListOptions{}
	d.GetDirection()
	d = nil
	d.GetDirection()
}

func TestDismissalRestrictions_GetApps(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*App{}
	d := &DismissalRestrictions{Apps: zeroValue}
	d.GetApps()
	d = &DismissalRestrictions{}
	d.GetApps()
	d = nil
	d.GetApps()
}

func TestDismissalRestrictions_GetTeams(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*Team{}
	d := &DismissalRestrictions{Teams: zeroValue}
	d.GetTeams()
	d = &DismissalRestrictions{}
	d.GetTeams()
	d = nil
	d.GetTeams()
}

func TestDismissalRestrictions_GetUsers(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*User{}
	d := &DismissalRestrictions{Users: zeroValue}
	d.GetUsers()
	d = &DismissalRestrictions{}
	d.GetUsers()
	d = nil
	d.GetUsers()
}

func TestDismissalRestrictionsRequest_GetApps(tt *testing.T) {
	tt.Parallel()
	var zeroValue []string
	d := &DismissalRestrictionsRequest{Apps: &zeroValue}
	d.GetApps()
	d = &DismissalRestrictionsRequest{}
	d.GetApps()
	d = nil
	d.GetApps()
}

func TestDismissalRestrictionsRequest_GetTeams(tt *testing.T) {
	tt.Parallel()
	var zeroValue []string
	d := &DismissalRestrictionsRequest{Teams: &zeroValue}
	d.GetTeams()
	d = &DismissalRestrictionsRequest{}
	d.GetTeams()
	d = nil
	d.GetTeams()
}

func TestDismissalRestrictionsRequest_GetUsers(tt *testing.T) {
	tt.Parallel()
	var zeroValue []string
	d := &DismissalRestrictionsRequest{Users: &zeroValue}
	d.GetUsers()
	d = &DismissalRestrictionsRequest{}
	d.GetUsers()
	d = nil
	d.GetUsers()
}

func TestDismissedReview_GetDismissalCommitID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DismissedReview{DismissalCommitID: &zeroValue}
	d.GetDismissalCommitID()
	d = &DismissedReview{}
	d.GetDismissalCommitID()
	d = nil
	d.GetDismissalCommitID()
}

func TestDismissedReview_GetDismissalMessage(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DismissedReview{DismissalMessage: &zeroValue}
	d.GetDismissalMessage()
	d = &DismissedReview{}
	d.GetDismissalMessage()
	d = nil
	d.GetDismissalMessage()
}

func TestDismissedReview_GetReviewID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	d := &DismissedReview{ReviewID: &zeroValue}
	d.GetReviewID()
	d = &DismissedReview{}
	d.GetReviewID()
	d = nil
	d.GetReviewID()
}

func TestDismissedReview_GetState(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DismissedReview{State: &zeroValue}
	d.GetState()
	d = &DismissedReview{}
	d.GetState()
	d = nil
	d.GetState()
}

func TestDismissStaleReviewsOnPushChanges_GetFrom(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	d := &DismissStaleReviewsOnPushChanges{From: &zeroValue}
	d.GetFrom()
	d = &DismissStaleReviewsOnPushChanges{}
	d.GetFrom()
	d = nil
	d.GetFrom()
}

func TestDispatchRequestOptions_GetClientPayload(tt *testing.T) {
	tt.Parallel()
	var zeroValue json.RawMessage
	d := &DispatchRequestOptions{ClientPayload: &zeroValue}
	d.GetClientPayload()
	d = &DispatchRequestOptions{}
	d.GetClientPayload()
	d = nil
	d.GetClientPayload()
}

func TestDispatchRequestOptions_GetEventType(tt *testing.T) {
	tt.Parallel()
	d := &DispatchRequestOptions{}
	d.GetEventType()
	d = nil
	d.GetEventType()
}

func TestDraftReviewComment_GetBody(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DraftReviewComment{Body: &zeroValue}
	d.GetBody()
	d = &DraftReviewComment{}
	d.GetBody()
	d = nil
	d.GetBody()
}

func TestDraftReviewComment_GetLine(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	d := &DraftReviewComment{Line: &zeroValue}
	d.GetLine()
	d = &DraftReviewComment{}
	d.GetLine()
	d = nil
	d.GetLine()
}

func TestDraftReviewComment_GetPath(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DraftReviewComment{Path: &zeroValue}
	d.GetPath()
	d = &DraftReviewComment{}
	d.GetPath()
	d = nil
	d.GetPath()
}

func TestDraftReviewComment_GetPosition(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	d := &DraftReviewComment{Position: &zeroValue}
	d.GetPosition()
	d = &DraftReviewComment{}
	d.GetPosition()
	d = nil
	d.GetPosition()
}

func TestDraftReviewComment_GetSide(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DraftReviewComment{Side: &zeroValue}
	d.GetSide()
	d = &DraftReviewComment{}
	d.GetSide()
	d = nil
	d.GetSide()
}

func TestDraftReviewComment_GetStartLine(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	d := &DraftReviewComment{StartLine: &zeroValue}
	d.GetStartLine()
	d = &DraftReviewComment{}
	d.GetStartLine()
	d = nil
	d.GetStartLine()
}

func TestDraftReviewComment_GetStartSide(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	d := &DraftReviewComment{StartSide: &zeroValue}
	d.GetStartSide()
	d = &DraftReviewComment{}
	d.GetStartSide()
	d = nil
	d.GetStartSide()
}

func TestEditBase_GetRef(tt *testing.T) {
	tt.Parallel()
	e := &EditBase{}
	e.GetRef()
	e = nil
	e.GetRef()
}

func TestEditBase_GetSHA(tt *testing.T) {
	tt.Parallel()
	e := &EditBase{}
	e.GetSHA()
	e = nil
	e.GetSHA()
}

func TestEditBody_GetFrom(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	e := &EditBody{From: &zeroValue}
	e.GetFrom()
	e = &EditBody{}
	e.GetFrom()
	e = nil
	e.GetFrom()
}

func TestEditChange_GetBase(tt *testing.T) {
	tt.Parallel()
	e := &EditChange{}
	e.GetBase()
	e = nil
	e.GetBase()
}

func TestEditChange_GetBody(tt *testing.T) {
	tt.Parallel()
	e := &EditChange{}
	e.GetBody()
	e = nil
	e.GetBody()
}

func TestEditChange_GetDefaultBranch(tt *testing.T) {
	tt.Parallel()
	e := &EditChange{}
	e.GetDefaultBranch()
	e = nil
	e.GetDefaultBranch()
}

func TestEditChange_GetOwner(tt *testing.T) {
	tt.Parallel()
	e := &EditChange{}
	e.GetOwner()
	e = nil
	e.GetOwner()
}

func TestEditChange_GetRepo(tt *testing.T) {
	tt.Parallel()
	e := &EditChange{}
	e.GetRepo()
	e = nil
	e.GetRepo()
}

func TestEditChange_GetTitle(tt *testing.T) {
	tt.Parallel()
	e := &EditChange{}
	e.GetTitle()
	e = nil
	e.GetTitle()
}

func TestEditChange_GetTopics(tt *testing.T) {
	tt.Parallel()
	e := &EditChange{}
	e.GetTopics()
	e = nil
	e.GetTopics()
}

func TestEditDefaultBranch_GetFrom(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	e := &EditDefaultBranch{From: &zeroValue}
	e.GetFrom()
	e = &EditDefaultBranch{}
	e.GetFrom()
	e = nil
	e.GetFrom()
}

func TestEditOwner_GetOwnerInfo(tt *testing.T) {
	tt.Parallel()
	e := &EditOwner{}
	e.GetOwnerInfo()
	e = nil
	e.GetOwnerInfo()
}

func TestEditRef_GetFrom(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	e := &EditRef{From: &zeroValue}
	e.GetFrom()
	e = &EditRef{}
	e.GetFrom()
	e = nil
	e.GetFrom()
}

func TestEditRepo_GetName(tt *testing.T) {
	tt.Parallel()
	e := &EditRepo{}
	e.GetName()
	e = nil
	e.GetName()
}

func TestEditSHA_GetFrom(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	e := &EditSHA{From: &zeroValue}
	e.GetFrom()
	e = &EditSHA{}
	e.GetFrom()
	e = nil
	e.GetFrom()
}

func TestEditTitle_GetFrom(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	e := &EditTitle{From: &zeroValue}
	e.GetFrom()
	e = &EditTitle{}
	e.GetFrom()
	e = nil
	e.GetFrom()
}

func TestEditTopics_GetFrom(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	e := &EditTopics{From: zeroValue}
	e.GetFrom()
	e = &EditTopics{}
	e.GetFrom()
	e = nil
	e.GetFrom()
}

func TestEncryptedSecret_GetEncryptedValue(tt *testing.T) {
	tt.Parallel()
	e := &EncryptedSecret{}
	e.GetEncryptedValue()
	e = nil
	e.GetEncryptedValue()
}

func TestEncryptedSecret_GetKeyID(tt *testing.T) {
	tt.Parallel()
	e := &EncryptedSecret{}
	e.GetKeyID()
	e = nil
	e.GetKeyID()
}

func TestEncryptedSecret_GetName(tt *testing.T) {
	tt.Parallel()
	e := &EncryptedSecret{}
	e.GetName()
	e = nil
	e.GetName()
}

func TestEncryptedSecret_GetSelectedRepositoryIDs(tt *testing.T) {
	tt.Parallel()
	e := &EncryptedSecret{}
	e.GetSelectedRepositoryIDs()
	e = nil
	e.GetSelectedRepositoryIDs()
}

func TestEncryptedSecret_GetVisibility(tt *testing.T) {
	tt.Parallel()
	e := &EncryptedSecret{}
	e.GetVisibility()
	e = nil
	e.GetVisibility()
}

func TestEnterprise_GetAvatarURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	e := &Enterprise{AvatarURL: &zeroValue}
	e.GetAvatarURL()
	e = &Enterprise{}
	e.GetAvatarURL()
	e = nil
	e.GetAvatarURL()
}

func TestEnterprise_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	e := &Enterprise{CreatedAt: &zeroValue}
	e.GetCreatedAt()
	e = &Enterprise{}
	e.GetCreatedAt()
	e = nil
	e.GetCreatedAt()
}

func TestEnterprise_GetDescription(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	e := &Enterprise{Description: &zeroValue}
	e.GetDescription()
	e = &Enterprise{}
	e.GetDescription()
	e = nil
	e.GetDescription()
}

func TestEnterprise_GetHTMLURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	e := &Enterprise{HTMLURL: &zeroValue}
	e.GetHTMLURL()
	e = &Enterprise{}
	e.GetHTMLURL()
	e = nil
	e.GetHTMLURL()
}

func TestEnterprise_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	e := &Enterprise{ID: &zeroValue}
	e.GetID()
	e = &Enterprise{}
	e.GetID()
	e = nil
	e.GetID()
}

func TestEnterprise_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	e := &Enterprise{Name: &zeroValue}
	e.GetName()
	e = &Enterprise{}
	e.GetName()
	e = nil
	e.GetName()
}

func TestEnterprise_GetNodeID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	e := &Enterprise{NodeID: &zeroValue}
	e.GetNodeID()
	e = &Enterprise{}
	e.GetNodeID()
	e = nil
	e.GetNodeID()
}

func TestEnterprise_GetSlug(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	e := &Enterprise{Slug: &zeroValue}
	e.GetSlug()
	e = &Enterprise{}
	e.GetSlug()
	e = nil
	e.GetSlug()
}

func TestEnterprise_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	e := &Enterprise{UpdatedAt: &zeroValue}
	e.GetUpdatedAt()
	e = &Enterprise{}
	e.GetUpdatedAt()
	e = nil
	e.GetUpdatedAt()
}

func TestEnterprise_GetWebsiteURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	e := &Enterprise{WebsiteURL: &zeroValue}
	e.GetWebsiteURL()
	e = &Enterprise{}
	e.GetWebsiteURL()
	e = nil
	e.GetWebsiteURL()
}

func TestEnterpriseAggregatedUsageItem_GetDiscountAmount(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseAggregatedUsageItem{}
	e.GetDiscountAmount()
	e = nil
	e.GetDiscountAmount()
}

func TestEnterpriseAggregatedUsageItem_GetDiscountQuantity(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseAggregatedUsageItem{}
	e.GetDiscountQuantity()
	e = nil
	e.GetDiscountQuantity()
}

func TestEnterpriseAggregatedUsageItem_GetGrossAmount(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseAggregatedUsageItem{}
	e.GetGrossAmount()
	e = nil
	e.GetGrossAmount()
}

func TestEnterpriseAggregatedUsageItem_GetGrossQuantity(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseAggregatedUsageItem{}
	e.GetGrossQuantity()
	e = nil
	e.GetGrossQuantity()
}

func TestEnterpriseAggregatedUsageItem_GetModel(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseAggregatedUsageItem{}
	e.GetModel()
	e = nil
	e.GetModel()
}

func TestEnterpriseAggregatedUsageItem_GetNetAmount(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseAggregatedUsageItem{}
	e.GetNetAmount()
	e = nil
	e.GetNetAmount()
}

func TestEnterpriseAggregatedUsageItem_GetNetQuantity(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseAggregatedUsageItem{}
	e.GetNetQuantity()
	e = nil
	e.GetNetQuantity()
}

func TestEnterpriseAggregatedUsageItem_GetPricePerUnit(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseAggregatedUsageItem{}
	e.GetPricePerUnit()
	e = nil
	e.GetPricePerUnit()
}

func TestEnterpriseAggregatedUsageItem_GetProduct(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseAggregatedUsageItem{}
	e.GetProduct()
	e = nil
	e.GetProduct()
}

func TestEnterpriseAggregatedUsageItem_GetSKU(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseAggregatedUsageItem{}
	e.GetSKU()
	e = nil
	e.GetSKU()
}

func TestEnterpriseAggregatedUsageItem_GetUnitType(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseAggregatedUsageItem{}
	e.GetUnitType()
	e = nil
	e.GetUnitType()
}

func TestEnterpriseAggregatedUsageReport_GetCostCenter(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseAggregatedUsageReport{}
	e.GetCostCenter()
	e = nil
	e.GetCostCenter()
}

func TestEnterpriseAggregatedUsageReport_GetEnterprise(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseAggregatedUsageReport{}
	e.GetEnterprise()
	e = nil
	e.GetEnterprise()
}

func TestEnterpriseAggregatedUsageReport_GetModel(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	e := &EnterpriseAggregatedUsageReport{Model: &zeroValue}
	e.GetModel()
	e = &EnterpriseAggregatedUsageReport{}
	e.GetModel()
	e = nil
	e.GetModel()
}

func TestEnterpriseAggregatedUsageReport_GetOrganization(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	e := &EnterpriseAggregatedUsageReport{Organization: &zeroValue}
	e.GetOrganization()
	e = &EnterpriseAggregatedUsageReport{}
	e.GetOrganization()
	e = nil
	e.GetOrganization()
}

func TestEnterpriseAggregatedUsageReport_GetProduct(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	e := &EnterpriseAggregatedUsageReport{Product: &zeroValue}
	e.GetProduct()
	e = &EnterpriseAggregatedUsageReport{}
	e.GetProduct()
	e = nil
	e.GetProduct()
}

func TestEnterpriseAggregatedUsageReport_GetTimePeriod(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseAggregatedUsageReport{}
	e.GetTimePeriod()
	e = nil
	e.GetTimePeriod()
}

func TestEnterpriseAggregatedUsageReport_GetUsageItems(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*EnterpriseAggregatedUsageItem{}
	e := &EnterpriseAggregatedUsageReport{UsageItems: zeroValue}
	e.GetUsageItems()
	e = &EnterpriseAggregatedUsageReport{}
	e.GetUsageItems()
	e = nil
	e.GetUsageItems()
}

func TestEnterpriseAggregatedUsageReport_GetUser(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	e := &EnterpriseAggregatedUsageReport{User: &zeroValue}
	e.GetUser()
	e = &EnterpriseAggregatedUsageReport{}
	e.GetUser()
	e = nil
	e.GetUser()
}

func TestEnterpriseBudget_GetBudgetAlerting(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseBudget{}
	e.GetBudgetAlerting()
	e = nil
	e.GetBudgetAlerting()
}

func TestEnterpriseBudget_GetBudgetAmount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	e := &EnterpriseBudget{BudgetAmount: &zeroValue}
	e.GetBudgetAmount()
	e = &EnterpriseBudget{}
	e.GetBudgetAmount()
	e = nil
	e.GetBudgetAmount()
}

func TestEnterpriseBudget_GetBudgetEntityName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	e := &EnterpriseBudget{BudgetEntityName: &zeroValue}
	e.GetBudgetEntityName()
	e = &EnterpriseBudget{}
	e.GetBudgetEntityName()
	e = nil
	e.GetBudgetEntityName()
}

func TestEnterpriseBudget_GetBudgetProductSKU(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	e := &EnterpriseBudget{BudgetProductSKU: &zeroValue}
	e.GetBudgetProductSKU()
	e = &EnterpriseBudget{}
	e.GetBudgetProductSKU()
	e = nil
	e.GetBudgetProductSKU()
}

func TestEnterpriseBudget_GetBudgetScope(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	e := &EnterpriseBudget{BudgetScope: &zeroValue}
	e.GetBudgetScope()
	e = &EnterpriseBudget{}
	e.GetBudgetScope()
	e = nil
	e.GetBudgetScope()
}

func TestEnterpriseBudget_GetBudgetType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	e := &EnterpriseBudget{BudgetType: &zeroValue}
	e.GetBudgetType()
	e = &EnterpriseBudget{}
	e.GetBudgetType()
	e = nil
	e.GetBudgetType()
}

func TestEnterpriseBudget_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	e := &EnterpriseBudget{ID: &zeroValue}
	e.GetID()
	e = &EnterpriseBudget{}
	e.GetID()
	e = nil
	e.GetID()
}

func TestEnterpriseBudget_GetPreventFurtherUsage(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	e := &EnterpriseBudget{PreventFurtherUsage: &zeroValue}
	e.GetPreventFurtherUsage()
	e = &EnterpriseBudget{}
	e.GetPreventFurtherUsage()
	e = nil
	e.GetPreventFurtherUsage()
}

func TestEnterpriseBudgetAlerting_GetAlertRecipients(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	e := &EnterpriseBudgetAlerting{AlertRecipients: zeroValue}
	e.GetAlertRecipients()
	e = &EnterpriseBudgetAlerting{}
	e.GetAlertRecipients()
	e = nil
	e.GetAlertRecipients()
}

func TestEnterpriseBudgetAlerting_GetWillAlert(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	e := &EnterpriseBudgetAlerting{WillAlert: &zeroValue}
	e.GetWillAlert()
	e = &EnterpriseBudgetAlerting{}
	e.GetWillAlert()
	e = nil
	e.GetWillAlert()
}

func TestEnterpriseConsumedLicenses_GetTotalSeatsConsumed(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseConsumedLicenses{}
	e.GetTotalSeatsConsumed()
	e = nil
	e.GetTotalSeatsConsumed()
}

func TestEnterpriseConsumedLicenses_GetTotalSeatsPurchased(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseConsumedLicenses{}
	e.GetTotalSeatsPurchased()
	e = nil
	e.GetTotalSeatsPurchased()
}

func TestEnterpriseConsumedLicenses_GetUsers(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*EnterpriseLicensedUsers{}
	e := &EnterpriseConsumedLicenses{Users: zeroValue}
	e.GetUsers()
	e = &EnterpriseConsumedLicenses{}
	e.GetUsers()
	e = nil
	e.GetUsers()
}

func TestEnterpriseCreateBudget_GetBudgetAlerting(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseCreateBudget{}
	e.GetBudgetAlerting()
	e = nil
	e.GetBudgetAlerting()
}

func TestEnterpriseCreateBudget_GetBudgetAmount(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseCreateBudget{}
	e.GetBudgetAmount()
	e = nil
	e.GetBudgetAmount()
}

func TestEnterpriseCreateBudget_GetBudgetEntityName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	e := &EnterpriseCreateBudget{BudgetEntityName: &zeroValue}
	e.GetBudgetEntityName()
	e = &EnterpriseCreateBudget{}
	e.GetBudgetEntityName()
	e = nil
	e.GetBudgetEntityName()
}

func TestEnterpriseCreateBudget_GetBudgetProductSKU(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	e := &EnterpriseCreateBudget{BudgetProductSKU: &zeroValue}
	e.GetBudgetProductSKU()
	e = &EnterpriseCreateBudget{}
	e.GetBudgetProductSKU()
	e = nil
	e.GetBudgetProductSKU()
}

func TestEnterpriseCreateBudget_GetBudgetScope(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseCreateBudget{}
	e.GetBudgetScope()
	e = nil
	e.GetBudgetScope()
}

func TestEnterpriseCreateBudget_GetBudgetType(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseCreateBudget{}
	e.GetBudgetType()
	e = nil
	e.GetBudgetType()
}

func TestEnterpriseCreateBudget_GetPreventFurtherUsage(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseCreateBudget{}
	e.GetPreventFurtherUsage()
	e = nil
	e.GetPreventFurtherUsage()
}

func TestEnterpriseCreateOrUpdateBudgetResponse_GetBudget(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseCreateOrUpdateBudgetResponse{}
	e.GetBudget()
	e = nil
	e.GetBudget()
}

func TestEnterpriseCreateOrUpdateBudgetResponse_GetMessage(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseCreateOrUpdateBudgetResponse{}
	e.GetMessage()
	e = nil
	e.GetMessage()
}

func TestEnterpriseCustomPropertiesValues_GetOrganizationID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	e := &EnterpriseCustomPropertiesValues{OrganizationID: &zeroValue}
	e.GetOrganizationID()
	e = &EnterpriseCustomPropertiesValues{}
	e.GetOrganizationID()
	e = nil
	e.GetOrganizationID()
}

func TestEnterpriseCustomPropertiesValues_GetOrganizationLogin(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	e := &EnterpriseCustomPropertiesValues{OrganizationLogin: &zeroValue}
	e.GetOrganizationLogin()
	e = &EnterpriseCustomPropertiesValues{}
	e.GetOrganizationLogin()
	e = nil
	e.GetOrganizationLogin()
}

func TestEnterpriseCustomPropertiesValues_GetProperties(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*CustomPropertyValue{}
	e := &EnterpriseCustomPropertiesValues{Properties: zeroValue}
	e.GetProperties()
	e = &EnterpriseCustomPropertiesValues{}
	e.GetProperties()
	e = nil
	e.GetProperties()
}

func TestEnterpriseCustomPropertySchema_GetProperties(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*CustomProperty{}
	e := &EnterpriseCustomPropertySchema{Properties: zeroValue}
	e.GetProperties()
	e = &EnterpriseCustomPropertySchema{}
	e.GetProperties()
	e = nil
	e.GetProperties()
}

func TestEnterpriseCustomPropertyValuesRequest_GetOrganizationLogin(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	e := &EnterpriseCustomPropertyValuesRequest{OrganizationLogin: zeroValue}
	e.GetOrganizationLogin()
	e = &EnterpriseCustomPropertyValuesRequest{}
	e.GetOrganizationLogin()
	e = nil
	e.GetOrganizationLogin()
}

func TestEnterpriseCustomPropertyValuesRequest_GetProperties(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*CustomPropertyValue{}
	e := &EnterpriseCustomPropertyValuesRequest{Properties: zeroValue}
	e.GetProperties()
	e = &EnterpriseCustomPropertyValuesRequest{}
	e.GetProperties()
	e = nil
	e.GetProperties()
}

func TestEnterpriseDeleteBudgetResponse_GetID(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseDeleteBudgetResponse{}
	e.GetID()
	e = nil
	e.GetID()
}

func TestEnterpriseDeleteBudgetResponse_GetMessage(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseDeleteBudgetResponse{}
	e.GetMessage()
	e = nil
	e.GetMessage()
}

func TestEnterpriseLicensedUsers_GetEnterpriseServerEmails(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	e := &EnterpriseLicensedUsers{EnterpriseServerEmails: zeroValue}
	e.GetEnterpriseServerEmails()
	e = &EnterpriseLicensedUsers{}
	e.GetEnterpriseServerEmails()
	e = nil
	e.GetEnterpriseServerEmails()
}

func TestEnterpriseLicensedUsers_GetEnterpriseServerUser(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	e := &EnterpriseLicensedUsers{EnterpriseServerUser: &zeroValue}
	e.GetEnterpriseServerUser()
	e = &EnterpriseLicensedUsers{}
	e.GetEnterpriseServerUser()
	e = nil
	e.GetEnterpriseServerUser()
}

func TestEnterpriseLicensedUsers_GetEnterpriseServerUserIDs(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	e := &EnterpriseLicensedUsers{EnterpriseServerUserIDs: zeroValue}
	e.GetEnterpriseServerUserIDs()
	e = &EnterpriseLicensedUsers{}
	e.GetEnterpriseServerUserIDs()
	e = nil
	e.GetEnterpriseServerUserIDs()
}

func TestEnterpriseLicensedUsers_GetGithubComEnterpriseRoles(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	e := &EnterpriseLicensedUsers{GithubComEnterpriseRoles: zeroValue}
	e.GetGithubComEnterpriseRoles()
	e = &EnterpriseLicensedUsers{}
	e.GetGithubComEnterpriseRoles()
	e = nil
	e.GetGithubComEnterpriseRoles()
}

func TestEnterpriseLicensedUsers_GetGithubComLogin(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseLicensedUsers{}
	e.GetGithubComLogin()
	e = nil
	e.GetGithubComLogin()
}

func TestEnterpriseLicensedUsers_GetGithubComMemberRoles(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	e := &EnterpriseLicensedUsers{GithubComMemberRoles: zeroValue}
	e.GetGithubComMemberRoles()
	e = &EnterpriseLicensedUsers{}
	e.GetGithubComMemberRoles()
	e = nil
	e.GetGithubComMemberRoles()
}

func TestEnterpriseLicensedUsers_GetGithubComName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	e := &EnterpriseLicensedUsers{GithubComName: &zeroValue}
	e.GetGithubComName()
	e = &EnterpriseLicensedUsers{}
	e.GetGithubComName()
	e = nil
	e.GetGithubComName()
}

func TestEnterpriseLicensedUsers_GetGithubComOrgsWithPendingInvites(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	e := &EnterpriseLicensedUsers{GithubComOrgsWithPendingInvites: zeroValue}
	e.GetGithubComOrgsWithPendingInvites()
	e = &EnterpriseLicensedUsers{}
	e.GetGithubComOrgsWithPendingInvites()
	e = nil
	e.GetGithubComOrgsWithPendingInvites()
}

func TestEnterpriseLicensedUsers_GetGithubComProfile(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	e := &EnterpriseLicensedUsers{GithubComProfile: &zeroValue}
	e.GetGithubComProfile()
	e = &EnterpriseLicensedUsers{}
	e.GetGithubComProfile()
	e = nil
	e.GetGithubComProfile()
}

func TestEnterpriseLicensedUsers_GetGithubComSamlNameID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	e := &EnterpriseLicensedUsers{GithubComSamlNameID: &zeroValue}
	e.GetGithubComSamlNameID()
	e = &EnterpriseLicensedUsers{}
	e.GetGithubComSamlNameID()
	e = nil
	e.GetGithubComSamlNameID()
}

func TestEnterpriseLicensedUsers_GetGithubComTwoFactorAuth(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	e := &EnterpriseLicensedUsers{GithubComTwoFactorAuth: &zeroValue}
	e.GetGithubComTwoFactorAuth()
	e = &EnterpriseLicensedUsers{}
	e.GetGithubComTwoFactorAuth()
	e = nil
	e.GetGithubComTwoFactorAuth()
}

func TestEnterpriseLicensedUsers_GetGithubComUser(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseLicensedUsers{}
	e.GetGithubComUser()
	e = nil
	e.GetGithubComUser()
}

func TestEnterpriseLicensedUsers_GetGithubComVerifiedDomainEmails(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	e := &EnterpriseLicensedUsers{GithubComVerifiedDomainEmails: zeroValue}
	e.GetGithubComVerifiedDomainEmails()
	e = &EnterpriseLicensedUsers{}
	e.GetGithubComVerifiedDomainEmails()
	e = nil
	e.GetGithubComVerifiedDomainEmails()
}

func TestEnterpriseLicensedUsers_GetLicenseType(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseLicensedUsers{}
	e.GetLicenseType()
	e = nil
	e.GetLicenseType()
}

func TestEnterpriseLicensedUsers_GetTotalUserAccounts(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseLicensedUsers{}
	e.GetTotalUserAccounts()
	e = nil
	e.GetTotalUserAccounts()
}

func TestEnterpriseLicensedUsers_GetVisualStudioLicenseStatus(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	e := &EnterpriseLicensedUsers{VisualStudioLicenseStatus: &zeroValue}
	e.GetVisualStudioLicenseStatus()
	e = &EnterpriseLicensedUsers{}
	e.GetVisualStudioLicenseStatus()
	e = nil
	e.GetVisualStudioLicenseStatus()
}

func TestEnterpriseLicensedUsers_GetVisualStudioSubscriptionEmail(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	e := &EnterpriseLicensedUsers{VisualStudioSubscriptionEmail: &zeroValue}
	e.GetVisualStudioSubscriptionEmail()
	e = &EnterpriseLicensedUsers{}
	e.GetVisualStudioSubscriptionEmail()
	e = nil
	e.GetVisualStudioSubscriptionEmail()
}

func TestEnterpriseLicensedUsers_GetVisualStudioSubscriptionUser(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseLicensedUsers{}
	e.GetVisualStudioSubscriptionUser()
	e = nil
	e.GetVisualStudioSubscriptionUser()
}

func TestEnterpriseLicenseSyncStatus_GetDescription(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseLicenseSyncStatus{}
	e.GetDescription()
	e = nil
	e.GetDescription()
}

func TestEnterpriseLicenseSyncStatus_GetProperties(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseLicenseSyncStatus{}
	e.GetProperties()
	e = nil
	e.GetProperties()
}

func TestEnterpriseLicenseSyncStatus_GetTitle(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseLicenseSyncStatus{}
	e.GetTitle()
	e = nil
	e.GetTitle()
}

func TestEnterpriseListBudgets_GetBudgets(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*EnterpriseBudget{}
	e := &EnterpriseListBudgets{Budgets: zeroValue}
	e.GetBudgets()
	e = &EnterpriseListBudgets{}
	e.GetBudgets()
	e = nil
	e.GetBudgets()
}

func TestEnterpriseListBudgets_GetHasNextPage(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	e := &EnterpriseListBudgets{HasNextPage: &zeroValue}
	e.GetHasNextPage()
	e = &EnterpriseListBudgets{}
	e.GetHasNextPage()
	e = nil
	e.GetHasNextPage()
}

func TestEnterpriseListBudgets_GetTotalCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	e := &EnterpriseListBudgets{TotalCount: &zeroValue}
	e.GetTotalCount()
	e = &EnterpriseListBudgets{}
	e.GetTotalCount()
	e = nil
	e.GetTotalCount()
}

func TestEnterprisePremiumRequestUsageReportOptions_GetModel(tt *testing.T) {
	tt.Parallel()
	e := &EnterprisePremiumRequestUsageReportOptions{}
	e.GetModel()
	e = nil
	e.GetModel()
}

func TestEnterprisePremiumRequestUsageReportOptions_GetOrganization(tt *testing.T) {
	tt.Parallel()
	e := &EnterprisePremiumRequestUsageReportOptions{}
	e.GetOrganization()
	e = nil
	e.GetOrganization()
}

func TestEnterprisePremiumRequestUsageReportOptions_GetProduct(tt *testing.T) {
	tt.Parallel()
	e := &EnterprisePremiumRequestUsageReportOptions{}
	e.GetProduct()
	e = nil
	e.GetProduct()
}

func TestEnterprisePremiumRequestUsageReportOptions_GetUser(tt *testing.T) {
	tt.Parallel()
	e := &EnterprisePremiumRequestUsageReportOptions{}
	e.GetUser()
	e = nil
	e.GetUser()
}

func TestEnterpriseRunnerGroup_GetAllowsPublicRepositories(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	e := &EnterpriseRunnerGroup{AllowsPublicRepositories: &zeroValue}
	e.GetAllowsPublicRepositories()
	e = &EnterpriseRunnerGroup{}
	e.GetAllowsPublicRepositories()
	e = nil
	e.GetAllowsPublicRepositories()
}

func TestEnterpriseRunnerGroup_GetDefault(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	e := &EnterpriseRunnerGroup{Default: &zeroValue}
	e.GetDefault()
	e = &EnterpriseRunnerGroup{}
	e.GetDefault()
	e = nil
	e.GetDefault()
}

func TestEnterpriseRunnerGroup_GetHostedRunnersURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	e := &EnterpriseRunnerGroup{HostedRunnersURL: &zeroValue}
	e.GetHostedRunnersURL()
	e = &EnterpriseRunnerGroup{}
	e.GetHostedRunnersURL()
	e = nil
	e.GetHostedRunnersURL()
}

func TestEnterpriseRunnerGroup_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	e := &EnterpriseRunnerGroup{ID: &zeroValue}
	e.GetID()
	e = &EnterpriseRunnerGroup{}
	e.GetID()
	e = nil
	e.GetID()
}

func TestEnterpriseRunnerGroup_GetInherited(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	e := &EnterpriseRunnerGroup{Inherited: &zeroValue}
	e.GetInherited()
	e = &EnterpriseRunnerGroup{}
	e.GetInherited()
	e = nil
	e.GetInherited()
}

func TestEnterpriseRunnerGroup_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	e := &EnterpriseRunnerGroup{Name: &zeroValue}
	e.GetName()
	e = &EnterpriseRunnerGroup{}
	e.GetName()
	e = nil
	e.GetName()
}

func TestEnterpriseRunnerGroup_GetNetworkConfigurationID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	e := &EnterpriseRunnerGroup{NetworkConfigurationID: &zeroValue}
	e.GetNetworkConfigurationID()
	e = &EnterpriseRunnerGroup{}
	e.GetNetworkConfigurationID()
	e = nil
	e.GetNetworkConfigurationID()
}

func TestEnterpriseRunnerGroup_GetRestrictedToWorkflows(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	e := &EnterpriseRunnerGroup{RestrictedToWorkflows: &zeroValue}
	e.GetRestrictedToWorkflows()
	e = &EnterpriseRunnerGroup{}
	e.GetRestrictedToWorkflows()
	e = nil
	e.GetRestrictedToWorkflows()
}

func TestEnterpriseRunnerGroup_GetRunnersURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	e := &EnterpriseRunnerGroup{RunnersURL: &zeroValue}
	e.GetRunnersURL()
	e = &EnterpriseRunnerGroup{}
	e.GetRunnersURL()
	e = nil
	e.GetRunnersURL()
}

func TestEnterpriseRunnerGroup_GetSelectedOrganizationsURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	e := &EnterpriseRunnerGroup{SelectedOrganizationsURL: &zeroValue}
	e.GetSelectedOrganizationsURL()
	e = &EnterpriseRunnerGroup{}
	e.GetSelectedOrganizationsURL()
	e = nil
	e.GetSelectedOrganizationsURL()
}

func TestEnterpriseRunnerGroup_GetSelectedWorkflows(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	e := &EnterpriseRunnerGroup{SelectedWorkflows: zeroValue}
	e.GetSelectedWorkflows()
	e = &EnterpriseRunnerGroup{}
	e.GetSelectedWorkflows()
	e = nil
	e.GetSelectedWorkflows()
}

func TestEnterpriseRunnerGroup_GetVisibility(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	e := &EnterpriseRunnerGroup{Visibility: &zeroValue}
	e.GetVisibility()
	e = &EnterpriseRunnerGroup{}
	e.GetVisibility()
	e = nil
	e.GetVisibility()
}

func TestEnterpriseRunnerGroup_GetWorkflowRestrictionsReadOnly(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	e := &EnterpriseRunnerGroup{WorkflowRestrictionsReadOnly: &zeroValue}
	e.GetWorkflowRestrictionsReadOnly()
	e = &EnterpriseRunnerGroup{}
	e.GetWorkflowRestrictionsReadOnly()
	e = nil
	e.GetWorkflowRestrictionsReadOnly()
}

func TestEnterpriseRunnerGroups_GetRunnerGroups(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*EnterpriseRunnerGroup{}
	e := &EnterpriseRunnerGroups{RunnerGroups: zeroValue}
	e.GetRunnerGroups()
	e = &EnterpriseRunnerGroups{}
	e.GetRunnerGroups()
	e = nil
	e.GetRunnerGroups()
}

func TestEnterpriseRunnerGroups_GetTotalCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	e := &EnterpriseRunnerGroups{TotalCount: &zeroValue}
	e.GetTotalCount()
	e = &EnterpriseRunnerGroups{}
	e.GetTotalCount()
	e = nil
	e.GetTotalCount()
}

func TestEnterpriseSecurityAnalysisSettings_GetAdvancedSecurityEnabledForNewRepositories(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	e := &EnterpriseSecurityAnalysisSettings{AdvancedSecurityEnabledForNewRepositories: &zeroValue}
	e.GetAdvancedSecurityEnabledForNewRepositories()
	e = &EnterpriseSecurityAnalysisSettings{}
	e.GetAdvancedSecurityEnabledForNewRepositories()
	e = nil
	e.GetAdvancedSecurityEnabledForNewRepositories()
}

func TestEnterpriseSecurityAnalysisSettings_GetSecretScanningEnabledForNewRepositories(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	e := &EnterpriseSecurityAnalysisSettings{SecretScanningEnabledForNewRepositories: &zeroValue}
	e.GetSecretScanningEnabledForNewRepositories()
	e = &EnterpriseSecurityAnalysisSettings{}
	e.GetSecretScanningEnabledForNewRepositories()
	e = nil
	e.GetSecretScanningEnabledForNewRepositories()
}

func TestEnterpriseSecurityAnalysisSettings_GetSecretScanningPushProtectionCustomLink(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	e := &EnterpriseSecurityAnalysisSettings{SecretScanningPushProtectionCustomLink: &zeroValue}
	e.GetSecretScanningPushProtectionCustomLink()
	e = &EnterpriseSecurityAnalysisSettings{}
	e.GetSecretScanningPushProtectionCustomLink()
	e = nil
	e.GetSecretScanningPushProtectionCustomLink()
}

func TestEnterpriseSecurityAnalysisSettings_GetSecretScanningPushProtectionEnabledForNewRepositories(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	e := &EnterpriseSecurityAnalysisSettings{SecretScanningPushProtectionEnabledForNewRepositories: &zeroValue}
	e.GetSecretScanningPushProtectionEnabledForNewRepositories()
	e = &EnterpriseSecurityAnalysisSettings{}
	e.GetSecretScanningPushProtectionEnabledForNewRepositories()
	e = nil
	e.GetSecretScanningPushProtectionEnabledForNewRepositories()
}

func TestEnterpriseSecurityAnalysisSettings_GetSecretScanningValidityChecksEnabled(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	e := &EnterpriseSecurityAnalysisSettings{SecretScanningValidityChecksEnabled: &zeroValue}
	e.GetSecretScanningValidityChecksEnabled()
	e = &EnterpriseSecurityAnalysisSettings{}
	e.GetSecretScanningValidityChecksEnabled()
	e = nil
	e.GetSecretScanningValidityChecksEnabled()
}

func TestEnterpriseTeam_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseTeam{}
	e.GetCreatedAt()
	e = nil
	e.GetCreatedAt()
}

func TestEnterpriseTeam_GetDescription(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	e := &EnterpriseTeam{Description: &zeroValue}
	e.GetDescription()
	e = &EnterpriseTeam{}
	e.GetDescription()
	e = nil
	e.GetDescription()
}

func TestEnterpriseTeam_GetGroupID(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseTeam{}
	e.GetGroupID()
	e = nil
	e.GetGroupID()
}

func TestEnterpriseTeam_GetHTMLURL(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseTeam{}
	e.GetHTMLURL()
	e = nil
	e.GetHTMLURL()
}

func TestEnterpriseTeam_GetID(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseTeam{}
	e.GetID()
	e = nil
	e.GetID()
}

func TestEnterpriseTeam_GetMemberURL(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseTeam{}
	e.GetMemberURL()
	e = nil
	e.GetMemberURL()
}

func TestEnterpriseTeam_GetName(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseTeam{}
	e.GetName()
	e = nil
	e.GetName()
}

func TestEnterpriseTeam_GetOrganizationSelectionType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	e := &EnterpriseTeam{OrganizationSelectionType: &zeroValue}
	e.GetOrganizationSelectionType()
	e = &EnterpriseTeam{}
	e.GetOrganizationSelectionType()
	e = nil
	e.GetOrganizationSelectionType()
}

func TestEnterpriseTeam_GetSlug(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseTeam{}
	e.GetSlug()
	e = nil
	e.GetSlug()
}

func TestEnterpriseTeam_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseTeam{}
	e.GetUpdatedAt()
	e = nil
	e.GetUpdatedAt()
}

func TestEnterpriseTeam_GetURL(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseTeam{}
	e.GetURL()
	e = nil
	e.GetURL()
}

func TestEnterpriseTeamCreateOrUpdateRequest_GetDescription(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	e := &EnterpriseTeamCreateOrUpdateRequest{Description: &zeroValue}
	e.GetDescription()
	e = &EnterpriseTeamCreateOrUpdateRequest{}
	e.GetDescription()
	e = nil
	e.GetDescription()
}

func TestEnterpriseTeamCreateOrUpdateRequest_GetGroupID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	e := &EnterpriseTeamCreateOrUpdateRequest{GroupID: &zeroValue}
	e.GetGroupID()
	e = &EnterpriseTeamCreateOrUpdateRequest{}
	e.GetGroupID()
	e = nil
	e.GetGroupID()
}

func TestEnterpriseTeamCreateOrUpdateRequest_GetName(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseTeamCreateOrUpdateRequest{}
	e.GetName()
	e = nil
	e.GetName()
}

func TestEnterpriseTeamCreateOrUpdateRequest_GetOrganizationSelectionType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	e := &EnterpriseTeamCreateOrUpdateRequest{OrganizationSelectionType: &zeroValue}
	e.GetOrganizationSelectionType()
	e = &EnterpriseTeamCreateOrUpdateRequest{}
	e.GetOrganizationSelectionType()
	e = nil
	e.GetOrganizationSelectionType()
}

func TestEnterpriseUpdateBudget_GetBudgetAlerting(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseUpdateBudget{}
	e.GetBudgetAlerting()
	e = nil
	e.GetBudgetAlerting()
}

func TestEnterpriseUpdateBudget_GetBudgetAmount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	e := &EnterpriseUpdateBudget{BudgetAmount: &zeroValue}
	e.GetBudgetAmount()
	e = &EnterpriseUpdateBudget{}
	e.GetBudgetAmount()
	e = nil
	e.GetBudgetAmount()
}

func TestEnterpriseUpdateBudget_GetBudgetEntityName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	e := &EnterpriseUpdateBudget{BudgetEntityName: &zeroValue}
	e.GetBudgetEntityName()
	e = &EnterpriseUpdateBudget{}
	e.GetBudgetEntityName()
	e = nil
	e.GetBudgetEntityName()
}

func TestEnterpriseUpdateBudget_GetBudgetProductSKU(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	e := &EnterpriseUpdateBudget{BudgetProductSKU: &zeroValue}
	e.GetBudgetProductSKU()
	e = &EnterpriseUpdateBudget{}
	e.GetBudgetProductSKU()
	e = nil
	e.GetBudgetProductSKU()
}

func TestEnterpriseUpdateBudget_GetBudgetScope(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	e := &EnterpriseUpdateBudget{BudgetScope: &zeroValue}
	e.GetBudgetScope()
	e = &EnterpriseUpdateBudget{}
	e.GetBudgetScope()
	e = nil
	e.GetBudgetScope()
}

func TestEnterpriseUpdateBudget_GetBudgetType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	e := &EnterpriseUpdateBudget{BudgetType: &zeroValue}
	e.GetBudgetType()
	e = &EnterpriseUpdateBudget{}
	e.GetBudgetType()
	e = nil
	e.GetBudgetType()
}

func TestEnterpriseUpdateBudget_GetPreventFurtherUsage(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	e := &EnterpriseUpdateBudget{PreventFurtherUsage: &zeroValue}
	e.GetPreventFurtherUsage()
	e = &EnterpriseUpdateBudget{}
	e.GetPreventFurtherUsage()
	e = nil
	e.GetPreventFurtherUsage()
}

func TestEnterpriseUsageItem_GetDate(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseUsageItem{}
	e.GetDate()
	e = nil
	e.GetDate()
}

func TestEnterpriseUsageItem_GetDiscountAmount(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseUsageItem{}
	e.GetDiscountAmount()
	e = nil
	e.GetDiscountAmount()
}

func TestEnterpriseUsageItem_GetGrossAmount(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseUsageItem{}
	e.GetGrossAmount()
	e = nil
	e.GetGrossAmount()
}

func TestEnterpriseUsageItem_GetNetAmount(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseUsageItem{}
	e.GetNetAmount()
	e = nil
	e.GetNetAmount()
}

func TestEnterpriseUsageItem_GetOrganizationName(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseUsageItem{}
	e.GetOrganizationName()
	e = nil
	e.GetOrganizationName()
}

func TestEnterpriseUsageItem_GetPricePerUnit(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseUsageItem{}
	e.GetPricePerUnit()
	e = nil
	e.GetPricePerUnit()
}

func TestEnterpriseUsageItem_GetProduct(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseUsageItem{}
	e.GetProduct()
	e = nil
	e.GetProduct()
}

func TestEnterpriseUsageItem_GetQuantity(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseUsageItem{}
	e.GetQuantity()
	e = nil
	e.GetQuantity()
}

func TestEnterpriseUsageItem_GetRepositoryName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	e := &EnterpriseUsageItem{RepositoryName: &zeroValue}
	e.GetRepositoryName()
	e = &EnterpriseUsageItem{}
	e.GetRepositoryName()
	e = nil
	e.GetRepositoryName()
}

func TestEnterpriseUsageItem_GetSKU(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseUsageItem{}
	e.GetSKU()
	e = nil
	e.GetSKU()
}

func TestEnterpriseUsageItem_GetUnitType(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseUsageItem{}
	e.GetUnitType()
	e = nil
	e.GetUnitType()
}

func TestEnterpriseUsageReport_GetUsageItems(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*EnterpriseUsageItem{}
	e := &EnterpriseUsageReport{UsageItems: zeroValue}
	e.GetUsageItems()
	e = &EnterpriseUsageReport{}
	e.GetUsageItems()
	e = nil
	e.GetUsageItems()
}

func TestEnterpriseUsageReportOptions_GetCostCenterID(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseUsageReportOptions{}
	e.GetCostCenterID()
	e = nil
	e.GetCostCenterID()
}

func TestEnterpriseUsageReportOptions_GetDay(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseUsageReportOptions{}
	e.GetDay()
	e = nil
	e.GetDay()
}

func TestEnterpriseUsageReportOptions_GetMonth(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseUsageReportOptions{}
	e.GetMonth()
	e = nil
	e.GetMonth()
}

func TestEnterpriseUsageReportOptions_GetYear(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseUsageReportOptions{}
	e.GetYear()
	e = nil
	e.GetYear()
}

func TestEnterpriseUsageSummaryItem_GetDiscountAmount(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseUsageSummaryItem{}
	e.GetDiscountAmount()
	e = nil
	e.GetDiscountAmount()
}

func TestEnterpriseUsageSummaryItem_GetDiscountQuantity(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseUsageSummaryItem{}
	e.GetDiscountQuantity()
	e = nil
	e.GetDiscountQuantity()
}

func TestEnterpriseUsageSummaryItem_GetGrossAmount(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseUsageSummaryItem{}
	e.GetGrossAmount()
	e = nil
	e.GetGrossAmount()
}

func TestEnterpriseUsageSummaryItem_GetGrossQuantity(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseUsageSummaryItem{}
	e.GetGrossQuantity()
	e = nil
	e.GetGrossQuantity()
}

func TestEnterpriseUsageSummaryItem_GetNetAmount(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseUsageSummaryItem{}
	e.GetNetAmount()
	e = nil
	e.GetNetAmount()
}

func TestEnterpriseUsageSummaryItem_GetNetQuantity(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseUsageSummaryItem{}
	e.GetNetQuantity()
	e = nil
	e.GetNetQuantity()
}

func TestEnterpriseUsageSummaryItem_GetPricePerUnit(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseUsageSummaryItem{}
	e.GetPricePerUnit()
	e = nil
	e.GetPricePerUnit()
}

func TestEnterpriseUsageSummaryItem_GetProduct(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseUsageSummaryItem{}
	e.GetProduct()
	e = nil
	e.GetProduct()
}

func TestEnterpriseUsageSummaryItem_GetSKU(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseUsageSummaryItem{}
	e.GetSKU()
	e = nil
	e.GetSKU()
}

func TestEnterpriseUsageSummaryItem_GetUnitType(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseUsageSummaryItem{}
	e.GetUnitType()
	e = nil
	e.GetUnitType()
}

func TestEnterpriseUsageSummaryOptions_GetOrganization(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseUsageSummaryOptions{}
	e.GetOrganization()
	e = nil
	e.GetOrganization()
}

func TestEnterpriseUsageSummaryOptions_GetProduct(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseUsageSummaryOptions{}
	e.GetProduct()
	e = nil
	e.GetProduct()
}

func TestEnterpriseUsageSummaryOptions_GetRepository(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseUsageSummaryOptions{}
	e.GetRepository()
	e = nil
	e.GetRepository()
}

func TestEnterpriseUsageSummaryOptions_GetSKU(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseUsageSummaryOptions{}
	e.GetSKU()
	e = nil
	e.GetSKU()
}

func TestEnterpriseUsageSummaryReport_GetCostCenter(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseUsageSummaryReport{}
	e.GetCostCenter()
	e = nil
	e.GetCostCenter()
}

func TestEnterpriseUsageSummaryReport_GetEnterprise(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseUsageSummaryReport{}
	e.GetEnterprise()
	e = nil
	e.GetEnterprise()
}

func TestEnterpriseUsageSummaryReport_GetOrganization(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	e := &EnterpriseUsageSummaryReport{Organization: &zeroValue}
	e.GetOrganization()
	e = &EnterpriseUsageSummaryReport{}
	e.GetOrganization()
	e = nil
	e.GetOrganization()
}

func TestEnterpriseUsageSummaryReport_GetProduct(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	e := &EnterpriseUsageSummaryReport{Product: &zeroValue}
	e.GetProduct()
	e = &EnterpriseUsageSummaryReport{}
	e.GetProduct()
	e = nil
	e.GetProduct()
}

func TestEnterpriseUsageSummaryReport_GetRepository(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	e := &EnterpriseUsageSummaryReport{Repository: &zeroValue}
	e.GetRepository()
	e = &EnterpriseUsageSummaryReport{}
	e.GetRepository()
	e = nil
	e.GetRepository()
}

func TestEnterpriseUsageSummaryReport_GetSKU(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	e := &EnterpriseUsageSummaryReport{SKU: &zeroValue}
	e.GetSKU()
	e = &EnterpriseUsageSummaryReport{}
	e.GetSKU()
	e = nil
	e.GetSKU()
}

func TestEnterpriseUsageSummaryReport_GetTimePeriod(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseUsageSummaryReport{}
	e.GetTimePeriod()
	e = nil
	e.GetTimePeriod()
}

func TestEnterpriseUsageSummaryReport_GetUsageItems(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*EnterpriseUsageSummaryItem{}
	e := &EnterpriseUsageSummaryReport{UsageItems: zeroValue}
	e.GetUsageItems()
	e = &EnterpriseUsageSummaryReport{}
	e.GetUsageItems()
	e = nil
	e.GetUsageItems()
}

func TestEnterpriseUsageTimePeriod_GetDay(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	e := &EnterpriseUsageTimePeriod{Day: &zeroValue}
	e.GetDay()
	e = &EnterpriseUsageTimePeriod{}
	e.GetDay()
	e = nil
	e.GetDay()
}

func TestEnterpriseUsageTimePeriod_GetMonth(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	e := &EnterpriseUsageTimePeriod{Month: &zeroValue}
	e.GetMonth()
	e = &EnterpriseUsageTimePeriod{}
	e.GetMonth()
	e = nil
	e.GetMonth()
}

func TestEnterpriseUsageTimePeriod_GetYear(tt *testing.T) {
	tt.Parallel()
	e := &EnterpriseUsageTimePeriod{}
	e.GetYear()
	e = nil
	e.GetYear()
}

func TestEnvironment_GetCanAdminsBypass(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	e := &Environment{CanAdminsBypass: &zeroValue}
	e.GetCanAdminsBypass()
	e = &Environment{}
	e.GetCanAdminsBypass()
	e = nil
	e.GetCanAdminsBypass()
}

func TestEnvironment_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	e := &Environment{CreatedAt: &zeroValue}
	e.GetCreatedAt()
	e = &Environment{}
	e.GetCreatedAt()
	e = nil
	e.GetCreatedAt()
}

func TestEnvironment_GetDeploymentBranchPolicy(tt *testing.T) {
	tt.Parallel()
	e := &Environment{}
	e.GetDeploymentBranchPolicy()
	e = nil
	e.GetDeploymentBranchPolicy()
}

func TestEnvironment_GetEnvironmentName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	e := &Environment{EnvironmentName: &zeroValue}
	e.GetEnvironmentName()
	e = &Environment{}
	e.GetEnvironmentName()
	e = nil
	e.GetEnvironmentName()
}

func TestEnvironment_GetHTMLURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	e := &Environment{HTMLURL: &zeroValue}
	e.GetHTMLURL()
	e = &Environment{}
	e.GetHTMLURL()
	e = nil
	e.GetHTMLURL()
}

func TestEnvironment_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	e := &Environment{ID: &zeroValue}
	e.GetID()
	e = &Environment{}
	e.GetID()
	e = nil
	e.GetID()
}

func TestEnvironment_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	e := &Environment{Name: &zeroValue}
	e.GetName()
	e = &Environment{}
	e.GetName()
	e = nil
	e.GetName()
}

func TestEnvironment_GetNodeID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	e := &Environment{NodeID: &zeroValue}
	e.GetNodeID()
	e = &Environment{}
	e.GetNodeID()
	e = nil
	e.GetNodeID()
}

func TestEnvironment_GetOwner(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	e := &Environment{Owner: &zeroValue}
	e.GetOwner()
	e = &Environment{}
	e.GetOwner()
	e = nil
	e.GetOwner()
}

func TestEnvironment_GetProtectionRules(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*ProtectionRule{}
	e := &Environment{ProtectionRules: zeroValue}
	e.GetProtectionRules()
	e = &Environment{}
	e.GetProtectionRules()
	e = nil
	e.GetProtectionRules()
}

func TestEnvironment_GetRepo(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	e := &Environment{Repo: &zeroValue}
	e.GetRepo()
	e = &Environment{}
	e.GetRepo()
	e = nil
	e.GetRepo()
}

func TestEnvironment_GetReviewers(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*EnvReviewers{}
	e := &Environment{Reviewers: zeroValue}
	e.GetReviewers()
	e = &Environment{}
	e.GetReviewers()
	e = nil
	e.GetReviewers()
}

func TestEnvironment_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	e := &Environment{UpdatedAt: &zeroValue}
	e.GetUpdatedAt()
	e = &Environment{}
	e.GetUpdatedAt()
	e = nil
	e.GetUpdatedAt()
}

func TestEnvironment_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	e := &Environment{URL: &zeroValue}
	e.GetURL()
	e = &Environment{}
	e.GetURL()
	e = nil
	e.GetURL()
}

func TestEnvironment_GetWaitTimer(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	e := &Environment{WaitTimer: &zeroValue}
	e.GetWaitTimer()
	e = &Environment{}
	e.GetWaitTimer()
	e = nil
	e.GetWaitTimer()
}

func TestEnvResponse_GetEnvironments(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*Environment{}
	e := &EnvResponse{Environments: zeroValue}
	e.GetEnvironments()
	e = &EnvResponse{}
	e.GetEnvironments()
	e = nil
	e.GetEnvironments()
}

func TestEnvResponse_GetTotalCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	e := &EnvResponse{TotalCount: &zeroValue}
	e.GetTotalCount()
	e = &EnvResponse{}
	e.GetTotalCount()
	e = nil
	e.GetTotalCount()
}

func TestEnvReviewers_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	e := &EnvReviewers{ID: &zeroValue}
	e.GetID()
	e = &EnvReviewers{}
	e.GetID()
	e = nil
	e.GetID()
}

func TestEnvReviewers_GetType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	e := &EnvReviewers{Type: &zeroValue}
	e.GetType()
	e = &EnvReviewers{}
	e.GetType()
	e = nil
	e.GetType()
}

func TestError_GetCode(tt *testing.T) {
	tt.Parallel()
	e := &Error{}
	e.GetCode()
	e = nil
	e.GetCode()
}

func TestError_GetField(tt *testing.T) {
	tt.Parallel()
	e := &Error{}
	e.GetField()
	e = nil
	e.GetField()
}

func TestError_GetMessage(tt *testing.T) {
	tt.Parallel()
	e := &Error{}
	e.GetMessage()
	e = nil
	e.GetMessage()
}

func TestError_GetResource(tt *testing.T) {
	tt.Parallel()
	e := &Error{}
	e.GetResource()
	e = nil
	e.GetResource()
}

func TestErrorBlock_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	e := &ErrorBlock{CreatedAt: &zeroValue}
	e.GetCreatedAt()
	e = &ErrorBlock{}
	e.GetCreatedAt()
	e = nil
	e.GetCreatedAt()
}

func TestErrorBlock_GetReason(tt *testing.T) {
	tt.Parallel()
	e := &ErrorBlock{}
	e.GetReason()
	e = nil
	e.GetReason()
}

func TestErrorResponse_GetBlock(tt *testing.T) {
	tt.Parallel()
	e := &ErrorResponse{}
	e.GetBlock()
	e = nil
	e.GetBlock()
}

func TestErrorResponse_GetDocumentationURL(tt *testing.T) {
	tt.Parallel()
	e := &ErrorResponse{}
	e.GetDocumentationURL()
	e = nil
	e.GetDocumentationURL()
}

func TestErrorResponse_GetErrors(tt *testing.T) {
	tt.Parallel()
	zeroValue := []Error{}
	e := &ErrorResponse{Errors: zeroValue}
	e.GetErrors()
	e = &ErrorResponse{}
	e.GetErrors()
	e = nil
	e.GetErrors()
}

func TestErrorResponse_GetMessage(tt *testing.T) {
	tt.Parallel()
	e := &ErrorResponse{}
	e.GetMessage()
	e = nil
	e.GetMessage()
}

func TestEvent_GetActor(tt *testing.T) {
	tt.Parallel()
	e := &Event{}
	e.GetActor()
	e = nil
	e.GetActor()
}

func TestEvent_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	e := &Event{CreatedAt: &zeroValue}
	e.GetCreatedAt()
	e = &Event{}
	e.GetCreatedAt()
	e = nil
	e.GetCreatedAt()
}

func TestEvent_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	e := &Event{ID: &zeroValue}
	e.GetID()
	e = &Event{}
	e.GetID()
	e = nil
	e.GetID()
}

func TestEvent_GetOrg(tt *testing.T) {
	tt.Parallel()
	e := &Event{}
	e.GetOrg()
	e = nil
	e.GetOrg()
}

func TestEvent_GetPublic(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	e := &Event{Public: &zeroValue}
	e.GetPublic()
	e = &Event{}
	e.GetPublic()
	e = nil
	e.GetPublic()
}

func TestEvent_GetRawPayload(tt *testing.T) {
	tt.Parallel()
	var zeroValue json.RawMessage
	e := &Event{RawPayload: &zeroValue}
	e.GetRawPayload()
	e = &Event{}
	e.GetRawPayload()
	e = nil
	e.GetRawPayload()
}

func TestEvent_GetRepo(tt *testing.T) {
	tt.Parallel()
	e := &Event{}
	e.GetRepo()
	e = nil
	e.GetRepo()
}

func TestEvent_GetType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	e := &Event{Type: &zeroValue}
	e.GetType()
	e = &Event{}
	e.GetType()
	e = nil
	e.GetType()
}

func TestExternalGroup_GetGroupID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	e := &ExternalGroup{GroupID: &zeroValue}
	e.GetGroupID()
	e = &ExternalGroup{}
	e.GetGroupID()
	e = nil
	e.GetGroupID()
}

func TestExternalGroup_GetGroupName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	e := &ExternalGroup{GroupName: &zeroValue}
	e.GetGroupName()
	e = &ExternalGroup{}
	e.GetGroupName()
	e = nil
	e.GetGroupName()
}

func TestExternalGroup_GetMembers(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*ExternalGroupMember{}
	e := &ExternalGroup{Members: zeroValue}
	e.GetMembers()
	e = &ExternalGroup{}
	e.GetMembers()
	e = nil
	e.GetMembers()
}

func TestExternalGroup_GetTeams(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*ExternalGroupTeam{}
	e := &ExternalGroup{Teams: zeroValue}
	e.GetTeams()
	e = &ExternalGroup{}
	e.GetTeams()
	e = nil
	e.GetTeams()
}

func TestExternalGroup_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	e := &ExternalGroup{UpdatedAt: &zeroValue}
	e.GetUpdatedAt()
	e = &ExternalGroup{}
	e.GetUpdatedAt()
	e = nil
	e.GetUpdatedAt()
}

func TestExternalGroupList_GetGroups(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*ExternalGroup{}
	e := &ExternalGroupList{Groups: zeroValue}
	e.GetGroups()
	e = &ExternalGroupList{}
	e.GetGroups()
	e = nil
	e.GetGroups()
}

func TestExternalGroupMember_GetMemberEmail(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	e := &ExternalGroupMember{MemberEmail: &zeroValue}
	e.GetMemberEmail()
	e = &ExternalGroupMember{}
	e.GetMemberEmail()
	e = nil
	e.GetMemberEmail()
}

func TestExternalGroupMember_GetMemberID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	e := &ExternalGroupMember{MemberID: &zeroValue}
	e.GetMemberID()
	e = &ExternalGroupMember{}
	e.GetMemberID()
	e = nil
	e.GetMemberID()
}

func TestExternalGroupMember_GetMemberLogin(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	e := &ExternalGroupMember{MemberLogin: &zeroValue}
	e.GetMemberLogin()
	e = &ExternalGroupMember{}
	e.GetMemberLogin()
	e = nil
	e.GetMemberLogin()
}

func TestExternalGroupMember_GetMemberName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	e := &ExternalGroupMember{MemberName: &zeroValue}
	e.GetMemberName()
	e = &ExternalGroupMember{}
	e.GetMemberName()
	e = nil
	e.GetMemberName()
}

func TestExternalGroupTeam_GetTeamID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	e := &ExternalGroupTeam{TeamID: &zeroValue}
	e.GetTeamID()
	e = &ExternalGroupTeam{}
	e.GetTeamID()
	e = nil
	e.GetTeamID()
}

func TestExternalGroupTeam_GetTeamName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	e := &ExternalGroupTeam{TeamName: &zeroValue}
	e.GetTeamName()
	e = &ExternalGroupTeam{}
	e.GetTeamName()
	e = nil
	e.GetTeamName()
}

func TestFeedLink_GetHRef(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	f := &FeedLink{HRef: &zeroValue}
	f.GetHRef()
	f = &FeedLink{}
	f.GetHRef()
	f = nil
	f.GetHRef()
}

func TestFeedLink_GetType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	f := &FeedLink{Type: &zeroValue}
	f.GetType()
	f = &FeedLink{}
	f.GetType()
	f = nil
	f.GetType()
}

func TestFeedLinks_GetCurrentUser(tt *testing.T) {
	tt.Parallel()
	f := &FeedLinks{}
	f.GetCurrentUser()
	f = nil
	f.GetCurrentUser()
}

func TestFeedLinks_GetCurrentUserActor(tt *testing.T) {
	tt.Parallel()
	f := &FeedLinks{}
	f.GetCurrentUserActor()
	f = nil
	f.GetCurrentUserActor()
}

func TestFeedLinks_GetCurrentUserOrganization(tt *testing.T) {
	tt.Parallel()
	f := &FeedLinks{}
	f.GetCurrentUserOrganization()
	f = nil
	f.GetCurrentUserOrganization()
}

func TestFeedLinks_GetCurrentUserOrganizations(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*FeedLink{}
	f := &FeedLinks{CurrentUserOrganizations: zeroValue}
	f.GetCurrentUserOrganizations()
	f = &FeedLinks{}
	f.GetCurrentUserOrganizations()
	f = nil
	f.GetCurrentUserOrganizations()
}

func TestFeedLinks_GetCurrentUserPublic(tt *testing.T) {
	tt.Parallel()
	f := &FeedLinks{}
	f.GetCurrentUserPublic()
	f = nil
	f.GetCurrentUserPublic()
}

func TestFeedLinks_GetTimeline(tt *testing.T) {
	tt.Parallel()
	f := &FeedLinks{}
	f.GetTimeline()
	f = nil
	f.GetTimeline()
}

func TestFeedLinks_GetUser(tt *testing.T) {
	tt.Parallel()
	f := &FeedLinks{}
	f.GetUser()
	f = nil
	f.GetUser()
}

func TestFeeds_GetCurrentUserActorURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	f := &Feeds{CurrentUserActorURL: &zeroValue}
	f.GetCurrentUserActorURL()
	f = &Feeds{}
	f.GetCurrentUserActorURL()
	f = nil
	f.GetCurrentUserActorURL()
}

func TestFeeds_GetCurrentUserOrganizationURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	f := &Feeds{CurrentUserOrganizationURL: &zeroValue}
	f.GetCurrentUserOrganizationURL()
	f = &Feeds{}
	f.GetCurrentUserOrganizationURL()
	f = nil
	f.GetCurrentUserOrganizationURL()
}

func TestFeeds_GetCurrentUserOrganizationURLs(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	f := &Feeds{CurrentUserOrganizationURLs: zeroValue}
	f.GetCurrentUserOrganizationURLs()
	f = &Feeds{}
	f.GetCurrentUserOrganizationURLs()
	f = nil
	f.GetCurrentUserOrganizationURLs()
}

func TestFeeds_GetCurrentUserPublicURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	f := &Feeds{CurrentUserPublicURL: &zeroValue}
	f.GetCurrentUserPublicURL()
	f = &Feeds{}
	f.GetCurrentUserPublicURL()
	f = nil
	f.GetCurrentUserPublicURL()
}

func TestFeeds_GetCurrentUserURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	f := &Feeds{CurrentUserURL: &zeroValue}
	f.GetCurrentUserURL()
	f = &Feeds{}
	f.GetCurrentUserURL()
	f = nil
	f.GetCurrentUserURL()
}

func TestFeeds_GetLinks(tt *testing.T) {
	tt.Parallel()
	f := &Feeds{}
	f.GetLinks()
	f = nil
	f.GetLinks()
}

func TestFeeds_GetTimelineURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	f := &Feeds{TimelineURL: &zeroValue}
	f.GetTimelineURL()
	f = &Feeds{}
	f.GetTimelineURL()
	f = nil
	f.GetTimelineURL()
}

func TestFeeds_GetUserURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	f := &Feeds{UserURL: &zeroValue}
	f.GetUserURL()
	f = &Feeds{}
	f.GetUserURL()
	f = nil
	f.GetUserURL()
}

func TestFieldValue_GetFieldName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	f := &FieldValue{FieldName: &zeroValue}
	f.GetFieldName()
	f = &FieldValue{}
	f.GetFieldName()
	f = nil
	f.GetFieldName()
}

func TestFieldValue_GetFieldNodeID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	f := &FieldValue{FieldNodeID: &zeroValue}
	f.GetFieldNodeID()
	f = &FieldValue{}
	f.GetFieldNodeID()
	f = nil
	f.GetFieldNodeID()
}

func TestFieldValue_GetFieldType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	f := &FieldValue{FieldType: &zeroValue}
	f.GetFieldType()
	f = &FieldValue{}
	f.GetFieldType()
	f = nil
	f.GetFieldType()
}

func TestFieldValue_GetFrom(tt *testing.T) {
	tt.Parallel()
	f := &FieldValue{}
	f.GetFrom()
	f = nil
	f.GetFrom()
}

func TestFieldValue_GetProjectNumber(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	f := &FieldValue{ProjectNumber: &zeroValue}
	f.GetProjectNumber()
	f = &FieldValue{}
	f.GetProjectNumber()
	f = nil
	f.GetProjectNumber()
}

func TestFieldValue_GetTo(tt *testing.T) {
	tt.Parallel()
	f := &FieldValue{}
	f.GetTo()
	f = nil
	f.GetTo()
}

func TestFileExtensionRestrictionBranchRule_GetParameters(tt *testing.T) {
	tt.Parallel()
	f := &FileExtensionRestrictionBranchRule{}
	f.GetParameters()
	f = nil
	f.GetParameters()
}

func TestFileExtensionRestrictionRuleParameters_GetRestrictedFileExtensions(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	f := &FileExtensionRestrictionRuleParameters{RestrictedFileExtensions: zeroValue}
	f.GetRestrictedFileExtensions()
	f = &FileExtensionRestrictionRuleParameters{}
	f.GetRestrictedFileExtensions()
	f = nil
	f.GetRestrictedFileExtensions()
}

func TestFilePathRestrictionBranchRule_GetParameters(tt *testing.T) {
	tt.Parallel()
	f := &FilePathRestrictionBranchRule{}
	f.GetParameters()
	f = nil
	f.GetParameters()
}

func TestFilePathRestrictionRuleParameters_GetRestrictedFilePaths(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	f := &FilePathRestrictionRuleParameters{RestrictedFilePaths: zeroValue}
	f.GetRestrictedFilePaths()
	f = &FilePathRestrictionRuleParameters{}
	f.GetRestrictedFilePaths()
	f = nil
	f.GetRestrictedFilePaths()
}

func TestFineGrainedPersonalAccessTokenRequest_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	f := &FineGrainedPersonalAccessTokenRequest{CreatedAt: &zeroValue}
	f.GetCreatedAt()
	f = &FineGrainedPersonalAccessTokenRequest{}
	f.GetCreatedAt()
	f = nil
	f.GetCreatedAt()
}

func TestFineGrainedPersonalAccessTokenRequest_GetID(tt *testing.T) {
	tt.Parallel()
	f := &FineGrainedPersonalAccessTokenRequest{}
	f.GetID()
	f = nil
	f.GetID()
}

func TestFineGrainedPersonalAccessTokenRequest_GetOwner(tt *testing.T) {
	tt.Parallel()
	f := &FineGrainedPersonalAccessTokenRequest{}
	f.GetOwner()
	f = nil
	f.GetOwner()
}

func TestFineGrainedPersonalAccessTokenRequest_GetPermissions(tt *testing.T) {
	tt.Parallel()
	f := &FineGrainedPersonalAccessTokenRequest{}
	f.GetPermissions()
	f = nil
	f.GetPermissions()
}

func TestFineGrainedPersonalAccessTokenRequest_GetReason(tt *testing.T) {
	tt.Parallel()
	f := &FineGrainedPersonalAccessTokenRequest{}
	f.GetReason()
	f = nil
	f.GetReason()
}

func TestFineGrainedPersonalAccessTokenRequest_GetRepositoriesURL(tt *testing.T) {
	tt.Parallel()
	f := &FineGrainedPersonalAccessTokenRequest{}
	f.GetRepositoriesURL()
	f = nil
	f.GetRepositoriesURL()
}

func TestFineGrainedPersonalAccessTokenRequest_GetRepositorySelection(tt *testing.T) {
	tt.Parallel()
	f := &FineGrainedPersonalAccessTokenRequest{}
	f.GetRepositorySelection()
	f = nil
	f.GetRepositorySelection()
}

func TestFineGrainedPersonalAccessTokenRequest_GetTokenExpired(tt *testing.T) {
	tt.Parallel()
	f := &FineGrainedPersonalAccessTokenRequest{}
	f.GetTokenExpired()
	f = nil
	f.GetTokenExpired()
}

func TestFineGrainedPersonalAccessTokenRequest_GetTokenExpiresAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	f := &FineGrainedPersonalAccessTokenRequest{TokenExpiresAt: &zeroValue}
	f.GetTokenExpiresAt()
	f = &FineGrainedPersonalAccessTokenRequest{}
	f.GetTokenExpiresAt()
	f = nil
	f.GetTokenExpiresAt()
}

func TestFineGrainedPersonalAccessTokenRequest_GetTokenID(tt *testing.T) {
	tt.Parallel()
	f := &FineGrainedPersonalAccessTokenRequest{}
	f.GetTokenID()
	f = nil
	f.GetTokenID()
}

func TestFineGrainedPersonalAccessTokenRequest_GetTokenLastUsedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	f := &FineGrainedPersonalAccessTokenRequest{TokenLastUsedAt: &zeroValue}
	f.GetTokenLastUsedAt()
	f = &FineGrainedPersonalAccessTokenRequest{}
	f.GetTokenLastUsedAt()
	f = nil
	f.GetTokenLastUsedAt()
}

func TestFineGrainedPersonalAccessTokenRequest_GetTokenName(tt *testing.T) {
	tt.Parallel()
	f := &FineGrainedPersonalAccessTokenRequest{}
	f.GetTokenName()
	f = nil
	f.GetTokenName()
}

func TestFirstPatchedVersion_GetIdentifier(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	f := &FirstPatchedVersion{Identifier: &zeroValue}
	f.GetIdentifier()
	f = &FirstPatchedVersion{}
	f.GetIdentifier()
	f = nil
	f.GetIdentifier()
}

func TestForkEvent_GetForkee(tt *testing.T) {
	tt.Parallel()
	f := &ForkEvent{}
	f.GetForkee()
	f = nil
	f.GetForkee()
}

func TestForkEvent_GetInstallation(tt *testing.T) {
	tt.Parallel()
	f := &ForkEvent{}
	f.GetInstallation()
	f = nil
	f.GetInstallation()
}

func TestForkEvent_GetRepo(tt *testing.T) {
	tt.Parallel()
	f := &ForkEvent{}
	f.GetRepo()
	f = nil
	f.GetRepo()
}

func TestForkEvent_GetSender(tt *testing.T) {
	tt.Parallel()
	f := &ForkEvent{}
	f.GetSender()
	f = nil
	f.GetSender()
}

func TestGenerateNotesRequest_GetConfigurationFilePath(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	g := &GenerateNotesRequest{ConfigurationFilePath: &zeroValue}
	g.GetConfigurationFilePath()
	g = &GenerateNotesRequest{}
	g.GetConfigurationFilePath()
	g = nil
	g.GetConfigurationFilePath()
}

func TestGenerateNotesRequest_GetPreviousTagName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	g := &GenerateNotesRequest{PreviousTagName: &zeroValue}
	g.GetPreviousTagName()
	g = &GenerateNotesRequest{}
	g.GetPreviousTagName()
	g = nil
	g.GetPreviousTagName()
}

func TestGenerateNotesRequest_GetTagName(tt *testing.T) {
	tt.Parallel()
	g := &GenerateNotesRequest{}
	g.GetTagName()
	g = nil
	g.GetTagName()
}

func TestGenerateNotesRequest_GetTargetCommitish(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	g := &GenerateNotesRequest{TargetCommitish: &zeroValue}
	g.GetTargetCommitish()
	g = &GenerateNotesRequest{}
	g.GetTargetCommitish()
	g = nil
	g.GetTargetCommitish()
}

func TestGetAuditLogOptions_GetInclude(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	g := &GetAuditLogOptions{Include: &zeroValue}
	g.GetInclude()
	g = &GetAuditLogOptions{}
	g.GetInclude()
	g = nil
	g.GetInclude()
}

func TestGetAuditLogOptions_GetOrder(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	g := &GetAuditLogOptions{Order: &zeroValue}
	g.GetOrder()
	g = &GetAuditLogOptions{}
	g.GetOrder()
	g = nil
	g.GetOrder()
}

func TestGetAuditLogOptions_GetPhrase(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	g := &GetAuditLogOptions{Phrase: &zeroValue}
	g.GetPhrase()
	g = &GetAuditLogOptions{}
	g.GetPhrase()
	g = nil
	g.GetPhrase()
}

func TestGetCodeownersErrorsOptions_GetRef(tt *testing.T) {
	tt.Parallel()
	g := &GetCodeownersErrorsOptions{}
	g.GetRef()
	g = nil
	g.GetRef()
}

func TestGetProjectItemOptions_GetFields(tt *testing.T) {
	tt.Parallel()
	zeroValue := []int64{}
	g := &GetProjectItemOptions{Fields: zeroValue}
	g.GetFields()
	g = &GetProjectItemOptions{}
	g.GetFields()
	g = nil
	g.GetFields()
}

func TestGetProvisionedSCIMGroupEnterpriseOptions_GetExcludedAttributes(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	g := &GetProvisionedSCIMGroupEnterpriseOptions{ExcludedAttributes: &zeroValue}
	g.GetExcludedAttributes()
	g = &GetProvisionedSCIMGroupEnterpriseOptions{}
	g.GetExcludedAttributes()
	g = nil
	g.GetExcludedAttributes()
}

func TestGist_GetComments(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	g := &Gist{Comments: &zeroValue}
	g.GetComments()
	g = &Gist{}
	g.GetComments()
	g = nil
	g.GetComments()
}

func TestGist_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	g := &Gist{CreatedAt: &zeroValue}
	g.GetCreatedAt()
	g = &Gist{}
	g.GetCreatedAt()
	g = nil
	g.GetCreatedAt()
}

func TestGist_GetDescription(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	g := &Gist{Description: &zeroValue}
	g.GetDescription()
	g = &Gist{}
	g.GetDescription()
	g = nil
	g.GetDescription()
}

func TestGist_GetFiles(tt *testing.T) {
	tt.Parallel()
	zeroValue := map[GistFilename]GistFile{}
	g := &Gist{Files: zeroValue}
	g.GetFiles()
	g = &Gist{}
	g.GetFiles()
	g = nil
	g.GetFiles()
}

func TestGist_GetGitPullURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	g := &Gist{GitPullURL: &zeroValue}
	g.GetGitPullURL()
	g = &Gist{}
	g.GetGitPullURL()
	g = nil
	g.GetGitPullURL()
}

func TestGist_GetGitPushURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	g := &Gist{GitPushURL: &zeroValue}
	g.GetGitPushURL()
	g = &Gist{}
	g.GetGitPushURL()
	g = nil
	g.GetGitPushURL()
}

func TestGist_GetHTMLURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	g := &Gist{HTMLURL: &zeroValue}
	g.GetHTMLURL()
	g = &Gist{}
	g.GetHTMLURL()
	g = nil
	g.GetHTMLURL()
}

func TestGist_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	g := &Gist{ID: &zeroValue}
	g.GetID()
	g = &Gist{}
	g.GetID()
	g = nil
	g.GetID()
}

func TestGist_GetNodeID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	g := &Gist{NodeID: &zeroValue}
	g.GetNodeID()
	g = &Gist{}
	g.GetNodeID()
	g = nil
	g.GetNodeID()
}

func TestGist_GetOwner(tt *testing.T) {
	tt.Parallel()
	g := &Gist{}
	g.GetOwner()
	g = nil
	g.GetOwner()
}

func TestGist_GetPublic(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	g := &Gist{Public: &zeroValue}
	g.GetPublic()
	g = &Gist{}
	g.GetPublic()
	g = nil
	g.GetPublic()
}

func TestGist_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	g := &Gist{UpdatedAt: &zeroValue}
	g.GetUpdatedAt()
	g = &Gist{}
	g.GetUpdatedAt()
	g = nil
	g.GetUpdatedAt()
}

func TestGistComment_GetBody(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	g := &GistComment{Body: &zeroValue}
	g.GetBody()
	g = &GistComment{}
	g.GetBody()
	g = nil
	g.GetBody()
}

func TestGistComment_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	g := &GistComment{CreatedAt: &zeroValue}
	g.GetCreatedAt()
	g = &GistComment{}
	g.GetCreatedAt()
	g = nil
	g.GetCreatedAt()
}

func TestGistComment_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	g := &GistComment{ID: &zeroValue}
	g.GetID()
	g = &GistComment{}
	g.GetID()
	g = nil
	g.GetID()
}

func TestGistComment_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	g := &GistComment{URL: &zeroValue}
	g.GetURL()
	g = &GistComment{}
	g.GetURL()
	g = nil
	g.GetURL()
}

func TestGistComment_GetUser(tt *testing.T) {
	tt.Parallel()
	g := &GistComment{}
	g.GetUser()
	g = nil
	g.GetUser()
}

func TestGistCommit_GetChangeStatus(tt *testing.T) {
	tt.Parallel()
	g := &GistCommit{}
	g.GetChangeStatus()
	g = nil
	g.GetChangeStatus()
}

func TestGistCommit_GetCommittedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	g := &GistCommit{CommittedAt: &zeroValue}
	g.GetCommittedAt()
	g = &GistCommit{}
	g.GetCommittedAt()
	g = nil
	g.GetCommittedAt()
}

func TestGistCommit_GetNodeID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	g := &GistCommit{NodeID: &zeroValue}
	g.GetNodeID()
	g = &GistCommit{}
	g.GetNodeID()
	g = nil
	g.GetNodeID()
}

func TestGistCommit_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	g := &GistCommit{URL: &zeroValue}
	g.GetURL()
	g = &GistCommit{}
	g.GetURL()
	g = nil
	g.GetURL()
}

func TestGistCommit_GetUser(tt *testing.T) {
	tt.Parallel()
	g := &GistCommit{}
	g.GetUser()
	g = nil
	g.GetUser()
}

func TestGistCommit_GetVersion(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	g := &GistCommit{Version: &zeroValue}
	g.GetVersion()
	g = &GistCommit{}
	g.GetVersion()
	g = nil
	g.GetVersion()
}

func TestGistFile_GetContent(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	g := &GistFile{Content: &zeroValue}
	g.GetContent()
	g = &GistFile{}
	g.GetContent()
	g = nil
	g.GetContent()
}

func TestGistFile_GetFilename(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	g := &GistFile{Filename: &zeroValue}
	g.GetFilename()
	g = &GistFile{}
	g.GetFilename()
	g = nil
	g.GetFilename()
}

func TestGistFile_GetLanguage(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	g := &GistFile{Language: &zeroValue}
	g.GetLanguage()
	g = &GistFile{}
	g.GetLanguage()
	g = nil
	g.GetLanguage()
}

func TestGistFile_GetRawURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	g := &GistFile{RawURL: &zeroValue}
	g.GetRawURL()
	g = &GistFile{}
	g.GetRawURL()
	g = nil
	g.GetRawURL()
}

func TestGistFile_GetSize(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	g := &GistFile{Size: &zeroValue}
	g.GetSize()
	g = &GistFile{}
	g.GetSize()
	g = nil
	g.GetSize()
}

func TestGistFile_GetType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	g := &GistFile{Type: &zeroValue}
	g.GetType()
	g = &GistFile{}
	g.GetType()
	g = nil
	g.GetType()
}

func TestGistFork_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	g := &GistFork{CreatedAt: &zeroValue}
	g.GetCreatedAt()
	g = &GistFork{}
	g.GetCreatedAt()
	g = nil
	g.GetCreatedAt()
}

func TestGistFork_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	g := &GistFork{ID: &zeroValue}
	g.GetID()
	g = &GistFork{}
	g.GetID()
	g = nil
	g.GetID()
}

func TestGistFork_GetNodeID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	g := &GistFork{NodeID: &zeroValue}
	g.GetNodeID()
	g = &GistFork{}
	g.GetNodeID()
	g = nil
	g.GetNodeID()
}

func TestGistFork_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	g := &GistFork{UpdatedAt: &zeroValue}
	g.GetUpdatedAt()
	g = &GistFork{}
	g.GetUpdatedAt()
	g = nil
	g.GetUpdatedAt()
}

func TestGistFork_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	g := &GistFork{URL: &zeroValue}
	g.GetURL()
	g = &GistFork{}
	g.GetURL()
	g = nil
	g.GetURL()
}

func TestGistFork_GetUser(tt *testing.T) {
	tt.Parallel()
	g := &GistFork{}
	g.GetUser()
	g = nil
	g.GetUser()
}

func TestGistListOptions_GetSince(tt *testing.T) {
	tt.Parallel()
	g := &GistListOptions{}
	g.GetSince()
	g = nil
	g.GetSince()
}

func TestGistStats_GetPrivateGists(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	g := &GistStats{PrivateGists: &zeroValue}
	g.GetPrivateGists()
	g = &GistStats{}
	g.GetPrivateGists()
	g = nil
	g.GetPrivateGists()
}

func TestGistStats_GetPublicGists(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	g := &GistStats{PublicGists: &zeroValue}
	g.GetPublicGists()
	g = &GistStats{}
	g.GetPublicGists()
	g = nil
	g.GetPublicGists()
}

func TestGistStats_GetTotalGists(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	g := &GistStats{TotalGists: &zeroValue}
	g.GetTotalGists()
	g = &GistStats{}
	g.GetTotalGists()
	g = nil
	g.GetTotalGists()
}

func TestGitHubAppAuthorizationEvent_GetAction(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	g := &GitHubAppAuthorizationEvent{Action: &zeroValue}
	g.GetAction()
	g = &GitHubAppAuthorizationEvent{}
	g.GetAction()
	g = nil
	g.GetAction()
}

func TestGitHubAppAuthorizationEvent_GetInstallation(tt *testing.T) {
	tt.Parallel()
	g := &GitHubAppAuthorizationEvent{}
	g.GetInstallation()
	g = nil
	g.GetInstallation()
}

func TestGitHubAppAuthorizationEvent_GetSender(tt *testing.T) {
	tt.Parallel()
	g := &GitHubAppAuthorizationEvent{}
	g.GetSender()
	g = nil
	g.GetSender()
}

func TestGitignore_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	g := &Gitignore{Name: &zeroValue}
	g.GetName()
	g = &Gitignore{}
	g.GetName()
	g = nil
	g.GetName()
}

func TestGitignore_GetSource(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	g := &Gitignore{Source: &zeroValue}
	g.GetSource()
	g = &Gitignore{}
	g.GetSource()
	g = nil
	g.GetSource()
}

func TestGitObject_GetSHA(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	g := &GitObject{SHA: &zeroValue}
	g.GetSHA()
	g = &GitObject{}
	g.GetSHA()
	g = nil
	g.GetSHA()
}

func TestGitObject_GetType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	g := &GitObject{Type: &zeroValue}
	g.GetType()
	g = &GitObject{}
	g.GetType()
	g = nil
	g.GetType()
}

func TestGitObject_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	g := &GitObject{URL: &zeroValue}
	g.GetURL()
	g = &GitObject{}
	g.GetURL()
	g = nil
	g.GetURL()
}

func TestGlobalSecurityAdvisory_GetCredits(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*Credit{}
	g := &GlobalSecurityAdvisory{Credits: zeroValue}
	g.GetCredits()
	g = &GlobalSecurityAdvisory{}
	g.GetCredits()
	g = nil
	g.GetCredits()
}

func TestGlobalSecurityAdvisory_GetGithubReviewedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	g := &GlobalSecurityAdvisory{GithubReviewedAt: &zeroValue}
	g.GetGithubReviewedAt()
	g = &GlobalSecurityAdvisory{}
	g.GetGithubReviewedAt()
	g = nil
	g.GetGithubReviewedAt()
}

func TestGlobalSecurityAdvisory_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	g := &GlobalSecurityAdvisory{ID: &zeroValue}
	g.GetID()
	g = &GlobalSecurityAdvisory{}
	g.GetID()
	g = nil
	g.GetID()
}

func TestGlobalSecurityAdvisory_GetNVDPublishedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	g := &GlobalSecurityAdvisory{NVDPublishedAt: &zeroValue}
	g.GetNVDPublishedAt()
	g = &GlobalSecurityAdvisory{}
	g.GetNVDPublishedAt()
	g = nil
	g.GetNVDPublishedAt()
}

func TestGlobalSecurityAdvisory_GetReferences(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	g := &GlobalSecurityAdvisory{References: zeroValue}
	g.GetReferences()
	g = &GlobalSecurityAdvisory{}
	g.GetReferences()
	g = nil
	g.GetReferences()
}

func TestGlobalSecurityAdvisory_GetRepositoryAdvisoryURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	g := &GlobalSecurityAdvisory{RepositoryAdvisoryURL: &zeroValue}
	g.GetRepositoryAdvisoryURL()
	g = &GlobalSecurityAdvisory{}
	g.GetRepositoryAdvisoryURL()
	g = nil
	g.GetRepositoryAdvisoryURL()
}

func TestGlobalSecurityAdvisory_GetSourceCodeLocation(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	g := &GlobalSecurityAdvisory{SourceCodeLocation: &zeroValue}
	g.GetSourceCodeLocation()
	g = &GlobalSecurityAdvisory{}
	g.GetSourceCodeLocation()
	g = nil
	g.GetSourceCodeLocation()
}

func TestGlobalSecurityAdvisory_GetType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	g := &GlobalSecurityAdvisory{Type: &zeroValue}
	g.GetType()
	g = &GlobalSecurityAdvisory{}
	g.GetType()
	g = nil
	g.GetType()
}

func TestGlobalSecurityAdvisory_GetVulnerabilities(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*GlobalSecurityVulnerability{}
	g := &GlobalSecurityAdvisory{Vulnerabilities: zeroValue}
	g.GetVulnerabilities()
	g = &GlobalSecurityAdvisory{}
	g.GetVulnerabilities()
	g = nil
	g.GetVulnerabilities()
}

func TestGlobalSecurityVulnerability_GetFirstPatchedVersion(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	g := &GlobalSecurityVulnerability{FirstPatchedVersion: &zeroValue}
	g.GetFirstPatchedVersion()
	g = &GlobalSecurityVulnerability{}
	g.GetFirstPatchedVersion()
	g = nil
	g.GetFirstPatchedVersion()
}

func TestGlobalSecurityVulnerability_GetPackage(tt *testing.T) {
	tt.Parallel()
	g := &GlobalSecurityVulnerability{}
	g.GetPackage()
	g = nil
	g.GetPackage()
}

func TestGlobalSecurityVulnerability_GetVulnerableFunctions(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	g := &GlobalSecurityVulnerability{VulnerableFunctions: zeroValue}
	g.GetVulnerableFunctions()
	g = &GlobalSecurityVulnerability{}
	g.GetVulnerableFunctions()
	g = nil
	g.GetVulnerableFunctions()
}

func TestGlobalSecurityVulnerability_GetVulnerableVersionRange(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	g := &GlobalSecurityVulnerability{VulnerableVersionRange: &zeroValue}
	g.GetVulnerableVersionRange()
	g = &GlobalSecurityVulnerability{}
	g.GetVulnerableVersionRange()
	g = nil
	g.GetVulnerableVersionRange()
}

func TestGollumEvent_GetInstallation(tt *testing.T) {
	tt.Parallel()
	g := &GollumEvent{}
	g.GetInstallation()
	g = nil
	g.GetInstallation()
}

func TestGollumEvent_GetOrg(tt *testing.T) {
	tt.Parallel()
	g := &GollumEvent{}
	g.GetOrg()
	g = nil
	g.GetOrg()
}

func TestGollumEvent_GetPages(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*Page{}
	g := &GollumEvent{Pages: zeroValue}
	g.GetPages()
	g = &GollumEvent{}
	g.GetPages()
	g = nil
	g.GetPages()
}

func TestGollumEvent_GetRepo(tt *testing.T) {
	tt.Parallel()
	g := &GollumEvent{}
	g.GetRepo()
	g = nil
	g.GetRepo()
}

func TestGollumEvent_GetSender(tt *testing.T) {
	tt.Parallel()
	g := &GollumEvent{}
	g.GetSender()
	g = nil
	g.GetSender()
}

func TestGoogleCloudConfig_GetBucket(tt *testing.T) {
	tt.Parallel()
	g := &GoogleCloudConfig{}
	g.GetBucket()
	g = nil
	g.GetBucket()
}

func TestGoogleCloudConfig_GetEncryptedJSONCredentials(tt *testing.T) {
	tt.Parallel()
	g := &GoogleCloudConfig{}
	g.GetEncryptedJSONCredentials()
	g = nil
	g.GetEncryptedJSONCredentials()
}

func TestGoogleCloudConfig_GetKeyID(tt *testing.T) {
	tt.Parallel()
	g := &GoogleCloudConfig{}
	g.GetKeyID()
	g = nil
	g.GetKeyID()
}

func TestGPGEmail_GetEmail(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	g := &GPGEmail{Email: &zeroValue}
	g.GetEmail()
	g = &GPGEmail{}
	g.GetEmail()
	g = nil
	g.GetEmail()
}

func TestGPGEmail_GetVerified(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	g := &GPGEmail{Verified: &zeroValue}
	g.GetVerified()
	g = &GPGEmail{}
	g.GetVerified()
	g = nil
	g.GetVerified()
}

func TestGPGKey_GetCanCertify(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	g := &GPGKey{CanCertify: &zeroValue}
	g.GetCanCertify()
	g = &GPGKey{}
	g.GetCanCertify()
	g = nil
	g.GetCanCertify()
}

func TestGPGKey_GetCanEncryptComms(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	g := &GPGKey{CanEncryptComms: &zeroValue}
	g.GetCanEncryptComms()
	g = &GPGKey{}
	g.GetCanEncryptComms()
	g = nil
	g.GetCanEncryptComms()
}

func TestGPGKey_GetCanEncryptStorage(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	g := &GPGKey{CanEncryptStorage: &zeroValue}
	g.GetCanEncryptStorage()
	g = &GPGKey{}
	g.GetCanEncryptStorage()
	g = nil
	g.GetCanEncryptStorage()
}

func TestGPGKey_GetCanSign(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	g := &GPGKey{CanSign: &zeroValue}
	g.GetCanSign()
	g = &GPGKey{}
	g.GetCanSign()
	g = nil
	g.GetCanSign()
}

func TestGPGKey_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	g := &GPGKey{CreatedAt: &zeroValue}
	g.GetCreatedAt()
	g = &GPGKey{}
	g.GetCreatedAt()
	g = nil
	g.GetCreatedAt()
}

func TestGPGKey_GetEmails(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*GPGEmail{}
	g := &GPGKey{Emails: zeroValue}
	g.GetEmails()
	g = &GPGKey{}
	g.GetEmails()
	g = nil
	g.GetEmails()
}

func TestGPGKey_GetExpiresAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	g := &GPGKey{ExpiresAt: &zeroValue}
	g.GetExpiresAt()
	g = &GPGKey{}
	g.GetExpiresAt()
	g = nil
	g.GetExpiresAt()
}

func TestGPGKey_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	g := &GPGKey{ID: &zeroValue}
	g.GetID()
	g = &GPGKey{}
	g.GetID()
	g = nil
	g.GetID()
}

func TestGPGKey_GetKeyID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	g := &GPGKey{KeyID: &zeroValue}
	g.GetKeyID()
	g = &GPGKey{}
	g.GetKeyID()
	g = nil
	g.GetKeyID()
}

func TestGPGKey_GetPrimaryKeyID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	g := &GPGKey{PrimaryKeyID: &zeroValue}
	g.GetPrimaryKeyID()
	g = &GPGKey{}
	g.GetPrimaryKeyID()
	g = nil
	g.GetPrimaryKeyID()
}

func TestGPGKey_GetPublicKey(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	g := &GPGKey{PublicKey: &zeroValue}
	g.GetPublicKey()
	g = &GPGKey{}
	g.GetPublicKey()
	g = nil
	g.GetPublicKey()
}

func TestGPGKey_GetRawKey(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	g := &GPGKey{RawKey: &zeroValue}
	g.GetRawKey()
	g = &GPGKey{}
	g.GetRawKey()
	g = nil
	g.GetRawKey()
}

func TestGPGKey_GetSubkeys(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*GPGKey{}
	g := &GPGKey{Subkeys: zeroValue}
	g.GetSubkeys()
	g = &GPGKey{}
	g.GetSubkeys()
	g = nil
	g.GetSubkeys()
}

func TestGrant_GetApp(tt *testing.T) {
	tt.Parallel()
	g := &Grant{}
	g.GetApp()
	g = nil
	g.GetApp()
}

func TestGrant_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	g := &Grant{CreatedAt: &zeroValue}
	g.GetCreatedAt()
	g = &Grant{}
	g.GetCreatedAt()
	g = nil
	g.GetCreatedAt()
}

func TestGrant_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	g := &Grant{ID: &zeroValue}
	g.GetID()
	g = &Grant{}
	g.GetID()
	g = nil
	g.GetID()
}

func TestGrant_GetScopes(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	g := &Grant{Scopes: zeroValue}
	g.GetScopes()
	g = &Grant{}
	g.GetScopes()
	g = nil
	g.GetScopes()
}

func TestGrant_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	g := &Grant{UpdatedAt: &zeroValue}
	g.GetUpdatedAt()
	g = &Grant{}
	g.GetUpdatedAt()
	g = nil
	g.GetUpdatedAt()
}

func TestGrant_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	g := &Grant{URL: &zeroValue}
	g.GetURL()
	g = &Grant{}
	g.GetURL()
	g = nil
	g.GetURL()
}

func TestHeadCommit_GetAdded(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	h := &HeadCommit{Added: zeroValue}
	h.GetAdded()
	h = &HeadCommit{}
	h.GetAdded()
	h = nil
	h.GetAdded()
}

func TestHeadCommit_GetAuthor(tt *testing.T) {
	tt.Parallel()
	h := &HeadCommit{}
	h.GetAuthor()
	h = nil
	h.GetAuthor()
}

func TestHeadCommit_GetCommitter(tt *testing.T) {
	tt.Parallel()
	h := &HeadCommit{}
	h.GetCommitter()
	h = nil
	h.GetCommitter()
}

func TestHeadCommit_GetDistinct(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	h := &HeadCommit{Distinct: &zeroValue}
	h.GetDistinct()
	h = &HeadCommit{}
	h.GetDistinct()
	h = nil
	h.GetDistinct()
}

func TestHeadCommit_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	h := &HeadCommit{ID: &zeroValue}
	h.GetID()
	h = &HeadCommit{}
	h.GetID()
	h = nil
	h.GetID()
}

func TestHeadCommit_GetMessage(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	h := &HeadCommit{Message: &zeroValue}
	h.GetMessage()
	h = &HeadCommit{}
	h.GetMessage()
	h = nil
	h.GetMessage()
}

func TestHeadCommit_GetModified(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	h := &HeadCommit{Modified: zeroValue}
	h.GetModified()
	h = &HeadCommit{}
	h.GetModified()
	h = nil
	h.GetModified()
}

func TestHeadCommit_GetRemoved(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	h := &HeadCommit{Removed: zeroValue}
	h.GetRemoved()
	h = &HeadCommit{}
	h.GetRemoved()
	h = nil
	h.GetRemoved()
}

func TestHeadCommit_GetSHA(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	h := &HeadCommit{SHA: &zeroValue}
	h.GetSHA()
	h = &HeadCommit{}
	h.GetSHA()
	h = nil
	h.GetSHA()
}

func TestHeadCommit_GetTimestamp(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	h := &HeadCommit{Timestamp: &zeroValue}
	h.GetTimestamp()
	h = &HeadCommit{}
	h.GetTimestamp()
	h = nil
	h.GetTimestamp()
}

func TestHeadCommit_GetTreeID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	h := &HeadCommit{TreeID: &zeroValue}
	h.GetTreeID()
	h = &HeadCommit{}
	h.GetTreeID()
	h = nil
	h.GetTreeID()
}

func TestHeadCommit_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	h := &HeadCommit{URL: &zeroValue}
	h.GetURL()
	h = &HeadCommit{}
	h.GetURL()
	h = nil
	h.GetURL()
}

func TestHecConfig_GetDomain(tt *testing.T) {
	tt.Parallel()
	h := &HecConfig{}
	h.GetDomain()
	h = nil
	h.GetDomain()
}

func TestHecConfig_GetEncryptedToken(tt *testing.T) {
	tt.Parallel()
	h := &HecConfig{}
	h.GetEncryptedToken()
	h = nil
	h.GetEncryptedToken()
}

func TestHecConfig_GetKeyID(tt *testing.T) {
	tt.Parallel()
	h := &HecConfig{}
	h.GetKeyID()
	h = nil
	h.GetKeyID()
}

func TestHecConfig_GetPath(tt *testing.T) {
	tt.Parallel()
	h := &HecConfig{}
	h.GetPath()
	h = nil
	h.GetPath()
}

func TestHecConfig_GetPort(tt *testing.T) {
	tt.Parallel()
	h := &HecConfig{}
	h.GetPort()
	h = nil
	h.GetPort()
}

func TestHecConfig_GetSSLVerify(tt *testing.T) {
	tt.Parallel()
	h := &HecConfig{}
	h.GetSSLVerify()
	h = nil
	h.GetSSLVerify()
}

func TestHook_GetActive(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	h := &Hook{Active: &zeroValue}
	h.GetActive()
	h = &Hook{}
	h.GetActive()
	h = nil
	h.GetActive()
}

func TestHook_GetConfig(tt *testing.T) {
	tt.Parallel()
	h := &Hook{}
	h.GetConfig()
	h = nil
	h.GetConfig()
}

func TestHook_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	h := &Hook{CreatedAt: &zeroValue}
	h.GetCreatedAt()
	h = &Hook{}
	h.GetCreatedAt()
	h = nil
	h.GetCreatedAt()
}

func TestHook_GetEvents(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	h := &Hook{Events: zeroValue}
	h.GetEvents()
	h = &Hook{}
	h.GetEvents()
	h = nil
	h.GetEvents()
}

func TestHook_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	h := &Hook{ID: &zeroValue}
	h.GetID()
	h = &Hook{}
	h.GetID()
	h = nil
	h.GetID()
}

func TestHook_GetLastResponse(tt *testing.T) {
	tt.Parallel()
	zeroValue := map[string]any{}
	h := &Hook{LastResponse: zeroValue}
	h.GetLastResponse()
	h = &Hook{}
	h.GetLastResponse()
	h = nil
	h.GetLastResponse()
}

func TestHook_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	h := &Hook{Name: &zeroValue}
	h.GetName()
	h = &Hook{}
	h.GetName()
	h = nil
	h.GetName()
}

func TestHook_GetPingURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	h := &Hook{PingURL: &zeroValue}
	h.GetPingURL()
	h = &Hook{}
	h.GetPingURL()
	h = nil
	h.GetPingURL()
}

func TestHook_GetTestURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	h := &Hook{TestURL: &zeroValue}
	h.GetTestURL()
	h = &Hook{}
	h.GetTestURL()
	h = nil
	h.GetTestURL()
}

func TestHook_GetType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	h := &Hook{Type: &zeroValue}
	h.GetType()
	h = &Hook{}
	h.GetType()
	h = nil
	h.GetType()
}

func TestHook_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	h := &Hook{UpdatedAt: &zeroValue}
	h.GetUpdatedAt()
	h = &Hook{}
	h.GetUpdatedAt()
	h = nil
	h.GetUpdatedAt()
}

func TestHook_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	h := &Hook{URL: &zeroValue}
	h.GetURL()
	h = &Hook{}
	h.GetURL()
	h = nil
	h.GetURL()
}

func TestHookConfig_GetContentType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	h := &HookConfig{ContentType: &zeroValue}
	h.GetContentType()
	h = &HookConfig{}
	h.GetContentType()
	h = nil
	h.GetContentType()
}

func TestHookConfig_GetInsecureSSL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	h := &HookConfig{InsecureSSL: &zeroValue}
	h.GetInsecureSSL()
	h = &HookConfig{}
	h.GetInsecureSSL()
	h = nil
	h.GetInsecureSSL()
}

func TestHookConfig_GetSecret(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	h := &HookConfig{Secret: &zeroValue}
	h.GetSecret()
	h = &HookConfig{}
	h.GetSecret()
	h = nil
	h.GetSecret()
}

func TestHookConfig_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	h := &HookConfig{URL: &zeroValue}
	h.GetURL()
	h = &HookConfig{}
	h.GetURL()
	h = nil
	h.GetURL()
}

func TestHookDelivery_GetAction(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	h := &HookDelivery{Action: &zeroValue}
	h.GetAction()
	h = &HookDelivery{}
	h.GetAction()
	h = nil
	h.GetAction()
}

func TestHookDelivery_GetDeliveredAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	h := &HookDelivery{DeliveredAt: &zeroValue}
	h.GetDeliveredAt()
	h = &HookDelivery{}
	h.GetDeliveredAt()
	h = nil
	h.GetDeliveredAt()
}

func TestHookDelivery_GetDuration(tt *testing.T) {
	tt.Parallel()
	var zeroValue float64
	h := &HookDelivery{Duration: &zeroValue}
	h.GetDuration()
	h = &HookDelivery{}
	h.GetDuration()
	h = nil
	h.GetDuration()
}

func TestHookDelivery_GetEvent(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	h := &HookDelivery{Event: &zeroValue}
	h.GetEvent()
	h = &HookDelivery{}
	h.GetEvent()
	h = nil
	h.GetEvent()
}

func TestHookDelivery_GetGUID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	h := &HookDelivery{GUID: &zeroValue}
	h.GetGUID()
	h = &HookDelivery{}
	h.GetGUID()
	h = nil
	h.GetGUID()
}

func TestHookDelivery_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	h := &HookDelivery{ID: &zeroValue}
	h.GetID()
	h = &HookDelivery{}
	h.GetID()
	h = nil
	h.GetID()
}

func TestHookDelivery_GetInstallationID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	h := &HookDelivery{InstallationID: &zeroValue}
	h.GetInstallationID()
	h = &HookDelivery{}
	h.GetInstallationID()
	h = nil
	h.GetInstallationID()
}

func TestHookDelivery_GetRedelivery(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	h := &HookDelivery{Redelivery: &zeroValue}
	h.GetRedelivery()
	h = &HookDelivery{}
	h.GetRedelivery()
	h = nil
	h.GetRedelivery()
}

func TestHookDelivery_GetRepositoryID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	h := &HookDelivery{RepositoryID: &zeroValue}
	h.GetRepositoryID()
	h = &HookDelivery{}
	h.GetRepositoryID()
	h = nil
	h.GetRepositoryID()
}

func TestHookDelivery_GetRequest(tt *testing.T) {
	tt.Parallel()
	h := &HookDelivery{}
	h.GetRequest()
	h = nil
	h.GetRequest()
}

func TestHookDelivery_GetResponse(tt *testing.T) {
	tt.Parallel()
	h := &HookDelivery{}
	h.GetResponse()
	h = nil
	h.GetResponse()
}

func TestHookDelivery_GetStatus(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	h := &HookDelivery{Status: &zeroValue}
	h.GetStatus()
	h = &HookDelivery{}
	h.GetStatus()
	h = nil
	h.GetStatus()
}

func TestHookDelivery_GetStatusCode(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	h := &HookDelivery{StatusCode: &zeroValue}
	h.GetStatusCode()
	h = &HookDelivery{}
	h.GetStatusCode()
	h = nil
	h.GetStatusCode()
}

func TestHookRequest_GetHeaders(tt *testing.T) {
	tt.Parallel()
	zeroValue := map[string]string{}
	h := &HookRequest{Headers: zeroValue}
	h.GetHeaders()
	h = &HookRequest{}
	h.GetHeaders()
	h = nil
	h.GetHeaders()
}

func TestHookRequest_GetRawPayload(tt *testing.T) {
	tt.Parallel()
	var zeroValue json.RawMessage
	h := &HookRequest{RawPayload: &zeroValue}
	h.GetRawPayload()
	h = &HookRequest{}
	h.GetRawPayload()
	h = nil
	h.GetRawPayload()
}

func TestHookResponse_GetHeaders(tt *testing.T) {
	tt.Parallel()
	zeroValue := map[string]string{}
	h := &HookResponse{Headers: zeroValue}
	h.GetHeaders()
	h = &HookResponse{}
	h.GetHeaders()
	h = nil
	h.GetHeaders()
}

func TestHookResponse_GetRawPayload(tt *testing.T) {
	tt.Parallel()
	var zeroValue json.RawMessage
	h := &HookResponse{RawPayload: &zeroValue}
	h.GetRawPayload()
	h = &HookResponse{}
	h.GetRawPayload()
	h = nil
	h.GetRawPayload()
}

func TestHookStats_GetActiveHooks(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	h := &HookStats{ActiveHooks: &zeroValue}
	h.GetActiveHooks()
	h = &HookStats{}
	h.GetActiveHooks()
	h = nil
	h.GetActiveHooks()
}

func TestHookStats_GetInactiveHooks(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	h := &HookStats{InactiveHooks: &zeroValue}
	h.GetInactiveHooks()
	h = &HookStats{}
	h.GetInactiveHooks()
	h = nil
	h.GetInactiveHooks()
}

func TestHookStats_GetTotalHooks(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	h := &HookStats{TotalHooks: &zeroValue}
	h.GetTotalHooks()
	h = &HookStats{}
	h.GetTotalHooks()
	h = nil
	h.GetTotalHooks()
}

func TestHostedRunner_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	h := &HostedRunner{ID: &zeroValue}
	h.GetID()
	h = &HostedRunner{}
	h.GetID()
	h = nil
	h.GetID()
}

func TestHostedRunner_GetImageDetails(tt *testing.T) {
	tt.Parallel()
	h := &HostedRunner{}
	h.GetImageDetails()
	h = nil
	h.GetImageDetails()
}

func TestHostedRunner_GetLastActiveOn(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	h := &HostedRunner{LastActiveOn: &zeroValue}
	h.GetLastActiveOn()
	h = &HostedRunner{}
	h.GetLastActiveOn()
	h = nil
	h.GetLastActiveOn()
}

func TestHostedRunner_GetMachineSizeDetails(tt *testing.T) {
	tt.Parallel()
	h := &HostedRunner{}
	h.GetMachineSizeDetails()
	h = nil
	h.GetMachineSizeDetails()
}

func TestHostedRunner_GetMaximumRunners(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	h := &HostedRunner{MaximumRunners: &zeroValue}
	h.GetMaximumRunners()
	h = &HostedRunner{}
	h.GetMaximumRunners()
	h = nil
	h.GetMaximumRunners()
}

func TestHostedRunner_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	h := &HostedRunner{Name: &zeroValue}
	h.GetName()
	h = &HostedRunner{}
	h.GetName()
	h = nil
	h.GetName()
}

func TestHostedRunner_GetPlatform(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	h := &HostedRunner{Platform: &zeroValue}
	h.GetPlatform()
	h = &HostedRunner{}
	h.GetPlatform()
	h = nil
	h.GetPlatform()
}

func TestHostedRunner_GetPublicIPEnabled(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	h := &HostedRunner{PublicIPEnabled: &zeroValue}
	h.GetPublicIPEnabled()
	h = &HostedRunner{}
	h.GetPublicIPEnabled()
	h = nil
	h.GetPublicIPEnabled()
}

func TestHostedRunner_GetPublicIPs(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*HostedRunnerPublicIP{}
	h := &HostedRunner{PublicIPs: zeroValue}
	h.GetPublicIPs()
	h = &HostedRunner{}
	h.GetPublicIPs()
	h = nil
	h.GetPublicIPs()
}

func TestHostedRunner_GetRunnerGroupID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	h := &HostedRunner{RunnerGroupID: &zeroValue}
	h.GetRunnerGroupID()
	h = &HostedRunner{}
	h.GetRunnerGroupID()
	h = nil
	h.GetRunnerGroupID()
}

func TestHostedRunner_GetStatus(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	h := &HostedRunner{Status: &zeroValue}
	h.GetStatus()
	h = &HostedRunner{}
	h.GetStatus()
	h = nil
	h.GetStatus()
}

func TestHostedRunnerCustomImage_GetID(tt *testing.T) {
	tt.Parallel()
	h := &HostedRunnerCustomImage{}
	h.GetID()
	h = nil
	h.GetID()
}

func TestHostedRunnerCustomImage_GetLatestVersion(tt *testing.T) {
	tt.Parallel()
	h := &HostedRunnerCustomImage{}
	h.GetLatestVersion()
	h = nil
	h.GetLatestVersion()
}

func TestHostedRunnerCustomImage_GetName(tt *testing.T) {
	tt.Parallel()
	h := &HostedRunnerCustomImage{}
	h.GetName()
	h = nil
	h.GetName()
}

func TestHostedRunnerCustomImage_GetPlatform(tt *testing.T) {
	tt.Parallel()
	h := &HostedRunnerCustomImage{}
	h.GetPlatform()
	h = nil
	h.GetPlatform()
}

func TestHostedRunnerCustomImage_GetSource(tt *testing.T) {
	tt.Parallel()
	h := &HostedRunnerCustomImage{}
	h.GetSource()
	h = nil
	h.GetSource()
}

func TestHostedRunnerCustomImage_GetState(tt *testing.T) {
	tt.Parallel()
	h := &HostedRunnerCustomImage{}
	h.GetState()
	h = nil
	h.GetState()
}

func TestHostedRunnerCustomImage_GetTotalVersionsSize(tt *testing.T) {
	tt.Parallel()
	h := &HostedRunnerCustomImage{}
	h.GetTotalVersionsSize()
	h = nil
	h.GetTotalVersionsSize()
}

func TestHostedRunnerCustomImage_GetVersionsCount(tt *testing.T) {
	tt.Parallel()
	h := &HostedRunnerCustomImage{}
	h.GetVersionsCount()
	h = nil
	h.GetVersionsCount()
}

func TestHostedRunnerCustomImages_GetImages(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*HostedRunnerCustomImage{}
	h := &HostedRunnerCustomImages{Images: zeroValue}
	h.GetImages()
	h = &HostedRunnerCustomImages{}
	h.GetImages()
	h = nil
	h.GetImages()
}

func TestHostedRunnerCustomImages_GetTotalCount(tt *testing.T) {
	tt.Parallel()
	h := &HostedRunnerCustomImages{}
	h.GetTotalCount()
	h = nil
	h.GetTotalCount()
}

func TestHostedRunnerCustomImageVersion_GetCreatedOn(tt *testing.T) {
	tt.Parallel()
	h := &HostedRunnerCustomImageVersion{}
	h.GetCreatedOn()
	h = nil
	h.GetCreatedOn()
}

func TestHostedRunnerCustomImageVersion_GetSizeGB(tt *testing.T) {
	tt.Parallel()
	h := &HostedRunnerCustomImageVersion{}
	h.GetSizeGB()
	h = nil
	h.GetSizeGB()
}

func TestHostedRunnerCustomImageVersion_GetState(tt *testing.T) {
	tt.Parallel()
	h := &HostedRunnerCustomImageVersion{}
	h.GetState()
	h = nil
	h.GetState()
}

func TestHostedRunnerCustomImageVersion_GetStateDetails(tt *testing.T) {
	tt.Parallel()
	h := &HostedRunnerCustomImageVersion{}
	h.GetStateDetails()
	h = nil
	h.GetStateDetails()
}

func TestHostedRunnerCustomImageVersion_GetVersion(tt *testing.T) {
	tt.Parallel()
	h := &HostedRunnerCustomImageVersion{}
	h.GetVersion()
	h = nil
	h.GetVersion()
}

func TestHostedRunnerCustomImageVersions_GetImageVersions(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*HostedRunnerCustomImageVersion{}
	h := &HostedRunnerCustomImageVersions{ImageVersions: zeroValue}
	h.GetImageVersions()
	h = &HostedRunnerCustomImageVersions{}
	h.GetImageVersions()
	h = nil
	h.GetImageVersions()
}

func TestHostedRunnerCustomImageVersions_GetTotalCount(tt *testing.T) {
	tt.Parallel()
	h := &HostedRunnerCustomImageVersions{}
	h.GetTotalCount()
	h = nil
	h.GetTotalCount()
}

func TestHostedRunnerImage_GetID(tt *testing.T) {
	tt.Parallel()
	h := &HostedRunnerImage{}
	h.GetID()
	h = nil
	h.GetID()
}

func TestHostedRunnerImage_GetSource(tt *testing.T) {
	tt.Parallel()
	h := &HostedRunnerImage{}
	h.GetSource()
	h = nil
	h.GetSource()
}

func TestHostedRunnerImage_GetVersion(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	h := &HostedRunnerImage{Version: &zeroValue}
	h.GetVersion()
	h = &HostedRunnerImage{}
	h.GetVersion()
	h = nil
	h.GetVersion()
}

func TestHostedRunnerImageDetail_GetDisplayName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	h := &HostedRunnerImageDetail{DisplayName: &zeroValue}
	h.GetDisplayName()
	h = &HostedRunnerImageDetail{}
	h.GetDisplayName()
	h = nil
	h.GetDisplayName()
}

func TestHostedRunnerImageDetail_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	h := &HostedRunnerImageDetail{ID: &zeroValue}
	h.GetID()
	h = &HostedRunnerImageDetail{}
	h.GetID()
	h = nil
	h.GetID()
}

func TestHostedRunnerImageDetail_GetSizeGB(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	h := &HostedRunnerImageDetail{SizeGB: &zeroValue}
	h.GetSizeGB()
	h = &HostedRunnerImageDetail{}
	h.GetSizeGB()
	h = nil
	h.GetSizeGB()
}

func TestHostedRunnerImageDetail_GetSource(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	h := &HostedRunnerImageDetail{Source: &zeroValue}
	h.GetSource()
	h = &HostedRunnerImageDetail{}
	h.GetSource()
	h = nil
	h.GetSource()
}

func TestHostedRunnerImageDetail_GetVersion(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	h := &HostedRunnerImageDetail{Version: &zeroValue}
	h.GetVersion()
	h = &HostedRunnerImageDetail{}
	h.GetVersion()
	h = nil
	h.GetVersion()
}

func TestHostedRunnerImages_GetImages(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*HostedRunnerImageSpecs{}
	h := &HostedRunnerImages{Images: zeroValue}
	h.GetImages()
	h = &HostedRunnerImages{}
	h.GetImages()
	h = nil
	h.GetImages()
}

func TestHostedRunnerImages_GetTotalCount(tt *testing.T) {
	tt.Parallel()
	h := &HostedRunnerImages{}
	h.GetTotalCount()
	h = nil
	h.GetTotalCount()
}

func TestHostedRunnerImageSpecs_GetDisplayName(tt *testing.T) {
	tt.Parallel()
	h := &HostedRunnerImageSpecs{}
	h.GetDisplayName()
	h = nil
	h.GetDisplayName()
}

func TestHostedRunnerImageSpecs_GetID(tt *testing.T) {
	tt.Parallel()
	h := &HostedRunnerImageSpecs{}
	h.GetID()
	h = nil
	h.GetID()
}

func TestHostedRunnerImageSpecs_GetPlatform(tt *testing.T) {
	tt.Parallel()
	h := &HostedRunnerImageSpecs{}
	h.GetPlatform()
	h = nil
	h.GetPlatform()
}

func TestHostedRunnerImageSpecs_GetSizeGB(tt *testing.T) {
	tt.Parallel()
	h := &HostedRunnerImageSpecs{}
	h.GetSizeGB()
	h = nil
	h.GetSizeGB()
}

func TestHostedRunnerImageSpecs_GetSource(tt *testing.T) {
	tt.Parallel()
	h := &HostedRunnerImageSpecs{}
	h.GetSource()
	h = nil
	h.GetSource()
}

func TestHostedRunnerMachineSpec_GetCPUCores(tt *testing.T) {
	tt.Parallel()
	h := &HostedRunnerMachineSpec{}
	h.GetCPUCores()
	h = nil
	h.GetCPUCores()
}

func TestHostedRunnerMachineSpec_GetID(tt *testing.T) {
	tt.Parallel()
	h := &HostedRunnerMachineSpec{}
	h.GetID()
	h = nil
	h.GetID()
}

func TestHostedRunnerMachineSpec_GetMemoryGB(tt *testing.T) {
	tt.Parallel()
	h := &HostedRunnerMachineSpec{}
	h.GetMemoryGB()
	h = nil
	h.GetMemoryGB()
}

func TestHostedRunnerMachineSpec_GetStorageGB(tt *testing.T) {
	tt.Parallel()
	h := &HostedRunnerMachineSpec{}
	h.GetStorageGB()
	h = nil
	h.GetStorageGB()
}

func TestHostedRunnerMachineSpecs_GetMachineSpecs(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*HostedRunnerMachineSpec{}
	h := &HostedRunnerMachineSpecs{MachineSpecs: zeroValue}
	h.GetMachineSpecs()
	h = &HostedRunnerMachineSpecs{}
	h.GetMachineSpecs()
	h = nil
	h.GetMachineSpecs()
}

func TestHostedRunnerMachineSpecs_GetTotalCount(tt *testing.T) {
	tt.Parallel()
	h := &HostedRunnerMachineSpecs{}
	h.GetTotalCount()
	h = nil
	h.GetTotalCount()
}

func TestHostedRunnerPlatforms_GetPlatforms(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	h := &HostedRunnerPlatforms{Platforms: zeroValue}
	h.GetPlatforms()
	h = &HostedRunnerPlatforms{}
	h.GetPlatforms()
	h = nil
	h.GetPlatforms()
}

func TestHostedRunnerPlatforms_GetTotalCount(tt *testing.T) {
	tt.Parallel()
	h := &HostedRunnerPlatforms{}
	h.GetTotalCount()
	h = nil
	h.GetTotalCount()
}

func TestHostedRunnerPublicIP_GetEnabled(tt *testing.T) {
	tt.Parallel()
	h := &HostedRunnerPublicIP{}
	h.GetEnabled()
	h = nil
	h.GetEnabled()
}

func TestHostedRunnerPublicIP_GetLength(tt *testing.T) {
	tt.Parallel()
	h := &HostedRunnerPublicIP{}
	h.GetLength()
	h = nil
	h.GetLength()
}

func TestHostedRunnerPublicIP_GetPrefix(tt *testing.T) {
	tt.Parallel()
	h := &HostedRunnerPublicIP{}
	h.GetPrefix()
	h = nil
	h.GetPrefix()
}

func TestHostedRunnerPublicIPLimits_GetPublicIPs(tt *testing.T) {
	tt.Parallel()
	h := &HostedRunnerPublicIPLimits{}
	h.GetPublicIPs()
	h = nil
	h.GetPublicIPs()
}

func TestHostedRunners_GetRunners(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*HostedRunner{}
	h := &HostedRunners{Runners: zeroValue}
	h.GetRunners()
	h = &HostedRunners{}
	h.GetRunners()
	h = nil
	h.GetRunners()
}

func TestHostedRunners_GetTotalCount(tt *testing.T) {
	tt.Parallel()
	h := &HostedRunners{}
	h.GetTotalCount()
	h = nil
	h.GetTotalCount()
}

func TestHovercard_GetContexts(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*UserContext{}
	h := &Hovercard{Contexts: zeroValue}
	h.GetContexts()
	h = &Hovercard{}
	h.GetContexts()
	h = nil
	h.GetContexts()
}

func TestHovercardOptions_GetSubjectID(tt *testing.T) {
	tt.Parallel()
	h := &HovercardOptions{}
	h.GetSubjectID()
	h = nil
	h.GetSubjectID()
}

func TestHovercardOptions_GetSubjectType(tt *testing.T) {
	tt.Parallel()
	h := &HovercardOptions{}
	h.GetSubjectType()
	h = nil
	h.GetSubjectType()
}

func TestIDPGroup_GetGroupDescription(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &IDPGroup{GroupDescription: &zeroValue}
	i.GetGroupDescription()
	i = &IDPGroup{}
	i.GetGroupDescription()
	i = nil
	i.GetGroupDescription()
}

func TestIDPGroup_GetGroupID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &IDPGroup{GroupID: &zeroValue}
	i.GetGroupID()
	i = &IDPGroup{}
	i.GetGroupID()
	i = nil
	i.GetGroupID()
}

func TestIDPGroup_GetGroupName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &IDPGroup{GroupName: &zeroValue}
	i.GetGroupName()
	i = &IDPGroup{}
	i.GetGroupName()
	i = nil
	i.GetGroupName()
}

func TestIDPGroupList_GetGroups(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*IDPGroup{}
	i := &IDPGroupList{Groups: zeroValue}
	i.GetGroups()
	i = &IDPGroupList{}
	i.GetGroups()
	i = nil
	i.GetGroups()
}

func TestImmutableReleasePolicy_GetEnforcedRepositories(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &ImmutableReleasePolicy{EnforcedRepositories: &zeroValue}
	i.GetEnforcedRepositories()
	i = &ImmutableReleasePolicy{}
	i.GetEnforcedRepositories()
	i = nil
	i.GetEnforcedRepositories()
}

func TestImmutableReleasePolicy_GetSelectedRepositoryIDs(tt *testing.T) {
	tt.Parallel()
	zeroValue := []int64{}
	i := &ImmutableReleasePolicy{SelectedRepositoryIDs: zeroValue}
	i.GetSelectedRepositoryIDs()
	i = &ImmutableReleasePolicy{}
	i.GetSelectedRepositoryIDs()
	i = nil
	i.GetSelectedRepositoryIDs()
}

func TestImmutableReleaseSettings_GetEnforcedRepositories(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &ImmutableReleaseSettings{EnforcedRepositories: &zeroValue}
	i.GetEnforcedRepositories()
	i = &ImmutableReleaseSettings{}
	i.GetEnforcedRepositories()
	i = nil
	i.GetEnforcedRepositories()
}

func TestImmutableReleaseSettings_GetSelectedRepositoriesURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &ImmutableReleaseSettings{SelectedRepositoriesURL: &zeroValue}
	i.GetSelectedRepositoriesURL()
	i = &ImmutableReleaseSettings{}
	i.GetSelectedRepositoriesURL()
	i = nil
	i.GetSelectedRepositoriesURL()
}

func TestImpersonateUserOptions_GetScopes(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	i := &ImpersonateUserOptions{Scopes: zeroValue}
	i.GetScopes()
	i = &ImpersonateUserOptions{}
	i.GetScopes()
	i = nil
	i.GetScopes()
}

func TestImport_GetAuthorsCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	i := &Import{AuthorsCount: &zeroValue}
	i.GetAuthorsCount()
	i = &Import{}
	i.GetAuthorsCount()
	i = nil
	i.GetAuthorsCount()
}

func TestImport_GetAuthorsURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &Import{AuthorsURL: &zeroValue}
	i.GetAuthorsURL()
	i = &Import{}
	i.GetAuthorsURL()
	i = nil
	i.GetAuthorsURL()
}

func TestImport_GetCommitCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	i := &Import{CommitCount: &zeroValue}
	i.GetCommitCount()
	i = &Import{}
	i.GetCommitCount()
	i = nil
	i.GetCommitCount()
}

func TestImport_GetFailedStep(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &Import{FailedStep: &zeroValue}
	i.GetFailedStep()
	i = &Import{}
	i.GetFailedStep()
	i = nil
	i.GetFailedStep()
}

func TestImport_GetHasLargeFiles(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	i := &Import{HasLargeFiles: &zeroValue}
	i.GetHasLargeFiles()
	i = &Import{}
	i.GetHasLargeFiles()
	i = nil
	i.GetHasLargeFiles()
}

func TestImport_GetHTMLURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &Import{HTMLURL: &zeroValue}
	i.GetHTMLURL()
	i = &Import{}
	i.GetHTMLURL()
	i = nil
	i.GetHTMLURL()
}

func TestImport_GetHumanName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &Import{HumanName: &zeroValue}
	i.GetHumanName()
	i = &Import{}
	i.GetHumanName()
	i = nil
	i.GetHumanName()
}

func TestImport_GetLargeFilesCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	i := &Import{LargeFilesCount: &zeroValue}
	i.GetLargeFilesCount()
	i = &Import{}
	i.GetLargeFilesCount()
	i = nil
	i.GetLargeFilesCount()
}

func TestImport_GetLargeFilesSize(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	i := &Import{LargeFilesSize: &zeroValue}
	i.GetLargeFilesSize()
	i = &Import{}
	i.GetLargeFilesSize()
	i = nil
	i.GetLargeFilesSize()
}

func TestImport_GetMessage(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &Import{Message: &zeroValue}
	i.GetMessage()
	i = &Import{}
	i.GetMessage()
	i = nil
	i.GetMessage()
}

func TestImport_GetPercent(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	i := &Import{Percent: &zeroValue}
	i.GetPercent()
	i = &Import{}
	i.GetPercent()
	i = nil
	i.GetPercent()
}

func TestImport_GetProjectChoices(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*Import{}
	i := &Import{ProjectChoices: zeroValue}
	i.GetProjectChoices()
	i = &Import{}
	i.GetProjectChoices()
	i = nil
	i.GetProjectChoices()
}

func TestImport_GetPushPercent(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	i := &Import{PushPercent: &zeroValue}
	i.GetPushPercent()
	i = &Import{}
	i.GetPushPercent()
	i = nil
	i.GetPushPercent()
}

func TestImport_GetRepositoryURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &Import{RepositoryURL: &zeroValue}
	i.GetRepositoryURL()
	i = &Import{}
	i.GetRepositoryURL()
	i = nil
	i.GetRepositoryURL()
}

func TestImport_GetStatus(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &Import{Status: &zeroValue}
	i.GetStatus()
	i = &Import{}
	i.GetStatus()
	i = nil
	i.GetStatus()
}

func TestImport_GetStatusText(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &Import{StatusText: &zeroValue}
	i.GetStatusText()
	i = &Import{}
	i.GetStatusText()
	i = nil
	i.GetStatusText()
}

func TestImport_GetTFVCProject(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &Import{TFVCProject: &zeroValue}
	i.GetTFVCProject()
	i = &Import{}
	i.GetTFVCProject()
	i = nil
	i.GetTFVCProject()
}

func TestImport_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &Import{URL: &zeroValue}
	i.GetURL()
	i = &Import{}
	i.GetURL()
	i = nil
	i.GetURL()
}

func TestImport_GetUseLFS(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &Import{UseLFS: &zeroValue}
	i.GetUseLFS()
	i = &Import{}
	i.GetUseLFS()
	i = nil
	i.GetUseLFS()
}

func TestImport_GetVCS(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &Import{VCS: &zeroValue}
	i.GetVCS()
	i = &Import{}
	i.GetVCS()
	i = nil
	i.GetVCS()
}

func TestImport_GetVCSPassword(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &Import{VCSPassword: &zeroValue}
	i.GetVCSPassword()
	i = &Import{}
	i.GetVCSPassword()
	i = nil
	i.GetVCSPassword()
}

func TestImport_GetVCSURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &Import{VCSURL: &zeroValue}
	i.GetVCSURL()
	i = &Import{}
	i.GetVCSURL()
	i = nil
	i.GetVCSURL()
}

func TestImport_GetVCSUsername(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &Import{VCSUsername: &zeroValue}
	i.GetVCSUsername()
	i = &Import{}
	i.GetVCSUsername()
	i = nil
	i.GetVCSUsername()
}

func TestInitialConfigOptions_GetLicense(tt *testing.T) {
	tt.Parallel()
	i := &InitialConfigOptions{}
	i.GetLicense()
	i = nil
	i.GetLicense()
}

func TestInitialConfigOptions_GetPassword(tt *testing.T) {
	tt.Parallel()
	i := &InitialConfigOptions{}
	i.GetPassword()
	i = nil
	i.GetPassword()
}

func TestInstallableOrganization_GetAccessibleRepositoriesURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallableOrganization{AccessibleRepositoriesURL: &zeroValue}
	i.GetAccessibleRepositoriesURL()
	i = &InstallableOrganization{}
	i.GetAccessibleRepositoriesURL()
	i = nil
	i.GetAccessibleRepositoriesURL()
}

func TestInstallableOrganization_GetID(tt *testing.T) {
	tt.Parallel()
	i := &InstallableOrganization{}
	i.GetID()
	i = nil
	i.GetID()
}

func TestInstallableOrganization_GetLogin(tt *testing.T) {
	tt.Parallel()
	i := &InstallableOrganization{}
	i.GetLogin()
	i = nil
	i.GetLogin()
}

func TestInstallAppRequest_GetClientID(tt *testing.T) {
	tt.Parallel()
	i := &InstallAppRequest{}
	i.GetClientID()
	i = nil
	i.GetClientID()
}

func TestInstallAppRequest_GetRepositories(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	i := &InstallAppRequest{Repositories: zeroValue}
	i.GetRepositories()
	i = &InstallAppRequest{}
	i.GetRepositories()
	i = nil
	i.GetRepositories()
}

func TestInstallAppRequest_GetRepositorySelection(tt *testing.T) {
	tt.Parallel()
	i := &InstallAppRequest{}
	i.GetRepositorySelection()
	i = nil
	i.GetRepositorySelection()
}

func TestInstallation_GetAccessTokensURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &Installation{AccessTokensURL: &zeroValue}
	i.GetAccessTokensURL()
	i = &Installation{}
	i.GetAccessTokensURL()
	i = nil
	i.GetAccessTokensURL()
}

func TestInstallation_GetAccount(tt *testing.T) {
	tt.Parallel()
	i := &Installation{}
	i.GetAccount()
	i = nil
	i.GetAccount()
}

func TestInstallation_GetAppID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	i := &Installation{AppID: &zeroValue}
	i.GetAppID()
	i = &Installation{}
	i.GetAppID()
	i = nil
	i.GetAppID()
}

func TestInstallation_GetAppSlug(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &Installation{AppSlug: &zeroValue}
	i.GetAppSlug()
	i = &Installation{}
	i.GetAppSlug()
	i = nil
	i.GetAppSlug()
}

func TestInstallation_GetClientID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &Installation{ClientID: &zeroValue}
	i.GetClientID()
	i = &Installation{}
	i.GetClientID()
	i = nil
	i.GetClientID()
}

func TestInstallation_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	i := &Installation{CreatedAt: &zeroValue}
	i.GetCreatedAt()
	i = &Installation{}
	i.GetCreatedAt()
	i = nil
	i.GetCreatedAt()
}

func TestInstallation_GetEvents(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	i := &Installation{Events: zeroValue}
	i.GetEvents()
	i = &Installation{}
	i.GetEvents()
	i = nil
	i.GetEvents()
}

func TestInstallation_GetHasMultipleSingleFiles(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	i := &Installation{HasMultipleSingleFiles: &zeroValue}
	i.GetHasMultipleSingleFiles()
	i = &Installation{}
	i.GetHasMultipleSingleFiles()
	i = nil
	i.GetHasMultipleSingleFiles()
}

func TestInstallation_GetHTMLURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &Installation{HTMLURL: &zeroValue}
	i.GetHTMLURL()
	i = &Installation{}
	i.GetHTMLURL()
	i = nil
	i.GetHTMLURL()
}

func TestInstallation_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	i := &Installation{ID: &zeroValue}
	i.GetID()
	i = &Installation{}
	i.GetID()
	i = nil
	i.GetID()
}

func TestInstallation_GetNodeID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &Installation{NodeID: &zeroValue}
	i.GetNodeID()
	i = &Installation{}
	i.GetNodeID()
	i = nil
	i.GetNodeID()
}

func TestInstallation_GetPermissions(tt *testing.T) {
	tt.Parallel()
	i := &Installation{}
	i.GetPermissions()
	i = nil
	i.GetPermissions()
}

func TestInstallation_GetRepositoriesURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &Installation{RepositoriesURL: &zeroValue}
	i.GetRepositoriesURL()
	i = &Installation{}
	i.GetRepositoriesURL()
	i = nil
	i.GetRepositoriesURL()
}

func TestInstallation_GetRepositorySelection(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &Installation{RepositorySelection: &zeroValue}
	i.GetRepositorySelection()
	i = &Installation{}
	i.GetRepositorySelection()
	i = nil
	i.GetRepositorySelection()
}

func TestInstallation_GetSingleFileName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &Installation{SingleFileName: &zeroValue}
	i.GetSingleFileName()
	i = &Installation{}
	i.GetSingleFileName()
	i = nil
	i.GetSingleFileName()
}

func TestInstallation_GetSingleFilePaths(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	i := &Installation{SingleFilePaths: zeroValue}
	i.GetSingleFilePaths()
	i = &Installation{}
	i.GetSingleFilePaths()
	i = nil
	i.GetSingleFilePaths()
}

func TestInstallation_GetSuspendedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	i := &Installation{SuspendedAt: &zeroValue}
	i.GetSuspendedAt()
	i = &Installation{}
	i.GetSuspendedAt()
	i = nil
	i.GetSuspendedAt()
}

func TestInstallation_GetSuspendedBy(tt *testing.T) {
	tt.Parallel()
	i := &Installation{}
	i.GetSuspendedBy()
	i = nil
	i.GetSuspendedBy()
}

func TestInstallation_GetTargetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	i := &Installation{TargetID: &zeroValue}
	i.GetTargetID()
	i = &Installation{}
	i.GetTargetID()
	i = nil
	i.GetTargetID()
}

func TestInstallation_GetTargetType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &Installation{TargetType: &zeroValue}
	i.GetTargetType()
	i = &Installation{}
	i.GetTargetType()
	i = nil
	i.GetTargetType()
}

func TestInstallation_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	i := &Installation{UpdatedAt: &zeroValue}
	i.GetUpdatedAt()
	i = &Installation{}
	i.GetUpdatedAt()
	i = nil
	i.GetUpdatedAt()
}

func TestInstallationChanges_GetLogin(tt *testing.T) {
	tt.Parallel()
	i := &InstallationChanges{}
	i.GetLogin()
	i = nil
	i.GetLogin()
}

func TestInstallationChanges_GetSlug(tt *testing.T) {
	tt.Parallel()
	i := &InstallationChanges{}
	i.GetSlug()
	i = nil
	i.GetSlug()
}

func TestInstallationEvent_GetAction(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationEvent{Action: &zeroValue}
	i.GetAction()
	i = &InstallationEvent{}
	i.GetAction()
	i = nil
	i.GetAction()
}

func TestInstallationEvent_GetInstallation(tt *testing.T) {
	tt.Parallel()
	i := &InstallationEvent{}
	i.GetInstallation()
	i = nil
	i.GetInstallation()
}

func TestInstallationEvent_GetOrg(tt *testing.T) {
	tt.Parallel()
	i := &InstallationEvent{}
	i.GetOrg()
	i = nil
	i.GetOrg()
}

func TestInstallationEvent_GetRepositories(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*Repository{}
	i := &InstallationEvent{Repositories: zeroValue}
	i.GetRepositories()
	i = &InstallationEvent{}
	i.GetRepositories()
	i = nil
	i.GetRepositories()
}

func TestInstallationEvent_GetRequester(tt *testing.T) {
	tt.Parallel()
	i := &InstallationEvent{}
	i.GetRequester()
	i = nil
	i.GetRequester()
}

func TestInstallationEvent_GetSender(tt *testing.T) {
	tt.Parallel()
	i := &InstallationEvent{}
	i.GetSender()
	i = nil
	i.GetSender()
}

func TestInstallationLoginChange_GetFrom(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationLoginChange{From: &zeroValue}
	i.GetFrom()
	i = &InstallationLoginChange{}
	i.GetFrom()
	i = nil
	i.GetFrom()
}

func TestInstallationPermissions_GetActions(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{Actions: &zeroValue}
	i.GetActions()
	i = &InstallationPermissions{}
	i.GetActions()
	i = nil
	i.GetActions()
}

func TestInstallationPermissions_GetActionsVariables(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{ActionsVariables: &zeroValue}
	i.GetActionsVariables()
	i = &InstallationPermissions{}
	i.GetActionsVariables()
	i = nil
	i.GetActionsVariables()
}

func TestInstallationPermissions_GetAdministration(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{Administration: &zeroValue}
	i.GetAdministration()
	i = &InstallationPermissions{}
	i.GetAdministration()
	i = nil
	i.GetAdministration()
}

func TestInstallationPermissions_GetAttestations(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{Attestations: &zeroValue}
	i.GetAttestations()
	i = &InstallationPermissions{}
	i.GetAttestations()
	i = nil
	i.GetAttestations()
}

func TestInstallationPermissions_GetBlocking(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{Blocking: &zeroValue}
	i.GetBlocking()
	i = &InstallationPermissions{}
	i.GetBlocking()
	i = nil
	i.GetBlocking()
}

func TestInstallationPermissions_GetChecks(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{Checks: &zeroValue}
	i.GetChecks()
	i = &InstallationPermissions{}
	i.GetChecks()
	i = nil
	i.GetChecks()
}

func TestInstallationPermissions_GetCodespaces(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{Codespaces: &zeroValue}
	i.GetCodespaces()
	i = &InstallationPermissions{}
	i.GetCodespaces()
	i = nil
	i.GetCodespaces()
}

func TestInstallationPermissions_GetCodespacesLifecycleAdmin(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{CodespacesLifecycleAdmin: &zeroValue}
	i.GetCodespacesLifecycleAdmin()
	i = &InstallationPermissions{}
	i.GetCodespacesLifecycleAdmin()
	i = nil
	i.GetCodespacesLifecycleAdmin()
}

func TestInstallationPermissions_GetCodespacesMetadata(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{CodespacesMetadata: &zeroValue}
	i.GetCodespacesMetadata()
	i = &InstallationPermissions{}
	i.GetCodespacesMetadata()
	i = nil
	i.GetCodespacesMetadata()
}

func TestInstallationPermissions_GetCodespacesSecrets(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{CodespacesSecrets: &zeroValue}
	i.GetCodespacesSecrets()
	i = &InstallationPermissions{}
	i.GetCodespacesSecrets()
	i = nil
	i.GetCodespacesSecrets()
}

func TestInstallationPermissions_GetCodespacesUserSecrets(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{CodespacesUserSecrets: &zeroValue}
	i.GetCodespacesUserSecrets()
	i = &InstallationPermissions{}
	i.GetCodespacesUserSecrets()
	i = nil
	i.GetCodespacesUserSecrets()
}

func TestInstallationPermissions_GetContentReferences(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{ContentReferences: &zeroValue}
	i.GetContentReferences()
	i = &InstallationPermissions{}
	i.GetContentReferences()
	i = nil
	i.GetContentReferences()
}

func TestInstallationPermissions_GetContents(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{Contents: &zeroValue}
	i.GetContents()
	i = &InstallationPermissions{}
	i.GetContents()
	i = nil
	i.GetContents()
}

func TestInstallationPermissions_GetCopilotMessages(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{CopilotMessages: &zeroValue}
	i.GetCopilotMessages()
	i = &InstallationPermissions{}
	i.GetCopilotMessages()
	i = nil
	i.GetCopilotMessages()
}

func TestInstallationPermissions_GetDependabotSecrets(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{DependabotSecrets: &zeroValue}
	i.GetDependabotSecrets()
	i = &InstallationPermissions{}
	i.GetDependabotSecrets()
	i = nil
	i.GetDependabotSecrets()
}

func TestInstallationPermissions_GetDeployments(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{Deployments: &zeroValue}
	i.GetDeployments()
	i = &InstallationPermissions{}
	i.GetDeployments()
	i = nil
	i.GetDeployments()
}

func TestInstallationPermissions_GetDiscussions(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{Discussions: &zeroValue}
	i.GetDiscussions()
	i = &InstallationPermissions{}
	i.GetDiscussions()
	i = nil
	i.GetDiscussions()
}

func TestInstallationPermissions_GetEmails(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{Emails: &zeroValue}
	i.GetEmails()
	i = &InstallationPermissions{}
	i.GetEmails()
	i = nil
	i.GetEmails()
}

func TestInstallationPermissions_GetEnterpriseAIControls(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{EnterpriseAIControls: &zeroValue}
	i.GetEnterpriseAIControls()
	i = &InstallationPermissions{}
	i.GetEnterpriseAIControls()
	i = nil
	i.GetEnterpriseAIControls()
}

func TestInstallationPermissions_GetEnterpriseCopilotMetrics(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{EnterpriseCopilotMetrics: &zeroValue}
	i.GetEnterpriseCopilotMetrics()
	i = &InstallationPermissions{}
	i.GetEnterpriseCopilotMetrics()
	i = nil
	i.GetEnterpriseCopilotMetrics()
}

func TestInstallationPermissions_GetEnterpriseCredentials(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{EnterpriseCredentials: &zeroValue}
	i.GetEnterpriseCredentials()
	i = &InstallationPermissions{}
	i.GetEnterpriseCredentials()
	i = nil
	i.GetEnterpriseCredentials()
}

func TestInstallationPermissions_GetEnterpriseCustomEnterpriseRoles(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{EnterpriseCustomEnterpriseRoles: &zeroValue}
	i.GetEnterpriseCustomEnterpriseRoles()
	i = &InstallationPermissions{}
	i.GetEnterpriseCustomEnterpriseRoles()
	i = nil
	i.GetEnterpriseCustomEnterpriseRoles()
}

func TestInstallationPermissions_GetEnterpriseCustomOrgRoles(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{EnterpriseCustomOrgRoles: &zeroValue}
	i.GetEnterpriseCustomOrgRoles()
	i = &InstallationPermissions{}
	i.GetEnterpriseCustomOrgRoles()
	i = nil
	i.GetEnterpriseCustomOrgRoles()
}

func TestInstallationPermissions_GetEnterpriseCustomProperties(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{EnterpriseCustomProperties: &zeroValue}
	i.GetEnterpriseCustomProperties()
	i = &InstallationPermissions{}
	i.GetEnterpriseCustomProperties()
	i = nil
	i.GetEnterpriseCustomProperties()
}

func TestInstallationPermissions_GetEnterpriseCustomPropertiesForOrgs(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{EnterpriseCustomPropertiesForOrgs: &zeroValue}
	i.GetEnterpriseCustomPropertiesForOrgs()
	i = &InstallationPermissions{}
	i.GetEnterpriseCustomPropertiesForOrgs()
	i = nil
	i.GetEnterpriseCustomPropertiesForOrgs()
}

func TestInstallationPermissions_GetEnterpriseOrganizationInstallations(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{EnterpriseOrganizationInstallations: &zeroValue}
	i.GetEnterpriseOrganizationInstallations()
	i = &InstallationPermissions{}
	i.GetEnterpriseOrganizationInstallations()
	i = nil
	i.GetEnterpriseOrganizationInstallations()
}

func TestInstallationPermissions_GetEnterpriseOrganizations(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{EnterpriseOrganizations: &zeroValue}
	i.GetEnterpriseOrganizations()
	i = &InstallationPermissions{}
	i.GetEnterpriseOrganizations()
	i = nil
	i.GetEnterpriseOrganizations()
}

func TestInstallationPermissions_GetEnterpriseOrgInstallationRepos(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{EnterpriseOrgInstallationRepos: &zeroValue}
	i.GetEnterpriseOrgInstallationRepos()
	i = &InstallationPermissions{}
	i.GetEnterpriseOrgInstallationRepos()
	i = nil
	i.GetEnterpriseOrgInstallationRepos()
}

func TestInstallationPermissions_GetEnterprisePeople(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{EnterprisePeople: &zeroValue}
	i.GetEnterprisePeople()
	i = &InstallationPermissions{}
	i.GetEnterprisePeople()
	i = nil
	i.GetEnterprisePeople()
}

func TestInstallationPermissions_GetEnterpriseSSO(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{EnterpriseSSO: &zeroValue}
	i.GetEnterpriseSSO()
	i = &InstallationPermissions{}
	i.GetEnterpriseSSO()
	i = nil
	i.GetEnterpriseSSO()
}

func TestInstallationPermissions_GetEnterpriseTeams(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{EnterpriseTeams: &zeroValue}
	i.GetEnterpriseTeams()
	i = &InstallationPermissions{}
	i.GetEnterpriseTeams()
	i = nil
	i.GetEnterpriseTeams()
}

func TestInstallationPermissions_GetEnvironments(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{Environments: &zeroValue}
	i.GetEnvironments()
	i = &InstallationPermissions{}
	i.GetEnvironments()
	i = nil
	i.GetEnvironments()
}

func TestInstallationPermissions_GetFollowers(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{Followers: &zeroValue}
	i.GetFollowers()
	i = &InstallationPermissions{}
	i.GetFollowers()
	i = nil
	i.GetFollowers()
}

func TestInstallationPermissions_GetGists(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{Gists: &zeroValue}
	i.GetGists()
	i = &InstallationPermissions{}
	i.GetGists()
	i = nil
	i.GetGists()
}

func TestInstallationPermissions_GetGitSigningSSHPublicKeys(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{GitSigningSSHPublicKeys: &zeroValue}
	i.GetGitSigningSSHPublicKeys()
	i = &InstallationPermissions{}
	i.GetGitSigningSSHPublicKeys()
	i = nil
	i.GetGitSigningSSHPublicKeys()
}

func TestInstallationPermissions_GetGPGKeys(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{GPGKeys: &zeroValue}
	i.GetGPGKeys()
	i = &InstallationPermissions{}
	i.GetGPGKeys()
	i = nil
	i.GetGPGKeys()
}

func TestInstallationPermissions_GetInteractionLimits(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{InteractionLimits: &zeroValue}
	i.GetInteractionLimits()
	i = &InstallationPermissions{}
	i.GetInteractionLimits()
	i = nil
	i.GetInteractionLimits()
}

func TestInstallationPermissions_GetIssues(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{Issues: &zeroValue}
	i.GetIssues()
	i = &InstallationPermissions{}
	i.GetIssues()
	i = nil
	i.GetIssues()
}

func TestInstallationPermissions_GetKeys(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{Keys: &zeroValue}
	i.GetKeys()
	i = &InstallationPermissions{}
	i.GetKeys()
	i = nil
	i.GetKeys()
}

func TestInstallationPermissions_GetMembers(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{Members: &zeroValue}
	i.GetMembers()
	i = &InstallationPermissions{}
	i.GetMembers()
	i = nil
	i.GetMembers()
}

func TestInstallationPermissions_GetMergeQueues(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{MergeQueues: &zeroValue}
	i.GetMergeQueues()
	i = &InstallationPermissions{}
	i.GetMergeQueues()
	i = nil
	i.GetMergeQueues()
}

func TestInstallationPermissions_GetMetadata(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{Metadata: &zeroValue}
	i.GetMetadata()
	i = &InstallationPermissions{}
	i.GetMetadata()
	i = nil
	i.GetMetadata()
}

func TestInstallationPermissions_GetOrganizationActionsVariables(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{OrganizationActionsVariables: &zeroValue}
	i.GetOrganizationActionsVariables()
	i = &InstallationPermissions{}
	i.GetOrganizationActionsVariables()
	i = nil
	i.GetOrganizationActionsVariables()
}

func TestInstallationPermissions_GetOrganizationAdministration(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{OrganizationAdministration: &zeroValue}
	i.GetOrganizationAdministration()
	i = &InstallationPermissions{}
	i.GetOrganizationAdministration()
	i = nil
	i.GetOrganizationAdministration()
}

func TestInstallationPermissions_GetOrganizationAnnouncementBanners(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{OrganizationAnnouncementBanners: &zeroValue}
	i.GetOrganizationAnnouncementBanners()
	i = &InstallationPermissions{}
	i.GetOrganizationAnnouncementBanners()
	i = nil
	i.GetOrganizationAnnouncementBanners()
}

func TestInstallationPermissions_GetOrganizationAPIInsights(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{OrganizationAPIInsights: &zeroValue}
	i.GetOrganizationAPIInsights()
	i = &InstallationPermissions{}
	i.GetOrganizationAPIInsights()
	i = nil
	i.GetOrganizationAPIInsights()
}

func TestInstallationPermissions_GetOrganizationCodespaces(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{OrganizationCodespaces: &zeroValue}
	i.GetOrganizationCodespaces()
	i = &InstallationPermissions{}
	i.GetOrganizationCodespaces()
	i = nil
	i.GetOrganizationCodespaces()
}

func TestInstallationPermissions_GetOrganizationCodespacesSecrets(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{OrganizationCodespacesSecrets: &zeroValue}
	i.GetOrganizationCodespacesSecrets()
	i = &InstallationPermissions{}
	i.GetOrganizationCodespacesSecrets()
	i = nil
	i.GetOrganizationCodespacesSecrets()
}

func TestInstallationPermissions_GetOrganizationCodespacesSettings(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{OrganizationCodespacesSettings: &zeroValue}
	i.GetOrganizationCodespacesSettings()
	i = &InstallationPermissions{}
	i.GetOrganizationCodespacesSettings()
	i = nil
	i.GetOrganizationCodespacesSettings()
}

func TestInstallationPermissions_GetOrganizationCopilotMetrics(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{OrganizationCopilotMetrics: &zeroValue}
	i.GetOrganizationCopilotMetrics()
	i = &InstallationPermissions{}
	i.GetOrganizationCopilotMetrics()
	i = nil
	i.GetOrganizationCopilotMetrics()
}

func TestInstallationPermissions_GetOrganizationCopilotSeatManagement(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{OrganizationCopilotSeatManagement: &zeroValue}
	i.GetOrganizationCopilotSeatManagement()
	i = &InstallationPermissions{}
	i.GetOrganizationCopilotSeatManagement()
	i = nil
	i.GetOrganizationCopilotSeatManagement()
}

func TestInstallationPermissions_GetOrganizationCustomOrgRoles(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{OrganizationCustomOrgRoles: &zeroValue}
	i.GetOrganizationCustomOrgRoles()
	i = &InstallationPermissions{}
	i.GetOrganizationCustomOrgRoles()
	i = nil
	i.GetOrganizationCustomOrgRoles()
}

func TestInstallationPermissions_GetOrganizationCustomProperties(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{OrganizationCustomProperties: &zeroValue}
	i.GetOrganizationCustomProperties()
	i = &InstallationPermissions{}
	i.GetOrganizationCustomProperties()
	i = nil
	i.GetOrganizationCustomProperties()
}

func TestInstallationPermissions_GetOrganizationCustomRoles(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{OrganizationCustomRoles: &zeroValue}
	i.GetOrganizationCustomRoles()
	i = &InstallationPermissions{}
	i.GetOrganizationCustomRoles()
	i = nil
	i.GetOrganizationCustomRoles()
}

func TestInstallationPermissions_GetOrganizationDependabotSecrets(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{OrganizationDependabotSecrets: &zeroValue}
	i.GetOrganizationDependabotSecrets()
	i = &InstallationPermissions{}
	i.GetOrganizationDependabotSecrets()
	i = nil
	i.GetOrganizationDependabotSecrets()
}

func TestInstallationPermissions_GetOrganizationEvents(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{OrganizationEvents: &zeroValue}
	i.GetOrganizationEvents()
	i = &InstallationPermissions{}
	i.GetOrganizationEvents()
	i = nil
	i.GetOrganizationEvents()
}

func TestInstallationPermissions_GetOrganizationHooks(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{OrganizationHooks: &zeroValue}
	i.GetOrganizationHooks()
	i = &InstallationPermissions{}
	i.GetOrganizationHooks()
	i = nil
	i.GetOrganizationHooks()
}

func TestInstallationPermissions_GetOrganizationKnowledgeBases(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{OrganizationKnowledgeBases: &zeroValue}
	i.GetOrganizationKnowledgeBases()
	i = &InstallationPermissions{}
	i.GetOrganizationKnowledgeBases()
	i = nil
	i.GetOrganizationKnowledgeBases()
}

func TestInstallationPermissions_GetOrganizationPackages(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{OrganizationPackages: &zeroValue}
	i.GetOrganizationPackages()
	i = &InstallationPermissions{}
	i.GetOrganizationPackages()
	i = nil
	i.GetOrganizationPackages()
}

func TestInstallationPermissions_GetOrganizationPersonalAccessTokenRequests(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{OrganizationPersonalAccessTokenRequests: &zeroValue}
	i.GetOrganizationPersonalAccessTokenRequests()
	i = &InstallationPermissions{}
	i.GetOrganizationPersonalAccessTokenRequests()
	i = nil
	i.GetOrganizationPersonalAccessTokenRequests()
}

func TestInstallationPermissions_GetOrganizationPersonalAccessTokens(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{OrganizationPersonalAccessTokens: &zeroValue}
	i.GetOrganizationPersonalAccessTokens()
	i = &InstallationPermissions{}
	i.GetOrganizationPersonalAccessTokens()
	i = nil
	i.GetOrganizationPersonalAccessTokens()
}

func TestInstallationPermissions_GetOrganizationPlan(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{OrganizationPlan: &zeroValue}
	i.GetOrganizationPlan()
	i = &InstallationPermissions{}
	i.GetOrganizationPlan()
	i = nil
	i.GetOrganizationPlan()
}

func TestInstallationPermissions_GetOrganizationPreReceiveHooks(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{OrganizationPreReceiveHooks: &zeroValue}
	i.GetOrganizationPreReceiveHooks()
	i = &InstallationPermissions{}
	i.GetOrganizationPreReceiveHooks()
	i = nil
	i.GetOrganizationPreReceiveHooks()
}

func TestInstallationPermissions_GetOrganizationProjects(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{OrganizationProjects: &zeroValue}
	i.GetOrganizationProjects()
	i = &InstallationPermissions{}
	i.GetOrganizationProjects()
	i = nil
	i.GetOrganizationProjects()
}

func TestInstallationPermissions_GetOrganizationSecrets(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{OrganizationSecrets: &zeroValue}
	i.GetOrganizationSecrets()
	i = &InstallationPermissions{}
	i.GetOrganizationSecrets()
	i = nil
	i.GetOrganizationSecrets()
}

func TestInstallationPermissions_GetOrganizationSelfHostedRunners(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{OrganizationSelfHostedRunners: &zeroValue}
	i.GetOrganizationSelfHostedRunners()
	i = &InstallationPermissions{}
	i.GetOrganizationSelfHostedRunners()
	i = nil
	i.GetOrganizationSelfHostedRunners()
}

func TestInstallationPermissions_GetOrganizationUserBlocking(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{OrganizationUserBlocking: &zeroValue}
	i.GetOrganizationUserBlocking()
	i = &InstallationPermissions{}
	i.GetOrganizationUserBlocking()
	i = nil
	i.GetOrganizationUserBlocking()
}

func TestInstallationPermissions_GetPackages(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{Packages: &zeroValue}
	i.GetPackages()
	i = &InstallationPermissions{}
	i.GetPackages()
	i = nil
	i.GetPackages()
}

func TestInstallationPermissions_GetPages(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{Pages: &zeroValue}
	i.GetPages()
	i = &InstallationPermissions{}
	i.GetPages()
	i = nil
	i.GetPages()
}

func TestInstallationPermissions_GetPlan(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{Plan: &zeroValue}
	i.GetPlan()
	i = &InstallationPermissions{}
	i.GetPlan()
	i = nil
	i.GetPlan()
}

func TestInstallationPermissions_GetProfile(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{Profile: &zeroValue}
	i.GetProfile()
	i = &InstallationPermissions{}
	i.GetProfile()
	i = nil
	i.GetProfile()
}

func TestInstallationPermissions_GetPullRequests(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{PullRequests: &zeroValue}
	i.GetPullRequests()
	i = &InstallationPermissions{}
	i.GetPullRequests()
	i = nil
	i.GetPullRequests()
}

func TestInstallationPermissions_GetRepositoryAdvisories(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{RepositoryAdvisories: &zeroValue}
	i.GetRepositoryAdvisories()
	i = &InstallationPermissions{}
	i.GetRepositoryAdvisories()
	i = nil
	i.GetRepositoryAdvisories()
}

func TestInstallationPermissions_GetRepositoryCustomProperties(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{RepositoryCustomProperties: &zeroValue}
	i.GetRepositoryCustomProperties()
	i = &InstallationPermissions{}
	i.GetRepositoryCustomProperties()
	i = nil
	i.GetRepositoryCustomProperties()
}

func TestInstallationPermissions_GetRepositoryHooks(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{RepositoryHooks: &zeroValue}
	i.GetRepositoryHooks()
	i = &InstallationPermissions{}
	i.GetRepositoryHooks()
	i = nil
	i.GetRepositoryHooks()
}

func TestInstallationPermissions_GetRepositoryPreReceiveHooks(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{RepositoryPreReceiveHooks: &zeroValue}
	i.GetRepositoryPreReceiveHooks()
	i = &InstallationPermissions{}
	i.GetRepositoryPreReceiveHooks()
	i = nil
	i.GetRepositoryPreReceiveHooks()
}

func TestInstallationPermissions_GetRepositoryProjects(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{RepositoryProjects: &zeroValue}
	i.GetRepositoryProjects()
	i = &InstallationPermissions{}
	i.GetRepositoryProjects()
	i = nil
	i.GetRepositoryProjects()
}

func TestInstallationPermissions_GetSecrets(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{Secrets: &zeroValue}
	i.GetSecrets()
	i = &InstallationPermissions{}
	i.GetSecrets()
	i = nil
	i.GetSecrets()
}

func TestInstallationPermissions_GetSecretScanningAlerts(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{SecretScanningAlerts: &zeroValue}
	i.GetSecretScanningAlerts()
	i = &InstallationPermissions{}
	i.GetSecretScanningAlerts()
	i = nil
	i.GetSecretScanningAlerts()
}

func TestInstallationPermissions_GetSecurityEvents(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{SecurityEvents: &zeroValue}
	i.GetSecurityEvents()
	i = &InstallationPermissions{}
	i.GetSecurityEvents()
	i = nil
	i.GetSecurityEvents()
}

func TestInstallationPermissions_GetSingleFile(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{SingleFile: &zeroValue}
	i.GetSingleFile()
	i = &InstallationPermissions{}
	i.GetSingleFile()
	i = nil
	i.GetSingleFile()
}

func TestInstallationPermissions_GetStarring(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{Starring: &zeroValue}
	i.GetStarring()
	i = &InstallationPermissions{}
	i.GetStarring()
	i = nil
	i.GetStarring()
}

func TestInstallationPermissions_GetStatuses(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{Statuses: &zeroValue}
	i.GetStatuses()
	i = &InstallationPermissions{}
	i.GetStatuses()
	i = nil
	i.GetStatuses()
}

func TestInstallationPermissions_GetTeamDiscussions(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{TeamDiscussions: &zeroValue}
	i.GetTeamDiscussions()
	i = &InstallationPermissions{}
	i.GetTeamDiscussions()
	i = nil
	i.GetTeamDiscussions()
}

func TestInstallationPermissions_GetUserEvents(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{UserEvents: &zeroValue}
	i.GetUserEvents()
	i = &InstallationPermissions{}
	i.GetUserEvents()
	i = nil
	i.GetUserEvents()
}

func TestInstallationPermissions_GetVulnerabilityAlerts(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{VulnerabilityAlerts: &zeroValue}
	i.GetVulnerabilityAlerts()
	i = &InstallationPermissions{}
	i.GetVulnerabilityAlerts()
	i = nil
	i.GetVulnerabilityAlerts()
}

func TestInstallationPermissions_GetWatching(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{Watching: &zeroValue}
	i.GetWatching()
	i = &InstallationPermissions{}
	i.GetWatching()
	i = nil
	i.GetWatching()
}

func TestInstallationPermissions_GetWorkflows(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationPermissions{Workflows: &zeroValue}
	i.GetWorkflows()
	i = &InstallationPermissions{}
	i.GetWorkflows()
	i = nil
	i.GetWorkflows()
}

func TestInstallationRepositoriesEvent_GetAction(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationRepositoriesEvent{Action: &zeroValue}
	i.GetAction()
	i = &InstallationRepositoriesEvent{}
	i.GetAction()
	i = nil
	i.GetAction()
}

func TestInstallationRepositoriesEvent_GetInstallation(tt *testing.T) {
	tt.Parallel()
	i := &InstallationRepositoriesEvent{}
	i.GetInstallation()
	i = nil
	i.GetInstallation()
}

func TestInstallationRepositoriesEvent_GetOrg(tt *testing.T) {
	tt.Parallel()
	i := &InstallationRepositoriesEvent{}
	i.GetOrg()
	i = nil
	i.GetOrg()
}

func TestInstallationRepositoriesEvent_GetRepositoriesAdded(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*Repository{}
	i := &InstallationRepositoriesEvent{RepositoriesAdded: zeroValue}
	i.GetRepositoriesAdded()
	i = &InstallationRepositoriesEvent{}
	i.GetRepositoriesAdded()
	i = nil
	i.GetRepositoriesAdded()
}

func TestInstallationRepositoriesEvent_GetRepositoriesRemoved(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*Repository{}
	i := &InstallationRepositoriesEvent{RepositoriesRemoved: zeroValue}
	i.GetRepositoriesRemoved()
	i = &InstallationRepositoriesEvent{}
	i.GetRepositoriesRemoved()
	i = nil
	i.GetRepositoriesRemoved()
}

func TestInstallationRepositoriesEvent_GetRepositorySelection(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationRepositoriesEvent{RepositorySelection: &zeroValue}
	i.GetRepositorySelection()
	i = &InstallationRepositoriesEvent{}
	i.GetRepositorySelection()
	i = nil
	i.GetRepositorySelection()
}

func TestInstallationRepositoriesEvent_GetSender(tt *testing.T) {
	tt.Parallel()
	i := &InstallationRepositoriesEvent{}
	i.GetSender()
	i = nil
	i.GetSender()
}

func TestInstallationRequest_GetAccount(tt *testing.T) {
	tt.Parallel()
	i := &InstallationRequest{}
	i.GetAccount()
	i = nil
	i.GetAccount()
}

func TestInstallationRequest_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	i := &InstallationRequest{CreatedAt: &zeroValue}
	i.GetCreatedAt()
	i = &InstallationRequest{}
	i.GetCreatedAt()
	i = nil
	i.GetCreatedAt()
}

func TestInstallationRequest_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	i := &InstallationRequest{ID: &zeroValue}
	i.GetID()
	i = &InstallationRequest{}
	i.GetID()
	i = nil
	i.GetID()
}

func TestInstallationRequest_GetNodeID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationRequest{NodeID: &zeroValue}
	i.GetNodeID()
	i = &InstallationRequest{}
	i.GetNodeID()
	i = nil
	i.GetNodeID()
}

func TestInstallationRequest_GetRequester(tt *testing.T) {
	tt.Parallel()
	i := &InstallationRequest{}
	i.GetRequester()
	i = nil
	i.GetRequester()
}

func TestInstallationSlugChange_GetFrom(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationSlugChange{From: &zeroValue}
	i.GetFrom()
	i = &InstallationSlugChange{}
	i.GetFrom()
	i = nil
	i.GetFrom()
}

func TestInstallationTargetEvent_GetAccount(tt *testing.T) {
	tt.Parallel()
	i := &InstallationTargetEvent{}
	i.GetAccount()
	i = nil
	i.GetAccount()
}

func TestInstallationTargetEvent_GetAction(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationTargetEvent{Action: &zeroValue}
	i.GetAction()
	i = &InstallationTargetEvent{}
	i.GetAction()
	i = nil
	i.GetAction()
}

func TestInstallationTargetEvent_GetChanges(tt *testing.T) {
	tt.Parallel()
	i := &InstallationTargetEvent{}
	i.GetChanges()
	i = nil
	i.GetChanges()
}

func TestInstallationTargetEvent_GetEnterprise(tt *testing.T) {
	tt.Parallel()
	i := &InstallationTargetEvent{}
	i.GetEnterprise()
	i = nil
	i.GetEnterprise()
}

func TestInstallationTargetEvent_GetInstallation(tt *testing.T) {
	tt.Parallel()
	i := &InstallationTargetEvent{}
	i.GetInstallation()
	i = nil
	i.GetInstallation()
}

func TestInstallationTargetEvent_GetOrganization(tt *testing.T) {
	tt.Parallel()
	i := &InstallationTargetEvent{}
	i.GetOrganization()
	i = nil
	i.GetOrganization()
}

func TestInstallationTargetEvent_GetRepository(tt *testing.T) {
	tt.Parallel()
	i := &InstallationTargetEvent{}
	i.GetRepository()
	i = nil
	i.GetRepository()
}

func TestInstallationTargetEvent_GetSender(tt *testing.T) {
	tt.Parallel()
	i := &InstallationTargetEvent{}
	i.GetSender()
	i = nil
	i.GetSender()
}

func TestInstallationTargetEvent_GetTargetType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationTargetEvent{TargetType: &zeroValue}
	i.GetTargetType()
	i = &InstallationTargetEvent{}
	i.GetTargetType()
	i = nil
	i.GetTargetType()
}

func TestInstallationToken_GetExpiresAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	i := &InstallationToken{ExpiresAt: &zeroValue}
	i.GetExpiresAt()
	i = &InstallationToken{}
	i.GetExpiresAt()
	i = nil
	i.GetExpiresAt()
}

func TestInstallationToken_GetPermissions(tt *testing.T) {
	tt.Parallel()
	i := &InstallationToken{}
	i.GetPermissions()
	i = nil
	i.GetPermissions()
}

func TestInstallationToken_GetRepositories(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*Repository{}
	i := &InstallationToken{Repositories: zeroValue}
	i.GetRepositories()
	i = &InstallationToken{}
	i.GetRepositories()
	i = nil
	i.GetRepositories()
}

func TestInstallationToken_GetToken(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InstallationToken{Token: &zeroValue}
	i.GetToken()
	i = &InstallationToken{}
	i.GetToken()
	i = nil
	i.GetToken()
}

func TestInstallationTokenListRepoOptions_GetPermissions(tt *testing.T) {
	tt.Parallel()
	i := &InstallationTokenListRepoOptions{}
	i.GetPermissions()
	i = nil
	i.GetPermissions()
}

func TestInstallationTokenListRepoOptions_GetRepositories(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	i := &InstallationTokenListRepoOptions{Repositories: zeroValue}
	i.GetRepositories()
	i = &InstallationTokenListRepoOptions{}
	i.GetRepositories()
	i = nil
	i.GetRepositories()
}

func TestInstallationTokenListRepoOptions_GetRepositoryIDs(tt *testing.T) {
	tt.Parallel()
	zeroValue := []int64{}
	i := &InstallationTokenListRepoOptions{RepositoryIDs: zeroValue}
	i.GetRepositoryIDs()
	i = &InstallationTokenListRepoOptions{}
	i.GetRepositoryIDs()
	i = nil
	i.GetRepositoryIDs()
}

func TestInstallationTokenOptions_GetPermissions(tt *testing.T) {
	tt.Parallel()
	i := &InstallationTokenOptions{}
	i.GetPermissions()
	i = nil
	i.GetPermissions()
}

func TestInstallationTokenOptions_GetRepositories(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	i := &InstallationTokenOptions{Repositories: zeroValue}
	i.GetRepositories()
	i = &InstallationTokenOptions{}
	i.GetRepositories()
	i = nil
	i.GetRepositories()
}

func TestInstallationTokenOptions_GetRepositoryIDs(tt *testing.T) {
	tt.Parallel()
	zeroValue := []int64{}
	i := &InstallationTokenOptions{RepositoryIDs: zeroValue}
	i.GetRepositoryIDs()
	i = &InstallationTokenOptions{}
	i.GetRepositoryIDs()
	i = nil
	i.GetRepositoryIDs()
}

func TestInteractionRestriction_GetExpiresAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	i := &InteractionRestriction{ExpiresAt: &zeroValue}
	i.GetExpiresAt()
	i = &InteractionRestriction{}
	i.GetExpiresAt()
	i = nil
	i.GetExpiresAt()
}

func TestInteractionRestriction_GetLimit(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InteractionRestriction{Limit: &zeroValue}
	i.GetLimit()
	i = &InteractionRestriction{}
	i.GetLimit()
	i = nil
	i.GetLimit()
}

func TestInteractionRestriction_GetOrigin(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &InteractionRestriction{Origin: &zeroValue}
	i.GetOrigin()
	i = &InteractionRestriction{}
	i.GetOrigin()
	i = nil
	i.GetOrigin()
}

func TestInvitation_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	i := &Invitation{CreatedAt: &zeroValue}
	i.GetCreatedAt()
	i = &Invitation{}
	i.GetCreatedAt()
	i = nil
	i.GetCreatedAt()
}

func TestInvitation_GetEmail(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &Invitation{Email: &zeroValue}
	i.GetEmail()
	i = &Invitation{}
	i.GetEmail()
	i = nil
	i.GetEmail()
}

func TestInvitation_GetFailedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	i := &Invitation{FailedAt: &zeroValue}
	i.GetFailedAt()
	i = &Invitation{}
	i.GetFailedAt()
	i = nil
	i.GetFailedAt()
}

func TestInvitation_GetFailedReason(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &Invitation{FailedReason: &zeroValue}
	i.GetFailedReason()
	i = &Invitation{}
	i.GetFailedReason()
	i = nil
	i.GetFailedReason()
}

func TestInvitation_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	i := &Invitation{ID: &zeroValue}
	i.GetID()
	i = &Invitation{}
	i.GetID()
	i = nil
	i.GetID()
}

func TestInvitation_GetInvitationTeamURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &Invitation{InvitationTeamURL: &zeroValue}
	i.GetInvitationTeamURL()
	i = &Invitation{}
	i.GetInvitationTeamURL()
	i = nil
	i.GetInvitationTeamURL()
}

func TestInvitation_GetInviter(tt *testing.T) {
	tt.Parallel()
	i := &Invitation{}
	i.GetInviter()
	i = nil
	i.GetInviter()
}

func TestInvitation_GetLogin(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &Invitation{Login: &zeroValue}
	i.GetLogin()
	i = &Invitation{}
	i.GetLogin()
	i = nil
	i.GetLogin()
}

func TestInvitation_GetNodeID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &Invitation{NodeID: &zeroValue}
	i.GetNodeID()
	i = &Invitation{}
	i.GetNodeID()
	i = nil
	i.GetNodeID()
}

func TestInvitation_GetRole(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &Invitation{Role: &zeroValue}
	i.GetRole()
	i = &Invitation{}
	i.GetRole()
	i = nil
	i.GetRole()
}

func TestInvitation_GetTeamCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	i := &Invitation{TeamCount: &zeroValue}
	i.GetTeamCount()
	i = &Invitation{}
	i.GetTeamCount()
	i = nil
	i.GetTeamCount()
}

func TestIssue_GetActiveLockReason(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &Issue{ActiveLockReason: &zeroValue}
	i.GetActiveLockReason()
	i = &Issue{}
	i.GetActiveLockReason()
	i = nil
	i.GetActiveLockReason()
}

func TestIssue_GetAssignee(tt *testing.T) {
	tt.Parallel()
	i := &Issue{}
	i.GetAssignee()
	i = nil
	i.GetAssignee()
}

func TestIssue_GetAssignees(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*User{}
	i := &Issue{Assignees: zeroValue}
	i.GetAssignees()
	i = &Issue{}
	i.GetAssignees()
	i = nil
	i.GetAssignees()
}

func TestIssue_GetAuthorAssociation(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &Issue{AuthorAssociation: &zeroValue}
	i.GetAuthorAssociation()
	i = &Issue{}
	i.GetAuthorAssociation()
	i = nil
	i.GetAuthorAssociation()
}

func TestIssue_GetBody(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &Issue{Body: &zeroValue}
	i.GetBody()
	i = &Issue{}
	i.GetBody()
	i = nil
	i.GetBody()
}

func TestIssue_GetClosedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	i := &Issue{ClosedAt: &zeroValue}
	i.GetClosedAt()
	i = &Issue{}
	i.GetClosedAt()
	i = nil
	i.GetClosedAt()
}

func TestIssue_GetClosedBy(tt *testing.T) {
	tt.Parallel()
	i := &Issue{}
	i.GetClosedBy()
	i = nil
	i.GetClosedBy()
}

func TestIssue_GetComments(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	i := &Issue{Comments: &zeroValue}
	i.GetComments()
	i = &Issue{}
	i.GetComments()
	i = nil
	i.GetComments()
}

func TestIssue_GetCommentsURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &Issue{CommentsURL: &zeroValue}
	i.GetCommentsURL()
	i = &Issue{}
	i.GetCommentsURL()
	i = nil
	i.GetCommentsURL()
}

func TestIssue_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	i := &Issue{CreatedAt: &zeroValue}
	i.GetCreatedAt()
	i = &Issue{}
	i.GetCreatedAt()
	i = nil
	i.GetCreatedAt()
}

func TestIssue_GetDraft(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	i := &Issue{Draft: &zeroValue}
	i.GetDraft()
	i = &Issue{}
	i.GetDraft()
	i = nil
	i.GetDraft()
}

func TestIssue_GetEventsURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &Issue{EventsURL: &zeroValue}
	i.GetEventsURL()
	i = &Issue{}
	i.GetEventsURL()
	i = nil
	i.GetEventsURL()
}

func TestIssue_GetHTMLURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &Issue{HTMLURL: &zeroValue}
	i.GetHTMLURL()
	i = &Issue{}
	i.GetHTMLURL()
	i = nil
	i.GetHTMLURL()
}

func TestIssue_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	i := &Issue{ID: &zeroValue}
	i.GetID()
	i = &Issue{}
	i.GetID()
	i = nil
	i.GetID()
}

func TestIssue_GetIssueDependenciesSummary(tt *testing.T) {
	tt.Parallel()
	i := &Issue{}
	i.GetIssueDependenciesSummary()
	i = nil
	i.GetIssueDependenciesSummary()
}

func TestIssue_GetIssueFieldValues(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*IssueFieldValue{}
	i := &Issue{IssueFieldValues: zeroValue}
	i.GetIssueFieldValues()
	i = &Issue{}
	i.GetIssueFieldValues()
	i = nil
	i.GetIssueFieldValues()
}

func TestIssue_GetLabels(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*Label{}
	i := &Issue{Labels: zeroValue}
	i.GetLabels()
	i = &Issue{}
	i.GetLabels()
	i = nil
	i.GetLabels()
}

func TestIssue_GetLabelsURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &Issue{LabelsURL: &zeroValue}
	i.GetLabelsURL()
	i = &Issue{}
	i.GetLabelsURL()
	i = nil
	i.GetLabelsURL()
}

func TestIssue_GetLocked(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	i := &Issue{Locked: &zeroValue}
	i.GetLocked()
	i = &Issue{}
	i.GetLocked()
	i = nil
	i.GetLocked()
}

func TestIssue_GetMilestone(tt *testing.T) {
	tt.Parallel()
	i := &Issue{}
	i.GetMilestone()
	i = nil
	i.GetMilestone()
}

func TestIssue_GetNodeID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &Issue{NodeID: &zeroValue}
	i.GetNodeID()
	i = &Issue{}
	i.GetNodeID()
	i = nil
	i.GetNodeID()
}

func TestIssue_GetNumber(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	i := &Issue{Number: &zeroValue}
	i.GetNumber()
	i = &Issue{}
	i.GetNumber()
	i = nil
	i.GetNumber()
}

func TestIssue_GetParentIssueURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &Issue{ParentIssueURL: &zeroValue}
	i.GetParentIssueURL()
	i = &Issue{}
	i.GetParentIssueURL()
	i = nil
	i.GetParentIssueURL()
}

func TestIssue_GetPerformedViaGithubApp(tt *testing.T) {
	tt.Parallel()
	i := &Issue{}
	i.GetPerformedViaGithubApp()
	i = nil
	i.GetPerformedViaGithubApp()
}

func TestIssue_GetPinnedComment(tt *testing.T) {
	tt.Parallel()
	i := &Issue{}
	i.GetPinnedComment()
	i = nil
	i.GetPinnedComment()
}

func TestIssue_GetPullRequestLinks(tt *testing.T) {
	tt.Parallel()
	i := &Issue{}
	i.GetPullRequestLinks()
	i = nil
	i.GetPullRequestLinks()
}

func TestIssue_GetReactions(tt *testing.T) {
	tt.Parallel()
	i := &Issue{}
	i.GetReactions()
	i = nil
	i.GetReactions()
}

func TestIssue_GetRepository(tt *testing.T) {
	tt.Parallel()
	i := &Issue{}
	i.GetRepository()
	i = nil
	i.GetRepository()
}

func TestIssue_GetRepositoryURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &Issue{RepositoryURL: &zeroValue}
	i.GetRepositoryURL()
	i = &Issue{}
	i.GetRepositoryURL()
	i = nil
	i.GetRepositoryURL()
}

func TestIssue_GetState(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &Issue{State: &zeroValue}
	i.GetState()
	i = &Issue{}
	i.GetState()
	i = nil
	i.GetState()
}

func TestIssue_GetStateReason(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &Issue{StateReason: &zeroValue}
	i.GetStateReason()
	i = &Issue{}
	i.GetStateReason()
	i = nil
	i.GetStateReason()
}

func TestIssue_GetSubIssuesSummary(tt *testing.T) {
	tt.Parallel()
	i := &Issue{}
	i.GetSubIssuesSummary()
	i = nil
	i.GetSubIssuesSummary()
}

func TestIssue_GetTextMatches(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*TextMatch{}
	i := &Issue{TextMatches: zeroValue}
	i.GetTextMatches()
	i = &Issue{}
	i.GetTextMatches()
	i = nil
	i.GetTextMatches()
}

func TestIssue_GetTitle(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &Issue{Title: &zeroValue}
	i.GetTitle()
	i = &Issue{}
	i.GetTitle()
	i = nil
	i.GetTitle()
}

func TestIssue_GetType(tt *testing.T) {
	tt.Parallel()
	i := &Issue{}
	i.GetType()
	i = nil
	i.GetType()
}

func TestIssue_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	i := &Issue{UpdatedAt: &zeroValue}
	i.GetUpdatedAt()
	i = &Issue{}
	i.GetUpdatedAt()
	i = nil
	i.GetUpdatedAt()
}

func TestIssue_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &Issue{URL: &zeroValue}
	i.GetURL()
	i = &Issue{}
	i.GetURL()
	i = nil
	i.GetURL()
}

func TestIssue_GetUser(tt *testing.T) {
	tt.Parallel()
	i := &Issue{}
	i.GetUser()
	i = nil
	i.GetUser()
}

func TestIssueComment_GetAuthorAssociation(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &IssueComment{AuthorAssociation: &zeroValue}
	i.GetAuthorAssociation()
	i = &IssueComment{}
	i.GetAuthorAssociation()
	i = nil
	i.GetAuthorAssociation()
}

func TestIssueComment_GetBody(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &IssueComment{Body: &zeroValue}
	i.GetBody()
	i = &IssueComment{}
	i.GetBody()
	i = nil
	i.GetBody()
}

func TestIssueComment_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	i := &IssueComment{CreatedAt: &zeroValue}
	i.GetCreatedAt()
	i = &IssueComment{}
	i.GetCreatedAt()
	i = nil
	i.GetCreatedAt()
}

func TestIssueComment_GetHTMLURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &IssueComment{HTMLURL: &zeroValue}
	i.GetHTMLURL()
	i = &IssueComment{}
	i.GetHTMLURL()
	i = nil
	i.GetHTMLURL()
}

func TestIssueComment_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	i := &IssueComment{ID: &zeroValue}
	i.GetID()
	i = &IssueComment{}
	i.GetID()
	i = nil
	i.GetID()
}

func TestIssueComment_GetIssueURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &IssueComment{IssueURL: &zeroValue}
	i.GetIssueURL()
	i = &IssueComment{}
	i.GetIssueURL()
	i = nil
	i.GetIssueURL()
}

func TestIssueComment_GetNodeID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &IssueComment{NodeID: &zeroValue}
	i.GetNodeID()
	i = &IssueComment{}
	i.GetNodeID()
	i = nil
	i.GetNodeID()
}

func TestIssueComment_GetReactions(tt *testing.T) {
	tt.Parallel()
	i := &IssueComment{}
	i.GetReactions()
	i = nil
	i.GetReactions()
}

func TestIssueComment_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	i := &IssueComment{UpdatedAt: &zeroValue}
	i.GetUpdatedAt()
	i = &IssueComment{}
	i.GetUpdatedAt()
	i = nil
	i.GetUpdatedAt()
}

func TestIssueComment_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &IssueComment{URL: &zeroValue}
	i.GetURL()
	i = &IssueComment{}
	i.GetURL()
	i = nil
	i.GetURL()
}

func TestIssueComment_GetUser(tt *testing.T) {
	tt.Parallel()
	i := &IssueComment{}
	i.GetUser()
	i = nil
	i.GetUser()
}

func TestIssueCommentEvent_GetAction(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &IssueCommentEvent{Action: &zeroValue}
	i.GetAction()
	i = &IssueCommentEvent{}
	i.GetAction()
	i = nil
	i.GetAction()
}

func TestIssueCommentEvent_GetChanges(tt *testing.T) {
	tt.Parallel()
	i := &IssueCommentEvent{}
	i.GetChanges()
	i = nil
	i.GetChanges()
}

func TestIssueCommentEvent_GetComment(tt *testing.T) {
	tt.Parallel()
	i := &IssueCommentEvent{}
	i.GetComment()
	i = nil
	i.GetComment()
}

func TestIssueCommentEvent_GetInstallation(tt *testing.T) {
	tt.Parallel()
	i := &IssueCommentEvent{}
	i.GetInstallation()
	i = nil
	i.GetInstallation()
}

func TestIssueCommentEvent_GetIssue(tt *testing.T) {
	tt.Parallel()
	i := &IssueCommentEvent{}
	i.GetIssue()
	i = nil
	i.GetIssue()
}

func TestIssueCommentEvent_GetOrganization(tt *testing.T) {
	tt.Parallel()
	i := &IssueCommentEvent{}
	i.GetOrganization()
	i = nil
	i.GetOrganization()
}

func TestIssueCommentEvent_GetRepo(tt *testing.T) {
	tt.Parallel()
	i := &IssueCommentEvent{}
	i.GetRepo()
	i = nil
	i.GetRepo()
}

func TestIssueCommentEvent_GetSender(tt *testing.T) {
	tt.Parallel()
	i := &IssueCommentEvent{}
	i.GetSender()
	i = nil
	i.GetSender()
}

func TestIssueDependenciesSummary_GetBlockedBy(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	i := &IssueDependenciesSummary{BlockedBy: &zeroValue}
	i.GetBlockedBy()
	i = &IssueDependenciesSummary{}
	i.GetBlockedBy()
	i = nil
	i.GetBlockedBy()
}

func TestIssueDependenciesSummary_GetBlocking(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	i := &IssueDependenciesSummary{Blocking: &zeroValue}
	i.GetBlocking()
	i = &IssueDependenciesSummary{}
	i.GetBlocking()
	i = nil
	i.GetBlocking()
}

func TestIssueDependenciesSummary_GetTotalBlockedBy(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	i := &IssueDependenciesSummary{TotalBlockedBy: &zeroValue}
	i.GetTotalBlockedBy()
	i = &IssueDependenciesSummary{}
	i.GetTotalBlockedBy()
	i = nil
	i.GetTotalBlockedBy()
}

func TestIssueDependenciesSummary_GetTotalBlocking(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	i := &IssueDependenciesSummary{TotalBlocking: &zeroValue}
	i.GetTotalBlocking()
	i = &IssueDependenciesSummary{}
	i.GetTotalBlocking()
	i = nil
	i.GetTotalBlocking()
}

func TestIssueDependencyRequest_GetIssueID(tt *testing.T) {
	tt.Parallel()
	i := &IssueDependencyRequest{}
	i.GetIssueID()
	i = nil
	i.GetIssueID()
}

func TestIssueEvent_GetAction(tt *testing.T) {
	tt.Parallel()
	i := &IssueEvent{}
	i.GetAction()
	i = nil
	i.GetAction()
}

func TestIssueEvent_GetActor(tt *testing.T) {
	tt.Parallel()
	i := &IssueEvent{}
	i.GetActor()
	i = nil
	i.GetActor()
}

func TestIssueEvent_GetAssignee(tt *testing.T) {
	tt.Parallel()
	i := &IssueEvent{}
	i.GetAssignee()
	i = nil
	i.GetAssignee()
}

func TestIssueEvent_GetAssigner(tt *testing.T) {
	tt.Parallel()
	i := &IssueEvent{}
	i.GetAssigner()
	i = nil
	i.GetAssigner()
}

func TestIssueEvent_GetCommitID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &IssueEvent{CommitID: &zeroValue}
	i.GetCommitID()
	i = &IssueEvent{}
	i.GetCommitID()
	i = nil
	i.GetCommitID()
}

func TestIssueEvent_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	i := &IssueEvent{CreatedAt: &zeroValue}
	i.GetCreatedAt()
	i = &IssueEvent{}
	i.GetCreatedAt()
	i = nil
	i.GetCreatedAt()
}

func TestIssueEvent_GetDismissedReview(tt *testing.T) {
	tt.Parallel()
	i := &IssueEvent{}
	i.GetDismissedReview()
	i = nil
	i.GetDismissedReview()
}

func TestIssueEvent_GetEvent(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &IssueEvent{Event: &zeroValue}
	i.GetEvent()
	i = &IssueEvent{}
	i.GetEvent()
	i = nil
	i.GetEvent()
}

func TestIssueEvent_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	i := &IssueEvent{ID: &zeroValue}
	i.GetID()
	i = &IssueEvent{}
	i.GetID()
	i = nil
	i.GetID()
}

func TestIssueEvent_GetIssue(tt *testing.T) {
	tt.Parallel()
	i := &IssueEvent{}
	i.GetIssue()
	i = nil
	i.GetIssue()
}

func TestIssueEvent_GetLabel(tt *testing.T) {
	tt.Parallel()
	i := &IssueEvent{}
	i.GetLabel()
	i = nil
	i.GetLabel()
}

func TestIssueEvent_GetLockReason(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &IssueEvent{LockReason: &zeroValue}
	i.GetLockReason()
	i = &IssueEvent{}
	i.GetLockReason()
	i = nil
	i.GetLockReason()
}

func TestIssueEvent_GetMilestone(tt *testing.T) {
	tt.Parallel()
	i := &IssueEvent{}
	i.GetMilestone()
	i = nil
	i.GetMilestone()
}

func TestIssueEvent_GetPerformedViaGithubApp(tt *testing.T) {
	tt.Parallel()
	i := &IssueEvent{}
	i.GetPerformedViaGithubApp()
	i = nil
	i.GetPerformedViaGithubApp()
}

func TestIssueEvent_GetRename(tt *testing.T) {
	tt.Parallel()
	i := &IssueEvent{}
	i.GetRename()
	i = nil
	i.GetRename()
}

func TestIssueEvent_GetRepository(tt *testing.T) {
	tt.Parallel()
	i := &IssueEvent{}
	i.GetRepository()
	i = nil
	i.GetRepository()
}

func TestIssueEvent_GetRequestedReviewer(tt *testing.T) {
	tt.Parallel()
	i := &IssueEvent{}
	i.GetRequestedReviewer()
	i = nil
	i.GetRequestedReviewer()
}

func TestIssueEvent_GetRequestedTeam(tt *testing.T) {
	tt.Parallel()
	i := &IssueEvent{}
	i.GetRequestedTeam()
	i = nil
	i.GetRequestedTeam()
}

func TestIssueEvent_GetReviewRequester(tt *testing.T) {
	tt.Parallel()
	i := &IssueEvent{}
	i.GetReviewRequester()
	i = nil
	i.GetReviewRequester()
}

func TestIssueEvent_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &IssueEvent{URL: &zeroValue}
	i.GetURL()
	i = &IssueEvent{}
	i.GetURL()
	i = nil
	i.GetURL()
}

func TestIssueFieldValue_GetDataType(tt *testing.T) {
	tt.Parallel()
	i := &IssueFieldValue{}
	i.GetDataType()
	i = nil
	i.GetDataType()
}

func TestIssueFieldValue_GetIssueFieldID(tt *testing.T) {
	tt.Parallel()
	i := &IssueFieldValue{}
	i.GetIssueFieldID()
	i = nil
	i.GetIssueFieldID()
}

func TestIssueFieldValue_GetNodeID(tt *testing.T) {
	tt.Parallel()
	i := &IssueFieldValue{}
	i.GetNodeID()
	i = nil
	i.GetNodeID()
}

func TestIssueFieldValue_GetSingleSelectOption(tt *testing.T) {
	tt.Parallel()
	i := &IssueFieldValue{}
	i.GetSingleSelectOption()
	i = nil
	i.GetSingleSelectOption()
}

func TestIssueFieldValue_GetValue(tt *testing.T) {
	tt.Parallel()
	i := &IssueFieldValue{}
	i.GetValue()
	i = nil
	i.GetValue()
}

func TestIssueFieldValueSingleSelectOption_GetColor(tt *testing.T) {
	tt.Parallel()
	i := &IssueFieldValueSingleSelectOption{}
	i.GetColor()
	i = nil
	i.GetColor()
}

func TestIssueFieldValueSingleSelectOption_GetID(tt *testing.T) {
	tt.Parallel()
	i := &IssueFieldValueSingleSelectOption{}
	i.GetID()
	i = nil
	i.GetID()
}

func TestIssueFieldValueSingleSelectOption_GetName(tt *testing.T) {
	tt.Parallel()
	i := &IssueFieldValueSingleSelectOption{}
	i.GetName()
	i = nil
	i.GetName()
}

func TestIssueImport_GetAssignee(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &IssueImport{Assignee: &zeroValue}
	i.GetAssignee()
	i = &IssueImport{}
	i.GetAssignee()
	i = nil
	i.GetAssignee()
}

func TestIssueImport_GetBody(tt *testing.T) {
	tt.Parallel()
	i := &IssueImport{}
	i.GetBody()
	i = nil
	i.GetBody()
}

func TestIssueImport_GetClosed(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	i := &IssueImport{Closed: &zeroValue}
	i.GetClosed()
	i = &IssueImport{}
	i.GetClosed()
	i = nil
	i.GetClosed()
}

func TestIssueImport_GetClosedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	i := &IssueImport{ClosedAt: &zeroValue}
	i.GetClosedAt()
	i = &IssueImport{}
	i.GetClosedAt()
	i = nil
	i.GetClosedAt()
}

func TestIssueImport_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	i := &IssueImport{CreatedAt: &zeroValue}
	i.GetCreatedAt()
	i = &IssueImport{}
	i.GetCreatedAt()
	i = nil
	i.GetCreatedAt()
}

func TestIssueImport_GetLabels(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	i := &IssueImport{Labels: zeroValue}
	i.GetLabels()
	i = &IssueImport{}
	i.GetLabels()
	i = nil
	i.GetLabels()
}

func TestIssueImport_GetMilestone(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	i := &IssueImport{Milestone: &zeroValue}
	i.GetMilestone()
	i = &IssueImport{}
	i.GetMilestone()
	i = nil
	i.GetMilestone()
}

func TestIssueImport_GetTitle(tt *testing.T) {
	tt.Parallel()
	i := &IssueImport{}
	i.GetTitle()
	i = nil
	i.GetTitle()
}

func TestIssueImport_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	i := &IssueImport{UpdatedAt: &zeroValue}
	i.GetUpdatedAt()
	i = &IssueImport{}
	i.GetUpdatedAt()
	i = nil
	i.GetUpdatedAt()
}

func TestIssueImportError_GetCode(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &IssueImportError{Code: &zeroValue}
	i.GetCode()
	i = &IssueImportError{}
	i.GetCode()
	i = nil
	i.GetCode()
}

func TestIssueImportError_GetField(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &IssueImportError{Field: &zeroValue}
	i.GetField()
	i = &IssueImportError{}
	i.GetField()
	i = nil
	i.GetField()
}

func TestIssueImportError_GetLocation(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &IssueImportError{Location: &zeroValue}
	i.GetLocation()
	i = &IssueImportError{}
	i.GetLocation()
	i = nil
	i.GetLocation()
}

func TestIssueImportError_GetResource(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &IssueImportError{Resource: &zeroValue}
	i.GetResource()
	i = &IssueImportError{}
	i.GetResource()
	i = nil
	i.GetResource()
}

func TestIssueImportError_GetValue(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &IssueImportError{Value: &zeroValue}
	i.GetValue()
	i = &IssueImportError{}
	i.GetValue()
	i = nil
	i.GetValue()
}

func TestIssueImportRequest_GetComments(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*Comment{}
	i := &IssueImportRequest{Comments: zeroValue}
	i.GetComments()
	i = &IssueImportRequest{}
	i.GetComments()
	i = nil
	i.GetComments()
}

func TestIssueImportRequest_GetIssueImport(tt *testing.T) {
	tt.Parallel()
	i := &IssueImportRequest{}
	i.GetIssueImport()
	i = nil
	i.GetIssueImport()
}

func TestIssueImportResponse_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	i := &IssueImportResponse{CreatedAt: &zeroValue}
	i.GetCreatedAt()
	i = &IssueImportResponse{}
	i.GetCreatedAt()
	i = nil
	i.GetCreatedAt()
}

func TestIssueImportResponse_GetDocumentationURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &IssueImportResponse{DocumentationURL: &zeroValue}
	i.GetDocumentationURL()
	i = &IssueImportResponse{}
	i.GetDocumentationURL()
	i = nil
	i.GetDocumentationURL()
}

func TestIssueImportResponse_GetErrors(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*IssueImportError{}
	i := &IssueImportResponse{Errors: zeroValue}
	i.GetErrors()
	i = &IssueImportResponse{}
	i.GetErrors()
	i = nil
	i.GetErrors()
}

func TestIssueImportResponse_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	i := &IssueImportResponse{ID: &zeroValue}
	i.GetID()
	i = &IssueImportResponse{}
	i.GetID()
	i = nil
	i.GetID()
}

func TestIssueImportResponse_GetImportIssuesURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &IssueImportResponse{ImportIssuesURL: &zeroValue}
	i.GetImportIssuesURL()
	i = &IssueImportResponse{}
	i.GetImportIssuesURL()
	i = nil
	i.GetImportIssuesURL()
}

func TestIssueImportResponse_GetMessage(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &IssueImportResponse{Message: &zeroValue}
	i.GetMessage()
	i = &IssueImportResponse{}
	i.GetMessage()
	i = nil
	i.GetMessage()
}

func TestIssueImportResponse_GetRepositoryURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &IssueImportResponse{RepositoryURL: &zeroValue}
	i.GetRepositoryURL()
	i = &IssueImportResponse{}
	i.GetRepositoryURL()
	i = nil
	i.GetRepositoryURL()
}

func TestIssueImportResponse_GetStatus(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &IssueImportResponse{Status: &zeroValue}
	i.GetStatus()
	i = &IssueImportResponse{}
	i.GetStatus()
	i = nil
	i.GetStatus()
}

func TestIssueImportResponse_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	i := &IssueImportResponse{UpdatedAt: &zeroValue}
	i.GetUpdatedAt()
	i = &IssueImportResponse{}
	i.GetUpdatedAt()
	i = nil
	i.GetUpdatedAt()
}

func TestIssueImportResponse_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &IssueImportResponse{URL: &zeroValue}
	i.GetURL()
	i = &IssueImportResponse{}
	i.GetURL()
	i = nil
	i.GetURL()
}

func TestIssueListByOrgOptions_GetDirection(tt *testing.T) {
	tt.Parallel()
	i := &IssueListByOrgOptions{}
	i.GetDirection()
	i = nil
	i.GetDirection()
}

func TestIssueListByOrgOptions_GetFilter(tt *testing.T) {
	tt.Parallel()
	i := &IssueListByOrgOptions{}
	i.GetFilter()
	i = nil
	i.GetFilter()
}

func TestIssueListByOrgOptions_GetLabels(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	i := &IssueListByOrgOptions{Labels: zeroValue}
	i.GetLabels()
	i = &IssueListByOrgOptions{}
	i.GetLabels()
	i = nil
	i.GetLabels()
}

func TestIssueListByOrgOptions_GetSince(tt *testing.T) {
	tt.Parallel()
	i := &IssueListByOrgOptions{}
	i.GetSince()
	i = nil
	i.GetSince()
}

func TestIssueListByOrgOptions_GetSort(tt *testing.T) {
	tt.Parallel()
	i := &IssueListByOrgOptions{}
	i.GetSort()
	i = nil
	i.GetSort()
}

func TestIssueListByOrgOptions_GetState(tt *testing.T) {
	tt.Parallel()
	i := &IssueListByOrgOptions{}
	i.GetState()
	i = nil
	i.GetState()
}

func TestIssueListByOrgOptions_GetType(tt *testing.T) {
	tt.Parallel()
	i := &IssueListByOrgOptions{}
	i.GetType()
	i = nil
	i.GetType()
}

func TestIssueListByRepoOptions_GetAssignee(tt *testing.T) {
	tt.Parallel()
	i := &IssueListByRepoOptions{}
	i.GetAssignee()
	i = nil
	i.GetAssignee()
}

func TestIssueListByRepoOptions_GetCreator(tt *testing.T) {
	tt.Parallel()
	i := &IssueListByRepoOptions{}
	i.GetCreator()
	i = nil
	i.GetCreator()
}

func TestIssueListByRepoOptions_GetDirection(tt *testing.T) {
	tt.Parallel()
	i := &IssueListByRepoOptions{}
	i.GetDirection()
	i = nil
	i.GetDirection()
}

func TestIssueListByRepoOptions_GetLabels(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	i := &IssueListByRepoOptions{Labels: zeroValue}
	i.GetLabels()
	i = &IssueListByRepoOptions{}
	i.GetLabels()
	i = nil
	i.GetLabels()
}

func TestIssueListByRepoOptions_GetMentioned(tt *testing.T) {
	tt.Parallel()
	i := &IssueListByRepoOptions{}
	i.GetMentioned()
	i = nil
	i.GetMentioned()
}

func TestIssueListByRepoOptions_GetMilestone(tt *testing.T) {
	tt.Parallel()
	i := &IssueListByRepoOptions{}
	i.GetMilestone()
	i = nil
	i.GetMilestone()
}

func TestIssueListByRepoOptions_GetSince(tt *testing.T) {
	tt.Parallel()
	i := &IssueListByRepoOptions{}
	i.GetSince()
	i = nil
	i.GetSince()
}

func TestIssueListByRepoOptions_GetSort(tt *testing.T) {
	tt.Parallel()
	i := &IssueListByRepoOptions{}
	i.GetSort()
	i = nil
	i.GetSort()
}

func TestIssueListByRepoOptions_GetState(tt *testing.T) {
	tt.Parallel()
	i := &IssueListByRepoOptions{}
	i.GetState()
	i = nil
	i.GetState()
}

func TestIssueListByRepoOptions_GetType(tt *testing.T) {
	tt.Parallel()
	i := &IssueListByRepoOptions{}
	i.GetType()
	i = nil
	i.GetType()
}

func TestIssueListCommentsOptions_GetDirection(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &IssueListCommentsOptions{Direction: &zeroValue}
	i.GetDirection()
	i = &IssueListCommentsOptions{}
	i.GetDirection()
	i = nil
	i.GetDirection()
}

func TestIssueListCommentsOptions_GetSince(tt *testing.T) {
	tt.Parallel()
	var zeroValue time.Time
	i := &IssueListCommentsOptions{Since: &zeroValue}
	i.GetSince()
	i = &IssueListCommentsOptions{}
	i.GetSince()
	i = nil
	i.GetSince()
}

func TestIssueListCommentsOptions_GetSort(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &IssueListCommentsOptions{Sort: &zeroValue}
	i.GetSort()
	i = &IssueListCommentsOptions{}
	i.GetSort()
	i = nil
	i.GetSort()
}

func TestIssueRequestFieldValue_GetFieldID(tt *testing.T) {
	tt.Parallel()
	i := &IssueRequestFieldValue{}
	i.GetFieldID()
	i = nil
	i.GetFieldID()
}

func TestIssueRequestFieldValue_GetValue(tt *testing.T) {
	tt.Parallel()
	i := &IssueRequestFieldValue{}
	i.GetValue()
	i = nil
	i.GetValue()
}

func TestIssuesEvent_GetAction(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &IssuesEvent{Action: &zeroValue}
	i.GetAction()
	i = &IssuesEvent{}
	i.GetAction()
	i = nil
	i.GetAction()
}

func TestIssuesEvent_GetAssignee(tt *testing.T) {
	tt.Parallel()
	i := &IssuesEvent{}
	i.GetAssignee()
	i = nil
	i.GetAssignee()
}

func TestIssuesEvent_GetChanges(tt *testing.T) {
	tt.Parallel()
	i := &IssuesEvent{}
	i.GetChanges()
	i = nil
	i.GetChanges()
}

func TestIssuesEvent_GetInstallation(tt *testing.T) {
	tt.Parallel()
	i := &IssuesEvent{}
	i.GetInstallation()
	i = nil
	i.GetInstallation()
}

func TestIssuesEvent_GetIssue(tt *testing.T) {
	tt.Parallel()
	i := &IssuesEvent{}
	i.GetIssue()
	i = nil
	i.GetIssue()
}

func TestIssuesEvent_GetLabel(tt *testing.T) {
	tt.Parallel()
	i := &IssuesEvent{}
	i.GetLabel()
	i = nil
	i.GetLabel()
}

func TestIssuesEvent_GetMilestone(tt *testing.T) {
	tt.Parallel()
	i := &IssuesEvent{}
	i.GetMilestone()
	i = nil
	i.GetMilestone()
}

func TestIssuesEvent_GetOrg(tt *testing.T) {
	tt.Parallel()
	i := &IssuesEvent{}
	i.GetOrg()
	i = nil
	i.GetOrg()
}

func TestIssuesEvent_GetRepo(tt *testing.T) {
	tt.Parallel()
	i := &IssuesEvent{}
	i.GetRepo()
	i = nil
	i.GetRepo()
}

func TestIssuesEvent_GetSender(tt *testing.T) {
	tt.Parallel()
	i := &IssuesEvent{}
	i.GetSender()
	i = nil
	i.GetSender()
}

func TestIssuesSearchResult_GetIncompleteResults(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	i := &IssuesSearchResult{IncompleteResults: &zeroValue}
	i.GetIncompleteResults()
	i = &IssuesSearchResult{}
	i.GetIncompleteResults()
	i = nil
	i.GetIncompleteResults()
}

func TestIssuesSearchResult_GetIssues(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*Issue{}
	i := &IssuesSearchResult{Issues: zeroValue}
	i.GetIssues()
	i = &IssuesSearchResult{}
	i.GetIssues()
	i = nil
	i.GetIssues()
}

func TestIssuesSearchResult_GetSearchType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &IssuesSearchResult{SearchType: &zeroValue}
	i.GetSearchType()
	i = &IssuesSearchResult{}
	i.GetSearchType()
	i = nil
	i.GetSearchType()
}

func TestIssuesSearchResult_GetTotal(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	i := &IssuesSearchResult{Total: &zeroValue}
	i.GetTotal()
	i = &IssuesSearchResult{}
	i.GetTotal()
	i = nil
	i.GetTotal()
}

func TestIssueStats_GetClosedIssues(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	i := &IssueStats{ClosedIssues: &zeroValue}
	i.GetClosedIssues()
	i = &IssueStats{}
	i.GetClosedIssues()
	i = nil
	i.GetClosedIssues()
}

func TestIssueStats_GetOpenIssues(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	i := &IssueStats{OpenIssues: &zeroValue}
	i.GetOpenIssues()
	i = &IssueStats{}
	i.GetOpenIssues()
	i = nil
	i.GetOpenIssues()
}

func TestIssueStats_GetTotalIssues(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	i := &IssueStats{TotalIssues: &zeroValue}
	i.GetTotalIssues()
	i = &IssueStats{}
	i.GetTotalIssues()
	i = nil
	i.GetTotalIssues()
}

func TestIssueType_GetColor(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &IssueType{Color: &zeroValue}
	i.GetColor()
	i = &IssueType{}
	i.GetColor()
	i = nil
	i.GetColor()
}

func TestIssueType_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	i := &IssueType{CreatedAt: &zeroValue}
	i.GetCreatedAt()
	i = &IssueType{}
	i.GetCreatedAt()
	i = nil
	i.GetCreatedAt()
}

func TestIssueType_GetDescription(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &IssueType{Description: &zeroValue}
	i.GetDescription()
	i = &IssueType{}
	i.GetDescription()
	i = nil
	i.GetDescription()
}

func TestIssueType_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	i := &IssueType{ID: &zeroValue}
	i.GetID()
	i = &IssueType{}
	i.GetID()
	i = nil
	i.GetID()
}

func TestIssueType_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &IssueType{Name: &zeroValue}
	i.GetName()
	i = &IssueType{}
	i.GetName()
	i = nil
	i.GetName()
}

func TestIssueType_GetNodeID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	i := &IssueType{NodeID: &zeroValue}
	i.GetNodeID()
	i = &IssueType{}
	i.GetNodeID()
	i = nil
	i.GetNodeID()
}

func TestIssueType_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	i := &IssueType{UpdatedAt: &zeroValue}
	i.GetUpdatedAt()
	i = &IssueType{}
	i.GetUpdatedAt()
	i = nil
	i.GetUpdatedAt()
}

func TestJITRunnerConfig_GetEncodedJITConfig(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	j := &JITRunnerConfig{EncodedJITConfig: &zeroValue}
	j.GetEncodedJITConfig()
	j = &JITRunnerConfig{}
	j.GetEncodedJITConfig()
	j = nil
	j.GetEncodedJITConfig()
}

func TestJITRunnerConfig_GetRunner(tt *testing.T) {
	tt.Parallel()
	j := &JITRunnerConfig{}
	j.GetRunner()
	j = nil
	j.GetRunner()
}

func TestJobs_GetJobs(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*WorkflowJob{}
	j := &Jobs{Jobs: zeroValue}
	j.GetJobs()
	j = &Jobs{}
	j.GetJobs()
	j = nil
	j.GetJobs()
}

func TestJobs_GetTotalCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	j := &Jobs{TotalCount: &zeroValue}
	j.GetTotalCount()
	j = &Jobs{}
	j.GetTotalCount()
	j = nil
	j.GetTotalCount()
}

func TestKey_GetAddedBy(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	k := &Key{AddedBy: &zeroValue}
	k.GetAddedBy()
	k = &Key{}
	k.GetAddedBy()
	k = nil
	k.GetAddedBy()
}

func TestKey_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	k := &Key{CreatedAt: &zeroValue}
	k.GetCreatedAt()
	k = &Key{}
	k.GetCreatedAt()
	k = nil
	k.GetCreatedAt()
}

func TestKey_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	k := &Key{ID: &zeroValue}
	k.GetID()
	k = &Key{}
	k.GetID()
	k = nil
	k.GetID()
}

func TestKey_GetKey(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	k := &Key{Key: &zeroValue}
	k.GetKey()
	k = &Key{}
	k.GetKey()
	k = nil
	k.GetKey()
}

func TestKey_GetLastUsed(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	k := &Key{LastUsed: &zeroValue}
	k.GetLastUsed()
	k = &Key{}
	k.GetLastUsed()
	k = nil
	k.GetLastUsed()
}

func TestKey_GetReadOnly(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	k := &Key{ReadOnly: &zeroValue}
	k.GetReadOnly()
	k = &Key{}
	k.GetReadOnly()
	k = nil
	k.GetReadOnly()
}

func TestKey_GetTitle(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	k := &Key{Title: &zeroValue}
	k.GetTitle()
	k = &Key{}
	k.GetTitle()
	k = nil
	k.GetTitle()
}

func TestKey_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	k := &Key{URL: &zeroValue}
	k.GetURL()
	k = &Key{}
	k.GetURL()
	k = nil
	k.GetURL()
}

func TestKey_GetVerified(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	k := &Key{Verified: &zeroValue}
	k.GetVerified()
	k = &Key{}
	k.GetVerified()
	k = nil
	k.GetVerified()
}

func TestLabel_GetColor(tt *testing.T) {
	tt.Parallel()
	l := &Label{}
	l.GetColor()
	l = nil
	l.GetColor()
}

func TestLabel_GetDefault(tt *testing.T) {
	tt.Parallel()
	l := &Label{}
	l.GetDefault()
	l = nil
	l.GetDefault()
}

func TestLabel_GetDescription(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	l := &Label{Description: &zeroValue}
	l.GetDescription()
	l = &Label{}
	l.GetDescription()
	l = nil
	l.GetDescription()
}

func TestLabel_GetID(tt *testing.T) {
	tt.Parallel()
	l := &Label{}
	l.GetID()
	l = nil
	l.GetID()
}

func TestLabel_GetName(tt *testing.T) {
	tt.Parallel()
	l := &Label{}
	l.GetName()
	l = nil
	l.GetName()
}

func TestLabel_GetNodeID(tt *testing.T) {
	tt.Parallel()
	l := &Label{}
	l.GetNodeID()
	l = nil
	l.GetNodeID()
}

func TestLabel_GetURL(tt *testing.T) {
	tt.Parallel()
	l := &Label{}
	l.GetURL()
	l = nil
	l.GetURL()
}

func TestLabelEvent_GetAction(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	l := &LabelEvent{Action: &zeroValue}
	l.GetAction()
	l = &LabelEvent{}
	l.GetAction()
	l = nil
	l.GetAction()
}

func TestLabelEvent_GetChanges(tt *testing.T) {
	tt.Parallel()
	l := &LabelEvent{}
	l.GetChanges()
	l = nil
	l.GetChanges()
}

func TestLabelEvent_GetInstallation(tt *testing.T) {
	tt.Parallel()
	l := &LabelEvent{}
	l.GetInstallation()
	l = nil
	l.GetInstallation()
}

func TestLabelEvent_GetLabel(tt *testing.T) {
	tt.Parallel()
	l := &LabelEvent{}
	l.GetLabel()
	l = nil
	l.GetLabel()
}

func TestLabelEvent_GetOrg(tt *testing.T) {
	tt.Parallel()
	l := &LabelEvent{}
	l.GetOrg()
	l = nil
	l.GetOrg()
}

func TestLabelEvent_GetRepo(tt *testing.T) {
	tt.Parallel()
	l := &LabelEvent{}
	l.GetRepo()
	l = nil
	l.GetRepo()
}

func TestLabelEvent_GetSender(tt *testing.T) {
	tt.Parallel()
	l := &LabelEvent{}
	l.GetSender()
	l = nil
	l.GetSender()
}

func TestLabelResult_GetColor(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	l := &LabelResult{Color: &zeroValue}
	l.GetColor()
	l = &LabelResult{}
	l.GetColor()
	l = nil
	l.GetColor()
}

func TestLabelResult_GetDefault(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	l := &LabelResult{Default: &zeroValue}
	l.GetDefault()
	l = &LabelResult{}
	l.GetDefault()
	l = nil
	l.GetDefault()
}

func TestLabelResult_GetDescription(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	l := &LabelResult{Description: &zeroValue}
	l.GetDescription()
	l = &LabelResult{}
	l.GetDescription()
	l = nil
	l.GetDescription()
}

func TestLabelResult_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	l := &LabelResult{ID: &zeroValue}
	l.GetID()
	l = &LabelResult{}
	l.GetID()
	l = nil
	l.GetID()
}

func TestLabelResult_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	l := &LabelResult{Name: &zeroValue}
	l.GetName()
	l = &LabelResult{}
	l.GetName()
	l = nil
	l.GetName()
}

func TestLabelResult_GetScore(tt *testing.T) {
	tt.Parallel()
	var zeroValue float64
	l := &LabelResult{Score: &zeroValue}
	l.GetScore()
	l = &LabelResult{}
	l.GetScore()
	l = nil
	l.GetScore()
}

func TestLabelResult_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	l := &LabelResult{URL: &zeroValue}
	l.GetURL()
	l = &LabelResult{}
	l.GetURL()
	l = nil
	l.GetURL()
}

func TestLabelsSearchResult_GetIncompleteResults(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	l := &LabelsSearchResult{IncompleteResults: &zeroValue}
	l.GetIncompleteResults()
	l = &LabelsSearchResult{}
	l.GetIncompleteResults()
	l = nil
	l.GetIncompleteResults()
}

func TestLabelsSearchResult_GetLabels(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*LabelResult{}
	l := &LabelsSearchResult{Labels: zeroValue}
	l.GetLabels()
	l = &LabelsSearchResult{}
	l.GetLabels()
	l = nil
	l.GetLabels()
}

func TestLabelsSearchResult_GetTotal(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	l := &LabelsSearchResult{Total: &zeroValue}
	l.GetTotal()
	l = &LabelsSearchResult{}
	l.GetTotal()
	l = nil
	l.GetTotal()
}

func TestLargeFile_GetOID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	l := &LargeFile{OID: &zeroValue}
	l.GetOID()
	l = &LargeFile{}
	l.GetOID()
	l = nil
	l.GetOID()
}

func TestLargeFile_GetPath(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	l := &LargeFile{Path: &zeroValue}
	l.GetPath()
	l = &LargeFile{}
	l.GetPath()
	l = nil
	l.GetPath()
}

func TestLargeFile_GetRefName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	l := &LargeFile{RefName: &zeroValue}
	l.GetRefName()
	l = &LargeFile{}
	l.GetRefName()
	l = nil
	l.GetRefName()
}

func TestLargeFile_GetSize(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	l := &LargeFile{Size: &zeroValue}
	l.GetSize()
	l = &LargeFile{}
	l.GetSize()
	l = nil
	l.GetSize()
}

func TestLastLicenseSync_GetProperties(tt *testing.T) {
	tt.Parallel()
	l := &LastLicenseSync{}
	l.GetProperties()
	l = nil
	l.GetProperties()
}

func TestLastLicenseSync_GetType(tt *testing.T) {
	tt.Parallel()
	l := &LastLicenseSync{}
	l.GetType()
	l = nil
	l.GetType()
}

func TestLastLicenseSyncProperties_GetDate(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	l := &LastLicenseSyncProperties{Date: &zeroValue}
	l.GetDate()
	l = &LastLicenseSyncProperties{}
	l.GetDate()
	l = nil
	l.GetDate()
}

func TestLastLicenseSyncProperties_GetError(tt *testing.T) {
	tt.Parallel()
	l := &LastLicenseSyncProperties{}
	l.GetError()
	l = nil
	l.GetError()
}

func TestLastLicenseSyncProperties_GetStatus(tt *testing.T) {
	tt.Parallel()
	l := &LastLicenseSyncProperties{}
	l.GetStatus()
	l = nil
	l.GetStatus()
}

func TestLicense_GetBody(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	l := &License{Body: &zeroValue}
	l.GetBody()
	l = &License{}
	l.GetBody()
	l = nil
	l.GetBody()
}

func TestLicense_GetConditions(tt *testing.T) {
	tt.Parallel()
	var zeroValue []string
	l := &License{Conditions: &zeroValue}
	l.GetConditions()
	l = &License{}
	l.GetConditions()
	l = nil
	l.GetConditions()
}

func TestLicense_GetDescription(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	l := &License{Description: &zeroValue}
	l.GetDescription()
	l = &License{}
	l.GetDescription()
	l = nil
	l.GetDescription()
}

func TestLicense_GetFeatured(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	l := &License{Featured: &zeroValue}
	l.GetFeatured()
	l = &License{}
	l.GetFeatured()
	l = nil
	l.GetFeatured()
}

func TestLicense_GetHTMLURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	l := &License{HTMLURL: &zeroValue}
	l.GetHTMLURL()
	l = &License{}
	l.GetHTMLURL()
	l = nil
	l.GetHTMLURL()
}

func TestLicense_GetImplementation(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	l := &License{Implementation: &zeroValue}
	l.GetImplementation()
	l = &License{}
	l.GetImplementation()
	l = nil
	l.GetImplementation()
}

func TestLicense_GetKey(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	l := &License{Key: &zeroValue}
	l.GetKey()
	l = &License{}
	l.GetKey()
	l = nil
	l.GetKey()
}

func TestLicense_GetLimitations(tt *testing.T) {
	tt.Parallel()
	var zeroValue []string
	l := &License{Limitations: &zeroValue}
	l.GetLimitations()
	l = &License{}
	l.GetLimitations()
	l = nil
	l.GetLimitations()
}

func TestLicense_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	l := &License{Name: &zeroValue}
	l.GetName()
	l = &License{}
	l.GetName()
	l = nil
	l.GetName()
}

func TestLicense_GetPermissions(tt *testing.T) {
	tt.Parallel()
	var zeroValue []string
	l := &License{Permissions: &zeroValue}
	l.GetPermissions()
	l = &License{}
	l.GetPermissions()
	l = nil
	l.GetPermissions()
}

func TestLicense_GetSPDXID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	l := &License{SPDXID: &zeroValue}
	l.GetSPDXID()
	l = &License{}
	l.GetSPDXID()
	l = nil
	l.GetSPDXID()
}

func TestLicense_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	l := &License{URL: &zeroValue}
	l.GetURL()
	l = &License{}
	l.GetURL()
	l = nil
	l.GetURL()
}

func TestLicenseCheck_GetStatus(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	l := &LicenseCheck{Status: &zeroValue}
	l.GetStatus()
	l = &LicenseCheck{}
	l.GetStatus()
	l = nil
	l.GetStatus()
}

func TestLicenseStatus_GetAdvancedSecurityEnabled(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	l := &LicenseStatus{AdvancedSecurityEnabled: &zeroValue}
	l.GetAdvancedSecurityEnabled()
	l = &LicenseStatus{}
	l.GetAdvancedSecurityEnabled()
	l = nil
	l.GetAdvancedSecurityEnabled()
}

func TestLicenseStatus_GetAdvancedSecuritySeats(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	l := &LicenseStatus{AdvancedSecuritySeats: &zeroValue}
	l.GetAdvancedSecuritySeats()
	l = &LicenseStatus{}
	l.GetAdvancedSecuritySeats()
	l = nil
	l.GetAdvancedSecuritySeats()
}

func TestLicenseStatus_GetClusterSupport(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	l := &LicenseStatus{ClusterSupport: &zeroValue}
	l.GetClusterSupport()
	l = &LicenseStatus{}
	l.GetClusterSupport()
	l = nil
	l.GetClusterSupport()
}

func TestLicenseStatus_GetCompany(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	l := &LicenseStatus{Company: &zeroValue}
	l.GetCompany()
	l = &LicenseStatus{}
	l.GetCompany()
	l = nil
	l.GetCompany()
}

func TestLicenseStatus_GetCroquetSupport(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	l := &LicenseStatus{CroquetSupport: &zeroValue}
	l.GetCroquetSupport()
	l = &LicenseStatus{}
	l.GetCroquetSupport()
	l = nil
	l.GetCroquetSupport()
}

func TestLicenseStatus_GetCustomTerms(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	l := &LicenseStatus{CustomTerms: &zeroValue}
	l.GetCustomTerms()
	l = &LicenseStatus{}
	l.GetCustomTerms()
	l = nil
	l.GetCustomTerms()
}

func TestLicenseStatus_GetEvaluation(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	l := &LicenseStatus{Evaluation: &zeroValue}
	l.GetEvaluation()
	l = &LicenseStatus{}
	l.GetEvaluation()
	l = nil
	l.GetEvaluation()
}

func TestLicenseStatus_GetExpireAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	l := &LicenseStatus{ExpireAt: &zeroValue}
	l.GetExpireAt()
	l = &LicenseStatus{}
	l.GetExpireAt()
	l = nil
	l.GetExpireAt()
}

func TestLicenseStatus_GetInsightsEnabled(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	l := &LicenseStatus{InsightsEnabled: &zeroValue}
	l.GetInsightsEnabled()
	l = &LicenseStatus{}
	l.GetInsightsEnabled()
	l = nil
	l.GetInsightsEnabled()
}

func TestLicenseStatus_GetInsightsExpireAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	l := &LicenseStatus{InsightsExpireAt: &zeroValue}
	l.GetInsightsExpireAt()
	l = &LicenseStatus{}
	l.GetInsightsExpireAt()
	l = nil
	l.GetInsightsExpireAt()
}

func TestLicenseStatus_GetLearningLabEvaluationExpires(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	l := &LicenseStatus{LearningLabEvaluationExpires: &zeroValue}
	l.GetLearningLabEvaluationExpires()
	l = &LicenseStatus{}
	l.GetLearningLabEvaluationExpires()
	l = nil
	l.GetLearningLabEvaluationExpires()
}

func TestLicenseStatus_GetLearningLabSeats(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	l := &LicenseStatus{LearningLabSeats: &zeroValue}
	l.GetLearningLabSeats()
	l = &LicenseStatus{}
	l.GetLearningLabSeats()
	l = nil
	l.GetLearningLabSeats()
}

func TestLicenseStatus_GetPerpetual(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	l := &LicenseStatus{Perpetual: &zeroValue}
	l.GetPerpetual()
	l = &LicenseStatus{}
	l.GetPerpetual()
	l = nil
	l.GetPerpetual()
}

func TestLicenseStatus_GetReferenceNumber(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	l := &LicenseStatus{ReferenceNumber: &zeroValue}
	l.GetReferenceNumber()
	l = &LicenseStatus{}
	l.GetReferenceNumber()
	l = nil
	l.GetReferenceNumber()
}

func TestLicenseStatus_GetSeats(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	l := &LicenseStatus{Seats: &zeroValue}
	l.GetSeats()
	l = &LicenseStatus{}
	l.GetSeats()
	l = nil
	l.GetSeats()
}

func TestLicenseStatus_GetSSHAllowed(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	l := &LicenseStatus{SSHAllowed: &zeroValue}
	l.GetSSHAllowed()
	l = &LicenseStatus{}
	l.GetSSHAllowed()
	l = nil
	l.GetSSHAllowed()
}

func TestLicenseStatus_GetSupportKey(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	l := &LicenseStatus{SupportKey: &zeroValue}
	l.GetSupportKey()
	l = &LicenseStatus{}
	l.GetSupportKey()
	l = nil
	l.GetSupportKey()
}

func TestLicenseStatus_GetUnlimitedSeating(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	l := &LicenseStatus{UnlimitedSeating: &zeroValue}
	l.GetUnlimitedSeating()
	l = &LicenseStatus{}
	l.GetUnlimitedSeating()
	l = nil
	l.GetUnlimitedSeating()
}

func TestLinearHistoryRequirementEnforcementLevelChanges_GetFrom(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	l := &LinearHistoryRequirementEnforcementLevelChanges{From: &zeroValue}
	l.GetFrom()
	l = &LinearHistoryRequirementEnforcementLevelChanges{}
	l.GetFrom()
	l = nil
	l.GetFrom()
}

func TestListAlertsOptions_GetDirection(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	l := &ListAlertsOptions{Direction: &zeroValue}
	l.GetDirection()
	l = &ListAlertsOptions{}
	l.GetDirection()
	l = nil
	l.GetDirection()
}

func TestListAlertsOptions_GetEcosystem(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	l := &ListAlertsOptions{Ecosystem: &zeroValue}
	l.GetEcosystem()
	l = &ListAlertsOptions{}
	l.GetEcosystem()
	l = nil
	l.GetEcosystem()
}

func TestListAlertsOptions_GetPackage(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	l := &ListAlertsOptions{Package: &zeroValue}
	l.GetPackage()
	l = &ListAlertsOptions{}
	l.GetPackage()
	l = nil
	l.GetPackage()
}

func TestListAlertsOptions_GetScope(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	l := &ListAlertsOptions{Scope: &zeroValue}
	l.GetScope()
	l = &ListAlertsOptions{}
	l.GetScope()
	l = nil
	l.GetScope()
}

func TestListAlertsOptions_GetSeverity(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	l := &ListAlertsOptions{Severity: &zeroValue}
	l.GetSeverity()
	l = &ListAlertsOptions{}
	l.GetSeverity()
	l = nil
	l.GetSeverity()
}

func TestListAlertsOptions_GetSort(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	l := &ListAlertsOptions{Sort: &zeroValue}
	l.GetSort()
	l = &ListAlertsOptions{}
	l.GetSort()
	l = nil
	l.GetSort()
}

func TestListAlertsOptions_GetState(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	l := &ListAlertsOptions{State: &zeroValue}
	l.GetState()
	l = &ListAlertsOptions{}
	l.GetState()
	l = nil
	l.GetState()
}

func TestListAllIssuesOptions_GetCollab(tt *testing.T) {
	tt.Parallel()
	l := &ListAllIssuesOptions{}
	l.GetCollab()
	l = nil
	l.GetCollab()
}

func TestListAllIssuesOptions_GetDirection(tt *testing.T) {
	tt.Parallel()
	l := &ListAllIssuesOptions{}
	l.GetDirection()
	l = nil
	l.GetDirection()
}

func TestListAllIssuesOptions_GetFilter(tt *testing.T) {
	tt.Parallel()
	l := &ListAllIssuesOptions{}
	l.GetFilter()
	l = nil
	l.GetFilter()
}

func TestListAllIssuesOptions_GetLabels(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	l := &ListAllIssuesOptions{Labels: zeroValue}
	l.GetLabels()
	l = &ListAllIssuesOptions{}
	l.GetLabels()
	l = nil
	l.GetLabels()
}

func TestListAllIssuesOptions_GetOrgs(tt *testing.T) {
	tt.Parallel()
	l := &ListAllIssuesOptions{}
	l.GetOrgs()
	l = nil
	l.GetOrgs()
}

func TestListAllIssuesOptions_GetOwned(tt *testing.T) {
	tt.Parallel()
	l := &ListAllIssuesOptions{}
	l.GetOwned()
	l = nil
	l.GetOwned()
}

func TestListAllIssuesOptions_GetPulls(tt *testing.T) {
	tt.Parallel()
	l := &ListAllIssuesOptions{}
	l.GetPulls()
	l = nil
	l.GetPulls()
}

func TestListAllIssuesOptions_GetSince(tt *testing.T) {
	tt.Parallel()
	l := &ListAllIssuesOptions{}
	l.GetSince()
	l = nil
	l.GetSince()
}

func TestListAllIssuesOptions_GetSort(tt *testing.T) {
	tt.Parallel()
	l := &ListAllIssuesOptions{}
	l.GetSort()
	l = nil
	l.GetSort()
}

func TestListAllIssuesOptions_GetState(tt *testing.T) {
	tt.Parallel()
	l := &ListAllIssuesOptions{}
	l.GetState()
	l = nil
	l.GetState()
}

func TestListArtifactsOptions_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	l := &ListArtifactsOptions{Name: &zeroValue}
	l.GetName()
	l = &ListArtifactsOptions{}
	l.GetName()
	l = nil
	l.GetName()
}

func TestListCheckRunsOptions_GetAppID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	l := &ListCheckRunsOptions{AppID: &zeroValue}
	l.GetAppID()
	l = &ListCheckRunsOptions{}
	l.GetAppID()
	l = nil
	l.GetAppID()
}

func TestListCheckRunsOptions_GetCheckName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	l := &ListCheckRunsOptions{CheckName: &zeroValue}
	l.GetCheckName()
	l = &ListCheckRunsOptions{}
	l.GetCheckName()
	l = nil
	l.GetCheckName()
}

func TestListCheckRunsOptions_GetFilter(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	l := &ListCheckRunsOptions{Filter: &zeroValue}
	l.GetFilter()
	l = &ListCheckRunsOptions{}
	l.GetFilter()
	l = nil
	l.GetFilter()
}

func TestListCheckRunsOptions_GetStatus(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	l := &ListCheckRunsOptions{Status: &zeroValue}
	l.GetStatus()
	l = &ListCheckRunsOptions{}
	l.GetStatus()
	l = nil
	l.GetStatus()
}

func TestListCheckRunsResults_GetCheckRuns(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*CheckRun{}
	l := &ListCheckRunsResults{CheckRuns: zeroValue}
	l.GetCheckRuns()
	l = &ListCheckRunsResults{}
	l.GetCheckRuns()
	l = nil
	l.GetCheckRuns()
}

func TestListCheckRunsResults_GetTotal(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	l := &ListCheckRunsResults{Total: &zeroValue}
	l.GetTotal()
	l = &ListCheckRunsResults{}
	l.GetTotal()
	l = nil
	l.GetTotal()
}

func TestListCheckSuiteOptions_GetAppID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	l := &ListCheckSuiteOptions{AppID: &zeroValue}
	l.GetAppID()
	l = &ListCheckSuiteOptions{}
	l.GetAppID()
	l = nil
	l.GetAppID()
}

func TestListCheckSuiteOptions_GetCheckName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	l := &ListCheckSuiteOptions{CheckName: &zeroValue}
	l.GetCheckName()
	l = &ListCheckSuiteOptions{}
	l.GetCheckName()
	l = nil
	l.GetCheckName()
}

func TestListCheckSuiteResults_GetCheckSuites(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*CheckSuite{}
	l := &ListCheckSuiteResults{CheckSuites: zeroValue}
	l.GetCheckSuites()
	l = &ListCheckSuiteResults{}
	l.GetCheckSuites()
	l = nil
	l.GetCheckSuites()
}

func TestListCheckSuiteResults_GetTotal(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	l := &ListCheckSuiteResults{Total: &zeroValue}
	l.GetTotal()
	l = &ListCheckSuiteResults{}
	l.GetTotal()
	l = nil
	l.GetTotal()
}

func TestListCodeQualityFindingsOptions_GetDirection(tt *testing.T) {
	tt.Parallel()
	l := &ListCodeQualityFindingsOptions{}
	l.GetDirection()
	l = nil
	l.GetDirection()
}

func TestListCodeQualityFindingsOptions_GetState(tt *testing.T) {
	tt.Parallel()
	l := &ListCodeQualityFindingsOptions{}
	l.GetState()
	l = nil
	l.GetState()
}

func TestListCodeSecurityConfigurationRepositoriesOptions_GetAfter(tt *testing.T) {
	tt.Parallel()
	l := &ListCodeSecurityConfigurationRepositoriesOptions{}
	l.GetAfter()
	l = nil
	l.GetAfter()
}

func TestListCodeSecurityConfigurationRepositoriesOptions_GetBefore(tt *testing.T) {
	tt.Parallel()
	l := &ListCodeSecurityConfigurationRepositoriesOptions{}
	l.GetBefore()
	l = nil
	l.GetBefore()
}

func TestListCodeSecurityConfigurationRepositoriesOptions_GetPerPage(tt *testing.T) {
	tt.Parallel()
	l := &ListCodeSecurityConfigurationRepositoriesOptions{}
	l.GetPerPage()
	l = nil
	l.GetPerPage()
}

func TestListCodeSecurityConfigurationRepositoriesOptions_GetStatus(tt *testing.T) {
	tt.Parallel()
	l := &ListCodeSecurityConfigurationRepositoriesOptions{}
	l.GetStatus()
	l = nil
	l.GetStatus()
}

func TestListCodespaces_GetCodespaces(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*Codespace{}
	l := &ListCodespaces{Codespaces: zeroValue}
	l.GetCodespaces()
	l = &ListCodespaces{}
	l.GetCodespaces()
	l = nil
	l.GetCodespaces()
}

func TestListCodespaces_GetTotalCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	l := &ListCodespaces{TotalCount: &zeroValue}
	l.GetTotalCount()
	l = &ListCodespaces{}
	l.GetTotalCount()
	l = nil
	l.GetTotalCount()
}

func TestListCodespacesOptions_GetRepositoryID(tt *testing.T) {
	tt.Parallel()
	l := &ListCodespacesOptions{}
	l.GetRepositoryID()
	l = nil
	l.GetRepositoryID()
}

func TestListCollaboratorsOptions_GetAffiliation(tt *testing.T) {
	tt.Parallel()
	l := &ListCollaboratorsOptions{}
	l.GetAffiliation()
	l = nil
	l.GetAffiliation()
}

func TestListCollaboratorsOptions_GetPermission(tt *testing.T) {
	tt.Parallel()
	l := &ListCollaboratorsOptions{}
	l.GetPermission()
	l = nil
	l.GetPermission()
}

func TestListContributorsOptions_GetAnon(tt *testing.T) {
	tt.Parallel()
	l := &ListContributorsOptions{}
	l.GetAnon()
	l = nil
	l.GetAnon()
}

func TestListCopilotSeatsResponse_GetSeats(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*CopilotSeatDetails{}
	l := &ListCopilotSeatsResponse{Seats: zeroValue}
	l.GetSeats()
	l = &ListCopilotSeatsResponse{}
	l.GetSeats()
	l = nil
	l.GetSeats()
}

func TestListCopilotSeatsResponse_GetTotalSeats(tt *testing.T) {
	tt.Parallel()
	l := &ListCopilotSeatsResponse{}
	l.GetTotalSeats()
	l = nil
	l.GetTotalSeats()
}

func TestListCostCenterOptions_GetState(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	l := &ListCostCenterOptions{State: &zeroValue}
	l.GetState()
	l = &ListCostCenterOptions{}
	l.GetState()
	l = nil
	l.GetState()
}

func TestListCursorOptions_GetAfter(tt *testing.T) {
	tt.Parallel()
	l := &ListCursorOptions{}
	l.GetAfter()
	l = nil
	l.GetAfter()
}

func TestListCursorOptions_GetBefore(tt *testing.T) {
	tt.Parallel()
	l := &ListCursorOptions{}
	l.GetBefore()
	l = nil
	l.GetBefore()
}

func TestListCursorOptions_GetCursor(tt *testing.T) {
	tt.Parallel()
	l := &ListCursorOptions{}
	l.GetCursor()
	l = nil
	l.GetCursor()
}

func TestListCursorOptions_GetFirst(tt *testing.T) {
	tt.Parallel()
	l := &ListCursorOptions{}
	l.GetFirst()
	l = nil
	l.GetFirst()
}

func TestListCursorOptions_GetLast(tt *testing.T) {
	tt.Parallel()
	l := &ListCursorOptions{}
	l.GetLast()
	l = nil
	l.GetLast()
}

func TestListCursorOptions_GetPage(tt *testing.T) {
	tt.Parallel()
	l := &ListCursorOptions{}
	l.GetPage()
	l = nil
	l.GetPage()
}

func TestListCursorOptions_GetPerPage(tt *testing.T) {
	tt.Parallel()
	l := &ListCursorOptions{}
	l.GetPerPage()
	l = nil
	l.GetPerPage()
}

func TestListCustomDeploymentRuleIntegrationsResponse_GetAvailableIntegrations(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*CustomDeploymentProtectionRuleApp{}
	l := &ListCustomDeploymentRuleIntegrationsResponse{AvailableIntegrations: zeroValue}
	l.GetAvailableIntegrations()
	l = &ListCustomDeploymentRuleIntegrationsResponse{}
	l.GetAvailableIntegrations()
	l = nil
	l.GetAvailableIntegrations()
}

func TestListCustomDeploymentRuleIntegrationsResponse_GetTotalCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	l := &ListCustomDeploymentRuleIntegrationsResponse{TotalCount: &zeroValue}
	l.GetTotalCount()
	l = &ListCustomDeploymentRuleIntegrationsResponse{}
	l.GetTotalCount()
	l = nil
	l.GetTotalCount()
}

func TestListCustomPropertyValuesOptions_GetRepositoryQuery(tt *testing.T) {
	tt.Parallel()
	l := &ListCustomPropertyValuesOptions{}
	l.GetRepositoryQuery()
	l = nil
	l.GetRepositoryQuery()
}

func TestListDeploymentProtectionRuleResponse_GetProtectionRules(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*CustomDeploymentProtectionRule{}
	l := &ListDeploymentProtectionRuleResponse{ProtectionRules: zeroValue}
	l.GetProtectionRules()
	l = &ListDeploymentProtectionRuleResponse{}
	l.GetProtectionRules()
	l = nil
	l.GetProtectionRules()
}

func TestListDeploymentProtectionRuleResponse_GetTotalCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	l := &ListDeploymentProtectionRuleResponse{TotalCount: &zeroValue}
	l.GetTotalCount()
	l = &ListDeploymentProtectionRuleResponse{}
	l.GetTotalCount()
	l = nil
	l.GetTotalCount()
}

func TestListEnterpriseCodeSecurityConfigurationOptions_GetAfter(tt *testing.T) {
	tt.Parallel()
	l := &ListEnterpriseCodeSecurityConfigurationOptions{}
	l.GetAfter()
	l = nil
	l.GetAfter()
}

func TestListEnterpriseCodeSecurityConfigurationOptions_GetBefore(tt *testing.T) {
	tt.Parallel()
	l := &ListEnterpriseCodeSecurityConfigurationOptions{}
	l.GetBefore()
	l = nil
	l.GetBefore()
}

func TestListEnterpriseCodeSecurityConfigurationOptions_GetPerPage(tt *testing.T) {
	tt.Parallel()
	l := &ListEnterpriseCodeSecurityConfigurationOptions{}
	l.GetPerPage()
	l = nil
	l.GetPerPage()
}

func TestListEnterpriseRunnerGroupOptions_GetVisibleToOrganization(tt *testing.T) {
	tt.Parallel()
	l := &ListEnterpriseRunnerGroupOptions{}
	l.GetVisibleToOrganization()
	l = nil
	l.GetVisibleToOrganization()
}

func TestListExternalGroupsOptions_GetDisplayName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	l := &ListExternalGroupsOptions{DisplayName: &zeroValue}
	l.GetDisplayName()
	l = &ListExternalGroupsOptions{}
	l.GetDisplayName()
	l = nil
	l.GetDisplayName()
}

func TestListFineGrainedPATOptions_GetDirection(tt *testing.T) {
	tt.Parallel()
	l := &ListFineGrainedPATOptions{}
	l.GetDirection()
	l = nil
	l.GetDirection()
}

func TestListFineGrainedPATOptions_GetLastUsedAfter(tt *testing.T) {
	tt.Parallel()
	l := &ListFineGrainedPATOptions{}
	l.GetLastUsedAfter()
	l = nil
	l.GetLastUsedAfter()
}

func TestListFineGrainedPATOptions_GetLastUsedBefore(tt *testing.T) {
	tt.Parallel()
	l := &ListFineGrainedPATOptions{}
	l.GetLastUsedBefore()
	l = nil
	l.GetLastUsedBefore()
}

func TestListFineGrainedPATOptions_GetOwner(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	l := &ListFineGrainedPATOptions{Owner: zeroValue}
	l.GetOwner()
	l = &ListFineGrainedPATOptions{}
	l.GetOwner()
	l = nil
	l.GetOwner()
}

func TestListFineGrainedPATOptions_GetPermission(tt *testing.T) {
	tt.Parallel()
	l := &ListFineGrainedPATOptions{}
	l.GetPermission()
	l = nil
	l.GetPermission()
}

func TestListFineGrainedPATOptions_GetRepository(tt *testing.T) {
	tt.Parallel()
	l := &ListFineGrainedPATOptions{}
	l.GetRepository()
	l = nil
	l.GetRepository()
}

func TestListFineGrainedPATOptions_GetSort(tt *testing.T) {
	tt.Parallel()
	l := &ListFineGrainedPATOptions{}
	l.GetSort()
	l = nil
	l.GetSort()
}

func TestListFineGrainedPATOptions_GetTokenID(tt *testing.T) {
	tt.Parallel()
	zeroValue := []int64{}
	l := &ListFineGrainedPATOptions{TokenID: zeroValue}
	l.GetTokenID()
	l = &ListFineGrainedPATOptions{}
	l.GetTokenID()
	l = nil
	l.GetTokenID()
}

func TestListGlobalSecurityAdvisoriesOptions_GetAffects(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	l := &ListGlobalSecurityAdvisoriesOptions{Affects: &zeroValue}
	l.GetAffects()
	l = &ListGlobalSecurityAdvisoriesOptions{}
	l.GetAffects()
	l = nil
	l.GetAffects()
}

func TestListGlobalSecurityAdvisoriesOptions_GetCVEID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	l := &ListGlobalSecurityAdvisoriesOptions{CVEID: &zeroValue}
	l.GetCVEID()
	l = &ListGlobalSecurityAdvisoriesOptions{}
	l.GetCVEID()
	l = nil
	l.GetCVEID()
}

func TestListGlobalSecurityAdvisoriesOptions_GetCWEs(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	l := &ListGlobalSecurityAdvisoriesOptions{CWEs: zeroValue}
	l.GetCWEs()
	l = &ListGlobalSecurityAdvisoriesOptions{}
	l.GetCWEs()
	l = nil
	l.GetCWEs()
}

func TestListGlobalSecurityAdvisoriesOptions_GetEcosystem(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	l := &ListGlobalSecurityAdvisoriesOptions{Ecosystem: &zeroValue}
	l.GetEcosystem()
	l = &ListGlobalSecurityAdvisoriesOptions{}
	l.GetEcosystem()
	l = nil
	l.GetEcosystem()
}

func TestListGlobalSecurityAdvisoriesOptions_GetGHSAID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	l := &ListGlobalSecurityAdvisoriesOptions{GHSAID: &zeroValue}
	l.GetGHSAID()
	l = &ListGlobalSecurityAdvisoriesOptions{}
	l.GetGHSAID()
	l = nil
	l.GetGHSAID()
}

func TestListGlobalSecurityAdvisoriesOptions_GetIsWithdrawn(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	l := &ListGlobalSecurityAdvisoriesOptions{IsWithdrawn: &zeroValue}
	l.GetIsWithdrawn()
	l = &ListGlobalSecurityAdvisoriesOptions{}
	l.GetIsWithdrawn()
	l = nil
	l.GetIsWithdrawn()
}

func TestListGlobalSecurityAdvisoriesOptions_GetModified(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	l := &ListGlobalSecurityAdvisoriesOptions{Modified: &zeroValue}
	l.GetModified()
	l = &ListGlobalSecurityAdvisoriesOptions{}
	l.GetModified()
	l = nil
	l.GetModified()
}

func TestListGlobalSecurityAdvisoriesOptions_GetPublished(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	l := &ListGlobalSecurityAdvisoriesOptions{Published: &zeroValue}
	l.GetPublished()
	l = &ListGlobalSecurityAdvisoriesOptions{}
	l.GetPublished()
	l = nil
	l.GetPublished()
}

func TestListGlobalSecurityAdvisoriesOptions_GetSeverity(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	l := &ListGlobalSecurityAdvisoriesOptions{Severity: &zeroValue}
	l.GetSeverity()
	l = &ListGlobalSecurityAdvisoriesOptions{}
	l.GetSeverity()
	l = nil
	l.GetSeverity()
}

func TestListGlobalSecurityAdvisoriesOptions_GetType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	l := &ListGlobalSecurityAdvisoriesOptions{Type: &zeroValue}
	l.GetType()
	l = &ListGlobalSecurityAdvisoriesOptions{}
	l.GetType()
	l = nil
	l.GetType()
}

func TestListGlobalSecurityAdvisoriesOptions_GetUpdated(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	l := &ListGlobalSecurityAdvisoriesOptions{Updated: &zeroValue}
	l.GetUpdated()
	l = &ListGlobalSecurityAdvisoriesOptions{}
	l.GetUpdated()
	l = nil
	l.GetUpdated()
}

func TestListIDPGroupsOptions_GetQuery(tt *testing.T) {
	tt.Parallel()
	l := &ListIDPGroupsOptions{}
	l.GetQuery()
	l = nil
	l.GetQuery()
}

func TestListLicensesOptions_GetFeatured(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	l := &ListLicensesOptions{Featured: &zeroValue}
	l.GetFeatured()
	l = &ListLicensesOptions{}
	l.GetFeatured()
	l = nil
	l.GetFeatured()
}

func TestListMembersOptions_GetFilter(tt *testing.T) {
	tt.Parallel()
	l := &ListMembersOptions{}
	l.GetFilter()
	l = nil
	l.GetFilter()
}

func TestListMembersOptions_GetPublicOnly(tt *testing.T) {
	tt.Parallel()
	l := &ListMembersOptions{}
	l.GetPublicOnly()
	l = nil
	l.GetPublicOnly()
}

func TestListMembersOptions_GetRole(tt *testing.T) {
	tt.Parallel()
	l := &ListMembersOptions{}
	l.GetRole()
	l = nil
	l.GetRole()
}

func TestListOptions_GetPage(tt *testing.T) {
	tt.Parallel()
	l := &ListOptions{}
	l.GetPage()
	l = nil
	l.GetPage()
}

func TestListOptions_GetPerPage(tt *testing.T) {
	tt.Parallel()
	l := &ListOptions{}
	l.GetPerPage()
	l = nil
	l.GetPerPage()
}

func TestListOrganizationCopilotCodingAgentRepositoriesResponse_GetRepositories(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*Repository{}
	l := &ListOrganizationCopilotCodingAgentRepositoriesResponse{Repositories: zeroValue}
	l.GetRepositories()
	l = &ListOrganizationCopilotCodingAgentRepositoriesResponse{}
	l.GetRepositories()
	l = nil
	l.GetRepositories()
}

func TestListOrganizationCopilotCodingAgentRepositoriesResponse_GetTotalCount(tt *testing.T) {
	tt.Parallel()
	l := &ListOrganizationCopilotCodingAgentRepositoriesResponse{}
	l.GetTotalCount()
	l = nil
	l.GetTotalCount()
}

func TestListOrganizations_GetOrganizations(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*Organization{}
	l := &ListOrganizations{Organizations: zeroValue}
	l.GetOrganizations()
	l = &ListOrganizations{}
	l.GetOrganizations()
	l = nil
	l.GetOrganizations()
}

func TestListOrganizations_GetTotalCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	l := &ListOrganizations{TotalCount: &zeroValue}
	l.GetTotalCount()
	l = &ListOrganizations{}
	l.GetTotalCount()
	l = nil
	l.GetTotalCount()
}

func TestListOrgCodeSecurityConfigurationOptions_GetAfter(tt *testing.T) {
	tt.Parallel()
	l := &ListOrgCodeSecurityConfigurationOptions{}
	l.GetAfter()
	l = nil
	l.GetAfter()
}

func TestListOrgCodeSecurityConfigurationOptions_GetBefore(tt *testing.T) {
	tt.Parallel()
	l := &ListOrgCodeSecurityConfigurationOptions{}
	l.GetBefore()
	l = nil
	l.GetBefore()
}

func TestListOrgCodeSecurityConfigurationOptions_GetPerPage(tt *testing.T) {
	tt.Parallel()
	l := &ListOrgCodeSecurityConfigurationOptions{}
	l.GetPerPage()
	l = nil
	l.GetPerPage()
}

func TestListOrgCodeSecurityConfigurationOptions_GetTargetType(tt *testing.T) {
	tt.Parallel()
	l := &ListOrgCodeSecurityConfigurationOptions{}
	l.GetTargetType()
	l = nil
	l.GetTargetType()
}

func TestListOrgMembershipsOptions_GetState(tt *testing.T) {
	tt.Parallel()
	l := &ListOrgMembershipsOptions{}
	l.GetState()
	l = nil
	l.GetState()
}

func TestListOrgRunnerGroupOptions_GetVisibleToRepository(tt *testing.T) {
	tt.Parallel()
	l := &ListOrgRunnerGroupOptions{}
	l.GetVisibleToRepository()
	l = nil
	l.GetVisibleToRepository()
}

func TestListOutsideCollaboratorsOptions_GetFilter(tt *testing.T) {
	tt.Parallel()
	l := &ListOutsideCollaboratorsOptions{}
	l.GetFilter()
	l = nil
	l.GetFilter()
}

func TestListPackageVersionsOptions_GetState(tt *testing.T) {
	tt.Parallel()
	l := &ListPackageVersionsOptions{}
	l.GetState()
	l = nil
	l.GetState()
}

func TestListProjectItemsOptions_GetFields(tt *testing.T) {
	tt.Parallel()
	zeroValue := []int64{}
	l := &ListProjectItemsOptions{Fields: zeroValue}
	l.GetFields()
	l = &ListProjectItemsOptions{}
	l.GetFields()
	l = nil
	l.GetFields()
}

func TestListProjectsOptions_GetQuery(tt *testing.T) {
	tt.Parallel()
	l := &ListProjectsOptions{}
	l.GetQuery()
	l = nil
	l.GetQuery()
}

func TestListProjectsPaginationOptions_GetAfter(tt *testing.T) {
	tt.Parallel()
	l := &ListProjectsPaginationOptions{}
	l.GetAfter()
	l = nil
	l.GetAfter()
}

func TestListProjectsPaginationOptions_GetBefore(tt *testing.T) {
	tt.Parallel()
	l := &ListProjectsPaginationOptions{}
	l.GetBefore()
	l = nil
	l.GetBefore()
}

func TestListProjectsPaginationOptions_GetPerPage(tt *testing.T) {
	tt.Parallel()
	l := &ListProjectsPaginationOptions{}
	l.GetPerPage()
	l = nil
	l.GetPerPage()
}

func TestListProvisionedSCIMGroupsEnterpriseOptions_GetCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	l := &ListProvisionedSCIMGroupsEnterpriseOptions{Count: &zeroValue}
	l.GetCount()
	l = &ListProvisionedSCIMGroupsEnterpriseOptions{}
	l.GetCount()
	l = nil
	l.GetCount()
}

func TestListProvisionedSCIMGroupsEnterpriseOptions_GetExcludedAttributes(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	l := &ListProvisionedSCIMGroupsEnterpriseOptions{ExcludedAttributes: &zeroValue}
	l.GetExcludedAttributes()
	l = &ListProvisionedSCIMGroupsEnterpriseOptions{}
	l.GetExcludedAttributes()
	l = nil
	l.GetExcludedAttributes()
}

func TestListProvisionedSCIMGroupsEnterpriseOptions_GetFilter(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	l := &ListProvisionedSCIMGroupsEnterpriseOptions{Filter: &zeroValue}
	l.GetFilter()
	l = &ListProvisionedSCIMGroupsEnterpriseOptions{}
	l.GetFilter()
	l = nil
	l.GetFilter()
}

func TestListProvisionedSCIMGroupsEnterpriseOptions_GetStartIndex(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	l := &ListProvisionedSCIMGroupsEnterpriseOptions{StartIndex: &zeroValue}
	l.GetStartIndex()
	l = &ListProvisionedSCIMGroupsEnterpriseOptions{}
	l.GetStartIndex()
	l = nil
	l.GetStartIndex()
}

func TestListProvisionedSCIMUsersEnterpriseOptions_GetCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	l := &ListProvisionedSCIMUsersEnterpriseOptions{Count: &zeroValue}
	l.GetCount()
	l = &ListProvisionedSCIMUsersEnterpriseOptions{}
	l.GetCount()
	l = nil
	l.GetCount()
}

func TestListProvisionedSCIMUsersEnterpriseOptions_GetFilter(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	l := &ListProvisionedSCIMUsersEnterpriseOptions{Filter: &zeroValue}
	l.GetFilter()
	l = &ListProvisionedSCIMUsersEnterpriseOptions{}
	l.GetFilter()
	l = nil
	l.GetFilter()
}

func TestListProvisionedSCIMUsersEnterpriseOptions_GetStartIndex(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	l := &ListProvisionedSCIMUsersEnterpriseOptions{StartIndex: &zeroValue}
	l.GetStartIndex()
	l = &ListProvisionedSCIMUsersEnterpriseOptions{}
	l.GetStartIndex()
	l = nil
	l.GetStartIndex()
}

func TestListReactionOptions_GetContent(tt *testing.T) {
	tt.Parallel()
	l := &ListReactionOptions{}
	l.GetContent()
	l = nil
	l.GetContent()
}

func TestListRepoMachineTypesOptions_GetClientIP(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	l := &ListRepoMachineTypesOptions{ClientIP: &zeroValue}
	l.GetClientIP()
	l = &ListRepoMachineTypesOptions{}
	l.GetClientIP()
	l = nil
	l.GetClientIP()
}

func TestListRepoMachineTypesOptions_GetLocation(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	l := &ListRepoMachineTypesOptions{Location: &zeroValue}
	l.GetLocation()
	l = &ListRepoMachineTypesOptions{}
	l.GetLocation()
	l = nil
	l.GetLocation()
}

func TestListRepoMachineTypesOptions_GetRef(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	l := &ListRepoMachineTypesOptions{Ref: &zeroValue}
	l.GetRef()
	l = &ListRepoMachineTypesOptions{}
	l.GetRef()
	l = nil
	l.GetRef()
}

func TestListRepositories_GetRepositories(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*Repository{}
	l := &ListRepositories{Repositories: zeroValue}
	l.GetRepositories()
	l = &ListRepositories{}
	l.GetRepositories()
	l = nil
	l.GetRepositories()
}

func TestListRepositories_GetTotalCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	l := &ListRepositories{TotalCount: &zeroValue}
	l.GetTotalCount()
	l = &ListRepositories{}
	l.GetTotalCount()
	l = nil
	l.GetTotalCount()
}

func TestListRepositoryActivityOptions_GetActivityType(tt *testing.T) {
	tt.Parallel()
	l := &ListRepositoryActivityOptions{}
	l.GetActivityType()
	l = nil
	l.GetActivityType()
}

func TestListRepositoryActivityOptions_GetActor(tt *testing.T) {
	tt.Parallel()
	l := &ListRepositoryActivityOptions{}
	l.GetActor()
	l = nil
	l.GetActor()
}

func TestListRepositoryActivityOptions_GetAfter(tt *testing.T) {
	tt.Parallel()
	l := &ListRepositoryActivityOptions{}
	l.GetAfter()
	l = nil
	l.GetAfter()
}

func TestListRepositoryActivityOptions_GetBefore(tt *testing.T) {
	tt.Parallel()
	l := &ListRepositoryActivityOptions{}
	l.GetBefore()
	l = nil
	l.GetBefore()
}

func TestListRepositoryActivityOptions_GetDirection(tt *testing.T) {
	tt.Parallel()
	l := &ListRepositoryActivityOptions{}
	l.GetDirection()
	l = nil
	l.GetDirection()
}

func TestListRepositoryActivityOptions_GetPerPage(tt *testing.T) {
	tt.Parallel()
	l := &ListRepositoryActivityOptions{}
	l.GetPerPage()
	l = nil
	l.GetPerPage()
}

func TestListRepositoryActivityOptions_GetRef(tt *testing.T) {
	tt.Parallel()
	l := &ListRepositoryActivityOptions{}
	l.GetRef()
	l = nil
	l.GetRef()
}

func TestListRepositoryActivityOptions_GetTimePeriod(tt *testing.T) {
	tt.Parallel()
	l := &ListRepositoryActivityOptions{}
	l.GetTimePeriod()
	l = nil
	l.GetTimePeriod()
}

func TestListRepositorySecurityAdvisoriesOptions_GetDirection(tt *testing.T) {
	tt.Parallel()
	l := &ListRepositorySecurityAdvisoriesOptions{}
	l.GetDirection()
	l = nil
	l.GetDirection()
}

func TestListRepositorySecurityAdvisoriesOptions_GetSort(tt *testing.T) {
	tt.Parallel()
	l := &ListRepositorySecurityAdvisoriesOptions{}
	l.GetSort()
	l = nil
	l.GetSort()
}

func TestListRepositorySecurityAdvisoriesOptions_GetState(tt *testing.T) {
	tt.Parallel()
	l := &ListRepositorySecurityAdvisoriesOptions{}
	l.GetState()
	l = nil
	l.GetState()
}

func TestListRunnersOptions_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	l := &ListRunnersOptions{Name: &zeroValue}
	l.GetName()
	l = &ListRunnersOptions{}
	l.GetName()
	l = nil
	l.GetName()
}

func TestListSCIMProvisionedIdentitiesOptions_GetCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	l := &ListSCIMProvisionedIdentitiesOptions{Count: &zeroValue}
	l.GetCount()
	l = &ListSCIMProvisionedIdentitiesOptions{}
	l.GetCount()
	l = nil
	l.GetCount()
}

func TestListSCIMProvisionedIdentitiesOptions_GetFilter(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	l := &ListSCIMProvisionedIdentitiesOptions{Filter: &zeroValue}
	l.GetFilter()
	l = &ListSCIMProvisionedIdentitiesOptions{}
	l.GetFilter()
	l = nil
	l.GetFilter()
}

func TestListSCIMProvisionedIdentitiesOptions_GetStartIndex(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	l := &ListSCIMProvisionedIdentitiesOptions{StartIndex: &zeroValue}
	l.GetStartIndex()
	l = &ListSCIMProvisionedIdentitiesOptions{}
	l.GetStartIndex()
	l = nil
	l.GetStartIndex()
}

func TestListUserIssuesOptions_GetDirection(tt *testing.T) {
	tt.Parallel()
	l := &ListUserIssuesOptions{}
	l.GetDirection()
	l = nil
	l.GetDirection()
}

func TestListUserIssuesOptions_GetFilter(tt *testing.T) {
	tt.Parallel()
	l := &ListUserIssuesOptions{}
	l.GetFilter()
	l = nil
	l.GetFilter()
}

func TestListUserIssuesOptions_GetLabels(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	l := &ListUserIssuesOptions{Labels: zeroValue}
	l.GetLabels()
	l = &ListUserIssuesOptions{}
	l.GetLabels()
	l = nil
	l.GetLabels()
}

func TestListUserIssuesOptions_GetSince(tt *testing.T) {
	tt.Parallel()
	l := &ListUserIssuesOptions{}
	l.GetSince()
	l = nil
	l.GetSince()
}

func TestListUserIssuesOptions_GetSort(tt *testing.T) {
	tt.Parallel()
	l := &ListUserIssuesOptions{}
	l.GetSort()
	l = nil
	l.GetSort()
}

func TestListUserIssuesOptions_GetState(tt *testing.T) {
	tt.Parallel()
	l := &ListUserIssuesOptions{}
	l.GetState()
	l = nil
	l.GetState()
}

func TestListWorkflowJobsOptions_GetFilter(tt *testing.T) {
	tt.Parallel()
	l := &ListWorkflowJobsOptions{}
	l.GetFilter()
	l = nil
	l.GetFilter()
}

func TestListWorkflowRunsOptions_GetActor(tt *testing.T) {
	tt.Parallel()
	l := &ListWorkflowRunsOptions{}
	l.GetActor()
	l = nil
	l.GetActor()
}

func TestListWorkflowRunsOptions_GetBranch(tt *testing.T) {
	tt.Parallel()
	l := &ListWorkflowRunsOptions{}
	l.GetBranch()
	l = nil
	l.GetBranch()
}

func TestListWorkflowRunsOptions_GetCheckSuiteID(tt *testing.T) {
	tt.Parallel()
	l := &ListWorkflowRunsOptions{}
	l.GetCheckSuiteID()
	l = nil
	l.GetCheckSuiteID()
}

func TestListWorkflowRunsOptions_GetCreated(tt *testing.T) {
	tt.Parallel()
	l := &ListWorkflowRunsOptions{}
	l.GetCreated()
	l = nil
	l.GetCreated()
}

func TestListWorkflowRunsOptions_GetEvent(tt *testing.T) {
	tt.Parallel()
	l := &ListWorkflowRunsOptions{}
	l.GetEvent()
	l = nil
	l.GetEvent()
}

func TestListWorkflowRunsOptions_GetExcludePullRequests(tt *testing.T) {
	tt.Parallel()
	l := &ListWorkflowRunsOptions{}
	l.GetExcludePullRequests()
	l = nil
	l.GetExcludePullRequests()
}

func TestListWorkflowRunsOptions_GetHeadSHA(tt *testing.T) {
	tt.Parallel()
	l := &ListWorkflowRunsOptions{}
	l.GetHeadSHA()
	l = nil
	l.GetHeadSHA()
}

func TestListWorkflowRunsOptions_GetStatus(tt *testing.T) {
	tt.Parallel()
	l := &ListWorkflowRunsOptions{}
	l.GetStatus()
	l = nil
	l.GetStatus()
}

func TestLocation_GetEndColumn(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	l := &Location{EndColumn: &zeroValue}
	l.GetEndColumn()
	l = &Location{}
	l.GetEndColumn()
	l = nil
	l.GetEndColumn()
}

func TestLocation_GetEndLine(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	l := &Location{EndLine: &zeroValue}
	l.GetEndLine()
	l = &Location{}
	l.GetEndLine()
	l = nil
	l.GetEndLine()
}

func TestLocation_GetPath(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	l := &Location{Path: &zeroValue}
	l.GetPath()
	l = &Location{}
	l.GetPath()
	l = nil
	l.GetPath()
}

func TestLocation_GetStartColumn(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	l := &Location{StartColumn: &zeroValue}
	l.GetStartColumn()
	l = &Location{}
	l.GetStartColumn()
	l = nil
	l.GetStartColumn()
}

func TestLocation_GetStartLine(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	l := &Location{StartLine: &zeroValue}
	l.GetStartLine()
	l = &Location{}
	l.GetStartLine()
	l = nil
	l.GetStartLine()
}

func TestLockBranch_GetEnabled(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	l := &LockBranch{Enabled: &zeroValue}
	l.GetEnabled()
	l = &LockBranch{}
	l.GetEnabled()
	l = nil
	l.GetEnabled()
}

func TestLockIssueOptions_GetLockReason(tt *testing.T) {
	tt.Parallel()
	l := &LockIssueOptions{}
	l.GetLockReason()
	l = nil
	l.GetLockReason()
}

func TestMaintenanceOperationStatus_GetHostname(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &MaintenanceOperationStatus{Hostname: &zeroValue}
	m.GetHostname()
	m = &MaintenanceOperationStatus{}
	m.GetHostname()
	m = nil
	m.GetHostname()
}

func TestMaintenanceOperationStatus_GetMessage(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &MaintenanceOperationStatus{Message: &zeroValue}
	m.GetMessage()
	m = &MaintenanceOperationStatus{}
	m.GetMessage()
	m = nil
	m.GetMessage()
}

func TestMaintenanceOperationStatus_GetUUID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &MaintenanceOperationStatus{UUID: &zeroValue}
	m.GetUUID()
	m = &MaintenanceOperationStatus{}
	m.GetUUID()
	m = nil
	m.GetUUID()
}

func TestMaintenanceOptions_GetEnabled(tt *testing.T) {
	tt.Parallel()
	m := &MaintenanceOptions{}
	m.GetEnabled()
	m = nil
	m.GetEnabled()
}

func TestMaintenanceOptions_GetIPExceptionList(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	m := &MaintenanceOptions{IPExceptionList: zeroValue}
	m.GetIPExceptionList()
	m = &MaintenanceOptions{}
	m.GetIPExceptionList()
	m = nil
	m.GetIPExceptionList()
}

func TestMaintenanceOptions_GetMaintenanceModeMessage(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &MaintenanceOptions{MaintenanceModeMessage: &zeroValue}
	m.GetMaintenanceModeMessage()
	m = &MaintenanceOptions{}
	m.GetMaintenanceModeMessage()
	m = nil
	m.GetMaintenanceModeMessage()
}

func TestMaintenanceOptions_GetUUID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &MaintenanceOptions{UUID: &zeroValue}
	m.GetUUID()
	m = &MaintenanceOptions{}
	m.GetUUID()
	m = nil
	m.GetUUID()
}

func TestMaintenanceOptions_GetWhen(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &MaintenanceOptions{When: &zeroValue}
	m.GetWhen()
	m = &MaintenanceOptions{}
	m.GetWhen()
	m = nil
	m.GetWhen()
}

func TestMaintenanceStatus_GetCanUnsetMaintenance(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	m := &MaintenanceStatus{CanUnsetMaintenance: &zeroValue}
	m.GetCanUnsetMaintenance()
	m = &MaintenanceStatus{}
	m.GetCanUnsetMaintenance()
	m = nil
	m.GetCanUnsetMaintenance()
}

func TestMaintenanceStatus_GetConnectionServices(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*ConnectionServiceItem{}
	m := &MaintenanceStatus{ConnectionServices: zeroValue}
	m.GetConnectionServices()
	m = &MaintenanceStatus{}
	m.GetConnectionServices()
	m = nil
	m.GetConnectionServices()
}

func TestMaintenanceStatus_GetHostname(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &MaintenanceStatus{Hostname: &zeroValue}
	m.GetHostname()
	m = &MaintenanceStatus{}
	m.GetHostname()
	m = nil
	m.GetHostname()
}

func TestMaintenanceStatus_GetIPExceptionList(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	m := &MaintenanceStatus{IPExceptionList: zeroValue}
	m.GetIPExceptionList()
	m = &MaintenanceStatus{}
	m.GetIPExceptionList()
	m = nil
	m.GetIPExceptionList()
}

func TestMaintenanceStatus_GetMaintenanceModeMessage(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &MaintenanceStatus{MaintenanceModeMessage: &zeroValue}
	m.GetMaintenanceModeMessage()
	m = &MaintenanceStatus{}
	m.GetMaintenanceModeMessage()
	m = nil
	m.GetMaintenanceModeMessage()
}

func TestMaintenanceStatus_GetScheduledTime(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	m := &MaintenanceStatus{ScheduledTime: &zeroValue}
	m.GetScheduledTime()
	m = &MaintenanceStatus{}
	m.GetScheduledTime()
	m = nil
	m.GetScheduledTime()
}

func TestMaintenanceStatus_GetStatus(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &MaintenanceStatus{Status: &zeroValue}
	m.GetStatus()
	m = &MaintenanceStatus{}
	m.GetStatus()
	m = nil
	m.GetStatus()
}

func TestMaintenanceStatus_GetUUID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &MaintenanceStatus{UUID: &zeroValue}
	m.GetUUID()
	m = &MaintenanceStatus{}
	m.GetUUID()
	m = nil
	m.GetUUID()
}

func TestMarkdownOptions_GetContext(tt *testing.T) {
	tt.Parallel()
	m := &MarkdownOptions{}
	m.GetContext()
	m = nil
	m.GetContext()
}

func TestMarkdownOptions_GetMode(tt *testing.T) {
	tt.Parallel()
	m := &MarkdownOptions{}
	m.GetMode()
	m = nil
	m.GetMode()
}

func TestMarketplacePendingChange_GetEffectiveDate(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	m := &MarketplacePendingChange{EffectiveDate: &zeroValue}
	m.GetEffectiveDate()
	m = &MarketplacePendingChange{}
	m.GetEffectiveDate()
	m = nil
	m.GetEffectiveDate()
}

func TestMarketplacePendingChange_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	m := &MarketplacePendingChange{ID: &zeroValue}
	m.GetID()
	m = &MarketplacePendingChange{}
	m.GetID()
	m = nil
	m.GetID()
}

func TestMarketplacePendingChange_GetPlan(tt *testing.T) {
	tt.Parallel()
	m := &MarketplacePendingChange{}
	m.GetPlan()
	m = nil
	m.GetPlan()
}

func TestMarketplacePendingChange_GetUnitCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	m := &MarketplacePendingChange{UnitCount: &zeroValue}
	m.GetUnitCount()
	m = &MarketplacePendingChange{}
	m.GetUnitCount()
	m = nil
	m.GetUnitCount()
}

func TestMarketplacePlan_GetAccountsURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &MarketplacePlan{AccountsURL: &zeroValue}
	m.GetAccountsURL()
	m = &MarketplacePlan{}
	m.GetAccountsURL()
	m = nil
	m.GetAccountsURL()
}

func TestMarketplacePlan_GetBullets(tt *testing.T) {
	tt.Parallel()
	var zeroValue []string
	m := &MarketplacePlan{Bullets: &zeroValue}
	m.GetBullets()
	m = &MarketplacePlan{}
	m.GetBullets()
	m = nil
	m.GetBullets()
}

func TestMarketplacePlan_GetDescription(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &MarketplacePlan{Description: &zeroValue}
	m.GetDescription()
	m = &MarketplacePlan{}
	m.GetDescription()
	m = nil
	m.GetDescription()
}

func TestMarketplacePlan_GetHasFreeTrial(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	m := &MarketplacePlan{HasFreeTrial: &zeroValue}
	m.GetHasFreeTrial()
	m = &MarketplacePlan{}
	m.GetHasFreeTrial()
	m = nil
	m.GetHasFreeTrial()
}

func TestMarketplacePlan_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	m := &MarketplacePlan{ID: &zeroValue}
	m.GetID()
	m = &MarketplacePlan{}
	m.GetID()
	m = nil
	m.GetID()
}

func TestMarketplacePlan_GetMonthlyPriceInCents(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	m := &MarketplacePlan{MonthlyPriceInCents: &zeroValue}
	m.GetMonthlyPriceInCents()
	m = &MarketplacePlan{}
	m.GetMonthlyPriceInCents()
	m = nil
	m.GetMonthlyPriceInCents()
}

func TestMarketplacePlan_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &MarketplacePlan{Name: &zeroValue}
	m.GetName()
	m = &MarketplacePlan{}
	m.GetName()
	m = nil
	m.GetName()
}

func TestMarketplacePlan_GetNumber(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	m := &MarketplacePlan{Number: &zeroValue}
	m.GetNumber()
	m = &MarketplacePlan{}
	m.GetNumber()
	m = nil
	m.GetNumber()
}

func TestMarketplacePlan_GetPriceModel(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &MarketplacePlan{PriceModel: &zeroValue}
	m.GetPriceModel()
	m = &MarketplacePlan{}
	m.GetPriceModel()
	m = nil
	m.GetPriceModel()
}

func TestMarketplacePlan_GetState(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &MarketplacePlan{State: &zeroValue}
	m.GetState()
	m = &MarketplacePlan{}
	m.GetState()
	m = nil
	m.GetState()
}

func TestMarketplacePlan_GetUnitName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &MarketplacePlan{UnitName: &zeroValue}
	m.GetUnitName()
	m = &MarketplacePlan{}
	m.GetUnitName()
	m = nil
	m.GetUnitName()
}

func TestMarketplacePlan_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &MarketplacePlan{URL: &zeroValue}
	m.GetURL()
	m = &MarketplacePlan{}
	m.GetURL()
	m = nil
	m.GetURL()
}

func TestMarketplacePlan_GetYearlyPriceInCents(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	m := &MarketplacePlan{YearlyPriceInCents: &zeroValue}
	m.GetYearlyPriceInCents()
	m = &MarketplacePlan{}
	m.GetYearlyPriceInCents()
	m = nil
	m.GetYearlyPriceInCents()
}

func TestMarketplacePlanAccount_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	m := &MarketplacePlanAccount{ID: &zeroValue}
	m.GetID()
	m = &MarketplacePlanAccount{}
	m.GetID()
	m = nil
	m.GetID()
}

func TestMarketplacePlanAccount_GetLogin(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &MarketplacePlanAccount{Login: &zeroValue}
	m.GetLogin()
	m = &MarketplacePlanAccount{}
	m.GetLogin()
	m = nil
	m.GetLogin()
}

func TestMarketplacePlanAccount_GetMarketplacePendingChange(tt *testing.T) {
	tt.Parallel()
	m := &MarketplacePlanAccount{}
	m.GetMarketplacePendingChange()
	m = nil
	m.GetMarketplacePendingChange()
}

func TestMarketplacePlanAccount_GetMarketplacePurchase(tt *testing.T) {
	tt.Parallel()
	m := &MarketplacePlanAccount{}
	m.GetMarketplacePurchase()
	m = nil
	m.GetMarketplacePurchase()
}

func TestMarketplacePlanAccount_GetOrganizationBillingEmail(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &MarketplacePlanAccount{OrganizationBillingEmail: &zeroValue}
	m.GetOrganizationBillingEmail()
	m = &MarketplacePlanAccount{}
	m.GetOrganizationBillingEmail()
	m = nil
	m.GetOrganizationBillingEmail()
}

func TestMarketplacePlanAccount_GetType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &MarketplacePlanAccount{Type: &zeroValue}
	m.GetType()
	m = &MarketplacePlanAccount{}
	m.GetType()
	m = nil
	m.GetType()
}

func TestMarketplacePlanAccount_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &MarketplacePlanAccount{URL: &zeroValue}
	m.GetURL()
	m = &MarketplacePlanAccount{}
	m.GetURL()
	m = nil
	m.GetURL()
}

func TestMarketplacePurchase_GetAccount(tt *testing.T) {
	tt.Parallel()
	m := &MarketplacePurchase{}
	m.GetAccount()
	m = nil
	m.GetAccount()
}

func TestMarketplacePurchase_GetBillingCycle(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &MarketplacePurchase{BillingCycle: &zeroValue}
	m.GetBillingCycle()
	m = &MarketplacePurchase{}
	m.GetBillingCycle()
	m = nil
	m.GetBillingCycle()
}

func TestMarketplacePurchase_GetFreeTrialEndsOn(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	m := &MarketplacePurchase{FreeTrialEndsOn: &zeroValue}
	m.GetFreeTrialEndsOn()
	m = &MarketplacePurchase{}
	m.GetFreeTrialEndsOn()
	m = nil
	m.GetFreeTrialEndsOn()
}

func TestMarketplacePurchase_GetNextBillingDate(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	m := &MarketplacePurchase{NextBillingDate: &zeroValue}
	m.GetNextBillingDate()
	m = &MarketplacePurchase{}
	m.GetNextBillingDate()
	m = nil
	m.GetNextBillingDate()
}

func TestMarketplacePurchase_GetOnFreeTrial(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	m := &MarketplacePurchase{OnFreeTrial: &zeroValue}
	m.GetOnFreeTrial()
	m = &MarketplacePurchase{}
	m.GetOnFreeTrial()
	m = nil
	m.GetOnFreeTrial()
}

func TestMarketplacePurchase_GetPlan(tt *testing.T) {
	tt.Parallel()
	m := &MarketplacePurchase{}
	m.GetPlan()
	m = nil
	m.GetPlan()
}

func TestMarketplacePurchase_GetUnitCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	m := &MarketplacePurchase{UnitCount: &zeroValue}
	m.GetUnitCount()
	m = &MarketplacePurchase{}
	m.GetUnitCount()
	m = nil
	m.GetUnitCount()
}

func TestMarketplacePurchase_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	m := &MarketplacePurchase{UpdatedAt: &zeroValue}
	m.GetUpdatedAt()
	m = &MarketplacePurchase{}
	m.GetUpdatedAt()
	m = nil
	m.GetUpdatedAt()
}

func TestMarketplacePurchaseAccount_GetEmail(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &MarketplacePurchaseAccount{Email: &zeroValue}
	m.GetEmail()
	m = &MarketplacePurchaseAccount{}
	m.GetEmail()
	m = nil
	m.GetEmail()
}

func TestMarketplacePurchaseAccount_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	m := &MarketplacePurchaseAccount{ID: &zeroValue}
	m.GetID()
	m = &MarketplacePurchaseAccount{}
	m.GetID()
	m = nil
	m.GetID()
}

func TestMarketplacePurchaseAccount_GetLogin(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &MarketplacePurchaseAccount{Login: &zeroValue}
	m.GetLogin()
	m = &MarketplacePurchaseAccount{}
	m.GetLogin()
	m = nil
	m.GetLogin()
}

func TestMarketplacePurchaseAccount_GetNodeID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &MarketplacePurchaseAccount{NodeID: &zeroValue}
	m.GetNodeID()
	m = &MarketplacePurchaseAccount{}
	m.GetNodeID()
	m = nil
	m.GetNodeID()
}

func TestMarketplacePurchaseAccount_GetOrganizationBillingEmail(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &MarketplacePurchaseAccount{OrganizationBillingEmail: &zeroValue}
	m.GetOrganizationBillingEmail()
	m = &MarketplacePurchaseAccount{}
	m.GetOrganizationBillingEmail()
	m = nil
	m.GetOrganizationBillingEmail()
}

func TestMarketplacePurchaseAccount_GetType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &MarketplacePurchaseAccount{Type: &zeroValue}
	m.GetType()
	m = &MarketplacePurchaseAccount{}
	m.GetType()
	m = nil
	m.GetType()
}

func TestMarketplacePurchaseAccount_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &MarketplacePurchaseAccount{URL: &zeroValue}
	m.GetURL()
	m = &MarketplacePurchaseAccount{}
	m.GetURL()
	m = nil
	m.GetURL()
}

func TestMarketplacePurchaseEvent_GetAction(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &MarketplacePurchaseEvent{Action: &zeroValue}
	m.GetAction()
	m = &MarketplacePurchaseEvent{}
	m.GetAction()
	m = nil
	m.GetAction()
}

func TestMarketplacePurchaseEvent_GetEffectiveDate(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	m := &MarketplacePurchaseEvent{EffectiveDate: &zeroValue}
	m.GetEffectiveDate()
	m = &MarketplacePurchaseEvent{}
	m.GetEffectiveDate()
	m = nil
	m.GetEffectiveDate()
}

func TestMarketplacePurchaseEvent_GetInstallation(tt *testing.T) {
	tt.Parallel()
	m := &MarketplacePurchaseEvent{}
	m.GetInstallation()
	m = nil
	m.GetInstallation()
}

func TestMarketplacePurchaseEvent_GetMarketplacePurchase(tt *testing.T) {
	tt.Parallel()
	m := &MarketplacePurchaseEvent{}
	m.GetMarketplacePurchase()
	m = nil
	m.GetMarketplacePurchase()
}

func TestMarketplacePurchaseEvent_GetOrg(tt *testing.T) {
	tt.Parallel()
	m := &MarketplacePurchaseEvent{}
	m.GetOrg()
	m = nil
	m.GetOrg()
}

func TestMarketplacePurchaseEvent_GetPreviousMarketplacePurchase(tt *testing.T) {
	tt.Parallel()
	m := &MarketplacePurchaseEvent{}
	m.GetPreviousMarketplacePurchase()
	m = nil
	m.GetPreviousMarketplacePurchase()
}

func TestMarketplacePurchaseEvent_GetSender(tt *testing.T) {
	tt.Parallel()
	m := &MarketplacePurchaseEvent{}
	m.GetSender()
	m = nil
	m.GetSender()
}

func TestMatch_GetIndices(tt *testing.T) {
	tt.Parallel()
	zeroValue := []int{}
	m := &Match{Indices: zeroValue}
	m.GetIndices()
	m = &Match{}
	m.GetIndices()
	m = nil
	m.GetIndices()
}

func TestMatch_GetText(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &Match{Text: &zeroValue}
	m.GetText()
	m = &Match{}
	m.GetText()
	m = nil
	m.GetText()
}

func TestMaxFilePathLengthBranchRule_GetParameters(tt *testing.T) {
	tt.Parallel()
	m := &MaxFilePathLengthBranchRule{}
	m.GetParameters()
	m = nil
	m.GetParameters()
}

func TestMaxFilePathLengthRuleParameters_GetMaxFilePathLength(tt *testing.T) {
	tt.Parallel()
	m := &MaxFilePathLengthRuleParameters{}
	m.GetMaxFilePathLength()
	m = nil
	m.GetMaxFilePathLength()
}

func TestMaxFileSizeBranchRule_GetParameters(tt *testing.T) {
	tt.Parallel()
	m := &MaxFileSizeBranchRule{}
	m.GetParameters()
	m = nil
	m.GetParameters()
}

func TestMaxFileSizeRuleParameters_GetMaxFileSize(tt *testing.T) {
	tt.Parallel()
	m := &MaxFileSizeRuleParameters{}
	m.GetMaxFileSize()
	m = nil
	m.GetMaxFileSize()
}

func TestMemberChanges_GetPermission(tt *testing.T) {
	tt.Parallel()
	m := &MemberChanges{}
	m.GetPermission()
	m = nil
	m.GetPermission()
}

func TestMemberChanges_GetRoleName(tt *testing.T) {
	tt.Parallel()
	m := &MemberChanges{}
	m.GetRoleName()
	m = nil
	m.GetRoleName()
}

func TestMemberChangesPermission_GetFrom(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &MemberChangesPermission{From: &zeroValue}
	m.GetFrom()
	m = &MemberChangesPermission{}
	m.GetFrom()
	m = nil
	m.GetFrom()
}

func TestMemberChangesPermission_GetTo(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &MemberChangesPermission{To: &zeroValue}
	m.GetTo()
	m = &MemberChangesPermission{}
	m.GetTo()
	m = nil
	m.GetTo()
}

func TestMemberChangesRoleName_GetFrom(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &MemberChangesRoleName{From: &zeroValue}
	m.GetFrom()
	m = &MemberChangesRoleName{}
	m.GetFrom()
	m = nil
	m.GetFrom()
}

func TestMemberChangesRoleName_GetTo(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &MemberChangesRoleName{To: &zeroValue}
	m.GetTo()
	m = &MemberChangesRoleName{}
	m.GetTo()
	m = nil
	m.GetTo()
}

func TestMemberEvent_GetAction(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &MemberEvent{Action: &zeroValue}
	m.GetAction()
	m = &MemberEvent{}
	m.GetAction()
	m = nil
	m.GetAction()
}

func TestMemberEvent_GetChanges(tt *testing.T) {
	tt.Parallel()
	m := &MemberEvent{}
	m.GetChanges()
	m = nil
	m.GetChanges()
}

func TestMemberEvent_GetInstallation(tt *testing.T) {
	tt.Parallel()
	m := &MemberEvent{}
	m.GetInstallation()
	m = nil
	m.GetInstallation()
}

func TestMemberEvent_GetMember(tt *testing.T) {
	tt.Parallel()
	m := &MemberEvent{}
	m.GetMember()
	m = nil
	m.GetMember()
}

func TestMemberEvent_GetOrg(tt *testing.T) {
	tt.Parallel()
	m := &MemberEvent{}
	m.GetOrg()
	m = nil
	m.GetOrg()
}

func TestMemberEvent_GetRepo(tt *testing.T) {
	tt.Parallel()
	m := &MemberEvent{}
	m.GetRepo()
	m = nil
	m.GetRepo()
}

func TestMemberEvent_GetSender(tt *testing.T) {
	tt.Parallel()
	m := &MemberEvent{}
	m.GetSender()
	m = nil
	m.GetSender()
}

func TestMembership_GetOrganization(tt *testing.T) {
	tt.Parallel()
	m := &Membership{}
	m.GetOrganization()
	m = nil
	m.GetOrganization()
}

func TestMembership_GetOrganizationURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &Membership{OrganizationURL: &zeroValue}
	m.GetOrganizationURL()
	m = &Membership{}
	m.GetOrganizationURL()
	m = nil
	m.GetOrganizationURL()
}

func TestMembership_GetRole(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &Membership{Role: &zeroValue}
	m.GetRole()
	m = &Membership{}
	m.GetRole()
	m = nil
	m.GetRole()
}

func TestMembership_GetState(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &Membership{State: &zeroValue}
	m.GetState()
	m = &Membership{}
	m.GetState()
	m = nil
	m.GetState()
}

func TestMembership_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &Membership{URL: &zeroValue}
	m.GetURL()
	m = &Membership{}
	m.GetURL()
	m = nil
	m.GetURL()
}

func TestMembership_GetUser(tt *testing.T) {
	tt.Parallel()
	m := &Membership{}
	m.GetUser()
	m = nil
	m.GetUser()
}

func TestMembershipEvent_GetAction(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &MembershipEvent{Action: &zeroValue}
	m.GetAction()
	m = &MembershipEvent{}
	m.GetAction()
	m = nil
	m.GetAction()
}

func TestMembershipEvent_GetInstallation(tt *testing.T) {
	tt.Parallel()
	m := &MembershipEvent{}
	m.GetInstallation()
	m = nil
	m.GetInstallation()
}

func TestMembershipEvent_GetMember(tt *testing.T) {
	tt.Parallel()
	m := &MembershipEvent{}
	m.GetMember()
	m = nil
	m.GetMember()
}

func TestMembershipEvent_GetOrg(tt *testing.T) {
	tt.Parallel()
	m := &MembershipEvent{}
	m.GetOrg()
	m = nil
	m.GetOrg()
}

func TestMembershipEvent_GetScope(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &MembershipEvent{Scope: &zeroValue}
	m.GetScope()
	m = &MembershipEvent{}
	m.GetScope()
	m = nil
	m.GetScope()
}

func TestMembershipEvent_GetSender(tt *testing.T) {
	tt.Parallel()
	m := &MembershipEvent{}
	m.GetSender()
	m = nil
	m.GetSender()
}

func TestMembershipEvent_GetTeam(tt *testing.T) {
	tt.Parallel()
	m := &MembershipEvent{}
	m.GetTeam()
	m = nil
	m.GetTeam()
}

func TestMergeGroup_GetBaseRef(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &MergeGroup{BaseRef: &zeroValue}
	m.GetBaseRef()
	m = &MergeGroup{}
	m.GetBaseRef()
	m = nil
	m.GetBaseRef()
}

func TestMergeGroup_GetBaseSHA(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &MergeGroup{BaseSHA: &zeroValue}
	m.GetBaseSHA()
	m = &MergeGroup{}
	m.GetBaseSHA()
	m = nil
	m.GetBaseSHA()
}

func TestMergeGroup_GetHeadCommit(tt *testing.T) {
	tt.Parallel()
	m := &MergeGroup{}
	m.GetHeadCommit()
	m = nil
	m.GetHeadCommit()
}

func TestMergeGroup_GetHeadRef(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &MergeGroup{HeadRef: &zeroValue}
	m.GetHeadRef()
	m = &MergeGroup{}
	m.GetHeadRef()
	m = nil
	m.GetHeadRef()
}

func TestMergeGroup_GetHeadSHA(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &MergeGroup{HeadSHA: &zeroValue}
	m.GetHeadSHA()
	m = &MergeGroup{}
	m.GetHeadSHA()
	m = nil
	m.GetHeadSHA()
}

func TestMergeGroupEvent_GetAction(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &MergeGroupEvent{Action: &zeroValue}
	m.GetAction()
	m = &MergeGroupEvent{}
	m.GetAction()
	m = nil
	m.GetAction()
}

func TestMergeGroupEvent_GetInstallation(tt *testing.T) {
	tt.Parallel()
	m := &MergeGroupEvent{}
	m.GetInstallation()
	m = nil
	m.GetInstallation()
}

func TestMergeGroupEvent_GetMergeGroup(tt *testing.T) {
	tt.Parallel()
	m := &MergeGroupEvent{}
	m.GetMergeGroup()
	m = nil
	m.GetMergeGroup()
}

func TestMergeGroupEvent_GetOrg(tt *testing.T) {
	tt.Parallel()
	m := &MergeGroupEvent{}
	m.GetOrg()
	m = nil
	m.GetOrg()
}

func TestMergeGroupEvent_GetReason(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &MergeGroupEvent{Reason: &zeroValue}
	m.GetReason()
	m = &MergeGroupEvent{}
	m.GetReason()
	m = nil
	m.GetReason()
}

func TestMergeGroupEvent_GetRepo(tt *testing.T) {
	tt.Parallel()
	m := &MergeGroupEvent{}
	m.GetRepo()
	m = nil
	m.GetRepo()
}

func TestMergeGroupEvent_GetSender(tt *testing.T) {
	tt.Parallel()
	m := &MergeGroupEvent{}
	m.GetSender()
	m = nil
	m.GetSender()
}

func TestMergeQueueBranchRule_GetParameters(tt *testing.T) {
	tt.Parallel()
	m := &MergeQueueBranchRule{}
	m.GetParameters()
	m = nil
	m.GetParameters()
}

func TestMergeQueueRuleParameters_GetCheckResponseTimeoutMinutes(tt *testing.T) {
	tt.Parallel()
	m := &MergeQueueRuleParameters{}
	m.GetCheckResponseTimeoutMinutes()
	m = nil
	m.GetCheckResponseTimeoutMinutes()
}

func TestMergeQueueRuleParameters_GetGroupingStrategy(tt *testing.T) {
	tt.Parallel()
	m := &MergeQueueRuleParameters{}
	m.GetGroupingStrategy()
	m = nil
	m.GetGroupingStrategy()
}

func TestMergeQueueRuleParameters_GetMaxEntriesToBuild(tt *testing.T) {
	tt.Parallel()
	m := &MergeQueueRuleParameters{}
	m.GetMaxEntriesToBuild()
	m = nil
	m.GetMaxEntriesToBuild()
}

func TestMergeQueueRuleParameters_GetMaxEntriesToMerge(tt *testing.T) {
	tt.Parallel()
	m := &MergeQueueRuleParameters{}
	m.GetMaxEntriesToMerge()
	m = nil
	m.GetMaxEntriesToMerge()
}

func TestMergeQueueRuleParameters_GetMergeMethod(tt *testing.T) {
	tt.Parallel()
	m := &MergeQueueRuleParameters{}
	m.GetMergeMethod()
	m = nil
	m.GetMergeMethod()
}

func TestMergeQueueRuleParameters_GetMinEntriesToMerge(tt *testing.T) {
	tt.Parallel()
	m := &MergeQueueRuleParameters{}
	m.GetMinEntriesToMerge()
	m = nil
	m.GetMinEntriesToMerge()
}

func TestMergeQueueRuleParameters_GetMinEntriesToMergeWaitMinutes(tt *testing.T) {
	tt.Parallel()
	m := &MergeQueueRuleParameters{}
	m.GetMinEntriesToMergeWaitMinutes()
	m = nil
	m.GetMinEntriesToMergeWaitMinutes()
}

func TestMessage_GetText(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &Message{Text: &zeroValue}
	m.GetText()
	m = &Message{}
	m.GetText()
	m = nil
	m.GetText()
}

func TestMetaEvent_GetAction(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &MetaEvent{Action: &zeroValue}
	m.GetAction()
	m = &MetaEvent{}
	m.GetAction()
	m = nil
	m.GetAction()
}

func TestMetaEvent_GetHook(tt *testing.T) {
	tt.Parallel()
	m := &MetaEvent{}
	m.GetHook()
	m = nil
	m.GetHook()
}

func TestMetaEvent_GetHookID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	m := &MetaEvent{HookID: &zeroValue}
	m.GetHookID()
	m = &MetaEvent{}
	m.GetHookID()
	m = nil
	m.GetHookID()
}

func TestMetaEvent_GetInstallation(tt *testing.T) {
	tt.Parallel()
	m := &MetaEvent{}
	m.GetInstallation()
	m = nil
	m.GetInstallation()
}

func TestMetaEvent_GetOrg(tt *testing.T) {
	tt.Parallel()
	m := &MetaEvent{}
	m.GetOrg()
	m = nil
	m.GetOrg()
}

func TestMetaEvent_GetRepo(tt *testing.T) {
	tt.Parallel()
	m := &MetaEvent{}
	m.GetRepo()
	m = nil
	m.GetRepo()
}

func TestMetaEvent_GetSender(tt *testing.T) {
	tt.Parallel()
	m := &MetaEvent{}
	m.GetSender()
	m = nil
	m.GetSender()
}

func TestMetric_GetHTMLURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &Metric{HTMLURL: &zeroValue}
	m.GetHTMLURL()
	m = &Metric{}
	m.GetHTMLURL()
	m = nil
	m.GetHTMLURL()
}

func TestMetric_GetKey(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &Metric{Key: &zeroValue}
	m.GetKey()
	m = &Metric{}
	m.GetKey()
	m = nil
	m.GetKey()
}

func TestMetric_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &Metric{Name: &zeroValue}
	m.GetName()
	m = &Metric{}
	m.GetName()
	m = nil
	m.GetName()
}

func TestMetric_GetNodeID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &Metric{NodeID: &zeroValue}
	m.GetNodeID()
	m = &Metric{}
	m.GetNodeID()
	m = nil
	m.GetNodeID()
}

func TestMetric_GetSPDXID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &Metric{SPDXID: &zeroValue}
	m.GetSPDXID()
	m = &Metric{}
	m.GetSPDXID()
	m = nil
	m.GetSPDXID()
}

func TestMetric_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &Metric{URL: &zeroValue}
	m.GetURL()
	m = &Metric{}
	m.GetURL()
	m = nil
	m.GetURL()
}

func TestMigration_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &Migration{CreatedAt: &zeroValue}
	m.GetCreatedAt()
	m = &Migration{}
	m.GetCreatedAt()
	m = nil
	m.GetCreatedAt()
}

func TestMigration_GetExcludeAttachments(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	m := &Migration{ExcludeAttachments: &zeroValue}
	m.GetExcludeAttachments()
	m = &Migration{}
	m.GetExcludeAttachments()
	m = nil
	m.GetExcludeAttachments()
}

func TestMigration_GetGUID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &Migration{GUID: &zeroValue}
	m.GetGUID()
	m = &Migration{}
	m.GetGUID()
	m = nil
	m.GetGUID()
}

func TestMigration_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	m := &Migration{ID: &zeroValue}
	m.GetID()
	m = &Migration{}
	m.GetID()
	m = nil
	m.GetID()
}

func TestMigration_GetLockRepositories(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	m := &Migration{LockRepositories: &zeroValue}
	m.GetLockRepositories()
	m = &Migration{}
	m.GetLockRepositories()
	m = nil
	m.GetLockRepositories()
}

func TestMigration_GetRepositories(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*Repository{}
	m := &Migration{Repositories: zeroValue}
	m.GetRepositories()
	m = &Migration{}
	m.GetRepositories()
	m = nil
	m.GetRepositories()
}

func TestMigration_GetState(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &Migration{State: &zeroValue}
	m.GetState()
	m = &Migration{}
	m.GetState()
	m = nil
	m.GetState()
}

func TestMigration_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &Migration{UpdatedAt: &zeroValue}
	m.GetUpdatedAt()
	m = &Migration{}
	m.GetUpdatedAt()
	m = nil
	m.GetUpdatedAt()
}

func TestMigration_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &Migration{URL: &zeroValue}
	m.GetURL()
	m = &Migration{}
	m.GetURL()
	m = nil
	m.GetURL()
}

func TestMigrationOptions_GetExclude(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	m := &MigrationOptions{Exclude: zeroValue}
	m.GetExclude()
	m = &MigrationOptions{}
	m.GetExclude()
	m = nil
	m.GetExclude()
}

func TestMigrationOptions_GetExcludeAttachments(tt *testing.T) {
	tt.Parallel()
	m := &MigrationOptions{}
	m.GetExcludeAttachments()
	m = nil
	m.GetExcludeAttachments()
}

func TestMigrationOptions_GetExcludeReleases(tt *testing.T) {
	tt.Parallel()
	m := &MigrationOptions{}
	m.GetExcludeReleases()
	m = nil
	m.GetExcludeReleases()
}

func TestMigrationOptions_GetLockRepositories(tt *testing.T) {
	tt.Parallel()
	m := &MigrationOptions{}
	m.GetLockRepositories()
	m = nil
	m.GetLockRepositories()
}

func TestMilestone_GetClosedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	m := &Milestone{ClosedAt: &zeroValue}
	m.GetClosedAt()
	m = &Milestone{}
	m.GetClosedAt()
	m = nil
	m.GetClosedAt()
}

func TestMilestone_GetClosedIssues(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	m := &Milestone{ClosedIssues: &zeroValue}
	m.GetClosedIssues()
	m = &Milestone{}
	m.GetClosedIssues()
	m = nil
	m.GetClosedIssues()
}

func TestMilestone_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	m := &Milestone{CreatedAt: &zeroValue}
	m.GetCreatedAt()
	m = &Milestone{}
	m.GetCreatedAt()
	m = nil
	m.GetCreatedAt()
}

func TestMilestone_GetCreator(tt *testing.T) {
	tt.Parallel()
	m := &Milestone{}
	m.GetCreator()
	m = nil
	m.GetCreator()
}

func TestMilestone_GetDescription(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &Milestone{Description: &zeroValue}
	m.GetDescription()
	m = &Milestone{}
	m.GetDescription()
	m = nil
	m.GetDescription()
}

func TestMilestone_GetDueOn(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	m := &Milestone{DueOn: &zeroValue}
	m.GetDueOn()
	m = &Milestone{}
	m.GetDueOn()
	m = nil
	m.GetDueOn()
}

func TestMilestone_GetHTMLURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &Milestone{HTMLURL: &zeroValue}
	m.GetHTMLURL()
	m = &Milestone{}
	m.GetHTMLURL()
	m = nil
	m.GetHTMLURL()
}

func TestMilestone_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	m := &Milestone{ID: &zeroValue}
	m.GetID()
	m = &Milestone{}
	m.GetID()
	m = nil
	m.GetID()
}

func TestMilestone_GetLabelsURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &Milestone{LabelsURL: &zeroValue}
	m.GetLabelsURL()
	m = &Milestone{}
	m.GetLabelsURL()
	m = nil
	m.GetLabelsURL()
}

func TestMilestone_GetNodeID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &Milestone{NodeID: &zeroValue}
	m.GetNodeID()
	m = &Milestone{}
	m.GetNodeID()
	m = nil
	m.GetNodeID()
}

func TestMilestone_GetNumber(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	m := &Milestone{Number: &zeroValue}
	m.GetNumber()
	m = &Milestone{}
	m.GetNumber()
	m = nil
	m.GetNumber()
}

func TestMilestone_GetOpenIssues(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	m := &Milestone{OpenIssues: &zeroValue}
	m.GetOpenIssues()
	m = &Milestone{}
	m.GetOpenIssues()
	m = nil
	m.GetOpenIssues()
}

func TestMilestone_GetState(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &Milestone{State: &zeroValue}
	m.GetState()
	m = &Milestone{}
	m.GetState()
	m = nil
	m.GetState()
}

func TestMilestone_GetTitle(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &Milestone{Title: &zeroValue}
	m.GetTitle()
	m = &Milestone{}
	m.GetTitle()
	m = nil
	m.GetTitle()
}

func TestMilestone_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	m := &Milestone{UpdatedAt: &zeroValue}
	m.GetUpdatedAt()
	m = &Milestone{}
	m.GetUpdatedAt()
	m = nil
	m.GetUpdatedAt()
}

func TestMilestone_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &Milestone{URL: &zeroValue}
	m.GetURL()
	m = &Milestone{}
	m.GetURL()
	m = nil
	m.GetURL()
}

func TestMilestoneEvent_GetAction(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &MilestoneEvent{Action: &zeroValue}
	m.GetAction()
	m = &MilestoneEvent{}
	m.GetAction()
	m = nil
	m.GetAction()
}

func TestMilestoneEvent_GetChanges(tt *testing.T) {
	tt.Parallel()
	m := &MilestoneEvent{}
	m.GetChanges()
	m = nil
	m.GetChanges()
}

func TestMilestoneEvent_GetInstallation(tt *testing.T) {
	tt.Parallel()
	m := &MilestoneEvent{}
	m.GetInstallation()
	m = nil
	m.GetInstallation()
}

func TestMilestoneEvent_GetMilestone(tt *testing.T) {
	tt.Parallel()
	m := &MilestoneEvent{}
	m.GetMilestone()
	m = nil
	m.GetMilestone()
}

func TestMilestoneEvent_GetOrg(tt *testing.T) {
	tt.Parallel()
	m := &MilestoneEvent{}
	m.GetOrg()
	m = nil
	m.GetOrg()
}

func TestMilestoneEvent_GetRepo(tt *testing.T) {
	tt.Parallel()
	m := &MilestoneEvent{}
	m.GetRepo()
	m = nil
	m.GetRepo()
}

func TestMilestoneEvent_GetSender(tt *testing.T) {
	tt.Parallel()
	m := &MilestoneEvent{}
	m.GetSender()
	m = nil
	m.GetSender()
}

func TestMilestoneListOptions_GetDirection(tt *testing.T) {
	tt.Parallel()
	m := &MilestoneListOptions{}
	m.GetDirection()
	m = nil
	m.GetDirection()
}

func TestMilestoneListOptions_GetSort(tt *testing.T) {
	tt.Parallel()
	m := &MilestoneListOptions{}
	m.GetSort()
	m = nil
	m.GetSort()
}

func TestMilestoneListOptions_GetState(tt *testing.T) {
	tt.Parallel()
	m := &MilestoneListOptions{}
	m.GetState()
	m = nil
	m.GetState()
}

func TestMilestoneStats_GetClosedMilestones(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	m := &MilestoneStats{ClosedMilestones: &zeroValue}
	m.GetClosedMilestones()
	m = &MilestoneStats{}
	m.GetClosedMilestones()
	m = nil
	m.GetClosedMilestones()
}

func TestMilestoneStats_GetOpenMilestones(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	m := &MilestoneStats{OpenMilestones: &zeroValue}
	m.GetOpenMilestones()
	m = &MilestoneStats{}
	m.GetOpenMilestones()
	m = nil
	m.GetOpenMilestones()
}

func TestMilestoneStats_GetTotalMilestones(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	m := &MilestoneStats{TotalMilestones: &zeroValue}
	m.GetTotalMilestones()
	m = &MilestoneStats{}
	m.GetTotalMilestones()
	m = nil
	m.GetTotalMilestones()
}

func TestMostRecentInstance_GetAnalysisKey(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &MostRecentInstance{AnalysisKey: &zeroValue}
	m.GetAnalysisKey()
	m = &MostRecentInstance{}
	m.GetAnalysisKey()
	m = nil
	m.GetAnalysisKey()
}

func TestMostRecentInstance_GetCategory(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &MostRecentInstance{Category: &zeroValue}
	m.GetCategory()
	m = &MostRecentInstance{}
	m.GetCategory()
	m = nil
	m.GetCategory()
}

func TestMostRecentInstance_GetClassifications(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	m := &MostRecentInstance{Classifications: zeroValue}
	m.GetClassifications()
	m = &MostRecentInstance{}
	m.GetClassifications()
	m = nil
	m.GetClassifications()
}

func TestMostRecentInstance_GetCommitSHA(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &MostRecentInstance{CommitSHA: &zeroValue}
	m.GetCommitSHA()
	m = &MostRecentInstance{}
	m.GetCommitSHA()
	m = nil
	m.GetCommitSHA()
}

func TestMostRecentInstance_GetEnvironment(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &MostRecentInstance{Environment: &zeroValue}
	m.GetEnvironment()
	m = &MostRecentInstance{}
	m.GetEnvironment()
	m = nil
	m.GetEnvironment()
}

func TestMostRecentInstance_GetHTMLURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &MostRecentInstance{HTMLURL: &zeroValue}
	m.GetHTMLURL()
	m = &MostRecentInstance{}
	m.GetHTMLURL()
	m = nil
	m.GetHTMLURL()
}

func TestMostRecentInstance_GetLocation(tt *testing.T) {
	tt.Parallel()
	m := &MostRecentInstance{}
	m.GetLocation()
	m = nil
	m.GetLocation()
}

func TestMostRecentInstance_GetMessage(tt *testing.T) {
	tt.Parallel()
	m := &MostRecentInstance{}
	m.GetMessage()
	m = nil
	m.GetMessage()
}

func TestMostRecentInstance_GetRef(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &MostRecentInstance{Ref: &zeroValue}
	m.GetRef()
	m = &MostRecentInstance{}
	m.GetRef()
	m = nil
	m.GetRef()
}

func TestMostRecentInstance_GetState(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	m := &MostRecentInstance{State: &zeroValue}
	m.GetState()
	m = &MostRecentInstance{}
	m.GetState()
	m = nil
	m.GetState()
}

func TestNetworkConfiguration_GetComputeService(tt *testing.T) {
	tt.Parallel()
	n := &NetworkConfiguration{}
	n.GetComputeService()
	n = nil
	n.GetComputeService()
}

func TestNetworkConfiguration_GetCreatedOn(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	n := &NetworkConfiguration{CreatedOn: &zeroValue}
	n.GetCreatedOn()
	n = &NetworkConfiguration{}
	n.GetCreatedOn()
	n = nil
	n.GetCreatedOn()
}

func TestNetworkConfiguration_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	n := &NetworkConfiguration{ID: &zeroValue}
	n.GetID()
	n = &NetworkConfiguration{}
	n.GetID()
	n = nil
	n.GetID()
}

func TestNetworkConfiguration_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	n := &NetworkConfiguration{Name: &zeroValue}
	n.GetName()
	n = &NetworkConfiguration{}
	n.GetName()
	n = nil
	n.GetName()
}

func TestNetworkConfiguration_GetNetworkSettingsIDs(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	n := &NetworkConfiguration{NetworkSettingsIDs: zeroValue}
	n.GetNetworkSettingsIDs()
	n = &NetworkConfiguration{}
	n.GetNetworkSettingsIDs()
	n = nil
	n.GetNetworkSettingsIDs()
}

func TestNetworkConfigurationRequest_GetComputeService(tt *testing.T) {
	tt.Parallel()
	n := &NetworkConfigurationRequest{}
	n.GetComputeService()
	n = nil
	n.GetComputeService()
}

func TestNetworkConfigurationRequest_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	n := &NetworkConfigurationRequest{Name: &zeroValue}
	n.GetName()
	n = &NetworkConfigurationRequest{}
	n.GetName()
	n = nil
	n.GetName()
}

func TestNetworkConfigurationRequest_GetNetworkSettingsIDs(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	n := &NetworkConfigurationRequest{NetworkSettingsIDs: zeroValue}
	n.GetNetworkSettingsIDs()
	n = &NetworkConfigurationRequest{}
	n.GetNetworkSettingsIDs()
	n = nil
	n.GetNetworkSettingsIDs()
}

func TestNetworkConfigurations_GetNetworkConfigurations(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*NetworkConfiguration{}
	n := &NetworkConfigurations{NetworkConfigurations: zeroValue}
	n.GetNetworkConfigurations()
	n = &NetworkConfigurations{}
	n.GetNetworkConfigurations()
	n = nil
	n.GetNetworkConfigurations()
}

func TestNetworkConfigurations_GetTotalCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	n := &NetworkConfigurations{TotalCount: &zeroValue}
	n.GetTotalCount()
	n = &NetworkConfigurations{}
	n.GetTotalCount()
	n = nil
	n.GetTotalCount()
}

func TestNetworkSettingsResource_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	n := &NetworkSettingsResource{ID: &zeroValue}
	n.GetID()
	n = &NetworkSettingsResource{}
	n.GetID()
	n = nil
	n.GetID()
}

func TestNetworkSettingsResource_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	n := &NetworkSettingsResource{Name: &zeroValue}
	n.GetName()
	n = &NetworkSettingsResource{}
	n.GetName()
	n = nil
	n.GetName()
}

func TestNetworkSettingsResource_GetNetworkConfigurationID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	n := &NetworkSettingsResource{NetworkConfigurationID: &zeroValue}
	n.GetNetworkConfigurationID()
	n = &NetworkSettingsResource{}
	n.GetNetworkConfigurationID()
	n = nil
	n.GetNetworkConfigurationID()
}

func TestNetworkSettingsResource_GetRegion(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	n := &NetworkSettingsResource{Region: &zeroValue}
	n.GetRegion()
	n = &NetworkSettingsResource{}
	n.GetRegion()
	n = nil
	n.GetRegion()
}

func TestNetworkSettingsResource_GetSubnetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	n := &NetworkSettingsResource{SubnetID: &zeroValue}
	n.GetSubnetID()
	n = &NetworkSettingsResource{}
	n.GetSubnetID()
	n = nil
	n.GetSubnetID()
}

func TestNewTeam_GetDescription(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	n := &NewTeam{Description: &zeroValue}
	n.GetDescription()
	n = &NewTeam{}
	n.GetDescription()
	n = nil
	n.GetDescription()
}

func TestNewTeam_GetLDAPDN(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	n := &NewTeam{LDAPDN: &zeroValue}
	n.GetLDAPDN()
	n = &NewTeam{}
	n.GetLDAPDN()
	n = nil
	n.GetLDAPDN()
}

func TestNewTeam_GetMaintainers(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	n := &NewTeam{Maintainers: zeroValue}
	n.GetMaintainers()
	n = &NewTeam{}
	n.GetMaintainers()
	n = nil
	n.GetMaintainers()
}

func TestNewTeam_GetName(tt *testing.T) {
	tt.Parallel()
	n := &NewTeam{}
	n.GetName()
	n = nil
	n.GetName()
}

func TestNewTeam_GetNotificationSetting(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	n := &NewTeam{NotificationSetting: &zeroValue}
	n.GetNotificationSetting()
	n = &NewTeam{}
	n.GetNotificationSetting()
	n = nil
	n.GetNotificationSetting()
}

func TestNewTeam_GetParentTeamID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	n := &NewTeam{ParentTeamID: &zeroValue}
	n.GetParentTeamID()
	n = &NewTeam{}
	n.GetParentTeamID()
	n = nil
	n.GetParentTeamID()
}

func TestNewTeam_GetPermission(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	n := &NewTeam{Permission: &zeroValue}
	n.GetPermission()
	n = &NewTeam{}
	n.GetPermission()
	n = nil
	n.GetPermission()
}

func TestNewTeam_GetPrivacy(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	n := &NewTeam{Privacy: &zeroValue}
	n.GetPrivacy()
	n = &NewTeam{}
	n.GetPrivacy()
	n = nil
	n.GetPrivacy()
}

func TestNewTeam_GetRepoNames(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	n := &NewTeam{RepoNames: zeroValue}
	n.GetRepoNames()
	n = &NewTeam{}
	n.GetRepoNames()
	n = nil
	n.GetRepoNames()
}

func TestNodeDetails_GetClusterRoles(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	n := &NodeDetails{ClusterRoles: zeroValue}
	n.GetClusterRoles()
	n = &NodeDetails{}
	n.GetClusterRoles()
	n = nil
	n.GetClusterRoles()
}

func TestNodeDetails_GetHostname(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	n := &NodeDetails{Hostname: &zeroValue}
	n.GetHostname()
	n = &NodeDetails{}
	n.GetHostname()
	n = nil
	n.GetHostname()
}

func TestNodeDetails_GetUUID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	n := &NodeDetails{UUID: &zeroValue}
	n.GetUUID()
	n = &NodeDetails{}
	n.GetUUID()
	n = nil
	n.GetUUID()
}

func TestNodeMetadataStatus_GetNodes(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*NodeDetails{}
	n := &NodeMetadataStatus{Nodes: zeroValue}
	n.GetNodes()
	n = &NodeMetadataStatus{}
	n.GetNodes()
	n = nil
	n.GetNodes()
}

func TestNodeMetadataStatus_GetTopology(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	n := &NodeMetadataStatus{Topology: &zeroValue}
	n.GetTopology()
	n = &NodeMetadataStatus{}
	n.GetTopology()
	n = nil
	n.GetTopology()
}

func TestNodeQueryOptions_GetClusterRoles(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	n := &NodeQueryOptions{ClusterRoles: &zeroValue}
	n.GetClusterRoles()
	n = &NodeQueryOptions{}
	n.GetClusterRoles()
	n = nil
	n.GetClusterRoles()
}

func TestNodeQueryOptions_GetUUID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	n := &NodeQueryOptions{UUID: &zeroValue}
	n.GetUUID()
	n = &NodeQueryOptions{}
	n.GetUUID()
	n = nil
	n.GetUUID()
}

func TestNodeReleaseVersion_GetHostname(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	n := &NodeReleaseVersion{Hostname: &zeroValue}
	n.GetHostname()
	n = &NodeReleaseVersion{}
	n.GetHostname()
	n = nil
	n.GetHostname()
}

func TestNodeReleaseVersion_GetVersion(tt *testing.T) {
	tt.Parallel()
	n := &NodeReleaseVersion{}
	n.GetVersion()
	n = nil
	n.GetVersion()
}

func TestNotification_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	n := &Notification{ID: &zeroValue}
	n.GetID()
	n = &Notification{}
	n.GetID()
	n = nil
	n.GetID()
}

func TestNotification_GetLastReadAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	n := &Notification{LastReadAt: &zeroValue}
	n.GetLastReadAt()
	n = &Notification{}
	n.GetLastReadAt()
	n = nil
	n.GetLastReadAt()
}

func TestNotification_GetReason(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	n := &Notification{Reason: &zeroValue}
	n.GetReason()
	n = &Notification{}
	n.GetReason()
	n = nil
	n.GetReason()
}

func TestNotification_GetRepository(tt *testing.T) {
	tt.Parallel()
	n := &Notification{}
	n.GetRepository()
	n = nil
	n.GetRepository()
}

func TestNotification_GetSubject(tt *testing.T) {
	tt.Parallel()
	n := &Notification{}
	n.GetSubject()
	n = nil
	n.GetSubject()
}

func TestNotification_GetUnread(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	n := &Notification{Unread: &zeroValue}
	n.GetUnread()
	n = &Notification{}
	n.GetUnread()
	n = nil
	n.GetUnread()
}

func TestNotification_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	n := &Notification{UpdatedAt: &zeroValue}
	n.GetUpdatedAt()
	n = &Notification{}
	n.GetUpdatedAt()
	n = nil
	n.GetUpdatedAt()
}

func TestNotification_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	n := &Notification{URL: &zeroValue}
	n.GetURL()
	n = &Notification{}
	n.GetURL()
	n = nil
	n.GetURL()
}

func TestNotificationListOptions_GetAll(tt *testing.T) {
	tt.Parallel()
	n := &NotificationListOptions{}
	n.GetAll()
	n = nil
	n.GetAll()
}

func TestNotificationListOptions_GetBefore(tt *testing.T) {
	tt.Parallel()
	n := &NotificationListOptions{}
	n.GetBefore()
	n = nil
	n.GetBefore()
}

func TestNotificationListOptions_GetParticipating(tt *testing.T) {
	tt.Parallel()
	n := &NotificationListOptions{}
	n.GetParticipating()
	n = nil
	n.GetParticipating()
}

func TestNotificationListOptions_GetSince(tt *testing.T) {
	tt.Parallel()
	n := &NotificationListOptions{}
	n.GetSince()
	n = nil
	n.GetSince()
}

func TestNotificationSubject_GetLatestCommentURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	n := &NotificationSubject{LatestCommentURL: &zeroValue}
	n.GetLatestCommentURL()
	n = &NotificationSubject{}
	n.GetLatestCommentURL()
	n = nil
	n.GetLatestCommentURL()
}

func TestNotificationSubject_GetTitle(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	n := &NotificationSubject{Title: &zeroValue}
	n.GetTitle()
	n = &NotificationSubject{}
	n.GetTitle()
	n = nil
	n.GetTitle()
}

func TestNotificationSubject_GetType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	n := &NotificationSubject{Type: &zeroValue}
	n.GetType()
	n = &NotificationSubject{}
	n.GetType()
	n = nil
	n.GetType()
}

func TestNotificationSubject_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	n := &NotificationSubject{URL: &zeroValue}
	n.GetURL()
	n = &NotificationSubject{}
	n.GetURL()
	n = nil
	n.GetURL()
}

func TestOAuthAPP_GetClientID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	o := &OAuthAPP{ClientID: &zeroValue}
	o.GetClientID()
	o = &OAuthAPP{}
	o.GetClientID()
	o = nil
	o.GetClientID()
}

func TestOAuthAPP_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	o := &OAuthAPP{Name: &zeroValue}
	o.GetName()
	o = &OAuthAPP{}
	o.GetName()
	o = nil
	o.GetName()
}

func TestOAuthAPP_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	o := &OAuthAPP{URL: &zeroValue}
	o.GetURL()
	o = &OAuthAPP{}
	o.GetURL()
	o = nil
	o.GetURL()
}

func TestOIDCCustomPropertyClaim_GetCustomPropertyName(tt *testing.T) {
	tt.Parallel()
	o := &OIDCCustomPropertyClaim{}
	o.GetCustomPropertyName()
	o = nil
	o.GetCustomPropertyName()
}

func TestOIDCCustomPropertyClaimResponse_GetInclusionSource(tt *testing.T) {
	tt.Parallel()
	o := &OIDCCustomPropertyClaimResponse{}
	o.GetInclusionSource()
	o = nil
	o.GetInclusionSource()
}

func TestOIDCSubjectClaimCustomTemplate_GetIncludeClaimKeys(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	o := &OIDCSubjectClaimCustomTemplate{IncludeClaimKeys: zeroValue}
	o.GetIncludeClaimKeys()
	o = &OIDCSubjectClaimCustomTemplate{}
	o.GetIncludeClaimKeys()
	o = nil
	o.GetIncludeClaimKeys()
}

func TestOIDCSubjectClaimCustomTemplate_GetSubClaimPrefix(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	o := &OIDCSubjectClaimCustomTemplate{SubClaimPrefix: &zeroValue}
	o.GetSubClaimPrefix()
	o = &OIDCSubjectClaimCustomTemplate{}
	o.GetSubClaimPrefix()
	o = nil
	o.GetSubClaimPrefix()
}

func TestOIDCSubjectClaimCustomTemplate_GetUseDefault(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	o := &OIDCSubjectClaimCustomTemplate{UseDefault: &zeroValue}
	o.GetUseDefault()
	o = &OIDCSubjectClaimCustomTemplate{}
	o.GetUseDefault()
	o = nil
	o.GetUseDefault()
}

func TestOIDCSubjectClaimCustomTemplate_GetUseImmutableSubject(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	o := &OIDCSubjectClaimCustomTemplate{UseImmutableSubject: &zeroValue}
	o.GetUseImmutableSubject()
	o = &OIDCSubjectClaimCustomTemplate{}
	o.GetUseImmutableSubject()
	o = nil
	o.GetUseImmutableSubject()
}

func TestOrganization_GetAdvancedSecurityEnabledForNewRepos(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	o := &Organization{AdvancedSecurityEnabledForNewRepos: &zeroValue}
	o.GetAdvancedSecurityEnabledForNewRepos()
	o = &Organization{}
	o.GetAdvancedSecurityEnabledForNewRepos()
	o = nil
	o.GetAdvancedSecurityEnabledForNewRepos()
}

func TestOrganization_GetArchivedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	o := &Organization{ArchivedAt: &zeroValue}
	o.GetArchivedAt()
	o = &Organization{}
	o.GetArchivedAt()
	o = nil
	o.GetArchivedAt()
}

func TestOrganization_GetAvatarURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	o := &Organization{AvatarURL: &zeroValue}
	o.GetAvatarURL()
	o = &Organization{}
	o.GetAvatarURL()
	o = nil
	o.GetAvatarURL()
}

func TestOrganization_GetBillingEmail(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	o := &Organization{BillingEmail: &zeroValue}
	o.GetBillingEmail()
	o = &Organization{}
	o.GetBillingEmail()
	o = nil
	o.GetBillingEmail()
}

func TestOrganization_GetBlog(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	o := &Organization{Blog: &zeroValue}
	o.GetBlog()
	o = &Organization{}
	o.GetBlog()
	o = nil
	o.GetBlog()
}

func TestOrganization_GetCollaborators(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	o := &Organization{Collaborators: &zeroValue}
	o.GetCollaborators()
	o = &Organization{}
	o.GetCollaborators()
	o = nil
	o.GetCollaborators()
}

func TestOrganization_GetCompany(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	o := &Organization{Company: &zeroValue}
	o.GetCompany()
	o = &Organization{}
	o.GetCompany()
	o = nil
	o.GetCompany()
}

func TestOrganization_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	o := &Organization{CreatedAt: &zeroValue}
	o.GetCreatedAt()
	o = &Organization{}
	o.GetCreatedAt()
	o = nil
	o.GetCreatedAt()
}

func TestOrganization_GetDefaultRepoPermission(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	o := &Organization{DefaultRepoPermission: &zeroValue}
	o.GetDefaultRepoPermission()
	o = &Organization{}
	o.GetDefaultRepoPermission()
	o = nil
	o.GetDefaultRepoPermission()
}

func TestOrganization_GetDefaultRepoSettings(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	o := &Organization{DefaultRepoSettings: &zeroValue}
	o.GetDefaultRepoSettings()
	o = &Organization{}
	o.GetDefaultRepoSettings()
	o = nil
	o.GetDefaultRepoSettings()
}

func TestOrganization_GetDefaultRepositoryBranch(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	o := &Organization{DefaultRepositoryBranch: &zeroValue}
	o.GetDefaultRepositoryBranch()
	o = &Organization{}
	o.GetDefaultRepositoryBranch()
	o = nil
	o.GetDefaultRepositoryBranch()
}

func TestOrganization_GetDependabotAlertsEnabledForNewRepos(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	o := &Organization{DependabotAlertsEnabledForNewRepos: &zeroValue}
	o.GetDependabotAlertsEnabledForNewRepos()
	o = &Organization{}
	o.GetDependabotAlertsEnabledForNewRepos()
	o = nil
	o.GetDependabotAlertsEnabledForNewRepos()
}

func TestOrganization_GetDependabotSecurityUpdatesEnabledForNewRepos(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	o := &Organization{DependabotSecurityUpdatesEnabledForNewRepos: &zeroValue}
	o.GetDependabotSecurityUpdatesEnabledForNewRepos()
	o = &Organization{}
	o.GetDependabotSecurityUpdatesEnabledForNewRepos()
	o = nil
	o.GetDependabotSecurityUpdatesEnabledForNewRepos()
}

func TestOrganization_GetDependencyGraphEnabledForNewRepos(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	o := &Organization{DependencyGraphEnabledForNewRepos: &zeroValue}
	o.GetDependencyGraphEnabledForNewRepos()
	o = &Organization{}
	o.GetDependencyGraphEnabledForNewRepos()
	o = nil
	o.GetDependencyGraphEnabledForNewRepos()
}

func TestOrganization_GetDeployKeysEnabledForRepositories(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	o := &Organization{DeployKeysEnabledForRepositories: &zeroValue}
	o.GetDeployKeysEnabledForRepositories()
	o = &Organization{}
	o.GetDeployKeysEnabledForRepositories()
	o = nil
	o.GetDeployKeysEnabledForRepositories()
}

func TestOrganization_GetDescription(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	o := &Organization{Description: &zeroValue}
	o.GetDescription()
	o = &Organization{}
	o.GetDescription()
	o = nil
	o.GetDescription()
}

func TestOrganization_GetDiskUsage(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	o := &Organization{DiskUsage: &zeroValue}
	o.GetDiskUsage()
	o = &Organization{}
	o.GetDiskUsage()
	o = nil
	o.GetDiskUsage()
}

func TestOrganization_GetDisplayCommenterFullNameSettingEnabled(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	o := &Organization{DisplayCommenterFullNameSettingEnabled: &zeroValue}
	o.GetDisplayCommenterFullNameSettingEnabled()
	o = &Organization{}
	o.GetDisplayCommenterFullNameSettingEnabled()
	o = nil
	o.GetDisplayCommenterFullNameSettingEnabled()
}

func TestOrganization_GetEmail(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	o := &Organization{Email: &zeroValue}
	o.GetEmail()
	o = &Organization{}
	o.GetEmail()
	o = nil
	o.GetEmail()
}

func TestOrganization_GetEventsURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	o := &Organization{EventsURL: &zeroValue}
	o.GetEventsURL()
	o = &Organization{}
	o.GetEventsURL()
	o = nil
	o.GetEventsURL()
}

func TestOrganization_GetFollowers(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	o := &Organization{Followers: &zeroValue}
	o.GetFollowers()
	o = &Organization{}
	o.GetFollowers()
	o = nil
	o.GetFollowers()
}

func TestOrganization_GetFollowing(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	o := &Organization{Following: &zeroValue}
	o.GetFollowing()
	o = &Organization{}
	o.GetFollowing()
	o = nil
	o.GetFollowing()
}

func TestOrganization_GetHasOrganizationProjects(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	o := &Organization{HasOrganizationProjects: &zeroValue}
	o.GetHasOrganizationProjects()
	o = &Organization{}
	o.GetHasOrganizationProjects()
	o = nil
	o.GetHasOrganizationProjects()
}

func TestOrganization_GetHasRepositoryProjects(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	o := &Organization{HasRepositoryProjects: &zeroValue}
	o.GetHasRepositoryProjects()
	o = &Organization{}
	o.GetHasRepositoryProjects()
	o = nil
	o.GetHasRepositoryProjects()
}

func TestOrganization_GetHooksURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	o := &Organization{HooksURL: &zeroValue}
	o.GetHooksURL()
	o = &Organization{}
	o.GetHooksURL()
	o = nil
	o.GetHooksURL()
}

func TestOrganization_GetHTMLURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	o := &Organization{HTMLURL: &zeroValue}
	o.GetHTMLURL()
	o = &Organization{}
	o.GetHTMLURL()
	o = nil
	o.GetHTMLURL()
}

func TestOrganization_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	o := &Organization{ID: &zeroValue}
	o.GetID()
	o = &Organization{}
	o.GetID()
	o = nil
	o.GetID()
}

func TestOrganization_GetIssuesURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	o := &Organization{IssuesURL: &zeroValue}
	o.GetIssuesURL()
	o = &Organization{}
	o.GetIssuesURL()
	o = nil
	o.GetIssuesURL()
}

func TestOrganization_GetIsVerified(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	o := &Organization{IsVerified: &zeroValue}
	o.GetIsVerified()
	o = &Organization{}
	o.GetIsVerified()
	o = nil
	o.GetIsVerified()
}

func TestOrganization_GetLocation(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	o := &Organization{Location: &zeroValue}
	o.GetLocation()
	o = &Organization{}
	o.GetLocation()
	o = nil
	o.GetLocation()
}

func TestOrganization_GetLogin(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	o := &Organization{Login: &zeroValue}
	o.GetLogin()
	o = &Organization{}
	o.GetLogin()
	o = nil
	o.GetLogin()
}

func TestOrganization_GetMembersAllowedRepositoryCreationType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	o := &Organization{MembersAllowedRepositoryCreationType: &zeroValue}
	o.GetMembersAllowedRepositoryCreationType()
	o = &Organization{}
	o.GetMembersAllowedRepositoryCreationType()
	o = nil
	o.GetMembersAllowedRepositoryCreationType()
}

func TestOrganization_GetMembersCanChangeRepoVisibility(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	o := &Organization{MembersCanChangeRepoVisibility: &zeroValue}
	o.GetMembersCanChangeRepoVisibility()
	o = &Organization{}
	o.GetMembersCanChangeRepoVisibility()
	o = nil
	o.GetMembersCanChangeRepoVisibility()
}

func TestOrganization_GetMembersCanCreateInternalRepos(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	o := &Organization{MembersCanCreateInternalRepos: &zeroValue}
	o.GetMembersCanCreateInternalRepos()
	o = &Organization{}
	o.GetMembersCanCreateInternalRepos()
	o = nil
	o.GetMembersCanCreateInternalRepos()
}

func TestOrganization_GetMembersCanCreatePages(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	o := &Organization{MembersCanCreatePages: &zeroValue}
	o.GetMembersCanCreatePages()
	o = &Organization{}
	o.GetMembersCanCreatePages()
	o = nil
	o.GetMembersCanCreatePages()
}

func TestOrganization_GetMembersCanCreatePrivatePages(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	o := &Organization{MembersCanCreatePrivatePages: &zeroValue}
	o.GetMembersCanCreatePrivatePages()
	o = &Organization{}
	o.GetMembersCanCreatePrivatePages()
	o = nil
	o.GetMembersCanCreatePrivatePages()
}

func TestOrganization_GetMembersCanCreatePrivateRepos(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	o := &Organization{MembersCanCreatePrivateRepos: &zeroValue}
	o.GetMembersCanCreatePrivateRepos()
	o = &Organization{}
	o.GetMembersCanCreatePrivateRepos()
	o = nil
	o.GetMembersCanCreatePrivateRepos()
}

func TestOrganization_GetMembersCanCreatePublicPages(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	o := &Organization{MembersCanCreatePublicPages: &zeroValue}
	o.GetMembersCanCreatePublicPages()
	o = &Organization{}
	o.GetMembersCanCreatePublicPages()
	o = nil
	o.GetMembersCanCreatePublicPages()
}

func TestOrganization_GetMembersCanCreatePublicRepos(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	o := &Organization{MembersCanCreatePublicRepos: &zeroValue}
	o.GetMembersCanCreatePublicRepos()
	o = &Organization{}
	o.GetMembersCanCreatePublicRepos()
	o = nil
	o.GetMembersCanCreatePublicRepos()
}

func TestOrganization_GetMembersCanCreateRepos(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	o := &Organization{MembersCanCreateRepos: &zeroValue}
	o.GetMembersCanCreateRepos()
	o = &Organization{}
	o.GetMembersCanCreateRepos()
	o = nil
	o.GetMembersCanCreateRepos()
}

func TestOrganization_GetMembersCanCreateTeams(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	o := &Organization{MembersCanCreateTeams: &zeroValue}
	o.GetMembersCanCreateTeams()
	o = &Organization{}
	o.GetMembersCanCreateTeams()
	o = nil
	o.GetMembersCanCreateTeams()
}

func TestOrganization_GetMembersCanDeleteIssues(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	o := &Organization{MembersCanDeleteIssues: &zeroValue}
	o.GetMembersCanDeleteIssues()
	o = &Organization{}
	o.GetMembersCanDeleteIssues()
	o = nil
	o.GetMembersCanDeleteIssues()
}

func TestOrganization_GetMembersCanDeleteRepositories(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	o := &Organization{MembersCanDeleteRepositories: &zeroValue}
	o.GetMembersCanDeleteRepositories()
	o = &Organization{}
	o.GetMembersCanDeleteRepositories()
	o = nil
	o.GetMembersCanDeleteRepositories()
}

func TestOrganization_GetMembersCanForkPrivateRepos(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	o := &Organization{MembersCanForkPrivateRepos: &zeroValue}
	o.GetMembersCanForkPrivateRepos()
	o = &Organization{}
	o.GetMembersCanForkPrivateRepos()
	o = nil
	o.GetMembersCanForkPrivateRepos()
}

func TestOrganization_GetMembersCanInviteOutsideCollaborators(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	o := &Organization{MembersCanInviteOutsideCollaborators: &zeroValue}
	o.GetMembersCanInviteOutsideCollaborators()
	o = &Organization{}
	o.GetMembersCanInviteOutsideCollaborators()
	o = nil
	o.GetMembersCanInviteOutsideCollaborators()
}

func TestOrganization_GetMembersCanViewDependencyInsights(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	o := &Organization{MembersCanViewDependencyInsights: &zeroValue}
	o.GetMembersCanViewDependencyInsights()
	o = &Organization{}
	o.GetMembersCanViewDependencyInsights()
	o = nil
	o.GetMembersCanViewDependencyInsights()
}

func TestOrganization_GetMembersURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	o := &Organization{MembersURL: &zeroValue}
	o.GetMembersURL()
	o = &Organization{}
	o.GetMembersURL()
	o = nil
	o.GetMembersURL()
}

func TestOrganization_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	o := &Organization{Name: &zeroValue}
	o.GetName()
	o = &Organization{}
	o.GetName()
	o = nil
	o.GetName()
}

func TestOrganization_GetNodeID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	o := &Organization{NodeID: &zeroValue}
	o.GetNodeID()
	o = &Organization{}
	o.GetNodeID()
	o = nil
	o.GetNodeID()
}

func TestOrganization_GetOwnedPrivateRepos(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	o := &Organization{OwnedPrivateRepos: &zeroValue}
	o.GetOwnedPrivateRepos()
	o = &Organization{}
	o.GetOwnedPrivateRepos()
	o = nil
	o.GetOwnedPrivateRepos()
}

func TestOrganization_GetPlan(tt *testing.T) {
	tt.Parallel()
	o := &Organization{}
	o.GetPlan()
	o = nil
	o.GetPlan()
}

func TestOrganization_GetPrivateGists(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	o := &Organization{PrivateGists: &zeroValue}
	o.GetPrivateGists()
	o = &Organization{}
	o.GetPrivateGists()
	o = nil
	o.GetPrivateGists()
}

func TestOrganization_GetPublicGists(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	o := &Organization{PublicGists: &zeroValue}
	o.GetPublicGists()
	o = &Organization{}
	o.GetPublicGists()
	o = nil
	o.GetPublicGists()
}

func TestOrganization_GetPublicMembersURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	o := &Organization{PublicMembersURL: &zeroValue}
	o.GetPublicMembersURL()
	o = &Organization{}
	o.GetPublicMembersURL()
	o = nil
	o.GetPublicMembersURL()
}

func TestOrganization_GetPublicRepos(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	o := &Organization{PublicRepos: &zeroValue}
	o.GetPublicRepos()
	o = &Organization{}
	o.GetPublicRepos()
	o = nil
	o.GetPublicRepos()
}

func TestOrganization_GetReadersCanCreateDiscussions(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	o := &Organization{ReadersCanCreateDiscussions: &zeroValue}
	o.GetReadersCanCreateDiscussions()
	o = &Organization{}
	o.GetReadersCanCreateDiscussions()
	o = nil
	o.GetReadersCanCreateDiscussions()
}

func TestOrganization_GetReposURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	o := &Organization{ReposURL: &zeroValue}
	o.GetReposURL()
	o = &Organization{}
	o.GetReposURL()
	o = nil
	o.GetReposURL()
}

func TestOrganization_GetSecretScanningEnabledForNewRepos(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	o := &Organization{SecretScanningEnabledForNewRepos: &zeroValue}
	o.GetSecretScanningEnabledForNewRepos()
	o = &Organization{}
	o.GetSecretScanningEnabledForNewRepos()
	o = nil
	o.GetSecretScanningEnabledForNewRepos()
}

func TestOrganization_GetSecretScanningPushProtectionCustomLink(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	o := &Organization{SecretScanningPushProtectionCustomLink: &zeroValue}
	o.GetSecretScanningPushProtectionCustomLink()
	o = &Organization{}
	o.GetSecretScanningPushProtectionCustomLink()
	o = nil
	o.GetSecretScanningPushProtectionCustomLink()
}

func TestOrganization_GetSecretScanningPushProtectionCustomLinkEnabled(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	o := &Organization{SecretScanningPushProtectionCustomLinkEnabled: &zeroValue}
	o.GetSecretScanningPushProtectionCustomLinkEnabled()
	o = &Organization{}
	o.GetSecretScanningPushProtectionCustomLinkEnabled()
	o = nil
	o.GetSecretScanningPushProtectionCustomLinkEnabled()
}

func TestOrganization_GetSecretScanningPushProtectionEnabledForNewRepos(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	o := &Organization{SecretScanningPushProtectionEnabledForNewRepos: &zeroValue}
	o.GetSecretScanningPushProtectionEnabledForNewRepos()
	o = &Organization{}
	o.GetSecretScanningPushProtectionEnabledForNewRepos()
	o = nil
	o.GetSecretScanningPushProtectionEnabledForNewRepos()
}

func TestOrganization_GetSecretScanningValidityChecksEnabled(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	o := &Organization{SecretScanningValidityChecksEnabled: &zeroValue}
	o.GetSecretScanningValidityChecksEnabled()
	o = &Organization{}
	o.GetSecretScanningValidityChecksEnabled()
	o = nil
	o.GetSecretScanningValidityChecksEnabled()
}

func TestOrganization_GetTotalPrivateRepos(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	o := &Organization{TotalPrivateRepos: &zeroValue}
	o.GetTotalPrivateRepos()
	o = &Organization{}
	o.GetTotalPrivateRepos()
	o = nil
	o.GetTotalPrivateRepos()
}

func TestOrganization_GetTwitterUsername(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	o := &Organization{TwitterUsername: &zeroValue}
	o.GetTwitterUsername()
	o = &Organization{}
	o.GetTwitterUsername()
	o = nil
	o.GetTwitterUsername()
}

func TestOrganization_GetTwoFactorRequirementEnabled(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	o := &Organization{TwoFactorRequirementEnabled: &zeroValue}
	o.GetTwoFactorRequirementEnabled()
	o = &Organization{}
	o.GetTwoFactorRequirementEnabled()
	o = nil
	o.GetTwoFactorRequirementEnabled()
}

func TestOrganization_GetType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	o := &Organization{Type: &zeroValue}
	o.GetType()
	o = &Organization{}
	o.GetType()
	o = nil
	o.GetType()
}

func TestOrganization_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	o := &Organization{UpdatedAt: &zeroValue}
	o.GetUpdatedAt()
	o = &Organization{}
	o.GetUpdatedAt()
	o = nil
	o.GetUpdatedAt()
}

func TestOrganization_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	o := &Organization{URL: &zeroValue}
	o.GetURL()
	o = &Organization{}
	o.GetURL()
	o = nil
	o.GetURL()
}

func TestOrganization_GetWebCommitSignoffRequired(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	o := &Organization{WebCommitSignoffRequired: &zeroValue}
	o.GetWebCommitSignoffRequired()
	o = &Organization{}
	o.GetWebCommitSignoffRequired()
	o = nil
	o.GetWebCommitSignoffRequired()
}

func TestOrganizationCustomPropertyValues_GetProperties(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*CustomPropertyValue{}
	o := &OrganizationCustomPropertyValues{Properties: zeroValue}
	o.GetProperties()
	o = &OrganizationCustomPropertyValues{}
	o.GetProperties()
	o = nil
	o.GetProperties()
}

func TestOrganizationCustomRepoRoles_GetCustomRepoRoles(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*CustomRepoRoles{}
	o := &OrganizationCustomRepoRoles{CustomRepoRoles: zeroValue}
	o.GetCustomRepoRoles()
	o = &OrganizationCustomRepoRoles{}
	o.GetCustomRepoRoles()
	o = nil
	o.GetCustomRepoRoles()
}

func TestOrganizationCustomRepoRoles_GetTotalCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	o := &OrganizationCustomRepoRoles{TotalCount: &zeroValue}
	o.GetTotalCount()
	o = &OrganizationCustomRepoRoles{}
	o.GetTotalCount()
	o = nil
	o.GetTotalCount()
}

func TestOrganizationCustomRoles_GetCustomRepoRoles(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*CustomOrgRole{}
	o := &OrganizationCustomRoles{CustomRepoRoles: zeroValue}
	o.GetCustomRepoRoles()
	o = &OrganizationCustomRoles{}
	o.GetCustomRepoRoles()
	o = nil
	o.GetCustomRepoRoles()
}

func TestOrganizationCustomRoles_GetTotalCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	o := &OrganizationCustomRoles{TotalCount: &zeroValue}
	o.GetTotalCount()
	o = &OrganizationCustomRoles{}
	o.GetTotalCount()
	o = nil
	o.GetTotalCount()
}

func TestOrganizationEvent_GetAction(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	o := &OrganizationEvent{Action: &zeroValue}
	o.GetAction()
	o = &OrganizationEvent{}
	o.GetAction()
	o = nil
	o.GetAction()
}

func TestOrganizationEvent_GetInstallation(tt *testing.T) {
	tt.Parallel()
	o := &OrganizationEvent{}
	o.GetInstallation()
	o = nil
	o.GetInstallation()
}

func TestOrganizationEvent_GetInvitation(tt *testing.T) {
	tt.Parallel()
	o := &OrganizationEvent{}
	o.GetInvitation()
	o = nil
	o.GetInvitation()
}

func TestOrganizationEvent_GetMembership(tt *testing.T) {
	tt.Parallel()
	o := &OrganizationEvent{}
	o.GetMembership()
	o = nil
	o.GetMembership()
}

func TestOrganizationEvent_GetOrganization(tt *testing.T) {
	tt.Parallel()
	o := &OrganizationEvent{}
	o.GetOrganization()
	o = nil
	o.GetOrganization()
}

func TestOrganizationEvent_GetSender(tt *testing.T) {
	tt.Parallel()
	o := &OrganizationEvent{}
	o.GetSender()
	o = nil
	o.GetSender()
}

func TestOrganizationFineGrainedPermission_GetDescription(tt *testing.T) {
	tt.Parallel()
	o := &OrganizationFineGrainedPermission{}
	o.GetDescription()
	o = nil
	o.GetDescription()
}

func TestOrganizationFineGrainedPermission_GetName(tt *testing.T) {
	tt.Parallel()
	o := &OrganizationFineGrainedPermission{}
	o.GetName()
	o = nil
	o.GetName()
}

func TestOrganizationInstallations_GetInstallations(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*Installation{}
	o := &OrganizationInstallations{Installations: zeroValue}
	o.GetInstallations()
	o = &OrganizationInstallations{}
	o.GetInstallations()
	o = nil
	o.GetInstallations()
}

func TestOrganizationInstallations_GetTotalCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	o := &OrganizationInstallations{TotalCount: &zeroValue}
	o.GetTotalCount()
	o = &OrganizationInstallations{}
	o.GetTotalCount()
	o = nil
	o.GetTotalCount()
}

func TestOrganizationsListOptions_GetPerPage(tt *testing.T) {
	tt.Parallel()
	o := &OrganizationsListOptions{}
	o.GetPerPage()
	o = nil
	o.GetPerPage()
}

func TestOrganizationsListOptions_GetSince(tt *testing.T) {
	tt.Parallel()
	o := &OrganizationsListOptions{}
	o.GetSince()
	o = nil
	o.GetSince()
}

func TestOrgBlockEvent_GetAction(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	o := &OrgBlockEvent{Action: &zeroValue}
	o.GetAction()
	o = &OrgBlockEvent{}
	o.GetAction()
	o = nil
	o.GetAction()
}

func TestOrgBlockEvent_GetBlockedUser(tt *testing.T) {
	tt.Parallel()
	o := &OrgBlockEvent{}
	o.GetBlockedUser()
	o = nil
	o.GetBlockedUser()
}

func TestOrgBlockEvent_GetInstallation(tt *testing.T) {
	tt.Parallel()
	o := &OrgBlockEvent{}
	o.GetInstallation()
	o = nil
	o.GetInstallation()
}

func TestOrgBlockEvent_GetOrganization(tt *testing.T) {
	tt.Parallel()
	o := &OrgBlockEvent{}
	o.GetOrganization()
	o = nil
	o.GetOrganization()
}

func TestOrgBlockEvent_GetSender(tt *testing.T) {
	tt.Parallel()
	o := &OrgBlockEvent{}
	o.GetSender()
	o = nil
	o.GetSender()
}

func TestOrgStats_GetDisabledOrgs(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	o := &OrgStats{DisabledOrgs: &zeroValue}
	o.GetDisabledOrgs()
	o = &OrgStats{}
	o.GetDisabledOrgs()
	o = nil
	o.GetDisabledOrgs()
}

func TestOrgStats_GetTotalOrgs(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	o := &OrgStats{TotalOrgs: &zeroValue}
	o.GetTotalOrgs()
	o = &OrgStats{}
	o.GetTotalOrgs()
	o = nil
	o.GetTotalOrgs()
}

func TestOrgStats_GetTotalTeamMembers(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	o := &OrgStats{TotalTeamMembers: &zeroValue}
	o.GetTotalTeamMembers()
	o = &OrgStats{}
	o.GetTotalTeamMembers()
	o = nil
	o.GetTotalTeamMembers()
}

func TestOrgStats_GetTotalTeams(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	o := &OrgStats{TotalTeams: &zeroValue}
	o.GetTotalTeams()
	o = &OrgStats{}
	o.GetTotalTeams()
	o = nil
	o.GetTotalTeams()
}

func TestOwnerInfo_GetOrg(tt *testing.T) {
	tt.Parallel()
	o := &OwnerInfo{}
	o.GetOrg()
	o = nil
	o.GetOrg()
}

func TestOwnerInfo_GetUser(tt *testing.T) {
	tt.Parallel()
	o := &OwnerInfo{}
	o.GetUser()
	o = nil
	o.GetUser()
}

func TestPackage_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	p := &Package{CreatedAt: &zeroValue}
	p.GetCreatedAt()
	p = &Package{}
	p.GetCreatedAt()
	p = nil
	p.GetCreatedAt()
}

func TestPackage_GetDescription(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &Package{Description: &zeroValue}
	p.GetDescription()
	p = &Package{}
	p.GetDescription()
	p = nil
	p.GetDescription()
}

func TestPackage_GetEcosystem(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &Package{Ecosystem: &zeroValue}
	p.GetEcosystem()
	p = &Package{}
	p.GetEcosystem()
	p = nil
	p.GetEcosystem()
}

func TestPackage_GetHTMLURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &Package{HTMLURL: &zeroValue}
	p.GetHTMLURL()
	p = &Package{}
	p.GetHTMLURL()
	p = nil
	p.GetHTMLURL()
}

func TestPackage_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	p := &Package{ID: &zeroValue}
	p.GetID()
	p = &Package{}
	p.GetID()
	p = nil
	p.GetID()
}

func TestPackage_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &Package{Name: &zeroValue}
	p.GetName()
	p = &Package{}
	p.GetName()
	p = nil
	p.GetName()
}

func TestPackage_GetNamespace(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &Package{Namespace: &zeroValue}
	p.GetNamespace()
	p = &Package{}
	p.GetNamespace()
	p = nil
	p.GetNamespace()
}

func TestPackage_GetOwner(tt *testing.T) {
	tt.Parallel()
	p := &Package{}
	p.GetOwner()
	p = nil
	p.GetOwner()
}

func TestPackage_GetPackageType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &Package{PackageType: &zeroValue}
	p.GetPackageType()
	p = &Package{}
	p.GetPackageType()
	p = nil
	p.GetPackageType()
}

func TestPackage_GetPackageVersion(tt *testing.T) {
	tt.Parallel()
	p := &Package{}
	p.GetPackageVersion()
	p = nil
	p.GetPackageVersion()
}

func TestPackage_GetRegistry(tt *testing.T) {
	tt.Parallel()
	p := &Package{}
	p.GetRegistry()
	p = nil
	p.GetRegistry()
}

func TestPackage_GetRepository(tt *testing.T) {
	tt.Parallel()
	p := &Package{}
	p.GetRepository()
	p = nil
	p.GetRepository()
}

func TestPackage_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	p := &Package{UpdatedAt: &zeroValue}
	p.GetUpdatedAt()
	p = &Package{}
	p.GetUpdatedAt()
	p = nil
	p.GetUpdatedAt()
}

func TestPackage_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &Package{URL: &zeroValue}
	p.GetURL()
	p = &Package{}
	p.GetURL()
	p = nil
	p.GetURL()
}

func TestPackage_GetVersionCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	p := &Package{VersionCount: &zeroValue}
	p.GetVersionCount()
	p = &Package{}
	p.GetVersionCount()
	p = nil
	p.GetVersionCount()
}

func TestPackage_GetVisibility(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &Package{Visibility: &zeroValue}
	p.GetVisibility()
	p = &Package{}
	p.GetVisibility()
	p = nil
	p.GetVisibility()
}

func TestPackageContainerMetadata_GetTags(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	p := &PackageContainerMetadata{Tags: zeroValue}
	p.GetTags()
	p = &PackageContainerMetadata{}
	p.GetTags()
	p = nil
	p.GetTags()
}

func TestPackageEvent_GetAction(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PackageEvent{Action: &zeroValue}
	p.GetAction()
	p = &PackageEvent{}
	p.GetAction()
	p = nil
	p.GetAction()
}

func TestPackageEvent_GetInstallation(tt *testing.T) {
	tt.Parallel()
	p := &PackageEvent{}
	p.GetInstallation()
	p = nil
	p.GetInstallation()
}

func TestPackageEvent_GetOrg(tt *testing.T) {
	tt.Parallel()
	p := &PackageEvent{}
	p.GetOrg()
	p = nil
	p.GetOrg()
}

func TestPackageEvent_GetPackage(tt *testing.T) {
	tt.Parallel()
	p := &PackageEvent{}
	p.GetPackage()
	p = nil
	p.GetPackage()
}

func TestPackageEvent_GetRepo(tt *testing.T) {
	tt.Parallel()
	p := &PackageEvent{}
	p.GetRepo()
	p = nil
	p.GetRepo()
}

func TestPackageEvent_GetSender(tt *testing.T) {
	tt.Parallel()
	p := &PackageEvent{}
	p.GetSender()
	p = nil
	p.GetSender()
}

func TestPackageEventContainerMetadata_GetLabels(tt *testing.T) {
	tt.Parallel()
	zeroValue := map[string]any{}
	p := &PackageEventContainerMetadata{Labels: zeroValue}
	p.GetLabels()
	p = &PackageEventContainerMetadata{}
	p.GetLabels()
	p = nil
	p.GetLabels()
}

func TestPackageEventContainerMetadata_GetManifest(tt *testing.T) {
	tt.Parallel()
	zeroValue := map[string]any{}
	p := &PackageEventContainerMetadata{Manifest: zeroValue}
	p.GetManifest()
	p = &PackageEventContainerMetadata{}
	p.GetManifest()
	p = nil
	p.GetManifest()
}

func TestPackageEventContainerMetadata_GetTag(tt *testing.T) {
	tt.Parallel()
	p := &PackageEventContainerMetadata{}
	p.GetTag()
	p = nil
	p.GetTag()
}

func TestPackageEventContainerMetadataTag_GetDigest(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PackageEventContainerMetadataTag{Digest: &zeroValue}
	p.GetDigest()
	p = &PackageEventContainerMetadataTag{}
	p.GetDigest()
	p = nil
	p.GetDigest()
}

func TestPackageEventContainerMetadataTag_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PackageEventContainerMetadataTag{Name: &zeroValue}
	p.GetName()
	p = &PackageEventContainerMetadataTag{}
	p.GetName()
	p = nil
	p.GetName()
}

func TestPackageExternalRef_GetReferenceCategory(tt *testing.T) {
	tt.Parallel()
	p := &PackageExternalRef{}
	p.GetReferenceCategory()
	p = nil
	p.GetReferenceCategory()
}

func TestPackageExternalRef_GetReferenceLocator(tt *testing.T) {
	tt.Parallel()
	p := &PackageExternalRef{}
	p.GetReferenceLocator()
	p = nil
	p.GetReferenceLocator()
}

func TestPackageExternalRef_GetReferenceType(tt *testing.T) {
	tt.Parallel()
	p := &PackageExternalRef{}
	p.GetReferenceType()
	p = nil
	p.GetReferenceType()
}

func TestPackageFile_GetAuthor(tt *testing.T) {
	tt.Parallel()
	p := &PackageFile{}
	p.GetAuthor()
	p = nil
	p.GetAuthor()
}

func TestPackageFile_GetContentType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PackageFile{ContentType: &zeroValue}
	p.GetContentType()
	p = &PackageFile{}
	p.GetContentType()
	p = nil
	p.GetContentType()
}

func TestPackageFile_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	p := &PackageFile{CreatedAt: &zeroValue}
	p.GetCreatedAt()
	p = &PackageFile{}
	p.GetCreatedAt()
	p = nil
	p.GetCreatedAt()
}

func TestPackageFile_GetDownloadURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PackageFile{DownloadURL: &zeroValue}
	p.GetDownloadURL()
	p = &PackageFile{}
	p.GetDownloadURL()
	p = nil
	p.GetDownloadURL()
}

func TestPackageFile_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	p := &PackageFile{ID: &zeroValue}
	p.GetID()
	p = &PackageFile{}
	p.GetID()
	p = nil
	p.GetID()
}

func TestPackageFile_GetMD5(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PackageFile{MD5: &zeroValue}
	p.GetMD5()
	p = &PackageFile{}
	p.GetMD5()
	p = nil
	p.GetMD5()
}

func TestPackageFile_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PackageFile{Name: &zeroValue}
	p.GetName()
	p = &PackageFile{}
	p.GetName()
	p = nil
	p.GetName()
}

func TestPackageFile_GetSHA1(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PackageFile{SHA1: &zeroValue}
	p.GetSHA1()
	p = &PackageFile{}
	p.GetSHA1()
	p = nil
	p.GetSHA1()
}

func TestPackageFile_GetSHA256(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PackageFile{SHA256: &zeroValue}
	p.GetSHA256()
	p = &PackageFile{}
	p.GetSHA256()
	p = nil
	p.GetSHA256()
}

func TestPackageFile_GetSize(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	p := &PackageFile{Size: &zeroValue}
	p.GetSize()
	p = &PackageFile{}
	p.GetSize()
	p = nil
	p.GetSize()
}

func TestPackageFile_GetState(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PackageFile{State: &zeroValue}
	p.GetState()
	p = &PackageFile{}
	p.GetState()
	p = nil
	p.GetState()
}

func TestPackageFile_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	p := &PackageFile{UpdatedAt: &zeroValue}
	p.GetUpdatedAt()
	p = &PackageFile{}
	p.GetUpdatedAt()
	p = nil
	p.GetUpdatedAt()
}

func TestPackageListOptions_GetPackageType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PackageListOptions{PackageType: &zeroValue}
	p.GetPackageType()
	p = &PackageListOptions{}
	p.GetPackageType()
	p = nil
	p.GetPackageType()
}

func TestPackageListOptions_GetState(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PackageListOptions{State: &zeroValue}
	p.GetState()
	p = &PackageListOptions{}
	p.GetState()
	p = nil
	p.GetState()
}

func TestPackageListOptions_GetVisibility(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PackageListOptions{Visibility: &zeroValue}
	p.GetVisibility()
	p = &PackageListOptions{}
	p.GetVisibility()
	p = nil
	p.GetVisibility()
}

func TestPackageMetadata_GetContainer(tt *testing.T) {
	tt.Parallel()
	p := &PackageMetadata{}
	p.GetContainer()
	p = nil
	p.GetContainer()
}

func TestPackageMetadata_GetPackageType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PackageMetadata{PackageType: &zeroValue}
	p.GetPackageType()
	p = &PackageMetadata{}
	p.GetPackageType()
	p = nil
	p.GetPackageType()
}

func TestPackageNPMMetadata_GetAuthor(tt *testing.T) {
	tt.Parallel()
	zeroValue := map[string]string{}
	p := &PackageNPMMetadata{Author: zeroValue}
	p.GetAuthor()
	p = &PackageNPMMetadata{}
	p.GetAuthor()
	p = nil
	p.GetAuthor()
}

func TestPackageNPMMetadata_GetBin(tt *testing.T) {
	tt.Parallel()
	zeroValue := map[string]any{}
	p := &PackageNPMMetadata{Bin: zeroValue}
	p.GetBin()
	p = &PackageNPMMetadata{}
	p.GetBin()
	p = nil
	p.GetBin()
}

func TestPackageNPMMetadata_GetBugs(tt *testing.T) {
	tt.Parallel()
	zeroValue := map[string]string{}
	p := &PackageNPMMetadata{Bugs: zeroValue}
	p.GetBugs()
	p = &PackageNPMMetadata{}
	p.GetBugs()
	p = nil
	p.GetBugs()
}

func TestPackageNPMMetadata_GetCommitOID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PackageNPMMetadata{CommitOID: &zeroValue}
	p.GetCommitOID()
	p = &PackageNPMMetadata{}
	p.GetCommitOID()
	p = nil
	p.GetCommitOID()
}

func TestPackageNPMMetadata_GetContributors(tt *testing.T) {
	tt.Parallel()
	zeroValue := []any{}
	p := &PackageNPMMetadata{Contributors: zeroValue}
	p.GetContributors()
	p = &PackageNPMMetadata{}
	p.GetContributors()
	p = nil
	p.GetContributors()
}

func TestPackageNPMMetadata_GetCPU(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	p := &PackageNPMMetadata{CPU: zeroValue}
	p.GetCPU()
	p = &PackageNPMMetadata{}
	p.GetCPU()
	p = nil
	p.GetCPU()
}

func TestPackageNPMMetadata_GetDeletedByID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	p := &PackageNPMMetadata{DeletedByID: &zeroValue}
	p.GetDeletedByID()
	p = &PackageNPMMetadata{}
	p.GetDeletedByID()
	p = nil
	p.GetDeletedByID()
}

func TestPackageNPMMetadata_GetDependencies(tt *testing.T) {
	tt.Parallel()
	zeroValue := map[string]string{}
	p := &PackageNPMMetadata{Dependencies: zeroValue}
	p.GetDependencies()
	p = &PackageNPMMetadata{}
	p.GetDependencies()
	p = nil
	p.GetDependencies()
}

func TestPackageNPMMetadata_GetDescription(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PackageNPMMetadata{Description: &zeroValue}
	p.GetDescription()
	p = &PackageNPMMetadata{}
	p.GetDescription()
	p = nil
	p.GetDescription()
}

func TestPackageNPMMetadata_GetDevDependencies(tt *testing.T) {
	tt.Parallel()
	zeroValue := map[string]string{}
	p := &PackageNPMMetadata{DevDependencies: zeroValue}
	p.GetDevDependencies()
	p = &PackageNPMMetadata{}
	p.GetDevDependencies()
	p = nil
	p.GetDevDependencies()
}

func TestPackageNPMMetadata_GetDirectories(tt *testing.T) {
	tt.Parallel()
	zeroValue := map[string]string{}
	p := &PackageNPMMetadata{Directories: zeroValue}
	p.GetDirectories()
	p = &PackageNPMMetadata{}
	p.GetDirectories()
	p = nil
	p.GetDirectories()
}

func TestPackageNPMMetadata_GetDist(tt *testing.T) {
	tt.Parallel()
	zeroValue := map[string]string{}
	p := &PackageNPMMetadata{Dist: zeroValue}
	p.GetDist()
	p = &PackageNPMMetadata{}
	p.GetDist()
	p = nil
	p.GetDist()
}

func TestPackageNPMMetadata_GetEngines(tt *testing.T) {
	tt.Parallel()
	zeroValue := map[string]string{}
	p := &PackageNPMMetadata{Engines: zeroValue}
	p.GetEngines()
	p = &PackageNPMMetadata{}
	p.GetEngines()
	p = nil
	p.GetEngines()
}

func TestPackageNPMMetadata_GetFiles(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	p := &PackageNPMMetadata{Files: zeroValue}
	p.GetFiles()
	p = &PackageNPMMetadata{}
	p.GetFiles()
	p = nil
	p.GetFiles()
}

func TestPackageNPMMetadata_GetGitHead(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PackageNPMMetadata{GitHead: &zeroValue}
	p.GetGitHead()
	p = &PackageNPMMetadata{}
	p.GetGitHead()
	p = nil
	p.GetGitHead()
}

func TestPackageNPMMetadata_GetHasShrinkwrap(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &PackageNPMMetadata{HasShrinkwrap: &zeroValue}
	p.GetHasShrinkwrap()
	p = &PackageNPMMetadata{}
	p.GetHasShrinkwrap()
	p = nil
	p.GetHasShrinkwrap()
}

func TestPackageNPMMetadata_GetHomepage(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PackageNPMMetadata{Homepage: &zeroValue}
	p.GetHomepage()
	p = &PackageNPMMetadata{}
	p.GetHomepage()
	p = nil
	p.GetHomepage()
}

func TestPackageNPMMetadata_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PackageNPMMetadata{ID: &zeroValue}
	p.GetID()
	p = &PackageNPMMetadata{}
	p.GetID()
	p = nil
	p.GetID()
}

func TestPackageNPMMetadata_GetInstallationCommand(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PackageNPMMetadata{InstallationCommand: &zeroValue}
	p.GetInstallationCommand()
	p = &PackageNPMMetadata{}
	p.GetInstallationCommand()
	p = nil
	p.GetInstallationCommand()
}

func TestPackageNPMMetadata_GetKeywords(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	p := &PackageNPMMetadata{Keywords: zeroValue}
	p.GetKeywords()
	p = &PackageNPMMetadata{}
	p.GetKeywords()
	p = nil
	p.GetKeywords()
}

func TestPackageNPMMetadata_GetLicense(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PackageNPMMetadata{License: &zeroValue}
	p.GetLicense()
	p = &PackageNPMMetadata{}
	p.GetLicense()
	p = nil
	p.GetLicense()
}

func TestPackageNPMMetadata_GetMain(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PackageNPMMetadata{Main: &zeroValue}
	p.GetMain()
	p = &PackageNPMMetadata{}
	p.GetMain()
	p = nil
	p.GetMain()
}

func TestPackageNPMMetadata_GetMaintainers(tt *testing.T) {
	tt.Parallel()
	zeroValue := []any{}
	p := &PackageNPMMetadata{Maintainers: zeroValue}
	p.GetMaintainers()
	p = &PackageNPMMetadata{}
	p.GetMaintainers()
	p = nil
	p.GetMaintainers()
}

func TestPackageNPMMetadata_GetMan(tt *testing.T) {
	tt.Parallel()
	zeroValue := map[string]any{}
	p := &PackageNPMMetadata{Man: zeroValue}
	p.GetMan()
	p = &PackageNPMMetadata{}
	p.GetMan()
	p = nil
	p.GetMan()
}

func TestPackageNPMMetadata_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PackageNPMMetadata{Name: &zeroValue}
	p.GetName()
	p = &PackageNPMMetadata{}
	p.GetName()
	p = nil
	p.GetName()
}

func TestPackageNPMMetadata_GetNodeVersion(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PackageNPMMetadata{NodeVersion: &zeroValue}
	p.GetNodeVersion()
	p = &PackageNPMMetadata{}
	p.GetNodeVersion()
	p = nil
	p.GetNodeVersion()
}

func TestPackageNPMMetadata_GetNPMUser(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PackageNPMMetadata{NPMUser: &zeroValue}
	p.GetNPMUser()
	p = &PackageNPMMetadata{}
	p.GetNPMUser()
	p = nil
	p.GetNPMUser()
}

func TestPackageNPMMetadata_GetNPMVersion(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PackageNPMMetadata{NPMVersion: &zeroValue}
	p.GetNPMVersion()
	p = &PackageNPMMetadata{}
	p.GetNPMVersion()
	p = nil
	p.GetNPMVersion()
}

func TestPackageNPMMetadata_GetOptionalDependencies(tt *testing.T) {
	tt.Parallel()
	zeroValue := map[string]string{}
	p := &PackageNPMMetadata{OptionalDependencies: zeroValue}
	p.GetOptionalDependencies()
	p = &PackageNPMMetadata{}
	p.GetOptionalDependencies()
	p = nil
	p.GetOptionalDependencies()
}

func TestPackageNPMMetadata_GetOS(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	p := &PackageNPMMetadata{OS: zeroValue}
	p.GetOS()
	p = &PackageNPMMetadata{}
	p.GetOS()
	p = nil
	p.GetOS()
}

func TestPackageNPMMetadata_GetPeerDependencies(tt *testing.T) {
	tt.Parallel()
	zeroValue := map[string]string{}
	p := &PackageNPMMetadata{PeerDependencies: zeroValue}
	p.GetPeerDependencies()
	p = &PackageNPMMetadata{}
	p.GetPeerDependencies()
	p = nil
	p.GetPeerDependencies()
}

func TestPackageNPMMetadata_GetPublishedViaActions(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &PackageNPMMetadata{PublishedViaActions: &zeroValue}
	p.GetPublishedViaActions()
	p = &PackageNPMMetadata{}
	p.GetPublishedViaActions()
	p = nil
	p.GetPublishedViaActions()
}

func TestPackageNPMMetadata_GetReadme(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PackageNPMMetadata{Readme: &zeroValue}
	p.GetReadme()
	p = &PackageNPMMetadata{}
	p.GetReadme()
	p = nil
	p.GetReadme()
}

func TestPackageNPMMetadata_GetReleaseID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	p := &PackageNPMMetadata{ReleaseID: &zeroValue}
	p.GetReleaseID()
	p = &PackageNPMMetadata{}
	p.GetReleaseID()
	p = nil
	p.GetReleaseID()
}

func TestPackageNPMMetadata_GetRepository(tt *testing.T) {
	tt.Parallel()
	zeroValue := map[string]string{}
	p := &PackageNPMMetadata{Repository: zeroValue}
	p.GetRepository()
	p = &PackageNPMMetadata{}
	p.GetRepository()
	p = nil
	p.GetRepository()
}

func TestPackageNPMMetadata_GetScripts(tt *testing.T) {
	tt.Parallel()
	zeroValue := map[string]any{}
	p := &PackageNPMMetadata{Scripts: zeroValue}
	p.GetScripts()
	p = &PackageNPMMetadata{}
	p.GetScripts()
	p = nil
	p.GetScripts()
}

func TestPackageNPMMetadata_GetVersion(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PackageNPMMetadata{Version: &zeroValue}
	p.GetVersion()
	p = &PackageNPMMetadata{}
	p.GetVersion()
	p = nil
	p.GetVersion()
}

func TestPackageNugetMetadata_GetID(tt *testing.T) {
	tt.Parallel()
	p := &PackageNugetMetadata{}
	p.GetID()
	p = nil
	p.GetID()
}

func TestPackageNugetMetadata_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PackageNugetMetadata{Name: &zeroValue}
	p.GetName()
	p = &PackageNugetMetadata{}
	p.GetName()
	p = nil
	p.GetName()
}

func TestPackageNugetMetadata_GetValue(tt *testing.T) {
	tt.Parallel()
	p := &PackageNugetMetadata{}
	p.GetValue()
	p = nil
	p.GetValue()
}

func TestPackageRegistry_GetAboutURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PackageRegistry{AboutURL: &zeroValue}
	p.GetAboutURL()
	p = &PackageRegistry{}
	p.GetAboutURL()
	p = nil
	p.GetAboutURL()
}

func TestPackageRegistry_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PackageRegistry{Name: &zeroValue}
	p.GetName()
	p = &PackageRegistry{}
	p.GetName()
	p = nil
	p.GetName()
}

func TestPackageRegistry_GetType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PackageRegistry{Type: &zeroValue}
	p.GetType()
	p = &PackageRegistry{}
	p.GetType()
	p = nil
	p.GetType()
}

func TestPackageRegistry_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PackageRegistry{URL: &zeroValue}
	p.GetURL()
	p = &PackageRegistry{}
	p.GetURL()
	p = nil
	p.GetURL()
}

func TestPackageRegistry_GetVendor(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PackageRegistry{Vendor: &zeroValue}
	p.GetVendor()
	p = &PackageRegistry{}
	p.GetVendor()
	p = nil
	p.GetVendor()
}

func TestPackageRelease_GetAuthor(tt *testing.T) {
	tt.Parallel()
	p := &PackageRelease{}
	p.GetAuthor()
	p = nil
	p.GetAuthor()
}

func TestPackageRelease_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	p := &PackageRelease{CreatedAt: &zeroValue}
	p.GetCreatedAt()
	p = &PackageRelease{}
	p.GetCreatedAt()
	p = nil
	p.GetCreatedAt()
}

func TestPackageRelease_GetDraft(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &PackageRelease{Draft: &zeroValue}
	p.GetDraft()
	p = &PackageRelease{}
	p.GetDraft()
	p = nil
	p.GetDraft()
}

func TestPackageRelease_GetHTMLURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PackageRelease{HTMLURL: &zeroValue}
	p.GetHTMLURL()
	p = &PackageRelease{}
	p.GetHTMLURL()
	p = nil
	p.GetHTMLURL()
}

func TestPackageRelease_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	p := &PackageRelease{ID: &zeroValue}
	p.GetID()
	p = &PackageRelease{}
	p.GetID()
	p = nil
	p.GetID()
}

func TestPackageRelease_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PackageRelease{Name: &zeroValue}
	p.GetName()
	p = &PackageRelease{}
	p.GetName()
	p = nil
	p.GetName()
}

func TestPackageRelease_GetPrerelease(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &PackageRelease{Prerelease: &zeroValue}
	p.GetPrerelease()
	p = &PackageRelease{}
	p.GetPrerelease()
	p = nil
	p.GetPrerelease()
}

func TestPackageRelease_GetPublishedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	p := &PackageRelease{PublishedAt: &zeroValue}
	p.GetPublishedAt()
	p = &PackageRelease{}
	p.GetPublishedAt()
	p = nil
	p.GetPublishedAt()
}

func TestPackageRelease_GetTagName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PackageRelease{TagName: &zeroValue}
	p.GetTagName()
	p = &PackageRelease{}
	p.GetTagName()
	p = nil
	p.GetTagName()
}

func TestPackageRelease_GetTargetCommitish(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PackageRelease{TargetCommitish: &zeroValue}
	p.GetTargetCommitish()
	p = &PackageRelease{}
	p.GetTargetCommitish()
	p = nil
	p.GetTargetCommitish()
}

func TestPackageRelease_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PackageRelease{URL: &zeroValue}
	p.GetURL()
	p = &PackageRelease{}
	p.GetURL()
	p = nil
	p.GetURL()
}

func TestPackagesBilling_GetIncludedGigabytesBandwidth(tt *testing.T) {
	tt.Parallel()
	p := &PackagesBilling{}
	p.GetIncludedGigabytesBandwidth()
	p = nil
	p.GetIncludedGigabytesBandwidth()
}

func TestPackagesBilling_GetTotalGigabytesBandwidthUsed(tt *testing.T) {
	tt.Parallel()
	p := &PackagesBilling{}
	p.GetTotalGigabytesBandwidthUsed()
	p = nil
	p.GetTotalGigabytesBandwidthUsed()
}

func TestPackagesBilling_GetTotalPaidGigabytesBandwidthUsed(tt *testing.T) {
	tt.Parallel()
	p := &PackagesBilling{}
	p.GetTotalPaidGigabytesBandwidthUsed()
	p = nil
	p.GetTotalPaidGigabytesBandwidthUsed()
}

func TestPackageVersion_GetAuthor(tt *testing.T) {
	tt.Parallel()
	p := &PackageVersion{}
	p.GetAuthor()
	p = nil
	p.GetAuthor()
}

func TestPackageVersion_GetBodyHTML(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PackageVersion{BodyHTML: &zeroValue}
	p.GetBodyHTML()
	p = &PackageVersion{}
	p.GetBodyHTML()
	p = nil
	p.GetBodyHTML()
}

func TestPackageVersion_GetContainerMetadata(tt *testing.T) {
	tt.Parallel()
	p := &PackageVersion{}
	p.GetContainerMetadata()
	p = nil
	p.GetContainerMetadata()
}

func TestPackageVersion_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	p := &PackageVersion{CreatedAt: &zeroValue}
	p.GetCreatedAt()
	p = &PackageVersion{}
	p.GetCreatedAt()
	p = nil
	p.GetCreatedAt()
}

func TestPackageVersion_GetDeletedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	p := &PackageVersion{DeletedAt: &zeroValue}
	p.GetDeletedAt()
	p = &PackageVersion{}
	p.GetDeletedAt()
	p = nil
	p.GetDeletedAt()
}

func TestPackageVersion_GetDescription(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PackageVersion{Description: &zeroValue}
	p.GetDescription()
	p = &PackageVersion{}
	p.GetDescription()
	p = nil
	p.GetDescription()
}

func TestPackageVersion_GetDockerMetadata(tt *testing.T) {
	tt.Parallel()
	zeroValue := []any{}
	p := &PackageVersion{DockerMetadata: zeroValue}
	p.GetDockerMetadata()
	p = &PackageVersion{}
	p.GetDockerMetadata()
	p = nil
	p.GetDockerMetadata()
}

func TestPackageVersion_GetDraft(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &PackageVersion{Draft: &zeroValue}
	p.GetDraft()
	p = &PackageVersion{}
	p.GetDraft()
	p = nil
	p.GetDraft()
}

func TestPackageVersion_GetHTMLURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PackageVersion{HTMLURL: &zeroValue}
	p.GetHTMLURL()
	p = &PackageVersion{}
	p.GetHTMLURL()
	p = nil
	p.GetHTMLURL()
}

func TestPackageVersion_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	p := &PackageVersion{ID: &zeroValue}
	p.GetID()
	p = &PackageVersion{}
	p.GetID()
	p = nil
	p.GetID()
}

func TestPackageVersion_GetInstallationCommand(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PackageVersion{InstallationCommand: &zeroValue}
	p.GetInstallationCommand()
	p = &PackageVersion{}
	p.GetInstallationCommand()
	p = nil
	p.GetInstallationCommand()
}

func TestPackageVersion_GetLicense(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PackageVersion{License: &zeroValue}
	p.GetLicense()
	p = &PackageVersion{}
	p.GetLicense()
	p = nil
	p.GetLicense()
}

func TestPackageVersion_GetManifest(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PackageVersion{Manifest: &zeroValue}
	p.GetManifest()
	p = &PackageVersion{}
	p.GetManifest()
	p = nil
	p.GetManifest()
}

func TestPackageVersion_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PackageVersion{Name: &zeroValue}
	p.GetName()
	p = &PackageVersion{}
	p.GetName()
	p = nil
	p.GetName()
}

func TestPackageVersion_GetNPMMetadata(tt *testing.T) {
	tt.Parallel()
	p := &PackageVersion{}
	p.GetNPMMetadata()
	p = nil
	p.GetNPMMetadata()
}

func TestPackageVersion_GetNugetMetadata(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*PackageNugetMetadata{}
	p := &PackageVersion{NugetMetadata: zeroValue}
	p.GetNugetMetadata()
	p = &PackageVersion{}
	p.GetNugetMetadata()
	p = nil
	p.GetNugetMetadata()
}

func TestPackageVersion_GetPackageFiles(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*PackageFile{}
	p := &PackageVersion{PackageFiles: zeroValue}
	p.GetPackageFiles()
	p = &PackageVersion{}
	p.GetPackageFiles()
	p = nil
	p.GetPackageFiles()
}

func TestPackageVersion_GetPackageHTMLURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PackageVersion{PackageHTMLURL: &zeroValue}
	p.GetPackageHTMLURL()
	p = &PackageVersion{}
	p.GetPackageHTMLURL()
	p = nil
	p.GetPackageHTMLURL()
}

func TestPackageVersion_GetPackageURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PackageVersion{PackageURL: &zeroValue}
	p.GetPackageURL()
	p = &PackageVersion{}
	p.GetPackageURL()
	p = nil
	p.GetPackageURL()
}

func TestPackageVersion_GetPrerelease(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &PackageVersion{Prerelease: &zeroValue}
	p.GetPrerelease()
	p = &PackageVersion{}
	p.GetPrerelease()
	p = nil
	p.GetPrerelease()
}

func TestPackageVersion_GetRelease(tt *testing.T) {
	tt.Parallel()
	p := &PackageVersion{}
	p.GetRelease()
	p = nil
	p.GetRelease()
}

func TestPackageVersion_GetRubyMetadata(tt *testing.T) {
	tt.Parallel()
	zeroValue := map[string]any{}
	p := &PackageVersion{RubyMetadata: zeroValue}
	p.GetRubyMetadata()
	p = &PackageVersion{}
	p.GetRubyMetadata()
	p = nil
	p.GetRubyMetadata()
}

func TestPackageVersion_GetSourceURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PackageVersion{SourceURL: &zeroValue}
	p.GetSourceURL()
	p = &PackageVersion{}
	p.GetSourceURL()
	p = nil
	p.GetSourceURL()
}

func TestPackageVersion_GetSummary(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PackageVersion{Summary: &zeroValue}
	p.GetSummary()
	p = &PackageVersion{}
	p.GetSummary()
	p = nil
	p.GetSummary()
}

func TestPackageVersion_GetTagName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PackageVersion{TagName: &zeroValue}
	p.GetTagName()
	p = &PackageVersion{}
	p.GetTagName()
	p = nil
	p.GetTagName()
}

func TestPackageVersion_GetTargetCommitish(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PackageVersion{TargetCommitish: &zeroValue}
	p.GetTargetCommitish()
	p = &PackageVersion{}
	p.GetTargetCommitish()
	p = nil
	p.GetTargetCommitish()
}

func TestPackageVersion_GetTargetOID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PackageVersion{TargetOID: &zeroValue}
	p.GetTargetOID()
	p = &PackageVersion{}
	p.GetTargetOID()
	p = nil
	p.GetTargetOID()
}

func TestPackageVersion_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	p := &PackageVersion{UpdatedAt: &zeroValue}
	p.GetUpdatedAt()
	p = &PackageVersion{}
	p.GetUpdatedAt()
	p = nil
	p.GetUpdatedAt()
}

func TestPackageVersion_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PackageVersion{URL: &zeroValue}
	p.GetURL()
	p = &PackageVersion{}
	p.GetURL()
	p = nil
	p.GetURL()
}

func TestPackageVersion_GetVersion(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PackageVersion{Version: &zeroValue}
	p.GetVersion()
	p = &PackageVersion{}
	p.GetVersion()
	p = nil
	p.GetVersion()
}

func TestPackageVersionBody_GetInfo(tt *testing.T) {
	tt.Parallel()
	p := &PackageVersionBody{}
	p.GetInfo()
	p = nil
	p.GetInfo()
}

func TestPackageVersionBody_GetRepo(tt *testing.T) {
	tt.Parallel()
	p := &PackageVersionBody{}
	p.GetRepo()
	p = nil
	p.GetRepo()
}

func TestPackageVersionBodyInfo_GetCollection(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &PackageVersionBodyInfo{Collection: &zeroValue}
	p.GetCollection()
	p = &PackageVersionBodyInfo{}
	p.GetCollection()
	p = nil
	p.GetCollection()
}

func TestPackageVersionBodyInfo_GetMode(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	p := &PackageVersionBodyInfo{Mode: &zeroValue}
	p.GetMode()
	p = &PackageVersionBodyInfo{}
	p.GetMode()
	p = nil
	p.GetMode()
}

func TestPackageVersionBodyInfo_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PackageVersionBodyInfo{Name: &zeroValue}
	p.GetName()
	p = &PackageVersionBodyInfo{}
	p.GetName()
	p = nil
	p.GetName()
}

func TestPackageVersionBodyInfo_GetOID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PackageVersionBodyInfo{OID: &zeroValue}
	p.GetOID()
	p = &PackageVersionBodyInfo{}
	p.GetOID()
	p = nil
	p.GetOID()
}

func TestPackageVersionBodyInfo_GetPath(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PackageVersionBodyInfo{Path: &zeroValue}
	p.GetPath()
	p = &PackageVersionBodyInfo{}
	p.GetPath()
	p = nil
	p.GetPath()
}

func TestPackageVersionBodyInfo_GetSize(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	p := &PackageVersionBodyInfo{Size: &zeroValue}
	p.GetSize()
	p = &PackageVersionBodyInfo{}
	p.GetSize()
	p = nil
	p.GetSize()
}

func TestPackageVersionBodyInfo_GetType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PackageVersionBodyInfo{Type: &zeroValue}
	p.GetType()
	p = &PackageVersionBodyInfo{}
	p.GetType()
	p = nil
	p.GetType()
}

func TestPage_GetAction(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &Page{Action: &zeroValue}
	p.GetAction()
	p = &Page{}
	p.GetAction()
	p = nil
	p.GetAction()
}

func TestPage_GetHTMLURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &Page{HTMLURL: &zeroValue}
	p.GetHTMLURL()
	p = &Page{}
	p.GetHTMLURL()
	p = nil
	p.GetHTMLURL()
}

func TestPage_GetPageName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &Page{PageName: &zeroValue}
	p.GetPageName()
	p = &Page{}
	p.GetPageName()
	p = nil
	p.GetPageName()
}

func TestPage_GetSHA(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &Page{SHA: &zeroValue}
	p.GetSHA()
	p = &Page{}
	p.GetSHA()
	p = nil
	p.GetSHA()
}

func TestPage_GetSummary(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &Page{Summary: &zeroValue}
	p.GetSummary()
	p = &Page{}
	p.GetSummary()
	p = nil
	p.GetSummary()
}

func TestPage_GetTitle(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &Page{Title: &zeroValue}
	p.GetTitle()
	p = &Page{}
	p.GetTitle()
	p = nil
	p.GetTitle()
}

func TestPageBuildEvent_GetBuild(tt *testing.T) {
	tt.Parallel()
	p := &PageBuildEvent{}
	p.GetBuild()
	p = nil
	p.GetBuild()
}

func TestPageBuildEvent_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	p := &PageBuildEvent{ID: &zeroValue}
	p.GetID()
	p = &PageBuildEvent{}
	p.GetID()
	p = nil
	p.GetID()
}

func TestPageBuildEvent_GetInstallation(tt *testing.T) {
	tt.Parallel()
	p := &PageBuildEvent{}
	p.GetInstallation()
	p = nil
	p.GetInstallation()
}

func TestPageBuildEvent_GetOrg(tt *testing.T) {
	tt.Parallel()
	p := &PageBuildEvent{}
	p.GetOrg()
	p = nil
	p.GetOrg()
}

func TestPageBuildEvent_GetRepo(tt *testing.T) {
	tt.Parallel()
	p := &PageBuildEvent{}
	p.GetRepo()
	p = nil
	p.GetRepo()
}

func TestPageBuildEvent_GetSender(tt *testing.T) {
	tt.Parallel()
	p := &PageBuildEvent{}
	p.GetSender()
	p = nil
	p.GetSender()
}

func TestPages_GetBuildType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &Pages{BuildType: &zeroValue}
	p.GetBuildType()
	p = &Pages{}
	p.GetBuildType()
	p = nil
	p.GetBuildType()
}

func TestPages_GetCNAME(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &Pages{CNAME: &zeroValue}
	p.GetCNAME()
	p = &Pages{}
	p.GetCNAME()
	p = nil
	p.GetCNAME()
}

func TestPages_GetCustom404(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &Pages{Custom404: &zeroValue}
	p.GetCustom404()
	p = &Pages{}
	p.GetCustom404()
	p = nil
	p.GetCustom404()
}

func TestPages_GetHTMLURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &Pages{HTMLURL: &zeroValue}
	p.GetHTMLURL()
	p = &Pages{}
	p.GetHTMLURL()
	p = nil
	p.GetHTMLURL()
}

func TestPages_GetHTTPSCertificate(tt *testing.T) {
	tt.Parallel()
	p := &Pages{}
	p.GetHTTPSCertificate()
	p = nil
	p.GetHTTPSCertificate()
}

func TestPages_GetHTTPSEnforced(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &Pages{HTTPSEnforced: &zeroValue}
	p.GetHTTPSEnforced()
	p = &Pages{}
	p.GetHTTPSEnforced()
	p = nil
	p.GetHTTPSEnforced()
}

func TestPages_GetPublic(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &Pages{Public: &zeroValue}
	p.GetPublic()
	p = &Pages{}
	p.GetPublic()
	p = nil
	p.GetPublic()
}

func TestPages_GetSource(tt *testing.T) {
	tt.Parallel()
	p := &Pages{}
	p.GetSource()
	p = nil
	p.GetSource()
}

func TestPages_GetStatus(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &Pages{Status: &zeroValue}
	p.GetStatus()
	p = &Pages{}
	p.GetStatus()
	p = nil
	p.GetStatus()
}

func TestPages_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &Pages{URL: &zeroValue}
	p.GetURL()
	p = &Pages{}
	p.GetURL()
	p = nil
	p.GetURL()
}

func TestPagesBuild_GetCommit(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PagesBuild{Commit: &zeroValue}
	p.GetCommit()
	p = &PagesBuild{}
	p.GetCommit()
	p = nil
	p.GetCommit()
}

func TestPagesBuild_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	p := &PagesBuild{CreatedAt: &zeroValue}
	p.GetCreatedAt()
	p = &PagesBuild{}
	p.GetCreatedAt()
	p = nil
	p.GetCreatedAt()
}

func TestPagesBuild_GetDuration(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	p := &PagesBuild{Duration: &zeroValue}
	p.GetDuration()
	p = &PagesBuild{}
	p.GetDuration()
	p = nil
	p.GetDuration()
}

func TestPagesBuild_GetError(tt *testing.T) {
	tt.Parallel()
	p := &PagesBuild{}
	p.GetError()
	p = nil
	p.GetError()
}

func TestPagesBuild_GetPusher(tt *testing.T) {
	tt.Parallel()
	p := &PagesBuild{}
	p.GetPusher()
	p = nil
	p.GetPusher()
}

func TestPagesBuild_GetStatus(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PagesBuild{Status: &zeroValue}
	p.GetStatus()
	p = &PagesBuild{}
	p.GetStatus()
	p = nil
	p.GetStatus()
}

func TestPagesBuild_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	p := &PagesBuild{UpdatedAt: &zeroValue}
	p.GetUpdatedAt()
	p = &PagesBuild{}
	p.GetUpdatedAt()
	p = nil
	p.GetUpdatedAt()
}

func TestPagesBuild_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PagesBuild{URL: &zeroValue}
	p.GetURL()
	p = &PagesBuild{}
	p.GetURL()
	p = nil
	p.GetURL()
}

func TestPagesDomain_GetCAAError(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PagesDomain{CAAError: &zeroValue}
	p.GetCAAError()
	p = &PagesDomain{}
	p.GetCAAError()
	p = nil
	p.GetCAAError()
}

func TestPagesDomain_GetDNSResolves(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &PagesDomain{DNSResolves: &zeroValue}
	p.GetDNSResolves()
	p = &PagesDomain{}
	p.GetDNSResolves()
	p = nil
	p.GetDNSResolves()
}

func TestPagesDomain_GetEnforcesHTTPS(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &PagesDomain{EnforcesHTTPS: &zeroValue}
	p.GetEnforcesHTTPS()
	p = &PagesDomain{}
	p.GetEnforcesHTTPS()
	p = nil
	p.GetEnforcesHTTPS()
}

func TestPagesDomain_GetHasCNAMERecord(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &PagesDomain{HasCNAMERecord: &zeroValue}
	p.GetHasCNAMERecord()
	p = &PagesDomain{}
	p.GetHasCNAMERecord()
	p = nil
	p.GetHasCNAMERecord()
}

func TestPagesDomain_GetHasMXRecordsPresent(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &PagesDomain{HasMXRecordsPresent: &zeroValue}
	p.GetHasMXRecordsPresent()
	p = &PagesDomain{}
	p.GetHasMXRecordsPresent()
	p = nil
	p.GetHasMXRecordsPresent()
}

func TestPagesDomain_GetHost(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PagesDomain{Host: &zeroValue}
	p.GetHost()
	p = &PagesDomain{}
	p.GetHost()
	p = nil
	p.GetHost()
}

func TestPagesDomain_GetHTTPSError(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PagesDomain{HTTPSError: &zeroValue}
	p.GetHTTPSError()
	p = &PagesDomain{}
	p.GetHTTPSError()
	p = nil
	p.GetHTTPSError()
}

func TestPagesDomain_GetIsApexDomain(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &PagesDomain{IsApexDomain: &zeroValue}
	p.GetIsApexDomain()
	p = &PagesDomain{}
	p.GetIsApexDomain()
	p = nil
	p.GetIsApexDomain()
}

func TestPagesDomain_GetIsARecord(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &PagesDomain{IsARecord: &zeroValue}
	p.GetIsARecord()
	p = &PagesDomain{}
	p.GetIsARecord()
	p = nil
	p.GetIsARecord()
}

func TestPagesDomain_GetIsCloudflareIP(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &PagesDomain{IsCloudflareIP: &zeroValue}
	p.GetIsCloudflareIP()
	p = &PagesDomain{}
	p.GetIsCloudflareIP()
	p = nil
	p.GetIsCloudflareIP()
}

func TestPagesDomain_GetIsCNAMEToFastly(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &PagesDomain{IsCNAMEToFastly: &zeroValue}
	p.GetIsCNAMEToFastly()
	p = &PagesDomain{}
	p.GetIsCNAMEToFastly()
	p = nil
	p.GetIsCNAMEToFastly()
}

func TestPagesDomain_GetIsCNAMEToGithubUserDomain(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &PagesDomain{IsCNAMEToGithubUserDomain: &zeroValue}
	p.GetIsCNAMEToGithubUserDomain()
	p = &PagesDomain{}
	p.GetIsCNAMEToGithubUserDomain()
	p = nil
	p.GetIsCNAMEToGithubUserDomain()
}

func TestPagesDomain_GetIsCNAMEToPagesDotGithubDotCom(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &PagesDomain{IsCNAMEToPagesDotGithubDotCom: &zeroValue}
	p.GetIsCNAMEToPagesDotGithubDotCom()
	p = &PagesDomain{}
	p.GetIsCNAMEToPagesDotGithubDotCom()
	p = nil
	p.GetIsCNAMEToPagesDotGithubDotCom()
}

func TestPagesDomain_GetIsFastlyIP(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &PagesDomain{IsFastlyIP: &zeroValue}
	p.GetIsFastlyIP()
	p = &PagesDomain{}
	p.GetIsFastlyIP()
	p = nil
	p.GetIsFastlyIP()
}

func TestPagesDomain_GetIsHTTPSEligible(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &PagesDomain{IsHTTPSEligible: &zeroValue}
	p.GetIsHTTPSEligible()
	p = &PagesDomain{}
	p.GetIsHTTPSEligible()
	p = nil
	p.GetIsHTTPSEligible()
}

func TestPagesDomain_GetIsNonGithubPagesIPPresent(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &PagesDomain{IsNonGithubPagesIPPresent: &zeroValue}
	p.GetIsNonGithubPagesIPPresent()
	p = &PagesDomain{}
	p.GetIsNonGithubPagesIPPresent()
	p = nil
	p.GetIsNonGithubPagesIPPresent()
}

func TestPagesDomain_GetIsOldIPAddress(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &PagesDomain{IsOldIPAddress: &zeroValue}
	p.GetIsOldIPAddress()
	p = &PagesDomain{}
	p.GetIsOldIPAddress()
	p = nil
	p.GetIsOldIPAddress()
}

func TestPagesDomain_GetIsPagesDomain(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &PagesDomain{IsPagesDomain: &zeroValue}
	p.GetIsPagesDomain()
	p = &PagesDomain{}
	p.GetIsPagesDomain()
	p = nil
	p.GetIsPagesDomain()
}

func TestPagesDomain_GetIsPointedToGithubPagesIP(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &PagesDomain{IsPointedToGithubPagesIP: &zeroValue}
	p.GetIsPointedToGithubPagesIP()
	p = &PagesDomain{}
	p.GetIsPointedToGithubPagesIP()
	p = nil
	p.GetIsPointedToGithubPagesIP()
}

func TestPagesDomain_GetIsProxied(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &PagesDomain{IsProxied: &zeroValue}
	p.GetIsProxied()
	p = &PagesDomain{}
	p.GetIsProxied()
	p = nil
	p.GetIsProxied()
}

func TestPagesDomain_GetIsServedByPages(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &PagesDomain{IsServedByPages: &zeroValue}
	p.GetIsServedByPages()
	p = &PagesDomain{}
	p.GetIsServedByPages()
	p = nil
	p.GetIsServedByPages()
}

func TestPagesDomain_GetIsValid(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &PagesDomain{IsValid: &zeroValue}
	p.GetIsValid()
	p = &PagesDomain{}
	p.GetIsValid()
	p = nil
	p.GetIsValid()
}

func TestPagesDomain_GetIsValidDomain(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &PagesDomain{IsValidDomain: &zeroValue}
	p.GetIsValidDomain()
	p = &PagesDomain{}
	p.GetIsValidDomain()
	p = nil
	p.GetIsValidDomain()
}

func TestPagesDomain_GetNameservers(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PagesDomain{Nameservers: &zeroValue}
	p.GetNameservers()
	p = &PagesDomain{}
	p.GetNameservers()
	p = nil
	p.GetNameservers()
}

func TestPagesDomain_GetReason(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PagesDomain{Reason: &zeroValue}
	p.GetReason()
	p = &PagesDomain{}
	p.GetReason()
	p = nil
	p.GetReason()
}

func TestPagesDomain_GetRespondsToHTTPS(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &PagesDomain{RespondsToHTTPS: &zeroValue}
	p.GetRespondsToHTTPS()
	p = &PagesDomain{}
	p.GetRespondsToHTTPS()
	p = nil
	p.GetRespondsToHTTPS()
}

func TestPagesDomain_GetShouldBeARecord(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &PagesDomain{ShouldBeARecord: &zeroValue}
	p.GetShouldBeARecord()
	p = &PagesDomain{}
	p.GetShouldBeARecord()
	p = nil
	p.GetShouldBeARecord()
}

func TestPagesDomain_GetURI(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PagesDomain{URI: &zeroValue}
	p.GetURI()
	p = &PagesDomain{}
	p.GetURI()
	p = nil
	p.GetURI()
}

func TestPagesError_GetMessage(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PagesError{Message: &zeroValue}
	p.GetMessage()
	p = &PagesError{}
	p.GetMessage()
	p = nil
	p.GetMessage()
}

func TestPagesHealthCheckResponse_GetAltDomain(tt *testing.T) {
	tt.Parallel()
	p := &PagesHealthCheckResponse{}
	p.GetAltDomain()
	p = nil
	p.GetAltDomain()
}

func TestPagesHealthCheckResponse_GetDomain(tt *testing.T) {
	tt.Parallel()
	p := &PagesHealthCheckResponse{}
	p.GetDomain()
	p = nil
	p.GetDomain()
}

func TestPagesHTTPSCertificate_GetDescription(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PagesHTTPSCertificate{Description: &zeroValue}
	p.GetDescription()
	p = &PagesHTTPSCertificate{}
	p.GetDescription()
	p = nil
	p.GetDescription()
}

func TestPagesHTTPSCertificate_GetDomains(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	p := &PagesHTTPSCertificate{Domains: zeroValue}
	p.GetDomains()
	p = &PagesHTTPSCertificate{}
	p.GetDomains()
	p = nil
	p.GetDomains()
}

func TestPagesHTTPSCertificate_GetExpiresAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PagesHTTPSCertificate{ExpiresAt: &zeroValue}
	p.GetExpiresAt()
	p = &PagesHTTPSCertificate{}
	p.GetExpiresAt()
	p = nil
	p.GetExpiresAt()
}

func TestPagesHTTPSCertificate_GetState(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PagesHTTPSCertificate{State: &zeroValue}
	p.GetState()
	p = &PagesHTTPSCertificate{}
	p.GetState()
	p = nil
	p.GetState()
}

func TestPagesSource_GetBranch(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PagesSource{Branch: &zeroValue}
	p.GetBranch()
	p = &PagesSource{}
	p.GetBranch()
	p = nil
	p.GetBranch()
}

func TestPagesSource_GetPath(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PagesSource{Path: &zeroValue}
	p.GetPath()
	p = &PagesSource{}
	p.GetPath()
	p = nil
	p.GetPath()
}

func TestPageStats_GetTotalPages(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	p := &PageStats{TotalPages: &zeroValue}
	p.GetTotalPages()
	p = &PageStats{}
	p.GetTotalPages()
	p = nil
	p.GetTotalPages()
}

func TestPagesUpdate_GetBuildType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PagesUpdate{BuildType: &zeroValue}
	p.GetBuildType()
	p = &PagesUpdate{}
	p.GetBuildType()
	p = nil
	p.GetBuildType()
}

func TestPagesUpdate_GetCNAME(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PagesUpdate{CNAME: &zeroValue}
	p.GetCNAME()
	p = &PagesUpdate{}
	p.GetCNAME()
	p = nil
	p.GetCNAME()
}

func TestPagesUpdate_GetHTTPSEnforced(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &PagesUpdate{HTTPSEnforced: &zeroValue}
	p.GetHTTPSEnforced()
	p = &PagesUpdate{}
	p.GetHTTPSEnforced()
	p = nil
	p.GetHTTPSEnforced()
}

func TestPagesUpdate_GetPublic(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &PagesUpdate{Public: &zeroValue}
	p.GetPublic()
	p = &PagesUpdate{}
	p.GetPublic()
	p = nil
	p.GetPublic()
}

func TestPagesUpdate_GetSource(tt *testing.T) {
	tt.Parallel()
	p := &PagesUpdate{}
	p.GetSource()
	p = nil
	p.GetSource()
}

func TestPagesUpdateWithoutCNAME_GetBuildType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PagesUpdateWithoutCNAME{BuildType: &zeroValue}
	p.GetBuildType()
	p = &PagesUpdateWithoutCNAME{}
	p.GetBuildType()
	p = nil
	p.GetBuildType()
}

func TestPagesUpdateWithoutCNAME_GetHTTPSEnforced(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &PagesUpdateWithoutCNAME{HTTPSEnforced: &zeroValue}
	p.GetHTTPSEnforced()
	p = &PagesUpdateWithoutCNAME{}
	p.GetHTTPSEnforced()
	p = nil
	p.GetHTTPSEnforced()
}

func TestPagesUpdateWithoutCNAME_GetPublic(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &PagesUpdateWithoutCNAME{Public: &zeroValue}
	p.GetPublic()
	p = &PagesUpdateWithoutCNAME{}
	p.GetPublic()
	p = nil
	p.GetPublic()
}

func TestPagesUpdateWithoutCNAME_GetSource(tt *testing.T) {
	tt.Parallel()
	p := &PagesUpdateWithoutCNAME{}
	p.GetSource()
	p = nil
	p.GetSource()
}

func TestPatternBranchRule_GetParameters(tt *testing.T) {
	tt.Parallel()
	p := &PatternBranchRule{}
	p.GetParameters()
	p = nil
	p.GetParameters()
}

func TestPatternRuleParameters_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PatternRuleParameters{Name: &zeroValue}
	p.GetName()
	p = &PatternRuleParameters{}
	p.GetName()
	p = nil
	p.GetName()
}

func TestPatternRuleParameters_GetNegate(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &PatternRuleParameters{Negate: &zeroValue}
	p.GetNegate()
	p = &PatternRuleParameters{}
	p.GetNegate()
	p = nil
	p.GetNegate()
}

func TestPatternRuleParameters_GetOperator(tt *testing.T) {
	tt.Parallel()
	p := &PatternRuleParameters{}
	p.GetOperator()
	p = nil
	p.GetOperator()
}

func TestPatternRuleParameters_GetPattern(tt *testing.T) {
	tt.Parallel()
	p := &PatternRuleParameters{}
	p.GetPattern()
	p = nil
	p.GetPattern()
}

func TestPendingDeployment_GetCurrentUserCanApprove(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &PendingDeployment{CurrentUserCanApprove: &zeroValue}
	p.GetCurrentUserCanApprove()
	p = &PendingDeployment{}
	p.GetCurrentUserCanApprove()
	p = nil
	p.GetCurrentUserCanApprove()
}

func TestPendingDeployment_GetEnvironment(tt *testing.T) {
	tt.Parallel()
	p := &PendingDeployment{}
	p.GetEnvironment()
	p = nil
	p.GetEnvironment()
}

func TestPendingDeployment_GetReviewers(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*RequiredReviewer{}
	p := &PendingDeployment{Reviewers: zeroValue}
	p.GetReviewers()
	p = &PendingDeployment{}
	p.GetReviewers()
	p = nil
	p.GetReviewers()
}

func TestPendingDeployment_GetWaitTimer(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	p := &PendingDeployment{WaitTimer: &zeroValue}
	p.GetWaitTimer()
	p = &PendingDeployment{}
	p.GetWaitTimer()
	p = nil
	p.GetWaitTimer()
}

func TestPendingDeployment_GetWaitTimerStartedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	p := &PendingDeployment{WaitTimerStartedAt: &zeroValue}
	p.GetWaitTimerStartedAt()
	p = &PendingDeployment{}
	p.GetWaitTimerStartedAt()
	p = nil
	p.GetWaitTimerStartedAt()
}

func TestPendingDeploymentEnvironment_GetHTMLURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PendingDeploymentEnvironment{HTMLURL: &zeroValue}
	p.GetHTMLURL()
	p = &PendingDeploymentEnvironment{}
	p.GetHTMLURL()
	p = nil
	p.GetHTMLURL()
}

func TestPendingDeploymentEnvironment_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	p := &PendingDeploymentEnvironment{ID: &zeroValue}
	p.GetID()
	p = &PendingDeploymentEnvironment{}
	p.GetID()
	p = nil
	p.GetID()
}

func TestPendingDeploymentEnvironment_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PendingDeploymentEnvironment{Name: &zeroValue}
	p.GetName()
	p = &PendingDeploymentEnvironment{}
	p.GetName()
	p = nil
	p.GetName()
}

func TestPendingDeploymentEnvironment_GetNodeID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PendingDeploymentEnvironment{NodeID: &zeroValue}
	p.GetNodeID()
	p = &PendingDeploymentEnvironment{}
	p.GetNodeID()
	p = nil
	p.GetNodeID()
}

func TestPendingDeploymentEnvironment_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PendingDeploymentEnvironment{URL: &zeroValue}
	p.GetURL()
	p = &PendingDeploymentEnvironment{}
	p.GetURL()
	p = nil
	p.GetURL()
}

func TestPendingDeploymentsRequest_GetComment(tt *testing.T) {
	tt.Parallel()
	p := &PendingDeploymentsRequest{}
	p.GetComment()
	p = nil
	p.GetComment()
}

func TestPendingDeploymentsRequest_GetEnvironmentIDs(tt *testing.T) {
	tt.Parallel()
	zeroValue := []int64{}
	p := &PendingDeploymentsRequest{EnvironmentIDs: zeroValue}
	p.GetEnvironmentIDs()
	p = &PendingDeploymentsRequest{}
	p.GetEnvironmentIDs()
	p = nil
	p.GetEnvironmentIDs()
}

func TestPendingDeploymentsRequest_GetState(tt *testing.T) {
	tt.Parallel()
	p := &PendingDeploymentsRequest{}
	p.GetState()
	p = nil
	p.GetState()
}

func TestPersonalAccessToken_GetAccessGrantedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	p := &PersonalAccessToken{AccessGrantedAt: &zeroValue}
	p.GetAccessGrantedAt()
	p = &PersonalAccessToken{}
	p.GetAccessGrantedAt()
	p = nil
	p.GetAccessGrantedAt()
}

func TestPersonalAccessToken_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	p := &PersonalAccessToken{ID: &zeroValue}
	p.GetID()
	p = &PersonalAccessToken{}
	p.GetID()
	p = nil
	p.GetID()
}

func TestPersonalAccessToken_GetOwner(tt *testing.T) {
	tt.Parallel()
	p := &PersonalAccessToken{}
	p.GetOwner()
	p = nil
	p.GetOwner()
}

func TestPersonalAccessToken_GetPermissions(tt *testing.T) {
	tt.Parallel()
	p := &PersonalAccessToken{}
	p.GetPermissions()
	p = nil
	p.GetPermissions()
}

func TestPersonalAccessToken_GetRepositoriesURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PersonalAccessToken{RepositoriesURL: &zeroValue}
	p.GetRepositoriesURL()
	p = &PersonalAccessToken{}
	p.GetRepositoriesURL()
	p = nil
	p.GetRepositoriesURL()
}

func TestPersonalAccessToken_GetRepositorySelection(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PersonalAccessToken{RepositorySelection: &zeroValue}
	p.GetRepositorySelection()
	p = &PersonalAccessToken{}
	p.GetRepositorySelection()
	p = nil
	p.GetRepositorySelection()
}

func TestPersonalAccessToken_GetTokenExpired(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &PersonalAccessToken{TokenExpired: &zeroValue}
	p.GetTokenExpired()
	p = &PersonalAccessToken{}
	p.GetTokenExpired()
	p = nil
	p.GetTokenExpired()
}

func TestPersonalAccessToken_GetTokenExpiresAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	p := &PersonalAccessToken{TokenExpiresAt: &zeroValue}
	p.GetTokenExpiresAt()
	p = &PersonalAccessToken{}
	p.GetTokenExpiresAt()
	p = nil
	p.GetTokenExpiresAt()
}

func TestPersonalAccessToken_GetTokenID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	p := &PersonalAccessToken{TokenID: &zeroValue}
	p.GetTokenID()
	p = &PersonalAccessToken{}
	p.GetTokenID()
	p = nil
	p.GetTokenID()
}

func TestPersonalAccessToken_GetTokenLastUsedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	p := &PersonalAccessToken{TokenLastUsedAt: &zeroValue}
	p.GetTokenLastUsedAt()
	p = &PersonalAccessToken{}
	p.GetTokenLastUsedAt()
	p = nil
	p.GetTokenLastUsedAt()
}

func TestPersonalAccessToken_GetTokenName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PersonalAccessToken{TokenName: &zeroValue}
	p.GetTokenName()
	p = &PersonalAccessToken{}
	p.GetTokenName()
	p = nil
	p.GetTokenName()
}

func TestPersonalAccessTokenPermissions_GetOrg(tt *testing.T) {
	tt.Parallel()
	zeroValue := map[string]string{}
	p := &PersonalAccessTokenPermissions{Org: zeroValue}
	p.GetOrg()
	p = &PersonalAccessTokenPermissions{}
	p.GetOrg()
	p = nil
	p.GetOrg()
}

func TestPersonalAccessTokenPermissions_GetOther(tt *testing.T) {
	tt.Parallel()
	zeroValue := map[string]string{}
	p := &PersonalAccessTokenPermissions{Other: zeroValue}
	p.GetOther()
	p = &PersonalAccessTokenPermissions{}
	p.GetOther()
	p = nil
	p.GetOther()
}

func TestPersonalAccessTokenPermissions_GetRepo(tt *testing.T) {
	tt.Parallel()
	zeroValue := map[string]string{}
	p := &PersonalAccessTokenPermissions{Repo: zeroValue}
	p.GetRepo()
	p = &PersonalAccessTokenPermissions{}
	p.GetRepo()
	p = nil
	p.GetRepo()
}

func TestPersonalAccessTokenRequest_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	p := &PersonalAccessTokenRequest{CreatedAt: &zeroValue}
	p.GetCreatedAt()
	p = &PersonalAccessTokenRequest{}
	p.GetCreatedAt()
	p = nil
	p.GetCreatedAt()
}

func TestPersonalAccessTokenRequest_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	p := &PersonalAccessTokenRequest{ID: &zeroValue}
	p.GetID()
	p = &PersonalAccessTokenRequest{}
	p.GetID()
	p = nil
	p.GetID()
}

func TestPersonalAccessTokenRequest_GetOrg(tt *testing.T) {
	tt.Parallel()
	p := &PersonalAccessTokenRequest{}
	p.GetOrg()
	p = nil
	p.GetOrg()
}

func TestPersonalAccessTokenRequest_GetOwner(tt *testing.T) {
	tt.Parallel()
	p := &PersonalAccessTokenRequest{}
	p.GetOwner()
	p = nil
	p.GetOwner()
}

func TestPersonalAccessTokenRequest_GetPermissionsAdded(tt *testing.T) {
	tt.Parallel()
	p := &PersonalAccessTokenRequest{}
	p.GetPermissionsAdded()
	p = nil
	p.GetPermissionsAdded()
}

func TestPersonalAccessTokenRequest_GetPermissionsResult(tt *testing.T) {
	tt.Parallel()
	p := &PersonalAccessTokenRequest{}
	p.GetPermissionsResult()
	p = nil
	p.GetPermissionsResult()
}

func TestPersonalAccessTokenRequest_GetPermissionsUpgraded(tt *testing.T) {
	tt.Parallel()
	p := &PersonalAccessTokenRequest{}
	p.GetPermissionsUpgraded()
	p = nil
	p.GetPermissionsUpgraded()
}

func TestPersonalAccessTokenRequest_GetRepositories(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*Repository{}
	p := &PersonalAccessTokenRequest{Repositories: zeroValue}
	p.GetRepositories()
	p = &PersonalAccessTokenRequest{}
	p.GetRepositories()
	p = nil
	p.GetRepositories()
}

func TestPersonalAccessTokenRequest_GetRepositoryCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	p := &PersonalAccessTokenRequest{RepositoryCount: &zeroValue}
	p.GetRepositoryCount()
	p = &PersonalAccessTokenRequest{}
	p.GetRepositoryCount()
	p = nil
	p.GetRepositoryCount()
}

func TestPersonalAccessTokenRequest_GetRepositorySelection(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PersonalAccessTokenRequest{RepositorySelection: &zeroValue}
	p.GetRepositorySelection()
	p = &PersonalAccessTokenRequest{}
	p.GetRepositorySelection()
	p = nil
	p.GetRepositorySelection()
}

func TestPersonalAccessTokenRequest_GetTokenExpired(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &PersonalAccessTokenRequest{TokenExpired: &zeroValue}
	p.GetTokenExpired()
	p = &PersonalAccessTokenRequest{}
	p.GetTokenExpired()
	p = nil
	p.GetTokenExpired()
}

func TestPersonalAccessTokenRequest_GetTokenExpiresAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	p := &PersonalAccessTokenRequest{TokenExpiresAt: &zeroValue}
	p.GetTokenExpiresAt()
	p = &PersonalAccessTokenRequest{}
	p.GetTokenExpiresAt()
	p = nil
	p.GetTokenExpiresAt()
}

func TestPersonalAccessTokenRequest_GetTokenLastUsedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	p := &PersonalAccessTokenRequest{TokenLastUsedAt: &zeroValue}
	p.GetTokenLastUsedAt()
	p = &PersonalAccessTokenRequest{}
	p.GetTokenLastUsedAt()
	p = nil
	p.GetTokenLastUsedAt()
}

func TestPersonalAccessTokenRequestEvent_GetAction(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PersonalAccessTokenRequestEvent{Action: &zeroValue}
	p.GetAction()
	p = &PersonalAccessTokenRequestEvent{}
	p.GetAction()
	p = nil
	p.GetAction()
}

func TestPersonalAccessTokenRequestEvent_GetInstallation(tt *testing.T) {
	tt.Parallel()
	p := &PersonalAccessTokenRequestEvent{}
	p.GetInstallation()
	p = nil
	p.GetInstallation()
}

func TestPersonalAccessTokenRequestEvent_GetOrg(tt *testing.T) {
	tt.Parallel()
	p := &PersonalAccessTokenRequestEvent{}
	p.GetOrg()
	p = nil
	p.GetOrg()
}

func TestPersonalAccessTokenRequestEvent_GetPersonalAccessTokenRequest(tt *testing.T) {
	tt.Parallel()
	p := &PersonalAccessTokenRequestEvent{}
	p.GetPersonalAccessTokenRequest()
	p = nil
	p.GetPersonalAccessTokenRequest()
}

func TestPersonalAccessTokenRequestEvent_GetSender(tt *testing.T) {
	tt.Parallel()
	p := &PersonalAccessTokenRequestEvent{}
	p.GetSender()
	p = nil
	p.GetSender()
}

func TestPingEvent_GetHook(tt *testing.T) {
	tt.Parallel()
	p := &PingEvent{}
	p.GetHook()
	p = nil
	p.GetHook()
}

func TestPingEvent_GetHookID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	p := &PingEvent{HookID: &zeroValue}
	p.GetHookID()
	p = &PingEvent{}
	p.GetHookID()
	p = nil
	p.GetHookID()
}

func TestPingEvent_GetInstallation(tt *testing.T) {
	tt.Parallel()
	p := &PingEvent{}
	p.GetInstallation()
	p = nil
	p.GetInstallation()
}

func TestPingEvent_GetOrg(tt *testing.T) {
	tt.Parallel()
	p := &PingEvent{}
	p.GetOrg()
	p = nil
	p.GetOrg()
}

func TestPingEvent_GetRepo(tt *testing.T) {
	tt.Parallel()
	p := &PingEvent{}
	p.GetRepo()
	p = nil
	p.GetRepo()
}

func TestPingEvent_GetSender(tt *testing.T) {
	tt.Parallel()
	p := &PingEvent{}
	p.GetSender()
	p = nil
	p.GetSender()
}

func TestPingEvent_GetZen(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PingEvent{Zen: &zeroValue}
	p.GetZen()
	p = &PingEvent{}
	p.GetZen()
	p = nil
	p.GetZen()
}

func TestPlan_GetCollaborators(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	p := &Plan{Collaborators: &zeroValue}
	p.GetCollaborators()
	p = &Plan{}
	p.GetCollaborators()
	p = nil
	p.GetCollaborators()
}

func TestPlan_GetFilledSeats(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	p := &Plan{FilledSeats: &zeroValue}
	p.GetFilledSeats()
	p = &Plan{}
	p.GetFilledSeats()
	p = nil
	p.GetFilledSeats()
}

func TestPlan_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &Plan{Name: &zeroValue}
	p.GetName()
	p = &Plan{}
	p.GetName()
	p = nil
	p.GetName()
}

func TestPlan_GetPrivateRepos(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	p := &Plan{PrivateRepos: &zeroValue}
	p.GetPrivateRepos()
	p = &Plan{}
	p.GetPrivateRepos()
	p = nil
	p.GetPrivateRepos()
}

func TestPlan_GetSeats(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	p := &Plan{Seats: &zeroValue}
	p.GetSeats()
	p = &Plan{}
	p.GetSeats()
	p = nil
	p.GetSeats()
}

func TestPlan_GetSpace(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	p := &Plan{Space: &zeroValue}
	p.GetSpace()
	p = &Plan{}
	p.GetSpace()
	p = nil
	p.GetSpace()
}

func TestPreferenceList_GetAutoTriggerChecks(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*AutoTriggerCheck{}
	p := &PreferenceList{AutoTriggerChecks: zeroValue}
	p.GetAutoTriggerChecks()
	p = &PreferenceList{}
	p.GetAutoTriggerChecks()
	p = nil
	p.GetAutoTriggerChecks()
}

func TestPremiumRequestUsageItem_GetDiscountAmount(tt *testing.T) {
	tt.Parallel()
	p := &PremiumRequestUsageItem{}
	p.GetDiscountAmount()
	p = nil
	p.GetDiscountAmount()
}

func TestPremiumRequestUsageItem_GetDiscountQuantity(tt *testing.T) {
	tt.Parallel()
	p := &PremiumRequestUsageItem{}
	p.GetDiscountQuantity()
	p = nil
	p.GetDiscountQuantity()
}

func TestPremiumRequestUsageItem_GetGrossAmount(tt *testing.T) {
	tt.Parallel()
	p := &PremiumRequestUsageItem{}
	p.GetGrossAmount()
	p = nil
	p.GetGrossAmount()
}

func TestPremiumRequestUsageItem_GetGrossQuantity(tt *testing.T) {
	tt.Parallel()
	p := &PremiumRequestUsageItem{}
	p.GetGrossQuantity()
	p = nil
	p.GetGrossQuantity()
}

func TestPremiumRequestUsageItem_GetModel(tt *testing.T) {
	tt.Parallel()
	p := &PremiumRequestUsageItem{}
	p.GetModel()
	p = nil
	p.GetModel()
}

func TestPremiumRequestUsageItem_GetNetAmount(tt *testing.T) {
	tt.Parallel()
	p := &PremiumRequestUsageItem{}
	p.GetNetAmount()
	p = nil
	p.GetNetAmount()
}

func TestPremiumRequestUsageItem_GetNetQuantity(tt *testing.T) {
	tt.Parallel()
	p := &PremiumRequestUsageItem{}
	p.GetNetQuantity()
	p = nil
	p.GetNetQuantity()
}

func TestPremiumRequestUsageItem_GetPricePerUnit(tt *testing.T) {
	tt.Parallel()
	p := &PremiumRequestUsageItem{}
	p.GetPricePerUnit()
	p = nil
	p.GetPricePerUnit()
}

func TestPremiumRequestUsageItem_GetProduct(tt *testing.T) {
	tt.Parallel()
	p := &PremiumRequestUsageItem{}
	p.GetProduct()
	p = nil
	p.GetProduct()
}

func TestPremiumRequestUsageItem_GetSKU(tt *testing.T) {
	tt.Parallel()
	p := &PremiumRequestUsageItem{}
	p.GetSKU()
	p = nil
	p.GetSKU()
}

func TestPremiumRequestUsageItem_GetUnitType(tt *testing.T) {
	tt.Parallel()
	p := &PremiumRequestUsageItem{}
	p.GetUnitType()
	p = nil
	p.GetUnitType()
}

func TestPremiumRequestUsageReport_GetModel(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PremiumRequestUsageReport{Model: &zeroValue}
	p.GetModel()
	p = &PremiumRequestUsageReport{}
	p.GetModel()
	p = nil
	p.GetModel()
}

func TestPremiumRequestUsageReport_GetOrganization(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PremiumRequestUsageReport{Organization: &zeroValue}
	p.GetOrganization()
	p = &PremiumRequestUsageReport{}
	p.GetOrganization()
	p = nil
	p.GetOrganization()
}

func TestPremiumRequestUsageReport_GetProduct(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PremiumRequestUsageReport{Product: &zeroValue}
	p.GetProduct()
	p = &PremiumRequestUsageReport{}
	p.GetProduct()
	p = nil
	p.GetProduct()
}

func TestPremiumRequestUsageReport_GetTimePeriod(tt *testing.T) {
	tt.Parallel()
	p := &PremiumRequestUsageReport{}
	p.GetTimePeriod()
	p = nil
	p.GetTimePeriod()
}

func TestPremiumRequestUsageReport_GetUsageItems(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*PremiumRequestUsageItem{}
	p := &PremiumRequestUsageReport{UsageItems: zeroValue}
	p.GetUsageItems()
	p = &PremiumRequestUsageReport{}
	p.GetUsageItems()
	p = nil
	p.GetUsageItems()
}

func TestPremiumRequestUsageReport_GetUser(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PremiumRequestUsageReport{User: &zeroValue}
	p.GetUser()
	p = &PremiumRequestUsageReport{}
	p.GetUser()
	p = nil
	p.GetUser()
}

func TestPremiumRequestUsageReportOptions_GetDay(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	p := &PremiumRequestUsageReportOptions{Day: &zeroValue}
	p.GetDay()
	p = &PremiumRequestUsageReportOptions{}
	p.GetDay()
	p = nil
	p.GetDay()
}

func TestPremiumRequestUsageReportOptions_GetModel(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PremiumRequestUsageReportOptions{Model: &zeroValue}
	p.GetModel()
	p = &PremiumRequestUsageReportOptions{}
	p.GetModel()
	p = nil
	p.GetModel()
}

func TestPremiumRequestUsageReportOptions_GetMonth(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	p := &PremiumRequestUsageReportOptions{Month: &zeroValue}
	p.GetMonth()
	p = &PremiumRequestUsageReportOptions{}
	p.GetMonth()
	p = nil
	p.GetMonth()
}

func TestPremiumRequestUsageReportOptions_GetProduct(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PremiumRequestUsageReportOptions{Product: &zeroValue}
	p.GetProduct()
	p = &PremiumRequestUsageReportOptions{}
	p.GetProduct()
	p = nil
	p.GetProduct()
}

func TestPremiumRequestUsageReportOptions_GetUser(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PremiumRequestUsageReportOptions{User: &zeroValue}
	p.GetUser()
	p = &PremiumRequestUsageReportOptions{}
	p.GetUser()
	p = nil
	p.GetUser()
}

func TestPremiumRequestUsageReportOptions_GetYear(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	p := &PremiumRequestUsageReportOptions{Year: &zeroValue}
	p.GetYear()
	p = &PremiumRequestUsageReportOptions{}
	p.GetYear()
	p = nil
	p.GetYear()
}

func TestPremiumRequestUsageTimePeriod_GetDay(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	p := &PremiumRequestUsageTimePeriod{Day: &zeroValue}
	p.GetDay()
	p = &PremiumRequestUsageTimePeriod{}
	p.GetDay()
	p = nil
	p.GetDay()
}

func TestPremiumRequestUsageTimePeriod_GetMonth(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	p := &PremiumRequestUsageTimePeriod{Month: &zeroValue}
	p.GetMonth()
	p = &PremiumRequestUsageTimePeriod{}
	p.GetMonth()
	p = nil
	p.GetMonth()
}

func TestPremiumRequestUsageTimePeriod_GetYear(tt *testing.T) {
	tt.Parallel()
	p := &PremiumRequestUsageTimePeriod{}
	p.GetYear()
	p = nil
	p.GetYear()
}

func TestPreReceiveHook_GetConfigURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PreReceiveHook{ConfigURL: &zeroValue}
	p.GetConfigURL()
	p = &PreReceiveHook{}
	p.GetConfigURL()
	p = nil
	p.GetConfigURL()
}

func TestPreReceiveHook_GetEnforcement(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PreReceiveHook{Enforcement: &zeroValue}
	p.GetEnforcement()
	p = &PreReceiveHook{}
	p.GetEnforcement()
	p = nil
	p.GetEnforcement()
}

func TestPreReceiveHook_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	p := &PreReceiveHook{ID: &zeroValue}
	p.GetID()
	p = &PreReceiveHook{}
	p.GetID()
	p = nil
	p.GetID()
}

func TestPreReceiveHook_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PreReceiveHook{Name: &zeroValue}
	p.GetName()
	p = &PreReceiveHook{}
	p.GetName()
	p = nil
	p.GetName()
}

func TestPrivateRegistries_GetConfigurations(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*PrivateRegistry{}
	p := &PrivateRegistries{Configurations: zeroValue}
	p.GetConfigurations()
	p = &PrivateRegistries{}
	p.GetConfigurations()
	p = nil
	p.GetConfigurations()
}

func TestPrivateRegistries_GetTotalCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	p := &PrivateRegistries{TotalCount: &zeroValue}
	p.GetTotalCount()
	p = &PrivateRegistries{}
	p.GetTotalCount()
	p = nil
	p.GetTotalCount()
}

func TestPrivateRegistry_GetAccountID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PrivateRegistry{AccountID: &zeroValue}
	p.GetAccountID()
	p = &PrivateRegistry{}
	p.GetAccountID()
	p = nil
	p.GetAccountID()
}

func TestPrivateRegistry_GetAudience(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PrivateRegistry{Audience: &zeroValue}
	p.GetAudience()
	p = &PrivateRegistry{}
	p.GetAudience()
	p = nil
	p.GetAudience()
}

func TestPrivateRegistry_GetAuthType(tt *testing.T) {
	tt.Parallel()
	p := &PrivateRegistry{}
	p.GetAuthType()
	p = nil
	p.GetAuthType()
}

func TestPrivateRegistry_GetAWSRegion(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PrivateRegistry{AWSRegion: &zeroValue}
	p.GetAWSRegion()
	p = &PrivateRegistry{}
	p.GetAWSRegion()
	p = nil
	p.GetAWSRegion()
}

func TestPrivateRegistry_GetClientID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PrivateRegistry{ClientID: &zeroValue}
	p.GetClientID()
	p = &PrivateRegistry{}
	p.GetClientID()
	p = nil
	p.GetClientID()
}

func TestPrivateRegistry_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	p := &PrivateRegistry{CreatedAt: &zeroValue}
	p.GetCreatedAt()
	p = &PrivateRegistry{}
	p.GetCreatedAt()
	p = nil
	p.GetCreatedAt()
}

func TestPrivateRegistry_GetDomain(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PrivateRegistry{Domain: &zeroValue}
	p.GetDomain()
	p = &PrivateRegistry{}
	p.GetDomain()
	p = nil
	p.GetDomain()
}

func TestPrivateRegistry_GetDomainOwner(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PrivateRegistry{DomainOwner: &zeroValue}
	p.GetDomainOwner()
	p = &PrivateRegistry{}
	p.GetDomainOwner()
	p = nil
	p.GetDomainOwner()
}

func TestPrivateRegistry_GetIdentityMappingName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PrivateRegistry{IdentityMappingName: &zeroValue}
	p.GetIdentityMappingName()
	p = &PrivateRegistry{}
	p.GetIdentityMappingName()
	p = nil
	p.GetIdentityMappingName()
}

func TestPrivateRegistry_GetJFrogOIDCProviderName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PrivateRegistry{JFrogOIDCProviderName: &zeroValue}
	p.GetJFrogOIDCProviderName()
	p = &PrivateRegistry{}
	p.GetJFrogOIDCProviderName()
	p = nil
	p.GetJFrogOIDCProviderName()
}

func TestPrivateRegistry_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PrivateRegistry{Name: &zeroValue}
	p.GetName()
	p = &PrivateRegistry{}
	p.GetName()
	p = nil
	p.GetName()
}

func TestPrivateRegistry_GetRegistryType(tt *testing.T) {
	tt.Parallel()
	p := &PrivateRegistry{}
	p.GetRegistryType()
	p = nil
	p.GetRegistryType()
}

func TestPrivateRegistry_GetReplacesBase(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &PrivateRegistry{ReplacesBase: &zeroValue}
	p.GetReplacesBase()
	p = &PrivateRegistry{}
	p.GetReplacesBase()
	p = nil
	p.GetReplacesBase()
}

func TestPrivateRegistry_GetRoleName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PrivateRegistry{RoleName: &zeroValue}
	p.GetRoleName()
	p = &PrivateRegistry{}
	p.GetRoleName()
	p = nil
	p.GetRoleName()
}

func TestPrivateRegistry_GetSelectedRepositoryIDs(tt *testing.T) {
	tt.Parallel()
	zeroValue := []int64{}
	p := &PrivateRegistry{SelectedRepositoryIDs: zeroValue}
	p.GetSelectedRepositoryIDs()
	p = &PrivateRegistry{}
	p.GetSelectedRepositoryIDs()
	p = nil
	p.GetSelectedRepositoryIDs()
}

func TestPrivateRegistry_GetTenantID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PrivateRegistry{TenantID: &zeroValue}
	p.GetTenantID()
	p = &PrivateRegistry{}
	p.GetTenantID()
	p = nil
	p.GetTenantID()
}

func TestPrivateRegistry_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	p := &PrivateRegistry{UpdatedAt: &zeroValue}
	p.GetUpdatedAt()
	p = &PrivateRegistry{}
	p.GetUpdatedAt()
	p = nil
	p.GetUpdatedAt()
}

func TestPrivateRegistry_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PrivateRegistry{URL: &zeroValue}
	p.GetURL()
	p = &PrivateRegistry{}
	p.GetURL()
	p = nil
	p.GetURL()
}

func TestPrivateRegistry_GetUsername(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PrivateRegistry{Username: &zeroValue}
	p.GetUsername()
	p = &PrivateRegistry{}
	p.GetUsername()
	p = nil
	p.GetUsername()
}

func TestPrivateRegistry_GetVisibility(tt *testing.T) {
	tt.Parallel()
	p := &PrivateRegistry{}
	p.GetVisibility()
	p = nil
	p.GetVisibility()
}

func TestPRLink_GetHRef(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PRLink{HRef: &zeroValue}
	p.GetHRef()
	p = &PRLink{}
	p.GetHRef()
	p = nil
	p.GetHRef()
}

func TestPRLinks_GetComments(tt *testing.T) {
	tt.Parallel()
	p := &PRLinks{}
	p.GetComments()
	p = nil
	p.GetComments()
}

func TestPRLinks_GetCommits(tt *testing.T) {
	tt.Parallel()
	p := &PRLinks{}
	p.GetCommits()
	p = nil
	p.GetCommits()
}

func TestPRLinks_GetHTML(tt *testing.T) {
	tt.Parallel()
	p := &PRLinks{}
	p.GetHTML()
	p = nil
	p.GetHTML()
}

func TestPRLinks_GetIssue(tt *testing.T) {
	tt.Parallel()
	p := &PRLinks{}
	p.GetIssue()
	p = nil
	p.GetIssue()
}

func TestPRLinks_GetReviewComment(tt *testing.T) {
	tt.Parallel()
	p := &PRLinks{}
	p.GetReviewComment()
	p = nil
	p.GetReviewComment()
}

func TestPRLinks_GetReviewComments(tt *testing.T) {
	tt.Parallel()
	p := &PRLinks{}
	p.GetReviewComments()
	p = nil
	p.GetReviewComments()
}

func TestPRLinks_GetSelf(tt *testing.T) {
	tt.Parallel()
	p := &PRLinks{}
	p.GetSelf()
	p = nil
	p.GetSelf()
}

func TestPRLinks_GetStatuses(tt *testing.T) {
	tt.Parallel()
	p := &PRLinks{}
	p.GetStatuses()
	p = nil
	p.GetStatuses()
}

func TestProjectBody_GetFrom(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &ProjectBody{From: &zeroValue}
	p.GetFrom()
	p = &ProjectBody{}
	p.GetFrom()
	p = nil
	p.GetFrom()
}

func TestProjectCardChange_GetNote(tt *testing.T) {
	tt.Parallel()
	p := &ProjectCardChange{}
	p.GetNote()
	p = nil
	p.GetNote()
}

func TestProjectCardNote_GetFrom(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &ProjectCardNote{From: &zeroValue}
	p.GetFrom()
	p = &ProjectCardNote{}
	p.GetFrom()
	p = nil
	p.GetFrom()
}

func TestProjectChange_GetBody(tt *testing.T) {
	tt.Parallel()
	p := &ProjectChange{}
	p.GetBody()
	p = nil
	p.GetBody()
}

func TestProjectChange_GetName(tt *testing.T) {
	tt.Parallel()
	p := &ProjectChange{}
	p.GetName()
	p = nil
	p.GetName()
}

func TestProjectColumnChange_GetName(tt *testing.T) {
	tt.Parallel()
	p := &ProjectColumnChange{}
	p.GetName()
	p = nil
	p.GetName()
}

func TestProjectColumnName_GetFrom(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &ProjectColumnName{From: &zeroValue}
	p.GetFrom()
	p = &ProjectColumnName{}
	p.GetFrom()
	p = nil
	p.GetFrom()
}

func TestProjectName_GetFrom(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &ProjectName{From: &zeroValue}
	p.GetFrom()
	p = &ProjectName{}
	p.GetFrom()
	p = nil
	p.GetFrom()
}

func TestProjectV2_GetBody(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &ProjectV2{Body: &zeroValue}
	p.GetBody()
	p = &ProjectV2{}
	p.GetBody()
	p = nil
	p.GetBody()
}

func TestProjectV2_GetClosedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	p := &ProjectV2{ClosedAt: &zeroValue}
	p.GetClosedAt()
	p = &ProjectV2{}
	p.GetClosedAt()
	p = nil
	p.GetClosedAt()
}

func TestProjectV2_GetColumnsURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &ProjectV2{ColumnsURL: &zeroValue}
	p.GetColumnsURL()
	p = &ProjectV2{}
	p.GetColumnsURL()
	p = nil
	p.GetColumnsURL()
}

func TestProjectV2_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	p := &ProjectV2{CreatedAt: &zeroValue}
	p.GetCreatedAt()
	p = &ProjectV2{}
	p.GetCreatedAt()
	p = nil
	p.GetCreatedAt()
}

func TestProjectV2_GetCreator(tt *testing.T) {
	tt.Parallel()
	p := &ProjectV2{}
	p.GetCreator()
	p = nil
	p.GetCreator()
}

func TestProjectV2_GetDeletedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	p := &ProjectV2{DeletedAt: &zeroValue}
	p.GetDeletedAt()
	p = &ProjectV2{}
	p.GetDeletedAt()
	p = nil
	p.GetDeletedAt()
}

func TestProjectV2_GetDeletedBy(tt *testing.T) {
	tt.Parallel()
	p := &ProjectV2{}
	p.GetDeletedBy()
	p = nil
	p.GetDeletedBy()
}

func TestProjectV2_GetDescription(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &ProjectV2{Description: &zeroValue}
	p.GetDescription()
	p = &ProjectV2{}
	p.GetDescription()
	p = nil
	p.GetDescription()
}

func TestProjectV2_GetHTMLURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &ProjectV2{HTMLURL: &zeroValue}
	p.GetHTMLURL()
	p = &ProjectV2{}
	p.GetHTMLURL()
	p = nil
	p.GetHTMLURL()
}

func TestProjectV2_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	p := &ProjectV2{ID: &zeroValue}
	p.GetID()
	p = &ProjectV2{}
	p.GetID()
	p = nil
	p.GetID()
}

func TestProjectV2_GetIsTemplate(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &ProjectV2{IsTemplate: &zeroValue}
	p.GetIsTemplate()
	p = &ProjectV2{}
	p.GetIsTemplate()
	p = nil
	p.GetIsTemplate()
}

func TestProjectV2_GetLatestStatusUpdate(tt *testing.T) {
	tt.Parallel()
	p := &ProjectV2{}
	p.GetLatestStatusUpdate()
	p = nil
	p.GetLatestStatusUpdate()
}

func TestProjectV2_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &ProjectV2{Name: &zeroValue}
	p.GetName()
	p = &ProjectV2{}
	p.GetName()
	p = nil
	p.GetName()
}

func TestProjectV2_GetNodeID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &ProjectV2{NodeID: &zeroValue}
	p.GetNodeID()
	p = &ProjectV2{}
	p.GetNodeID()
	p = nil
	p.GetNodeID()
}

func TestProjectV2_GetNumber(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	p := &ProjectV2{Number: &zeroValue}
	p.GetNumber()
	p = &ProjectV2{}
	p.GetNumber()
	p = nil
	p.GetNumber()
}

func TestProjectV2_GetOrganizationPermission(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &ProjectV2{OrganizationPermission: &zeroValue}
	p.GetOrganizationPermission()
	p = &ProjectV2{}
	p.GetOrganizationPermission()
	p = nil
	p.GetOrganizationPermission()
}

func TestProjectV2_GetOwner(tt *testing.T) {
	tt.Parallel()
	p := &ProjectV2{}
	p.GetOwner()
	p = nil
	p.GetOwner()
}

func TestProjectV2_GetOwnerURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &ProjectV2{OwnerURL: &zeroValue}
	p.GetOwnerURL()
	p = &ProjectV2{}
	p.GetOwnerURL()
	p = nil
	p.GetOwnerURL()
}

func TestProjectV2_GetPrivate(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &ProjectV2{Private: &zeroValue}
	p.GetPrivate()
	p = &ProjectV2{}
	p.GetPrivate()
	p = nil
	p.GetPrivate()
}

func TestProjectV2_GetPublic(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &ProjectV2{Public: &zeroValue}
	p.GetPublic()
	p = &ProjectV2{}
	p.GetPublic()
	p = nil
	p.GetPublic()
}

func TestProjectV2_GetShortDescription(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &ProjectV2{ShortDescription: &zeroValue}
	p.GetShortDescription()
	p = &ProjectV2{}
	p.GetShortDescription()
	p = nil
	p.GetShortDescription()
}

func TestProjectV2_GetState(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &ProjectV2{State: &zeroValue}
	p.GetState()
	p = &ProjectV2{}
	p.GetState()
	p = nil
	p.GetState()
}

func TestProjectV2_GetTitle(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &ProjectV2{Title: &zeroValue}
	p.GetTitle()
	p = &ProjectV2{}
	p.GetTitle()
	p = nil
	p.GetTitle()
}

func TestProjectV2_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	p := &ProjectV2{UpdatedAt: &zeroValue}
	p.GetUpdatedAt()
	p = &ProjectV2{}
	p.GetUpdatedAt()
	p = nil
	p.GetUpdatedAt()
}

func TestProjectV2_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &ProjectV2{URL: &zeroValue}
	p.GetURL()
	p = &ProjectV2{}
	p.GetURL()
	p = nil
	p.GetURL()
}

func TestProjectV2DraftIssue_GetBody(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &ProjectV2DraftIssue{Body: &zeroValue}
	p.GetBody()
	p = &ProjectV2DraftIssue{}
	p.GetBody()
	p = nil
	p.GetBody()
}

func TestProjectV2DraftIssue_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	p := &ProjectV2DraftIssue{CreatedAt: &zeroValue}
	p.GetCreatedAt()
	p = &ProjectV2DraftIssue{}
	p.GetCreatedAt()
	p = nil
	p.GetCreatedAt()
}

func TestProjectV2DraftIssue_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	p := &ProjectV2DraftIssue{ID: &zeroValue}
	p.GetID()
	p = &ProjectV2DraftIssue{}
	p.GetID()
	p = nil
	p.GetID()
}

func TestProjectV2DraftIssue_GetNodeID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &ProjectV2DraftIssue{NodeID: &zeroValue}
	p.GetNodeID()
	p = &ProjectV2DraftIssue{}
	p.GetNodeID()
	p = nil
	p.GetNodeID()
}

func TestProjectV2DraftIssue_GetTitle(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &ProjectV2DraftIssue{Title: &zeroValue}
	p.GetTitle()
	p = &ProjectV2DraftIssue{}
	p.GetTitle()
	p = nil
	p.GetTitle()
}

func TestProjectV2DraftIssue_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	p := &ProjectV2DraftIssue{UpdatedAt: &zeroValue}
	p.GetUpdatedAt()
	p = &ProjectV2DraftIssue{}
	p.GetUpdatedAt()
	p = nil
	p.GetUpdatedAt()
}

func TestProjectV2DraftIssue_GetUser(tt *testing.T) {
	tt.Parallel()
	p := &ProjectV2DraftIssue{}
	p.GetUser()
	p = nil
	p.GetUser()
}

func TestProjectV2Event_GetAction(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &ProjectV2Event{Action: &zeroValue}
	p.GetAction()
	p = &ProjectV2Event{}
	p.GetAction()
	p = nil
	p.GetAction()
}

func TestProjectV2Event_GetInstallation(tt *testing.T) {
	tt.Parallel()
	p := &ProjectV2Event{}
	p.GetInstallation()
	p = nil
	p.GetInstallation()
}

func TestProjectV2Event_GetOrg(tt *testing.T) {
	tt.Parallel()
	p := &ProjectV2Event{}
	p.GetOrg()
	p = nil
	p.GetOrg()
}

func TestProjectV2Event_GetProjectsV2(tt *testing.T) {
	tt.Parallel()
	p := &ProjectV2Event{}
	p.GetProjectsV2()
	p = nil
	p.GetProjectsV2()
}

func TestProjectV2Event_GetSender(tt *testing.T) {
	tt.Parallel()
	p := &ProjectV2Event{}
	p.GetSender()
	p = nil
	p.GetSender()
}

func TestProjectV2Field_GetConfiguration(tt *testing.T) {
	tt.Parallel()
	p := &ProjectV2Field{}
	p.GetConfiguration()
	p = nil
	p.GetConfiguration()
}

func TestProjectV2Field_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	p := &ProjectV2Field{CreatedAt: &zeroValue}
	p.GetCreatedAt()
	p = &ProjectV2Field{}
	p.GetCreatedAt()
	p = nil
	p.GetCreatedAt()
}

func TestProjectV2Field_GetDataType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &ProjectV2Field{DataType: &zeroValue}
	p.GetDataType()
	p = &ProjectV2Field{}
	p.GetDataType()
	p = nil
	p.GetDataType()
}

func TestProjectV2Field_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	p := &ProjectV2Field{ID: &zeroValue}
	p.GetID()
	p = &ProjectV2Field{}
	p.GetID()
	p = nil
	p.GetID()
}

func TestProjectV2Field_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &ProjectV2Field{Name: &zeroValue}
	p.GetName()
	p = &ProjectV2Field{}
	p.GetName()
	p = nil
	p.GetName()
}

func TestProjectV2Field_GetNodeID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &ProjectV2Field{NodeID: &zeroValue}
	p.GetNodeID()
	p = &ProjectV2Field{}
	p.GetNodeID()
	p = nil
	p.GetNodeID()
}

func TestProjectV2Field_GetOptions(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*ProjectV2FieldOption{}
	p := &ProjectV2Field{Options: zeroValue}
	p.GetOptions()
	p = &ProjectV2Field{}
	p.GetOptions()
	p = nil
	p.GetOptions()
}

func TestProjectV2Field_GetProjectURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &ProjectV2Field{ProjectURL: &zeroValue}
	p.GetProjectURL()
	p = &ProjectV2Field{}
	p.GetProjectURL()
	p = nil
	p.GetProjectURL()
}

func TestProjectV2Field_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	p := &ProjectV2Field{UpdatedAt: &zeroValue}
	p.GetUpdatedAt()
	p = &ProjectV2Field{}
	p.GetUpdatedAt()
	p = nil
	p.GetUpdatedAt()
}

func TestProjectV2FieldConfiguration_GetDuration(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	p := &ProjectV2FieldConfiguration{Duration: &zeroValue}
	p.GetDuration()
	p = &ProjectV2FieldConfiguration{}
	p.GetDuration()
	p = nil
	p.GetDuration()
}

func TestProjectV2FieldConfiguration_GetIterations(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*ProjectV2FieldIteration{}
	p := &ProjectV2FieldConfiguration{Iterations: zeroValue}
	p.GetIterations()
	p = &ProjectV2FieldConfiguration{}
	p.GetIterations()
	p = nil
	p.GetIterations()
}

func TestProjectV2FieldConfiguration_GetStartDay(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	p := &ProjectV2FieldConfiguration{StartDay: &zeroValue}
	p.GetStartDay()
	p = &ProjectV2FieldConfiguration{}
	p.GetStartDay()
	p = nil
	p.GetStartDay()
}

func TestProjectV2FieldIteration_GetDuration(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	p := &ProjectV2FieldIteration{Duration: &zeroValue}
	p.GetDuration()
	p = &ProjectV2FieldIteration{}
	p.GetDuration()
	p = nil
	p.GetDuration()
}

func TestProjectV2FieldIteration_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &ProjectV2FieldIteration{ID: &zeroValue}
	p.GetID()
	p = &ProjectV2FieldIteration{}
	p.GetID()
	p = nil
	p.GetID()
}

func TestProjectV2FieldIteration_GetStartDate(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &ProjectV2FieldIteration{StartDate: &zeroValue}
	p.GetStartDate()
	p = &ProjectV2FieldIteration{}
	p.GetStartDate()
	p = nil
	p.GetStartDate()
}

func TestProjectV2FieldIteration_GetTitle(tt *testing.T) {
	tt.Parallel()
	p := &ProjectV2FieldIteration{}
	p.GetTitle()
	p = nil
	p.GetTitle()
}

func TestProjectV2FieldIterationConfiguration_GetDuration(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	p := &ProjectV2FieldIterationConfiguration{Duration: &zeroValue}
	p.GetDuration()
	p = &ProjectV2FieldIterationConfiguration{}
	p.GetDuration()
	p = nil
	p.GetDuration()
}

func TestProjectV2FieldIterationConfiguration_GetIterations(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*ProjectV2FieldIterationConfigurationIteration{}
	p := &ProjectV2FieldIterationConfiguration{Iterations: zeroValue}
	p.GetIterations()
	p = &ProjectV2FieldIterationConfiguration{}
	p.GetIterations()
	p = nil
	p.GetIterations()
}

func TestProjectV2FieldIterationConfiguration_GetStartDate(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &ProjectV2FieldIterationConfiguration{StartDate: &zeroValue}
	p.GetStartDate()
	p = &ProjectV2FieldIterationConfiguration{}
	p.GetStartDate()
	p = nil
	p.GetStartDate()
}

func TestProjectV2FieldIterationConfigurationIteration_GetDuration(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	p := &ProjectV2FieldIterationConfigurationIteration{Duration: &zeroValue}
	p.GetDuration()
	p = &ProjectV2FieldIterationConfigurationIteration{}
	p.GetDuration()
	p = nil
	p.GetDuration()
}

func TestProjectV2FieldIterationConfigurationIteration_GetStartDate(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &ProjectV2FieldIterationConfigurationIteration{StartDate: &zeroValue}
	p.GetStartDate()
	p = &ProjectV2FieldIterationConfigurationIteration{}
	p.GetStartDate()
	p = nil
	p.GetStartDate()
}

func TestProjectV2FieldIterationConfigurationIteration_GetTitle(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &ProjectV2FieldIterationConfigurationIteration{Title: &zeroValue}
	p.GetTitle()
	p = &ProjectV2FieldIterationConfigurationIteration{}
	p.GetTitle()
	p = nil
	p.GetTitle()
}

func TestProjectV2FieldOption_GetColor(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &ProjectV2FieldOption{Color: &zeroValue}
	p.GetColor()
	p = &ProjectV2FieldOption{}
	p.GetColor()
	p = nil
	p.GetColor()
}

func TestProjectV2FieldOption_GetDescription(tt *testing.T) {
	tt.Parallel()
	p := &ProjectV2FieldOption{}
	p.GetDescription()
	p = nil
	p.GetDescription()
}

func TestProjectV2FieldOption_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &ProjectV2FieldOption{ID: &zeroValue}
	p.GetID()
	p = &ProjectV2FieldOption{}
	p.GetID()
	p = nil
	p.GetID()
}

func TestProjectV2FieldOption_GetName(tt *testing.T) {
	tt.Parallel()
	p := &ProjectV2FieldOption{}
	p.GetName()
	p = nil
	p.GetName()
}

func TestProjectV2FieldSingleSelectOption_GetColor(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &ProjectV2FieldSingleSelectOption{Color: &zeroValue}
	p.GetColor()
	p = &ProjectV2FieldSingleSelectOption{}
	p.GetColor()
	p = nil
	p.GetColor()
}

func TestProjectV2FieldSingleSelectOption_GetDescription(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &ProjectV2FieldSingleSelectOption{Description: &zeroValue}
	p.GetDescription()
	p = &ProjectV2FieldSingleSelectOption{}
	p.GetDescription()
	p = nil
	p.GetDescription()
}

func TestProjectV2FieldSingleSelectOption_GetName(tt *testing.T) {
	tt.Parallel()
	p := &ProjectV2FieldSingleSelectOption{}
	p.GetName()
	p = nil
	p.GetName()
}

func TestProjectV2Item_GetArchivedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	p := &ProjectV2Item{ArchivedAt: &zeroValue}
	p.GetArchivedAt()
	p = &ProjectV2Item{}
	p.GetArchivedAt()
	p = nil
	p.GetArchivedAt()
}

func TestProjectV2Item_GetContent(tt *testing.T) {
	tt.Parallel()
	p := &ProjectV2Item{}
	p.GetContent()
	p = nil
	p.GetContent()
}

func TestProjectV2Item_GetContentNodeID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &ProjectV2Item{ContentNodeID: &zeroValue}
	p.GetContentNodeID()
	p = &ProjectV2Item{}
	p.GetContentNodeID()
	p = nil
	p.GetContentNodeID()
}

func TestProjectV2Item_GetContentType(tt *testing.T) {
	tt.Parallel()
	p := &ProjectV2Item{}
	p.GetContentType()
	p = nil
	p.GetContentType()
}

func TestProjectV2Item_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	p := &ProjectV2Item{CreatedAt: &zeroValue}
	p.GetCreatedAt()
	p = &ProjectV2Item{}
	p.GetCreatedAt()
	p = nil
	p.GetCreatedAt()
}

func TestProjectV2Item_GetCreator(tt *testing.T) {
	tt.Parallel()
	p := &ProjectV2Item{}
	p.GetCreator()
	p = nil
	p.GetCreator()
}

func TestProjectV2Item_GetFields(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*ProjectV2ItemFieldValue{}
	p := &ProjectV2Item{Fields: zeroValue}
	p.GetFields()
	p = &ProjectV2Item{}
	p.GetFields()
	p = nil
	p.GetFields()
}

func TestProjectV2Item_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	p := &ProjectV2Item{ID: &zeroValue}
	p.GetID()
	p = &ProjectV2Item{}
	p.GetID()
	p = nil
	p.GetID()
}

func TestProjectV2Item_GetItemURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &ProjectV2Item{ItemURL: &zeroValue}
	p.GetItemURL()
	p = &ProjectV2Item{}
	p.GetItemURL()
	p = nil
	p.GetItemURL()
}

func TestProjectV2Item_GetNodeID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &ProjectV2Item{NodeID: &zeroValue}
	p.GetNodeID()
	p = &ProjectV2Item{}
	p.GetNodeID()
	p = nil
	p.GetNodeID()
}

func TestProjectV2Item_GetProjectNodeID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &ProjectV2Item{ProjectNodeID: &zeroValue}
	p.GetProjectNodeID()
	p = &ProjectV2Item{}
	p.GetProjectNodeID()
	p = nil
	p.GetProjectNodeID()
}

func TestProjectV2Item_GetProjectURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &ProjectV2Item{ProjectURL: &zeroValue}
	p.GetProjectURL()
	p = &ProjectV2Item{}
	p.GetProjectURL()
	p = nil
	p.GetProjectURL()
}

func TestProjectV2Item_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	p := &ProjectV2Item{UpdatedAt: &zeroValue}
	p.GetUpdatedAt()
	p = &ProjectV2Item{}
	p.GetUpdatedAt()
	p = nil
	p.GetUpdatedAt()
}

func TestProjectV2ItemChange_GetArchivedAt(tt *testing.T) {
	tt.Parallel()
	p := &ProjectV2ItemChange{}
	p.GetArchivedAt()
	p = nil
	p.GetArchivedAt()
}

func TestProjectV2ItemChange_GetFieldValue(tt *testing.T) {
	tt.Parallel()
	p := &ProjectV2ItemChange{}
	p.GetFieldValue()
	p = nil
	p.GetFieldValue()
}

func TestProjectV2ItemContent_GetDraftIssue(tt *testing.T) {
	tt.Parallel()
	p := &ProjectV2ItemContent{}
	p.GetDraftIssue()
	p = nil
	p.GetDraftIssue()
}

func TestProjectV2ItemContent_GetIssue(tt *testing.T) {
	tt.Parallel()
	p := &ProjectV2ItemContent{}
	p.GetIssue()
	p = nil
	p.GetIssue()
}

func TestProjectV2ItemContent_GetPullRequest(tt *testing.T) {
	tt.Parallel()
	p := &ProjectV2ItemContent{}
	p.GetPullRequest()
	p = nil
	p.GetPullRequest()
}

func TestProjectV2ItemEvent_GetAction(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &ProjectV2ItemEvent{Action: &zeroValue}
	p.GetAction()
	p = &ProjectV2ItemEvent{}
	p.GetAction()
	p = nil
	p.GetAction()
}

func TestProjectV2ItemEvent_GetChanges(tt *testing.T) {
	tt.Parallel()
	p := &ProjectV2ItemEvent{}
	p.GetChanges()
	p = nil
	p.GetChanges()
}

func TestProjectV2ItemEvent_GetInstallation(tt *testing.T) {
	tt.Parallel()
	p := &ProjectV2ItemEvent{}
	p.GetInstallation()
	p = nil
	p.GetInstallation()
}

func TestProjectV2ItemEvent_GetOrg(tt *testing.T) {
	tt.Parallel()
	p := &ProjectV2ItemEvent{}
	p.GetOrg()
	p = nil
	p.GetOrg()
}

func TestProjectV2ItemEvent_GetProjectV2Item(tt *testing.T) {
	tt.Parallel()
	p := &ProjectV2ItemEvent{}
	p.GetProjectV2Item()
	p = nil
	p.GetProjectV2Item()
}

func TestProjectV2ItemEvent_GetSender(tt *testing.T) {
	tt.Parallel()
	p := &ProjectV2ItemEvent{}
	p.GetSender()
	p = nil
	p.GetSender()
}

func TestProjectV2ItemFieldValue_GetDataType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &ProjectV2ItemFieldValue{DataType: &zeroValue}
	p.GetDataType()
	p = &ProjectV2ItemFieldValue{}
	p.GetDataType()
	p = nil
	p.GetDataType()
}

func TestProjectV2ItemFieldValue_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	p := &ProjectV2ItemFieldValue{ID: &zeroValue}
	p.GetID()
	p = &ProjectV2ItemFieldValue{}
	p.GetID()
	p = nil
	p.GetID()
}

func TestProjectV2ItemFieldValue_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &ProjectV2ItemFieldValue{Name: &zeroValue}
	p.GetName()
	p = &ProjectV2ItemFieldValue{}
	p.GetName()
	p = nil
	p.GetName()
}

func TestProjectV2ItemFieldValue_GetValue(tt *testing.T) {
	tt.Parallel()
	p := &ProjectV2ItemFieldValue{}
	p.GetValue()
	p = nil
	p.GetValue()
}

func TestProjectV2StatusUpdate_GetBody(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &ProjectV2StatusUpdate{Body: &zeroValue}
	p.GetBody()
	p = &ProjectV2StatusUpdate{}
	p.GetBody()
	p = nil
	p.GetBody()
}

func TestProjectV2StatusUpdate_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	p := &ProjectV2StatusUpdate{CreatedAt: &zeroValue}
	p.GetCreatedAt()
	p = &ProjectV2StatusUpdate{}
	p.GetCreatedAt()
	p = nil
	p.GetCreatedAt()
}

func TestProjectV2StatusUpdate_GetCreator(tt *testing.T) {
	tt.Parallel()
	p := &ProjectV2StatusUpdate{}
	p.GetCreator()
	p = nil
	p.GetCreator()
}

func TestProjectV2StatusUpdate_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	p := &ProjectV2StatusUpdate{ID: &zeroValue}
	p.GetID()
	p = &ProjectV2StatusUpdate{}
	p.GetID()
	p = nil
	p.GetID()
}

func TestProjectV2StatusUpdate_GetNodeID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &ProjectV2StatusUpdate{NodeID: &zeroValue}
	p.GetNodeID()
	p = &ProjectV2StatusUpdate{}
	p.GetNodeID()
	p = nil
	p.GetNodeID()
}

func TestProjectV2StatusUpdate_GetProjectNodeID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &ProjectV2StatusUpdate{ProjectNodeID: &zeroValue}
	p.GetProjectNodeID()
	p = &ProjectV2StatusUpdate{}
	p.GetProjectNodeID()
	p = nil
	p.GetProjectNodeID()
}

func TestProjectV2StatusUpdate_GetStartDate(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &ProjectV2StatusUpdate{StartDate: &zeroValue}
	p.GetStartDate()
	p = &ProjectV2StatusUpdate{}
	p.GetStartDate()
	p = nil
	p.GetStartDate()
}

func TestProjectV2StatusUpdate_GetStatus(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &ProjectV2StatusUpdate{Status: &zeroValue}
	p.GetStatus()
	p = &ProjectV2StatusUpdate{}
	p.GetStatus()
	p = nil
	p.GetStatus()
}

func TestProjectV2StatusUpdate_GetTargetDate(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &ProjectV2StatusUpdate{TargetDate: &zeroValue}
	p.GetTargetDate()
	p = &ProjectV2StatusUpdate{}
	p.GetTargetDate()
	p = nil
	p.GetTargetDate()
}

func TestProjectV2StatusUpdate_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	p := &ProjectV2StatusUpdate{UpdatedAt: &zeroValue}
	p.GetUpdatedAt()
	p = &ProjectV2StatusUpdate{}
	p.GetUpdatedAt()
	p = nil
	p.GetUpdatedAt()
}

func TestProjectV2TextContent_GetHTML(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &ProjectV2TextContent{HTML: &zeroValue}
	p.GetHTML()
	p = &ProjectV2TextContent{}
	p.GetHTML()
	p = nil
	p.GetHTML()
}

func TestProjectV2TextContent_GetRaw(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &ProjectV2TextContent{Raw: &zeroValue}
	p.GetRaw()
	p = &ProjectV2TextContent{}
	p.GetRaw()
	p = nil
	p.GetRaw()
}

func TestProjectV2View_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	p := &ProjectV2View{}
	p.GetCreatedAt()
	p = nil
	p.GetCreatedAt()
}

func TestProjectV2View_GetCreator(tt *testing.T) {
	tt.Parallel()
	p := &ProjectV2View{}
	p.GetCreator()
	p = nil
	p.GetCreator()
}

func TestProjectV2View_GetFilter(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &ProjectV2View{Filter: &zeroValue}
	p.GetFilter()
	p = &ProjectV2View{}
	p.GetFilter()
	p = nil
	p.GetFilter()
}

func TestProjectV2View_GetGroupBy(tt *testing.T) {
	tt.Parallel()
	zeroValue := []int64{}
	p := &ProjectV2View{GroupBy: zeroValue}
	p.GetGroupBy()
	p = &ProjectV2View{}
	p.GetGroupBy()
	p = nil
	p.GetGroupBy()
}

func TestProjectV2View_GetHTMLURL(tt *testing.T) {
	tt.Parallel()
	p := &ProjectV2View{}
	p.GetHTMLURL()
	p = nil
	p.GetHTMLURL()
}

func TestProjectV2View_GetID(tt *testing.T) {
	tt.Parallel()
	p := &ProjectV2View{}
	p.GetID()
	p = nil
	p.GetID()
}

func TestProjectV2View_GetLayout(tt *testing.T) {
	tt.Parallel()
	p := &ProjectV2View{}
	p.GetLayout()
	p = nil
	p.GetLayout()
}

func TestProjectV2View_GetName(tt *testing.T) {
	tt.Parallel()
	p := &ProjectV2View{}
	p.GetName()
	p = nil
	p.GetName()
}

func TestProjectV2View_GetNodeID(tt *testing.T) {
	tt.Parallel()
	p := &ProjectV2View{}
	p.GetNodeID()
	p = nil
	p.GetNodeID()
}

func TestProjectV2View_GetNumber(tt *testing.T) {
	tt.Parallel()
	p := &ProjectV2View{}
	p.GetNumber()
	p = nil
	p.GetNumber()
}

func TestProjectV2View_GetProjectURL(tt *testing.T) {
	tt.Parallel()
	p := &ProjectV2View{}
	p.GetProjectURL()
	p = nil
	p.GetProjectURL()
}

func TestProjectV2View_GetSortBy(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*ProjectV2ViewSortBy{}
	p := &ProjectV2View{SortBy: zeroValue}
	p.GetSortBy()
	p = &ProjectV2View{}
	p.GetSortBy()
	p = nil
	p.GetSortBy()
}

func TestProjectV2View_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	p := &ProjectV2View{}
	p.GetUpdatedAt()
	p = nil
	p.GetUpdatedAt()
}

func TestProjectV2View_GetVerticalGroupBy(tt *testing.T) {
	tt.Parallel()
	zeroValue := []int64{}
	p := &ProjectV2View{VerticalGroupBy: zeroValue}
	p.GetVerticalGroupBy()
	p = &ProjectV2View{}
	p.GetVerticalGroupBy()
	p = nil
	p.GetVerticalGroupBy()
}

func TestProjectV2View_GetVisibleFields(tt *testing.T) {
	tt.Parallel()
	zeroValue := []int64{}
	p := &ProjectV2View{VisibleFields: zeroValue}
	p.GetVisibleFields()
	p = &ProjectV2View{}
	p.GetVisibleFields()
	p = nil
	p.GetVisibleFields()
}

func TestProjectV2ViewSortBy_GetDirection(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &ProjectV2ViewSortBy{Direction: &zeroValue}
	p.GetDirection()
	p = &ProjectV2ViewSortBy{}
	p.GetDirection()
	p = nil
	p.GetDirection()
}

func TestProjectV2ViewSortBy_GetFieldID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	p := &ProjectV2ViewSortBy{FieldID: &zeroValue}
	p.GetFieldID()
	p = &ProjectV2ViewSortBy{}
	p.GetFieldID()
	p = nil
	p.GetFieldID()
}

func TestProtection_GetAllowDeletions(tt *testing.T) {
	tt.Parallel()
	p := &Protection{}
	p.GetAllowDeletions()
	p = nil
	p.GetAllowDeletions()
}

func TestProtection_GetAllowForcePushes(tt *testing.T) {
	tt.Parallel()
	p := &Protection{}
	p.GetAllowForcePushes()
	p = nil
	p.GetAllowForcePushes()
}

func TestProtection_GetAllowForkSyncing(tt *testing.T) {
	tt.Parallel()
	p := &Protection{}
	p.GetAllowForkSyncing()
	p = nil
	p.GetAllowForkSyncing()
}

func TestProtection_GetBlockCreations(tt *testing.T) {
	tt.Parallel()
	p := &Protection{}
	p.GetBlockCreations()
	p = nil
	p.GetBlockCreations()
}

func TestProtection_GetEnforceAdmins(tt *testing.T) {
	tt.Parallel()
	p := &Protection{}
	p.GetEnforceAdmins()
	p = nil
	p.GetEnforceAdmins()
}

func TestProtection_GetLockBranch(tt *testing.T) {
	tt.Parallel()
	p := &Protection{}
	p.GetLockBranch()
	p = nil
	p.GetLockBranch()
}

func TestProtection_GetRequiredConversationResolution(tt *testing.T) {
	tt.Parallel()
	p := &Protection{}
	p.GetRequiredConversationResolution()
	p = nil
	p.GetRequiredConversationResolution()
}

func TestProtection_GetRequiredPullRequestReviews(tt *testing.T) {
	tt.Parallel()
	p := &Protection{}
	p.GetRequiredPullRequestReviews()
	p = nil
	p.GetRequiredPullRequestReviews()
}

func TestProtection_GetRequiredSignatures(tt *testing.T) {
	tt.Parallel()
	p := &Protection{}
	p.GetRequiredSignatures()
	p = nil
	p.GetRequiredSignatures()
}

func TestProtection_GetRequiredStatusChecks(tt *testing.T) {
	tt.Parallel()
	p := &Protection{}
	p.GetRequiredStatusChecks()
	p = nil
	p.GetRequiredStatusChecks()
}

func TestProtection_GetRequireLinearHistory(tt *testing.T) {
	tt.Parallel()
	p := &Protection{}
	p.GetRequireLinearHistory()
	p = nil
	p.GetRequireLinearHistory()
}

func TestProtection_GetRestrictions(tt *testing.T) {
	tt.Parallel()
	p := &Protection{}
	p.GetRestrictions()
	p = nil
	p.GetRestrictions()
}

func TestProtection_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &Protection{URL: &zeroValue}
	p.GetURL()
	p = &Protection{}
	p.GetURL()
	p = nil
	p.GetURL()
}

func TestProtectionChanges_GetAdminEnforced(tt *testing.T) {
	tt.Parallel()
	p := &ProtectionChanges{}
	p.GetAdminEnforced()
	p = nil
	p.GetAdminEnforced()
}

func TestProtectionChanges_GetAllowDeletionsEnforcementLevel(tt *testing.T) {
	tt.Parallel()
	p := &ProtectionChanges{}
	p.GetAllowDeletionsEnforcementLevel()
	p = nil
	p.GetAllowDeletionsEnforcementLevel()
}

func TestProtectionChanges_GetAuthorizedActorNames(tt *testing.T) {
	tt.Parallel()
	p := &ProtectionChanges{}
	p.GetAuthorizedActorNames()
	p = nil
	p.GetAuthorizedActorNames()
}

func TestProtectionChanges_GetAuthorizedActorsOnly(tt *testing.T) {
	tt.Parallel()
	p := &ProtectionChanges{}
	p.GetAuthorizedActorsOnly()
	p = nil
	p.GetAuthorizedActorsOnly()
}

func TestProtectionChanges_GetAuthorizedDismissalActorsOnly(tt *testing.T) {
	tt.Parallel()
	p := &ProtectionChanges{}
	p.GetAuthorizedDismissalActorsOnly()
	p = nil
	p.GetAuthorizedDismissalActorsOnly()
}

func TestProtectionChanges_GetCreateProtected(tt *testing.T) {
	tt.Parallel()
	p := &ProtectionChanges{}
	p.GetCreateProtected()
	p = nil
	p.GetCreateProtected()
}

func TestProtectionChanges_GetDismissStaleReviewsOnPush(tt *testing.T) {
	tt.Parallel()
	p := &ProtectionChanges{}
	p.GetDismissStaleReviewsOnPush()
	p = nil
	p.GetDismissStaleReviewsOnPush()
}

func TestProtectionChanges_GetLinearHistoryRequirementEnforcementLevel(tt *testing.T) {
	tt.Parallel()
	p := &ProtectionChanges{}
	p.GetLinearHistoryRequirementEnforcementLevel()
	p = nil
	p.GetLinearHistoryRequirementEnforcementLevel()
}

func TestProtectionChanges_GetPullRequestReviewsEnforcementLevel(tt *testing.T) {
	tt.Parallel()
	p := &ProtectionChanges{}
	p.GetPullRequestReviewsEnforcementLevel()
	p = nil
	p.GetPullRequestReviewsEnforcementLevel()
}

func TestProtectionChanges_GetRequireCodeOwnerReview(tt *testing.T) {
	tt.Parallel()
	p := &ProtectionChanges{}
	p.GetRequireCodeOwnerReview()
	p = nil
	p.GetRequireCodeOwnerReview()
}

func TestProtectionChanges_GetRequiredConversationResolutionLevel(tt *testing.T) {
	tt.Parallel()
	p := &ProtectionChanges{}
	p.GetRequiredConversationResolutionLevel()
	p = nil
	p.GetRequiredConversationResolutionLevel()
}

func TestProtectionChanges_GetRequiredDeploymentsEnforcementLevel(tt *testing.T) {
	tt.Parallel()
	p := &ProtectionChanges{}
	p.GetRequiredDeploymentsEnforcementLevel()
	p = nil
	p.GetRequiredDeploymentsEnforcementLevel()
}

func TestProtectionChanges_GetRequiredStatusChecks(tt *testing.T) {
	tt.Parallel()
	p := &ProtectionChanges{}
	p.GetRequiredStatusChecks()
	p = nil
	p.GetRequiredStatusChecks()
}

func TestProtectionChanges_GetRequiredStatusChecksEnforcementLevel(tt *testing.T) {
	tt.Parallel()
	p := &ProtectionChanges{}
	p.GetRequiredStatusChecksEnforcementLevel()
	p = nil
	p.GetRequiredStatusChecksEnforcementLevel()
}

func TestProtectionChanges_GetRequireLastPushApproval(tt *testing.T) {
	tt.Parallel()
	p := &ProtectionChanges{}
	p.GetRequireLastPushApproval()
	p = nil
	p.GetRequireLastPushApproval()
}

func TestProtectionChanges_GetSignatureRequirementEnforcementLevel(tt *testing.T) {
	tt.Parallel()
	p := &ProtectionChanges{}
	p.GetSignatureRequirementEnforcementLevel()
	p = nil
	p.GetSignatureRequirementEnforcementLevel()
}

func TestProtectionRequest_GetAllowDeletions(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &ProtectionRequest{AllowDeletions: &zeroValue}
	p.GetAllowDeletions()
	p = &ProtectionRequest{}
	p.GetAllowDeletions()
	p = nil
	p.GetAllowDeletions()
}

func TestProtectionRequest_GetAllowForcePushes(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &ProtectionRequest{AllowForcePushes: &zeroValue}
	p.GetAllowForcePushes()
	p = &ProtectionRequest{}
	p.GetAllowForcePushes()
	p = nil
	p.GetAllowForcePushes()
}

func TestProtectionRequest_GetAllowForkSyncing(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &ProtectionRequest{AllowForkSyncing: &zeroValue}
	p.GetAllowForkSyncing()
	p = &ProtectionRequest{}
	p.GetAllowForkSyncing()
	p = nil
	p.GetAllowForkSyncing()
}

func TestProtectionRequest_GetBlockCreations(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &ProtectionRequest{BlockCreations: &zeroValue}
	p.GetBlockCreations()
	p = &ProtectionRequest{}
	p.GetBlockCreations()
	p = nil
	p.GetBlockCreations()
}

func TestProtectionRequest_GetEnforceAdmins(tt *testing.T) {
	tt.Parallel()
	p := &ProtectionRequest{}
	p.GetEnforceAdmins()
	p = nil
	p.GetEnforceAdmins()
}

func TestProtectionRequest_GetLockBranch(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &ProtectionRequest{LockBranch: &zeroValue}
	p.GetLockBranch()
	p = &ProtectionRequest{}
	p.GetLockBranch()
	p = nil
	p.GetLockBranch()
}

func TestProtectionRequest_GetRequiredConversationResolution(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &ProtectionRequest{RequiredConversationResolution: &zeroValue}
	p.GetRequiredConversationResolution()
	p = &ProtectionRequest{}
	p.GetRequiredConversationResolution()
	p = nil
	p.GetRequiredConversationResolution()
}

func TestProtectionRequest_GetRequiredPullRequestReviews(tt *testing.T) {
	tt.Parallel()
	p := &ProtectionRequest{}
	p.GetRequiredPullRequestReviews()
	p = nil
	p.GetRequiredPullRequestReviews()
}

func TestProtectionRequest_GetRequiredStatusChecks(tt *testing.T) {
	tt.Parallel()
	p := &ProtectionRequest{}
	p.GetRequiredStatusChecks()
	p = nil
	p.GetRequiredStatusChecks()
}

func TestProtectionRequest_GetRequireLinearHistory(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &ProtectionRequest{RequireLinearHistory: &zeroValue}
	p.GetRequireLinearHistory()
	p = &ProtectionRequest{}
	p.GetRequireLinearHistory()
	p = nil
	p.GetRequireLinearHistory()
}

func TestProtectionRequest_GetRestrictions(tt *testing.T) {
	tt.Parallel()
	p := &ProtectionRequest{}
	p.GetRestrictions()
	p = nil
	p.GetRestrictions()
}

func TestProtectionRule_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	p := &ProtectionRule{ID: &zeroValue}
	p.GetID()
	p = &ProtectionRule{}
	p.GetID()
	p = nil
	p.GetID()
}

func TestProtectionRule_GetNodeID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &ProtectionRule{NodeID: &zeroValue}
	p.GetNodeID()
	p = &ProtectionRule{}
	p.GetNodeID()
	p = nil
	p.GetNodeID()
}

func TestProtectionRule_GetPreventSelfReview(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &ProtectionRule{PreventSelfReview: &zeroValue}
	p.GetPreventSelfReview()
	p = &ProtectionRule{}
	p.GetPreventSelfReview()
	p = nil
	p.GetPreventSelfReview()
}

func TestProtectionRule_GetReviewers(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*RequiredReviewer{}
	p := &ProtectionRule{Reviewers: zeroValue}
	p.GetReviewers()
	p = &ProtectionRule{}
	p.GetReviewers()
	p = nil
	p.GetReviewers()
}

func TestProtectionRule_GetType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &ProtectionRule{Type: &zeroValue}
	p.GetType()
	p = &ProtectionRule{}
	p.GetType()
	p = nil
	p.GetType()
}

func TestProtectionRule_GetWaitTimer(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	p := &ProtectionRule{WaitTimer: &zeroValue}
	p.GetWaitTimer()
	p = &ProtectionRule{}
	p.GetWaitTimer()
	p = nil
	p.GetWaitTimer()
}

func TestPublicEvent_GetInstallation(tt *testing.T) {
	tt.Parallel()
	p := &PublicEvent{}
	p.GetInstallation()
	p = nil
	p.GetInstallation()
}

func TestPublicEvent_GetOrg(tt *testing.T) {
	tt.Parallel()
	p := &PublicEvent{}
	p.GetOrg()
	p = nil
	p.GetOrg()
}

func TestPublicEvent_GetRepo(tt *testing.T) {
	tt.Parallel()
	p := &PublicEvent{}
	p.GetRepo()
	p = nil
	p.GetRepo()
}

func TestPublicEvent_GetSender(tt *testing.T) {
	tt.Parallel()
	p := &PublicEvent{}
	p.GetSender()
	p = nil
	p.GetSender()
}

func TestPublicIPUsage_GetCurrentUsage(tt *testing.T) {
	tt.Parallel()
	p := &PublicIPUsage{}
	p.GetCurrentUsage()
	p = nil
	p.GetCurrentUsage()
}

func TestPublicIPUsage_GetMaximum(tt *testing.T) {
	tt.Parallel()
	p := &PublicIPUsage{}
	p.GetMaximum()
	p = nil
	p.GetMaximum()
}

func TestPublicKey_GetKey(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PublicKey{Key: &zeroValue}
	p.GetKey()
	p = &PublicKey{}
	p.GetKey()
	p = nil
	p.GetKey()
}

func TestPublicKey_GetKeyID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PublicKey{KeyID: &zeroValue}
	p.GetKeyID()
	p = &PublicKey{}
	p.GetKeyID()
	p = nil
	p.GetKeyID()
}

func TestPublishCodespaceOptions_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PublishCodespaceOptions{Name: &zeroValue}
	p.GetName()
	p = &PublishCodespaceOptions{}
	p.GetName()
	p = nil
	p.GetName()
}

func TestPublishCodespaceOptions_GetPrivate(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &PublishCodespaceOptions{Private: &zeroValue}
	p.GetPrivate()
	p = &PublishCodespaceOptions{}
	p.GetPrivate()
	p = nil
	p.GetPrivate()
}

func TestPullRequest_GetActiveLockReason(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PullRequest{ActiveLockReason: &zeroValue}
	p.GetActiveLockReason()
	p = &PullRequest{}
	p.GetActiveLockReason()
	p = nil
	p.GetActiveLockReason()
}

func TestPullRequest_GetAdditions(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	p := &PullRequest{Additions: &zeroValue}
	p.GetAdditions()
	p = &PullRequest{}
	p.GetAdditions()
	p = nil
	p.GetAdditions()
}

func TestPullRequest_GetAssignee(tt *testing.T) {
	tt.Parallel()
	p := &PullRequest{}
	p.GetAssignee()
	p = nil
	p.GetAssignee()
}

func TestPullRequest_GetAssignees(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*User{}
	p := &PullRequest{Assignees: zeroValue}
	p.GetAssignees()
	p = &PullRequest{}
	p.GetAssignees()
	p = nil
	p.GetAssignees()
}

func TestPullRequest_GetAuthorAssociation(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PullRequest{AuthorAssociation: &zeroValue}
	p.GetAuthorAssociation()
	p = &PullRequest{}
	p.GetAuthorAssociation()
	p = nil
	p.GetAuthorAssociation()
}

func TestPullRequest_GetAutoMerge(tt *testing.T) {
	tt.Parallel()
	p := &PullRequest{}
	p.GetAutoMerge()
	p = nil
	p.GetAutoMerge()
}

func TestPullRequest_GetBase(tt *testing.T) {
	tt.Parallel()
	p := &PullRequest{}
	p.GetBase()
	p = nil
	p.GetBase()
}

func TestPullRequest_GetBody(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PullRequest{Body: &zeroValue}
	p.GetBody()
	p = &PullRequest{}
	p.GetBody()
	p = nil
	p.GetBody()
}

func TestPullRequest_GetChangedFiles(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	p := &PullRequest{ChangedFiles: &zeroValue}
	p.GetChangedFiles()
	p = &PullRequest{}
	p.GetChangedFiles()
	p = nil
	p.GetChangedFiles()
}

func TestPullRequest_GetClosedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	p := &PullRequest{ClosedAt: &zeroValue}
	p.GetClosedAt()
	p = &PullRequest{}
	p.GetClosedAt()
	p = nil
	p.GetClosedAt()
}

func TestPullRequest_GetComments(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	p := &PullRequest{Comments: &zeroValue}
	p.GetComments()
	p = &PullRequest{}
	p.GetComments()
	p = nil
	p.GetComments()
}

func TestPullRequest_GetCommentsURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PullRequest{CommentsURL: &zeroValue}
	p.GetCommentsURL()
	p = &PullRequest{}
	p.GetCommentsURL()
	p = nil
	p.GetCommentsURL()
}

func TestPullRequest_GetCommits(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	p := &PullRequest{Commits: &zeroValue}
	p.GetCommits()
	p = &PullRequest{}
	p.GetCommits()
	p = nil
	p.GetCommits()
}

func TestPullRequest_GetCommitsURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PullRequest{CommitsURL: &zeroValue}
	p.GetCommitsURL()
	p = &PullRequest{}
	p.GetCommitsURL()
	p = nil
	p.GetCommitsURL()
}

func TestPullRequest_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	p := &PullRequest{CreatedAt: &zeroValue}
	p.GetCreatedAt()
	p = &PullRequest{}
	p.GetCreatedAt()
	p = nil
	p.GetCreatedAt()
}

func TestPullRequest_GetDeletions(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	p := &PullRequest{Deletions: &zeroValue}
	p.GetDeletions()
	p = &PullRequest{}
	p.GetDeletions()
	p = nil
	p.GetDeletions()
}

func TestPullRequest_GetDiffURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PullRequest{DiffURL: &zeroValue}
	p.GetDiffURL()
	p = &PullRequest{}
	p.GetDiffURL()
	p = nil
	p.GetDiffURL()
}

func TestPullRequest_GetDraft(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &PullRequest{Draft: &zeroValue}
	p.GetDraft()
	p = &PullRequest{}
	p.GetDraft()
	p = nil
	p.GetDraft()
}

func TestPullRequest_GetHead(tt *testing.T) {
	tt.Parallel()
	p := &PullRequest{}
	p.GetHead()
	p = nil
	p.GetHead()
}

func TestPullRequest_GetHTMLURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PullRequest{HTMLURL: &zeroValue}
	p.GetHTMLURL()
	p = &PullRequest{}
	p.GetHTMLURL()
	p = nil
	p.GetHTMLURL()
}

func TestPullRequest_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	p := &PullRequest{ID: &zeroValue}
	p.GetID()
	p = &PullRequest{}
	p.GetID()
	p = nil
	p.GetID()
}

func TestPullRequest_GetIssueURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PullRequest{IssueURL: &zeroValue}
	p.GetIssueURL()
	p = &PullRequest{}
	p.GetIssueURL()
	p = nil
	p.GetIssueURL()
}

func TestPullRequest_GetLabels(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*Label{}
	p := &PullRequest{Labels: zeroValue}
	p.GetLabels()
	p = &PullRequest{}
	p.GetLabels()
	p = nil
	p.GetLabels()
}

func TestPullRequest_GetLinks(tt *testing.T) {
	tt.Parallel()
	p := &PullRequest{}
	p.GetLinks()
	p = nil
	p.GetLinks()
}

func TestPullRequest_GetLocked(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &PullRequest{Locked: &zeroValue}
	p.GetLocked()
	p = &PullRequest{}
	p.GetLocked()
	p = nil
	p.GetLocked()
}

func TestPullRequest_GetMaintainerCanModify(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &PullRequest{MaintainerCanModify: &zeroValue}
	p.GetMaintainerCanModify()
	p = &PullRequest{}
	p.GetMaintainerCanModify()
	p = nil
	p.GetMaintainerCanModify()
}

func TestPullRequest_GetMergeable(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &PullRequest{Mergeable: &zeroValue}
	p.GetMergeable()
	p = &PullRequest{}
	p.GetMergeable()
	p = nil
	p.GetMergeable()
}

func TestPullRequest_GetMergeableState(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PullRequest{MergeableState: &zeroValue}
	p.GetMergeableState()
	p = &PullRequest{}
	p.GetMergeableState()
	p = nil
	p.GetMergeableState()
}

func TestPullRequest_GetMergeCommitSHA(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PullRequest{MergeCommitSHA: &zeroValue}
	p.GetMergeCommitSHA()
	p = &PullRequest{}
	p.GetMergeCommitSHA()
	p = nil
	p.GetMergeCommitSHA()
}

func TestPullRequest_GetMerged(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &PullRequest{Merged: &zeroValue}
	p.GetMerged()
	p = &PullRequest{}
	p.GetMerged()
	p = nil
	p.GetMerged()
}

func TestPullRequest_GetMergedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	p := &PullRequest{MergedAt: &zeroValue}
	p.GetMergedAt()
	p = &PullRequest{}
	p.GetMergedAt()
	p = nil
	p.GetMergedAt()
}

func TestPullRequest_GetMergedBy(tt *testing.T) {
	tt.Parallel()
	p := &PullRequest{}
	p.GetMergedBy()
	p = nil
	p.GetMergedBy()
}

func TestPullRequest_GetMilestone(tt *testing.T) {
	tt.Parallel()
	p := &PullRequest{}
	p.GetMilestone()
	p = nil
	p.GetMilestone()
}

func TestPullRequest_GetNodeID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PullRequest{NodeID: &zeroValue}
	p.GetNodeID()
	p = &PullRequest{}
	p.GetNodeID()
	p = nil
	p.GetNodeID()
}

func TestPullRequest_GetNumber(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	p := &PullRequest{Number: &zeroValue}
	p.GetNumber()
	p = &PullRequest{}
	p.GetNumber()
	p = nil
	p.GetNumber()
}

func TestPullRequest_GetPatchURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PullRequest{PatchURL: &zeroValue}
	p.GetPatchURL()
	p = &PullRequest{}
	p.GetPatchURL()
	p = nil
	p.GetPatchURL()
}

func TestPullRequest_GetRebaseable(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &PullRequest{Rebaseable: &zeroValue}
	p.GetRebaseable()
	p = &PullRequest{}
	p.GetRebaseable()
	p = nil
	p.GetRebaseable()
}

func TestPullRequest_GetRequestedReviewers(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*User{}
	p := &PullRequest{RequestedReviewers: zeroValue}
	p.GetRequestedReviewers()
	p = &PullRequest{}
	p.GetRequestedReviewers()
	p = nil
	p.GetRequestedReviewers()
}

func TestPullRequest_GetRequestedTeams(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*Team{}
	p := &PullRequest{RequestedTeams: zeroValue}
	p.GetRequestedTeams()
	p = &PullRequest{}
	p.GetRequestedTeams()
	p = nil
	p.GetRequestedTeams()
}

func TestPullRequest_GetReviewComments(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	p := &PullRequest{ReviewComments: &zeroValue}
	p.GetReviewComments()
	p = &PullRequest{}
	p.GetReviewComments()
	p = nil
	p.GetReviewComments()
}

func TestPullRequest_GetReviewCommentsURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PullRequest{ReviewCommentsURL: &zeroValue}
	p.GetReviewCommentsURL()
	p = &PullRequest{}
	p.GetReviewCommentsURL()
	p = nil
	p.GetReviewCommentsURL()
}

func TestPullRequest_GetReviewCommentURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PullRequest{ReviewCommentURL: &zeroValue}
	p.GetReviewCommentURL()
	p = &PullRequest{}
	p.GetReviewCommentURL()
	p = nil
	p.GetReviewCommentURL()
}

func TestPullRequest_GetState(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PullRequest{State: &zeroValue}
	p.GetState()
	p = &PullRequest{}
	p.GetState()
	p = nil
	p.GetState()
}

func TestPullRequest_GetStatusesURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PullRequest{StatusesURL: &zeroValue}
	p.GetStatusesURL()
	p = &PullRequest{}
	p.GetStatusesURL()
	p = nil
	p.GetStatusesURL()
}

func TestPullRequest_GetTitle(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PullRequest{Title: &zeroValue}
	p.GetTitle()
	p = &PullRequest{}
	p.GetTitle()
	p = nil
	p.GetTitle()
}

func TestPullRequest_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	p := &PullRequest{UpdatedAt: &zeroValue}
	p.GetUpdatedAt()
	p = &PullRequest{}
	p.GetUpdatedAt()
	p = nil
	p.GetUpdatedAt()
}

func TestPullRequest_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PullRequest{URL: &zeroValue}
	p.GetURL()
	p = &PullRequest{}
	p.GetURL()
	p = nil
	p.GetURL()
}

func TestPullRequest_GetUser(tt *testing.T) {
	tt.Parallel()
	p := &PullRequest{}
	p.GetUser()
	p = nil
	p.GetUser()
}

func TestPullRequestAutoMerge_GetCommitMessage(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PullRequestAutoMerge{CommitMessage: &zeroValue}
	p.GetCommitMessage()
	p = &PullRequestAutoMerge{}
	p.GetCommitMessage()
	p = nil
	p.GetCommitMessage()
}

func TestPullRequestAutoMerge_GetCommitTitle(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PullRequestAutoMerge{CommitTitle: &zeroValue}
	p.GetCommitTitle()
	p = &PullRequestAutoMerge{}
	p.GetCommitTitle()
	p = nil
	p.GetCommitTitle()
}

func TestPullRequestAutoMerge_GetEnabledBy(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestAutoMerge{}
	p.GetEnabledBy()
	p = nil
	p.GetEnabledBy()
}

func TestPullRequestAutoMerge_GetMergeMethod(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PullRequestAutoMerge{MergeMethod: &zeroValue}
	p.GetMergeMethod()
	p = &PullRequestAutoMerge{}
	p.GetMergeMethod()
	p = nil
	p.GetMergeMethod()
}

func TestPullRequestBranch_GetLabel(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PullRequestBranch{Label: &zeroValue}
	p.GetLabel()
	p = &PullRequestBranch{}
	p.GetLabel()
	p = nil
	p.GetLabel()
}

func TestPullRequestBranch_GetRef(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PullRequestBranch{Ref: &zeroValue}
	p.GetRef()
	p = &PullRequestBranch{}
	p.GetRef()
	p = nil
	p.GetRef()
}

func TestPullRequestBranch_GetRepo(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestBranch{}
	p.GetRepo()
	p = nil
	p.GetRepo()
}

func TestPullRequestBranch_GetSHA(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PullRequestBranch{SHA: &zeroValue}
	p.GetSHA()
	p = &PullRequestBranch{}
	p.GetSHA()
	p = nil
	p.GetSHA()
}

func TestPullRequestBranch_GetUser(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestBranch{}
	p.GetUser()
	p = nil
	p.GetUser()
}

func TestPullRequestBranchRule_GetParameters(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestBranchRule{}
	p.GetParameters()
	p = nil
	p.GetParameters()
}

func TestPullRequestBranchUpdateOptions_GetExpectedHeadSHA(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PullRequestBranchUpdateOptions{ExpectedHeadSHA: &zeroValue}
	p.GetExpectedHeadSHA()
	p = &PullRequestBranchUpdateOptions{}
	p.GetExpectedHeadSHA()
	p = nil
	p.GetExpectedHeadSHA()
}

func TestPullRequestBranchUpdateResponse_GetMessage(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PullRequestBranchUpdateResponse{Message: &zeroValue}
	p.GetMessage()
	p = &PullRequestBranchUpdateResponse{}
	p.GetMessage()
	p = nil
	p.GetMessage()
}

func TestPullRequestBranchUpdateResponse_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PullRequestBranchUpdateResponse{URL: &zeroValue}
	p.GetURL()
	p = &PullRequestBranchUpdateResponse{}
	p.GetURL()
	p = nil
	p.GetURL()
}

func TestPullRequestComment_GetAuthorAssociation(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PullRequestComment{AuthorAssociation: &zeroValue}
	p.GetAuthorAssociation()
	p = &PullRequestComment{}
	p.GetAuthorAssociation()
	p = nil
	p.GetAuthorAssociation()
}

func TestPullRequestComment_GetBody(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PullRequestComment{Body: &zeroValue}
	p.GetBody()
	p = &PullRequestComment{}
	p.GetBody()
	p = nil
	p.GetBody()
}

func TestPullRequestComment_GetCommitID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PullRequestComment{CommitID: &zeroValue}
	p.GetCommitID()
	p = &PullRequestComment{}
	p.GetCommitID()
	p = nil
	p.GetCommitID()
}

func TestPullRequestComment_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	p := &PullRequestComment{CreatedAt: &zeroValue}
	p.GetCreatedAt()
	p = &PullRequestComment{}
	p.GetCreatedAt()
	p = nil
	p.GetCreatedAt()
}

func TestPullRequestComment_GetDiffHunk(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PullRequestComment{DiffHunk: &zeroValue}
	p.GetDiffHunk()
	p = &PullRequestComment{}
	p.GetDiffHunk()
	p = nil
	p.GetDiffHunk()
}

func TestPullRequestComment_GetHTMLURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PullRequestComment{HTMLURL: &zeroValue}
	p.GetHTMLURL()
	p = &PullRequestComment{}
	p.GetHTMLURL()
	p = nil
	p.GetHTMLURL()
}

func TestPullRequestComment_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	p := &PullRequestComment{ID: &zeroValue}
	p.GetID()
	p = &PullRequestComment{}
	p.GetID()
	p = nil
	p.GetID()
}

func TestPullRequestComment_GetInReplyTo(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	p := &PullRequestComment{InReplyTo: &zeroValue}
	p.GetInReplyTo()
	p = &PullRequestComment{}
	p.GetInReplyTo()
	p = nil
	p.GetInReplyTo()
}

func TestPullRequestComment_GetLine(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	p := &PullRequestComment{Line: &zeroValue}
	p.GetLine()
	p = &PullRequestComment{}
	p.GetLine()
	p = nil
	p.GetLine()
}

func TestPullRequestComment_GetNodeID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PullRequestComment{NodeID: &zeroValue}
	p.GetNodeID()
	p = &PullRequestComment{}
	p.GetNodeID()
	p = nil
	p.GetNodeID()
}

func TestPullRequestComment_GetOriginalCommitID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PullRequestComment{OriginalCommitID: &zeroValue}
	p.GetOriginalCommitID()
	p = &PullRequestComment{}
	p.GetOriginalCommitID()
	p = nil
	p.GetOriginalCommitID()
}

func TestPullRequestComment_GetOriginalLine(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	p := &PullRequestComment{OriginalLine: &zeroValue}
	p.GetOriginalLine()
	p = &PullRequestComment{}
	p.GetOriginalLine()
	p = nil
	p.GetOriginalLine()
}

func TestPullRequestComment_GetOriginalPosition(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	p := &PullRequestComment{OriginalPosition: &zeroValue}
	p.GetOriginalPosition()
	p = &PullRequestComment{}
	p.GetOriginalPosition()
	p = nil
	p.GetOriginalPosition()
}

func TestPullRequestComment_GetOriginalStartLine(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	p := &PullRequestComment{OriginalStartLine: &zeroValue}
	p.GetOriginalStartLine()
	p = &PullRequestComment{}
	p.GetOriginalStartLine()
	p = nil
	p.GetOriginalStartLine()
}

func TestPullRequestComment_GetPath(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PullRequestComment{Path: &zeroValue}
	p.GetPath()
	p = &PullRequestComment{}
	p.GetPath()
	p = nil
	p.GetPath()
}

func TestPullRequestComment_GetPosition(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	p := &PullRequestComment{Position: &zeroValue}
	p.GetPosition()
	p = &PullRequestComment{}
	p.GetPosition()
	p = nil
	p.GetPosition()
}

func TestPullRequestComment_GetPullRequestReviewID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	p := &PullRequestComment{PullRequestReviewID: &zeroValue}
	p.GetPullRequestReviewID()
	p = &PullRequestComment{}
	p.GetPullRequestReviewID()
	p = nil
	p.GetPullRequestReviewID()
}

func TestPullRequestComment_GetPullRequestURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PullRequestComment{PullRequestURL: &zeroValue}
	p.GetPullRequestURL()
	p = &PullRequestComment{}
	p.GetPullRequestURL()
	p = nil
	p.GetPullRequestURL()
}

func TestPullRequestComment_GetReactions(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestComment{}
	p.GetReactions()
	p = nil
	p.GetReactions()
}

func TestPullRequestComment_GetSide(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PullRequestComment{Side: &zeroValue}
	p.GetSide()
	p = &PullRequestComment{}
	p.GetSide()
	p = nil
	p.GetSide()
}

func TestPullRequestComment_GetStartLine(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	p := &PullRequestComment{StartLine: &zeroValue}
	p.GetStartLine()
	p = &PullRequestComment{}
	p.GetStartLine()
	p = nil
	p.GetStartLine()
}

func TestPullRequestComment_GetStartSide(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PullRequestComment{StartSide: &zeroValue}
	p.GetStartSide()
	p = &PullRequestComment{}
	p.GetStartSide()
	p = nil
	p.GetStartSide()
}

func TestPullRequestComment_GetSubjectType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PullRequestComment{SubjectType: &zeroValue}
	p.GetSubjectType()
	p = &PullRequestComment{}
	p.GetSubjectType()
	p = nil
	p.GetSubjectType()
}

func TestPullRequestComment_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	p := &PullRequestComment{UpdatedAt: &zeroValue}
	p.GetUpdatedAt()
	p = &PullRequestComment{}
	p.GetUpdatedAt()
	p = nil
	p.GetUpdatedAt()
}

func TestPullRequestComment_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PullRequestComment{URL: &zeroValue}
	p.GetURL()
	p = &PullRequestComment{}
	p.GetURL()
	p = nil
	p.GetURL()
}

func TestPullRequestComment_GetUser(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestComment{}
	p.GetUser()
	p = nil
	p.GetUser()
}

func TestPullRequestEvent_GetAction(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PullRequestEvent{Action: &zeroValue}
	p.GetAction()
	p = &PullRequestEvent{}
	p.GetAction()
	p = nil
	p.GetAction()
}

func TestPullRequestEvent_GetAfter(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PullRequestEvent{After: &zeroValue}
	p.GetAfter()
	p = &PullRequestEvent{}
	p.GetAfter()
	p = nil
	p.GetAfter()
}

func TestPullRequestEvent_GetAssignee(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestEvent{}
	p.GetAssignee()
	p = nil
	p.GetAssignee()
}

func TestPullRequestEvent_GetBefore(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PullRequestEvent{Before: &zeroValue}
	p.GetBefore()
	p = &PullRequestEvent{}
	p.GetBefore()
	p = nil
	p.GetBefore()
}

func TestPullRequestEvent_GetChanges(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestEvent{}
	p.GetChanges()
	p = nil
	p.GetChanges()
}

func TestPullRequestEvent_GetInstallation(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestEvent{}
	p.GetInstallation()
	p = nil
	p.GetInstallation()
}

func TestPullRequestEvent_GetLabel(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestEvent{}
	p.GetLabel()
	p = nil
	p.GetLabel()
}

func TestPullRequestEvent_GetNumber(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	p := &PullRequestEvent{Number: &zeroValue}
	p.GetNumber()
	p = &PullRequestEvent{}
	p.GetNumber()
	p = nil
	p.GetNumber()
}

func TestPullRequestEvent_GetOrganization(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestEvent{}
	p.GetOrganization()
	p = nil
	p.GetOrganization()
}

func TestPullRequestEvent_GetPerformedViaGithubApp(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestEvent{}
	p.GetPerformedViaGithubApp()
	p = nil
	p.GetPerformedViaGithubApp()
}

func TestPullRequestEvent_GetPullRequest(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestEvent{}
	p.GetPullRequest()
	p = nil
	p.GetPullRequest()
}

func TestPullRequestEvent_GetReason(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PullRequestEvent{Reason: &zeroValue}
	p.GetReason()
	p = &PullRequestEvent{}
	p.GetReason()
	p = nil
	p.GetReason()
}

func TestPullRequestEvent_GetRepo(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestEvent{}
	p.GetRepo()
	p = nil
	p.GetRepo()
}

func TestPullRequestEvent_GetRequestedReviewer(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestEvent{}
	p.GetRequestedReviewer()
	p = nil
	p.GetRequestedReviewer()
}

func TestPullRequestEvent_GetRequestedTeam(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestEvent{}
	p.GetRequestedTeam()
	p = nil
	p.GetRequestedTeam()
}

func TestPullRequestEvent_GetSender(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestEvent{}
	p.GetSender()
	p = nil
	p.GetSender()
}

func TestPullRequestLinks_GetDiffURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PullRequestLinks{DiffURL: &zeroValue}
	p.GetDiffURL()
	p = &PullRequestLinks{}
	p.GetDiffURL()
	p = nil
	p.GetDiffURL()
}

func TestPullRequestLinks_GetHTMLURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PullRequestLinks{HTMLURL: &zeroValue}
	p.GetHTMLURL()
	p = &PullRequestLinks{}
	p.GetHTMLURL()
	p = nil
	p.GetHTMLURL()
}

func TestPullRequestLinks_GetMergedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	p := &PullRequestLinks{MergedAt: &zeroValue}
	p.GetMergedAt()
	p = &PullRequestLinks{}
	p.GetMergedAt()
	p = nil
	p.GetMergedAt()
}

func TestPullRequestLinks_GetPatchURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PullRequestLinks{PatchURL: &zeroValue}
	p.GetPatchURL()
	p = &PullRequestLinks{}
	p.GetPatchURL()
	p = nil
	p.GetPatchURL()
}

func TestPullRequestLinks_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PullRequestLinks{URL: &zeroValue}
	p.GetURL()
	p = &PullRequestLinks{}
	p.GetURL()
	p = nil
	p.GetURL()
}

func TestPullRequestListCommentsOptions_GetDirection(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestListCommentsOptions{}
	p.GetDirection()
	p = nil
	p.GetDirection()
}

func TestPullRequestListCommentsOptions_GetSince(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestListCommentsOptions{}
	p.GetSince()
	p = nil
	p.GetSince()
}

func TestPullRequestListCommentsOptions_GetSort(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestListCommentsOptions{}
	p.GetSort()
	p = nil
	p.GetSort()
}

func TestPullRequestListOptions_GetBase(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestListOptions{}
	p.GetBase()
	p = nil
	p.GetBase()
}

func TestPullRequestListOptions_GetDirection(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestListOptions{}
	p.GetDirection()
	p = nil
	p.GetDirection()
}

func TestPullRequestListOptions_GetHead(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestListOptions{}
	p.GetHead()
	p = nil
	p.GetHead()
}

func TestPullRequestListOptions_GetSort(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestListOptions{}
	p.GetSort()
	p = nil
	p.GetSort()
}

func TestPullRequestListOptions_GetState(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestListOptions{}
	p.GetState()
	p = nil
	p.GetState()
}

func TestPullRequestMergeResult_GetMerged(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &PullRequestMergeResult{Merged: &zeroValue}
	p.GetMerged()
	p = &PullRequestMergeResult{}
	p.GetMerged()
	p = nil
	p.GetMerged()
}

func TestPullRequestMergeResult_GetMessage(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PullRequestMergeResult{Message: &zeroValue}
	p.GetMessage()
	p = &PullRequestMergeResult{}
	p.GetMessage()
	p = nil
	p.GetMessage()
}

func TestPullRequestMergeResult_GetSHA(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PullRequestMergeResult{SHA: &zeroValue}
	p.GetSHA()
	p = &PullRequestMergeResult{}
	p.GetSHA()
	p = nil
	p.GetSHA()
}

func TestPullRequestOptions_GetCommitTitle(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestOptions{}
	p.GetCommitTitle()
	p = nil
	p.GetCommitTitle()
}

func TestPullRequestOptions_GetDontDefaultIfBlank(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestOptions{}
	p.GetDontDefaultIfBlank()
	p = nil
	p.GetDontDefaultIfBlank()
}

func TestPullRequestOptions_GetMergeMethod(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestOptions{}
	p.GetMergeMethod()
	p = nil
	p.GetMergeMethod()
}

func TestPullRequestOptions_GetSHA(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestOptions{}
	p.GetSHA()
	p = nil
	p.GetSHA()
}

func TestPullRequestReview_GetAuthorAssociation(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PullRequestReview{AuthorAssociation: &zeroValue}
	p.GetAuthorAssociation()
	p = &PullRequestReview{}
	p.GetAuthorAssociation()
	p = nil
	p.GetAuthorAssociation()
}

func TestPullRequestReview_GetBody(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PullRequestReview{Body: &zeroValue}
	p.GetBody()
	p = &PullRequestReview{}
	p.GetBody()
	p = nil
	p.GetBody()
}

func TestPullRequestReview_GetCommitID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PullRequestReview{CommitID: &zeroValue}
	p.GetCommitID()
	p = &PullRequestReview{}
	p.GetCommitID()
	p = nil
	p.GetCommitID()
}

func TestPullRequestReview_GetHTMLURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PullRequestReview{HTMLURL: &zeroValue}
	p.GetHTMLURL()
	p = &PullRequestReview{}
	p.GetHTMLURL()
	p = nil
	p.GetHTMLURL()
}

func TestPullRequestReview_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	p := &PullRequestReview{ID: &zeroValue}
	p.GetID()
	p = &PullRequestReview{}
	p.GetID()
	p = nil
	p.GetID()
}

func TestPullRequestReview_GetNodeID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PullRequestReview{NodeID: &zeroValue}
	p.GetNodeID()
	p = &PullRequestReview{}
	p.GetNodeID()
	p = nil
	p.GetNodeID()
}

func TestPullRequestReview_GetPullRequestURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PullRequestReview{PullRequestURL: &zeroValue}
	p.GetPullRequestURL()
	p = &PullRequestReview{}
	p.GetPullRequestURL()
	p = nil
	p.GetPullRequestURL()
}

func TestPullRequestReview_GetState(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PullRequestReview{State: &zeroValue}
	p.GetState()
	p = &PullRequestReview{}
	p.GetState()
	p = nil
	p.GetState()
}

func TestPullRequestReview_GetSubmittedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	p := &PullRequestReview{SubmittedAt: &zeroValue}
	p.GetSubmittedAt()
	p = &PullRequestReview{}
	p.GetSubmittedAt()
	p = nil
	p.GetSubmittedAt()
}

func TestPullRequestReview_GetUser(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestReview{}
	p.GetUser()
	p = nil
	p.GetUser()
}

func TestPullRequestReviewCommentEvent_GetAction(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PullRequestReviewCommentEvent{Action: &zeroValue}
	p.GetAction()
	p = &PullRequestReviewCommentEvent{}
	p.GetAction()
	p = nil
	p.GetAction()
}

func TestPullRequestReviewCommentEvent_GetChanges(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestReviewCommentEvent{}
	p.GetChanges()
	p = nil
	p.GetChanges()
}

func TestPullRequestReviewCommentEvent_GetComment(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestReviewCommentEvent{}
	p.GetComment()
	p = nil
	p.GetComment()
}

func TestPullRequestReviewCommentEvent_GetInstallation(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestReviewCommentEvent{}
	p.GetInstallation()
	p = nil
	p.GetInstallation()
}

func TestPullRequestReviewCommentEvent_GetOrg(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestReviewCommentEvent{}
	p.GetOrg()
	p = nil
	p.GetOrg()
}

func TestPullRequestReviewCommentEvent_GetPullRequest(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestReviewCommentEvent{}
	p.GetPullRequest()
	p = nil
	p.GetPullRequest()
}

func TestPullRequestReviewCommentEvent_GetRepo(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestReviewCommentEvent{}
	p.GetRepo()
	p = nil
	p.GetRepo()
}

func TestPullRequestReviewCommentEvent_GetSender(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestReviewCommentEvent{}
	p.GetSender()
	p = nil
	p.GetSender()
}

func TestPullRequestReviewDismissalRequest_GetMessage(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PullRequestReviewDismissalRequest{Message: &zeroValue}
	p.GetMessage()
	p = &PullRequestReviewDismissalRequest{}
	p.GetMessage()
	p = nil
	p.GetMessage()
}

func TestPullRequestReviewEvent_GetAction(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PullRequestReviewEvent{Action: &zeroValue}
	p.GetAction()
	p = &PullRequestReviewEvent{}
	p.GetAction()
	p = nil
	p.GetAction()
}

func TestPullRequestReviewEvent_GetInstallation(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestReviewEvent{}
	p.GetInstallation()
	p = nil
	p.GetInstallation()
}

func TestPullRequestReviewEvent_GetOrganization(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestReviewEvent{}
	p.GetOrganization()
	p = nil
	p.GetOrganization()
}

func TestPullRequestReviewEvent_GetPullRequest(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestReviewEvent{}
	p.GetPullRequest()
	p = nil
	p.GetPullRequest()
}

func TestPullRequestReviewEvent_GetRepo(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestReviewEvent{}
	p.GetRepo()
	p = nil
	p.GetRepo()
}

func TestPullRequestReviewEvent_GetReview(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestReviewEvent{}
	p.GetReview()
	p = nil
	p.GetReview()
}

func TestPullRequestReviewEvent_GetSender(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestReviewEvent{}
	p.GetSender()
	p = nil
	p.GetSender()
}

func TestPullRequestReviewRequest_GetBody(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PullRequestReviewRequest{Body: &zeroValue}
	p.GetBody()
	p = &PullRequestReviewRequest{}
	p.GetBody()
	p = nil
	p.GetBody()
}

func TestPullRequestReviewRequest_GetComments(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*DraftReviewComment{}
	p := &PullRequestReviewRequest{Comments: zeroValue}
	p.GetComments()
	p = &PullRequestReviewRequest{}
	p.GetComments()
	p = nil
	p.GetComments()
}

func TestPullRequestReviewRequest_GetCommitID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PullRequestReviewRequest{CommitID: &zeroValue}
	p.GetCommitID()
	p = &PullRequestReviewRequest{}
	p.GetCommitID()
	p = nil
	p.GetCommitID()
}

func TestPullRequestReviewRequest_GetEvent(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PullRequestReviewRequest{Event: &zeroValue}
	p.GetEvent()
	p = &PullRequestReviewRequest{}
	p.GetEvent()
	p = nil
	p.GetEvent()
}

func TestPullRequestReviewRequest_GetNodeID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PullRequestReviewRequest{NodeID: &zeroValue}
	p.GetNodeID()
	p = &PullRequestReviewRequest{}
	p.GetNodeID()
	p = nil
	p.GetNodeID()
}

func TestPullRequestReviewsEnforcement_GetBypassPullRequestAllowances(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestReviewsEnforcement{}
	p.GetBypassPullRequestAllowances()
	p = nil
	p.GetBypassPullRequestAllowances()
}

func TestPullRequestReviewsEnforcement_GetDismissalRestrictions(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestReviewsEnforcement{}
	p.GetDismissalRestrictions()
	p = nil
	p.GetDismissalRestrictions()
}

func TestPullRequestReviewsEnforcement_GetDismissStaleReviews(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestReviewsEnforcement{}
	p.GetDismissStaleReviews()
	p = nil
	p.GetDismissStaleReviews()
}

func TestPullRequestReviewsEnforcement_GetRequireCodeOwnerReviews(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestReviewsEnforcement{}
	p.GetRequireCodeOwnerReviews()
	p = nil
	p.GetRequireCodeOwnerReviews()
}

func TestPullRequestReviewsEnforcement_GetRequiredApprovingReviewCount(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestReviewsEnforcement{}
	p.GetRequiredApprovingReviewCount()
	p = nil
	p.GetRequiredApprovingReviewCount()
}

func TestPullRequestReviewsEnforcement_GetRequireLastPushApproval(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestReviewsEnforcement{}
	p.GetRequireLastPushApproval()
	p = nil
	p.GetRequireLastPushApproval()
}

func TestPullRequestReviewsEnforcementLevelChanges_GetFrom(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PullRequestReviewsEnforcementLevelChanges{From: &zeroValue}
	p.GetFrom()
	p = &PullRequestReviewsEnforcementLevelChanges{}
	p.GetFrom()
	p = nil
	p.GetFrom()
}

func TestPullRequestReviewsEnforcementRequest_GetBypassPullRequestAllowancesRequest(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestReviewsEnforcementRequest{}
	p.GetBypassPullRequestAllowancesRequest()
	p = nil
	p.GetBypassPullRequestAllowancesRequest()
}

func TestPullRequestReviewsEnforcementRequest_GetDismissalRestrictionsRequest(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestReviewsEnforcementRequest{}
	p.GetDismissalRestrictionsRequest()
	p = nil
	p.GetDismissalRestrictionsRequest()
}

func TestPullRequestReviewsEnforcementRequest_GetDismissStaleReviews(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestReviewsEnforcementRequest{}
	p.GetDismissStaleReviews()
	p = nil
	p.GetDismissStaleReviews()
}

func TestPullRequestReviewsEnforcementRequest_GetRequireCodeOwnerReviews(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestReviewsEnforcementRequest{}
	p.GetRequireCodeOwnerReviews()
	p = nil
	p.GetRequireCodeOwnerReviews()
}

func TestPullRequestReviewsEnforcementRequest_GetRequiredApprovingReviewCount(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestReviewsEnforcementRequest{}
	p.GetRequiredApprovingReviewCount()
	p = nil
	p.GetRequiredApprovingReviewCount()
}

func TestPullRequestReviewsEnforcementRequest_GetRequireLastPushApproval(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &PullRequestReviewsEnforcementRequest{RequireLastPushApproval: &zeroValue}
	p.GetRequireLastPushApproval()
	p = &PullRequestReviewsEnforcementRequest{}
	p.GetRequireLastPushApproval()
	p = nil
	p.GetRequireLastPushApproval()
}

func TestPullRequestReviewsEnforcementUpdate_GetBypassPullRequestAllowancesRequest(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestReviewsEnforcementUpdate{}
	p.GetBypassPullRequestAllowancesRequest()
	p = nil
	p.GetBypassPullRequestAllowancesRequest()
}

func TestPullRequestReviewsEnforcementUpdate_GetDismissalRestrictionsRequest(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestReviewsEnforcementUpdate{}
	p.GetDismissalRestrictionsRequest()
	p = nil
	p.GetDismissalRestrictionsRequest()
}

func TestPullRequestReviewsEnforcementUpdate_GetDismissStaleReviews(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &PullRequestReviewsEnforcementUpdate{DismissStaleReviews: &zeroValue}
	p.GetDismissStaleReviews()
	p = &PullRequestReviewsEnforcementUpdate{}
	p.GetDismissStaleReviews()
	p = nil
	p.GetDismissStaleReviews()
}

func TestPullRequestReviewsEnforcementUpdate_GetRequireCodeOwnerReviews(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &PullRequestReviewsEnforcementUpdate{RequireCodeOwnerReviews: &zeroValue}
	p.GetRequireCodeOwnerReviews()
	p = &PullRequestReviewsEnforcementUpdate{}
	p.GetRequireCodeOwnerReviews()
	p = nil
	p.GetRequireCodeOwnerReviews()
}

func TestPullRequestReviewsEnforcementUpdate_GetRequiredApprovingReviewCount(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestReviewsEnforcementUpdate{}
	p.GetRequiredApprovingReviewCount()
	p = nil
	p.GetRequiredApprovingReviewCount()
}

func TestPullRequestReviewsEnforcementUpdate_GetRequireLastPushApproval(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &PullRequestReviewsEnforcementUpdate{RequireLastPushApproval: &zeroValue}
	p.GetRequireLastPushApproval()
	p = &PullRequestReviewsEnforcementUpdate{}
	p.GetRequireLastPushApproval()
	p = nil
	p.GetRequireLastPushApproval()
}

func TestPullRequestReviewThreadEvent_GetAction(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PullRequestReviewThreadEvent{Action: &zeroValue}
	p.GetAction()
	p = &PullRequestReviewThreadEvent{}
	p.GetAction()
	p = nil
	p.GetAction()
}

func TestPullRequestReviewThreadEvent_GetInstallation(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestReviewThreadEvent{}
	p.GetInstallation()
	p = nil
	p.GetInstallation()
}

func TestPullRequestReviewThreadEvent_GetOrg(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestReviewThreadEvent{}
	p.GetOrg()
	p = nil
	p.GetOrg()
}

func TestPullRequestReviewThreadEvent_GetPullRequest(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestReviewThreadEvent{}
	p.GetPullRequest()
	p = nil
	p.GetPullRequest()
}

func TestPullRequestReviewThreadEvent_GetRepo(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestReviewThreadEvent{}
	p.GetRepo()
	p = nil
	p.GetRepo()
}

func TestPullRequestReviewThreadEvent_GetSender(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestReviewThreadEvent{}
	p.GetSender()
	p = nil
	p.GetSender()
}

func TestPullRequestReviewThreadEvent_GetThread(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestReviewThreadEvent{}
	p.GetThread()
	p = nil
	p.GetThread()
}

func TestPullRequestRuleParameters_GetAllowedMergeMethods(tt *testing.T) {
	tt.Parallel()
	zeroValue := []PullRequestMergeMethod{}
	p := &PullRequestRuleParameters{AllowedMergeMethods: zeroValue}
	p.GetAllowedMergeMethods()
	p = &PullRequestRuleParameters{}
	p.GetAllowedMergeMethods()
	p = nil
	p.GetAllowedMergeMethods()
}

func TestPullRequestRuleParameters_GetDismissStaleReviewsOnPush(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestRuleParameters{}
	p.GetDismissStaleReviewsOnPush()
	p = nil
	p.GetDismissStaleReviewsOnPush()
}

func TestPullRequestRuleParameters_GetRequireCodeOwnerReview(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestRuleParameters{}
	p.GetRequireCodeOwnerReview()
	p = nil
	p.GetRequireCodeOwnerReview()
}

func TestPullRequestRuleParameters_GetRequiredApprovingReviewCount(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestRuleParameters{}
	p.GetRequiredApprovingReviewCount()
	p = nil
	p.GetRequiredApprovingReviewCount()
}

func TestPullRequestRuleParameters_GetRequiredReviewers(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*RulesetRequiredReviewer{}
	p := &PullRequestRuleParameters{RequiredReviewers: zeroValue}
	p.GetRequiredReviewers()
	p = &PullRequestRuleParameters{}
	p.GetRequiredReviewers()
	p = nil
	p.GetRequiredReviewers()
}

func TestPullRequestRuleParameters_GetRequiredReviewThreadResolution(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestRuleParameters{}
	p.GetRequiredReviewThreadResolution()
	p = nil
	p.GetRequiredReviewThreadResolution()
}

func TestPullRequestRuleParameters_GetRequireLastPushApproval(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestRuleParameters{}
	p.GetRequireLastPushApproval()
	p = nil
	p.GetRequireLastPushApproval()
}

func TestPullRequestTargetEvent_GetAction(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PullRequestTargetEvent{Action: &zeroValue}
	p.GetAction()
	p = &PullRequestTargetEvent{}
	p.GetAction()
	p = nil
	p.GetAction()
}

func TestPullRequestTargetEvent_GetAfter(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PullRequestTargetEvent{After: &zeroValue}
	p.GetAfter()
	p = &PullRequestTargetEvent{}
	p.GetAfter()
	p = nil
	p.GetAfter()
}

func TestPullRequestTargetEvent_GetAssignee(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestTargetEvent{}
	p.GetAssignee()
	p = nil
	p.GetAssignee()
}

func TestPullRequestTargetEvent_GetBefore(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PullRequestTargetEvent{Before: &zeroValue}
	p.GetBefore()
	p = &PullRequestTargetEvent{}
	p.GetBefore()
	p = nil
	p.GetBefore()
}

func TestPullRequestTargetEvent_GetChanges(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestTargetEvent{}
	p.GetChanges()
	p = nil
	p.GetChanges()
}

func TestPullRequestTargetEvent_GetInstallation(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestTargetEvent{}
	p.GetInstallation()
	p = nil
	p.GetInstallation()
}

func TestPullRequestTargetEvent_GetLabel(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestTargetEvent{}
	p.GetLabel()
	p = nil
	p.GetLabel()
}

func TestPullRequestTargetEvent_GetNumber(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	p := &PullRequestTargetEvent{Number: &zeroValue}
	p.GetNumber()
	p = &PullRequestTargetEvent{}
	p.GetNumber()
	p = nil
	p.GetNumber()
}

func TestPullRequestTargetEvent_GetOrganization(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestTargetEvent{}
	p.GetOrganization()
	p = nil
	p.GetOrganization()
}

func TestPullRequestTargetEvent_GetPerformedViaGithubApp(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestTargetEvent{}
	p.GetPerformedViaGithubApp()
	p = nil
	p.GetPerformedViaGithubApp()
}

func TestPullRequestTargetEvent_GetPullRequest(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestTargetEvent{}
	p.GetPullRequest()
	p = nil
	p.GetPullRequest()
}

func TestPullRequestTargetEvent_GetRepo(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestTargetEvent{}
	p.GetRepo()
	p = nil
	p.GetRepo()
}

func TestPullRequestTargetEvent_GetRequestedReviewer(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestTargetEvent{}
	p.GetRequestedReviewer()
	p = nil
	p.GetRequestedReviewer()
}

func TestPullRequestTargetEvent_GetRequestedTeam(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestTargetEvent{}
	p.GetRequestedTeam()
	p = nil
	p.GetRequestedTeam()
}

func TestPullRequestTargetEvent_GetSender(tt *testing.T) {
	tt.Parallel()
	p := &PullRequestTargetEvent{}
	p.GetSender()
	p = nil
	p.GetSender()
}

func TestPullRequestThread_GetComments(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*PullRequestComment{}
	p := &PullRequestThread{Comments: zeroValue}
	p.GetComments()
	p = &PullRequestThread{}
	p.GetComments()
	p = nil
	p.GetComments()
}

func TestPullRequestThread_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	p := &PullRequestThread{ID: &zeroValue}
	p.GetID()
	p = &PullRequestThread{}
	p.GetID()
	p = nil
	p.GetID()
}

func TestPullRequestThread_GetNodeID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PullRequestThread{NodeID: &zeroValue}
	p.GetNodeID()
	p = &PullRequestThread{}
	p.GetNodeID()
	p = nil
	p.GetNodeID()
}

func TestPullStats_GetMergeablePulls(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	p := &PullStats{MergeablePulls: &zeroValue}
	p.GetMergeablePulls()
	p = &PullStats{}
	p.GetMergeablePulls()
	p = nil
	p.GetMergeablePulls()
}

func TestPullStats_GetMergedPulls(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	p := &PullStats{MergedPulls: &zeroValue}
	p.GetMergedPulls()
	p = &PullStats{}
	p.GetMergedPulls()
	p = nil
	p.GetMergedPulls()
}

func TestPullStats_GetTotalPulls(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	p := &PullStats{TotalPulls: &zeroValue}
	p.GetTotalPulls()
	p = &PullStats{}
	p.GetTotalPulls()
	p = nil
	p.GetTotalPulls()
}

func TestPullStats_GetUnmergeablePulls(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	p := &PullStats{UnmergeablePulls: &zeroValue}
	p.GetUnmergeablePulls()
	p = &PullStats{}
	p.GetUnmergeablePulls()
	p = nil
	p.GetUnmergeablePulls()
}

func TestPunchCard_GetCommits(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	p := &PunchCard{Commits: &zeroValue}
	p.GetCommits()
	p = &PunchCard{}
	p.GetCommits()
	p = nil
	p.GetCommits()
}

func TestPunchCard_GetDay(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	p := &PunchCard{Day: &zeroValue}
	p.GetDay()
	p = &PunchCard{}
	p.GetDay()
	p = nil
	p.GetDay()
}

func TestPunchCard_GetHour(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	p := &PunchCard{Hour: &zeroValue}
	p.GetHour()
	p = &PunchCard{}
	p.GetHour()
	p = nil
	p.GetHour()
}

func TestPushEvent_GetAction(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PushEvent{Action: &zeroValue}
	p.GetAction()
	p = &PushEvent{}
	p.GetAction()
	p = nil
	p.GetAction()
}

func TestPushEvent_GetAfter(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PushEvent{After: &zeroValue}
	p.GetAfter()
	p = &PushEvent{}
	p.GetAfter()
	p = nil
	p.GetAfter()
}

func TestPushEvent_GetBaseRef(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PushEvent{BaseRef: &zeroValue}
	p.GetBaseRef()
	p = &PushEvent{}
	p.GetBaseRef()
	p = nil
	p.GetBaseRef()
}

func TestPushEvent_GetBefore(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PushEvent{Before: &zeroValue}
	p.GetBefore()
	p = &PushEvent{}
	p.GetBefore()
	p = nil
	p.GetBefore()
}

func TestPushEvent_GetCommits(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*HeadCommit{}
	p := &PushEvent{Commits: zeroValue}
	p.GetCommits()
	p = &PushEvent{}
	p.GetCommits()
	p = nil
	p.GetCommits()
}

func TestPushEvent_GetCompare(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PushEvent{Compare: &zeroValue}
	p.GetCompare()
	p = &PushEvent{}
	p.GetCompare()
	p = nil
	p.GetCompare()
}

func TestPushEvent_GetCreated(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &PushEvent{Created: &zeroValue}
	p.GetCreated()
	p = &PushEvent{}
	p.GetCreated()
	p = nil
	p.GetCreated()
}

func TestPushEvent_GetDeleted(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &PushEvent{Deleted: &zeroValue}
	p.GetDeleted()
	p = &PushEvent{}
	p.GetDeleted()
	p = nil
	p.GetDeleted()
}

func TestPushEvent_GetDistinctSize(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	p := &PushEvent{DistinctSize: &zeroValue}
	p.GetDistinctSize()
	p = &PushEvent{}
	p.GetDistinctSize()
	p = nil
	p.GetDistinctSize()
}

func TestPushEvent_GetForced(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &PushEvent{Forced: &zeroValue}
	p.GetForced()
	p = &PushEvent{}
	p.GetForced()
	p = nil
	p.GetForced()
}

func TestPushEvent_GetHead(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PushEvent{Head: &zeroValue}
	p.GetHead()
	p = &PushEvent{}
	p.GetHead()
	p = nil
	p.GetHead()
}

func TestPushEvent_GetHeadCommit(tt *testing.T) {
	tt.Parallel()
	p := &PushEvent{}
	p.GetHeadCommit()
	p = nil
	p.GetHeadCommit()
}

func TestPushEvent_GetInstallation(tt *testing.T) {
	tt.Parallel()
	p := &PushEvent{}
	p.GetInstallation()
	p = nil
	p.GetInstallation()
}

func TestPushEvent_GetOrganization(tt *testing.T) {
	tt.Parallel()
	p := &PushEvent{}
	p.GetOrganization()
	p = nil
	p.GetOrganization()
}

func TestPushEvent_GetPusher(tt *testing.T) {
	tt.Parallel()
	p := &PushEvent{}
	p.GetPusher()
	p = nil
	p.GetPusher()
}

func TestPushEvent_GetPushID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	p := &PushEvent{PushID: &zeroValue}
	p.GetPushID()
	p = &PushEvent{}
	p.GetPushID()
	p = nil
	p.GetPushID()
}

func TestPushEvent_GetRef(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PushEvent{Ref: &zeroValue}
	p.GetRef()
	p = &PushEvent{}
	p.GetRef()
	p = nil
	p.GetRef()
}

func TestPushEvent_GetRepo(tt *testing.T) {
	tt.Parallel()
	p := &PushEvent{}
	p.GetRepo()
	p = nil
	p.GetRepo()
}

func TestPushEvent_GetSender(tt *testing.T) {
	tt.Parallel()
	p := &PushEvent{}
	p.GetSender()
	p = nil
	p.GetSender()
}

func TestPushEvent_GetSize(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	p := &PushEvent{Size: &zeroValue}
	p.GetSize()
	p = &PushEvent{}
	p.GetSize()
	p = nil
	p.GetSize()
}

func TestPushEventRepoOwner_GetEmail(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PushEventRepoOwner{Email: &zeroValue}
	p.GetEmail()
	p = &PushEventRepoOwner{}
	p.GetEmail()
	p = nil
	p.GetEmail()
}

func TestPushEventRepoOwner_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PushEventRepoOwner{Name: &zeroValue}
	p.GetName()
	p = &PushEventRepoOwner{}
	p.GetName()
	p = nil
	p.GetName()
}

func TestPushEventRepository_GetArchived(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &PushEventRepository{Archived: &zeroValue}
	p.GetArchived()
	p = &PushEventRepository{}
	p.GetArchived()
	p = nil
	p.GetArchived()
}

func TestPushEventRepository_GetArchiveURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PushEventRepository{ArchiveURL: &zeroValue}
	p.GetArchiveURL()
	p = &PushEventRepository{}
	p.GetArchiveURL()
	p = nil
	p.GetArchiveURL()
}

func TestPushEventRepository_GetCloneURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PushEventRepository{CloneURL: &zeroValue}
	p.GetCloneURL()
	p = &PushEventRepository{}
	p.GetCloneURL()
	p = nil
	p.GetCloneURL()
}

func TestPushEventRepository_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	p := &PushEventRepository{CreatedAt: &zeroValue}
	p.GetCreatedAt()
	p = &PushEventRepository{}
	p.GetCreatedAt()
	p = nil
	p.GetCreatedAt()
}

func TestPushEventRepository_GetCustomProperties(tt *testing.T) {
	tt.Parallel()
	zeroValue := map[string]any{}
	p := &PushEventRepository{CustomProperties: zeroValue}
	p.GetCustomProperties()
	p = &PushEventRepository{}
	p.GetCustomProperties()
	p = nil
	p.GetCustomProperties()
}

func TestPushEventRepository_GetDefaultBranch(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PushEventRepository{DefaultBranch: &zeroValue}
	p.GetDefaultBranch()
	p = &PushEventRepository{}
	p.GetDefaultBranch()
	p = nil
	p.GetDefaultBranch()
}

func TestPushEventRepository_GetDescription(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PushEventRepository{Description: &zeroValue}
	p.GetDescription()
	p = &PushEventRepository{}
	p.GetDescription()
	p = nil
	p.GetDescription()
}

func TestPushEventRepository_GetDisabled(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &PushEventRepository{Disabled: &zeroValue}
	p.GetDisabled()
	p = &PushEventRepository{}
	p.GetDisabled()
	p = nil
	p.GetDisabled()
}

func TestPushEventRepository_GetFork(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &PushEventRepository{Fork: &zeroValue}
	p.GetFork()
	p = &PushEventRepository{}
	p.GetFork()
	p = nil
	p.GetFork()
}

func TestPushEventRepository_GetForksCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	p := &PushEventRepository{ForksCount: &zeroValue}
	p.GetForksCount()
	p = &PushEventRepository{}
	p.GetForksCount()
	p = nil
	p.GetForksCount()
}

func TestPushEventRepository_GetFullName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PushEventRepository{FullName: &zeroValue}
	p.GetFullName()
	p = &PushEventRepository{}
	p.GetFullName()
	p = nil
	p.GetFullName()
}

func TestPushEventRepository_GetGitURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PushEventRepository{GitURL: &zeroValue}
	p.GetGitURL()
	p = &PushEventRepository{}
	p.GetGitURL()
	p = nil
	p.GetGitURL()
}

func TestPushEventRepository_GetHasDownloads(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &PushEventRepository{HasDownloads: &zeroValue}
	p.GetHasDownloads()
	p = &PushEventRepository{}
	p.GetHasDownloads()
	p = nil
	p.GetHasDownloads()
}

func TestPushEventRepository_GetHasIssues(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &PushEventRepository{HasIssues: &zeroValue}
	p.GetHasIssues()
	p = &PushEventRepository{}
	p.GetHasIssues()
	p = nil
	p.GetHasIssues()
}

func TestPushEventRepository_GetHasPages(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &PushEventRepository{HasPages: &zeroValue}
	p.GetHasPages()
	p = &PushEventRepository{}
	p.GetHasPages()
	p = nil
	p.GetHasPages()
}

func TestPushEventRepository_GetHasWiki(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &PushEventRepository{HasWiki: &zeroValue}
	p.GetHasWiki()
	p = &PushEventRepository{}
	p.GetHasWiki()
	p = nil
	p.GetHasWiki()
}

func TestPushEventRepository_GetHomepage(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PushEventRepository{Homepage: &zeroValue}
	p.GetHomepage()
	p = &PushEventRepository{}
	p.GetHomepage()
	p = nil
	p.GetHomepage()
}

func TestPushEventRepository_GetHTMLURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PushEventRepository{HTMLURL: &zeroValue}
	p.GetHTMLURL()
	p = &PushEventRepository{}
	p.GetHTMLURL()
	p = nil
	p.GetHTMLURL()
}

func TestPushEventRepository_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	p := &PushEventRepository{ID: &zeroValue}
	p.GetID()
	p = &PushEventRepository{}
	p.GetID()
	p = nil
	p.GetID()
}

func TestPushEventRepository_GetLanguage(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PushEventRepository{Language: &zeroValue}
	p.GetLanguage()
	p = &PushEventRepository{}
	p.GetLanguage()
	p = nil
	p.GetLanguage()
}

func TestPushEventRepository_GetMasterBranch(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PushEventRepository{MasterBranch: &zeroValue}
	p.GetMasterBranch()
	p = &PushEventRepository{}
	p.GetMasterBranch()
	p = nil
	p.GetMasterBranch()
}

func TestPushEventRepository_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PushEventRepository{Name: &zeroValue}
	p.GetName()
	p = &PushEventRepository{}
	p.GetName()
	p = nil
	p.GetName()
}

func TestPushEventRepository_GetNodeID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PushEventRepository{NodeID: &zeroValue}
	p.GetNodeID()
	p = &PushEventRepository{}
	p.GetNodeID()
	p = nil
	p.GetNodeID()
}

func TestPushEventRepository_GetOpenIssuesCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	p := &PushEventRepository{OpenIssuesCount: &zeroValue}
	p.GetOpenIssuesCount()
	p = &PushEventRepository{}
	p.GetOpenIssuesCount()
	p = nil
	p.GetOpenIssuesCount()
}

func TestPushEventRepository_GetOrganization(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PushEventRepository{Organization: &zeroValue}
	p.GetOrganization()
	p = &PushEventRepository{}
	p.GetOrganization()
	p = nil
	p.GetOrganization()
}

func TestPushEventRepository_GetOwner(tt *testing.T) {
	tt.Parallel()
	p := &PushEventRepository{}
	p.GetOwner()
	p = nil
	p.GetOwner()
}

func TestPushEventRepository_GetPrivate(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	p := &PushEventRepository{Private: &zeroValue}
	p.GetPrivate()
	p = &PushEventRepository{}
	p.GetPrivate()
	p = nil
	p.GetPrivate()
}

func TestPushEventRepository_GetPullsURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PushEventRepository{PullsURL: &zeroValue}
	p.GetPullsURL()
	p = &PushEventRepository{}
	p.GetPullsURL()
	p = nil
	p.GetPullsURL()
}

func TestPushEventRepository_GetPushedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	p := &PushEventRepository{PushedAt: &zeroValue}
	p.GetPushedAt()
	p = &PushEventRepository{}
	p.GetPushedAt()
	p = nil
	p.GetPushedAt()
}

func TestPushEventRepository_GetSize(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	p := &PushEventRepository{Size: &zeroValue}
	p.GetSize()
	p = &PushEventRepository{}
	p.GetSize()
	p = nil
	p.GetSize()
}

func TestPushEventRepository_GetSSHURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PushEventRepository{SSHURL: &zeroValue}
	p.GetSSHURL()
	p = &PushEventRepository{}
	p.GetSSHURL()
	p = nil
	p.GetSSHURL()
}

func TestPushEventRepository_GetStargazersCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	p := &PushEventRepository{StargazersCount: &zeroValue}
	p.GetStargazersCount()
	p = &PushEventRepository{}
	p.GetStargazersCount()
	p = nil
	p.GetStargazersCount()
}

func TestPushEventRepository_GetStatusesURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PushEventRepository{StatusesURL: &zeroValue}
	p.GetStatusesURL()
	p = &PushEventRepository{}
	p.GetStatusesURL()
	p = nil
	p.GetStatusesURL()
}

func TestPushEventRepository_GetSVNURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PushEventRepository{SVNURL: &zeroValue}
	p.GetSVNURL()
	p = &PushEventRepository{}
	p.GetSVNURL()
	p = nil
	p.GetSVNURL()
}

func TestPushEventRepository_GetTopics(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	p := &PushEventRepository{Topics: zeroValue}
	p.GetTopics()
	p = &PushEventRepository{}
	p.GetTopics()
	p = nil
	p.GetTopics()
}

func TestPushEventRepository_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	p := &PushEventRepository{UpdatedAt: &zeroValue}
	p.GetUpdatedAt()
	p = &PushEventRepository{}
	p.GetUpdatedAt()
	p = nil
	p.GetUpdatedAt()
}

func TestPushEventRepository_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	p := &PushEventRepository{URL: &zeroValue}
	p.GetURL()
	p = &PushEventRepository{}
	p.GetURL()
	p = nil
	p.GetURL()
}

func TestPushEventRepository_GetWatchersCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	p := &PushEventRepository{WatchersCount: &zeroValue}
	p.GetWatchersCount()
	p = &PushEventRepository{}
	p.GetWatchersCount()
	p = nil
	p.GetWatchersCount()
}

func TestPushProtectionBypass_GetExpireAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	p := &PushProtectionBypass{ExpireAt: &zeroValue}
	p.GetExpireAt()
	p = &PushProtectionBypass{}
	p.GetExpireAt()
	p = nil
	p.GetExpireAt()
}

func TestPushProtectionBypass_GetReason(tt *testing.T) {
	tt.Parallel()
	p := &PushProtectionBypass{}
	p.GetReason()
	p = nil
	p.GetReason()
}

func TestPushProtectionBypass_GetTokenType(tt *testing.T) {
	tt.Parallel()
	p := &PushProtectionBypass{}
	p.GetTokenType()
	p = nil
	p.GetTokenType()
}

func TestPushProtectionBypassRequest_GetPlaceholderID(tt *testing.T) {
	tt.Parallel()
	p := &PushProtectionBypassRequest{}
	p.GetPlaceholderID()
	p = nil
	p.GetPlaceholderID()
}

func TestPushProtectionBypassRequest_GetReason(tt *testing.T) {
	tt.Parallel()
	p := &PushProtectionBypassRequest{}
	p.GetReason()
	p = nil
	p.GetReason()
}

func TestRate_GetLimit(tt *testing.T) {
	tt.Parallel()
	r := &Rate{}
	r.GetLimit()
	r = nil
	r.GetLimit()
}

func TestRate_GetRemaining(tt *testing.T) {
	tt.Parallel()
	r := &Rate{}
	r.GetRemaining()
	r = nil
	r.GetRemaining()
}

func TestRate_GetReset(tt *testing.T) {
	tt.Parallel()
	r := &Rate{}
	r.GetReset()
	r = nil
	r.GetReset()
}

func TestRate_GetResource(tt *testing.T) {
	tt.Parallel()
	r := &Rate{}
	r.GetResource()
	r = nil
	r.GetResource()
}

func TestRate_GetUsed(tt *testing.T) {
	tt.Parallel()
	r := &Rate{}
	r.GetUsed()
	r = nil
	r.GetUsed()
}

func TestRateLimitError_GetMessage(tt *testing.T) {
	tt.Parallel()
	r := &RateLimitError{}
	r.GetMessage()
	r = nil
	r.GetMessage()
}

func TestRateLimitError_GetRate(tt *testing.T) {
	tt.Parallel()
	r := &RateLimitError{}
	r.GetRate()
	r = nil
	r.GetRate()
}

func TestRateLimits_GetActionsRunnerRegistration(tt *testing.T) {
	tt.Parallel()
	r := &RateLimits{}
	r.GetActionsRunnerRegistration()
	r = nil
	r.GetActionsRunnerRegistration()
}

func TestRateLimits_GetAuditLog(tt *testing.T) {
	tt.Parallel()
	r := &RateLimits{}
	r.GetAuditLog()
	r = nil
	r.GetAuditLog()
}

func TestRateLimits_GetCodeScanningUpload(tt *testing.T) {
	tt.Parallel()
	r := &RateLimits{}
	r.GetCodeScanningUpload()
	r = nil
	r.GetCodeScanningUpload()
}

func TestRateLimits_GetCodeSearch(tt *testing.T) {
	tt.Parallel()
	r := &RateLimits{}
	r.GetCodeSearch()
	r = nil
	r.GetCodeSearch()
}

func TestRateLimits_GetCore(tt *testing.T) {
	tt.Parallel()
	r := &RateLimits{}
	r.GetCore()
	r = nil
	r.GetCore()
}

func TestRateLimits_GetDependencySBOM(tt *testing.T) {
	tt.Parallel()
	r := &RateLimits{}
	r.GetDependencySBOM()
	r = nil
	r.GetDependencySBOM()
}

func TestRateLimits_GetDependencySnapshots(tt *testing.T) {
	tt.Parallel()
	r := &RateLimits{}
	r.GetDependencySnapshots()
	r = nil
	r.GetDependencySnapshots()
}

func TestRateLimits_GetGraphQL(tt *testing.T) {
	tt.Parallel()
	r := &RateLimits{}
	r.GetGraphQL()
	r = nil
	r.GetGraphQL()
}

func TestRateLimits_GetIntegrationManifest(tt *testing.T) {
	tt.Parallel()
	r := &RateLimits{}
	r.GetIntegrationManifest()
	r = nil
	r.GetIntegrationManifest()
}

func TestRateLimits_GetSCIM(tt *testing.T) {
	tt.Parallel()
	r := &RateLimits{}
	r.GetSCIM()
	r = nil
	r.GetSCIM()
}

func TestRateLimits_GetSearch(tt *testing.T) {
	tt.Parallel()
	r := &RateLimits{}
	r.GetSearch()
	r = nil
	r.GetSearch()
}

func TestRateLimits_GetSourceImport(tt *testing.T) {
	tt.Parallel()
	r := &RateLimits{}
	r.GetSourceImport()
	r = nil
	r.GetSourceImport()
}

func TestRawOptions_GetType(tt *testing.T) {
	tt.Parallel()
	r := &RawOptions{}
	r.GetType()
	r = nil
	r.GetType()
}

func TestReaction_GetContent(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Reaction{Content: &zeroValue}
	r.GetContent()
	r = &Reaction{}
	r.GetContent()
	r = nil
	r.GetContent()
}

func TestReaction_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	r := &Reaction{CreatedAt: &zeroValue}
	r.GetCreatedAt()
	r = &Reaction{}
	r.GetCreatedAt()
	r = nil
	r.GetCreatedAt()
}

func TestReaction_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	r := &Reaction{ID: &zeroValue}
	r.GetID()
	r = &Reaction{}
	r.GetID()
	r = nil
	r.GetID()
}

func TestReaction_GetNodeID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Reaction{NodeID: &zeroValue}
	r.GetNodeID()
	r = &Reaction{}
	r.GetNodeID()
	r = nil
	r.GetNodeID()
}

func TestReaction_GetUser(tt *testing.T) {
	tt.Parallel()
	r := &Reaction{}
	r.GetUser()
	r = nil
	r.GetUser()
}

func TestReactions_GetConfused(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	r := &Reactions{Confused: &zeroValue}
	r.GetConfused()
	r = &Reactions{}
	r.GetConfused()
	r = nil
	r.GetConfused()
}

func TestReactions_GetEyes(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	r := &Reactions{Eyes: &zeroValue}
	r.GetEyes()
	r = &Reactions{}
	r.GetEyes()
	r = nil
	r.GetEyes()
}

func TestReactions_GetHeart(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	r := &Reactions{Heart: &zeroValue}
	r.GetHeart()
	r = &Reactions{}
	r.GetHeart()
	r = nil
	r.GetHeart()
}

func TestReactions_GetHooray(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	r := &Reactions{Hooray: &zeroValue}
	r.GetHooray()
	r = &Reactions{}
	r.GetHooray()
	r = nil
	r.GetHooray()
}

func TestReactions_GetLaugh(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	r := &Reactions{Laugh: &zeroValue}
	r.GetLaugh()
	r = &Reactions{}
	r.GetLaugh()
	r = nil
	r.GetLaugh()
}

func TestReactions_GetMinusOne(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	r := &Reactions{MinusOne: &zeroValue}
	r.GetMinusOne()
	r = &Reactions{}
	r.GetMinusOne()
	r = nil
	r.GetMinusOne()
}

func TestReactions_GetPlusOne(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	r := &Reactions{PlusOne: &zeroValue}
	r.GetPlusOne()
	r = &Reactions{}
	r.GetPlusOne()
	r = nil
	r.GetPlusOne()
}

func TestReactions_GetRocket(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	r := &Reactions{Rocket: &zeroValue}
	r.GetRocket()
	r = &Reactions{}
	r.GetRocket()
	r = nil
	r.GetRocket()
}

func TestReactions_GetTotalCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	r := &Reactions{TotalCount: &zeroValue}
	r.GetTotalCount()
	r = &Reactions{}
	r.GetTotalCount()
	r = nil
	r.GetTotalCount()
}

func TestReactions_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Reactions{URL: &zeroValue}
	r.GetURL()
	r = &Reactions{}
	r.GetURL()
	r = nil
	r.GetURL()
}

func TestReassignedResource_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &ReassignedResource{Name: &zeroValue}
	r.GetName()
	r = &ReassignedResource{}
	r.GetName()
	r = nil
	r.GetName()
}

func TestReassignedResource_GetPreviousCostCenter(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &ReassignedResource{PreviousCostCenter: &zeroValue}
	r.GetPreviousCostCenter()
	r = &ReassignedResource{}
	r.GetPreviousCostCenter()
	r = nil
	r.GetPreviousCostCenter()
}

func TestReassignedResource_GetResourceType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &ReassignedResource{ResourceType: &zeroValue}
	r.GetResourceType()
	r = &ReassignedResource{}
	r.GetResourceType()
	r = nil
	r.GetResourceType()
}

func TestRedirectionError_GetStatusCode(tt *testing.T) {
	tt.Parallel()
	r := &RedirectionError{}
	r.GetStatusCode()
	r = nil
	r.GetStatusCode()
}

func TestReference_GetNodeID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Reference{NodeID: &zeroValue}
	r.GetNodeID()
	r = &Reference{}
	r.GetNodeID()
	r = nil
	r.GetNodeID()
}

func TestReference_GetObject(tt *testing.T) {
	tt.Parallel()
	r := &Reference{}
	r.GetObject()
	r = nil
	r.GetObject()
}

func TestReference_GetRef(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Reference{Ref: &zeroValue}
	r.GetRef()
	r = &Reference{}
	r.GetRef()
	r = nil
	r.GetRef()
}

func TestReference_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Reference{URL: &zeroValue}
	r.GetURL()
	r = &Reference{}
	r.GetURL()
	r = nil
	r.GetURL()
}

func TestReferencedWorkflow_GetPath(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &ReferencedWorkflow{Path: &zeroValue}
	r.GetPath()
	r = &ReferencedWorkflow{}
	r.GetPath()
	r = nil
	r.GetPath()
}

func TestReferencedWorkflow_GetRef(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &ReferencedWorkflow{Ref: &zeroValue}
	r.GetRef()
	r = &ReferencedWorkflow{}
	r.GetRef()
	r = nil
	r.GetRef()
}

func TestReferencedWorkflow_GetSHA(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &ReferencedWorkflow{SHA: &zeroValue}
	r.GetSHA()
	r = &ReferencedWorkflow{}
	r.GetSHA()
	r = nil
	r.GetSHA()
}

func TestRegistrationToken_GetExpiresAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	r := &RegistrationToken{ExpiresAt: &zeroValue}
	r.GetExpiresAt()
	r = &RegistrationToken{}
	r.GetExpiresAt()
	r = nil
	r.GetExpiresAt()
}

func TestRegistrationToken_GetToken(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RegistrationToken{Token: &zeroValue}
	r.GetToken()
	r = &RegistrationToken{}
	r.GetToken()
	r = nil
	r.GetToken()
}

func TestRegistryPackageEvent_GetAction(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RegistryPackageEvent{Action: &zeroValue}
	r.GetAction()
	r = &RegistryPackageEvent{}
	r.GetAction()
	r = nil
	r.GetAction()
}

func TestRegistryPackageEvent_GetEnterprise(tt *testing.T) {
	tt.Parallel()
	r := &RegistryPackageEvent{}
	r.GetEnterprise()
	r = nil
	r.GetEnterprise()
}

func TestRegistryPackageEvent_GetInstallation(tt *testing.T) {
	tt.Parallel()
	r := &RegistryPackageEvent{}
	r.GetInstallation()
	r = nil
	r.GetInstallation()
}

func TestRegistryPackageEvent_GetOrganization(tt *testing.T) {
	tt.Parallel()
	r := &RegistryPackageEvent{}
	r.GetOrganization()
	r = nil
	r.GetOrganization()
}

func TestRegistryPackageEvent_GetRegistryPackage(tt *testing.T) {
	tt.Parallel()
	r := &RegistryPackageEvent{}
	r.GetRegistryPackage()
	r = nil
	r.GetRegistryPackage()
}

func TestRegistryPackageEvent_GetRepository(tt *testing.T) {
	tt.Parallel()
	r := &RegistryPackageEvent{}
	r.GetRepository()
	r = nil
	r.GetRepository()
}

func TestRegistryPackageEvent_GetSender(tt *testing.T) {
	tt.Parallel()
	r := &RegistryPackageEvent{}
	r.GetSender()
	r = nil
	r.GetSender()
}

func TestReleaseAsset_GetBrowserDownloadURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &ReleaseAsset{BrowserDownloadURL: &zeroValue}
	r.GetBrowserDownloadURL()
	r = &ReleaseAsset{}
	r.GetBrowserDownloadURL()
	r = nil
	r.GetBrowserDownloadURL()
}

func TestReleaseAsset_GetContentType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &ReleaseAsset{ContentType: &zeroValue}
	r.GetContentType()
	r = &ReleaseAsset{}
	r.GetContentType()
	r = nil
	r.GetContentType()
}

func TestReleaseAsset_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	r := &ReleaseAsset{CreatedAt: &zeroValue}
	r.GetCreatedAt()
	r = &ReleaseAsset{}
	r.GetCreatedAt()
	r = nil
	r.GetCreatedAt()
}

func TestReleaseAsset_GetDigest(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &ReleaseAsset{Digest: &zeroValue}
	r.GetDigest()
	r = &ReleaseAsset{}
	r.GetDigest()
	r = nil
	r.GetDigest()
}

func TestReleaseAsset_GetDownloadCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	r := &ReleaseAsset{DownloadCount: &zeroValue}
	r.GetDownloadCount()
	r = &ReleaseAsset{}
	r.GetDownloadCount()
	r = nil
	r.GetDownloadCount()
}

func TestReleaseAsset_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	r := &ReleaseAsset{ID: &zeroValue}
	r.GetID()
	r = &ReleaseAsset{}
	r.GetID()
	r = nil
	r.GetID()
}

func TestReleaseAsset_GetLabel(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &ReleaseAsset{Label: &zeroValue}
	r.GetLabel()
	r = &ReleaseAsset{}
	r.GetLabel()
	r = nil
	r.GetLabel()
}

func TestReleaseAsset_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &ReleaseAsset{Name: &zeroValue}
	r.GetName()
	r = &ReleaseAsset{}
	r.GetName()
	r = nil
	r.GetName()
}

func TestReleaseAsset_GetNodeID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &ReleaseAsset{NodeID: &zeroValue}
	r.GetNodeID()
	r = &ReleaseAsset{}
	r.GetNodeID()
	r = nil
	r.GetNodeID()
}

func TestReleaseAsset_GetSize(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	r := &ReleaseAsset{Size: &zeroValue}
	r.GetSize()
	r = &ReleaseAsset{}
	r.GetSize()
	r = nil
	r.GetSize()
}

func TestReleaseAsset_GetState(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &ReleaseAsset{State: &zeroValue}
	r.GetState()
	r = &ReleaseAsset{}
	r.GetState()
	r = nil
	r.GetState()
}

func TestReleaseAsset_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	r := &ReleaseAsset{UpdatedAt: &zeroValue}
	r.GetUpdatedAt()
	r = &ReleaseAsset{}
	r.GetUpdatedAt()
	r = nil
	r.GetUpdatedAt()
}

func TestReleaseAsset_GetUploader(tt *testing.T) {
	tt.Parallel()
	r := &ReleaseAsset{}
	r.GetUploader()
	r = nil
	r.GetUploader()
}

func TestReleaseAsset_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &ReleaseAsset{URL: &zeroValue}
	r.GetURL()
	r = &ReleaseAsset{}
	r.GetURL()
	r = nil
	r.GetURL()
}

func TestReleaseEvent_GetAction(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &ReleaseEvent{Action: &zeroValue}
	r.GetAction()
	r = &ReleaseEvent{}
	r.GetAction()
	r = nil
	r.GetAction()
}

func TestReleaseEvent_GetInstallation(tt *testing.T) {
	tt.Parallel()
	r := &ReleaseEvent{}
	r.GetInstallation()
	r = nil
	r.GetInstallation()
}

func TestReleaseEvent_GetOrg(tt *testing.T) {
	tt.Parallel()
	r := &ReleaseEvent{}
	r.GetOrg()
	r = nil
	r.GetOrg()
}

func TestReleaseEvent_GetRelease(tt *testing.T) {
	tt.Parallel()
	r := &ReleaseEvent{}
	r.GetRelease()
	r = nil
	r.GetRelease()
}

func TestReleaseEvent_GetRepo(tt *testing.T) {
	tt.Parallel()
	r := &ReleaseEvent{}
	r.GetRepo()
	r = nil
	r.GetRepo()
}

func TestReleaseEvent_GetSender(tt *testing.T) {
	tt.Parallel()
	r := &ReleaseEvent{}
	r.GetSender()
	r = nil
	r.GetSender()
}

func TestReleaseVersion_GetBuildDate(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &ReleaseVersion{BuildDate: &zeroValue}
	r.GetBuildDate()
	r = &ReleaseVersion{}
	r.GetBuildDate()
	r = nil
	r.GetBuildDate()
}

func TestReleaseVersion_GetBuildID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &ReleaseVersion{BuildID: &zeroValue}
	r.GetBuildID()
	r = &ReleaseVersion{}
	r.GetBuildID()
	r = nil
	r.GetBuildID()
}

func TestReleaseVersion_GetPlatform(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &ReleaseVersion{Platform: &zeroValue}
	r.GetPlatform()
	r = &ReleaseVersion{}
	r.GetPlatform()
	r = nil
	r.GetPlatform()
}

func TestReleaseVersion_GetVersion(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &ReleaseVersion{Version: &zeroValue}
	r.GetVersion()
	r = &ReleaseVersion{}
	r.GetVersion()
	r = nil
	r.GetVersion()
}

func TestRemoveResourcesFromCostCenterResponse_GetMessage(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RemoveResourcesFromCostCenterResponse{Message: &zeroValue}
	r.GetMessage()
	r = &RemoveResourcesFromCostCenterResponse{}
	r.GetMessage()
	r = nil
	r.GetMessage()
}

func TestRemoveToken_GetExpiresAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	r := &RemoveToken{ExpiresAt: &zeroValue}
	r.GetExpiresAt()
	r = &RemoveToken{}
	r.GetExpiresAt()
	r = nil
	r.GetExpiresAt()
}

func TestRemoveToken_GetToken(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RemoveToken{Token: &zeroValue}
	r.GetToken()
	r = &RemoveToken{}
	r.GetToken()
	r = nil
	r.GetToken()
}

func TestRename_GetFrom(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Rename{From: &zeroValue}
	r.GetFrom()
	r = &Rename{}
	r.GetFrom()
	r = nil
	r.GetFrom()
}

func TestRename_GetTo(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Rename{To: &zeroValue}
	r.GetTo()
	r = &Rename{}
	r.GetTo()
	r = nil
	r.GetTo()
}

func TestRenameOrgResponse_GetMessage(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RenameOrgResponse{Message: &zeroValue}
	r.GetMessage()
	r = &RenameOrgResponse{}
	r.GetMessage()
	r = nil
	r.GetMessage()
}

func TestRenameOrgResponse_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RenameOrgResponse{URL: &zeroValue}
	r.GetURL()
	r = &RenameOrgResponse{}
	r.GetURL()
	r = nil
	r.GetURL()
}

func TestRepoAdvisoryCredit_GetLogin(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepoAdvisoryCredit{Login: &zeroValue}
	r.GetLogin()
	r = &RepoAdvisoryCredit{}
	r.GetLogin()
	r = nil
	r.GetLogin()
}

func TestRepoAdvisoryCredit_GetType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepoAdvisoryCredit{Type: &zeroValue}
	r.GetType()
	r = &RepoAdvisoryCredit{}
	r.GetType()
	r = nil
	r.GetType()
}

func TestRepoAdvisoryCreditDetailed_GetState(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepoAdvisoryCreditDetailed{State: &zeroValue}
	r.GetState()
	r = &RepoAdvisoryCreditDetailed{}
	r.GetState()
	r = nil
	r.GetState()
}

func TestRepoAdvisoryCreditDetailed_GetType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepoAdvisoryCreditDetailed{Type: &zeroValue}
	r.GetType()
	r = &RepoAdvisoryCreditDetailed{}
	r.GetType()
	r = nil
	r.GetType()
}

func TestRepoAdvisoryCreditDetailed_GetUser(tt *testing.T) {
	tt.Parallel()
	r := &RepoAdvisoryCreditDetailed{}
	r.GetUser()
	r = nil
	r.GetUser()
}

func TestRepoCustomPropertyValue_GetProperties(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*CustomPropertyValue{}
	r := &RepoCustomPropertyValue{Properties: zeroValue}
	r.GetProperties()
	r = &RepoCustomPropertyValue{}
	r.GetProperties()
	r = nil
	r.GetProperties()
}

func TestRepoCustomPropertyValue_GetRepositoryFullName(tt *testing.T) {
	tt.Parallel()
	r := &RepoCustomPropertyValue{}
	r.GetRepositoryFullName()
	r = nil
	r.GetRepositoryFullName()
}

func TestRepoCustomPropertyValue_GetRepositoryID(tt *testing.T) {
	tt.Parallel()
	r := &RepoCustomPropertyValue{}
	r.GetRepositoryID()
	r = nil
	r.GetRepositoryID()
}

func TestRepoCustomPropertyValue_GetRepositoryName(tt *testing.T) {
	tt.Parallel()
	r := &RepoCustomPropertyValue{}
	r.GetRepositoryName()
	r = nil
	r.GetRepositoryName()
}

func TestRepoDependencies_GetDownloadLocation(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepoDependencies{DownloadLocation: &zeroValue}
	r.GetDownloadLocation()
	r = &RepoDependencies{}
	r.GetDownloadLocation()
	r = nil
	r.GetDownloadLocation()
}

func TestRepoDependencies_GetExternalRefs(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*PackageExternalRef{}
	r := &RepoDependencies{ExternalRefs: zeroValue}
	r.GetExternalRefs()
	r = &RepoDependencies{}
	r.GetExternalRefs()
	r = nil
	r.GetExternalRefs()
}

func TestRepoDependencies_GetFilesAnalyzed(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	r := &RepoDependencies{FilesAnalyzed: &zeroValue}
	r.GetFilesAnalyzed()
	r = &RepoDependencies{}
	r.GetFilesAnalyzed()
	r = nil
	r.GetFilesAnalyzed()
}

func TestRepoDependencies_GetLicenseConcluded(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepoDependencies{LicenseConcluded: &zeroValue}
	r.GetLicenseConcluded()
	r = &RepoDependencies{}
	r.GetLicenseConcluded()
	r = nil
	r.GetLicenseConcluded()
}

func TestRepoDependencies_GetLicenseDeclared(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepoDependencies{LicenseDeclared: &zeroValue}
	r.GetLicenseDeclared()
	r = &RepoDependencies{}
	r.GetLicenseDeclared()
	r = nil
	r.GetLicenseDeclared()
}

func TestRepoDependencies_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepoDependencies{Name: &zeroValue}
	r.GetName()
	r = &RepoDependencies{}
	r.GetName()
	r = nil
	r.GetName()
}

func TestRepoDependencies_GetSPDXID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepoDependencies{SPDXID: &zeroValue}
	r.GetSPDXID()
	r = &RepoDependencies{}
	r.GetSPDXID()
	r = nil
	r.GetSPDXID()
}

func TestRepoDependencies_GetVersionInfo(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepoDependencies{VersionInfo: &zeroValue}
	r.GetVersionInfo()
	r = &RepoDependencies{}
	r.GetVersionInfo()
	r = nil
	r.GetVersionInfo()
}

func TestRepoFineGrainedPermission_GetDescription(tt *testing.T) {
	tt.Parallel()
	r := &RepoFineGrainedPermission{}
	r.GetDescription()
	r = nil
	r.GetDescription()
}

func TestRepoFineGrainedPermission_GetName(tt *testing.T) {
	tt.Parallel()
	r := &RepoFineGrainedPermission{}
	r.GetName()
	r = nil
	r.GetName()
}

func TestRepoImmutableReleasesStatus_GetEnabled(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	r := &RepoImmutableReleasesStatus{Enabled: &zeroValue}
	r.GetEnabled()
	r = &RepoImmutableReleasesStatus{}
	r.GetEnabled()
	r = nil
	r.GetEnabled()
}

func TestRepoImmutableReleasesStatus_GetEnforcedByOwner(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	r := &RepoImmutableReleasesStatus{EnforcedByOwner: &zeroValue}
	r.GetEnforcedByOwner()
	r = &RepoImmutableReleasesStatus{}
	r.GetEnforcedByOwner()
	r = nil
	r.GetEnforcedByOwner()
}

func TestRepoMergeUpstreamRequest_GetBranch(tt *testing.T) {
	tt.Parallel()
	r := &RepoMergeUpstreamRequest{}
	r.GetBranch()
	r = nil
	r.GetBranch()
}

func TestRepoMergeUpstreamResult_GetBaseBranch(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepoMergeUpstreamResult{BaseBranch: &zeroValue}
	r.GetBaseBranch()
	r = &RepoMergeUpstreamResult{}
	r.GetBaseBranch()
	r = nil
	r.GetBaseBranch()
}

func TestRepoMergeUpstreamResult_GetMergeType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepoMergeUpstreamResult{MergeType: &zeroValue}
	r.GetMergeType()
	r = &RepoMergeUpstreamResult{}
	r.GetMergeType()
	r = nil
	r.GetMergeType()
}

func TestRepoMergeUpstreamResult_GetMessage(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepoMergeUpstreamResult{Message: &zeroValue}
	r.GetMessage()
	r = &RepoMergeUpstreamResult{}
	r.GetMessage()
	r = nil
	r.GetMessage()
}

func TestRepoName_GetFrom(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepoName{From: &zeroValue}
	r.GetFrom()
	r = &RepoName{}
	r.GetFrom()
	r = nil
	r.GetFrom()
}

func TestRepositoriesSearchResult_GetIncompleteResults(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	r := &RepositoriesSearchResult{IncompleteResults: &zeroValue}
	r.GetIncompleteResults()
	r = &RepositoriesSearchResult{}
	r.GetIncompleteResults()
	r = nil
	r.GetIncompleteResults()
}

func TestRepositoriesSearchResult_GetRepositories(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*Repository{}
	r := &RepositoriesSearchResult{Repositories: zeroValue}
	r.GetRepositories()
	r = &RepositoriesSearchResult{}
	r.GetRepositories()
	r = nil
	r.GetRepositories()
}

func TestRepositoriesSearchResult_GetTotal(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	r := &RepositoriesSearchResult{Total: &zeroValue}
	r.GetTotal()
	r = &RepositoriesSearchResult{}
	r.GetTotal()
	r = nil
	r.GetTotal()
}

func TestRepository_GetAllowAutoMerge(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	r := &Repository{AllowAutoMerge: &zeroValue}
	r.GetAllowAutoMerge()
	r = &Repository{}
	r.GetAllowAutoMerge()
	r = nil
	r.GetAllowAutoMerge()
}

func TestRepository_GetAllowForking(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	r := &Repository{AllowForking: &zeroValue}
	r.GetAllowForking()
	r = &Repository{}
	r.GetAllowForking()
	r = nil
	r.GetAllowForking()
}

func TestRepository_GetAllowMergeCommit(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	r := &Repository{AllowMergeCommit: &zeroValue}
	r.GetAllowMergeCommit()
	r = &Repository{}
	r.GetAllowMergeCommit()
	r = nil
	r.GetAllowMergeCommit()
}

func TestRepository_GetAllowRebaseMerge(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	r := &Repository{AllowRebaseMerge: &zeroValue}
	r.GetAllowRebaseMerge()
	r = &Repository{}
	r.GetAllowRebaseMerge()
	r = nil
	r.GetAllowRebaseMerge()
}

func TestRepository_GetAllowSquashMerge(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	r := &Repository{AllowSquashMerge: &zeroValue}
	r.GetAllowSquashMerge()
	r = &Repository{}
	r.GetAllowSquashMerge()
	r = nil
	r.GetAllowSquashMerge()
}

func TestRepository_GetAllowUpdateBranch(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	r := &Repository{AllowUpdateBranch: &zeroValue}
	r.GetAllowUpdateBranch()
	r = &Repository{}
	r.GetAllowUpdateBranch()
	r = nil
	r.GetAllowUpdateBranch()
}

func TestRepository_GetArchived(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	r := &Repository{Archived: &zeroValue}
	r.GetArchived()
	r = &Repository{}
	r.GetArchived()
	r = nil
	r.GetArchived()
}

func TestRepository_GetArchiveURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Repository{ArchiveURL: &zeroValue}
	r.GetArchiveURL()
	r = &Repository{}
	r.GetArchiveURL()
	r = nil
	r.GetArchiveURL()
}

func TestRepository_GetAssigneesURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Repository{AssigneesURL: &zeroValue}
	r.GetAssigneesURL()
	r = &Repository{}
	r.GetAssigneesURL()
	r = nil
	r.GetAssigneesURL()
}

func TestRepository_GetAutoInit(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	r := &Repository{AutoInit: &zeroValue}
	r.GetAutoInit()
	r = &Repository{}
	r.GetAutoInit()
	r = nil
	r.GetAutoInit()
}

func TestRepository_GetBlobsURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Repository{BlobsURL: &zeroValue}
	r.GetBlobsURL()
	r = &Repository{}
	r.GetBlobsURL()
	r = nil
	r.GetBlobsURL()
}

func TestRepository_GetBranchesURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Repository{BranchesURL: &zeroValue}
	r.GetBranchesURL()
	r = &Repository{}
	r.GetBranchesURL()
	r = nil
	r.GetBranchesURL()
}

func TestRepository_GetCloneURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Repository{CloneURL: &zeroValue}
	r.GetCloneURL()
	r = &Repository{}
	r.GetCloneURL()
	r = nil
	r.GetCloneURL()
}

func TestRepository_GetCodeOfConduct(tt *testing.T) {
	tt.Parallel()
	r := &Repository{}
	r.GetCodeOfConduct()
	r = nil
	r.GetCodeOfConduct()
}

func TestRepository_GetCollaboratorsURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Repository{CollaboratorsURL: &zeroValue}
	r.GetCollaboratorsURL()
	r = &Repository{}
	r.GetCollaboratorsURL()
	r = nil
	r.GetCollaboratorsURL()
}

func TestRepository_GetCommentsURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Repository{CommentsURL: &zeroValue}
	r.GetCommentsURL()
	r = &Repository{}
	r.GetCommentsURL()
	r = nil
	r.GetCommentsURL()
}

func TestRepository_GetCommitsURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Repository{CommitsURL: &zeroValue}
	r.GetCommitsURL()
	r = &Repository{}
	r.GetCommitsURL()
	r = nil
	r.GetCommitsURL()
}

func TestRepository_GetCompareURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Repository{CompareURL: &zeroValue}
	r.GetCompareURL()
	r = &Repository{}
	r.GetCompareURL()
	r = nil
	r.GetCompareURL()
}

func TestRepository_GetContentsURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Repository{ContentsURL: &zeroValue}
	r.GetContentsURL()
	r = &Repository{}
	r.GetContentsURL()
	r = nil
	r.GetContentsURL()
}

func TestRepository_GetContributorsURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Repository{ContributorsURL: &zeroValue}
	r.GetContributorsURL()
	r = &Repository{}
	r.GetContributorsURL()
	r = nil
	r.GetContributorsURL()
}

func TestRepository_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	r := &Repository{CreatedAt: &zeroValue}
	r.GetCreatedAt()
	r = &Repository{}
	r.GetCreatedAt()
	r = nil
	r.GetCreatedAt()
}

func TestRepository_GetCustomProperties(tt *testing.T) {
	tt.Parallel()
	zeroValue := map[string]any{}
	r := &Repository{CustomProperties: zeroValue}
	r.GetCustomProperties()
	r = &Repository{}
	r.GetCustomProperties()
	r = nil
	r.GetCustomProperties()
}

func TestRepository_GetDefaultBranch(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Repository{DefaultBranch: &zeroValue}
	r.GetDefaultBranch()
	r = &Repository{}
	r.GetDefaultBranch()
	r = nil
	r.GetDefaultBranch()
}

func TestRepository_GetDeleteBranchOnMerge(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	r := &Repository{DeleteBranchOnMerge: &zeroValue}
	r.GetDeleteBranchOnMerge()
	r = &Repository{}
	r.GetDeleteBranchOnMerge()
	r = nil
	r.GetDeleteBranchOnMerge()
}

func TestRepository_GetDeploymentsURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Repository{DeploymentsURL: &zeroValue}
	r.GetDeploymentsURL()
	r = &Repository{}
	r.GetDeploymentsURL()
	r = nil
	r.GetDeploymentsURL()
}

func TestRepository_GetDescription(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Repository{Description: &zeroValue}
	r.GetDescription()
	r = &Repository{}
	r.GetDescription()
	r = nil
	r.GetDescription()
}

func TestRepository_GetDisabled(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	r := &Repository{Disabled: &zeroValue}
	r.GetDisabled()
	r = &Repository{}
	r.GetDisabled()
	r = nil
	r.GetDisabled()
}

func TestRepository_GetDownloadsURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Repository{DownloadsURL: &zeroValue}
	r.GetDownloadsURL()
	r = &Repository{}
	r.GetDownloadsURL()
	r = nil
	r.GetDownloadsURL()
}

func TestRepository_GetEventsURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Repository{EventsURL: &zeroValue}
	r.GetEventsURL()
	r = &Repository{}
	r.GetEventsURL()
	r = nil
	r.GetEventsURL()
}

func TestRepository_GetFork(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	r := &Repository{Fork: &zeroValue}
	r.GetFork()
	r = &Repository{}
	r.GetFork()
	r = nil
	r.GetFork()
}

func TestRepository_GetForksCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	r := &Repository{ForksCount: &zeroValue}
	r.GetForksCount()
	r = &Repository{}
	r.GetForksCount()
	r = nil
	r.GetForksCount()
}

func TestRepository_GetForksURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Repository{ForksURL: &zeroValue}
	r.GetForksURL()
	r = &Repository{}
	r.GetForksURL()
	r = nil
	r.GetForksURL()
}

func TestRepository_GetFullName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Repository{FullName: &zeroValue}
	r.GetFullName()
	r = &Repository{}
	r.GetFullName()
	r = nil
	r.GetFullName()
}

func TestRepository_GetGitCommitsURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Repository{GitCommitsURL: &zeroValue}
	r.GetGitCommitsURL()
	r = &Repository{}
	r.GetGitCommitsURL()
	r = nil
	r.GetGitCommitsURL()
}

func TestRepository_GetGitignoreTemplate(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Repository{GitignoreTemplate: &zeroValue}
	r.GetGitignoreTemplate()
	r = &Repository{}
	r.GetGitignoreTemplate()
	r = nil
	r.GetGitignoreTemplate()
}

func TestRepository_GetGitRefsURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Repository{GitRefsURL: &zeroValue}
	r.GetGitRefsURL()
	r = &Repository{}
	r.GetGitRefsURL()
	r = nil
	r.GetGitRefsURL()
}

func TestRepository_GetGitTagsURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Repository{GitTagsURL: &zeroValue}
	r.GetGitTagsURL()
	r = &Repository{}
	r.GetGitTagsURL()
	r = nil
	r.GetGitTagsURL()
}

func TestRepository_GetGitURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Repository{GitURL: &zeroValue}
	r.GetGitURL()
	r = &Repository{}
	r.GetGitURL()
	r = nil
	r.GetGitURL()
}

func TestRepository_GetHasDiscussions(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	r := &Repository{HasDiscussions: &zeroValue}
	r.GetHasDiscussions()
	r = &Repository{}
	r.GetHasDiscussions()
	r = nil
	r.GetHasDiscussions()
}

func TestRepository_GetHasDownloads(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	r := &Repository{HasDownloads: &zeroValue}
	r.GetHasDownloads()
	r = &Repository{}
	r.GetHasDownloads()
	r = nil
	r.GetHasDownloads()
}

func TestRepository_GetHasIssues(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	r := &Repository{HasIssues: &zeroValue}
	r.GetHasIssues()
	r = &Repository{}
	r.GetHasIssues()
	r = nil
	r.GetHasIssues()
}

func TestRepository_GetHasPages(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	r := &Repository{HasPages: &zeroValue}
	r.GetHasPages()
	r = &Repository{}
	r.GetHasPages()
	r = nil
	r.GetHasPages()
}

func TestRepository_GetHasProjects(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	r := &Repository{HasProjects: &zeroValue}
	r.GetHasProjects()
	r = &Repository{}
	r.GetHasProjects()
	r = nil
	r.GetHasProjects()
}

func TestRepository_GetHasPullRequests(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	r := &Repository{HasPullRequests: &zeroValue}
	r.GetHasPullRequests()
	r = &Repository{}
	r.GetHasPullRequests()
	r = nil
	r.GetHasPullRequests()
}

func TestRepository_GetHasWiki(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	r := &Repository{HasWiki: &zeroValue}
	r.GetHasWiki()
	r = &Repository{}
	r.GetHasWiki()
	r = nil
	r.GetHasWiki()
}

func TestRepository_GetHomepage(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Repository{Homepage: &zeroValue}
	r.GetHomepage()
	r = &Repository{}
	r.GetHomepage()
	r = nil
	r.GetHomepage()
}

func TestRepository_GetHooksURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Repository{HooksURL: &zeroValue}
	r.GetHooksURL()
	r = &Repository{}
	r.GetHooksURL()
	r = nil
	r.GetHooksURL()
}

func TestRepository_GetHTMLURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Repository{HTMLURL: &zeroValue}
	r.GetHTMLURL()
	r = &Repository{}
	r.GetHTMLURL()
	r = nil
	r.GetHTMLURL()
}

func TestRepository_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	r := &Repository{ID: &zeroValue}
	r.GetID()
	r = &Repository{}
	r.GetID()
	r = nil
	r.GetID()
}

func TestRepository_GetIssueCommentURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Repository{IssueCommentURL: &zeroValue}
	r.GetIssueCommentURL()
	r = &Repository{}
	r.GetIssueCommentURL()
	r = nil
	r.GetIssueCommentURL()
}

func TestRepository_GetIssueEventsURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Repository{IssueEventsURL: &zeroValue}
	r.GetIssueEventsURL()
	r = &Repository{}
	r.GetIssueEventsURL()
	r = nil
	r.GetIssueEventsURL()
}

func TestRepository_GetIssuesURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Repository{IssuesURL: &zeroValue}
	r.GetIssuesURL()
	r = &Repository{}
	r.GetIssuesURL()
	r = nil
	r.GetIssuesURL()
}

func TestRepository_GetIsTemplate(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	r := &Repository{IsTemplate: &zeroValue}
	r.GetIsTemplate()
	r = &Repository{}
	r.GetIsTemplate()
	r = nil
	r.GetIsTemplate()
}

func TestRepository_GetKeysURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Repository{KeysURL: &zeroValue}
	r.GetKeysURL()
	r = &Repository{}
	r.GetKeysURL()
	r = nil
	r.GetKeysURL()
}

func TestRepository_GetLabelsURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Repository{LabelsURL: &zeroValue}
	r.GetLabelsURL()
	r = &Repository{}
	r.GetLabelsURL()
	r = nil
	r.GetLabelsURL()
}

func TestRepository_GetLanguage(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Repository{Language: &zeroValue}
	r.GetLanguage()
	r = &Repository{}
	r.GetLanguage()
	r = nil
	r.GetLanguage()
}

func TestRepository_GetLanguagesURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Repository{LanguagesURL: &zeroValue}
	r.GetLanguagesURL()
	r = &Repository{}
	r.GetLanguagesURL()
	r = nil
	r.GetLanguagesURL()
}

func TestRepository_GetLicense(tt *testing.T) {
	tt.Parallel()
	r := &Repository{}
	r.GetLicense()
	r = nil
	r.GetLicense()
}

func TestRepository_GetLicenseTemplate(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Repository{LicenseTemplate: &zeroValue}
	r.GetLicenseTemplate()
	r = &Repository{}
	r.GetLicenseTemplate()
	r = nil
	r.GetLicenseTemplate()
}

func TestRepository_GetMasterBranch(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Repository{MasterBranch: &zeroValue}
	r.GetMasterBranch()
	r = &Repository{}
	r.GetMasterBranch()
	r = nil
	r.GetMasterBranch()
}

func TestRepository_GetMergeCommitMessage(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Repository{MergeCommitMessage: &zeroValue}
	r.GetMergeCommitMessage()
	r = &Repository{}
	r.GetMergeCommitMessage()
	r = nil
	r.GetMergeCommitMessage()
}

func TestRepository_GetMergeCommitTitle(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Repository{MergeCommitTitle: &zeroValue}
	r.GetMergeCommitTitle()
	r = &Repository{}
	r.GetMergeCommitTitle()
	r = nil
	r.GetMergeCommitTitle()
}

func TestRepository_GetMergesURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Repository{MergesURL: &zeroValue}
	r.GetMergesURL()
	r = &Repository{}
	r.GetMergesURL()
	r = nil
	r.GetMergesURL()
}

func TestRepository_GetMilestonesURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Repository{MilestonesURL: &zeroValue}
	r.GetMilestonesURL()
	r = &Repository{}
	r.GetMilestonesURL()
	r = nil
	r.GetMilestonesURL()
}

func TestRepository_GetMirrorURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Repository{MirrorURL: &zeroValue}
	r.GetMirrorURL()
	r = &Repository{}
	r.GetMirrorURL()
	r = nil
	r.GetMirrorURL()
}

func TestRepository_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Repository{Name: &zeroValue}
	r.GetName()
	r = &Repository{}
	r.GetName()
	r = nil
	r.GetName()
}

func TestRepository_GetNetworkCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	r := &Repository{NetworkCount: &zeroValue}
	r.GetNetworkCount()
	r = &Repository{}
	r.GetNetworkCount()
	r = nil
	r.GetNetworkCount()
}

func TestRepository_GetNodeID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Repository{NodeID: &zeroValue}
	r.GetNodeID()
	r = &Repository{}
	r.GetNodeID()
	r = nil
	r.GetNodeID()
}

func TestRepository_GetNotificationsURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Repository{NotificationsURL: &zeroValue}
	r.GetNotificationsURL()
	r = &Repository{}
	r.GetNotificationsURL()
	r = nil
	r.GetNotificationsURL()
}

func TestRepository_GetOpenIssues(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	r := &Repository{OpenIssues: &zeroValue}
	r.GetOpenIssues()
	r = &Repository{}
	r.GetOpenIssues()
	r = nil
	r.GetOpenIssues()
}

func TestRepository_GetOpenIssuesCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	r := &Repository{OpenIssuesCount: &zeroValue}
	r.GetOpenIssuesCount()
	r = &Repository{}
	r.GetOpenIssuesCount()
	r = nil
	r.GetOpenIssuesCount()
}

func TestRepository_GetOrganization(tt *testing.T) {
	tt.Parallel()
	r := &Repository{}
	r.GetOrganization()
	r = nil
	r.GetOrganization()
}

func TestRepository_GetOwner(tt *testing.T) {
	tt.Parallel()
	r := &Repository{}
	r.GetOwner()
	r = nil
	r.GetOwner()
}

func TestRepository_GetParent(tt *testing.T) {
	tt.Parallel()
	r := &Repository{}
	r.GetParent()
	r = nil
	r.GetParent()
}

func TestRepository_GetPermissions(tt *testing.T) {
	tt.Parallel()
	r := &Repository{}
	r.GetPermissions()
	r = nil
	r.GetPermissions()
}

func TestRepository_GetPrivate(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	r := &Repository{Private: &zeroValue}
	r.GetPrivate()
	r = &Repository{}
	r.GetPrivate()
	r = nil
	r.GetPrivate()
}

func TestRepository_GetPullRequestCreationPolicy(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Repository{PullRequestCreationPolicy: &zeroValue}
	r.GetPullRequestCreationPolicy()
	r = &Repository{}
	r.GetPullRequestCreationPolicy()
	r = nil
	r.GetPullRequestCreationPolicy()
}

func TestRepository_GetPullsURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Repository{PullsURL: &zeroValue}
	r.GetPullsURL()
	r = &Repository{}
	r.GetPullsURL()
	r = nil
	r.GetPullsURL()
}

func TestRepository_GetPushedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	r := &Repository{PushedAt: &zeroValue}
	r.GetPushedAt()
	r = &Repository{}
	r.GetPushedAt()
	r = nil
	r.GetPushedAt()
}

func TestRepository_GetReleasesURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Repository{ReleasesURL: &zeroValue}
	r.GetReleasesURL()
	r = &Repository{}
	r.GetReleasesURL()
	r = nil
	r.GetReleasesURL()
}

func TestRepository_GetRoleName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Repository{RoleName: &zeroValue}
	r.GetRoleName()
	r = &Repository{}
	r.GetRoleName()
	r = nil
	r.GetRoleName()
}

func TestRepository_GetSecurityAndAnalysis(tt *testing.T) {
	tt.Parallel()
	r := &Repository{}
	r.GetSecurityAndAnalysis()
	r = nil
	r.GetSecurityAndAnalysis()
}

func TestRepository_GetSize(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	r := &Repository{Size: &zeroValue}
	r.GetSize()
	r = &Repository{}
	r.GetSize()
	r = nil
	r.GetSize()
}

func TestRepository_GetSource(tt *testing.T) {
	tt.Parallel()
	r := &Repository{}
	r.GetSource()
	r = nil
	r.GetSource()
}

func TestRepository_GetSquashMergeCommitMessage(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Repository{SquashMergeCommitMessage: &zeroValue}
	r.GetSquashMergeCommitMessage()
	r = &Repository{}
	r.GetSquashMergeCommitMessage()
	r = nil
	r.GetSquashMergeCommitMessage()
}

func TestRepository_GetSquashMergeCommitTitle(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Repository{SquashMergeCommitTitle: &zeroValue}
	r.GetSquashMergeCommitTitle()
	r = &Repository{}
	r.GetSquashMergeCommitTitle()
	r = nil
	r.GetSquashMergeCommitTitle()
}

func TestRepository_GetSSHURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Repository{SSHURL: &zeroValue}
	r.GetSSHURL()
	r = &Repository{}
	r.GetSSHURL()
	r = nil
	r.GetSSHURL()
}

func TestRepository_GetStargazersCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	r := &Repository{StargazersCount: &zeroValue}
	r.GetStargazersCount()
	r = &Repository{}
	r.GetStargazersCount()
	r = nil
	r.GetStargazersCount()
}

func TestRepository_GetStargazersURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Repository{StargazersURL: &zeroValue}
	r.GetStargazersURL()
	r = &Repository{}
	r.GetStargazersURL()
	r = nil
	r.GetStargazersURL()
}

func TestRepository_GetStatusesURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Repository{StatusesURL: &zeroValue}
	r.GetStatusesURL()
	r = &Repository{}
	r.GetStatusesURL()
	r = nil
	r.GetStatusesURL()
}

func TestRepository_GetSubscribersCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	r := &Repository{SubscribersCount: &zeroValue}
	r.GetSubscribersCount()
	r = &Repository{}
	r.GetSubscribersCount()
	r = nil
	r.GetSubscribersCount()
}

func TestRepository_GetSubscribersURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Repository{SubscribersURL: &zeroValue}
	r.GetSubscribersURL()
	r = &Repository{}
	r.GetSubscribersURL()
	r = nil
	r.GetSubscribersURL()
}

func TestRepository_GetSubscriptionURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Repository{SubscriptionURL: &zeroValue}
	r.GetSubscriptionURL()
	r = &Repository{}
	r.GetSubscriptionURL()
	r = nil
	r.GetSubscriptionURL()
}

func TestRepository_GetSVNURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Repository{SVNURL: &zeroValue}
	r.GetSVNURL()
	r = &Repository{}
	r.GetSVNURL()
	r = nil
	r.GetSVNURL()
}

func TestRepository_GetTagsURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Repository{TagsURL: &zeroValue}
	r.GetTagsURL()
	r = &Repository{}
	r.GetTagsURL()
	r = nil
	r.GetTagsURL()
}

func TestRepository_GetTeamID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	r := &Repository{TeamID: &zeroValue}
	r.GetTeamID()
	r = &Repository{}
	r.GetTeamID()
	r = nil
	r.GetTeamID()
}

func TestRepository_GetTeamsURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Repository{TeamsURL: &zeroValue}
	r.GetTeamsURL()
	r = &Repository{}
	r.GetTeamsURL()
	r = nil
	r.GetTeamsURL()
}

func TestRepository_GetTemplateRepository(tt *testing.T) {
	tt.Parallel()
	r := &Repository{}
	r.GetTemplateRepository()
	r = nil
	r.GetTemplateRepository()
}

func TestRepository_GetTextMatches(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*TextMatch{}
	r := &Repository{TextMatches: zeroValue}
	r.GetTextMatches()
	r = &Repository{}
	r.GetTextMatches()
	r = nil
	r.GetTextMatches()
}

func TestRepository_GetTopics(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	r := &Repository{Topics: zeroValue}
	r.GetTopics()
	r = &Repository{}
	r.GetTopics()
	r = nil
	r.GetTopics()
}

func TestRepository_GetTreesURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Repository{TreesURL: &zeroValue}
	r.GetTreesURL()
	r = &Repository{}
	r.GetTreesURL()
	r = nil
	r.GetTreesURL()
}

func TestRepository_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	r := &Repository{UpdatedAt: &zeroValue}
	r.GetUpdatedAt()
	r = &Repository{}
	r.GetUpdatedAt()
	r = nil
	r.GetUpdatedAt()
}

func TestRepository_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Repository{URL: &zeroValue}
	r.GetURL()
	r = &Repository{}
	r.GetURL()
	r = nil
	r.GetURL()
}

func TestRepository_GetUseSquashPRTitleAsDefault(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	r := &Repository{UseSquashPRTitleAsDefault: &zeroValue}
	r.GetUseSquashPRTitleAsDefault()
	r = &Repository{}
	r.GetUseSquashPRTitleAsDefault()
	r = nil
	r.GetUseSquashPRTitleAsDefault()
}

func TestRepository_GetVisibility(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Repository{Visibility: &zeroValue}
	r.GetVisibility()
	r = &Repository{}
	r.GetVisibility()
	r = nil
	r.GetVisibility()
}

func TestRepository_GetWatchers(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	r := &Repository{Watchers: &zeroValue}
	r.GetWatchers()
	r = &Repository{}
	r.GetWatchers()
	r = nil
	r.GetWatchers()
}

func TestRepository_GetWatchersCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	r := &Repository{WatchersCount: &zeroValue}
	r.GetWatchersCount()
	r = &Repository{}
	r.GetWatchersCount()
	r = nil
	r.GetWatchersCount()
}

func TestRepository_GetWebCommitSignoffRequired(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	r := &Repository{WebCommitSignoffRequired: &zeroValue}
	r.GetWebCommitSignoffRequired()
	r = &Repository{}
	r.GetWebCommitSignoffRequired()
	r = nil
	r.GetWebCommitSignoffRequired()
}

func TestRepositoryActionsAccessLevel_GetAccessLevel(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryActionsAccessLevel{AccessLevel: &zeroValue}
	r.GetAccessLevel()
	r = &RepositoryActionsAccessLevel{}
	r.GetAccessLevel()
	r = nil
	r.GetAccessLevel()
}

func TestRepositoryActiveCommitters_GetAdvancedSecurityCommitters(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryActiveCommitters{}
	r.GetAdvancedSecurityCommitters()
	r = nil
	r.GetAdvancedSecurityCommitters()
}

func TestRepositoryActiveCommitters_GetAdvancedSecurityCommittersBreakdown(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*AdvancedSecurityCommittersBreakdown{}
	r := &RepositoryActiveCommitters{AdvancedSecurityCommittersBreakdown: zeroValue}
	r.GetAdvancedSecurityCommittersBreakdown()
	r = &RepositoryActiveCommitters{}
	r.GetAdvancedSecurityCommittersBreakdown()
	r = nil
	r.GetAdvancedSecurityCommittersBreakdown()
}

func TestRepositoryActiveCommitters_GetName(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryActiveCommitters{}
	r.GetName()
	r = nil
	r.GetName()
}

func TestRepositoryActivity_GetActivityType(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryActivity{}
	r.GetActivityType()
	r = nil
	r.GetActivityType()
}

func TestRepositoryActivity_GetActor(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryActivity{}
	r.GetActor()
	r = nil
	r.GetActor()
}

func TestRepositoryActivity_GetAfter(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryActivity{}
	r.GetAfter()
	r = nil
	r.GetAfter()
}

func TestRepositoryActivity_GetBefore(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryActivity{}
	r.GetBefore()
	r = nil
	r.GetBefore()
}

func TestRepositoryActivity_GetID(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryActivity{}
	r.GetID()
	r = nil
	r.GetID()
}

func TestRepositoryActivity_GetNodeID(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryActivity{}
	r.GetNodeID()
	r = nil
	r.GetNodeID()
}

func TestRepositoryActivity_GetRef(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryActivity{}
	r.GetRef()
	r = nil
	r.GetRef()
}

func TestRepositoryActivity_GetTimestamp(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	r := &RepositoryActivity{Timestamp: &zeroValue}
	r.GetTimestamp()
	r = &RepositoryActivity{}
	r.GetTimestamp()
	r = nil
	r.GetTimestamp()
}

func TestRepositoryActor_GetAvatarURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryActor{AvatarURL: &zeroValue}
	r.GetAvatarURL()
	r = &RepositoryActor{}
	r.GetAvatarURL()
	r = nil
	r.GetAvatarURL()
}

func TestRepositoryActor_GetEventsURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryActor{EventsURL: &zeroValue}
	r.GetEventsURL()
	r = &RepositoryActor{}
	r.GetEventsURL()
	r = nil
	r.GetEventsURL()
}

func TestRepositoryActor_GetFollowersURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryActor{FollowersURL: &zeroValue}
	r.GetFollowersURL()
	r = &RepositoryActor{}
	r.GetFollowersURL()
	r = nil
	r.GetFollowersURL()
}

func TestRepositoryActor_GetFollowingURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryActor{FollowingURL: &zeroValue}
	r.GetFollowingURL()
	r = &RepositoryActor{}
	r.GetFollowingURL()
	r = nil
	r.GetFollowingURL()
}

func TestRepositoryActor_GetGistsURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryActor{GistsURL: &zeroValue}
	r.GetGistsURL()
	r = &RepositoryActor{}
	r.GetGistsURL()
	r = nil
	r.GetGistsURL()
}

func TestRepositoryActor_GetGravatarID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryActor{GravatarID: &zeroValue}
	r.GetGravatarID()
	r = &RepositoryActor{}
	r.GetGravatarID()
	r = nil
	r.GetGravatarID()
}

func TestRepositoryActor_GetHTMLURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryActor{HTMLURL: &zeroValue}
	r.GetHTMLURL()
	r = &RepositoryActor{}
	r.GetHTMLURL()
	r = nil
	r.GetHTMLURL()
}

func TestRepositoryActor_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	r := &RepositoryActor{ID: &zeroValue}
	r.GetID()
	r = &RepositoryActor{}
	r.GetID()
	r = nil
	r.GetID()
}

func TestRepositoryActor_GetLogin(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryActor{Login: &zeroValue}
	r.GetLogin()
	r = &RepositoryActor{}
	r.GetLogin()
	r = nil
	r.GetLogin()
}

func TestRepositoryActor_GetNodeID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryActor{NodeID: &zeroValue}
	r.GetNodeID()
	r = &RepositoryActor{}
	r.GetNodeID()
	r = nil
	r.GetNodeID()
}

func TestRepositoryActor_GetOrganizationsURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryActor{OrganizationsURL: &zeroValue}
	r.GetOrganizationsURL()
	r = &RepositoryActor{}
	r.GetOrganizationsURL()
	r = nil
	r.GetOrganizationsURL()
}

func TestRepositoryActor_GetReceivedEventsURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryActor{ReceivedEventsURL: &zeroValue}
	r.GetReceivedEventsURL()
	r = &RepositoryActor{}
	r.GetReceivedEventsURL()
	r = nil
	r.GetReceivedEventsURL()
}

func TestRepositoryActor_GetReposURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryActor{ReposURL: &zeroValue}
	r.GetReposURL()
	r = &RepositoryActor{}
	r.GetReposURL()
	r = nil
	r.GetReposURL()
}

func TestRepositoryActor_GetSiteAdmin(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	r := &RepositoryActor{SiteAdmin: &zeroValue}
	r.GetSiteAdmin()
	r = &RepositoryActor{}
	r.GetSiteAdmin()
	r = nil
	r.GetSiteAdmin()
}

func TestRepositoryActor_GetStarredURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryActor{StarredURL: &zeroValue}
	r.GetStarredURL()
	r = &RepositoryActor{}
	r.GetStarredURL()
	r = nil
	r.GetStarredURL()
}

func TestRepositoryActor_GetSubscriptionsURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryActor{SubscriptionsURL: &zeroValue}
	r.GetSubscriptionsURL()
	r = &RepositoryActor{}
	r.GetSubscriptionsURL()
	r = nil
	r.GetSubscriptionsURL()
}

func TestRepositoryActor_GetType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryActor{Type: &zeroValue}
	r.GetType()
	r = &RepositoryActor{}
	r.GetType()
	r = nil
	r.GetType()
}

func TestRepositoryActor_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryActor{URL: &zeroValue}
	r.GetURL()
	r = &RepositoryActor{}
	r.GetURL()
	r = nil
	r.GetURL()
}

func TestRepositoryActor_GetUserViewType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryActor{UserViewType: &zeroValue}
	r.GetUserViewType()
	r = &RepositoryActor{}
	r.GetUserViewType()
	r = nil
	r.GetUserViewType()
}

func TestRepositoryAddCollaboratorOptions_GetPermission(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryAddCollaboratorOptions{}
	r.GetPermission()
	r = nil
	r.GetPermission()
}

func TestRepositoryAttachment_GetRepository(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryAttachment{}
	r.GetRepository()
	r = nil
	r.GetRepository()
}

func TestRepositoryAttachment_GetStatus(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryAttachment{Status: &zeroValue}
	r.GetStatus()
	r = &RepositoryAttachment{}
	r.GetStatus()
	r = nil
	r.GetStatus()
}

func TestRepositoryCodeSecurityConfiguration_GetConfiguration(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryCodeSecurityConfiguration{}
	r.GetConfiguration()
	r = nil
	r.GetConfiguration()
}

func TestRepositoryCodeSecurityConfiguration_GetState(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryCodeSecurityConfiguration{State: &zeroValue}
	r.GetState()
	r = &RepositoryCodeSecurityConfiguration{}
	r.GetState()
	r = nil
	r.GetState()
}

func TestRepositoryComment_GetBody(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryComment{Body: &zeroValue}
	r.GetBody()
	r = &RepositoryComment{}
	r.GetBody()
	r = nil
	r.GetBody()
}

func TestRepositoryComment_GetCommitID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryComment{CommitID: &zeroValue}
	r.GetCommitID()
	r = &RepositoryComment{}
	r.GetCommitID()
	r = nil
	r.GetCommitID()
}

func TestRepositoryComment_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	r := &RepositoryComment{CreatedAt: &zeroValue}
	r.GetCreatedAt()
	r = &RepositoryComment{}
	r.GetCreatedAt()
	r = nil
	r.GetCreatedAt()
}

func TestRepositoryComment_GetHTMLURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryComment{HTMLURL: &zeroValue}
	r.GetHTMLURL()
	r = &RepositoryComment{}
	r.GetHTMLURL()
	r = nil
	r.GetHTMLURL()
}

func TestRepositoryComment_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	r := &RepositoryComment{ID: &zeroValue}
	r.GetID()
	r = &RepositoryComment{}
	r.GetID()
	r = nil
	r.GetID()
}

func TestRepositoryComment_GetNodeID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryComment{NodeID: &zeroValue}
	r.GetNodeID()
	r = &RepositoryComment{}
	r.GetNodeID()
	r = nil
	r.GetNodeID()
}

func TestRepositoryComment_GetPath(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryComment{Path: &zeroValue}
	r.GetPath()
	r = &RepositoryComment{}
	r.GetPath()
	r = nil
	r.GetPath()
}

func TestRepositoryComment_GetPosition(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	r := &RepositoryComment{Position: &zeroValue}
	r.GetPosition()
	r = &RepositoryComment{}
	r.GetPosition()
	r = nil
	r.GetPosition()
}

func TestRepositoryComment_GetReactions(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryComment{}
	r.GetReactions()
	r = nil
	r.GetReactions()
}

func TestRepositoryComment_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	r := &RepositoryComment{UpdatedAt: &zeroValue}
	r.GetUpdatedAt()
	r = &RepositoryComment{}
	r.GetUpdatedAt()
	r = nil
	r.GetUpdatedAt()
}

func TestRepositoryComment_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryComment{URL: &zeroValue}
	r.GetURL()
	r = &RepositoryComment{}
	r.GetURL()
	r = nil
	r.GetURL()
}

func TestRepositoryComment_GetUser(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryComment{}
	r.GetUser()
	r = nil
	r.GetUser()
}

func TestRepositoryCommit_GetAuthor(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryCommit{}
	r.GetAuthor()
	r = nil
	r.GetAuthor()
}

func TestRepositoryCommit_GetCommentsURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryCommit{CommentsURL: &zeroValue}
	r.GetCommentsURL()
	r = &RepositoryCommit{}
	r.GetCommentsURL()
	r = nil
	r.GetCommentsURL()
}

func TestRepositoryCommit_GetCommit(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryCommit{}
	r.GetCommit()
	r = nil
	r.GetCommit()
}

func TestRepositoryCommit_GetCommitter(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryCommit{}
	r.GetCommitter()
	r = nil
	r.GetCommitter()
}

func TestRepositoryCommit_GetFiles(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*CommitFile{}
	r := &RepositoryCommit{Files: zeroValue}
	r.GetFiles()
	r = &RepositoryCommit{}
	r.GetFiles()
	r = nil
	r.GetFiles()
}

func TestRepositoryCommit_GetHTMLURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryCommit{HTMLURL: &zeroValue}
	r.GetHTMLURL()
	r = &RepositoryCommit{}
	r.GetHTMLURL()
	r = nil
	r.GetHTMLURL()
}

func TestRepositoryCommit_GetNodeID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryCommit{NodeID: &zeroValue}
	r.GetNodeID()
	r = &RepositoryCommit{}
	r.GetNodeID()
	r = nil
	r.GetNodeID()
}

func TestRepositoryCommit_GetParents(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*Commit{}
	r := &RepositoryCommit{Parents: zeroValue}
	r.GetParents()
	r = &RepositoryCommit{}
	r.GetParents()
	r = nil
	r.GetParents()
}

func TestRepositoryCommit_GetSHA(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryCommit{SHA: &zeroValue}
	r.GetSHA()
	r = &RepositoryCommit{}
	r.GetSHA()
	r = nil
	r.GetSHA()
}

func TestRepositoryCommit_GetStats(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryCommit{}
	r.GetStats()
	r = nil
	r.GetStats()
}

func TestRepositoryCommit_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryCommit{URL: &zeroValue}
	r.GetURL()
	r = &RepositoryCommit{}
	r.GetURL()
	r = nil
	r.GetURL()
}

func TestRepositoryContent_GetDownloadURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryContent{DownloadURL: &zeroValue}
	r.GetDownloadURL()
	r = &RepositoryContent{}
	r.GetDownloadURL()
	r = nil
	r.GetDownloadURL()
}

func TestRepositoryContent_GetEncoding(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryContent{Encoding: &zeroValue}
	r.GetEncoding()
	r = &RepositoryContent{}
	r.GetEncoding()
	r = nil
	r.GetEncoding()
}

func TestRepositoryContent_GetGitURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryContent{GitURL: &zeroValue}
	r.GetGitURL()
	r = &RepositoryContent{}
	r.GetGitURL()
	r = nil
	r.GetGitURL()
}

func TestRepositoryContent_GetHTMLURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryContent{HTMLURL: &zeroValue}
	r.GetHTMLURL()
	r = &RepositoryContent{}
	r.GetHTMLURL()
	r = nil
	r.GetHTMLURL()
}

func TestRepositoryContent_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryContent{Name: &zeroValue}
	r.GetName()
	r = &RepositoryContent{}
	r.GetName()
	r = nil
	r.GetName()
}

func TestRepositoryContent_GetPath(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryContent{Path: &zeroValue}
	r.GetPath()
	r = &RepositoryContent{}
	r.GetPath()
	r = nil
	r.GetPath()
}

func TestRepositoryContent_GetSHA(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryContent{SHA: &zeroValue}
	r.GetSHA()
	r = &RepositoryContent{}
	r.GetSHA()
	r = nil
	r.GetSHA()
}

func TestRepositoryContent_GetSize(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	r := &RepositoryContent{Size: &zeroValue}
	r.GetSize()
	r = &RepositoryContent{}
	r.GetSize()
	r = nil
	r.GetSize()
}

func TestRepositoryContent_GetSubmoduleGitURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryContent{SubmoduleGitURL: &zeroValue}
	r.GetSubmoduleGitURL()
	r = &RepositoryContent{}
	r.GetSubmoduleGitURL()
	r = nil
	r.GetSubmoduleGitURL()
}

func TestRepositoryContent_GetTarget(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryContent{Target: &zeroValue}
	r.GetTarget()
	r = &RepositoryContent{}
	r.GetTarget()
	r = nil
	r.GetTarget()
}

func TestRepositoryContent_GetType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryContent{Type: &zeroValue}
	r.GetType()
	r = &RepositoryContent{}
	r.GetType()
	r = nil
	r.GetType()
}

func TestRepositoryContent_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryContent{URL: &zeroValue}
	r.GetURL()
	r = &RepositoryContent{}
	r.GetURL()
	r = nil
	r.GetURL()
}

func TestRepositoryContentFileOptions_GetAuthor(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryContentFileOptions{}
	r.GetAuthor()
	r = nil
	r.GetAuthor()
}

func TestRepositoryContentFileOptions_GetBranch(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryContentFileOptions{Branch: &zeroValue}
	r.GetBranch()
	r = &RepositoryContentFileOptions{}
	r.GetBranch()
	r = nil
	r.GetBranch()
}

func TestRepositoryContentFileOptions_GetCommitter(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryContentFileOptions{}
	r.GetCommitter()
	r = nil
	r.GetCommitter()
}

func TestRepositoryContentFileOptions_GetContent(tt *testing.T) {
	tt.Parallel()
	zeroValue := []byte{}
	r := &RepositoryContentFileOptions{Content: zeroValue}
	r.GetContent()
	r = &RepositoryContentFileOptions{}
	r.GetContent()
	r = nil
	r.GetContent()
}

func TestRepositoryContentFileOptions_GetMessage(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryContentFileOptions{Message: &zeroValue}
	r.GetMessage()
	r = &RepositoryContentFileOptions{}
	r.GetMessage()
	r = nil
	r.GetMessage()
}

func TestRepositoryContentFileOptions_GetSHA(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryContentFileOptions{SHA: &zeroValue}
	r.GetSHA()
	r = &RepositoryContentFileOptions{}
	r.GetSHA()
	r = nil
	r.GetSHA()
}

func TestRepositoryContentGetOptions_GetRef(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryContentGetOptions{}
	r.GetRef()
	r = nil
	r.GetRef()
}

func TestRepositoryContentResponse_GetContent(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryContentResponse{}
	r.GetContent()
	r = nil
	r.GetContent()
}

func TestRepositoryCreateForkOptions_GetDefaultBranchOnly(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryCreateForkOptions{}
	r.GetDefaultBranchOnly()
	r = nil
	r.GetDefaultBranchOnly()
}

func TestRepositoryCreateForkOptions_GetName(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryCreateForkOptions{}
	r.GetName()
	r = nil
	r.GetName()
}

func TestRepositoryCreateForkOptions_GetOrganization(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryCreateForkOptions{}
	r.GetOrganization()
	r = nil
	r.GetOrganization()
}

func TestRepositoryDispatchEvent_GetAction(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryDispatchEvent{Action: &zeroValue}
	r.GetAction()
	r = &RepositoryDispatchEvent{}
	r.GetAction()
	r = nil
	r.GetAction()
}

func TestRepositoryDispatchEvent_GetBranch(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryDispatchEvent{Branch: &zeroValue}
	r.GetBranch()
	r = &RepositoryDispatchEvent{}
	r.GetBranch()
	r = nil
	r.GetBranch()
}

func TestRepositoryDispatchEvent_GetClientPayload(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryDispatchEvent{}
	r.GetClientPayload()
	r = nil
	r.GetClientPayload()
}

func TestRepositoryDispatchEvent_GetInstallation(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryDispatchEvent{}
	r.GetInstallation()
	r = nil
	r.GetInstallation()
}

func TestRepositoryDispatchEvent_GetOrg(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryDispatchEvent{}
	r.GetOrg()
	r = nil
	r.GetOrg()
}

func TestRepositoryDispatchEvent_GetRepo(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryDispatchEvent{}
	r.GetRepo()
	r = nil
	r.GetRepo()
}

func TestRepositoryDispatchEvent_GetSender(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryDispatchEvent{}
	r.GetSender()
	r = nil
	r.GetSender()
}

func TestRepositoryEvent_GetAction(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryEvent{Action: &zeroValue}
	r.GetAction()
	r = &RepositoryEvent{}
	r.GetAction()
	r = nil
	r.GetAction()
}

func TestRepositoryEvent_GetChanges(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryEvent{}
	r.GetChanges()
	r = nil
	r.GetChanges()
}

func TestRepositoryEvent_GetInstallation(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryEvent{}
	r.GetInstallation()
	r = nil
	r.GetInstallation()
}

func TestRepositoryEvent_GetOrg(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryEvent{}
	r.GetOrg()
	r = nil
	r.GetOrg()
}

func TestRepositoryEvent_GetRepo(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryEvent{}
	r.GetRepo()
	r = nil
	r.GetRepo()
}

func TestRepositoryEvent_GetSender(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryEvent{}
	r.GetSender()
	r = nil
	r.GetSender()
}

func TestRepositoryImportEvent_GetOrg(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryImportEvent{}
	r.GetOrg()
	r = nil
	r.GetOrg()
}

func TestRepositoryImportEvent_GetRepo(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryImportEvent{}
	r.GetRepo()
	r = nil
	r.GetRepo()
}

func TestRepositoryImportEvent_GetSender(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryImportEvent{}
	r.GetSender()
	r = nil
	r.GetSender()
}

func TestRepositoryImportEvent_GetStatus(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryImportEvent{Status: &zeroValue}
	r.GetStatus()
	r = &RepositoryImportEvent{}
	r.GetStatus()
	r = nil
	r.GetStatus()
}

func TestRepositoryInvitation_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	r := &RepositoryInvitation{CreatedAt: &zeroValue}
	r.GetCreatedAt()
	r = &RepositoryInvitation{}
	r.GetCreatedAt()
	r = nil
	r.GetCreatedAt()
}

func TestRepositoryInvitation_GetExpired(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	r := &RepositoryInvitation{Expired: &zeroValue}
	r.GetExpired()
	r = &RepositoryInvitation{}
	r.GetExpired()
	r = nil
	r.GetExpired()
}

func TestRepositoryInvitation_GetHTMLURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryInvitation{HTMLURL: &zeroValue}
	r.GetHTMLURL()
	r = &RepositoryInvitation{}
	r.GetHTMLURL()
	r = nil
	r.GetHTMLURL()
}

func TestRepositoryInvitation_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	r := &RepositoryInvitation{ID: &zeroValue}
	r.GetID()
	r = &RepositoryInvitation{}
	r.GetID()
	r = nil
	r.GetID()
}

func TestRepositoryInvitation_GetInvitee(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryInvitation{}
	r.GetInvitee()
	r = nil
	r.GetInvitee()
}

func TestRepositoryInvitation_GetInviter(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryInvitation{}
	r.GetInviter()
	r = nil
	r.GetInviter()
}

func TestRepositoryInvitation_GetPermissions(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryInvitation{Permissions: &zeroValue}
	r.GetPermissions()
	r = &RepositoryInvitation{}
	r.GetPermissions()
	r = nil
	r.GetPermissions()
}

func TestRepositoryInvitation_GetRepo(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryInvitation{}
	r.GetRepo()
	r = nil
	r.GetRepo()
}

func TestRepositoryInvitation_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryInvitation{URL: &zeroValue}
	r.GetURL()
	r = &RepositoryInvitation{}
	r.GetURL()
	r = nil
	r.GetURL()
}

func TestRepositoryLicense_GetContent(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryLicense{Content: &zeroValue}
	r.GetContent()
	r = &RepositoryLicense{}
	r.GetContent()
	r = nil
	r.GetContent()
}

func TestRepositoryLicense_GetDownloadURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryLicense{DownloadURL: &zeroValue}
	r.GetDownloadURL()
	r = &RepositoryLicense{}
	r.GetDownloadURL()
	r = nil
	r.GetDownloadURL()
}

func TestRepositoryLicense_GetEncoding(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryLicense{Encoding: &zeroValue}
	r.GetEncoding()
	r = &RepositoryLicense{}
	r.GetEncoding()
	r = nil
	r.GetEncoding()
}

func TestRepositoryLicense_GetGitURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryLicense{GitURL: &zeroValue}
	r.GetGitURL()
	r = &RepositoryLicense{}
	r.GetGitURL()
	r = nil
	r.GetGitURL()
}

func TestRepositoryLicense_GetHTMLURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryLicense{HTMLURL: &zeroValue}
	r.GetHTMLURL()
	r = &RepositoryLicense{}
	r.GetHTMLURL()
	r = nil
	r.GetHTMLURL()
}

func TestRepositoryLicense_GetLicense(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryLicense{}
	r.GetLicense()
	r = nil
	r.GetLicense()
}

func TestRepositoryLicense_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryLicense{Name: &zeroValue}
	r.GetName()
	r = &RepositoryLicense{}
	r.GetName()
	r = nil
	r.GetName()
}

func TestRepositoryLicense_GetPath(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryLicense{Path: &zeroValue}
	r.GetPath()
	r = &RepositoryLicense{}
	r.GetPath()
	r = nil
	r.GetPath()
}

func TestRepositoryLicense_GetSHA(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryLicense{SHA: &zeroValue}
	r.GetSHA()
	r = &RepositoryLicense{}
	r.GetSHA()
	r = nil
	r.GetSHA()
}

func TestRepositoryLicense_GetSize(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	r := &RepositoryLicense{Size: &zeroValue}
	r.GetSize()
	r = &RepositoryLicense{}
	r.GetSize()
	r = nil
	r.GetSize()
}

func TestRepositoryLicense_GetType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryLicense{Type: &zeroValue}
	r.GetType()
	r = &RepositoryLicense{}
	r.GetType()
	r = nil
	r.GetType()
}

func TestRepositoryLicense_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryLicense{URL: &zeroValue}
	r.GetURL()
	r = &RepositoryLicense{}
	r.GetURL()
	r = nil
	r.GetURL()
}

func TestRepositoryListAllOptions_GetSince(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryListAllOptions{}
	r.GetSince()
	r = nil
	r.GetSince()
}

func TestRepositoryListByAuthenticatedUserOptions_GetAffiliation(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryListByAuthenticatedUserOptions{}
	r.GetAffiliation()
	r = nil
	r.GetAffiliation()
}

func TestRepositoryListByAuthenticatedUserOptions_GetDirection(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryListByAuthenticatedUserOptions{}
	r.GetDirection()
	r = nil
	r.GetDirection()
}

func TestRepositoryListByAuthenticatedUserOptions_GetSort(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryListByAuthenticatedUserOptions{}
	r.GetSort()
	r = nil
	r.GetSort()
}

func TestRepositoryListByAuthenticatedUserOptions_GetType(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryListByAuthenticatedUserOptions{}
	r.GetType()
	r = nil
	r.GetType()
}

func TestRepositoryListByAuthenticatedUserOptions_GetVisibility(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryListByAuthenticatedUserOptions{}
	r.GetVisibility()
	r = nil
	r.GetVisibility()
}

func TestRepositoryListByOrgOptions_GetDirection(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryListByOrgOptions{}
	r.GetDirection()
	r = nil
	r.GetDirection()
}

func TestRepositoryListByOrgOptions_GetSort(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryListByOrgOptions{}
	r.GetSort()
	r = nil
	r.GetSort()
}

func TestRepositoryListByOrgOptions_GetType(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryListByOrgOptions{}
	r.GetType()
	r = nil
	r.GetType()
}

func TestRepositoryListByUserOptions_GetDirection(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryListByUserOptions{}
	r.GetDirection()
	r = nil
	r.GetDirection()
}

func TestRepositoryListByUserOptions_GetSort(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryListByUserOptions{}
	r.GetSort()
	r = nil
	r.GetSort()
}

func TestRepositoryListByUserOptions_GetType(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryListByUserOptions{}
	r.GetType()
	r = nil
	r.GetType()
}

func TestRepositoryListForksOptions_GetSort(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryListForksOptions{}
	r.GetSort()
	r = nil
	r.GetSort()
}

func TestRepositoryListOptions_GetAffiliation(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryListOptions{}
	r.GetAffiliation()
	r = nil
	r.GetAffiliation()
}

func TestRepositoryListOptions_GetDirection(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryListOptions{}
	r.GetDirection()
	r = nil
	r.GetDirection()
}

func TestRepositoryListOptions_GetSort(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryListOptions{}
	r.GetSort()
	r = nil
	r.GetSort()
}

func TestRepositoryListOptions_GetType(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryListOptions{}
	r.GetType()
	r = nil
	r.GetType()
}

func TestRepositoryListOptions_GetVisibility(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryListOptions{}
	r.GetVisibility()
	r = nil
	r.GetVisibility()
}

func TestRepositoryListRulesetsOptions_GetIncludesParents(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	r := &RepositoryListRulesetsOptions{IncludesParents: &zeroValue}
	r.GetIncludesParents()
	r = &RepositoryListRulesetsOptions{}
	r.GetIncludesParents()
	r = nil
	r.GetIncludesParents()
}

func TestRepositoryMergeRequest_GetBase(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryMergeRequest{}
	r.GetBase()
	r = nil
	r.GetBase()
}

func TestRepositoryMergeRequest_GetCommitMessage(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryMergeRequest{CommitMessage: &zeroValue}
	r.GetCommitMessage()
	r = &RepositoryMergeRequest{}
	r.GetCommitMessage()
	r = nil
	r.GetCommitMessage()
}

func TestRepositoryMergeRequest_GetHead(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryMergeRequest{}
	r.GetHead()
	r = nil
	r.GetHead()
}

func TestRepositoryParticipation_GetAll(tt *testing.T) {
	tt.Parallel()
	zeroValue := []int{}
	r := &RepositoryParticipation{All: zeroValue}
	r.GetAll()
	r = &RepositoryParticipation{}
	r.GetAll()
	r = nil
	r.GetAll()
}

func TestRepositoryParticipation_GetOwner(tt *testing.T) {
	tt.Parallel()
	zeroValue := []int{}
	r := &RepositoryParticipation{Owner: zeroValue}
	r.GetOwner()
	r = &RepositoryParticipation{}
	r.GetOwner()
	r = nil
	r.GetOwner()
}

func TestRepositoryPermissionLevel_GetPermission(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryPermissionLevel{Permission: &zeroValue}
	r.GetPermission()
	r = &RepositoryPermissionLevel{}
	r.GetPermission()
	r = nil
	r.GetPermission()
}

func TestRepositoryPermissionLevel_GetRoleName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryPermissionLevel{RoleName: &zeroValue}
	r.GetRoleName()
	r = &RepositoryPermissionLevel{}
	r.GetRoleName()
	r = nil
	r.GetRoleName()
}

func TestRepositoryPermissionLevel_GetUser(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryPermissionLevel{}
	r.GetUser()
	r = nil
	r.GetUser()
}

func TestRepositoryPermissions_GetAdmin(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	r := &RepositoryPermissions{Admin: &zeroValue}
	r.GetAdmin()
	r = &RepositoryPermissions{}
	r.GetAdmin()
	r = nil
	r.GetAdmin()
}

func TestRepositoryPermissions_GetMaintain(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	r := &RepositoryPermissions{Maintain: &zeroValue}
	r.GetMaintain()
	r = &RepositoryPermissions{}
	r.GetMaintain()
	r = nil
	r.GetMaintain()
}

func TestRepositoryPermissions_GetPull(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	r := &RepositoryPermissions{Pull: &zeroValue}
	r.GetPull()
	r = &RepositoryPermissions{}
	r.GetPull()
	r = nil
	r.GetPull()
}

func TestRepositoryPermissions_GetPush(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	r := &RepositoryPermissions{Push: &zeroValue}
	r.GetPush()
	r = &RepositoryPermissions{}
	r.GetPush()
	r = nil
	r.GetPush()
}

func TestRepositoryPermissions_GetTriage(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	r := &RepositoryPermissions{Triage: &zeroValue}
	r.GetTriage()
	r = &RepositoryPermissions{}
	r.GetTriage()
	r = nil
	r.GetTriage()
}

func TestRepositoryRelease_GetAssets(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*ReleaseAsset{}
	r := &RepositoryRelease{Assets: zeroValue}
	r.GetAssets()
	r = &RepositoryRelease{}
	r.GetAssets()
	r = nil
	r.GetAssets()
}

func TestRepositoryRelease_GetAssetsURL(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRelease{}
	r.GetAssetsURL()
	r = nil
	r.GetAssetsURL()
}

func TestRepositoryRelease_GetAuthor(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRelease{}
	r.GetAuthor()
	r = nil
	r.GetAuthor()
}

func TestRepositoryRelease_GetBody(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryRelease{Body: &zeroValue}
	r.GetBody()
	r = &RepositoryRelease{}
	r.GetBody()
	r = nil
	r.GetBody()
}

func TestRepositoryRelease_GetBodyHTML(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryRelease{BodyHTML: &zeroValue}
	r.GetBodyHTML()
	r = &RepositoryRelease{}
	r.GetBodyHTML()
	r = nil
	r.GetBodyHTML()
}

func TestRepositoryRelease_GetBodyText(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryRelease{BodyText: &zeroValue}
	r.GetBodyText()
	r = &RepositoryRelease{}
	r.GetBodyText()
	r = nil
	r.GetBodyText()
}

func TestRepositoryRelease_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRelease{}
	r.GetCreatedAt()
	r = nil
	r.GetCreatedAt()
}

func TestRepositoryRelease_GetDiscussionURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryRelease{DiscussionURL: &zeroValue}
	r.GetDiscussionURL()
	r = &RepositoryRelease{}
	r.GetDiscussionURL()
	r = nil
	r.GetDiscussionURL()
}

func TestRepositoryRelease_GetDraft(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRelease{}
	r.GetDraft()
	r = nil
	r.GetDraft()
}

func TestRepositoryRelease_GetHTMLURL(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRelease{}
	r.GetHTMLURL()
	r = nil
	r.GetHTMLURL()
}

func TestRepositoryRelease_GetID(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRelease{}
	r.GetID()
	r = nil
	r.GetID()
}

func TestRepositoryRelease_GetImmutable(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	r := &RepositoryRelease{Immutable: &zeroValue}
	r.GetImmutable()
	r = &RepositoryRelease{}
	r.GetImmutable()
	r = nil
	r.GetImmutable()
}

func TestRepositoryRelease_GetMentionsCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	r := &RepositoryRelease{MentionsCount: &zeroValue}
	r.GetMentionsCount()
	r = &RepositoryRelease{}
	r.GetMentionsCount()
	r = nil
	r.GetMentionsCount()
}

func TestRepositoryRelease_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryRelease{Name: &zeroValue}
	r.GetName()
	r = &RepositoryRelease{}
	r.GetName()
	r = nil
	r.GetName()
}

func TestRepositoryRelease_GetNodeID(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRelease{}
	r.GetNodeID()
	r = nil
	r.GetNodeID()
}

func TestRepositoryRelease_GetPrerelease(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRelease{}
	r.GetPrerelease()
	r = nil
	r.GetPrerelease()
}

func TestRepositoryRelease_GetPublishedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	r := &RepositoryRelease{PublishedAt: &zeroValue}
	r.GetPublishedAt()
	r = &RepositoryRelease{}
	r.GetPublishedAt()
	r = nil
	r.GetPublishedAt()
}

func TestRepositoryRelease_GetReactions(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRelease{}
	r.GetReactions()
	r = nil
	r.GetReactions()
}

func TestRepositoryRelease_GetTagName(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRelease{}
	r.GetTagName()
	r = nil
	r.GetTagName()
}

func TestRepositoryRelease_GetTarballURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryRelease{TarballURL: &zeroValue}
	r.GetTarballURL()
	r = &RepositoryRelease{}
	r.GetTarballURL()
	r = nil
	r.GetTarballURL()
}

func TestRepositoryRelease_GetTargetCommitish(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRelease{}
	r.GetTargetCommitish()
	r = nil
	r.GetTargetCommitish()
}

func TestRepositoryRelease_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	r := &RepositoryRelease{UpdatedAt: &zeroValue}
	r.GetUpdatedAt()
	r = &RepositoryRelease{}
	r.GetUpdatedAt()
	r = nil
	r.GetUpdatedAt()
}

func TestRepositoryRelease_GetUploadURL(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRelease{}
	r.GetUploadURL()
	r = nil
	r.GetUploadURL()
}

func TestRepositoryRelease_GetURL(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRelease{}
	r.GetURL()
	r = nil
	r.GetURL()
}

func TestRepositoryRelease_GetZipballURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryRelease{ZipballURL: &zeroValue}
	r.GetZipballURL()
	r = &RepositoryRelease{}
	r.GetZipballURL()
	r = nil
	r.GetZipballURL()
}

func TestRepositoryReleaseNotes_GetBody(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryReleaseNotes{}
	r.GetBody()
	r = nil
	r.GetBody()
}

func TestRepositoryReleaseNotes_GetName(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryReleaseNotes{}
	r.GetName()
	r = nil
	r.GetName()
}

func TestRepositoryRule_GetParameters(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRule{}
	r.GetParameters()
	r = nil
	r.GetParameters()
}

func TestRepositoryRule_GetType(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRule{}
	r.GetType()
	r = nil
	r.GetType()
}

func TestRepositoryRuleset_GetBypassActors(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*BypassActor{}
	r := &RepositoryRuleset{BypassActors: zeroValue}
	r.GetBypassActors()
	r = &RepositoryRuleset{}
	r.GetBypassActors()
	r = nil
	r.GetBypassActors()
}

func TestRepositoryRuleset_GetConditions(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRuleset{}
	r.GetConditions()
	r = nil
	r.GetConditions()
}

func TestRepositoryRuleset_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	r := &RepositoryRuleset{CreatedAt: &zeroValue}
	r.GetCreatedAt()
	r = &RepositoryRuleset{}
	r.GetCreatedAt()
	r = nil
	r.GetCreatedAt()
}

func TestRepositoryRuleset_GetCurrentUserCanBypass(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRuleset{}
	r.GetCurrentUserCanBypass()
	r = nil
	r.GetCurrentUserCanBypass()
}

func TestRepositoryRuleset_GetEnforcement(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRuleset{}
	r.GetEnforcement()
	r = nil
	r.GetEnforcement()
}

func TestRepositoryRuleset_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	r := &RepositoryRuleset{ID: &zeroValue}
	r.GetID()
	r = &RepositoryRuleset{}
	r.GetID()
	r = nil
	r.GetID()
}

func TestRepositoryRuleset_GetLinks(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRuleset{}
	r.GetLinks()
	r = nil
	r.GetLinks()
}

func TestRepositoryRuleset_GetName(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRuleset{}
	r.GetName()
	r = nil
	r.GetName()
}

func TestRepositoryRuleset_GetNodeID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryRuleset{NodeID: &zeroValue}
	r.GetNodeID()
	r = &RepositoryRuleset{}
	r.GetNodeID()
	r = nil
	r.GetNodeID()
}

func TestRepositoryRuleset_GetRules(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRuleset{}
	r.GetRules()
	r = nil
	r.GetRules()
}

func TestRepositoryRuleset_GetSource(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRuleset{}
	r.GetSource()
	r = nil
	r.GetSource()
}

func TestRepositoryRuleset_GetSourceType(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRuleset{}
	r.GetSourceType()
	r = nil
	r.GetSourceType()
}

func TestRepositoryRuleset_GetTarget(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRuleset{}
	r.GetTarget()
	r = nil
	r.GetTarget()
}

func TestRepositoryRuleset_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	r := &RepositoryRuleset{UpdatedAt: &zeroValue}
	r.GetUpdatedAt()
	r = &RepositoryRuleset{}
	r.GetUpdatedAt()
	r = nil
	r.GetUpdatedAt()
}

func TestRepositoryRulesetChangedConditions_GetAdded(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*RepositoryRulesetConditions{}
	r := &RepositoryRulesetChangedConditions{Added: zeroValue}
	r.GetAdded()
	r = &RepositoryRulesetChangedConditions{}
	r.GetAdded()
	r = nil
	r.GetAdded()
}

func TestRepositoryRulesetChangedConditions_GetDeleted(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*RepositoryRulesetConditions{}
	r := &RepositoryRulesetChangedConditions{Deleted: zeroValue}
	r.GetDeleted()
	r = &RepositoryRulesetChangedConditions{}
	r.GetDeleted()
	r = nil
	r.GetDeleted()
}

func TestRepositoryRulesetChangedConditions_GetUpdated(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*RepositoryRulesetUpdatedConditions{}
	r := &RepositoryRulesetChangedConditions{Updated: zeroValue}
	r.GetUpdated()
	r = &RepositoryRulesetChangedConditions{}
	r.GetUpdated()
	r = nil
	r.GetUpdated()
}

func TestRepositoryRulesetChangedRule_GetConfiguration(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRulesetChangedRule{}
	r.GetConfiguration()
	r = nil
	r.GetConfiguration()
}

func TestRepositoryRulesetChangedRule_GetPattern(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRulesetChangedRule{}
	r.GetPattern()
	r = nil
	r.GetPattern()
}

func TestRepositoryRulesetChangedRule_GetRuleType(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRulesetChangedRule{}
	r.GetRuleType()
	r = nil
	r.GetRuleType()
}

func TestRepositoryRulesetChangedRules_GetAdded(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*RepositoryRule{}
	r := &RepositoryRulesetChangedRules{Added: zeroValue}
	r.GetAdded()
	r = &RepositoryRulesetChangedRules{}
	r.GetAdded()
	r = nil
	r.GetAdded()
}

func TestRepositoryRulesetChangedRules_GetDeleted(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*RepositoryRule{}
	r := &RepositoryRulesetChangedRules{Deleted: zeroValue}
	r.GetDeleted()
	r = &RepositoryRulesetChangedRules{}
	r.GetDeleted()
	r = nil
	r.GetDeleted()
}

func TestRepositoryRulesetChangedRules_GetUpdated(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*RepositoryRulesetUpdatedRules{}
	r := &RepositoryRulesetChangedRules{Updated: zeroValue}
	r.GetUpdated()
	r = &RepositoryRulesetChangedRules{}
	r.GetUpdated()
	r = nil
	r.GetUpdated()
}

func TestRepositoryRulesetChanges_GetConditions(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRulesetChanges{}
	r.GetConditions()
	r = nil
	r.GetConditions()
}

func TestRepositoryRulesetChanges_GetEnforcement(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRulesetChanges{}
	r.GetEnforcement()
	r = nil
	r.GetEnforcement()
}

func TestRepositoryRulesetChanges_GetName(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRulesetChanges{}
	r.GetName()
	r = nil
	r.GetName()
}

func TestRepositoryRulesetChanges_GetRules(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRulesetChanges{}
	r.GetRules()
	r = nil
	r.GetRules()
}

func TestRepositoryRulesetChangeSource_GetFrom(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryRulesetChangeSource{From: &zeroValue}
	r.GetFrom()
	r = &RepositoryRulesetChangeSource{}
	r.GetFrom()
	r = nil
	r.GetFrom()
}

func TestRepositoryRulesetChangeSources_GetFrom(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	r := &RepositoryRulesetChangeSources{From: zeroValue}
	r.GetFrom()
	r = &RepositoryRulesetChangeSources{}
	r.GetFrom()
	r = nil
	r.GetFrom()
}

func TestRepositoryRulesetConditions_GetOrganizationID(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRulesetConditions{}
	r.GetOrganizationID()
	r = nil
	r.GetOrganizationID()
}

func TestRepositoryRulesetConditions_GetOrganizationName(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRulesetConditions{}
	r.GetOrganizationName()
	r = nil
	r.GetOrganizationName()
}

func TestRepositoryRulesetConditions_GetOrganizationProperty(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRulesetConditions{}
	r.GetOrganizationProperty()
	r = nil
	r.GetOrganizationProperty()
}

func TestRepositoryRulesetConditions_GetRefName(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRulesetConditions{}
	r.GetRefName()
	r = nil
	r.GetRefName()
}

func TestRepositoryRulesetConditions_GetRepositoryID(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRulesetConditions{}
	r.GetRepositoryID()
	r = nil
	r.GetRepositoryID()
}

func TestRepositoryRulesetConditions_GetRepositoryName(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRulesetConditions{}
	r.GetRepositoryName()
	r = nil
	r.GetRepositoryName()
}

func TestRepositoryRulesetConditions_GetRepositoryProperty(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRulesetConditions{}
	r.GetRepositoryProperty()
	r = nil
	r.GetRepositoryProperty()
}

func TestRepositoryRulesetEvent_GetAction(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryRulesetEvent{Action: &zeroValue}
	r.GetAction()
	r = &RepositoryRulesetEvent{}
	r.GetAction()
	r = nil
	r.GetAction()
}

func TestRepositoryRulesetEvent_GetChanges(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRulesetEvent{}
	r.GetChanges()
	r = nil
	r.GetChanges()
}

func TestRepositoryRulesetEvent_GetEnterprise(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRulesetEvent{}
	r.GetEnterprise()
	r = nil
	r.GetEnterprise()
}

func TestRepositoryRulesetEvent_GetInstallation(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRulesetEvent{}
	r.GetInstallation()
	r = nil
	r.GetInstallation()
}

func TestRepositoryRulesetEvent_GetOrganization(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRulesetEvent{}
	r.GetOrganization()
	r = nil
	r.GetOrganization()
}

func TestRepositoryRulesetEvent_GetRepository(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRulesetEvent{}
	r.GetRepository()
	r = nil
	r.GetRepository()
}

func TestRepositoryRulesetEvent_GetRepositoryRuleset(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRulesetEvent{}
	r.GetRepositoryRuleset()
	r = nil
	r.GetRepositoryRuleset()
}

func TestRepositoryRulesetEvent_GetSender(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRulesetEvent{}
	r.GetSender()
	r = nil
	r.GetSender()
}

func TestRepositoryRulesetLink_GetHRef(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryRulesetLink{HRef: &zeroValue}
	r.GetHRef()
	r = &RepositoryRulesetLink{}
	r.GetHRef()
	r = nil
	r.GetHRef()
}

func TestRepositoryRulesetLinks_GetHTML(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRulesetLinks{}
	r.GetHTML()
	r = nil
	r.GetHTML()
}

func TestRepositoryRulesetLinks_GetSelf(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRulesetLinks{}
	r.GetSelf()
	r = nil
	r.GetSelf()
}

func TestRepositoryRulesetOrganizationIDsConditionParameters_GetOrganizationIDs(tt *testing.T) {
	tt.Parallel()
	zeroValue := []int64{}
	r := &RepositoryRulesetOrganizationIDsConditionParameters{OrganizationIDs: zeroValue}
	r.GetOrganizationIDs()
	r = &RepositoryRulesetOrganizationIDsConditionParameters{}
	r.GetOrganizationIDs()
	r = nil
	r.GetOrganizationIDs()
}

func TestRepositoryRulesetOrganizationNamesConditionParameters_GetExclude(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	r := &RepositoryRulesetOrganizationNamesConditionParameters{Exclude: zeroValue}
	r.GetExclude()
	r = &RepositoryRulesetOrganizationNamesConditionParameters{}
	r.GetExclude()
	r = nil
	r.GetExclude()
}

func TestRepositoryRulesetOrganizationNamesConditionParameters_GetInclude(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	r := &RepositoryRulesetOrganizationNamesConditionParameters{Include: zeroValue}
	r.GetInclude()
	r = &RepositoryRulesetOrganizationNamesConditionParameters{}
	r.GetInclude()
	r = nil
	r.GetInclude()
}

func TestRepositoryRulesetOrganizationPropertyConditionParameters_GetExclude(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*RepositoryRulesetRepositoryPropertyTargetParameters{}
	r := &RepositoryRulesetOrganizationPropertyConditionParameters{Exclude: zeroValue}
	r.GetExclude()
	r = &RepositoryRulesetOrganizationPropertyConditionParameters{}
	r.GetExclude()
	r = nil
	r.GetExclude()
}

func TestRepositoryRulesetOrganizationPropertyConditionParameters_GetInclude(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*RepositoryRulesetRepositoryPropertyTargetParameters{}
	r := &RepositoryRulesetOrganizationPropertyConditionParameters{Include: zeroValue}
	r.GetInclude()
	r = &RepositoryRulesetOrganizationPropertyConditionParameters{}
	r.GetInclude()
	r = nil
	r.GetInclude()
}

func TestRepositoryRulesetRefConditionParameters_GetExclude(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	r := &RepositoryRulesetRefConditionParameters{Exclude: zeroValue}
	r.GetExclude()
	r = &RepositoryRulesetRefConditionParameters{}
	r.GetExclude()
	r = nil
	r.GetExclude()
}

func TestRepositoryRulesetRefConditionParameters_GetInclude(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	r := &RepositoryRulesetRefConditionParameters{Include: zeroValue}
	r.GetInclude()
	r = &RepositoryRulesetRefConditionParameters{}
	r.GetInclude()
	r = nil
	r.GetInclude()
}

func TestRepositoryRulesetRepositoryIDsConditionParameters_GetRepositoryIDs(tt *testing.T) {
	tt.Parallel()
	zeroValue := []int64{}
	r := &RepositoryRulesetRepositoryIDsConditionParameters{RepositoryIDs: zeroValue}
	r.GetRepositoryIDs()
	r = &RepositoryRulesetRepositoryIDsConditionParameters{}
	r.GetRepositoryIDs()
	r = nil
	r.GetRepositoryIDs()
}

func TestRepositoryRulesetRepositoryNamesConditionParameters_GetExclude(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	r := &RepositoryRulesetRepositoryNamesConditionParameters{Exclude: zeroValue}
	r.GetExclude()
	r = &RepositoryRulesetRepositoryNamesConditionParameters{}
	r.GetExclude()
	r = nil
	r.GetExclude()
}

func TestRepositoryRulesetRepositoryNamesConditionParameters_GetInclude(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	r := &RepositoryRulesetRepositoryNamesConditionParameters{Include: zeroValue}
	r.GetInclude()
	r = &RepositoryRulesetRepositoryNamesConditionParameters{}
	r.GetInclude()
	r = nil
	r.GetInclude()
}

func TestRepositoryRulesetRepositoryNamesConditionParameters_GetProtected(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	r := &RepositoryRulesetRepositoryNamesConditionParameters{Protected: &zeroValue}
	r.GetProtected()
	r = &RepositoryRulesetRepositoryNamesConditionParameters{}
	r.GetProtected()
	r = nil
	r.GetProtected()
}

func TestRepositoryRulesetRepositoryPropertyConditionParameters_GetExclude(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*RepositoryRulesetRepositoryPropertyTargetParameters{}
	r := &RepositoryRulesetRepositoryPropertyConditionParameters{Exclude: zeroValue}
	r.GetExclude()
	r = &RepositoryRulesetRepositoryPropertyConditionParameters{}
	r.GetExclude()
	r = nil
	r.GetExclude()
}

func TestRepositoryRulesetRepositoryPropertyConditionParameters_GetInclude(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*RepositoryRulesetRepositoryPropertyTargetParameters{}
	r := &RepositoryRulesetRepositoryPropertyConditionParameters{Include: zeroValue}
	r.GetInclude()
	r = &RepositoryRulesetRepositoryPropertyConditionParameters{}
	r.GetInclude()
	r = nil
	r.GetInclude()
}

func TestRepositoryRulesetRepositoryPropertyTargetParameters_GetName(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRulesetRepositoryPropertyTargetParameters{}
	r.GetName()
	r = nil
	r.GetName()
}

func TestRepositoryRulesetRepositoryPropertyTargetParameters_GetPropertyValues(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	r := &RepositoryRulesetRepositoryPropertyTargetParameters{PropertyValues: zeroValue}
	r.GetPropertyValues()
	r = &RepositoryRulesetRepositoryPropertyTargetParameters{}
	r.GetPropertyValues()
	r = nil
	r.GetPropertyValues()
}

func TestRepositoryRulesetRepositoryPropertyTargetParameters_GetSource(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryRulesetRepositoryPropertyTargetParameters{Source: &zeroValue}
	r.GetSource()
	r = &RepositoryRulesetRepositoryPropertyTargetParameters{}
	r.GetSource()
	r = nil
	r.GetSource()
}

func TestRepositoryRulesetRules_GetBranchNamePattern(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRulesetRules{}
	r.GetBranchNamePattern()
	r = nil
	r.GetBranchNamePattern()
}

func TestRepositoryRulesetRules_GetCodeScanning(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRulesetRules{}
	r.GetCodeScanning()
	r = nil
	r.GetCodeScanning()
}

func TestRepositoryRulesetRules_GetCommitAuthorEmailPattern(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRulesetRules{}
	r.GetCommitAuthorEmailPattern()
	r = nil
	r.GetCommitAuthorEmailPattern()
}

func TestRepositoryRulesetRules_GetCommitMessagePattern(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRulesetRules{}
	r.GetCommitMessagePattern()
	r = nil
	r.GetCommitMessagePattern()
}

func TestRepositoryRulesetRules_GetCommitterEmailPattern(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRulesetRules{}
	r.GetCommitterEmailPattern()
	r = nil
	r.GetCommitterEmailPattern()
}

func TestRepositoryRulesetRules_GetCopilotCodeReview(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRulesetRules{}
	r.GetCopilotCodeReview()
	r = nil
	r.GetCopilotCodeReview()
}

func TestRepositoryRulesetRules_GetCreation(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRulesetRules{}
	r.GetCreation()
	r = nil
	r.GetCreation()
}

func TestRepositoryRulesetRules_GetDeletion(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRulesetRules{}
	r.GetDeletion()
	r = nil
	r.GetDeletion()
}

func TestRepositoryRulesetRules_GetFileExtensionRestriction(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRulesetRules{}
	r.GetFileExtensionRestriction()
	r = nil
	r.GetFileExtensionRestriction()
}

func TestRepositoryRulesetRules_GetFilePathRestriction(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRulesetRules{}
	r.GetFilePathRestriction()
	r = nil
	r.GetFilePathRestriction()
}

func TestRepositoryRulesetRules_GetMaxFilePathLength(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRulesetRules{}
	r.GetMaxFilePathLength()
	r = nil
	r.GetMaxFilePathLength()
}

func TestRepositoryRulesetRules_GetMaxFileSize(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRulesetRules{}
	r.GetMaxFileSize()
	r = nil
	r.GetMaxFileSize()
}

func TestRepositoryRulesetRules_GetMergeQueue(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRulesetRules{}
	r.GetMergeQueue()
	r = nil
	r.GetMergeQueue()
}

func TestRepositoryRulesetRules_GetNonFastForward(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRulesetRules{}
	r.GetNonFastForward()
	r = nil
	r.GetNonFastForward()
}

func TestRepositoryRulesetRules_GetPullRequest(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRulesetRules{}
	r.GetPullRequest()
	r = nil
	r.GetPullRequest()
}

func TestRepositoryRulesetRules_GetRepositoryCreate(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRulesetRules{}
	r.GetRepositoryCreate()
	r = nil
	r.GetRepositoryCreate()
}

func TestRepositoryRulesetRules_GetRepositoryDelete(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRulesetRules{}
	r.GetRepositoryDelete()
	r = nil
	r.GetRepositoryDelete()
}

func TestRepositoryRulesetRules_GetRepositoryName(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRulesetRules{}
	r.GetRepositoryName()
	r = nil
	r.GetRepositoryName()
}

func TestRepositoryRulesetRules_GetRepositoryTransfer(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRulesetRules{}
	r.GetRepositoryTransfer()
	r = nil
	r.GetRepositoryTransfer()
}

func TestRepositoryRulesetRules_GetRepositoryVisibility(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRulesetRules{}
	r.GetRepositoryVisibility()
	r = nil
	r.GetRepositoryVisibility()
}

func TestRepositoryRulesetRules_GetRequiredDeployments(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRulesetRules{}
	r.GetRequiredDeployments()
	r = nil
	r.GetRequiredDeployments()
}

func TestRepositoryRulesetRules_GetRequiredLinearHistory(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRulesetRules{}
	r.GetRequiredLinearHistory()
	r = nil
	r.GetRequiredLinearHistory()
}

func TestRepositoryRulesetRules_GetRequiredSignatures(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRulesetRules{}
	r.GetRequiredSignatures()
	r = nil
	r.GetRequiredSignatures()
}

func TestRepositoryRulesetRules_GetRequiredStatusChecks(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRulesetRules{}
	r.GetRequiredStatusChecks()
	r = nil
	r.GetRequiredStatusChecks()
}

func TestRepositoryRulesetRules_GetTagNamePattern(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRulesetRules{}
	r.GetTagNamePattern()
	r = nil
	r.GetTagNamePattern()
}

func TestRepositoryRulesetRules_GetUpdate(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRulesetRules{}
	r.GetUpdate()
	r = nil
	r.GetUpdate()
}

func TestRepositoryRulesetRules_GetWorkflows(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRulesetRules{}
	r.GetWorkflows()
	r = nil
	r.GetWorkflows()
}

func TestRepositoryRulesetUpdatedCondition_GetConditionType(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRulesetUpdatedCondition{}
	r.GetConditionType()
	r = nil
	r.GetConditionType()
}

func TestRepositoryRulesetUpdatedCondition_GetExclude(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRulesetUpdatedCondition{}
	r.GetExclude()
	r = nil
	r.GetExclude()
}

func TestRepositoryRulesetUpdatedCondition_GetInclude(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRulesetUpdatedCondition{}
	r.GetInclude()
	r = nil
	r.GetInclude()
}

func TestRepositoryRulesetUpdatedCondition_GetTarget(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRulesetUpdatedCondition{}
	r.GetTarget()
	r = nil
	r.GetTarget()
}

func TestRepositoryRulesetUpdatedConditions_GetChanges(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRulesetUpdatedConditions{}
	r.GetChanges()
	r = nil
	r.GetChanges()
}

func TestRepositoryRulesetUpdatedConditions_GetCondition(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRulesetUpdatedConditions{}
	r.GetCondition()
	r = nil
	r.GetCondition()
}

func TestRepositoryRulesetUpdatedRules_GetChanges(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRulesetUpdatedRules{}
	r.GetChanges()
	r = nil
	r.GetChanges()
}

func TestRepositoryRulesetUpdatedRules_GetRule(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryRulesetUpdatedRules{}
	r.GetRule()
	r = nil
	r.GetRule()
}

func TestRepositoryTag_GetCommit(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryTag{}
	r.GetCommit()
	r = nil
	r.GetCommit()
}

func TestRepositoryTag_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryTag{Name: &zeroValue}
	r.GetName()
	r = &RepositoryTag{}
	r.GetName()
	r = nil
	r.GetName()
}

func TestRepositoryTag_GetTarballURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryTag{TarballURL: &zeroValue}
	r.GetTarballURL()
	r = &RepositoryTag{}
	r.GetTarballURL()
	r = nil
	r.GetTarballURL()
}

func TestRepositoryTag_GetZipballURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryTag{ZipballURL: &zeroValue}
	r.GetZipballURL()
	r = &RepositoryTag{}
	r.GetZipballURL()
	r = nil
	r.GetZipballURL()
}

func TestRepositoryVisibilityRuleParameters_GetInternal(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryVisibilityRuleParameters{}
	r.GetInternal()
	r = nil
	r.GetInternal()
}

func TestRepositoryVisibilityRuleParameters_GetPrivate(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryVisibilityRuleParameters{}
	r.GetPrivate()
	r = nil
	r.GetPrivate()
}

func TestRepositoryVulnerabilityAlert_GetAffectedPackageName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryVulnerabilityAlert{AffectedPackageName: &zeroValue}
	r.GetAffectedPackageName()
	r = &RepositoryVulnerabilityAlert{}
	r.GetAffectedPackageName()
	r = nil
	r.GetAffectedPackageName()
}

func TestRepositoryVulnerabilityAlert_GetAffectedRange(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryVulnerabilityAlert{AffectedRange: &zeroValue}
	r.GetAffectedRange()
	r = &RepositoryVulnerabilityAlert{}
	r.GetAffectedRange()
	r = nil
	r.GetAffectedRange()
}

func TestRepositoryVulnerabilityAlert_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	r := &RepositoryVulnerabilityAlert{CreatedAt: &zeroValue}
	r.GetCreatedAt()
	r = &RepositoryVulnerabilityAlert{}
	r.GetCreatedAt()
	r = nil
	r.GetCreatedAt()
}

func TestRepositoryVulnerabilityAlert_GetDismissedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	r := &RepositoryVulnerabilityAlert{DismissedAt: &zeroValue}
	r.GetDismissedAt()
	r = &RepositoryVulnerabilityAlert{}
	r.GetDismissedAt()
	r = nil
	r.GetDismissedAt()
}

func TestRepositoryVulnerabilityAlert_GetDismisser(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryVulnerabilityAlert{}
	r.GetDismisser()
	r = nil
	r.GetDismisser()
}

func TestRepositoryVulnerabilityAlert_GetDismissReason(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryVulnerabilityAlert{DismissReason: &zeroValue}
	r.GetDismissReason()
	r = &RepositoryVulnerabilityAlert{}
	r.GetDismissReason()
	r = nil
	r.GetDismissReason()
}

func TestRepositoryVulnerabilityAlert_GetExternalIdentifier(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryVulnerabilityAlert{ExternalIdentifier: &zeroValue}
	r.GetExternalIdentifier()
	r = &RepositoryVulnerabilityAlert{}
	r.GetExternalIdentifier()
	r = nil
	r.GetExternalIdentifier()
}

func TestRepositoryVulnerabilityAlert_GetExternalReference(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryVulnerabilityAlert{ExternalReference: &zeroValue}
	r.GetExternalReference()
	r = &RepositoryVulnerabilityAlert{}
	r.GetExternalReference()
	r = nil
	r.GetExternalReference()
}

func TestRepositoryVulnerabilityAlert_GetFixedIn(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryVulnerabilityAlert{FixedIn: &zeroValue}
	r.GetFixedIn()
	r = &RepositoryVulnerabilityAlert{}
	r.GetFixedIn()
	r = nil
	r.GetFixedIn()
}

func TestRepositoryVulnerabilityAlert_GetGitHubSecurityAdvisoryID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryVulnerabilityAlert{GitHubSecurityAdvisoryID: &zeroValue}
	r.GetGitHubSecurityAdvisoryID()
	r = &RepositoryVulnerabilityAlert{}
	r.GetGitHubSecurityAdvisoryID()
	r = nil
	r.GetGitHubSecurityAdvisoryID()
}

func TestRepositoryVulnerabilityAlert_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	r := &RepositoryVulnerabilityAlert{ID: &zeroValue}
	r.GetID()
	r = &RepositoryVulnerabilityAlert{}
	r.GetID()
	r = nil
	r.GetID()
}

func TestRepositoryVulnerabilityAlert_GetSeverity(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryVulnerabilityAlert{Severity: &zeroValue}
	r.GetSeverity()
	r = &RepositoryVulnerabilityAlert{}
	r.GetSeverity()
	r = nil
	r.GetSeverity()
}

func TestRepositoryVulnerabilityAlertEvent_GetAction(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepositoryVulnerabilityAlertEvent{Action: &zeroValue}
	r.GetAction()
	r = &RepositoryVulnerabilityAlertEvent{}
	r.GetAction()
	r = nil
	r.GetAction()
}

func TestRepositoryVulnerabilityAlertEvent_GetAlert(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryVulnerabilityAlertEvent{}
	r.GetAlert()
	r = nil
	r.GetAlert()
}

func TestRepositoryVulnerabilityAlertEvent_GetInstallation(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryVulnerabilityAlertEvent{}
	r.GetInstallation()
	r = nil
	r.GetInstallation()
}

func TestRepositoryVulnerabilityAlertEvent_GetOrg(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryVulnerabilityAlertEvent{}
	r.GetOrg()
	r = nil
	r.GetOrg()
}

func TestRepositoryVulnerabilityAlertEvent_GetRepository(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryVulnerabilityAlertEvent{}
	r.GetRepository()
	r = nil
	r.GetRepository()
}

func TestRepositoryVulnerabilityAlertEvent_GetSender(tt *testing.T) {
	tt.Parallel()
	r := &RepositoryVulnerabilityAlertEvent{}
	r.GetSender()
	r = nil
	r.GetSender()
}

func TestRepoStats_GetForkRepos(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	r := &RepoStats{ForkRepos: &zeroValue}
	r.GetForkRepos()
	r = &RepoStats{}
	r.GetForkRepos()
	r = nil
	r.GetForkRepos()
}

func TestRepoStats_GetOrgRepos(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	r := &RepoStats{OrgRepos: &zeroValue}
	r.GetOrgRepos()
	r = &RepoStats{}
	r.GetOrgRepos()
	r = nil
	r.GetOrgRepos()
}

func TestRepoStats_GetRootRepos(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	r := &RepoStats{RootRepos: &zeroValue}
	r.GetRootRepos()
	r = &RepoStats{}
	r.GetRootRepos()
	r = nil
	r.GetRootRepos()
}

func TestRepoStats_GetTotalPushes(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	r := &RepoStats{TotalPushes: &zeroValue}
	r.GetTotalPushes()
	r = &RepoStats{}
	r.GetTotalPushes()
	r = nil
	r.GetTotalPushes()
}

func TestRepoStats_GetTotalRepos(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	r := &RepoStats{TotalRepos: &zeroValue}
	r.GetTotalRepos()
	r = &RepoStats{}
	r.GetTotalRepos()
	r = nil
	r.GetTotalRepos()
}

func TestRepoStats_GetTotalWikis(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	r := &RepoStats{TotalWikis: &zeroValue}
	r.GetTotalWikis()
	r = &RepoStats{}
	r.GetTotalWikis()
	r = nil
	r.GetTotalWikis()
}

func TestRepoStatus_GetAvatarURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepoStatus{AvatarURL: &zeroValue}
	r.GetAvatarURL()
	r = &RepoStatus{}
	r.GetAvatarURL()
	r = nil
	r.GetAvatarURL()
}

func TestRepoStatus_GetContext(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepoStatus{Context: &zeroValue}
	r.GetContext()
	r = &RepoStatus{}
	r.GetContext()
	r = nil
	r.GetContext()
}

func TestRepoStatus_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	r := &RepoStatus{CreatedAt: &zeroValue}
	r.GetCreatedAt()
	r = &RepoStatus{}
	r.GetCreatedAt()
	r = nil
	r.GetCreatedAt()
}

func TestRepoStatus_GetCreator(tt *testing.T) {
	tt.Parallel()
	r := &RepoStatus{}
	r.GetCreator()
	r = nil
	r.GetCreator()
}

func TestRepoStatus_GetDescription(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepoStatus{Description: &zeroValue}
	r.GetDescription()
	r = &RepoStatus{}
	r.GetDescription()
	r = nil
	r.GetDescription()
}

func TestRepoStatus_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	r := &RepoStatus{ID: &zeroValue}
	r.GetID()
	r = &RepoStatus{}
	r.GetID()
	r = nil
	r.GetID()
}

func TestRepoStatus_GetNodeID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepoStatus{NodeID: &zeroValue}
	r.GetNodeID()
	r = &RepoStatus{}
	r.GetNodeID()
	r = nil
	r.GetNodeID()
}

func TestRepoStatus_GetState(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepoStatus{State: &zeroValue}
	r.GetState()
	r = &RepoStatus{}
	r.GetState()
	r = nil
	r.GetState()
}

func TestRepoStatus_GetTargetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepoStatus{TargetURL: &zeroValue}
	r.GetTargetURL()
	r = &RepoStatus{}
	r.GetTargetURL()
	r = nil
	r.GetTargetURL()
}

func TestRepoStatus_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	r := &RepoStatus{UpdatedAt: &zeroValue}
	r.GetUpdatedAt()
	r = &RepoStatus{}
	r.GetUpdatedAt()
	r = nil
	r.GetUpdatedAt()
}

func TestRepoStatus_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RepoStatus{URL: &zeroValue}
	r.GetURL()
	r = &RepoStatus{}
	r.GetURL()
	r = nil
	r.GetURL()
}

func TestRequestedAction_GetIdentifier(tt *testing.T) {
	tt.Parallel()
	r := &RequestedAction{}
	r.GetIdentifier()
	r = nil
	r.GetIdentifier()
}

func TestRequireCodeOwnerReviewChanges_GetFrom(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	r := &RequireCodeOwnerReviewChanges{From: &zeroValue}
	r.GetFrom()
	r = &RequireCodeOwnerReviewChanges{}
	r.GetFrom()
	r = nil
	r.GetFrom()
}

func TestRequiredConversationResolution_GetEnabled(tt *testing.T) {
	tt.Parallel()
	r := &RequiredConversationResolution{}
	r.GetEnabled()
	r = nil
	r.GetEnabled()
}

func TestRequiredConversationResolutionLevelChanges_GetFrom(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RequiredConversationResolutionLevelChanges{From: &zeroValue}
	r.GetFrom()
	r = &RequiredConversationResolutionLevelChanges{}
	r.GetFrom()
	r = nil
	r.GetFrom()
}

func TestRequiredDeploymentsBranchRule_GetParameters(tt *testing.T) {
	tt.Parallel()
	r := &RequiredDeploymentsBranchRule{}
	r.GetParameters()
	r = nil
	r.GetParameters()
}

func TestRequiredDeploymentsEnforcementLevelChanges_GetFrom(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RequiredDeploymentsEnforcementLevelChanges{From: &zeroValue}
	r.GetFrom()
	r = &RequiredDeploymentsEnforcementLevelChanges{}
	r.GetFrom()
	r = nil
	r.GetFrom()
}

func TestRequiredDeploymentsRuleParameters_GetRequiredDeploymentEnvironments(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	r := &RequiredDeploymentsRuleParameters{RequiredDeploymentEnvironments: zeroValue}
	r.GetRequiredDeploymentEnvironments()
	r = &RequiredDeploymentsRuleParameters{}
	r.GetRequiredDeploymentEnvironments()
	r = nil
	r.GetRequiredDeploymentEnvironments()
}

func TestRequiredReviewer_GetReviewer(tt *testing.T) {
	tt.Parallel()
	r := &RequiredReviewer{}
	r.GetReviewer()
	r = nil
	r.GetReviewer()
}

func TestRequiredReviewer_GetType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RequiredReviewer{Type: &zeroValue}
	r.GetType()
	r = &RequiredReviewer{}
	r.GetType()
	r = nil
	r.GetType()
}

func TestRequiredStatusCheck_GetAppID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	r := &RequiredStatusCheck{AppID: &zeroValue}
	r.GetAppID()
	r = &RequiredStatusCheck{}
	r.GetAppID()
	r = nil
	r.GetAppID()
}

func TestRequiredStatusCheck_GetContext(tt *testing.T) {
	tt.Parallel()
	r := &RequiredStatusCheck{}
	r.GetContext()
	r = nil
	r.GetContext()
}

func TestRequiredStatusChecks_GetChecks(tt *testing.T) {
	tt.Parallel()
	var zeroValue []*RequiredStatusCheck
	r := &RequiredStatusChecks{Checks: &zeroValue}
	r.GetChecks()
	r = &RequiredStatusChecks{}
	r.GetChecks()
	r = nil
	r.GetChecks()
}

func TestRequiredStatusChecks_GetContexts(tt *testing.T) {
	tt.Parallel()
	var zeroValue []string
	r := &RequiredStatusChecks{Contexts: &zeroValue}
	r.GetContexts()
	r = &RequiredStatusChecks{}
	r.GetContexts()
	r = nil
	r.GetContexts()
}

func TestRequiredStatusChecks_GetContextsURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RequiredStatusChecks{ContextsURL: &zeroValue}
	r.GetContextsURL()
	r = &RequiredStatusChecks{}
	r.GetContextsURL()
	r = nil
	r.GetContextsURL()
}

func TestRequiredStatusChecks_GetStrict(tt *testing.T) {
	tt.Parallel()
	r := &RequiredStatusChecks{}
	r.GetStrict()
	r = nil
	r.GetStrict()
}

func TestRequiredStatusChecks_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RequiredStatusChecks{URL: &zeroValue}
	r.GetURL()
	r = &RequiredStatusChecks{}
	r.GetURL()
	r = nil
	r.GetURL()
}

func TestRequiredStatusChecksBranchRule_GetParameters(tt *testing.T) {
	tt.Parallel()
	r := &RequiredStatusChecksBranchRule{}
	r.GetParameters()
	r = nil
	r.GetParameters()
}

func TestRequiredStatusChecksChanges_GetFrom(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	r := &RequiredStatusChecksChanges{From: zeroValue}
	r.GetFrom()
	r = &RequiredStatusChecksChanges{}
	r.GetFrom()
	r = nil
	r.GetFrom()
}

func TestRequiredStatusChecksEnforcementLevelChanges_GetFrom(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RequiredStatusChecksEnforcementLevelChanges{From: &zeroValue}
	r.GetFrom()
	r = &RequiredStatusChecksEnforcementLevelChanges{}
	r.GetFrom()
	r = nil
	r.GetFrom()
}

func TestRequiredStatusChecksRequest_GetChecks(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*RequiredStatusCheck{}
	r := &RequiredStatusChecksRequest{Checks: zeroValue}
	r.GetChecks()
	r = &RequiredStatusChecksRequest{}
	r.GetChecks()
	r = nil
	r.GetChecks()
}

func TestRequiredStatusChecksRequest_GetContexts(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	r := &RequiredStatusChecksRequest{Contexts: zeroValue}
	r.GetContexts()
	r = &RequiredStatusChecksRequest{}
	r.GetContexts()
	r = nil
	r.GetContexts()
}

func TestRequiredStatusChecksRequest_GetStrict(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	r := &RequiredStatusChecksRequest{Strict: &zeroValue}
	r.GetStrict()
	r = &RequiredStatusChecksRequest{}
	r.GetStrict()
	r = nil
	r.GetStrict()
}

func TestRequiredStatusChecksRuleParameters_GetDoNotEnforceOnCreate(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	r := &RequiredStatusChecksRuleParameters{DoNotEnforceOnCreate: &zeroValue}
	r.GetDoNotEnforceOnCreate()
	r = &RequiredStatusChecksRuleParameters{}
	r.GetDoNotEnforceOnCreate()
	r = nil
	r.GetDoNotEnforceOnCreate()
}

func TestRequiredStatusChecksRuleParameters_GetRequiredStatusChecks(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*RuleStatusCheck{}
	r := &RequiredStatusChecksRuleParameters{RequiredStatusChecks: zeroValue}
	r.GetRequiredStatusChecks()
	r = &RequiredStatusChecksRuleParameters{}
	r.GetRequiredStatusChecks()
	r = nil
	r.GetRequiredStatusChecks()
}

func TestRequiredStatusChecksRuleParameters_GetStrictRequiredStatusChecksPolicy(tt *testing.T) {
	tt.Parallel()
	r := &RequiredStatusChecksRuleParameters{}
	r.GetStrictRequiredStatusChecksPolicy()
	r = nil
	r.GetStrictRequiredStatusChecksPolicy()
}

func TestRequireLastPushApprovalChanges_GetFrom(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	r := &RequireLastPushApprovalChanges{From: &zeroValue}
	r.GetFrom()
	r = &RequireLastPushApprovalChanges{}
	r.GetFrom()
	r = nil
	r.GetFrom()
}

func TestRequireLinearHistory_GetEnabled(tt *testing.T) {
	tt.Parallel()
	r := &RequireLinearHistory{}
	r.GetEnabled()
	r = nil
	r.GetEnabled()
}

func TestResponse_GetAfter(tt *testing.T) {
	tt.Parallel()
	r := &Response{}
	r.GetAfter()
	r = nil
	r.GetAfter()
}

func TestResponse_GetBefore(tt *testing.T) {
	tt.Parallel()
	r := &Response{}
	r.GetBefore()
	r = nil
	r.GetBefore()
}

func TestResponse_GetCursor(tt *testing.T) {
	tt.Parallel()
	r := &Response{}
	r.GetCursor()
	r = nil
	r.GetCursor()
}

func TestResponse_GetFirstPage(tt *testing.T) {
	tt.Parallel()
	r := &Response{}
	r.GetFirstPage()
	r = nil
	r.GetFirstPage()
}

func TestResponse_GetLastPage(tt *testing.T) {
	tt.Parallel()
	r := &Response{}
	r.GetLastPage()
	r = nil
	r.GetLastPage()
}

func TestResponse_GetNextPage(tt *testing.T) {
	tt.Parallel()
	r := &Response{}
	r.GetNextPage()
	r = nil
	r.GetNextPage()
}

func TestResponse_GetNextPageToken(tt *testing.T) {
	tt.Parallel()
	r := &Response{}
	r.GetNextPageToken()
	r = nil
	r.GetNextPageToken()
}

func TestResponse_GetPrevPage(tt *testing.T) {
	tt.Parallel()
	r := &Response{}
	r.GetPrevPage()
	r = nil
	r.GetPrevPage()
}

func TestResponse_GetRate(tt *testing.T) {
	tt.Parallel()
	r := &Response{}
	r.GetRate()
	r = nil
	r.GetRate()
}

func TestResponse_GetTokenExpiration(tt *testing.T) {
	tt.Parallel()
	r := &Response{}
	r.GetTokenExpiration()
	r = nil
	r.GetTokenExpiration()
}

func TestReviewCustomDeploymentProtectionRuleRequest_GetComment(tt *testing.T) {
	tt.Parallel()
	r := &ReviewCustomDeploymentProtectionRuleRequest{}
	r.GetComment()
	r = nil
	r.GetComment()
}

func TestReviewCustomDeploymentProtectionRuleRequest_GetEnvironmentName(tt *testing.T) {
	tt.Parallel()
	r := &ReviewCustomDeploymentProtectionRuleRequest{}
	r.GetEnvironmentName()
	r = nil
	r.GetEnvironmentName()
}

func TestReviewCustomDeploymentProtectionRuleRequest_GetState(tt *testing.T) {
	tt.Parallel()
	r := &ReviewCustomDeploymentProtectionRuleRequest{}
	r.GetState()
	r = nil
	r.GetState()
}

func TestReviewers_GetTeams(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*Team{}
	r := &Reviewers{Teams: zeroValue}
	r.GetTeams()
	r = &Reviewers{}
	r.GetTeams()
	r = nil
	r.GetTeams()
}

func TestReviewers_GetUsers(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*User{}
	r := &Reviewers{Users: zeroValue}
	r.GetUsers()
	r = &Reviewers{}
	r.GetUsers()
	r = nil
	r.GetUsers()
}

func TestReviewersRequest_GetNodeID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &ReviewersRequest{NodeID: &zeroValue}
	r.GetNodeID()
	r = &ReviewersRequest{}
	r.GetNodeID()
	r = nil
	r.GetNodeID()
}

func TestReviewersRequest_GetReviewers(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	r := &ReviewersRequest{Reviewers: zeroValue}
	r.GetReviewers()
	r = &ReviewersRequest{}
	r.GetReviewers()
	r = nil
	r.GetReviewers()
}

func TestReviewersRequest_GetTeamReviewers(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	r := &ReviewersRequest{TeamReviewers: zeroValue}
	r.GetTeamReviewers()
	r = &ReviewersRequest{}
	r.GetTeamReviewers()
	r = nil
	r.GetTeamReviewers()
}

func TestReviewPersonalAccessTokenRequestOptions_GetAction(tt *testing.T) {
	tt.Parallel()
	r := &ReviewPersonalAccessTokenRequestOptions{}
	r.GetAction()
	r = nil
	r.GetAction()
}

func TestReviewPersonalAccessTokenRequestOptions_GetReason(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &ReviewPersonalAccessTokenRequestOptions{Reason: &zeroValue}
	r.GetReason()
	r = &ReviewPersonalAccessTokenRequestOptions{}
	r.GetReason()
	r = nil
	r.GetReason()
}

func TestRule_GetDescription(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Rule{Description: &zeroValue}
	r.GetDescription()
	r = &Rule{}
	r.GetDescription()
	r = nil
	r.GetDescription()
}

func TestRule_GetFullDescription(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Rule{FullDescription: &zeroValue}
	r.GetFullDescription()
	r = &Rule{}
	r.GetFullDescription()
	r = nil
	r.GetFullDescription()
}

func TestRule_GetHelp(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Rule{Help: &zeroValue}
	r.GetHelp()
	r = &Rule{}
	r.GetHelp()
	r = nil
	r.GetHelp()
}

func TestRule_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Rule{ID: &zeroValue}
	r.GetID()
	r = &Rule{}
	r.GetID()
	r = nil
	r.GetID()
}

func TestRule_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Rule{Name: &zeroValue}
	r.GetName()
	r = &Rule{}
	r.GetName()
	r = nil
	r.GetName()
}

func TestRule_GetSecuritySeverityLevel(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Rule{SecuritySeverityLevel: &zeroValue}
	r.GetSecuritySeverityLevel()
	r = &Rule{}
	r.GetSecuritySeverityLevel()
	r = nil
	r.GetSecuritySeverityLevel()
}

func TestRule_GetSeverity(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Rule{Severity: &zeroValue}
	r.GetSeverity()
	r = &Rule{}
	r.GetSeverity()
	r = nil
	r.GetSeverity()
}

func TestRule_GetTags(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	r := &Rule{Tags: zeroValue}
	r.GetTags()
	r = &Rule{}
	r.GetTags()
	r = nil
	r.GetTags()
}

func TestRuleCodeScanningTool_GetAlertsThreshold(tt *testing.T) {
	tt.Parallel()
	r := &RuleCodeScanningTool{}
	r.GetAlertsThreshold()
	r = nil
	r.GetAlertsThreshold()
}

func TestRuleCodeScanningTool_GetSecurityAlertsThreshold(tt *testing.T) {
	tt.Parallel()
	r := &RuleCodeScanningTool{}
	r.GetSecurityAlertsThreshold()
	r = nil
	r.GetSecurityAlertsThreshold()
}

func TestRuleCodeScanningTool_GetTool(tt *testing.T) {
	tt.Parallel()
	r := &RuleCodeScanningTool{}
	r.GetTool()
	r = nil
	r.GetTool()
}

func TestRulesetRequiredReviewer_GetFilePatterns(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	r := &RulesetRequiredReviewer{FilePatterns: zeroValue}
	r.GetFilePatterns()
	r = &RulesetRequiredReviewer{}
	r.GetFilePatterns()
	r = nil
	r.GetFilePatterns()
}

func TestRulesetRequiredReviewer_GetMinimumApprovals(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	r := &RulesetRequiredReviewer{MinimumApprovals: &zeroValue}
	r.GetMinimumApprovals()
	r = &RulesetRequiredReviewer{}
	r.GetMinimumApprovals()
	r = nil
	r.GetMinimumApprovals()
}

func TestRulesetRequiredReviewer_GetReviewer(tt *testing.T) {
	tt.Parallel()
	r := &RulesetRequiredReviewer{}
	r.GetReviewer()
	r = nil
	r.GetReviewer()
}

func TestRulesetReviewer_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	r := &RulesetReviewer{ID: &zeroValue}
	r.GetID()
	r = &RulesetReviewer{}
	r.GetID()
	r = nil
	r.GetID()
}

func TestRulesetReviewer_GetType(tt *testing.T) {
	tt.Parallel()
	r := &RulesetReviewer{}
	r.GetType()
	r = nil
	r.GetType()
}

func TestRuleStatusCheck_GetContext(tt *testing.T) {
	tt.Parallel()
	r := &RuleStatusCheck{}
	r.GetContext()
	r = nil
	r.GetContext()
}

func TestRuleStatusCheck_GetIntegrationID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	r := &RuleStatusCheck{IntegrationID: &zeroValue}
	r.GetIntegrationID()
	r = &RuleStatusCheck{}
	r.GetIntegrationID()
	r = nil
	r.GetIntegrationID()
}

func TestRuleWorkflow_GetPath(tt *testing.T) {
	tt.Parallel()
	r := &RuleWorkflow{}
	r.GetPath()
	r = nil
	r.GetPath()
}

func TestRuleWorkflow_GetRef(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RuleWorkflow{Ref: &zeroValue}
	r.GetRef()
	r = &RuleWorkflow{}
	r.GetRef()
	r = nil
	r.GetRef()
}

func TestRuleWorkflow_GetRepositoryID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	r := &RuleWorkflow{RepositoryID: &zeroValue}
	r.GetRepositoryID()
	r = &RuleWorkflow{}
	r.GetRepositoryID()
	r = nil
	r.GetRepositoryID()
}

func TestRuleWorkflow_GetSHA(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RuleWorkflow{SHA: &zeroValue}
	r.GetSHA()
	r = &RuleWorkflow{}
	r.GetSHA()
	r = nil
	r.GetSHA()
}

func TestRunner_GetBusy(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	r := &Runner{Busy: &zeroValue}
	r.GetBusy()
	r = &Runner{}
	r.GetBusy()
	r = nil
	r.GetBusy()
}

func TestRunner_GetEphemeral(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	r := &Runner{Ephemeral: &zeroValue}
	r.GetEphemeral()
	r = &Runner{}
	r.GetEphemeral()
	r = nil
	r.GetEphemeral()
}

func TestRunner_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	r := &Runner{ID: &zeroValue}
	r.GetID()
	r = &Runner{}
	r.GetID()
	r = nil
	r.GetID()
}

func TestRunner_GetLabels(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*RunnerLabels{}
	r := &Runner{Labels: zeroValue}
	r.GetLabels()
	r = &Runner{}
	r.GetLabels()
	r = nil
	r.GetLabels()
}

func TestRunner_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Runner{Name: &zeroValue}
	r.GetName()
	r = &Runner{}
	r.GetName()
	r = nil
	r.GetName()
}

func TestRunner_GetOS(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Runner{OS: &zeroValue}
	r.GetOS()
	r = &Runner{}
	r.GetOS()
	r = nil
	r.GetOS()
}

func TestRunner_GetRunnerGroupID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	r := &Runner{RunnerGroupID: &zeroValue}
	r.GetRunnerGroupID()
	r = &Runner{}
	r.GetRunnerGroupID()
	r = nil
	r.GetRunnerGroupID()
}

func TestRunner_GetStatus(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Runner{Status: &zeroValue}
	r.GetStatus()
	r = &Runner{}
	r.GetStatus()
	r = nil
	r.GetStatus()
}

func TestRunner_GetVersion(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &Runner{Version: &zeroValue}
	r.GetVersion()
	r = &Runner{}
	r.GetVersion()
	r = nil
	r.GetVersion()
}

func TestRunnerApplicationDownload_GetArchitecture(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RunnerApplicationDownload{Architecture: &zeroValue}
	r.GetArchitecture()
	r = &RunnerApplicationDownload{}
	r.GetArchitecture()
	r = nil
	r.GetArchitecture()
}

func TestRunnerApplicationDownload_GetDownloadURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RunnerApplicationDownload{DownloadURL: &zeroValue}
	r.GetDownloadURL()
	r = &RunnerApplicationDownload{}
	r.GetDownloadURL()
	r = nil
	r.GetDownloadURL()
}

func TestRunnerApplicationDownload_GetFilename(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RunnerApplicationDownload{Filename: &zeroValue}
	r.GetFilename()
	r = &RunnerApplicationDownload{}
	r.GetFilename()
	r = nil
	r.GetFilename()
}

func TestRunnerApplicationDownload_GetOS(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RunnerApplicationDownload{OS: &zeroValue}
	r.GetOS()
	r = &RunnerApplicationDownload{}
	r.GetOS()
	r = nil
	r.GetOS()
}

func TestRunnerApplicationDownload_GetSHA256Checksum(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RunnerApplicationDownload{SHA256Checksum: &zeroValue}
	r.GetSHA256Checksum()
	r = &RunnerApplicationDownload{}
	r.GetSHA256Checksum()
	r = nil
	r.GetSHA256Checksum()
}

func TestRunnerApplicationDownload_GetTempDownloadToken(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RunnerApplicationDownload{TempDownloadToken: &zeroValue}
	r.GetTempDownloadToken()
	r = &RunnerApplicationDownload{}
	r.GetTempDownloadToken()
	r = nil
	r.GetTempDownloadToken()
}

func TestRunnerGroup_GetAllowsPublicRepositories(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	r := &RunnerGroup{AllowsPublicRepositories: &zeroValue}
	r.GetAllowsPublicRepositories()
	r = &RunnerGroup{}
	r.GetAllowsPublicRepositories()
	r = nil
	r.GetAllowsPublicRepositories()
}

func TestRunnerGroup_GetDefault(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	r := &RunnerGroup{Default: &zeroValue}
	r.GetDefault()
	r = &RunnerGroup{}
	r.GetDefault()
	r = nil
	r.GetDefault()
}

func TestRunnerGroup_GetHostedRunnersURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RunnerGroup{HostedRunnersURL: &zeroValue}
	r.GetHostedRunnersURL()
	r = &RunnerGroup{}
	r.GetHostedRunnersURL()
	r = nil
	r.GetHostedRunnersURL()
}

func TestRunnerGroup_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	r := &RunnerGroup{ID: &zeroValue}
	r.GetID()
	r = &RunnerGroup{}
	r.GetID()
	r = nil
	r.GetID()
}

func TestRunnerGroup_GetInherited(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	r := &RunnerGroup{Inherited: &zeroValue}
	r.GetInherited()
	r = &RunnerGroup{}
	r.GetInherited()
	r = nil
	r.GetInherited()
}

func TestRunnerGroup_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RunnerGroup{Name: &zeroValue}
	r.GetName()
	r = &RunnerGroup{}
	r.GetName()
	r = nil
	r.GetName()
}

func TestRunnerGroup_GetNetworkConfigurationID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RunnerGroup{NetworkConfigurationID: &zeroValue}
	r.GetNetworkConfigurationID()
	r = &RunnerGroup{}
	r.GetNetworkConfigurationID()
	r = nil
	r.GetNetworkConfigurationID()
}

func TestRunnerGroup_GetRestrictedToWorkflows(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	r := &RunnerGroup{RestrictedToWorkflows: &zeroValue}
	r.GetRestrictedToWorkflows()
	r = &RunnerGroup{}
	r.GetRestrictedToWorkflows()
	r = nil
	r.GetRestrictedToWorkflows()
}

func TestRunnerGroup_GetRunnersURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RunnerGroup{RunnersURL: &zeroValue}
	r.GetRunnersURL()
	r = &RunnerGroup{}
	r.GetRunnersURL()
	r = nil
	r.GetRunnersURL()
}

func TestRunnerGroup_GetSelectedRepositoriesURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RunnerGroup{SelectedRepositoriesURL: &zeroValue}
	r.GetSelectedRepositoriesURL()
	r = &RunnerGroup{}
	r.GetSelectedRepositoriesURL()
	r = nil
	r.GetSelectedRepositoriesURL()
}

func TestRunnerGroup_GetSelectedWorkflows(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	r := &RunnerGroup{SelectedWorkflows: zeroValue}
	r.GetSelectedWorkflows()
	r = &RunnerGroup{}
	r.GetSelectedWorkflows()
	r = nil
	r.GetSelectedWorkflows()
}

func TestRunnerGroup_GetVisibility(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RunnerGroup{Visibility: &zeroValue}
	r.GetVisibility()
	r = &RunnerGroup{}
	r.GetVisibility()
	r = nil
	r.GetVisibility()
}

func TestRunnerGroup_GetWorkflowRestrictionsReadOnly(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	r := &RunnerGroup{WorkflowRestrictionsReadOnly: &zeroValue}
	r.GetWorkflowRestrictionsReadOnly()
	r = &RunnerGroup{}
	r.GetWorkflowRestrictionsReadOnly()
	r = nil
	r.GetWorkflowRestrictionsReadOnly()
}

func TestRunnerGroups_GetRunnerGroups(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*RunnerGroup{}
	r := &RunnerGroups{RunnerGroups: zeroValue}
	r.GetRunnerGroups()
	r = &RunnerGroups{}
	r.GetRunnerGroups()
	r = nil
	r.GetRunnerGroups()
}

func TestRunnerGroups_GetTotalCount(tt *testing.T) {
	tt.Parallel()
	r := &RunnerGroups{}
	r.GetTotalCount()
	r = nil
	r.GetTotalCount()
}

func TestRunnerLabels_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	r := &RunnerLabels{ID: &zeroValue}
	r.GetID()
	r = &RunnerLabels{}
	r.GetID()
	r = nil
	r.GetID()
}

func TestRunnerLabels_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RunnerLabels{Name: &zeroValue}
	r.GetName()
	r = &RunnerLabels{}
	r.GetName()
	r = nil
	r.GetName()
}

func TestRunnerLabels_GetType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	r := &RunnerLabels{Type: &zeroValue}
	r.GetType()
	r = &RunnerLabels{}
	r.GetType()
	r = nil
	r.GetType()
}

func TestRunners_GetRunners(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*Runner{}
	r := &Runners{Runners: zeroValue}
	r.GetRunners()
	r = &Runners{}
	r.GetRunners()
	r = nil
	r.GetRunners()
}

func TestRunners_GetTotalCount(tt *testing.T) {
	tt.Parallel()
	r := &Runners{}
	r.GetTotalCount()
	r = nil
	r.GetTotalCount()
}

func TestSarifAnalysis_GetCheckoutURI(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SarifAnalysis{CheckoutURI: &zeroValue}
	s.GetCheckoutURI()
	s = &SarifAnalysis{}
	s.GetCheckoutURI()
	s = nil
	s.GetCheckoutURI()
}

func TestSarifAnalysis_GetCommitSHA(tt *testing.T) {
	tt.Parallel()
	s := &SarifAnalysis{}
	s.GetCommitSHA()
	s = nil
	s.GetCommitSHA()
}

func TestSarifAnalysis_GetRef(tt *testing.T) {
	tt.Parallel()
	s := &SarifAnalysis{}
	s.GetRef()
	s = nil
	s.GetRef()
}

func TestSarifAnalysis_GetSarif(tt *testing.T) {
	tt.Parallel()
	s := &SarifAnalysis{}
	s.GetSarif()
	s = nil
	s.GetSarif()
}

func TestSarifAnalysis_GetStartedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	s := &SarifAnalysis{StartedAt: &zeroValue}
	s.GetStartedAt()
	s = &SarifAnalysis{}
	s.GetStartedAt()
	s = nil
	s.GetStartedAt()
}

func TestSarifAnalysis_GetToolName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SarifAnalysis{ToolName: &zeroValue}
	s.GetToolName()
	s = &SarifAnalysis{}
	s.GetToolName()
	s = nil
	s.GetToolName()
}

func TestSarifAnalysis_GetValidate(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	s := &SarifAnalysis{Validate: &zeroValue}
	s.GetValidate()
	s = &SarifAnalysis{}
	s.GetValidate()
	s = nil
	s.GetValidate()
}

func TestSarifID_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SarifID{ID: &zeroValue}
	s.GetID()
	s = &SarifID{}
	s.GetID()
	s = nil
	s.GetID()
}

func TestSarifID_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SarifID{URL: &zeroValue}
	s.GetURL()
	s = &SarifID{}
	s.GetURL()
	s = nil
	s.GetURL()
}

func TestSARIFUpload_GetAnalysesURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SARIFUpload{AnalysesURL: &zeroValue}
	s.GetAnalysesURL()
	s = &SARIFUpload{}
	s.GetAnalysesURL()
	s = nil
	s.GetAnalysesURL()
}

func TestSARIFUpload_GetProcessingStatus(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SARIFUpload{ProcessingStatus: &zeroValue}
	s.GetProcessingStatus()
	s = &SARIFUpload{}
	s.GetProcessingStatus()
	s = nil
	s.GetProcessingStatus()
}

func TestSBOM_GetSBOM(tt *testing.T) {
	tt.Parallel()
	s := &SBOM{}
	s.GetSBOM()
	s = nil
	s.GetSBOM()
}

func TestSBOMInfo_GetCreationInfo(tt *testing.T) {
	tt.Parallel()
	s := &SBOMInfo{}
	s.GetCreationInfo()
	s = nil
	s.GetCreationInfo()
}

func TestSBOMInfo_GetDataLicense(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SBOMInfo{DataLicense: &zeroValue}
	s.GetDataLicense()
	s = &SBOMInfo{}
	s.GetDataLicense()
	s = nil
	s.GetDataLicense()
}

func TestSBOMInfo_GetDocumentDescribes(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	s := &SBOMInfo{DocumentDescribes: zeroValue}
	s.GetDocumentDescribes()
	s = &SBOMInfo{}
	s.GetDocumentDescribes()
	s = nil
	s.GetDocumentDescribes()
}

func TestSBOMInfo_GetDocumentNamespace(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SBOMInfo{DocumentNamespace: &zeroValue}
	s.GetDocumentNamespace()
	s = &SBOMInfo{}
	s.GetDocumentNamespace()
	s = nil
	s.GetDocumentNamespace()
}

func TestSBOMInfo_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SBOMInfo{Name: &zeroValue}
	s.GetName()
	s = &SBOMInfo{}
	s.GetName()
	s = nil
	s.GetName()
}

func TestSBOMInfo_GetPackages(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*RepoDependencies{}
	s := &SBOMInfo{Packages: zeroValue}
	s.GetPackages()
	s = &SBOMInfo{}
	s.GetPackages()
	s = nil
	s.GetPackages()
}

func TestSBOMInfo_GetRelationships(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*SBOMRelationship{}
	s := &SBOMInfo{Relationships: zeroValue}
	s.GetRelationships()
	s = &SBOMInfo{}
	s.GetRelationships()
	s = nil
	s.GetRelationships()
}

func TestSBOMInfo_GetSPDXID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SBOMInfo{SPDXID: &zeroValue}
	s.GetSPDXID()
	s = &SBOMInfo{}
	s.GetSPDXID()
	s = nil
	s.GetSPDXID()
}

func TestSBOMInfo_GetSPDXVersion(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SBOMInfo{SPDXVersion: &zeroValue}
	s.GetSPDXVersion()
	s = &SBOMInfo{}
	s.GetSPDXVersion()
	s = nil
	s.GetSPDXVersion()
}

func TestSBOMRelationship_GetRelatedSPDXElement(tt *testing.T) {
	tt.Parallel()
	s := &SBOMRelationship{}
	s.GetRelatedSPDXElement()
	s = nil
	s.GetRelatedSPDXElement()
}

func TestSBOMRelationship_GetRelationshipType(tt *testing.T) {
	tt.Parallel()
	s := &SBOMRelationship{}
	s.GetRelationshipType()
	s = nil
	s.GetRelationshipType()
}

func TestSBOMRelationship_GetSPDXElementID(tt *testing.T) {
	tt.Parallel()
	s := &SBOMRelationship{}
	s.GetSPDXElementID()
	s = nil
	s.GetSPDXElementID()
}

func TestScanningAnalysis_GetAnalysisKey(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &ScanningAnalysis{AnalysisKey: &zeroValue}
	s.GetAnalysisKey()
	s = &ScanningAnalysis{}
	s.GetAnalysisKey()
	s = nil
	s.GetAnalysisKey()
}

func TestScanningAnalysis_GetCategory(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &ScanningAnalysis{Category: &zeroValue}
	s.GetCategory()
	s = &ScanningAnalysis{}
	s.GetCategory()
	s = nil
	s.GetCategory()
}

func TestScanningAnalysis_GetCommitSHA(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &ScanningAnalysis{CommitSHA: &zeroValue}
	s.GetCommitSHA()
	s = &ScanningAnalysis{}
	s.GetCommitSHA()
	s = nil
	s.GetCommitSHA()
}

func TestScanningAnalysis_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	s := &ScanningAnalysis{CreatedAt: &zeroValue}
	s.GetCreatedAt()
	s = &ScanningAnalysis{}
	s.GetCreatedAt()
	s = nil
	s.GetCreatedAt()
}

func TestScanningAnalysis_GetDeletable(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	s := &ScanningAnalysis{Deletable: &zeroValue}
	s.GetDeletable()
	s = &ScanningAnalysis{}
	s.GetDeletable()
	s = nil
	s.GetDeletable()
}

func TestScanningAnalysis_GetEnvironment(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &ScanningAnalysis{Environment: &zeroValue}
	s.GetEnvironment()
	s = &ScanningAnalysis{}
	s.GetEnvironment()
	s = nil
	s.GetEnvironment()
}

func TestScanningAnalysis_GetError(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &ScanningAnalysis{Error: &zeroValue}
	s.GetError()
	s = &ScanningAnalysis{}
	s.GetError()
	s = nil
	s.GetError()
}

func TestScanningAnalysis_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	s := &ScanningAnalysis{ID: &zeroValue}
	s.GetID()
	s = &ScanningAnalysis{}
	s.GetID()
	s = nil
	s.GetID()
}

func TestScanningAnalysis_GetRef(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &ScanningAnalysis{Ref: &zeroValue}
	s.GetRef()
	s = &ScanningAnalysis{}
	s.GetRef()
	s = nil
	s.GetRef()
}

func TestScanningAnalysis_GetResultsCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	s := &ScanningAnalysis{ResultsCount: &zeroValue}
	s.GetResultsCount()
	s = &ScanningAnalysis{}
	s.GetResultsCount()
	s = nil
	s.GetResultsCount()
}

func TestScanningAnalysis_GetRulesCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	s := &ScanningAnalysis{RulesCount: &zeroValue}
	s.GetRulesCount()
	s = &ScanningAnalysis{}
	s.GetRulesCount()
	s = nil
	s.GetRulesCount()
}

func TestScanningAnalysis_GetSarifID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &ScanningAnalysis{SarifID: &zeroValue}
	s.GetSarifID()
	s = &ScanningAnalysis{}
	s.GetSarifID()
	s = nil
	s.GetSarifID()
}

func TestScanningAnalysis_GetTool(tt *testing.T) {
	tt.Parallel()
	s := &ScanningAnalysis{}
	s.GetTool()
	s = nil
	s.GetTool()
}

func TestScanningAnalysis_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &ScanningAnalysis{URL: &zeroValue}
	s.GetURL()
	s = &ScanningAnalysis{}
	s.GetURL()
	s = nil
	s.GetURL()
}

func TestScanningAnalysis_GetWarning(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &ScanningAnalysis{Warning: &zeroValue}
	s.GetWarning()
	s = &ScanningAnalysis{}
	s.GetWarning()
	s = nil
	s.GetWarning()
}

func TestSCIMEnterpriseAttribute_GetOperations(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*SCIMEnterpriseAttributeOperation{}
	s := &SCIMEnterpriseAttribute{Operations: zeroValue}
	s.GetOperations()
	s = &SCIMEnterpriseAttribute{}
	s.GetOperations()
	s = nil
	s.GetOperations()
}

func TestSCIMEnterpriseAttribute_GetSchemas(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	s := &SCIMEnterpriseAttribute{Schemas: zeroValue}
	s.GetSchemas()
	s = &SCIMEnterpriseAttribute{}
	s.GetSchemas()
	s = nil
	s.GetSchemas()
}

func TestSCIMEnterpriseAttributeOperation_GetOp(tt *testing.T) {
	tt.Parallel()
	s := &SCIMEnterpriseAttributeOperation{}
	s.GetOp()
	s = nil
	s.GetOp()
}

func TestSCIMEnterpriseAttributeOperation_GetPath(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SCIMEnterpriseAttributeOperation{Path: &zeroValue}
	s.GetPath()
	s = &SCIMEnterpriseAttributeOperation{}
	s.GetPath()
	s = nil
	s.GetPath()
}

func TestSCIMEnterpriseAttributeOperation_GetValue(tt *testing.T) {
	tt.Parallel()
	s := &SCIMEnterpriseAttributeOperation{}
	s.GetValue()
	s = nil
	s.GetValue()
}

func TestSCIMEnterpriseDisplayReference_GetDisplay(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SCIMEnterpriseDisplayReference{Display: &zeroValue}
	s.GetDisplay()
	s = &SCIMEnterpriseDisplayReference{}
	s.GetDisplay()
	s = nil
	s.GetDisplay()
}

func TestSCIMEnterpriseDisplayReference_GetRef(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SCIMEnterpriseDisplayReference{Ref: &zeroValue}
	s.GetRef()
	s = &SCIMEnterpriseDisplayReference{}
	s.GetRef()
	s = nil
	s.GetRef()
}

func TestSCIMEnterpriseDisplayReference_GetValue(tt *testing.T) {
	tt.Parallel()
	s := &SCIMEnterpriseDisplayReference{}
	s.GetValue()
	s = nil
	s.GetValue()
}

func TestSCIMEnterpriseGroupAttributes_GetDisplayName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SCIMEnterpriseGroupAttributes{DisplayName: &zeroValue}
	s.GetDisplayName()
	s = &SCIMEnterpriseGroupAttributes{}
	s.GetDisplayName()
	s = nil
	s.GetDisplayName()
}

func TestSCIMEnterpriseGroupAttributes_GetExternalID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SCIMEnterpriseGroupAttributes{ExternalID: &zeroValue}
	s.GetExternalID()
	s = &SCIMEnterpriseGroupAttributes{}
	s.GetExternalID()
	s = nil
	s.GetExternalID()
}

func TestSCIMEnterpriseGroupAttributes_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SCIMEnterpriseGroupAttributes{ID: &zeroValue}
	s.GetID()
	s = &SCIMEnterpriseGroupAttributes{}
	s.GetID()
	s = nil
	s.GetID()
}

func TestSCIMEnterpriseGroupAttributes_GetMembers(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*SCIMEnterpriseDisplayReference{}
	s := &SCIMEnterpriseGroupAttributes{Members: zeroValue}
	s.GetMembers()
	s = &SCIMEnterpriseGroupAttributes{}
	s.GetMembers()
	s = nil
	s.GetMembers()
}

func TestSCIMEnterpriseGroupAttributes_GetMeta(tt *testing.T) {
	tt.Parallel()
	s := &SCIMEnterpriseGroupAttributes{}
	s.GetMeta()
	s = nil
	s.GetMeta()
}

func TestSCIMEnterpriseGroupAttributes_GetSchemas(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	s := &SCIMEnterpriseGroupAttributes{Schemas: zeroValue}
	s.GetSchemas()
	s = &SCIMEnterpriseGroupAttributes{}
	s.GetSchemas()
	s = nil
	s.GetSchemas()
}

func TestSCIMEnterpriseGroups_GetItemsPerPage(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	s := &SCIMEnterpriseGroups{ItemsPerPage: &zeroValue}
	s.GetItemsPerPage()
	s = &SCIMEnterpriseGroups{}
	s.GetItemsPerPage()
	s = nil
	s.GetItemsPerPage()
}

func TestSCIMEnterpriseGroups_GetResources(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*SCIMEnterpriseGroupAttributes{}
	s := &SCIMEnterpriseGroups{Resources: zeroValue}
	s.GetResources()
	s = &SCIMEnterpriseGroups{}
	s.GetResources()
	s = nil
	s.GetResources()
}

func TestSCIMEnterpriseGroups_GetSchemas(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	s := &SCIMEnterpriseGroups{Schemas: zeroValue}
	s.GetSchemas()
	s = &SCIMEnterpriseGroups{}
	s.GetSchemas()
	s = nil
	s.GetSchemas()
}

func TestSCIMEnterpriseGroups_GetStartIndex(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	s := &SCIMEnterpriseGroups{StartIndex: &zeroValue}
	s.GetStartIndex()
	s = &SCIMEnterpriseGroups{}
	s.GetStartIndex()
	s = nil
	s.GetStartIndex()
}

func TestSCIMEnterpriseGroups_GetTotalResults(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	s := &SCIMEnterpriseGroups{TotalResults: &zeroValue}
	s.GetTotalResults()
	s = &SCIMEnterpriseGroups{}
	s.GetTotalResults()
	s = nil
	s.GetTotalResults()
}

func TestSCIMEnterpriseMeta_GetCreated(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	s := &SCIMEnterpriseMeta{Created: &zeroValue}
	s.GetCreated()
	s = &SCIMEnterpriseMeta{}
	s.GetCreated()
	s = nil
	s.GetCreated()
}

func TestSCIMEnterpriseMeta_GetLastModified(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	s := &SCIMEnterpriseMeta{LastModified: &zeroValue}
	s.GetLastModified()
	s = &SCIMEnterpriseMeta{}
	s.GetLastModified()
	s = nil
	s.GetLastModified()
}

func TestSCIMEnterpriseMeta_GetLocation(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SCIMEnterpriseMeta{Location: &zeroValue}
	s.GetLocation()
	s = &SCIMEnterpriseMeta{}
	s.GetLocation()
	s = nil
	s.GetLocation()
}

func TestSCIMEnterpriseMeta_GetResourceType(tt *testing.T) {
	tt.Parallel()
	s := &SCIMEnterpriseMeta{}
	s.GetResourceType()
	s = nil
	s.GetResourceType()
}

func TestSCIMEnterpriseUserAttributes_GetActive(tt *testing.T) {
	tt.Parallel()
	s := &SCIMEnterpriseUserAttributes{}
	s.GetActive()
	s = nil
	s.GetActive()
}

func TestSCIMEnterpriseUserAttributes_GetDisplayName(tt *testing.T) {
	tt.Parallel()
	s := &SCIMEnterpriseUserAttributes{}
	s.GetDisplayName()
	s = nil
	s.GetDisplayName()
}

func TestSCIMEnterpriseUserAttributes_GetEmails(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*SCIMEnterpriseUserEmail{}
	s := &SCIMEnterpriseUserAttributes{Emails: zeroValue}
	s.GetEmails()
	s = &SCIMEnterpriseUserAttributes{}
	s.GetEmails()
	s = nil
	s.GetEmails()
}

func TestSCIMEnterpriseUserAttributes_GetExternalID(tt *testing.T) {
	tt.Parallel()
	s := &SCIMEnterpriseUserAttributes{}
	s.GetExternalID()
	s = nil
	s.GetExternalID()
}

func TestSCIMEnterpriseUserAttributes_GetGroups(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*SCIMEnterpriseDisplayReference{}
	s := &SCIMEnterpriseUserAttributes{Groups: zeroValue}
	s.GetGroups()
	s = &SCIMEnterpriseUserAttributes{}
	s.GetGroups()
	s = nil
	s.GetGroups()
}

func TestSCIMEnterpriseUserAttributes_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SCIMEnterpriseUserAttributes{ID: &zeroValue}
	s.GetID()
	s = &SCIMEnterpriseUserAttributes{}
	s.GetID()
	s = nil
	s.GetID()
}

func TestSCIMEnterpriseUserAttributes_GetMeta(tt *testing.T) {
	tt.Parallel()
	s := &SCIMEnterpriseUserAttributes{}
	s.GetMeta()
	s = nil
	s.GetMeta()
}

func TestSCIMEnterpriseUserAttributes_GetName(tt *testing.T) {
	tt.Parallel()
	s := &SCIMEnterpriseUserAttributes{}
	s.GetName()
	s = nil
	s.GetName()
}

func TestSCIMEnterpriseUserAttributes_GetRoles(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*SCIMEnterpriseUserRole{}
	s := &SCIMEnterpriseUserAttributes{Roles: zeroValue}
	s.GetRoles()
	s = &SCIMEnterpriseUserAttributes{}
	s.GetRoles()
	s = nil
	s.GetRoles()
}

func TestSCIMEnterpriseUserAttributes_GetSchemas(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	s := &SCIMEnterpriseUserAttributes{Schemas: zeroValue}
	s.GetSchemas()
	s = &SCIMEnterpriseUserAttributes{}
	s.GetSchemas()
	s = nil
	s.GetSchemas()
}

func TestSCIMEnterpriseUserAttributes_GetUserName(tt *testing.T) {
	tt.Parallel()
	s := &SCIMEnterpriseUserAttributes{}
	s.GetUserName()
	s = nil
	s.GetUserName()
}

func TestSCIMEnterpriseUserEmail_GetPrimary(tt *testing.T) {
	tt.Parallel()
	s := &SCIMEnterpriseUserEmail{}
	s.GetPrimary()
	s = nil
	s.GetPrimary()
}

func TestSCIMEnterpriseUserEmail_GetType(tt *testing.T) {
	tt.Parallel()
	s := &SCIMEnterpriseUserEmail{}
	s.GetType()
	s = nil
	s.GetType()
}

func TestSCIMEnterpriseUserEmail_GetValue(tt *testing.T) {
	tt.Parallel()
	s := &SCIMEnterpriseUserEmail{}
	s.GetValue()
	s = nil
	s.GetValue()
}

func TestSCIMEnterpriseUserName_GetFamilyName(tt *testing.T) {
	tt.Parallel()
	s := &SCIMEnterpriseUserName{}
	s.GetFamilyName()
	s = nil
	s.GetFamilyName()
}

func TestSCIMEnterpriseUserName_GetFormatted(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SCIMEnterpriseUserName{Formatted: &zeroValue}
	s.GetFormatted()
	s = &SCIMEnterpriseUserName{}
	s.GetFormatted()
	s = nil
	s.GetFormatted()
}

func TestSCIMEnterpriseUserName_GetGivenName(tt *testing.T) {
	tt.Parallel()
	s := &SCIMEnterpriseUserName{}
	s.GetGivenName()
	s = nil
	s.GetGivenName()
}

func TestSCIMEnterpriseUserName_GetMiddleName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SCIMEnterpriseUserName{MiddleName: &zeroValue}
	s.GetMiddleName()
	s = &SCIMEnterpriseUserName{}
	s.GetMiddleName()
	s = nil
	s.GetMiddleName()
}

func TestSCIMEnterpriseUserRole_GetDisplay(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SCIMEnterpriseUserRole{Display: &zeroValue}
	s.GetDisplay()
	s = &SCIMEnterpriseUserRole{}
	s.GetDisplay()
	s = nil
	s.GetDisplay()
}

func TestSCIMEnterpriseUserRole_GetPrimary(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	s := &SCIMEnterpriseUserRole{Primary: &zeroValue}
	s.GetPrimary()
	s = &SCIMEnterpriseUserRole{}
	s.GetPrimary()
	s = nil
	s.GetPrimary()
}

func TestSCIMEnterpriseUserRole_GetType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SCIMEnterpriseUserRole{Type: &zeroValue}
	s.GetType()
	s = &SCIMEnterpriseUserRole{}
	s.GetType()
	s = nil
	s.GetType()
}

func TestSCIMEnterpriseUserRole_GetValue(tt *testing.T) {
	tt.Parallel()
	s := &SCIMEnterpriseUserRole{}
	s.GetValue()
	s = nil
	s.GetValue()
}

func TestSCIMEnterpriseUsers_GetItemsPerPage(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	s := &SCIMEnterpriseUsers{ItemsPerPage: &zeroValue}
	s.GetItemsPerPage()
	s = &SCIMEnterpriseUsers{}
	s.GetItemsPerPage()
	s = nil
	s.GetItemsPerPage()
}

func TestSCIMEnterpriseUsers_GetResources(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*SCIMEnterpriseUserAttributes{}
	s := &SCIMEnterpriseUsers{Resources: zeroValue}
	s.GetResources()
	s = &SCIMEnterpriseUsers{}
	s.GetResources()
	s = nil
	s.GetResources()
}

func TestSCIMEnterpriseUsers_GetSchemas(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	s := &SCIMEnterpriseUsers{Schemas: zeroValue}
	s.GetSchemas()
	s = &SCIMEnterpriseUsers{}
	s.GetSchemas()
	s = nil
	s.GetSchemas()
}

func TestSCIMEnterpriseUsers_GetStartIndex(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	s := &SCIMEnterpriseUsers{StartIndex: &zeroValue}
	s.GetStartIndex()
	s = &SCIMEnterpriseUsers{}
	s.GetStartIndex()
	s = nil
	s.GetStartIndex()
}

func TestSCIMEnterpriseUsers_GetTotalResults(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	s := &SCIMEnterpriseUsers{TotalResults: &zeroValue}
	s.GetTotalResults()
	s = &SCIMEnterpriseUsers{}
	s.GetTotalResults()
	s = nil
	s.GetTotalResults()
}

func TestSCIMMeta_GetCreated(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	s := &SCIMMeta{Created: &zeroValue}
	s.GetCreated()
	s = &SCIMMeta{}
	s.GetCreated()
	s = nil
	s.GetCreated()
}

func TestSCIMMeta_GetLastModified(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	s := &SCIMMeta{LastModified: &zeroValue}
	s.GetLastModified()
	s = &SCIMMeta{}
	s.GetLastModified()
	s = nil
	s.GetLastModified()
}

func TestSCIMMeta_GetLocation(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SCIMMeta{Location: &zeroValue}
	s.GetLocation()
	s = &SCIMMeta{}
	s.GetLocation()
	s = nil
	s.GetLocation()
}

func TestSCIMMeta_GetResourceType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SCIMMeta{ResourceType: &zeroValue}
	s.GetResourceType()
	s = &SCIMMeta{}
	s.GetResourceType()
	s = nil
	s.GetResourceType()
}

func TestSCIMProvisionedIdentities_GetItemsPerPage(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	s := &SCIMProvisionedIdentities{ItemsPerPage: &zeroValue}
	s.GetItemsPerPage()
	s = &SCIMProvisionedIdentities{}
	s.GetItemsPerPage()
	s = nil
	s.GetItemsPerPage()
}

func TestSCIMProvisionedIdentities_GetResources(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*SCIMUserAttributes{}
	s := &SCIMProvisionedIdentities{Resources: zeroValue}
	s.GetResources()
	s = &SCIMProvisionedIdentities{}
	s.GetResources()
	s = nil
	s.GetResources()
}

func TestSCIMProvisionedIdentities_GetSchemas(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	s := &SCIMProvisionedIdentities{Schemas: zeroValue}
	s.GetSchemas()
	s = &SCIMProvisionedIdentities{}
	s.GetSchemas()
	s = nil
	s.GetSchemas()
}

func TestSCIMProvisionedIdentities_GetStartIndex(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	s := &SCIMProvisionedIdentities{StartIndex: &zeroValue}
	s.GetStartIndex()
	s = &SCIMProvisionedIdentities{}
	s.GetStartIndex()
	s = nil
	s.GetStartIndex()
}

func TestSCIMProvisionedIdentities_GetTotalResults(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	s := &SCIMProvisionedIdentities{TotalResults: &zeroValue}
	s.GetTotalResults()
	s = &SCIMProvisionedIdentities{}
	s.GetTotalResults()
	s = nil
	s.GetTotalResults()
}

func TestSCIMUserAttributes_GetActive(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	s := &SCIMUserAttributes{Active: &zeroValue}
	s.GetActive()
	s = &SCIMUserAttributes{}
	s.GetActive()
	s = nil
	s.GetActive()
}

func TestSCIMUserAttributes_GetDisplayName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SCIMUserAttributes{DisplayName: &zeroValue}
	s.GetDisplayName()
	s = &SCIMUserAttributes{}
	s.GetDisplayName()
	s = nil
	s.GetDisplayName()
}

func TestSCIMUserAttributes_GetEmails(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*SCIMUserEmail{}
	s := &SCIMUserAttributes{Emails: zeroValue}
	s.GetEmails()
	s = &SCIMUserAttributes{}
	s.GetEmails()
	s = nil
	s.GetEmails()
}

func TestSCIMUserAttributes_GetExternalID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SCIMUserAttributes{ExternalID: &zeroValue}
	s.GetExternalID()
	s = &SCIMUserAttributes{}
	s.GetExternalID()
	s = nil
	s.GetExternalID()
}

func TestSCIMUserAttributes_GetGroups(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	s := &SCIMUserAttributes{Groups: zeroValue}
	s.GetGroups()
	s = &SCIMUserAttributes{}
	s.GetGroups()
	s = nil
	s.GetGroups()
}

func TestSCIMUserAttributes_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SCIMUserAttributes{ID: &zeroValue}
	s.GetID()
	s = &SCIMUserAttributes{}
	s.GetID()
	s = nil
	s.GetID()
}

func TestSCIMUserAttributes_GetMeta(tt *testing.T) {
	tt.Parallel()
	s := &SCIMUserAttributes{}
	s.GetMeta()
	s = nil
	s.GetMeta()
}

func TestSCIMUserAttributes_GetName(tt *testing.T) {
	tt.Parallel()
	s := &SCIMUserAttributes{}
	s.GetName()
	s = nil
	s.GetName()
}

func TestSCIMUserAttributes_GetRoles(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*SCIMUserRole{}
	s := &SCIMUserAttributes{Roles: zeroValue}
	s.GetRoles()
	s = &SCIMUserAttributes{}
	s.GetRoles()
	s = nil
	s.GetRoles()
}

func TestSCIMUserAttributes_GetSchemas(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	s := &SCIMUserAttributes{Schemas: zeroValue}
	s.GetSchemas()
	s = &SCIMUserAttributes{}
	s.GetSchemas()
	s = nil
	s.GetSchemas()
}

func TestSCIMUserAttributes_GetUserName(tt *testing.T) {
	tt.Parallel()
	s := &SCIMUserAttributes{}
	s.GetUserName()
	s = nil
	s.GetUserName()
}

func TestSCIMUserEmail_GetPrimary(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	s := &SCIMUserEmail{Primary: &zeroValue}
	s.GetPrimary()
	s = &SCIMUserEmail{}
	s.GetPrimary()
	s = nil
	s.GetPrimary()
}

func TestSCIMUserEmail_GetType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SCIMUserEmail{Type: &zeroValue}
	s.GetType()
	s = &SCIMUserEmail{}
	s.GetType()
	s = nil
	s.GetType()
}

func TestSCIMUserEmail_GetValue(tt *testing.T) {
	tt.Parallel()
	s := &SCIMUserEmail{}
	s.GetValue()
	s = nil
	s.GetValue()
}

func TestSCIMUserName_GetFamilyName(tt *testing.T) {
	tt.Parallel()
	s := &SCIMUserName{}
	s.GetFamilyName()
	s = nil
	s.GetFamilyName()
}

func TestSCIMUserName_GetFormatted(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SCIMUserName{Formatted: &zeroValue}
	s.GetFormatted()
	s = &SCIMUserName{}
	s.GetFormatted()
	s = nil
	s.GetFormatted()
}

func TestSCIMUserName_GetGivenName(tt *testing.T) {
	tt.Parallel()
	s := &SCIMUserName{}
	s.GetGivenName()
	s = nil
	s.GetGivenName()
}

func TestSCIMUserRole_GetDisplay(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SCIMUserRole{Display: &zeroValue}
	s.GetDisplay()
	s = &SCIMUserRole{}
	s.GetDisplay()
	s = nil
	s.GetDisplay()
}

func TestSCIMUserRole_GetPrimary(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	s := &SCIMUserRole{Primary: &zeroValue}
	s.GetPrimary()
	s = &SCIMUserRole{}
	s.GetPrimary()
	s = nil
	s.GetPrimary()
}

func TestSCIMUserRole_GetType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SCIMUserRole{Type: &zeroValue}
	s.GetType()
	s = &SCIMUserRole{}
	s.GetType()
	s = nil
	s.GetType()
}

func TestSCIMUserRole_GetValue(tt *testing.T) {
	tt.Parallel()
	s := &SCIMUserRole{}
	s.GetValue()
	s = nil
	s.GetValue()
}

func TestSearchOptions_GetAdvancedSearch(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	s := &SearchOptions{AdvancedSearch: &zeroValue}
	s.GetAdvancedSearch()
	s = &SearchOptions{}
	s.GetAdvancedSearch()
	s = nil
	s.GetAdvancedSearch()
}

func TestSearchOptions_GetOrder(tt *testing.T) {
	tt.Parallel()
	s := &SearchOptions{}
	s.GetOrder()
	s = nil
	s.GetOrder()
}

func TestSearchOptions_GetSearchType(tt *testing.T) {
	tt.Parallel()
	s := &SearchOptions{}
	s.GetSearchType()
	s = nil
	s.GetSearchType()
}

func TestSearchOptions_GetSort(tt *testing.T) {
	tt.Parallel()
	s := &SearchOptions{}
	s.GetSort()
	s = nil
	s.GetSort()
}

func TestSearchOptions_GetTextMatch(tt *testing.T) {
	tt.Parallel()
	s := &SearchOptions{}
	s.GetTextMatch()
	s = nil
	s.GetTextMatch()
}

func TestSeatAssignments_GetSeatsCreated(tt *testing.T) {
	tt.Parallel()
	s := &SeatAssignments{}
	s.GetSeatsCreated()
	s = nil
	s.GetSeatsCreated()
}

func TestSeatCancellations_GetSeatsCancelled(tt *testing.T) {
	tt.Parallel()
	s := &SeatCancellations{}
	s.GetSeatsCancelled()
	s = nil
	s.GetSeatsCancelled()
}

func TestSecret_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	s := &Secret{}
	s.GetCreatedAt()
	s = nil
	s.GetCreatedAt()
}

func TestSecret_GetName(tt *testing.T) {
	tt.Parallel()
	s := &Secret{}
	s.GetName()
	s = nil
	s.GetName()
}

func TestSecret_GetSelectedRepositoriesURL(tt *testing.T) {
	tt.Parallel()
	s := &Secret{}
	s.GetSelectedRepositoriesURL()
	s = nil
	s.GetSelectedRepositoriesURL()
}

func TestSecret_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	s := &Secret{}
	s.GetUpdatedAt()
	s = nil
	s.GetUpdatedAt()
}

func TestSecret_GetVisibility(tt *testing.T) {
	tt.Parallel()
	s := &Secret{}
	s.GetVisibility()
	s = nil
	s.GetVisibility()
}

func TestSecretOrgRequest_GetEncryptedValue(tt *testing.T) {
	tt.Parallel()
	s := &SecretOrgRequest{}
	s.GetEncryptedValue()
	s = nil
	s.GetEncryptedValue()
}

func TestSecretOrgRequest_GetKeyID(tt *testing.T) {
	tt.Parallel()
	s := &SecretOrgRequest{}
	s.GetKeyID()
	s = nil
	s.GetKeyID()
}

func TestSecretOrgRequest_GetSelectedRepositoryIDs(tt *testing.T) {
	tt.Parallel()
	zeroValue := []int64{}
	s := &SecretOrgRequest{SelectedRepositoryIDs: zeroValue}
	s.GetSelectedRepositoryIDs()
	s = &SecretOrgRequest{}
	s.GetSelectedRepositoryIDs()
	s = nil
	s.GetSelectedRepositoryIDs()
}

func TestSecretOrgRequest_GetVisibility(tt *testing.T) {
	tt.Parallel()
	s := &SecretOrgRequest{}
	s.GetVisibility()
	s = nil
	s.GetVisibility()
}

func TestSecretRequest_GetEncryptedValue(tt *testing.T) {
	tt.Parallel()
	s := &SecretRequest{}
	s.GetEncryptedValue()
	s = nil
	s.GetEncryptedValue()
}

func TestSecretRequest_GetKeyID(tt *testing.T) {
	tt.Parallel()
	s := &SecretRequest{}
	s.GetKeyID()
	s = nil
	s.GetKeyID()
}

func TestSecrets_GetSecrets(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*Secret{}
	s := &Secrets{Secrets: zeroValue}
	s.GetSecrets()
	s = &Secrets{}
	s.GetSecrets()
	s = nil
	s.GetSecrets()
}

func TestSecrets_GetTotalCount(tt *testing.T) {
	tt.Parallel()
	s := &Secrets{}
	s.GetTotalCount()
	s = nil
	s.GetTotalCount()
}

func TestSecretScanning_GetStatus(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SecretScanning{Status: &zeroValue}
	s.GetStatus()
	s = &SecretScanning{}
	s.GetStatus()
	s = nil
	s.GetStatus()
}

func TestSecretScanningAlert_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	s := &SecretScanningAlert{CreatedAt: &zeroValue}
	s.GetCreatedAt()
	s = &SecretScanningAlert{}
	s.GetCreatedAt()
	s = nil
	s.GetCreatedAt()
}

func TestSecretScanningAlert_GetFirstLocationDetected(tt *testing.T) {
	tt.Parallel()
	s := &SecretScanningAlert{}
	s.GetFirstLocationDetected()
	s = nil
	s.GetFirstLocationDetected()
}

func TestSecretScanningAlert_GetHasMoreLocations(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	s := &SecretScanningAlert{HasMoreLocations: &zeroValue}
	s.GetHasMoreLocations()
	s = &SecretScanningAlert{}
	s.GetHasMoreLocations()
	s = nil
	s.GetHasMoreLocations()
}

func TestSecretScanningAlert_GetHTMLURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SecretScanningAlert{HTMLURL: &zeroValue}
	s.GetHTMLURL()
	s = &SecretScanningAlert{}
	s.GetHTMLURL()
	s = nil
	s.GetHTMLURL()
}

func TestSecretScanningAlert_GetIsBase64Encoded(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	s := &SecretScanningAlert{IsBase64Encoded: &zeroValue}
	s.GetIsBase64Encoded()
	s = &SecretScanningAlert{}
	s.GetIsBase64Encoded()
	s = nil
	s.GetIsBase64Encoded()
}

func TestSecretScanningAlert_GetLocationsURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SecretScanningAlert{LocationsURL: &zeroValue}
	s.GetLocationsURL()
	s = &SecretScanningAlert{}
	s.GetLocationsURL()
	s = nil
	s.GetLocationsURL()
}

func TestSecretScanningAlert_GetMultiRepo(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	s := &SecretScanningAlert{MultiRepo: &zeroValue}
	s.GetMultiRepo()
	s = &SecretScanningAlert{}
	s.GetMultiRepo()
	s = nil
	s.GetMultiRepo()
}

func TestSecretScanningAlert_GetNumber(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	s := &SecretScanningAlert{Number: &zeroValue}
	s.GetNumber()
	s = &SecretScanningAlert{}
	s.GetNumber()
	s = nil
	s.GetNumber()
}

func TestSecretScanningAlert_GetPubliclyLeaked(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	s := &SecretScanningAlert{PubliclyLeaked: &zeroValue}
	s.GetPubliclyLeaked()
	s = &SecretScanningAlert{}
	s.GetPubliclyLeaked()
	s = nil
	s.GetPubliclyLeaked()
}

func TestSecretScanningAlert_GetPushProtectionBypassed(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	s := &SecretScanningAlert{PushProtectionBypassed: &zeroValue}
	s.GetPushProtectionBypassed()
	s = &SecretScanningAlert{}
	s.GetPushProtectionBypassed()
	s = nil
	s.GetPushProtectionBypassed()
}

func TestSecretScanningAlert_GetPushProtectionBypassedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	s := &SecretScanningAlert{PushProtectionBypassedAt: &zeroValue}
	s.GetPushProtectionBypassedAt()
	s = &SecretScanningAlert{}
	s.GetPushProtectionBypassedAt()
	s = nil
	s.GetPushProtectionBypassedAt()
}

func TestSecretScanningAlert_GetPushProtectionBypassedBy(tt *testing.T) {
	tt.Parallel()
	s := &SecretScanningAlert{}
	s.GetPushProtectionBypassedBy()
	s = nil
	s.GetPushProtectionBypassedBy()
}

func TestSecretScanningAlert_GetPushProtectionBypassRequestComment(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SecretScanningAlert{PushProtectionBypassRequestComment: &zeroValue}
	s.GetPushProtectionBypassRequestComment()
	s = &SecretScanningAlert{}
	s.GetPushProtectionBypassRequestComment()
	s = nil
	s.GetPushProtectionBypassRequestComment()
}

func TestSecretScanningAlert_GetPushProtectionBypassRequestHTMLURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SecretScanningAlert{PushProtectionBypassRequestHTMLURL: &zeroValue}
	s.GetPushProtectionBypassRequestHTMLURL()
	s = &SecretScanningAlert{}
	s.GetPushProtectionBypassRequestHTMLURL()
	s = nil
	s.GetPushProtectionBypassRequestHTMLURL()
}

func TestSecretScanningAlert_GetPushProtectionBypassRequestReviewer(tt *testing.T) {
	tt.Parallel()
	s := &SecretScanningAlert{}
	s.GetPushProtectionBypassRequestReviewer()
	s = nil
	s.GetPushProtectionBypassRequestReviewer()
}

func TestSecretScanningAlert_GetPushProtectionBypassRequestReviewerComment(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SecretScanningAlert{PushProtectionBypassRequestReviewerComment: &zeroValue}
	s.GetPushProtectionBypassRequestReviewerComment()
	s = &SecretScanningAlert{}
	s.GetPushProtectionBypassRequestReviewerComment()
	s = nil
	s.GetPushProtectionBypassRequestReviewerComment()
}

func TestSecretScanningAlert_GetRepository(tt *testing.T) {
	tt.Parallel()
	s := &SecretScanningAlert{}
	s.GetRepository()
	s = nil
	s.GetRepository()
}

func TestSecretScanningAlert_GetResolution(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SecretScanningAlert{Resolution: &zeroValue}
	s.GetResolution()
	s = &SecretScanningAlert{}
	s.GetResolution()
	s = nil
	s.GetResolution()
}

func TestSecretScanningAlert_GetResolutionComment(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SecretScanningAlert{ResolutionComment: &zeroValue}
	s.GetResolutionComment()
	s = &SecretScanningAlert{}
	s.GetResolutionComment()
	s = nil
	s.GetResolutionComment()
}

func TestSecretScanningAlert_GetResolvedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	s := &SecretScanningAlert{ResolvedAt: &zeroValue}
	s.GetResolvedAt()
	s = &SecretScanningAlert{}
	s.GetResolvedAt()
	s = nil
	s.GetResolvedAt()
}

func TestSecretScanningAlert_GetResolvedBy(tt *testing.T) {
	tt.Parallel()
	s := &SecretScanningAlert{}
	s.GetResolvedBy()
	s = nil
	s.GetResolvedBy()
}

func TestSecretScanningAlert_GetSecret(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SecretScanningAlert{Secret: &zeroValue}
	s.GetSecret()
	s = &SecretScanningAlert{}
	s.GetSecret()
	s = nil
	s.GetSecret()
}

func TestSecretScanningAlert_GetSecretType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SecretScanningAlert{SecretType: &zeroValue}
	s.GetSecretType()
	s = &SecretScanningAlert{}
	s.GetSecretType()
	s = nil
	s.GetSecretType()
}

func TestSecretScanningAlert_GetSecretTypeDisplayName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SecretScanningAlert{SecretTypeDisplayName: &zeroValue}
	s.GetSecretTypeDisplayName()
	s = &SecretScanningAlert{}
	s.GetSecretTypeDisplayName()
	s = nil
	s.GetSecretTypeDisplayName()
}

func TestSecretScanningAlert_GetState(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SecretScanningAlert{State: &zeroValue}
	s.GetState()
	s = &SecretScanningAlert{}
	s.GetState()
	s = nil
	s.GetState()
}

func TestSecretScanningAlert_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	s := &SecretScanningAlert{UpdatedAt: &zeroValue}
	s.GetUpdatedAt()
	s = &SecretScanningAlert{}
	s.GetUpdatedAt()
	s = nil
	s.GetUpdatedAt()
}

func TestSecretScanningAlert_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SecretScanningAlert{URL: &zeroValue}
	s.GetURL()
	s = &SecretScanningAlert{}
	s.GetURL()
	s = nil
	s.GetURL()
}

func TestSecretScanningAlert_GetValidity(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SecretScanningAlert{Validity: &zeroValue}
	s.GetValidity()
	s = &SecretScanningAlert{}
	s.GetValidity()
	s = nil
	s.GetValidity()
}

func TestSecretScanningAlertEvent_GetAction(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SecretScanningAlertEvent{Action: &zeroValue}
	s.GetAction()
	s = &SecretScanningAlertEvent{}
	s.GetAction()
	s = nil
	s.GetAction()
}

func TestSecretScanningAlertEvent_GetAlert(tt *testing.T) {
	tt.Parallel()
	s := &SecretScanningAlertEvent{}
	s.GetAlert()
	s = nil
	s.GetAlert()
}

func TestSecretScanningAlertEvent_GetEnterprise(tt *testing.T) {
	tt.Parallel()
	s := &SecretScanningAlertEvent{}
	s.GetEnterprise()
	s = nil
	s.GetEnterprise()
}

func TestSecretScanningAlertEvent_GetInstallation(tt *testing.T) {
	tt.Parallel()
	s := &SecretScanningAlertEvent{}
	s.GetInstallation()
	s = nil
	s.GetInstallation()
}

func TestSecretScanningAlertEvent_GetOrganization(tt *testing.T) {
	tt.Parallel()
	s := &SecretScanningAlertEvent{}
	s.GetOrganization()
	s = nil
	s.GetOrganization()
}

func TestSecretScanningAlertEvent_GetRepo(tt *testing.T) {
	tt.Parallel()
	s := &SecretScanningAlertEvent{}
	s.GetRepo()
	s = nil
	s.GetRepo()
}

func TestSecretScanningAlertEvent_GetSender(tt *testing.T) {
	tt.Parallel()
	s := &SecretScanningAlertEvent{}
	s.GetSender()
	s = nil
	s.GetSender()
}

func TestSecretScanningAlertListOptions_GetDirection(tt *testing.T) {
	tt.Parallel()
	s := &SecretScanningAlertListOptions{}
	s.GetDirection()
	s = nil
	s.GetDirection()
}

func TestSecretScanningAlertListOptions_GetIsMultiRepo(tt *testing.T) {
	tt.Parallel()
	s := &SecretScanningAlertListOptions{}
	s.GetIsMultiRepo()
	s = nil
	s.GetIsMultiRepo()
}

func TestSecretScanningAlertListOptions_GetIsPubliclyLeaked(tt *testing.T) {
	tt.Parallel()
	s := &SecretScanningAlertListOptions{}
	s.GetIsPubliclyLeaked()
	s = nil
	s.GetIsPubliclyLeaked()
}

func TestSecretScanningAlertListOptions_GetResolution(tt *testing.T) {
	tt.Parallel()
	s := &SecretScanningAlertListOptions{}
	s.GetResolution()
	s = nil
	s.GetResolution()
}

func TestSecretScanningAlertListOptions_GetSecretType(tt *testing.T) {
	tt.Parallel()
	s := &SecretScanningAlertListOptions{}
	s.GetSecretType()
	s = nil
	s.GetSecretType()
}

func TestSecretScanningAlertListOptions_GetSort(tt *testing.T) {
	tt.Parallel()
	s := &SecretScanningAlertListOptions{}
	s.GetSort()
	s = nil
	s.GetSort()
}

func TestSecretScanningAlertListOptions_GetState(tt *testing.T) {
	tt.Parallel()
	s := &SecretScanningAlertListOptions{}
	s.GetState()
	s = nil
	s.GetState()
}

func TestSecretScanningAlertListOptions_GetValidity(tt *testing.T) {
	tt.Parallel()
	s := &SecretScanningAlertListOptions{}
	s.GetValidity()
	s = nil
	s.GetValidity()
}

func TestSecretScanningAlertLocation_GetDetails(tt *testing.T) {
	tt.Parallel()
	s := &SecretScanningAlertLocation{}
	s.GetDetails()
	s = nil
	s.GetDetails()
}

func TestSecretScanningAlertLocation_GetType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SecretScanningAlertLocation{Type: &zeroValue}
	s.GetType()
	s = &SecretScanningAlertLocation{}
	s.GetType()
	s = nil
	s.GetType()
}

func TestSecretScanningAlertLocationDetails_GetBlobSHA(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SecretScanningAlertLocationDetails{BlobSHA: &zeroValue}
	s.GetBlobSHA()
	s = &SecretScanningAlertLocationDetails{}
	s.GetBlobSHA()
	s = nil
	s.GetBlobSHA()
}

func TestSecretScanningAlertLocationDetails_GetBlobURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SecretScanningAlertLocationDetails{BlobURL: &zeroValue}
	s.GetBlobURL()
	s = &SecretScanningAlertLocationDetails{}
	s.GetBlobURL()
	s = nil
	s.GetBlobURL()
}

func TestSecretScanningAlertLocationDetails_GetCommitSHA(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SecretScanningAlertLocationDetails{CommitSHA: &zeroValue}
	s.GetCommitSHA()
	s = &SecretScanningAlertLocationDetails{}
	s.GetCommitSHA()
	s = nil
	s.GetCommitSHA()
}

func TestSecretScanningAlertLocationDetails_GetCommitURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SecretScanningAlertLocationDetails{CommitURL: &zeroValue}
	s.GetCommitURL()
	s = &SecretScanningAlertLocationDetails{}
	s.GetCommitURL()
	s = nil
	s.GetCommitURL()
}

func TestSecretScanningAlertLocationDetails_GetEndColumn(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	s := &SecretScanningAlertLocationDetails{EndColumn: &zeroValue}
	s.GetEndColumn()
	s = &SecretScanningAlertLocationDetails{}
	s.GetEndColumn()
	s = nil
	s.GetEndColumn()
}

func TestSecretScanningAlertLocationDetails_GetEndLine(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	s := &SecretScanningAlertLocationDetails{EndLine: &zeroValue}
	s.GetEndLine()
	s = &SecretScanningAlertLocationDetails{}
	s.GetEndLine()
	s = nil
	s.GetEndLine()
}

func TestSecretScanningAlertLocationDetails_GetPath(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SecretScanningAlertLocationDetails{Path: &zeroValue}
	s.GetPath()
	s = &SecretScanningAlertLocationDetails{}
	s.GetPath()
	s = nil
	s.GetPath()
}

func TestSecretScanningAlertLocationDetails_GetPullRequestCommentURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SecretScanningAlertLocationDetails{PullRequestCommentURL: &zeroValue}
	s.GetPullRequestCommentURL()
	s = &SecretScanningAlertLocationDetails{}
	s.GetPullRequestCommentURL()
	s = nil
	s.GetPullRequestCommentURL()
}

func TestSecretScanningAlertLocationDetails_GetStartColumn(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	s := &SecretScanningAlertLocationDetails{StartColumn: &zeroValue}
	s.GetStartColumn()
	s = &SecretScanningAlertLocationDetails{}
	s.GetStartColumn()
	s = nil
	s.GetStartColumn()
}

func TestSecretScanningAlertLocationDetails_GetStartline(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	s := &SecretScanningAlertLocationDetails{Startline: &zeroValue}
	s.GetStartline()
	s = &SecretScanningAlertLocationDetails{}
	s.GetStartline()
	s = nil
	s.GetStartline()
}

func TestSecretScanningAlertLocationEvent_GetAction(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SecretScanningAlertLocationEvent{Action: &zeroValue}
	s.GetAction()
	s = &SecretScanningAlertLocationEvent{}
	s.GetAction()
	s = nil
	s.GetAction()
}

func TestSecretScanningAlertLocationEvent_GetAlert(tt *testing.T) {
	tt.Parallel()
	s := &SecretScanningAlertLocationEvent{}
	s.GetAlert()
	s = nil
	s.GetAlert()
}

func TestSecretScanningAlertLocationEvent_GetInstallation(tt *testing.T) {
	tt.Parallel()
	s := &SecretScanningAlertLocationEvent{}
	s.GetInstallation()
	s = nil
	s.GetInstallation()
}

func TestSecretScanningAlertLocationEvent_GetLocation(tt *testing.T) {
	tt.Parallel()
	s := &SecretScanningAlertLocationEvent{}
	s.GetLocation()
	s = nil
	s.GetLocation()
}

func TestSecretScanningAlertLocationEvent_GetOrganization(tt *testing.T) {
	tt.Parallel()
	s := &SecretScanningAlertLocationEvent{}
	s.GetOrganization()
	s = nil
	s.GetOrganization()
}

func TestSecretScanningAlertLocationEvent_GetRepo(tt *testing.T) {
	tt.Parallel()
	s := &SecretScanningAlertLocationEvent{}
	s.GetRepo()
	s = nil
	s.GetRepo()
}

func TestSecretScanningAlertLocationEvent_GetSender(tt *testing.T) {
	tt.Parallel()
	s := &SecretScanningAlertLocationEvent{}
	s.GetSender()
	s = nil
	s.GetSender()
}

func TestSecretScanningAlertUpdateOptions_GetResolution(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SecretScanningAlertUpdateOptions{Resolution: &zeroValue}
	s.GetResolution()
	s = &SecretScanningAlertUpdateOptions{}
	s.GetResolution()
	s = nil
	s.GetResolution()
}

func TestSecretScanningAlertUpdateOptions_GetResolutionComment(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SecretScanningAlertUpdateOptions{ResolutionComment: &zeroValue}
	s.GetResolutionComment()
	s = &SecretScanningAlertUpdateOptions{}
	s.GetResolutionComment()
	s = nil
	s.GetResolutionComment()
}

func TestSecretScanningAlertUpdateOptions_GetState(tt *testing.T) {
	tt.Parallel()
	s := &SecretScanningAlertUpdateOptions{}
	s.GetState()
	s = nil
	s.GetState()
}

func TestSecretScanningCreateCustomPatternsRequest_GetPatterns(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*SecretScanningCustomPatternRequest{}
	s := &SecretScanningCreateCustomPatternsRequest{Patterns: zeroValue}
	s.GetPatterns()
	s = &SecretScanningCreateCustomPatternsRequest{}
	s.GetPatterns()
	s = nil
	s.GetPatterns()
}

func TestSecretScanningCreateCustomPatternsResponse_GetCreatedPatterns(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*SecretScanningCustomPattern{}
	s := &SecretScanningCreateCustomPatternsResponse{CreatedPatterns: zeroValue}
	s.GetCreatedPatterns()
	s = &SecretScanningCreateCustomPatternsResponse{}
	s.GetCreatedPatterns()
	s = nil
	s.GetCreatedPatterns()
}

func TestSecretScanningCustomPattern_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	s := &SecretScanningCustomPattern{CreatedAt: &zeroValue}
	s.GetCreatedAt()
	s = &SecretScanningCustomPattern{}
	s.GetCreatedAt()
	s = nil
	s.GetCreatedAt()
}

func TestSecretScanningCustomPattern_GetCustomPatternVersion(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SecretScanningCustomPattern{CustomPatternVersion: &zeroValue}
	s.GetCustomPatternVersion()
	s = &SecretScanningCustomPattern{}
	s.GetCustomPatternVersion()
	s = nil
	s.GetCustomPatternVersion()
}

func TestSecretScanningCustomPattern_GetEndDelimiter(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SecretScanningCustomPattern{EndDelimiter: &zeroValue}
	s.GetEndDelimiter()
	s = &SecretScanningCustomPattern{}
	s.GetEndDelimiter()
	s = nil
	s.GetEndDelimiter()
}

func TestSecretScanningCustomPattern_GetID(tt *testing.T) {
	tt.Parallel()
	s := &SecretScanningCustomPattern{}
	s.GetID()
	s = nil
	s.GetID()
}

func TestSecretScanningCustomPattern_GetMustMatch(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	s := &SecretScanningCustomPattern{MustMatch: zeroValue}
	s.GetMustMatch()
	s = &SecretScanningCustomPattern{}
	s.GetMustMatch()
	s = nil
	s.GetMustMatch()
}

func TestSecretScanningCustomPattern_GetMustNotMatch(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	s := &SecretScanningCustomPattern{MustNotMatch: zeroValue}
	s.GetMustNotMatch()
	s = &SecretScanningCustomPattern{}
	s.GetMustNotMatch()
	s = nil
	s.GetMustNotMatch()
}

func TestSecretScanningCustomPattern_GetName(tt *testing.T) {
	tt.Parallel()
	s := &SecretScanningCustomPattern{}
	s.GetName()
	s = nil
	s.GetName()
}

func TestSecretScanningCustomPattern_GetPattern(tt *testing.T) {
	tt.Parallel()
	s := &SecretScanningCustomPattern{}
	s.GetPattern()
	s = nil
	s.GetPattern()
}

func TestSecretScanningCustomPattern_GetPushProtectionEnabled(tt *testing.T) {
	tt.Parallel()
	s := &SecretScanningCustomPattern{}
	s.GetPushProtectionEnabled()
	s = nil
	s.GetPushProtectionEnabled()
}

func TestSecretScanningCustomPattern_GetSlug(tt *testing.T) {
	tt.Parallel()
	s := &SecretScanningCustomPattern{}
	s.GetSlug()
	s = nil
	s.GetSlug()
}

func TestSecretScanningCustomPattern_GetStartDelimiter(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SecretScanningCustomPattern{StartDelimiter: &zeroValue}
	s.GetStartDelimiter()
	s = &SecretScanningCustomPattern{}
	s.GetStartDelimiter()
	s = nil
	s.GetStartDelimiter()
}

func TestSecretScanningCustomPattern_GetState(tt *testing.T) {
	tt.Parallel()
	s := &SecretScanningCustomPattern{}
	s.GetState()
	s = nil
	s.GetState()
}

func TestSecretScanningCustomPattern_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	s := &SecretScanningCustomPattern{UpdatedAt: &zeroValue}
	s.GetUpdatedAt()
	s = &SecretScanningCustomPattern{}
	s.GetUpdatedAt()
	s = nil
	s.GetUpdatedAt()
}

func TestSecretScanningCustomPatternListOptions_GetDirection(tt *testing.T) {
	tt.Parallel()
	s := &SecretScanningCustomPatternListOptions{}
	s.GetDirection()
	s = nil
	s.GetDirection()
}

func TestSecretScanningCustomPatternListOptions_GetPushProtection(tt *testing.T) {
	tt.Parallel()
	s := &SecretScanningCustomPatternListOptions{}
	s.GetPushProtection()
	s = nil
	s.GetPushProtection()
}

func TestSecretScanningCustomPatternListOptions_GetSort(tt *testing.T) {
	tt.Parallel()
	s := &SecretScanningCustomPatternListOptions{}
	s.GetSort()
	s = nil
	s.GetSort()
}

func TestSecretScanningCustomPatternListOptions_GetState(tt *testing.T) {
	tt.Parallel()
	s := &SecretScanningCustomPatternListOptions{}
	s.GetState()
	s = nil
	s.GetState()
}

func TestSecretScanningCustomPatternRequest_GetEndDelimiter(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SecretScanningCustomPatternRequest{EndDelimiter: &zeroValue}
	s.GetEndDelimiter()
	s = &SecretScanningCustomPatternRequest{}
	s.GetEndDelimiter()
	s = nil
	s.GetEndDelimiter()
}

func TestSecretScanningCustomPatternRequest_GetMustMatch(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	s := &SecretScanningCustomPatternRequest{MustMatch: zeroValue}
	s.GetMustMatch()
	s = &SecretScanningCustomPatternRequest{}
	s.GetMustMatch()
	s = nil
	s.GetMustMatch()
}

func TestSecretScanningCustomPatternRequest_GetMustNotMatch(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	s := &SecretScanningCustomPatternRequest{MustNotMatch: zeroValue}
	s.GetMustNotMatch()
	s = &SecretScanningCustomPatternRequest{}
	s.GetMustNotMatch()
	s = nil
	s.GetMustNotMatch()
}

func TestSecretScanningCustomPatternRequest_GetName(tt *testing.T) {
	tt.Parallel()
	s := &SecretScanningCustomPatternRequest{}
	s.GetName()
	s = nil
	s.GetName()
}

func TestSecretScanningCustomPatternRequest_GetPattern(tt *testing.T) {
	tt.Parallel()
	s := &SecretScanningCustomPatternRequest{}
	s.GetPattern()
	s = nil
	s.GetPattern()
}

func TestSecretScanningCustomPatternRequest_GetStartDelimiter(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SecretScanningCustomPatternRequest{StartDelimiter: &zeroValue}
	s.GetStartDelimiter()
	s = &SecretScanningCustomPatternRequest{}
	s.GetStartDelimiter()
	s = nil
	s.GetStartDelimiter()
}

func TestSecretScanningCustomPatternSetting_GetCustomPatternVersion(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SecretScanningCustomPatternSetting{CustomPatternVersion: &zeroValue}
	s.GetCustomPatternVersion()
	s = &SecretScanningCustomPatternSetting{}
	s.GetCustomPatternVersion()
	s = nil
	s.GetCustomPatternVersion()
}

func TestSecretScanningCustomPatternSetting_GetPushProtectionSetting(tt *testing.T) {
	tt.Parallel()
	s := &SecretScanningCustomPatternSetting{}
	s.GetPushProtectionSetting()
	s = nil
	s.GetPushProtectionSetting()
}

func TestSecretScanningCustomPatternSetting_GetTokenType(tt *testing.T) {
	tt.Parallel()
	s := &SecretScanningCustomPatternSetting{}
	s.GetTokenType()
	s = nil
	s.GetTokenType()
}

func TestSecretScanningCustomPatternToDelete_GetCustomPatternVersion(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SecretScanningCustomPatternToDelete{CustomPatternVersion: &zeroValue}
	s.GetCustomPatternVersion()
	s = &SecretScanningCustomPatternToDelete{}
	s.GetCustomPatternVersion()
	s = nil
	s.GetCustomPatternVersion()
}

func TestSecretScanningCustomPatternToDelete_GetPatternID(tt *testing.T) {
	tt.Parallel()
	s := &SecretScanningCustomPatternToDelete{}
	s.GetPatternID()
	s = nil
	s.GetPatternID()
}

func TestSecretScanningDelegatedBypassOptions_GetReviewers(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*BypassReviewer{}
	s := &SecretScanningDelegatedBypassOptions{Reviewers: zeroValue}
	s.GetReviewers()
	s = &SecretScanningDelegatedBypassOptions{}
	s.GetReviewers()
	s = nil
	s.GetReviewers()
}

func TestSecretScanningDeleteCustomPatternsRequest_GetPatterns(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*SecretScanningCustomPatternToDelete{}
	s := &SecretScanningDeleteCustomPatternsRequest{Patterns: zeroValue}
	s.GetPatterns()
	s = &SecretScanningDeleteCustomPatternsRequest{}
	s.GetPatterns()
	s = nil
	s.GetPatterns()
}

func TestSecretScanningDeleteCustomPatternsRequest_GetPostDeleteAction(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SecretScanningDeleteCustomPatternsRequest{PostDeleteAction: &zeroValue}
	s.GetPostDeleteAction()
	s = &SecretScanningDeleteCustomPatternsRequest{}
	s.GetPostDeleteAction()
	s = nil
	s.GetPostDeleteAction()
}

func TestSecretScanningPatternConfigs_GetCustomPatternOverrides(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*SecretScanningPatternOverride{}
	s := &SecretScanningPatternConfigs{CustomPatternOverrides: zeroValue}
	s.GetCustomPatternOverrides()
	s = &SecretScanningPatternConfigs{}
	s.GetCustomPatternOverrides()
	s = nil
	s.GetCustomPatternOverrides()
}

func TestSecretScanningPatternConfigs_GetPatternConfigVersion(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SecretScanningPatternConfigs{PatternConfigVersion: &zeroValue}
	s.GetPatternConfigVersion()
	s = &SecretScanningPatternConfigs{}
	s.GetPatternConfigVersion()
	s = nil
	s.GetPatternConfigVersion()
}

func TestSecretScanningPatternConfigs_GetProviderPatternOverrides(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*SecretScanningPatternOverride{}
	s := &SecretScanningPatternConfigs{ProviderPatternOverrides: zeroValue}
	s.GetProviderPatternOverrides()
	s = &SecretScanningPatternConfigs{}
	s.GetProviderPatternOverrides()
	s = nil
	s.GetProviderPatternOverrides()
}

func TestSecretScanningPatternConfigsUpdate_GetPatternConfigVersion(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SecretScanningPatternConfigsUpdate{PatternConfigVersion: &zeroValue}
	s.GetPatternConfigVersion()
	s = &SecretScanningPatternConfigsUpdate{}
	s.GetPatternConfigVersion()
	s = nil
	s.GetPatternConfigVersion()
}

func TestSecretScanningPatternConfigsUpdateOptions_GetCustomPatternSettings(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*SecretScanningCustomPatternSetting{}
	s := &SecretScanningPatternConfigsUpdateOptions{CustomPatternSettings: zeroValue}
	s.GetCustomPatternSettings()
	s = &SecretScanningPatternConfigsUpdateOptions{}
	s.GetCustomPatternSettings()
	s = nil
	s.GetCustomPatternSettings()
}

func TestSecretScanningPatternConfigsUpdateOptions_GetPatternConfigVersion(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SecretScanningPatternConfigsUpdateOptions{PatternConfigVersion: &zeroValue}
	s.GetPatternConfigVersion()
	s = &SecretScanningPatternConfigsUpdateOptions{}
	s.GetPatternConfigVersion()
	s = nil
	s.GetPatternConfigVersion()
}

func TestSecretScanningPatternConfigsUpdateOptions_GetProviderPatternSettings(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*SecretScanningProviderPatternSetting{}
	s := &SecretScanningPatternConfigsUpdateOptions{ProviderPatternSettings: zeroValue}
	s.GetProviderPatternSettings()
	s = &SecretScanningPatternConfigsUpdateOptions{}
	s.GetProviderPatternSettings()
	s = nil
	s.GetProviderPatternSettings()
}

func TestSecretScanningPatternOverride_GetAlertTotal(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	s := &SecretScanningPatternOverride{AlertTotal: &zeroValue}
	s.GetAlertTotal()
	s = &SecretScanningPatternOverride{}
	s.GetAlertTotal()
	s = nil
	s.GetAlertTotal()
}

func TestSecretScanningPatternOverride_GetAlertTotalPercentage(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	s := &SecretScanningPatternOverride{AlertTotalPercentage: &zeroValue}
	s.GetAlertTotalPercentage()
	s = &SecretScanningPatternOverride{}
	s.GetAlertTotalPercentage()
	s = nil
	s.GetAlertTotalPercentage()
}

func TestSecretScanningPatternOverride_GetBypassrate(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	s := &SecretScanningPatternOverride{Bypassrate: &zeroValue}
	s.GetBypassrate()
	s = &SecretScanningPatternOverride{}
	s.GetBypassrate()
	s = nil
	s.GetBypassrate()
}

func TestSecretScanningPatternOverride_GetCustomPatternVersion(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SecretScanningPatternOverride{CustomPatternVersion: &zeroValue}
	s.GetCustomPatternVersion()
	s = &SecretScanningPatternOverride{}
	s.GetCustomPatternVersion()
	s = nil
	s.GetCustomPatternVersion()
}

func TestSecretScanningPatternOverride_GetDefaultSetting(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SecretScanningPatternOverride{DefaultSetting: &zeroValue}
	s.GetDefaultSetting()
	s = &SecretScanningPatternOverride{}
	s.GetDefaultSetting()
	s = nil
	s.GetDefaultSetting()
}

func TestSecretScanningPatternOverride_GetDisplayName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SecretScanningPatternOverride{DisplayName: &zeroValue}
	s.GetDisplayName()
	s = &SecretScanningPatternOverride{}
	s.GetDisplayName()
	s = nil
	s.GetDisplayName()
}

func TestSecretScanningPatternOverride_GetEnterpriseSetting(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SecretScanningPatternOverride{EnterpriseSetting: &zeroValue}
	s.GetEnterpriseSetting()
	s = &SecretScanningPatternOverride{}
	s.GetEnterpriseSetting()
	s = nil
	s.GetEnterpriseSetting()
}

func TestSecretScanningPatternOverride_GetFalsePositiveRate(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	s := &SecretScanningPatternOverride{FalsePositiveRate: &zeroValue}
	s.GetFalsePositiveRate()
	s = &SecretScanningPatternOverride{}
	s.GetFalsePositiveRate()
	s = nil
	s.GetFalsePositiveRate()
}

func TestSecretScanningPatternOverride_GetFalsePositives(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	s := &SecretScanningPatternOverride{FalsePositives: &zeroValue}
	s.GetFalsePositives()
	s = &SecretScanningPatternOverride{}
	s.GetFalsePositives()
	s = nil
	s.GetFalsePositives()
}

func TestSecretScanningPatternOverride_GetSetting(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SecretScanningPatternOverride{Setting: &zeroValue}
	s.GetSetting()
	s = &SecretScanningPatternOverride{}
	s.GetSetting()
	s = nil
	s.GetSetting()
}

func TestSecretScanningPatternOverride_GetSlug(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SecretScanningPatternOverride{Slug: &zeroValue}
	s.GetSlug()
	s = &SecretScanningPatternOverride{}
	s.GetSlug()
	s = nil
	s.GetSlug()
}

func TestSecretScanningPatternOverride_GetTokenType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SecretScanningPatternOverride{TokenType: &zeroValue}
	s.GetTokenType()
	s = &SecretScanningPatternOverride{}
	s.GetTokenType()
	s = nil
	s.GetTokenType()
}

func TestSecretScanningProviderPatternSetting_GetPushProtectionSetting(tt *testing.T) {
	tt.Parallel()
	s := &SecretScanningProviderPatternSetting{}
	s.GetPushProtectionSetting()
	s = nil
	s.GetPushProtectionSetting()
}

func TestSecretScanningProviderPatternSetting_GetTokenType(tt *testing.T) {
	tt.Parallel()
	s := &SecretScanningProviderPatternSetting{}
	s.GetTokenType()
	s = nil
	s.GetTokenType()
}

func TestSecretScanningPushProtection_GetStatus(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SecretScanningPushProtection{Status: &zeroValue}
	s.GetStatus()
	s = &SecretScanningPushProtection{}
	s.GetStatus()
	s = nil
	s.GetStatus()
}

func TestSecretScanningScanHistory_GetBackfillScans(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*SecretsScan{}
	s := &SecretScanningScanHistory{BackfillScans: zeroValue}
	s.GetBackfillScans()
	s = &SecretScanningScanHistory{}
	s.GetBackfillScans()
	s = nil
	s.GetBackfillScans()
}

func TestSecretScanningScanHistory_GetCustomPatternBackfillScans(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*CustomPatternBackfillScan{}
	s := &SecretScanningScanHistory{CustomPatternBackfillScans: zeroValue}
	s.GetCustomPatternBackfillScans()
	s = &SecretScanningScanHistory{}
	s.GetCustomPatternBackfillScans()
	s = nil
	s.GetCustomPatternBackfillScans()
}

func TestSecretScanningScanHistory_GetIncrementalScans(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*SecretsScan{}
	s := &SecretScanningScanHistory{IncrementalScans: zeroValue}
	s.GetIncrementalScans()
	s = &SecretScanningScanHistory{}
	s.GetIncrementalScans()
	s = nil
	s.GetIncrementalScans()
}

func TestSecretScanningScanHistory_GetPatternUpdateScans(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*SecretsScan{}
	s := &SecretScanningScanHistory{PatternUpdateScans: zeroValue}
	s.GetPatternUpdateScans()
	s = &SecretScanningScanHistory{}
	s.GetPatternUpdateScans()
	s = nil
	s.GetPatternUpdateScans()
}

func TestSecretScanningUpdateCustomPatternRequest_GetCustomPatternVersion(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SecretScanningUpdateCustomPatternRequest{CustomPatternVersion: &zeroValue}
	s.GetCustomPatternVersion()
	s = &SecretScanningUpdateCustomPatternRequest{}
	s.GetCustomPatternVersion()
	s = nil
	s.GetCustomPatternVersion()
}

func TestSecretScanningUpdateCustomPatternRequest_GetEndDelimiter(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SecretScanningUpdateCustomPatternRequest{EndDelimiter: &zeroValue}
	s.GetEndDelimiter()
	s = &SecretScanningUpdateCustomPatternRequest{}
	s.GetEndDelimiter()
	s = nil
	s.GetEndDelimiter()
}

func TestSecretScanningUpdateCustomPatternRequest_GetMustMatch(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	s := &SecretScanningUpdateCustomPatternRequest{MustMatch: zeroValue}
	s.GetMustMatch()
	s = &SecretScanningUpdateCustomPatternRequest{}
	s.GetMustMatch()
	s = nil
	s.GetMustMatch()
}

func TestSecretScanningUpdateCustomPatternRequest_GetMustNotMatch(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	s := &SecretScanningUpdateCustomPatternRequest{MustNotMatch: zeroValue}
	s.GetMustNotMatch()
	s = &SecretScanningUpdateCustomPatternRequest{}
	s.GetMustNotMatch()
	s = nil
	s.GetMustNotMatch()
}

func TestSecretScanningUpdateCustomPatternRequest_GetPattern(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SecretScanningUpdateCustomPatternRequest{Pattern: &zeroValue}
	s.GetPattern()
	s = &SecretScanningUpdateCustomPatternRequest{}
	s.GetPattern()
	s = nil
	s.GetPattern()
}

func TestSecretScanningUpdateCustomPatternRequest_GetStartDelimiter(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SecretScanningUpdateCustomPatternRequest{StartDelimiter: &zeroValue}
	s.GetStartDelimiter()
	s = &SecretScanningUpdateCustomPatternRequest{}
	s.GetStartDelimiter()
	s = nil
	s.GetStartDelimiter()
}

func TestSecretScanningValidityChecks_GetStatus(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SecretScanningValidityChecks{Status: &zeroValue}
	s.GetStatus()
	s = &SecretScanningValidityChecks{}
	s.GetStatus()
	s = nil
	s.GetStatus()
}

func TestSecretsScan_GetCompletedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	s := &SecretsScan{CompletedAt: &zeroValue}
	s.GetCompletedAt()
	s = &SecretsScan{}
	s.GetCompletedAt()
	s = nil
	s.GetCompletedAt()
}

func TestSecretsScan_GetStartedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	s := &SecretsScan{StartedAt: &zeroValue}
	s.GetStartedAt()
	s = &SecretsScan{}
	s.GetStartedAt()
	s = nil
	s.GetStartedAt()
}

func TestSecretsScan_GetStatus(tt *testing.T) {
	tt.Parallel()
	s := &SecretsScan{}
	s.GetStatus()
	s = nil
	s.GetStatus()
}

func TestSecretsScan_GetType(tt *testing.T) {
	tt.Parallel()
	s := &SecretsScan{}
	s.GetType()
	s = nil
	s.GetType()
}

func TestSecurityAdvisory_GetAuthor(tt *testing.T) {
	tt.Parallel()
	s := &SecurityAdvisory{}
	s.GetAuthor()
	s = nil
	s.GetAuthor()
}

func TestSecurityAdvisory_GetClosedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	s := &SecurityAdvisory{ClosedAt: &zeroValue}
	s.GetClosedAt()
	s = &SecurityAdvisory{}
	s.GetClosedAt()
	s = nil
	s.GetClosedAt()
}

func TestSecurityAdvisory_GetCollaboratingTeams(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*Team{}
	s := &SecurityAdvisory{CollaboratingTeams: zeroValue}
	s.GetCollaboratingTeams()
	s = &SecurityAdvisory{}
	s.GetCollaboratingTeams()
	s = nil
	s.GetCollaboratingTeams()
}

func TestSecurityAdvisory_GetCollaboratingUsers(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*User{}
	s := &SecurityAdvisory{CollaboratingUsers: zeroValue}
	s.GetCollaboratingUsers()
	s = &SecurityAdvisory{}
	s.GetCollaboratingUsers()
	s = nil
	s.GetCollaboratingUsers()
}

func TestSecurityAdvisory_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	s := &SecurityAdvisory{CreatedAt: &zeroValue}
	s.GetCreatedAt()
	s = &SecurityAdvisory{}
	s.GetCreatedAt()
	s = nil
	s.GetCreatedAt()
}

func TestSecurityAdvisory_GetCredits(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*RepoAdvisoryCredit{}
	s := &SecurityAdvisory{Credits: zeroValue}
	s.GetCredits()
	s = &SecurityAdvisory{}
	s.GetCredits()
	s = nil
	s.GetCredits()
}

func TestSecurityAdvisory_GetCreditsDetailed(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*RepoAdvisoryCreditDetailed{}
	s := &SecurityAdvisory{CreditsDetailed: zeroValue}
	s.GetCreditsDetailed()
	s = &SecurityAdvisory{}
	s.GetCreditsDetailed()
	s = nil
	s.GetCreditsDetailed()
}

func TestSecurityAdvisory_GetCVEID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SecurityAdvisory{CVEID: &zeroValue}
	s.GetCVEID()
	s = &SecurityAdvisory{}
	s.GetCVEID()
	s = nil
	s.GetCVEID()
}

func TestSecurityAdvisory_GetCVSS(tt *testing.T) {
	tt.Parallel()
	s := &SecurityAdvisory{}
	s.GetCVSS()
	s = nil
	s.GetCVSS()
}

func TestSecurityAdvisory_GetCVSSSeverities(tt *testing.T) {
	tt.Parallel()
	s := &SecurityAdvisory{}
	s.GetCVSSSeverities()
	s = nil
	s.GetCVSSSeverities()
}

func TestSecurityAdvisory_GetCWEIDs(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	s := &SecurityAdvisory{CWEIDs: zeroValue}
	s.GetCWEIDs()
	s = &SecurityAdvisory{}
	s.GetCWEIDs()
	s = nil
	s.GetCWEIDs()
}

func TestSecurityAdvisory_GetCWEs(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*AdvisoryCWEs{}
	s := &SecurityAdvisory{CWEs: zeroValue}
	s.GetCWEs()
	s = &SecurityAdvisory{}
	s.GetCWEs()
	s = nil
	s.GetCWEs()
}

func TestSecurityAdvisory_GetDescription(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SecurityAdvisory{Description: &zeroValue}
	s.GetDescription()
	s = &SecurityAdvisory{}
	s.GetDescription()
	s = nil
	s.GetDescription()
}

func TestSecurityAdvisory_GetGHSAID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SecurityAdvisory{GHSAID: &zeroValue}
	s.GetGHSAID()
	s = &SecurityAdvisory{}
	s.GetGHSAID()
	s = nil
	s.GetGHSAID()
}

func TestSecurityAdvisory_GetHTMLURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SecurityAdvisory{HTMLURL: &zeroValue}
	s.GetHTMLURL()
	s = &SecurityAdvisory{}
	s.GetHTMLURL()
	s = nil
	s.GetHTMLURL()
}

func TestSecurityAdvisory_GetIdentifiers(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*AdvisoryIdentifier{}
	s := &SecurityAdvisory{Identifiers: zeroValue}
	s.GetIdentifiers()
	s = &SecurityAdvisory{}
	s.GetIdentifiers()
	s = nil
	s.GetIdentifiers()
}

func TestSecurityAdvisory_GetPrivateFork(tt *testing.T) {
	tt.Parallel()
	s := &SecurityAdvisory{}
	s.GetPrivateFork()
	s = nil
	s.GetPrivateFork()
}

func TestSecurityAdvisory_GetPublishedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	s := &SecurityAdvisory{PublishedAt: &zeroValue}
	s.GetPublishedAt()
	s = &SecurityAdvisory{}
	s.GetPublishedAt()
	s = nil
	s.GetPublishedAt()
}

func TestSecurityAdvisory_GetPublisher(tt *testing.T) {
	tt.Parallel()
	s := &SecurityAdvisory{}
	s.GetPublisher()
	s = nil
	s.GetPublisher()
}

func TestSecurityAdvisory_GetReferences(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*AdvisoryReference{}
	s := &SecurityAdvisory{References: zeroValue}
	s.GetReferences()
	s = &SecurityAdvisory{}
	s.GetReferences()
	s = nil
	s.GetReferences()
}

func TestSecurityAdvisory_GetSeverity(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SecurityAdvisory{Severity: &zeroValue}
	s.GetSeverity()
	s = &SecurityAdvisory{}
	s.GetSeverity()
	s = nil
	s.GetSeverity()
}

func TestSecurityAdvisory_GetState(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SecurityAdvisory{State: &zeroValue}
	s.GetState()
	s = &SecurityAdvisory{}
	s.GetState()
	s = nil
	s.GetState()
}

func TestSecurityAdvisory_GetSubmission(tt *testing.T) {
	tt.Parallel()
	s := &SecurityAdvisory{}
	s.GetSubmission()
	s = nil
	s.GetSubmission()
}

func TestSecurityAdvisory_GetSummary(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SecurityAdvisory{Summary: &zeroValue}
	s.GetSummary()
	s = &SecurityAdvisory{}
	s.GetSummary()
	s = nil
	s.GetSummary()
}

func TestSecurityAdvisory_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	s := &SecurityAdvisory{UpdatedAt: &zeroValue}
	s.GetUpdatedAt()
	s = &SecurityAdvisory{}
	s.GetUpdatedAt()
	s = nil
	s.GetUpdatedAt()
}

func TestSecurityAdvisory_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SecurityAdvisory{URL: &zeroValue}
	s.GetURL()
	s = &SecurityAdvisory{}
	s.GetURL()
	s = nil
	s.GetURL()
}

func TestSecurityAdvisory_GetVulnerabilities(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*AdvisoryVulnerability{}
	s := &SecurityAdvisory{Vulnerabilities: zeroValue}
	s.GetVulnerabilities()
	s = &SecurityAdvisory{}
	s.GetVulnerabilities()
	s = nil
	s.GetVulnerabilities()
}

func TestSecurityAdvisory_GetWithdrawnAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	s := &SecurityAdvisory{WithdrawnAt: &zeroValue}
	s.GetWithdrawnAt()
	s = &SecurityAdvisory{}
	s.GetWithdrawnAt()
	s = nil
	s.GetWithdrawnAt()
}

func TestSecurityAdvisoryEvent_GetAction(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SecurityAdvisoryEvent{Action: &zeroValue}
	s.GetAction()
	s = &SecurityAdvisoryEvent{}
	s.GetAction()
	s = nil
	s.GetAction()
}

func TestSecurityAdvisoryEvent_GetEnterprise(tt *testing.T) {
	tt.Parallel()
	s := &SecurityAdvisoryEvent{}
	s.GetEnterprise()
	s = nil
	s.GetEnterprise()
}

func TestSecurityAdvisoryEvent_GetInstallation(tt *testing.T) {
	tt.Parallel()
	s := &SecurityAdvisoryEvent{}
	s.GetInstallation()
	s = nil
	s.GetInstallation()
}

func TestSecurityAdvisoryEvent_GetOrganization(tt *testing.T) {
	tt.Parallel()
	s := &SecurityAdvisoryEvent{}
	s.GetOrganization()
	s = nil
	s.GetOrganization()
}

func TestSecurityAdvisoryEvent_GetRepository(tt *testing.T) {
	tt.Parallel()
	s := &SecurityAdvisoryEvent{}
	s.GetRepository()
	s = nil
	s.GetRepository()
}

func TestSecurityAdvisoryEvent_GetSecurityAdvisory(tt *testing.T) {
	tt.Parallel()
	s := &SecurityAdvisoryEvent{}
	s.GetSecurityAdvisory()
	s = nil
	s.GetSecurityAdvisory()
}

func TestSecurityAdvisoryEvent_GetSender(tt *testing.T) {
	tt.Parallel()
	s := &SecurityAdvisoryEvent{}
	s.GetSender()
	s = nil
	s.GetSender()
}

func TestSecurityAdvisorySubmission_GetAccepted(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	s := &SecurityAdvisorySubmission{Accepted: &zeroValue}
	s.GetAccepted()
	s = &SecurityAdvisorySubmission{}
	s.GetAccepted()
	s = nil
	s.GetAccepted()
}

func TestSecurityAndAnalysis_GetAdvancedSecurity(tt *testing.T) {
	tt.Parallel()
	s := &SecurityAndAnalysis{}
	s.GetAdvancedSecurity()
	s = nil
	s.GetAdvancedSecurity()
}

func TestSecurityAndAnalysis_GetCodeSecurity(tt *testing.T) {
	tt.Parallel()
	s := &SecurityAndAnalysis{}
	s.GetCodeSecurity()
	s = nil
	s.GetCodeSecurity()
}

func TestSecurityAndAnalysis_GetDependabotSecurityUpdates(tt *testing.T) {
	tt.Parallel()
	s := &SecurityAndAnalysis{}
	s.GetDependabotSecurityUpdates()
	s = nil
	s.GetDependabotSecurityUpdates()
}

func TestSecurityAndAnalysis_GetSecretScanning(tt *testing.T) {
	tt.Parallel()
	s := &SecurityAndAnalysis{}
	s.GetSecretScanning()
	s = nil
	s.GetSecretScanning()
}

func TestSecurityAndAnalysis_GetSecretScanningPushProtection(tt *testing.T) {
	tt.Parallel()
	s := &SecurityAndAnalysis{}
	s.GetSecretScanningPushProtection()
	s = nil
	s.GetSecretScanningPushProtection()
}

func TestSecurityAndAnalysis_GetSecretScanningValidityChecks(tt *testing.T) {
	tt.Parallel()
	s := &SecurityAndAnalysis{}
	s.GetSecretScanningValidityChecks()
	s = nil
	s.GetSecretScanningValidityChecks()
}

func TestSecurityAndAnalysisChange_GetFrom(tt *testing.T) {
	tt.Parallel()
	s := &SecurityAndAnalysisChange{}
	s.GetFrom()
	s = nil
	s.GetFrom()
}

func TestSecurityAndAnalysisChangeFrom_GetSecurityAndAnalysis(tt *testing.T) {
	tt.Parallel()
	s := &SecurityAndAnalysisChangeFrom{}
	s.GetSecurityAndAnalysis()
	s = nil
	s.GetSecurityAndAnalysis()
}

func TestSecurityAndAnalysisEvent_GetChanges(tt *testing.T) {
	tt.Parallel()
	s := &SecurityAndAnalysisEvent{}
	s.GetChanges()
	s = nil
	s.GetChanges()
}

func TestSecurityAndAnalysisEvent_GetEnterprise(tt *testing.T) {
	tt.Parallel()
	s := &SecurityAndAnalysisEvent{}
	s.GetEnterprise()
	s = nil
	s.GetEnterprise()
}

func TestSecurityAndAnalysisEvent_GetInstallation(tt *testing.T) {
	tt.Parallel()
	s := &SecurityAndAnalysisEvent{}
	s.GetInstallation()
	s = nil
	s.GetInstallation()
}

func TestSecurityAndAnalysisEvent_GetOrganization(tt *testing.T) {
	tt.Parallel()
	s := &SecurityAndAnalysisEvent{}
	s.GetOrganization()
	s = nil
	s.GetOrganization()
}

func TestSecurityAndAnalysisEvent_GetRepository(tt *testing.T) {
	tt.Parallel()
	s := &SecurityAndAnalysisEvent{}
	s.GetRepository()
	s = nil
	s.GetRepository()
}

func TestSecurityAndAnalysisEvent_GetSender(tt *testing.T) {
	tt.Parallel()
	s := &SecurityAndAnalysisEvent{}
	s.GetSender()
	s = nil
	s.GetSender()
}

func TestSelectedReposList_GetRepositories(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*Repository{}
	s := &SelectedReposList{Repositories: zeroValue}
	s.GetRepositories()
	s = &SelectedReposList{}
	s.GetRepositories()
	s = nil
	s.GetRepositories()
}

func TestSelectedReposList_GetTotalCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	s := &SelectedReposList{TotalCount: &zeroValue}
	s.GetTotalCount()
	s = &SelectedReposList{}
	s.GetTotalCount()
	s = nil
	s.GetTotalCount()
}

func TestSelfHostedRunnersAllowedRepos_GetRepositories(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*Repository{}
	s := &SelfHostedRunnersAllowedRepos{Repositories: zeroValue}
	s.GetRepositories()
	s = &SelfHostedRunnersAllowedRepos{}
	s.GetRepositories()
	s = nil
	s.GetRepositories()
}

func TestSelfHostedRunnersAllowedRepos_GetTotalCount(tt *testing.T) {
	tt.Parallel()
	s := &SelfHostedRunnersAllowedRepos{}
	s.GetTotalCount()
	s = nil
	s.GetTotalCount()
}

func TestSelfHostedRunnersSettingsOrganization_GetEnabledRepositories(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SelfHostedRunnersSettingsOrganization{EnabledRepositories: &zeroValue}
	s.GetEnabledRepositories()
	s = &SelfHostedRunnersSettingsOrganization{}
	s.GetEnabledRepositories()
	s = nil
	s.GetEnabledRepositories()
}

func TestSelfHostedRunnersSettingsOrganization_GetSelectedRepositoriesURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SelfHostedRunnersSettingsOrganization{SelectedRepositoriesURL: &zeroValue}
	s.GetSelectedRepositoriesURL()
	s = &SelfHostedRunnersSettingsOrganization{}
	s.GetSelectedRepositoriesURL()
	s = nil
	s.GetSelectedRepositoriesURL()
}

func TestSelfHostedRunnersSettingsOrganizationOpt_GetEnabledRepositories(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SelfHostedRunnersSettingsOrganizationOpt{EnabledRepositories: &zeroValue}
	s.GetEnabledRepositories()
	s = &SelfHostedRunnersSettingsOrganizationOpt{}
	s.GetEnabledRepositories()
	s = nil
	s.GetEnabledRepositories()
}

func TestSelfHostRunnerPermissionsEnterprise_GetDisableSelfHostedRunnersForAllOrgs(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	s := &SelfHostRunnerPermissionsEnterprise{DisableSelfHostedRunnersForAllOrgs: &zeroValue}
	s.GetDisableSelfHostedRunnersForAllOrgs()
	s = &SelfHostRunnerPermissionsEnterprise{}
	s.GetDisableSelfHostedRunnersForAllOrgs()
	s = nil
	s.GetDisableSelfHostedRunnersForAllOrgs()
}

func TestServerInstanceProperties_GetServerInstances(tt *testing.T) {
	tt.Parallel()
	s := &ServerInstanceProperties{}
	s.GetServerInstances()
	s = nil
	s.GetServerInstances()
}

func TestServerInstances_GetItems(tt *testing.T) {
	tt.Parallel()
	s := &ServerInstances{}
	s.GetItems()
	s = nil
	s.GetItems()
}

func TestServerInstances_GetType(tt *testing.T) {
	tt.Parallel()
	s := &ServerInstances{}
	s.GetType()
	s = nil
	s.GetType()
}

func TestServerItemProperties_GetHostname(tt *testing.T) {
	tt.Parallel()
	s := &ServerItemProperties{}
	s.GetHostname()
	s = nil
	s.GetHostname()
}

func TestServerItemProperties_GetLastSync(tt *testing.T) {
	tt.Parallel()
	s := &ServerItemProperties{}
	s.GetLastSync()
	s = nil
	s.GetLastSync()
}

func TestServerItemProperties_GetServerID(tt *testing.T) {
	tt.Parallel()
	s := &ServerItemProperties{}
	s.GetServerID()
	s = nil
	s.GetServerID()
}

func TestServiceInstanceItems_GetProperties(tt *testing.T) {
	tt.Parallel()
	s := &ServiceInstanceItems{}
	s.GetProperties()
	s = nil
	s.GetProperties()
}

func TestServiceInstanceItems_GetType(tt *testing.T) {
	tt.Parallel()
	s := &ServiceInstanceItems{}
	s.GetType()
	s = nil
	s.GetType()
}

func TestSetOrgAccessRunnerGroupRequest_GetSelectedOrganizationIDs(tt *testing.T) {
	tt.Parallel()
	zeroValue := []int64{}
	s := &SetOrgAccessRunnerGroupRequest{SelectedOrganizationIDs: zeroValue}
	s.GetSelectedOrganizationIDs()
	s = &SetOrgAccessRunnerGroupRequest{}
	s.GetSelectedOrganizationIDs()
	s = nil
	s.GetSelectedOrganizationIDs()
}

func TestSetRepoAccessRunnerGroupRequest_GetSelectedRepositoryIDs(tt *testing.T) {
	tt.Parallel()
	zeroValue := []int64{}
	s := &SetRepoAccessRunnerGroupRequest{SelectedRepositoryIDs: zeroValue}
	s.GetSelectedRepositoryIDs()
	s = &SetRepoAccessRunnerGroupRequest{}
	s.GetSelectedRepositoryIDs()
	s = nil
	s.GetSelectedRepositoryIDs()
}

func TestSetRunnerGroupRunnersRequest_GetRunners(tt *testing.T) {
	tt.Parallel()
	zeroValue := []int64{}
	s := &SetRunnerGroupRunnersRequest{Runners: zeroValue}
	s.GetRunners()
	s = &SetRunnerGroupRunnersRequest{}
	s.GetRunners()
	s = nil
	s.GetRunners()
}

func TestSignatureRequirementEnforcementLevelChanges_GetFrom(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SignatureRequirementEnforcementLevelChanges{From: &zeroValue}
	s.GetFrom()
	s = &SignatureRequirementEnforcementLevelChanges{}
	s.GetFrom()
	s = nil
	s.GetFrom()
}

func TestSignaturesProtectedBranch_GetEnabled(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	s := &SignaturesProtectedBranch{Enabled: &zeroValue}
	s.GetEnabled()
	s = &SignaturesProtectedBranch{}
	s.GetEnabled()
	s = nil
	s.GetEnabled()
}

func TestSignaturesProtectedBranch_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SignaturesProtectedBranch{URL: &zeroValue}
	s.GetURL()
	s = &SignaturesProtectedBranch{}
	s.GetURL()
	s = nil
	s.GetURL()
}

func TestSignatureVerification_GetPayload(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SignatureVerification{Payload: &zeroValue}
	s.GetPayload()
	s = &SignatureVerification{}
	s.GetPayload()
	s = nil
	s.GetPayload()
}

func TestSignatureVerification_GetReason(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SignatureVerification{Reason: &zeroValue}
	s.GetReason()
	s = &SignatureVerification{}
	s.GetReason()
	s = nil
	s.GetReason()
}

func TestSignatureVerification_GetSignature(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SignatureVerification{Signature: &zeroValue}
	s.GetSignature()
	s = &SignatureVerification{}
	s.GetSignature()
	s = nil
	s.GetSignature()
}

func TestSignatureVerification_GetVerified(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	s := &SignatureVerification{Verified: &zeroValue}
	s.GetVerified()
	s = &SignatureVerification{}
	s.GetVerified()
	s = nil
	s.GetVerified()
}

func TestSimplePatternRuleParameters_GetNegate(tt *testing.T) {
	tt.Parallel()
	s := &SimplePatternRuleParameters{}
	s.GetNegate()
	s = nil
	s.GetNegate()
}

func TestSimplePatternRuleParameters_GetPattern(tt *testing.T) {
	tt.Parallel()
	s := &SimplePatternRuleParameters{}
	s.GetPattern()
	s = nil
	s.GetPattern()
}

func TestSocialAccount_GetProvider(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SocialAccount{Provider: &zeroValue}
	s.GetProvider()
	s = &SocialAccount{}
	s.GetProvider()
	s = nil
	s.GetProvider()
}

func TestSocialAccount_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SocialAccount{URL: &zeroValue}
	s.GetURL()
	s = &SocialAccount{}
	s.GetURL()
	s = nil
	s.GetURL()
}

func TestSource_GetActor(tt *testing.T) {
	tt.Parallel()
	s := &Source{}
	s.GetActor()
	s = nil
	s.GetActor()
}

func TestSource_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	s := &Source{ID: &zeroValue}
	s.GetID()
	s = &Source{}
	s.GetID()
	s = nil
	s.GetID()
}

func TestSource_GetIssue(tt *testing.T) {
	tt.Parallel()
	s := &Source{}
	s.GetIssue()
	s = nil
	s.GetIssue()
}

func TestSource_GetType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &Source{Type: &zeroValue}
	s.GetType()
	s = &Source{}
	s.GetType()
	s = nil
	s.GetType()
}

func TestSource_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &Source{URL: &zeroValue}
	s.GetURL()
	s = &Source{}
	s.GetURL()
	s = nil
	s.GetURL()
}

func TestSourceImportAuthor_GetEmail(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SourceImportAuthor{Email: &zeroValue}
	s.GetEmail()
	s = &SourceImportAuthor{}
	s.GetEmail()
	s = nil
	s.GetEmail()
}

func TestSourceImportAuthor_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	s := &SourceImportAuthor{ID: &zeroValue}
	s.GetID()
	s = &SourceImportAuthor{}
	s.GetID()
	s = nil
	s.GetID()
}

func TestSourceImportAuthor_GetImportURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SourceImportAuthor{ImportURL: &zeroValue}
	s.GetImportURL()
	s = &SourceImportAuthor{}
	s.GetImportURL()
	s = nil
	s.GetImportURL()
}

func TestSourceImportAuthor_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SourceImportAuthor{Name: &zeroValue}
	s.GetName()
	s = &SourceImportAuthor{}
	s.GetName()
	s = nil
	s.GetName()
}

func TestSourceImportAuthor_GetRemoteID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SourceImportAuthor{RemoteID: &zeroValue}
	s.GetRemoteID()
	s = &SourceImportAuthor{}
	s.GetRemoteID()
	s = nil
	s.GetRemoteID()
}

func TestSourceImportAuthor_GetRemoteName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SourceImportAuthor{RemoteName: &zeroValue}
	s.GetRemoteName()
	s = &SourceImportAuthor{}
	s.GetRemoteName()
	s = nil
	s.GetRemoteName()
}

func TestSourceImportAuthor_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SourceImportAuthor{URL: &zeroValue}
	s.GetURL()
	s = &SourceImportAuthor{}
	s.GetURL()
	s = nil
	s.GetURL()
}

func TestSplunkConfig_GetDomain(tt *testing.T) {
	tt.Parallel()
	s := &SplunkConfig{}
	s.GetDomain()
	s = nil
	s.GetDomain()
}

func TestSplunkConfig_GetEncryptedToken(tt *testing.T) {
	tt.Parallel()
	s := &SplunkConfig{}
	s.GetEncryptedToken()
	s = nil
	s.GetEncryptedToken()
}

func TestSplunkConfig_GetKeyID(tt *testing.T) {
	tt.Parallel()
	s := &SplunkConfig{}
	s.GetKeyID()
	s = nil
	s.GetKeyID()
}

func TestSplunkConfig_GetPort(tt *testing.T) {
	tt.Parallel()
	s := &SplunkConfig{}
	s.GetPort()
	s = nil
	s.GetPort()
}

func TestSplunkConfig_GetSSLVerify(tt *testing.T) {
	tt.Parallel()
	s := &SplunkConfig{}
	s.GetSSLVerify()
	s = nil
	s.GetSSLVerify()
}

func TestSponsorshipChanges_GetPrivacyLevel(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SponsorshipChanges{PrivacyLevel: &zeroValue}
	s.GetPrivacyLevel()
	s = &SponsorshipChanges{}
	s.GetPrivacyLevel()
	s = nil
	s.GetPrivacyLevel()
}

func TestSponsorshipChanges_GetTier(tt *testing.T) {
	tt.Parallel()
	s := &SponsorshipChanges{}
	s.GetTier()
	s = nil
	s.GetTier()
}

func TestSponsorshipEvent_GetAction(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SponsorshipEvent{Action: &zeroValue}
	s.GetAction()
	s = &SponsorshipEvent{}
	s.GetAction()
	s = nil
	s.GetAction()
}

func TestSponsorshipEvent_GetChanges(tt *testing.T) {
	tt.Parallel()
	s := &SponsorshipEvent{}
	s.GetChanges()
	s = nil
	s.GetChanges()
}

func TestSponsorshipEvent_GetEffectiveDate(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SponsorshipEvent{EffectiveDate: &zeroValue}
	s.GetEffectiveDate()
	s = &SponsorshipEvent{}
	s.GetEffectiveDate()
	s = nil
	s.GetEffectiveDate()
}

func TestSponsorshipEvent_GetInstallation(tt *testing.T) {
	tt.Parallel()
	s := &SponsorshipEvent{}
	s.GetInstallation()
	s = nil
	s.GetInstallation()
}

func TestSponsorshipEvent_GetOrganization(tt *testing.T) {
	tt.Parallel()
	s := &SponsorshipEvent{}
	s.GetOrganization()
	s = nil
	s.GetOrganization()
}

func TestSponsorshipEvent_GetRepository(tt *testing.T) {
	tt.Parallel()
	s := &SponsorshipEvent{}
	s.GetRepository()
	s = nil
	s.GetRepository()
}

func TestSponsorshipEvent_GetSender(tt *testing.T) {
	tt.Parallel()
	s := &SponsorshipEvent{}
	s.GetSender()
	s = nil
	s.GetSender()
}

func TestSponsorshipTier_GetFrom(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SponsorshipTier{From: &zeroValue}
	s.GetFrom()
	s = &SponsorshipTier{}
	s.GetFrom()
	s = nil
	s.GetFrom()
}

func TestSSHKeyOptions_GetKey(tt *testing.T) {
	tt.Parallel()
	s := &SSHKeyOptions{}
	s.GetKey()
	s = nil
	s.GetKey()
}

func TestSSHKeyStatus_GetHostname(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SSHKeyStatus{Hostname: &zeroValue}
	s.GetHostname()
	s = &SSHKeyStatus{}
	s.GetHostname()
	s = nil
	s.GetHostname()
}

func TestSSHKeyStatus_GetMessage(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SSHKeyStatus{Message: &zeroValue}
	s.GetMessage()
	s = &SSHKeyStatus{}
	s.GetMessage()
	s = nil
	s.GetMessage()
}

func TestSSHKeyStatus_GetModified(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	s := &SSHKeyStatus{Modified: &zeroValue}
	s.GetModified()
	s = &SSHKeyStatus{}
	s.GetModified()
	s = nil
	s.GetModified()
}

func TestSSHKeyStatus_GetUUID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SSHKeyStatus{UUID: &zeroValue}
	s.GetUUID()
	s = &SSHKeyStatus{}
	s.GetUUID()
	s = nil
	s.GetUUID()
}

func TestSSHSigningKey_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	s := &SSHSigningKey{CreatedAt: &zeroValue}
	s.GetCreatedAt()
	s = &SSHSigningKey{}
	s.GetCreatedAt()
	s = nil
	s.GetCreatedAt()
}

func TestSSHSigningKey_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	s := &SSHSigningKey{ID: &zeroValue}
	s.GetID()
	s = &SSHSigningKey{}
	s.GetID()
	s = nil
	s.GetID()
}

func TestSSHSigningKey_GetKey(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SSHSigningKey{Key: &zeroValue}
	s.GetKey()
	s = &SSHSigningKey{}
	s.GetKey()
	s = nil
	s.GetKey()
}

func TestSSHSigningKey_GetTitle(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SSHSigningKey{Title: &zeroValue}
	s.GetTitle()
	s = &SSHSigningKey{}
	s.GetTitle()
	s = nil
	s.GetTitle()
}

func TestStarEvent_GetAction(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &StarEvent{Action: &zeroValue}
	s.GetAction()
	s = &StarEvent{}
	s.GetAction()
	s = nil
	s.GetAction()
}

func TestStarEvent_GetInstallation(tt *testing.T) {
	tt.Parallel()
	s := &StarEvent{}
	s.GetInstallation()
	s = nil
	s.GetInstallation()
}

func TestStarEvent_GetOrg(tt *testing.T) {
	tt.Parallel()
	s := &StarEvent{}
	s.GetOrg()
	s = nil
	s.GetOrg()
}

func TestStarEvent_GetRepo(tt *testing.T) {
	tt.Parallel()
	s := &StarEvent{}
	s.GetRepo()
	s = nil
	s.GetRepo()
}

func TestStarEvent_GetSender(tt *testing.T) {
	tt.Parallel()
	s := &StarEvent{}
	s.GetSender()
	s = nil
	s.GetSender()
}

func TestStarEvent_GetStarredAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	s := &StarEvent{StarredAt: &zeroValue}
	s.GetStarredAt()
	s = &StarEvent{}
	s.GetStarredAt()
	s = nil
	s.GetStarredAt()
}

func TestStargazer_GetStarredAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	s := &Stargazer{StarredAt: &zeroValue}
	s.GetStarredAt()
	s = &Stargazer{}
	s.GetStarredAt()
	s = nil
	s.GetStarredAt()
}

func TestStargazer_GetUser(tt *testing.T) {
	tt.Parallel()
	s := &Stargazer{}
	s.GetUser()
	s = nil
	s.GetUser()
}

func TestStarredRepository_GetRepository(tt *testing.T) {
	tt.Parallel()
	s := &StarredRepository{}
	s.GetRepository()
	s = nil
	s.GetRepository()
}

func TestStarredRepository_GetStarredAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	s := &StarredRepository{StarredAt: &zeroValue}
	s.GetStarredAt()
	s = &StarredRepository{}
	s.GetStarredAt()
	s = nil
	s.GetStarredAt()
}

func TestStatusEvent_GetBranches(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*Branch{}
	s := &StatusEvent{Branches: zeroValue}
	s.GetBranches()
	s = &StatusEvent{}
	s.GetBranches()
	s = nil
	s.GetBranches()
}

func TestStatusEvent_GetCommit(tt *testing.T) {
	tt.Parallel()
	s := &StatusEvent{}
	s.GetCommit()
	s = nil
	s.GetCommit()
}

func TestStatusEvent_GetContext(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &StatusEvent{Context: &zeroValue}
	s.GetContext()
	s = &StatusEvent{}
	s.GetContext()
	s = nil
	s.GetContext()
}

func TestStatusEvent_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	s := &StatusEvent{CreatedAt: &zeroValue}
	s.GetCreatedAt()
	s = &StatusEvent{}
	s.GetCreatedAt()
	s = nil
	s.GetCreatedAt()
}

func TestStatusEvent_GetDescription(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &StatusEvent{Description: &zeroValue}
	s.GetDescription()
	s = &StatusEvent{}
	s.GetDescription()
	s = nil
	s.GetDescription()
}

func TestStatusEvent_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	s := &StatusEvent{ID: &zeroValue}
	s.GetID()
	s = &StatusEvent{}
	s.GetID()
	s = nil
	s.GetID()
}

func TestStatusEvent_GetInstallation(tt *testing.T) {
	tt.Parallel()
	s := &StatusEvent{}
	s.GetInstallation()
	s = nil
	s.GetInstallation()
}

func TestStatusEvent_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &StatusEvent{Name: &zeroValue}
	s.GetName()
	s = &StatusEvent{}
	s.GetName()
	s = nil
	s.GetName()
}

func TestStatusEvent_GetOrg(tt *testing.T) {
	tt.Parallel()
	s := &StatusEvent{}
	s.GetOrg()
	s = nil
	s.GetOrg()
}

func TestStatusEvent_GetRepo(tt *testing.T) {
	tt.Parallel()
	s := &StatusEvent{}
	s.GetRepo()
	s = nil
	s.GetRepo()
}

func TestStatusEvent_GetSender(tt *testing.T) {
	tt.Parallel()
	s := &StatusEvent{}
	s.GetSender()
	s = nil
	s.GetSender()
}

func TestStatusEvent_GetSHA(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &StatusEvent{SHA: &zeroValue}
	s.GetSHA()
	s = &StatusEvent{}
	s.GetSHA()
	s = nil
	s.GetSHA()
}

func TestStatusEvent_GetState(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &StatusEvent{State: &zeroValue}
	s.GetState()
	s = &StatusEvent{}
	s.GetState()
	s = nil
	s.GetState()
}

func TestStatusEvent_GetTargetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &StatusEvent{TargetURL: &zeroValue}
	s.GetTargetURL()
	s = &StatusEvent{}
	s.GetTargetURL()
	s = nil
	s.GetTargetURL()
}

func TestStatusEvent_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	s := &StatusEvent{UpdatedAt: &zeroValue}
	s.GetUpdatedAt()
	s = &StatusEvent{}
	s.GetUpdatedAt()
	s = nil
	s.GetUpdatedAt()
}

func TestStorageBilling_GetDaysLeftInBillingCycle(tt *testing.T) {
	tt.Parallel()
	s := &StorageBilling{}
	s.GetDaysLeftInBillingCycle()
	s = nil
	s.GetDaysLeftInBillingCycle()
}

func TestStorageBilling_GetEstimatedPaidStorageForMonth(tt *testing.T) {
	tt.Parallel()
	s := &StorageBilling{}
	s.GetEstimatedPaidStorageForMonth()
	s = nil
	s.GetEstimatedPaidStorageForMonth()
}

func TestStorageBilling_GetEstimatedStorageForMonth(tt *testing.T) {
	tt.Parallel()
	s := &StorageBilling{}
	s.GetEstimatedStorageForMonth()
	s = nil
	s.GetEstimatedStorageForMonth()
}

func TestSubIssueRequest_GetAfterID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	s := &SubIssueRequest{AfterID: &zeroValue}
	s.GetAfterID()
	s = &SubIssueRequest{}
	s.GetAfterID()
	s = nil
	s.GetAfterID()
}

func TestSubIssueRequest_GetBeforeID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	s := &SubIssueRequest{BeforeID: &zeroValue}
	s.GetBeforeID()
	s = &SubIssueRequest{}
	s.GetBeforeID()
	s = nil
	s.GetBeforeID()
}

func TestSubIssueRequest_GetReplaceParent(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	s := &SubIssueRequest{ReplaceParent: &zeroValue}
	s.GetReplaceParent()
	s = &SubIssueRequest{}
	s.GetReplaceParent()
	s = nil
	s.GetReplaceParent()
}

func TestSubIssueRequest_GetSubIssueID(tt *testing.T) {
	tt.Parallel()
	s := &SubIssueRequest{}
	s.GetSubIssueID()
	s = nil
	s.GetSubIssueID()
}

func TestSubIssuesSummary_GetCompleted(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	s := &SubIssuesSummary{Completed: &zeroValue}
	s.GetCompleted()
	s = &SubIssuesSummary{}
	s.GetCompleted()
	s = nil
	s.GetCompleted()
}

func TestSubIssuesSummary_GetPercentCompleted(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	s := &SubIssuesSummary{PercentCompleted: &zeroValue}
	s.GetPercentCompleted()
	s = &SubIssuesSummary{}
	s.GetPercentCompleted()
	s = nil
	s.GetPercentCompleted()
}

func TestSubIssuesSummary_GetTotal(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	s := &SubIssuesSummary{Total: &zeroValue}
	s.GetTotal()
	s = &SubIssuesSummary{}
	s.GetTotal()
	s = nil
	s.GetTotal()
}

func TestSubscription_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	s := &Subscription{CreatedAt: &zeroValue}
	s.GetCreatedAt()
	s = &Subscription{}
	s.GetCreatedAt()
	s = nil
	s.GetCreatedAt()
}

func TestSubscription_GetIgnored(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	s := &Subscription{Ignored: &zeroValue}
	s.GetIgnored()
	s = &Subscription{}
	s.GetIgnored()
	s = nil
	s.GetIgnored()
}

func TestSubscription_GetReason(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &Subscription{Reason: &zeroValue}
	s.GetReason()
	s = &Subscription{}
	s.GetReason()
	s = nil
	s.GetReason()
}

func TestSubscription_GetRepositoryURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &Subscription{RepositoryURL: &zeroValue}
	s.GetRepositoryURL()
	s = &Subscription{}
	s.GetRepositoryURL()
	s = nil
	s.GetRepositoryURL()
}

func TestSubscription_GetSubscribed(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	s := &Subscription{Subscribed: &zeroValue}
	s.GetSubscribed()
	s = &Subscription{}
	s.GetSubscribed()
	s = nil
	s.GetSubscribed()
}

func TestSubscription_GetThreadURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &Subscription{ThreadURL: &zeroValue}
	s.GetThreadURL()
	s = &Subscription{}
	s.GetThreadURL()
	s = nil
	s.GetThreadURL()
}

func TestSubscription_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &Subscription{URL: &zeroValue}
	s.GetURL()
	s = &Subscription{}
	s.GetURL()
	s = nil
	s.GetURL()
}

func TestSystemRequirements_GetNodes(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*SystemRequirementsNode{}
	s := &SystemRequirements{Nodes: zeroValue}
	s.GetNodes()
	s = &SystemRequirements{}
	s.GetNodes()
	s = nil
	s.GetNodes()
}

func TestSystemRequirements_GetStatus(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SystemRequirements{Status: &zeroValue}
	s.GetStatus()
	s = &SystemRequirements{}
	s.GetStatus()
	s = nil
	s.GetStatus()
}

func TestSystemRequirementsNode_GetHostname(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SystemRequirementsNode{Hostname: &zeroValue}
	s.GetHostname()
	s = &SystemRequirementsNode{}
	s.GetHostname()
	s = nil
	s.GetHostname()
}

func TestSystemRequirementsNode_GetRolesStatus(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*SystemRequirementsNodeRoleStatus{}
	s := &SystemRequirementsNode{RolesStatus: zeroValue}
	s.GetRolesStatus()
	s = &SystemRequirementsNode{}
	s.GetRolesStatus()
	s = nil
	s.GetRolesStatus()
}

func TestSystemRequirementsNode_GetStatus(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SystemRequirementsNode{Status: &zeroValue}
	s.GetStatus()
	s = &SystemRequirementsNode{}
	s.GetStatus()
	s = nil
	s.GetStatus()
}

func TestSystemRequirementsNodeRoleStatus_GetRole(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SystemRequirementsNodeRoleStatus{Role: &zeroValue}
	s.GetRole()
	s = &SystemRequirementsNodeRoleStatus{}
	s.GetRole()
	s = nil
	s.GetRole()
}

func TestSystemRequirementsNodeRoleStatus_GetStatus(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	s := &SystemRequirementsNodeRoleStatus{Status: &zeroValue}
	s.GetStatus()
	s = &SystemRequirementsNodeRoleStatus{}
	s.GetStatus()
	s = nil
	s.GetStatus()
}

func TestTag_GetMessage(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &Tag{Message: &zeroValue}
	t.GetMessage()
	t = &Tag{}
	t.GetMessage()
	t = nil
	t.GetMessage()
}

func TestTag_GetNodeID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &Tag{NodeID: &zeroValue}
	t.GetNodeID()
	t = &Tag{}
	t.GetNodeID()
	t = nil
	t.GetNodeID()
}

func TestTag_GetObject(tt *testing.T) {
	tt.Parallel()
	t := &Tag{}
	t.GetObject()
	t = nil
	t.GetObject()
}

func TestTag_GetSHA(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &Tag{SHA: &zeroValue}
	t.GetSHA()
	t = &Tag{}
	t.GetSHA()
	t = nil
	t.GetSHA()
}

func TestTag_GetTag(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &Tag{Tag: &zeroValue}
	t.GetTag()
	t = &Tag{}
	t.GetTag()
	t = nil
	t.GetTag()
}

func TestTag_GetTagger(tt *testing.T) {
	tt.Parallel()
	t := &Tag{}
	t.GetTagger()
	t = nil
	t.GetTagger()
}

func TestTag_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &Tag{URL: &zeroValue}
	t.GetURL()
	t = &Tag{}
	t.GetURL()
	t = nil
	t.GetURL()
}

func TestTag_GetVerification(tt *testing.T) {
	tt.Parallel()
	t := &Tag{}
	t.GetVerification()
	t = nil
	t.GetVerification()
}

func TestTagProtection_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	t := &TagProtection{ID: &zeroValue}
	t.GetID()
	t = &TagProtection{}
	t.GetID()
	t = nil
	t.GetID()
}

func TestTagProtection_GetPattern(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &TagProtection{Pattern: &zeroValue}
	t.GetPattern()
	t = &TagProtection{}
	t.GetPattern()
	t = nil
	t.GetPattern()
}

func TestTaskStep_GetCompletedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	t := &TaskStep{CompletedAt: &zeroValue}
	t.GetCompletedAt()
	t = &TaskStep{}
	t.GetCompletedAt()
	t = nil
	t.GetCompletedAt()
}

func TestTaskStep_GetConclusion(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &TaskStep{Conclusion: &zeroValue}
	t.GetConclusion()
	t = &TaskStep{}
	t.GetConclusion()
	t = nil
	t.GetConclusion()
}

func TestTaskStep_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &TaskStep{Name: &zeroValue}
	t.GetName()
	t = &TaskStep{}
	t.GetName()
	t = nil
	t.GetName()
}

func TestTaskStep_GetNumber(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	t := &TaskStep{Number: &zeroValue}
	t.GetNumber()
	t = &TaskStep{}
	t.GetNumber()
	t = nil
	t.GetNumber()
}

func TestTaskStep_GetStartedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	t := &TaskStep{StartedAt: &zeroValue}
	t.GetStartedAt()
	t = &TaskStep{}
	t.GetStartedAt()
	t = nil
	t.GetStartedAt()
}

func TestTaskStep_GetStatus(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &TaskStep{Status: &zeroValue}
	t.GetStatus()
	t = &TaskStep{}
	t.GetStatus()
	t = nil
	t.GetStatus()
}

func TestTeam_GetAccessSource(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &Team{AccessSource: &zeroValue}
	t.GetAccessSource()
	t = &Team{}
	t.GetAccessSource()
	t = nil
	t.GetAccessSource()
}

func TestTeam_GetAssignment(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &Team{Assignment: &zeroValue}
	t.GetAssignment()
	t = &Team{}
	t.GetAssignment()
	t = nil
	t.GetAssignment()
}

func TestTeam_GetDescription(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &Team{Description: &zeroValue}
	t.GetDescription()
	t = &Team{}
	t.GetDescription()
	t = nil
	t.GetDescription()
}

func TestTeam_GetHTMLURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &Team{HTMLURL: &zeroValue}
	t.GetHTMLURL()
	t = &Team{}
	t.GetHTMLURL()
	t = nil
	t.GetHTMLURL()
}

func TestTeam_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	t := &Team{ID: &zeroValue}
	t.GetID()
	t = &Team{}
	t.GetID()
	t = nil
	t.GetID()
}

func TestTeam_GetLDAPDN(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &Team{LDAPDN: &zeroValue}
	t.GetLDAPDN()
	t = &Team{}
	t.GetLDAPDN()
	t = nil
	t.GetLDAPDN()
}

func TestTeam_GetMembersCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	t := &Team{MembersCount: &zeroValue}
	t.GetMembersCount()
	t = &Team{}
	t.GetMembersCount()
	t = nil
	t.GetMembersCount()
}

func TestTeam_GetMembersURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &Team{MembersURL: &zeroValue}
	t.GetMembersURL()
	t = &Team{}
	t.GetMembersURL()
	t = nil
	t.GetMembersURL()
}

func TestTeam_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &Team{Name: &zeroValue}
	t.GetName()
	t = &Team{}
	t.GetName()
	t = nil
	t.GetName()
}

func TestTeam_GetNodeID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &Team{NodeID: &zeroValue}
	t.GetNodeID()
	t = &Team{}
	t.GetNodeID()
	t = nil
	t.GetNodeID()
}

func TestTeam_GetNotificationSetting(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &Team{NotificationSetting: &zeroValue}
	t.GetNotificationSetting()
	t = &Team{}
	t.GetNotificationSetting()
	t = nil
	t.GetNotificationSetting()
}

func TestTeam_GetOrganization(tt *testing.T) {
	tt.Parallel()
	t := &Team{}
	t.GetOrganization()
	t = nil
	t.GetOrganization()
}

func TestTeam_GetParent(tt *testing.T) {
	tt.Parallel()
	t := &Team{}
	t.GetParent()
	t = nil
	t.GetParent()
}

func TestTeam_GetPermission(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &Team{Permission: &zeroValue}
	t.GetPermission()
	t = &Team{}
	t.GetPermission()
	t = nil
	t.GetPermission()
}

func TestTeam_GetPermissions(tt *testing.T) {
	tt.Parallel()
	zeroValue := map[string]bool{}
	t := &Team{Permissions: zeroValue}
	t.GetPermissions()
	t = &Team{}
	t.GetPermissions()
	t = nil
	t.GetPermissions()
}

func TestTeam_GetPrivacy(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &Team{Privacy: &zeroValue}
	t.GetPrivacy()
	t = &Team{}
	t.GetPrivacy()
	t = nil
	t.GetPrivacy()
}

func TestTeam_GetReposCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	t := &Team{ReposCount: &zeroValue}
	t.GetReposCount()
	t = &Team{}
	t.GetReposCount()
	t = nil
	t.GetReposCount()
}

func TestTeam_GetRepositoriesURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &Team{RepositoriesURL: &zeroValue}
	t.GetRepositoriesURL()
	t = &Team{}
	t.GetRepositoriesURL()
	t = nil
	t.GetRepositoriesURL()
}

func TestTeam_GetSlug(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &Team{Slug: &zeroValue}
	t.GetSlug()
	t = &Team{}
	t.GetSlug()
	t = nil
	t.GetSlug()
}

func TestTeam_GetType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &Team{Type: &zeroValue}
	t.GetType()
	t = &Team{}
	t.GetType()
	t = nil
	t.GetType()
}

func TestTeam_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &Team{URL: &zeroValue}
	t.GetURL()
	t = &Team{}
	t.GetURL()
	t = nil
	t.GetURL()
}

func TestTeamAddEvent_GetInstallation(tt *testing.T) {
	tt.Parallel()
	t := &TeamAddEvent{}
	t.GetInstallation()
	t = nil
	t.GetInstallation()
}

func TestTeamAddEvent_GetOrg(tt *testing.T) {
	tt.Parallel()
	t := &TeamAddEvent{}
	t.GetOrg()
	t = nil
	t.GetOrg()
}

func TestTeamAddEvent_GetRepo(tt *testing.T) {
	tt.Parallel()
	t := &TeamAddEvent{}
	t.GetRepo()
	t = nil
	t.GetRepo()
}

func TestTeamAddEvent_GetSender(tt *testing.T) {
	tt.Parallel()
	t := &TeamAddEvent{}
	t.GetSender()
	t = nil
	t.GetSender()
}

func TestTeamAddEvent_GetTeam(tt *testing.T) {
	tt.Parallel()
	t := &TeamAddEvent{}
	t.GetTeam()
	t = nil
	t.GetTeam()
}

func TestTeamAddTeamMembershipOptions_GetRole(tt *testing.T) {
	tt.Parallel()
	t := &TeamAddTeamMembershipOptions{}
	t.GetRole()
	t = nil
	t.GetRole()
}

func TestTeamAddTeamRepoOptions_GetPermission(tt *testing.T) {
	tt.Parallel()
	t := &TeamAddTeamRepoOptions{}
	t.GetPermission()
	t = nil
	t.GetPermission()
}

func TestTeamChange_GetDescription(tt *testing.T) {
	tt.Parallel()
	t := &TeamChange{}
	t.GetDescription()
	t = nil
	t.GetDescription()
}

func TestTeamChange_GetName(tt *testing.T) {
	tt.Parallel()
	t := &TeamChange{}
	t.GetName()
	t = nil
	t.GetName()
}

func TestTeamChange_GetPrivacy(tt *testing.T) {
	tt.Parallel()
	t := &TeamChange{}
	t.GetPrivacy()
	t = nil
	t.GetPrivacy()
}

func TestTeamChange_GetRepository(tt *testing.T) {
	tt.Parallel()
	t := &TeamChange{}
	t.GetRepository()
	t = nil
	t.GetRepository()
}

func TestTeamDescription_GetFrom(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &TeamDescription{From: &zeroValue}
	t.GetFrom()
	t = &TeamDescription{}
	t.GetFrom()
	t = nil
	t.GetFrom()
}

func TestTeamDiscussion_GetAuthor(tt *testing.T) {
	tt.Parallel()
	t := &TeamDiscussion{}
	t.GetAuthor()
	t = nil
	t.GetAuthor()
}

func TestTeamDiscussion_GetBody(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &TeamDiscussion{Body: &zeroValue}
	t.GetBody()
	t = &TeamDiscussion{}
	t.GetBody()
	t = nil
	t.GetBody()
}

func TestTeamDiscussion_GetBodyHTML(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &TeamDiscussion{BodyHTML: &zeroValue}
	t.GetBodyHTML()
	t = &TeamDiscussion{}
	t.GetBodyHTML()
	t = nil
	t.GetBodyHTML()
}

func TestTeamDiscussion_GetBodyVersion(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &TeamDiscussion{BodyVersion: &zeroValue}
	t.GetBodyVersion()
	t = &TeamDiscussion{}
	t.GetBodyVersion()
	t = nil
	t.GetBodyVersion()
}

func TestTeamDiscussion_GetCommentsCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	t := &TeamDiscussion{CommentsCount: &zeroValue}
	t.GetCommentsCount()
	t = &TeamDiscussion{}
	t.GetCommentsCount()
	t = nil
	t.GetCommentsCount()
}

func TestTeamDiscussion_GetCommentsURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &TeamDiscussion{CommentsURL: &zeroValue}
	t.GetCommentsURL()
	t = &TeamDiscussion{}
	t.GetCommentsURL()
	t = nil
	t.GetCommentsURL()
}

func TestTeamDiscussion_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	t := &TeamDiscussion{CreatedAt: &zeroValue}
	t.GetCreatedAt()
	t = &TeamDiscussion{}
	t.GetCreatedAt()
	t = nil
	t.GetCreatedAt()
}

func TestTeamDiscussion_GetHTMLURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &TeamDiscussion{HTMLURL: &zeroValue}
	t.GetHTMLURL()
	t = &TeamDiscussion{}
	t.GetHTMLURL()
	t = nil
	t.GetHTMLURL()
}

func TestTeamDiscussion_GetLastEditedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	t := &TeamDiscussion{LastEditedAt: &zeroValue}
	t.GetLastEditedAt()
	t = &TeamDiscussion{}
	t.GetLastEditedAt()
	t = nil
	t.GetLastEditedAt()
}

func TestTeamDiscussion_GetNodeID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &TeamDiscussion{NodeID: &zeroValue}
	t.GetNodeID()
	t = &TeamDiscussion{}
	t.GetNodeID()
	t = nil
	t.GetNodeID()
}

func TestTeamDiscussion_GetNumber(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	t := &TeamDiscussion{Number: &zeroValue}
	t.GetNumber()
	t = &TeamDiscussion{}
	t.GetNumber()
	t = nil
	t.GetNumber()
}

func TestTeamDiscussion_GetPinned(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	t := &TeamDiscussion{Pinned: &zeroValue}
	t.GetPinned()
	t = &TeamDiscussion{}
	t.GetPinned()
	t = nil
	t.GetPinned()
}

func TestTeamDiscussion_GetPrivate(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	t := &TeamDiscussion{Private: &zeroValue}
	t.GetPrivate()
	t = &TeamDiscussion{}
	t.GetPrivate()
	t = nil
	t.GetPrivate()
}

func TestTeamDiscussion_GetReactions(tt *testing.T) {
	tt.Parallel()
	t := &TeamDiscussion{}
	t.GetReactions()
	t = nil
	t.GetReactions()
}

func TestTeamDiscussion_GetTeamURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &TeamDiscussion{TeamURL: &zeroValue}
	t.GetTeamURL()
	t = &TeamDiscussion{}
	t.GetTeamURL()
	t = nil
	t.GetTeamURL()
}

func TestTeamDiscussion_GetTitle(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &TeamDiscussion{Title: &zeroValue}
	t.GetTitle()
	t = &TeamDiscussion{}
	t.GetTitle()
	t = nil
	t.GetTitle()
}

func TestTeamDiscussion_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	t := &TeamDiscussion{UpdatedAt: &zeroValue}
	t.GetUpdatedAt()
	t = &TeamDiscussion{}
	t.GetUpdatedAt()
	t = nil
	t.GetUpdatedAt()
}

func TestTeamDiscussion_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &TeamDiscussion{URL: &zeroValue}
	t.GetURL()
	t = &TeamDiscussion{}
	t.GetURL()
	t = nil
	t.GetURL()
}

func TestTeamEvent_GetAction(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &TeamEvent{Action: &zeroValue}
	t.GetAction()
	t = &TeamEvent{}
	t.GetAction()
	t = nil
	t.GetAction()
}

func TestTeamEvent_GetChanges(tt *testing.T) {
	tt.Parallel()
	t := &TeamEvent{}
	t.GetChanges()
	t = nil
	t.GetChanges()
}

func TestTeamEvent_GetInstallation(tt *testing.T) {
	tt.Parallel()
	t := &TeamEvent{}
	t.GetInstallation()
	t = nil
	t.GetInstallation()
}

func TestTeamEvent_GetOrg(tt *testing.T) {
	tt.Parallel()
	t := &TeamEvent{}
	t.GetOrg()
	t = nil
	t.GetOrg()
}

func TestTeamEvent_GetRepo(tt *testing.T) {
	tt.Parallel()
	t := &TeamEvent{}
	t.GetRepo()
	t = nil
	t.GetRepo()
}

func TestTeamEvent_GetSender(tt *testing.T) {
	tt.Parallel()
	t := &TeamEvent{}
	t.GetSender()
	t = nil
	t.GetSender()
}

func TestTeamEvent_GetTeam(tt *testing.T) {
	tt.Parallel()
	t := &TeamEvent{}
	t.GetTeam()
	t = nil
	t.GetTeam()
}

func TestTeamLDAPMapping_GetDescription(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &TeamLDAPMapping{Description: &zeroValue}
	t.GetDescription()
	t = &TeamLDAPMapping{}
	t.GetDescription()
	t = nil
	t.GetDescription()
}

func TestTeamLDAPMapping_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	t := &TeamLDAPMapping{ID: &zeroValue}
	t.GetID()
	t = &TeamLDAPMapping{}
	t.GetID()
	t = nil
	t.GetID()
}

func TestTeamLDAPMapping_GetLDAPDN(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &TeamLDAPMapping{LDAPDN: &zeroValue}
	t.GetLDAPDN()
	t = &TeamLDAPMapping{}
	t.GetLDAPDN()
	t = nil
	t.GetLDAPDN()
}

func TestTeamLDAPMapping_GetMembersURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &TeamLDAPMapping{MembersURL: &zeroValue}
	t.GetMembersURL()
	t = &TeamLDAPMapping{}
	t.GetMembersURL()
	t = nil
	t.GetMembersURL()
}

func TestTeamLDAPMapping_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &TeamLDAPMapping{Name: &zeroValue}
	t.GetName()
	t = &TeamLDAPMapping{}
	t.GetName()
	t = nil
	t.GetName()
}

func TestTeamLDAPMapping_GetPermission(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &TeamLDAPMapping{Permission: &zeroValue}
	t.GetPermission()
	t = &TeamLDAPMapping{}
	t.GetPermission()
	t = nil
	t.GetPermission()
}

func TestTeamLDAPMapping_GetPrivacy(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &TeamLDAPMapping{Privacy: &zeroValue}
	t.GetPrivacy()
	t = &TeamLDAPMapping{}
	t.GetPrivacy()
	t = nil
	t.GetPrivacy()
}

func TestTeamLDAPMapping_GetRepositoriesURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &TeamLDAPMapping{RepositoriesURL: &zeroValue}
	t.GetRepositoriesURL()
	t = &TeamLDAPMapping{}
	t.GetRepositoriesURL()
	t = nil
	t.GetRepositoriesURL()
}

func TestTeamLDAPMapping_GetSlug(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &TeamLDAPMapping{Slug: &zeroValue}
	t.GetSlug()
	t = &TeamLDAPMapping{}
	t.GetSlug()
	t = nil
	t.GetSlug()
}

func TestTeamLDAPMapping_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &TeamLDAPMapping{URL: &zeroValue}
	t.GetURL()
	t = &TeamLDAPMapping{}
	t.GetURL()
	t = nil
	t.GetURL()
}

func TestTeamListTeamMembersOptions_GetRole(tt *testing.T) {
	tt.Parallel()
	t := &TeamListTeamMembersOptions{}
	t.GetRole()
	t = nil
	t.GetRole()
}

func TestTeamName_GetFrom(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &TeamName{From: &zeroValue}
	t.GetFrom()
	t = &TeamName{}
	t.GetFrom()
	t = nil
	t.GetFrom()
}

func TestTeamPermissions_GetFrom(tt *testing.T) {
	tt.Parallel()
	t := &TeamPermissions{}
	t.GetFrom()
	t = nil
	t.GetFrom()
}

func TestTeamPermissionsFrom_GetAdmin(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	t := &TeamPermissionsFrom{Admin: &zeroValue}
	t.GetAdmin()
	t = &TeamPermissionsFrom{}
	t.GetAdmin()
	t = nil
	t.GetAdmin()
}

func TestTeamPermissionsFrom_GetPull(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	t := &TeamPermissionsFrom{Pull: &zeroValue}
	t.GetPull()
	t = &TeamPermissionsFrom{}
	t.GetPull()
	t = nil
	t.GetPull()
}

func TestTeamPermissionsFrom_GetPush(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	t := &TeamPermissionsFrom{Push: &zeroValue}
	t.GetPush()
	t = &TeamPermissionsFrom{}
	t.GetPush()
	t = nil
	t.GetPush()
}

func TestTeamPrivacy_GetFrom(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &TeamPrivacy{From: &zeroValue}
	t.GetFrom()
	t = &TeamPrivacy{}
	t.GetFrom()
	t = nil
	t.GetFrom()
}

func TestTeamProjectOptions_GetPermission(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &TeamProjectOptions{Permission: &zeroValue}
	t.GetPermission()
	t = &TeamProjectOptions{}
	t.GetPermission()
	t = nil
	t.GetPermission()
}

func TestTeamRepository_GetPermissions(tt *testing.T) {
	tt.Parallel()
	t := &TeamRepository{}
	t.GetPermissions()
	t = nil
	t.GetPermissions()
}

func TestTemplateRepoRequest_GetDescription(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &TemplateRepoRequest{Description: &zeroValue}
	t.GetDescription()
	t = &TemplateRepoRequest{}
	t.GetDescription()
	t = nil
	t.GetDescription()
}

func TestTemplateRepoRequest_GetIncludeAllBranches(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	t := &TemplateRepoRequest{IncludeAllBranches: &zeroValue}
	t.GetIncludeAllBranches()
	t = &TemplateRepoRequest{}
	t.GetIncludeAllBranches()
	t = nil
	t.GetIncludeAllBranches()
}

func TestTemplateRepoRequest_GetName(tt *testing.T) {
	tt.Parallel()
	t := &TemplateRepoRequest{}
	t.GetName()
	t = nil
	t.GetName()
}

func TestTemplateRepoRequest_GetOwner(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &TemplateRepoRequest{Owner: &zeroValue}
	t.GetOwner()
	t = &TemplateRepoRequest{}
	t.GetOwner()
	t = nil
	t.GetOwner()
}

func TestTemplateRepoRequest_GetPrivate(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	t := &TemplateRepoRequest{Private: &zeroValue}
	t.GetPrivate()
	t = &TemplateRepoRequest{}
	t.GetPrivate()
	t = nil
	t.GetPrivate()
}

func TestTextMatch_GetFragment(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &TextMatch{Fragment: &zeroValue}
	t.GetFragment()
	t = &TextMatch{}
	t.GetFragment()
	t = nil
	t.GetFragment()
}

func TestTextMatch_GetMatches(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*Match{}
	t := &TextMatch{Matches: zeroValue}
	t.GetMatches()
	t = &TextMatch{}
	t.GetMatches()
	t = nil
	t.GetMatches()
}

func TestTextMatch_GetObjectType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &TextMatch{ObjectType: &zeroValue}
	t.GetObjectType()
	t = &TextMatch{}
	t.GetObjectType()
	t = nil
	t.GetObjectType()
}

func TestTextMatch_GetObjectURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &TextMatch{ObjectURL: &zeroValue}
	t.GetObjectURL()
	t = &TextMatch{}
	t.GetObjectURL()
	t = nil
	t.GetObjectURL()
}

func TestTextMatch_GetProperty(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &TextMatch{Property: &zeroValue}
	t.GetProperty()
	t = &TextMatch{}
	t.GetProperty()
	t = nil
	t.GetProperty()
}

func TestTimeline_GetActor(tt *testing.T) {
	tt.Parallel()
	t := &Timeline{}
	t.GetActor()
	t = nil
	t.GetActor()
}

func TestTimeline_GetAssignee(tt *testing.T) {
	tt.Parallel()
	t := &Timeline{}
	t.GetAssignee()
	t = nil
	t.GetAssignee()
}

func TestTimeline_GetAssigner(tt *testing.T) {
	tt.Parallel()
	t := &Timeline{}
	t.GetAssigner()
	t = nil
	t.GetAssigner()
}

func TestTimeline_GetAuthor(tt *testing.T) {
	tt.Parallel()
	t := &Timeline{}
	t.GetAuthor()
	t = nil
	t.GetAuthor()
}

func TestTimeline_GetBody(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &Timeline{Body: &zeroValue}
	t.GetBody()
	t = &Timeline{}
	t.GetBody()
	t = nil
	t.GetBody()
}

func TestTimeline_GetCommitID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &Timeline{CommitID: &zeroValue}
	t.GetCommitID()
	t = &Timeline{}
	t.GetCommitID()
	t = nil
	t.GetCommitID()
}

func TestTimeline_GetCommitter(tt *testing.T) {
	tt.Parallel()
	t := &Timeline{}
	t.GetCommitter()
	t = nil
	t.GetCommitter()
}

func TestTimeline_GetCommitURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &Timeline{CommitURL: &zeroValue}
	t.GetCommitURL()
	t = &Timeline{}
	t.GetCommitURL()
	t = nil
	t.GetCommitURL()
}

func TestTimeline_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	t := &Timeline{CreatedAt: &zeroValue}
	t.GetCreatedAt()
	t = &Timeline{}
	t.GetCreatedAt()
	t = nil
	t.GetCreatedAt()
}

func TestTimeline_GetEvent(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &Timeline{Event: &zeroValue}
	t.GetEvent()
	t = &Timeline{}
	t.GetEvent()
	t = nil
	t.GetEvent()
}

func TestTimeline_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	t := &Timeline{ID: &zeroValue}
	t.GetID()
	t = &Timeline{}
	t.GetID()
	t = nil
	t.GetID()
}

func TestTimeline_GetLabel(tt *testing.T) {
	tt.Parallel()
	t := &Timeline{}
	t.GetLabel()
	t = nil
	t.GetLabel()
}

func TestTimeline_GetMessage(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &Timeline{Message: &zeroValue}
	t.GetMessage()
	t = &Timeline{}
	t.GetMessage()
	t = nil
	t.GetMessage()
}

func TestTimeline_GetMilestone(tt *testing.T) {
	tt.Parallel()
	t := &Timeline{}
	t.GetMilestone()
	t = nil
	t.GetMilestone()
}

func TestTimeline_GetParents(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*Commit{}
	t := &Timeline{Parents: zeroValue}
	t.GetParents()
	t = &Timeline{}
	t.GetParents()
	t = nil
	t.GetParents()
}

func TestTimeline_GetPerformedViaGithubApp(tt *testing.T) {
	tt.Parallel()
	t := &Timeline{}
	t.GetPerformedViaGithubApp()
	t = nil
	t.GetPerformedViaGithubApp()
}

func TestTimeline_GetRename(tt *testing.T) {
	tt.Parallel()
	t := &Timeline{}
	t.GetRename()
	t = nil
	t.GetRename()
}

func TestTimeline_GetRequestedTeam(tt *testing.T) {
	tt.Parallel()
	t := &Timeline{}
	t.GetRequestedTeam()
	t = nil
	t.GetRequestedTeam()
}

func TestTimeline_GetRequester(tt *testing.T) {
	tt.Parallel()
	t := &Timeline{}
	t.GetRequester()
	t = nil
	t.GetRequester()
}

func TestTimeline_GetReviewer(tt *testing.T) {
	tt.Parallel()
	t := &Timeline{}
	t.GetReviewer()
	t = nil
	t.GetReviewer()
}

func TestTimeline_GetSHA(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &Timeline{SHA: &zeroValue}
	t.GetSHA()
	t = &Timeline{}
	t.GetSHA()
	t = nil
	t.GetSHA()
}

func TestTimeline_GetSource(tt *testing.T) {
	tt.Parallel()
	t := &Timeline{}
	t.GetSource()
	t = nil
	t.GetSource()
}

func TestTimeline_GetState(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &Timeline{State: &zeroValue}
	t.GetState()
	t = &Timeline{}
	t.GetState()
	t = nil
	t.GetState()
}

func TestTimeline_GetSubmittedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	t := &Timeline{SubmittedAt: &zeroValue}
	t.GetSubmittedAt()
	t = &Timeline{}
	t.GetSubmittedAt()
	t = nil
	t.GetSubmittedAt()
}

func TestTimeline_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &Timeline{URL: &zeroValue}
	t.GetURL()
	t = &Timeline{}
	t.GetURL()
	t = nil
	t.GetURL()
}

func TestTimeline_GetUser(tt *testing.T) {
	tt.Parallel()
	t := &Timeline{}
	t.GetUser()
	t = nil
	t.GetUser()
}

func TestTool_GetGUID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &Tool{GUID: &zeroValue}
	t.GetGUID()
	t = &Tool{}
	t.GetGUID()
	t = nil
	t.GetGUID()
}

func TestTool_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &Tool{Name: &zeroValue}
	t.GetName()
	t = &Tool{}
	t.GetName()
	t = nil
	t.GetName()
}

func TestTool_GetVersion(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &Tool{Version: &zeroValue}
	t.GetVersion()
	t = &Tool{}
	t.GetVersion()
	t = nil
	t.GetVersion()
}

func TestTopicResult_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	t := &TopicResult{CreatedAt: &zeroValue}
	t.GetCreatedAt()
	t = &TopicResult{}
	t.GetCreatedAt()
	t = nil
	t.GetCreatedAt()
}

func TestTopicResult_GetCreatedBy(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &TopicResult{CreatedBy: &zeroValue}
	t.GetCreatedBy()
	t = &TopicResult{}
	t.GetCreatedBy()
	t = nil
	t.GetCreatedBy()
}

func TestTopicResult_GetCurated(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	t := &TopicResult{Curated: &zeroValue}
	t.GetCurated()
	t = &TopicResult{}
	t.GetCurated()
	t = nil
	t.GetCurated()
}

func TestTopicResult_GetDescription(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &TopicResult{Description: &zeroValue}
	t.GetDescription()
	t = &TopicResult{}
	t.GetDescription()
	t = nil
	t.GetDescription()
}

func TestTopicResult_GetDisplayName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &TopicResult{DisplayName: &zeroValue}
	t.GetDisplayName()
	t = &TopicResult{}
	t.GetDisplayName()
	t = nil
	t.GetDisplayName()
}

func TestTopicResult_GetFeatured(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	t := &TopicResult{Featured: &zeroValue}
	t.GetFeatured()
	t = &TopicResult{}
	t.GetFeatured()
	t = nil
	t.GetFeatured()
}

func TestTopicResult_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &TopicResult{Name: &zeroValue}
	t.GetName()
	t = &TopicResult{}
	t.GetName()
	t = nil
	t.GetName()
}

func TestTopicResult_GetScore(tt *testing.T) {
	tt.Parallel()
	var zeroValue float64
	t := &TopicResult{Score: &zeroValue}
	t.GetScore()
	t = &TopicResult{}
	t.GetScore()
	t = nil
	t.GetScore()
}

func TestTopicResult_GetShortDescription(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &TopicResult{ShortDescription: &zeroValue}
	t.GetShortDescription()
	t = &TopicResult{}
	t.GetShortDescription()
	t = nil
	t.GetShortDescription()
}

func TestTopicResult_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &TopicResult{UpdatedAt: &zeroValue}
	t.GetUpdatedAt()
	t = &TopicResult{}
	t.GetUpdatedAt()
	t = nil
	t.GetUpdatedAt()
}

func TestTopicsSearchResult_GetIncompleteResults(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	t := &TopicsSearchResult{IncompleteResults: &zeroValue}
	t.GetIncompleteResults()
	t = &TopicsSearchResult{}
	t.GetIncompleteResults()
	t = nil
	t.GetIncompleteResults()
}

func TestTopicsSearchResult_GetTopics(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*TopicResult{}
	t := &TopicsSearchResult{Topics: zeroValue}
	t.GetTopics()
	t = &TopicsSearchResult{}
	t.GetTopics()
	t = nil
	t.GetTopics()
}

func TestTopicsSearchResult_GetTotal(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	t := &TopicsSearchResult{Total: &zeroValue}
	t.GetTotal()
	t = &TopicsSearchResult{}
	t.GetTotal()
	t = nil
	t.GetTotal()
}

func TestTotalCacheUsage_GetTotalActiveCachesCount(tt *testing.T) {
	tt.Parallel()
	t := &TotalCacheUsage{}
	t.GetTotalActiveCachesCount()
	t = nil
	t.GetTotalActiveCachesCount()
}

func TestTotalCacheUsage_GetTotalActiveCachesUsageSizeInBytes(tt *testing.T) {
	tt.Parallel()
	t := &TotalCacheUsage{}
	t.GetTotalActiveCachesUsageSizeInBytes()
	t = nil
	t.GetTotalActiveCachesUsageSizeInBytes()
}

func TestTrafficBreakdownOptions_GetPer(tt *testing.T) {
	tt.Parallel()
	t := &TrafficBreakdownOptions{}
	t.GetPer()
	t = nil
	t.GetPer()
}

func TestTrafficClones_GetClones(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*TrafficData{}
	t := &TrafficClones{Clones: zeroValue}
	t.GetClones()
	t = &TrafficClones{}
	t.GetClones()
	t = nil
	t.GetClones()
}

func TestTrafficClones_GetCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	t := &TrafficClones{Count: &zeroValue}
	t.GetCount()
	t = &TrafficClones{}
	t.GetCount()
	t = nil
	t.GetCount()
}

func TestTrafficClones_GetUniques(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	t := &TrafficClones{Uniques: &zeroValue}
	t.GetUniques()
	t = &TrafficClones{}
	t.GetUniques()
	t = nil
	t.GetUniques()
}

func TestTrafficData_GetCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	t := &TrafficData{Count: &zeroValue}
	t.GetCount()
	t = &TrafficData{}
	t.GetCount()
	t = nil
	t.GetCount()
}

func TestTrafficData_GetTimestamp(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	t := &TrafficData{Timestamp: &zeroValue}
	t.GetTimestamp()
	t = &TrafficData{}
	t.GetTimestamp()
	t = nil
	t.GetTimestamp()
}

func TestTrafficData_GetUniques(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	t := &TrafficData{Uniques: &zeroValue}
	t.GetUniques()
	t = &TrafficData{}
	t.GetUniques()
	t = nil
	t.GetUniques()
}

func TestTrafficPath_GetCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	t := &TrafficPath{Count: &zeroValue}
	t.GetCount()
	t = &TrafficPath{}
	t.GetCount()
	t = nil
	t.GetCount()
}

func TestTrafficPath_GetPath(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &TrafficPath{Path: &zeroValue}
	t.GetPath()
	t = &TrafficPath{}
	t.GetPath()
	t = nil
	t.GetPath()
}

func TestTrafficPath_GetTitle(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &TrafficPath{Title: &zeroValue}
	t.GetTitle()
	t = &TrafficPath{}
	t.GetTitle()
	t = nil
	t.GetTitle()
}

func TestTrafficPath_GetUniques(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	t := &TrafficPath{Uniques: &zeroValue}
	t.GetUniques()
	t = &TrafficPath{}
	t.GetUniques()
	t = nil
	t.GetUniques()
}

func TestTrafficReferrer_GetCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	t := &TrafficReferrer{Count: &zeroValue}
	t.GetCount()
	t = &TrafficReferrer{}
	t.GetCount()
	t = nil
	t.GetCount()
}

func TestTrafficReferrer_GetReferrer(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &TrafficReferrer{Referrer: &zeroValue}
	t.GetReferrer()
	t = &TrafficReferrer{}
	t.GetReferrer()
	t = nil
	t.GetReferrer()
}

func TestTrafficReferrer_GetUniques(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	t := &TrafficReferrer{Uniques: &zeroValue}
	t.GetUniques()
	t = &TrafficReferrer{}
	t.GetUniques()
	t = nil
	t.GetUniques()
}

func TestTrafficViews_GetCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	t := &TrafficViews{Count: &zeroValue}
	t.GetCount()
	t = &TrafficViews{}
	t.GetCount()
	t = nil
	t.GetCount()
}

func TestTrafficViews_GetUniques(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	t := &TrafficViews{Uniques: &zeroValue}
	t.GetUniques()
	t = &TrafficViews{}
	t.GetUniques()
	t = nil
	t.GetUniques()
}

func TestTrafficViews_GetViews(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*TrafficData{}
	t := &TrafficViews{Views: zeroValue}
	t.GetViews()
	t = &TrafficViews{}
	t.GetViews()
	t = nil
	t.GetViews()
}

func TestTransferRequest_GetNewName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &TransferRequest{NewName: &zeroValue}
	t.GetNewName()
	t = &TransferRequest{}
	t.GetNewName()
	t = nil
	t.GetNewName()
}

func TestTransferRequest_GetNewOwner(tt *testing.T) {
	tt.Parallel()
	t := &TransferRequest{}
	t.GetNewOwner()
	t = nil
	t.GetNewOwner()
}

func TestTransferRequest_GetTeamID(tt *testing.T) {
	tt.Parallel()
	zeroValue := []int64{}
	t := &TransferRequest{TeamID: zeroValue}
	t.GetTeamID()
	t = &TransferRequest{}
	t.GetTeamID()
	t = nil
	t.GetTeamID()
}

func TestTree_GetEntries(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*TreeEntry{}
	t := &Tree{Entries: zeroValue}
	t.GetEntries()
	t = &Tree{}
	t.GetEntries()
	t = nil
	t.GetEntries()
}

func TestTree_GetSHA(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &Tree{SHA: &zeroValue}
	t.GetSHA()
	t = &Tree{}
	t.GetSHA()
	t = nil
	t.GetSHA()
}

func TestTree_GetTruncated(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	t := &Tree{Truncated: &zeroValue}
	t.GetTruncated()
	t = &Tree{}
	t.GetTruncated()
	t = nil
	t.GetTruncated()
}

func TestTreeEntry_GetContent(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &TreeEntry{Content: &zeroValue}
	t.GetContent()
	t = &TreeEntry{}
	t.GetContent()
	t = nil
	t.GetContent()
}

func TestTreeEntry_GetMode(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &TreeEntry{Mode: &zeroValue}
	t.GetMode()
	t = &TreeEntry{}
	t.GetMode()
	t = nil
	t.GetMode()
}

func TestTreeEntry_GetPath(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &TreeEntry{Path: &zeroValue}
	t.GetPath()
	t = &TreeEntry{}
	t.GetPath()
	t = nil
	t.GetPath()
}

func TestTreeEntry_GetSHA(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &TreeEntry{SHA: &zeroValue}
	t.GetSHA()
	t = &TreeEntry{}
	t.GetSHA()
	t = nil
	t.GetSHA()
}

func TestTreeEntry_GetSize(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	t := &TreeEntry{Size: &zeroValue}
	t.GetSize()
	t = &TreeEntry{}
	t.GetSize()
	t = nil
	t.GetSize()
}

func TestTreeEntry_GetType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &TreeEntry{Type: &zeroValue}
	t.GetType()
	t = &TreeEntry{}
	t.GetType()
	t = nil
	t.GetType()
}

func TestTreeEntry_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	t := &TreeEntry{URL: &zeroValue}
	t.GetURL()
	t = &TreeEntry{}
	t.GetURL()
	t = nil
	t.GetURL()
}

func TestUnauthenticatedRateLimitedTransport_GetClientID(tt *testing.T) {
	tt.Parallel()
	u := &UnauthenticatedRateLimitedTransport{}
	u.GetClientID()
	u = nil
	u.GetClientID()
}

func TestUnauthenticatedRateLimitedTransport_GetClientSecret(tt *testing.T) {
	tt.Parallel()
	u := &UnauthenticatedRateLimitedTransport{}
	u.GetClientSecret()
	u = nil
	u.GetClientSecret()
}

func TestUpdateAppInstallationRepositoriesRequest_GetRepositories(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	u := &UpdateAppInstallationRepositoriesRequest{Repositories: zeroValue}
	u.GetRepositories()
	u = &UpdateAppInstallationRepositoriesRequest{}
	u.GetRepositories()
	u = nil
	u.GetRepositories()
}

func TestUpdateAppInstallationRepositoriesRequest_GetRepositorySelection(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UpdateAppInstallationRepositoriesRequest{RepositorySelection: &zeroValue}
	u.GetRepositorySelection()
	u = &UpdateAppInstallationRepositoriesRequest{}
	u.GetRepositorySelection()
	u = nil
	u.GetRepositorySelection()
}

func TestUpdateAttributeForSCIMUserOperations_GetOp(tt *testing.T) {
	tt.Parallel()
	u := &UpdateAttributeForSCIMUserOperations{}
	u.GetOp()
	u = nil
	u.GetOp()
}

func TestUpdateAttributeForSCIMUserOperations_GetPath(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UpdateAttributeForSCIMUserOperations{Path: &zeroValue}
	u.GetPath()
	u = &UpdateAttributeForSCIMUserOperations{}
	u.GetPath()
	u = nil
	u.GetPath()
}

func TestUpdateAttributeForSCIMUserOperations_GetValue(tt *testing.T) {
	tt.Parallel()
	u := &UpdateAttributeForSCIMUserOperations{}
	u.GetValue()
	u = nil
	u.GetValue()
}

func TestUpdateAttributeForSCIMUserRequest_GetOperations(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*UpdateAttributeForSCIMUserOperations{}
	u := &UpdateAttributeForSCIMUserRequest{Operations: zeroValue}
	u.GetOperations()
	u = &UpdateAttributeForSCIMUserRequest{}
	u.GetOperations()
	u = nil
	u.GetOperations()
}

func TestUpdateAttributeForSCIMUserRequest_GetSchemas(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	u := &UpdateAttributeForSCIMUserRequest{Schemas: zeroValue}
	u.GetSchemas()
	u = &UpdateAttributeForSCIMUserRequest{}
	u.GetSchemas()
	u = nil
	u.GetSchemas()
}

func TestUpdateBranchRule_GetParameters(tt *testing.T) {
	tt.Parallel()
	u := &UpdateBranchRule{}
	u.GetParameters()
	u = nil
	u.GetParameters()
}

func TestUpdateCheckRunOptions_GetActions(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*CheckRunAction{}
	u := &UpdateCheckRunOptions{Actions: zeroValue}
	u.GetActions()
	u = &UpdateCheckRunOptions{}
	u.GetActions()
	u = nil
	u.GetActions()
}

func TestUpdateCheckRunOptions_GetCompletedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	u := &UpdateCheckRunOptions{CompletedAt: &zeroValue}
	u.GetCompletedAt()
	u = &UpdateCheckRunOptions{}
	u.GetCompletedAt()
	u = nil
	u.GetCompletedAt()
}

func TestUpdateCheckRunOptions_GetConclusion(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UpdateCheckRunOptions{Conclusion: &zeroValue}
	u.GetConclusion()
	u = &UpdateCheckRunOptions{}
	u.GetConclusion()
	u = nil
	u.GetConclusion()
}

func TestUpdateCheckRunOptions_GetDetailsURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UpdateCheckRunOptions{DetailsURL: &zeroValue}
	u.GetDetailsURL()
	u = &UpdateCheckRunOptions{}
	u.GetDetailsURL()
	u = nil
	u.GetDetailsURL()
}

func TestUpdateCheckRunOptions_GetExternalID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UpdateCheckRunOptions{ExternalID: &zeroValue}
	u.GetExternalID()
	u = &UpdateCheckRunOptions{}
	u.GetExternalID()
	u = nil
	u.GetExternalID()
}

func TestUpdateCheckRunOptions_GetName(tt *testing.T) {
	tt.Parallel()
	u := &UpdateCheckRunOptions{}
	u.GetName()
	u = nil
	u.GetName()
}

func TestUpdateCheckRunOptions_GetOutput(tt *testing.T) {
	tt.Parallel()
	u := &UpdateCheckRunOptions{}
	u.GetOutput()
	u = nil
	u.GetOutput()
}

func TestUpdateCheckRunOptions_GetStatus(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UpdateCheckRunOptions{Status: &zeroValue}
	u.GetStatus()
	u = &UpdateCheckRunOptions{}
	u.GetStatus()
	u = nil
	u.GetStatus()
}

func TestUpdateCodespaceOptions_GetMachine(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UpdateCodespaceOptions{Machine: &zeroValue}
	u.GetMachine()
	u = &UpdateCodespaceOptions{}
	u.GetMachine()
	u = nil
	u.GetMachine()
}

func TestUpdateCodespaceOptions_GetRecentFolders(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	u := &UpdateCodespaceOptions{RecentFolders: zeroValue}
	u.GetRecentFolders()
	u = &UpdateCodespaceOptions{}
	u.GetRecentFolders()
	u = nil
	u.GetRecentFolders()
}

func TestUpdateCustomOrgRoleRequest_GetBaseRole(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UpdateCustomOrgRoleRequest{BaseRole: &zeroValue}
	u.GetBaseRole()
	u = &UpdateCustomOrgRoleRequest{}
	u.GetBaseRole()
	u = nil
	u.GetBaseRole()
}

func TestUpdateCustomOrgRoleRequest_GetDescription(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UpdateCustomOrgRoleRequest{Description: &zeroValue}
	u.GetDescription()
	u = &UpdateCustomOrgRoleRequest{}
	u.GetDescription()
	u = nil
	u.GetDescription()
}

func TestUpdateCustomOrgRoleRequest_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UpdateCustomOrgRoleRequest{Name: &zeroValue}
	u.GetName()
	u = &UpdateCustomOrgRoleRequest{}
	u.GetName()
	u = nil
	u.GetName()
}

func TestUpdateCustomOrgRoleRequest_GetPermissions(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	u := &UpdateCustomOrgRoleRequest{Permissions: zeroValue}
	u.GetPermissions()
	u = &UpdateCustomOrgRoleRequest{}
	u.GetPermissions()
	u = nil
	u.GetPermissions()
}

func TestUpdateCustomRepoRoleRequest_GetBaseRole(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UpdateCustomRepoRoleRequest{BaseRole: &zeroValue}
	u.GetBaseRole()
	u = &UpdateCustomRepoRoleRequest{}
	u.GetBaseRole()
	u = nil
	u.GetBaseRole()
}

func TestUpdateCustomRepoRoleRequest_GetDescription(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UpdateCustomRepoRoleRequest{Description: &zeroValue}
	u.GetDescription()
	u = &UpdateCustomRepoRoleRequest{}
	u.GetDescription()
	u = nil
	u.GetDescription()
}

func TestUpdateCustomRepoRoleRequest_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UpdateCustomRepoRoleRequest{Name: &zeroValue}
	u.GetName()
	u = &UpdateCustomRepoRoleRequest{}
	u.GetName()
	u = nil
	u.GetName()
}

func TestUpdateCustomRepoRoleRequest_GetPermissions(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	u := &UpdateCustomRepoRoleRequest{Permissions: zeroValue}
	u.GetPermissions()
	u = &UpdateCustomRepoRoleRequest{}
	u.GetPermissions()
	u = nil
	u.GetPermissions()
}

func TestUpdateDefaultSetupConfigurationOptions_GetLanguages(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	u := &UpdateDefaultSetupConfigurationOptions{Languages: zeroValue}
	u.GetLanguages()
	u = &UpdateDefaultSetupConfigurationOptions{}
	u.GetLanguages()
	u = nil
	u.GetLanguages()
}

func TestUpdateDefaultSetupConfigurationOptions_GetQuerySuite(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UpdateDefaultSetupConfigurationOptions{QuerySuite: &zeroValue}
	u.GetQuerySuite()
	u = &UpdateDefaultSetupConfigurationOptions{}
	u.GetQuerySuite()
	u = nil
	u.GetQuerySuite()
}

func TestUpdateDefaultSetupConfigurationOptions_GetState(tt *testing.T) {
	tt.Parallel()
	u := &UpdateDefaultSetupConfigurationOptions{}
	u.GetState()
	u = nil
	u.GetState()
}

func TestUpdateDefaultSetupConfigurationResponse_GetRunID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	u := &UpdateDefaultSetupConfigurationResponse{RunID: &zeroValue}
	u.GetRunID()
	u = &UpdateDefaultSetupConfigurationResponse{}
	u.GetRunID()
	u = nil
	u.GetRunID()
}

func TestUpdateDefaultSetupConfigurationResponse_GetRunURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UpdateDefaultSetupConfigurationResponse{RunURL: &zeroValue}
	u.GetRunURL()
	u = &UpdateDefaultSetupConfigurationResponse{}
	u.GetRunURL()
	u = nil
	u.GetRunURL()
}

func TestUpdateDeploymentBranchPolicyRequest_GetName(tt *testing.T) {
	tt.Parallel()
	u := &UpdateDeploymentBranchPolicyRequest{}
	u.GetName()
	u = nil
	u.GetName()
}

func TestUpdateEnterpriseRunnerGroupRequest_GetAllowsPublicRepositories(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	u := &UpdateEnterpriseRunnerGroupRequest{AllowsPublicRepositories: &zeroValue}
	u.GetAllowsPublicRepositories()
	u = &UpdateEnterpriseRunnerGroupRequest{}
	u.GetAllowsPublicRepositories()
	u = nil
	u.GetAllowsPublicRepositories()
}

func TestUpdateEnterpriseRunnerGroupRequest_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UpdateEnterpriseRunnerGroupRequest{Name: &zeroValue}
	u.GetName()
	u = &UpdateEnterpriseRunnerGroupRequest{}
	u.GetName()
	u = nil
	u.GetName()
}

func TestUpdateEnterpriseRunnerGroupRequest_GetNetworkConfigurationID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UpdateEnterpriseRunnerGroupRequest{NetworkConfigurationID: &zeroValue}
	u.GetNetworkConfigurationID()
	u = &UpdateEnterpriseRunnerGroupRequest{}
	u.GetNetworkConfigurationID()
	u = nil
	u.GetNetworkConfigurationID()
}

func TestUpdateEnterpriseRunnerGroupRequest_GetRestrictedToWorkflows(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	u := &UpdateEnterpriseRunnerGroupRequest{RestrictedToWorkflows: &zeroValue}
	u.GetRestrictedToWorkflows()
	u = &UpdateEnterpriseRunnerGroupRequest{}
	u.GetRestrictedToWorkflows()
	u = nil
	u.GetRestrictedToWorkflows()
}

func TestUpdateEnterpriseRunnerGroupRequest_GetSelectedWorkflows(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	u := &UpdateEnterpriseRunnerGroupRequest{SelectedWorkflows: zeroValue}
	u.GetSelectedWorkflows()
	u = &UpdateEnterpriseRunnerGroupRequest{}
	u.GetSelectedWorkflows()
	u = nil
	u.GetSelectedWorkflows()
}

func TestUpdateEnterpriseRunnerGroupRequest_GetVisibility(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UpdateEnterpriseRunnerGroupRequest{Visibility: &zeroValue}
	u.GetVisibility()
	u = &UpdateEnterpriseRunnerGroupRequest{}
	u.GetVisibility()
	u = nil
	u.GetVisibility()
}

func TestUpdateGistCommentRequest_GetBody(tt *testing.T) {
	tt.Parallel()
	u := &UpdateGistCommentRequest{}
	u.GetBody()
	u = nil
	u.GetBody()
}

func TestUpdateGistFile_GetContent(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UpdateGistFile{Content: &zeroValue}
	u.GetContent()
	u = &UpdateGistFile{}
	u.GetContent()
	u = nil
	u.GetContent()
}

func TestUpdateGistFile_GetFilename(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UpdateGistFile{Filename: &zeroValue}
	u.GetFilename()
	u = &UpdateGistFile{}
	u.GetFilename()
	u = nil
	u.GetFilename()
}

func TestUpdateGistRequest_GetDescription(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UpdateGistRequest{Description: &zeroValue}
	u.GetDescription()
	u = &UpdateGistRequest{}
	u.GetDescription()
	u = nil
	u.GetDescription()
}

func TestUpdateHostedRunnerRequest_GetEnableStaticIP(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	u := &UpdateHostedRunnerRequest{EnableStaticIP: &zeroValue}
	u.GetEnableStaticIP()
	u = &UpdateHostedRunnerRequest{}
	u.GetEnableStaticIP()
	u = nil
	u.GetEnableStaticIP()
}

func TestUpdateHostedRunnerRequest_GetImageID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UpdateHostedRunnerRequest{ImageID: &zeroValue}
	u.GetImageID()
	u = &UpdateHostedRunnerRequest{}
	u.GetImageID()
	u = nil
	u.GetImageID()
}

func TestUpdateHostedRunnerRequest_GetImageVersion(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UpdateHostedRunnerRequest{ImageVersion: &zeroValue}
	u.GetImageVersion()
	u = &UpdateHostedRunnerRequest{}
	u.GetImageVersion()
	u = nil
	u.GetImageVersion()
}

func TestUpdateHostedRunnerRequest_GetMaximumRunners(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	u := &UpdateHostedRunnerRequest{MaximumRunners: &zeroValue}
	u.GetMaximumRunners()
	u = &UpdateHostedRunnerRequest{}
	u.GetMaximumRunners()
	u = nil
	u.GetMaximumRunners()
}

func TestUpdateHostedRunnerRequest_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UpdateHostedRunnerRequest{Name: &zeroValue}
	u.GetName()
	u = &UpdateHostedRunnerRequest{}
	u.GetName()
	u = nil
	u.GetName()
}

func TestUpdateHostedRunnerRequest_GetRunnerGroupID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	u := &UpdateHostedRunnerRequest{RunnerGroupID: &zeroValue}
	u.GetRunnerGroupID()
	u = &UpdateHostedRunnerRequest{}
	u.GetRunnerGroupID()
	u = nil
	u.GetRunnerGroupID()
}

func TestUpdateHostedRunnerRequest_GetSize(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UpdateHostedRunnerRequest{Size: &zeroValue}
	u.GetSize()
	u = &UpdateHostedRunnerRequest{}
	u.GetSize()
	u = nil
	u.GetSize()
}

func TestUpdateIssueLabelRequest_GetColor(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UpdateIssueLabelRequest{Color: &zeroValue}
	u.GetColor()
	u = &UpdateIssueLabelRequest{}
	u.GetColor()
	u = nil
	u.GetColor()
}

func TestUpdateIssueLabelRequest_GetDescription(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UpdateIssueLabelRequest{Description: &zeroValue}
	u.GetDescription()
	u = &UpdateIssueLabelRequest{}
	u.GetDescription()
	u = nil
	u.GetDescription()
}

func TestUpdateIssueLabelRequest_GetNewName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UpdateIssueLabelRequest{NewName: &zeroValue}
	u.GetNewName()
	u = &UpdateIssueLabelRequest{}
	u.GetNewName()
	u = nil
	u.GetNewName()
}

func TestUpdateIssueRequest_GetAssignee(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UpdateIssueRequest{Assignee: &zeroValue}
	u.GetAssignee()
	u = &UpdateIssueRequest{}
	u.GetAssignee()
	u = nil
	u.GetAssignee()
}

func TestUpdateIssueRequest_GetAssignees(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	u := &UpdateIssueRequest{Assignees: zeroValue}
	u.GetAssignees()
	u = &UpdateIssueRequest{}
	u.GetAssignees()
	u = nil
	u.GetAssignees()
}

func TestUpdateIssueRequest_GetBody(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UpdateIssueRequest{Body: &zeroValue}
	u.GetBody()
	u = &UpdateIssueRequest{}
	u.GetBody()
	u = nil
	u.GetBody()
}

func TestUpdateIssueRequest_GetDuplicateIssueID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	u := &UpdateIssueRequest{DuplicateIssueID: &zeroValue}
	u.GetDuplicateIssueID()
	u = &UpdateIssueRequest{}
	u.GetDuplicateIssueID()
	u = nil
	u.GetDuplicateIssueID()
}

func TestUpdateIssueRequest_GetIssueFieldValues(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*IssueRequestFieldValue{}
	u := &UpdateIssueRequest{IssueFieldValues: zeroValue}
	u.GetIssueFieldValues()
	u = &UpdateIssueRequest{}
	u.GetIssueFieldValues()
	u = nil
	u.GetIssueFieldValues()
}

func TestUpdateIssueRequest_GetLabels(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	u := &UpdateIssueRequest{Labels: zeroValue}
	u.GetLabels()
	u = &UpdateIssueRequest{}
	u.GetLabels()
	u = nil
	u.GetLabels()
}

func TestUpdateIssueRequest_GetMilestone(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	u := &UpdateIssueRequest{Milestone: &zeroValue}
	u.GetMilestone()
	u = &UpdateIssueRequest{}
	u.GetMilestone()
	u = nil
	u.GetMilestone()
}

func TestUpdateIssueRequest_GetState(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UpdateIssueRequest{State: &zeroValue}
	u.GetState()
	u = &UpdateIssueRequest{}
	u.GetState()
	u = nil
	u.GetState()
}

func TestUpdateIssueRequest_GetStateReason(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UpdateIssueRequest{StateReason: &zeroValue}
	u.GetStateReason()
	u = &UpdateIssueRequest{}
	u.GetStateReason()
	u = nil
	u.GetStateReason()
}

func TestUpdateIssueRequest_GetTitle(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UpdateIssueRequest{Title: &zeroValue}
	u.GetTitle()
	u = &UpdateIssueRequest{}
	u.GetTitle()
	u = nil
	u.GetTitle()
}

func TestUpdateIssueRequest_GetType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UpdateIssueRequest{Type: &zeroValue}
	u.GetType()
	u = &UpdateIssueRequest{}
	u.GetType()
	u = nil
	u.GetType()
}

func TestUpdateOrganizationPrivateRegistry_GetAccountID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UpdateOrganizationPrivateRegistry{AccountID: &zeroValue}
	u.GetAccountID()
	u = &UpdateOrganizationPrivateRegistry{}
	u.GetAccountID()
	u = nil
	u.GetAccountID()
}

func TestUpdateOrganizationPrivateRegistry_GetAudience(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UpdateOrganizationPrivateRegistry{Audience: &zeroValue}
	u.GetAudience()
	u = &UpdateOrganizationPrivateRegistry{}
	u.GetAudience()
	u = nil
	u.GetAudience()
}

func TestUpdateOrganizationPrivateRegistry_GetAuthType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UpdateOrganizationPrivateRegistry{AuthType: &zeroValue}
	u.GetAuthType()
	u = &UpdateOrganizationPrivateRegistry{}
	u.GetAuthType()
	u = nil
	u.GetAuthType()
}

func TestUpdateOrganizationPrivateRegistry_GetAWSRegion(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UpdateOrganizationPrivateRegistry{AWSRegion: &zeroValue}
	u.GetAWSRegion()
	u = &UpdateOrganizationPrivateRegistry{}
	u.GetAWSRegion()
	u = nil
	u.GetAWSRegion()
}

func TestUpdateOrganizationPrivateRegistry_GetClientID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UpdateOrganizationPrivateRegistry{ClientID: &zeroValue}
	u.GetClientID()
	u = &UpdateOrganizationPrivateRegistry{}
	u.GetClientID()
	u = nil
	u.GetClientID()
}

func TestUpdateOrganizationPrivateRegistry_GetDomain(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UpdateOrganizationPrivateRegistry{Domain: &zeroValue}
	u.GetDomain()
	u = &UpdateOrganizationPrivateRegistry{}
	u.GetDomain()
	u = nil
	u.GetDomain()
}

func TestUpdateOrganizationPrivateRegistry_GetDomainOwner(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UpdateOrganizationPrivateRegistry{DomainOwner: &zeroValue}
	u.GetDomainOwner()
	u = &UpdateOrganizationPrivateRegistry{}
	u.GetDomainOwner()
	u = nil
	u.GetDomainOwner()
}

func TestUpdateOrganizationPrivateRegistry_GetEncryptedValue(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UpdateOrganizationPrivateRegistry{EncryptedValue: &zeroValue}
	u.GetEncryptedValue()
	u = &UpdateOrganizationPrivateRegistry{}
	u.GetEncryptedValue()
	u = nil
	u.GetEncryptedValue()
}

func TestUpdateOrganizationPrivateRegistry_GetIdentityMappingName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UpdateOrganizationPrivateRegistry{IdentityMappingName: &zeroValue}
	u.GetIdentityMappingName()
	u = &UpdateOrganizationPrivateRegistry{}
	u.GetIdentityMappingName()
	u = nil
	u.GetIdentityMappingName()
}

func TestUpdateOrganizationPrivateRegistry_GetJFrogOIDCProviderName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UpdateOrganizationPrivateRegistry{JFrogOIDCProviderName: &zeroValue}
	u.GetJFrogOIDCProviderName()
	u = &UpdateOrganizationPrivateRegistry{}
	u.GetJFrogOIDCProviderName()
	u = nil
	u.GetJFrogOIDCProviderName()
}

func TestUpdateOrganizationPrivateRegistry_GetKeyID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UpdateOrganizationPrivateRegistry{KeyID: &zeroValue}
	u.GetKeyID()
	u = &UpdateOrganizationPrivateRegistry{}
	u.GetKeyID()
	u = nil
	u.GetKeyID()
}

func TestUpdateOrganizationPrivateRegistry_GetRegistryType(tt *testing.T) {
	tt.Parallel()
	u := &UpdateOrganizationPrivateRegistry{}
	u.GetRegistryType()
	u = nil
	u.GetRegistryType()
}

func TestUpdateOrganizationPrivateRegistry_GetReplacesBase(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	u := &UpdateOrganizationPrivateRegistry{ReplacesBase: &zeroValue}
	u.GetReplacesBase()
	u = &UpdateOrganizationPrivateRegistry{}
	u.GetReplacesBase()
	u = nil
	u.GetReplacesBase()
}

func TestUpdateOrganizationPrivateRegistry_GetRoleName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UpdateOrganizationPrivateRegistry{RoleName: &zeroValue}
	u.GetRoleName()
	u = &UpdateOrganizationPrivateRegistry{}
	u.GetRoleName()
	u = nil
	u.GetRoleName()
}

func TestUpdateOrganizationPrivateRegistry_GetSelectedRepositoryIDs(tt *testing.T) {
	tt.Parallel()
	zeroValue := []int64{}
	u := &UpdateOrganizationPrivateRegistry{SelectedRepositoryIDs: zeroValue}
	u.GetSelectedRepositoryIDs()
	u = &UpdateOrganizationPrivateRegistry{}
	u.GetSelectedRepositoryIDs()
	u = nil
	u.GetSelectedRepositoryIDs()
}

func TestUpdateOrganizationPrivateRegistry_GetTenantID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UpdateOrganizationPrivateRegistry{TenantID: &zeroValue}
	u.GetTenantID()
	u = &UpdateOrganizationPrivateRegistry{}
	u.GetTenantID()
	u = nil
	u.GetTenantID()
}

func TestUpdateOrganizationPrivateRegistry_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UpdateOrganizationPrivateRegistry{URL: &zeroValue}
	u.GetURL()
	u = &UpdateOrganizationPrivateRegistry{}
	u.GetURL()
	u = nil
	u.GetURL()
}

func TestUpdateOrganizationPrivateRegistry_GetUsername(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UpdateOrganizationPrivateRegistry{Username: &zeroValue}
	u.GetUsername()
	u = &UpdateOrganizationPrivateRegistry{}
	u.GetUsername()
	u = nil
	u.GetUsername()
}

func TestUpdateOrganizationPrivateRegistry_GetVisibility(tt *testing.T) {
	tt.Parallel()
	u := &UpdateOrganizationPrivateRegistry{}
	u.GetVisibility()
	u = nil
	u.GetVisibility()
}

func TestUpdateProjectItemOptions_GetArchived(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	u := &UpdateProjectItemOptions{Archived: &zeroValue}
	u.GetArchived()
	u = &UpdateProjectItemOptions{}
	u.GetArchived()
	u = nil
	u.GetArchived()
}

func TestUpdateProjectItemOptions_GetFields(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*UpdateProjectV2Field{}
	u := &UpdateProjectItemOptions{Fields: zeroValue}
	u.GetFields()
	u = &UpdateProjectItemOptions{}
	u.GetFields()
	u = nil
	u.GetFields()
}

func TestUpdateProjectV2Field_GetID(tt *testing.T) {
	tt.Parallel()
	u := &UpdateProjectV2Field{}
	u.GetID()
	u = nil
	u.GetID()
}

func TestUpdateProjectV2Field_GetValue(tt *testing.T) {
	tt.Parallel()
	u := &UpdateProjectV2Field{}
	u.GetValue()
	u = nil
	u.GetValue()
}

func TestUpdateProvisionedOrgMembershipRequest_GetActive(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	u := &UpdateProvisionedOrgMembershipRequest{Active: &zeroValue}
	u.GetActive()
	u = &UpdateProvisionedOrgMembershipRequest{}
	u.GetActive()
	u = nil
	u.GetActive()
}

func TestUpdateProvisionedOrgMembershipRequest_GetDisplayName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UpdateProvisionedOrgMembershipRequest{DisplayName: &zeroValue}
	u.GetDisplayName()
	u = &UpdateProvisionedOrgMembershipRequest{}
	u.GetDisplayName()
	u = nil
	u.GetDisplayName()
}

func TestUpdateProvisionedOrgMembershipRequest_GetEmails(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*SCIMUserEmail{}
	u := &UpdateProvisionedOrgMembershipRequest{Emails: zeroValue}
	u.GetEmails()
	u = &UpdateProvisionedOrgMembershipRequest{}
	u.GetEmails()
	u = nil
	u.GetEmails()
}

func TestUpdateProvisionedOrgMembershipRequest_GetExternalID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UpdateProvisionedOrgMembershipRequest{ExternalID: &zeroValue}
	u.GetExternalID()
	u = &UpdateProvisionedOrgMembershipRequest{}
	u.GetExternalID()
	u = nil
	u.GetExternalID()
}

func TestUpdateProvisionedOrgMembershipRequest_GetGroups(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	u := &UpdateProvisionedOrgMembershipRequest{Groups: zeroValue}
	u.GetGroups()
	u = &UpdateProvisionedOrgMembershipRequest{}
	u.GetGroups()
	u = nil
	u.GetGroups()
}

func TestUpdateProvisionedOrgMembershipRequest_GetName(tt *testing.T) {
	tt.Parallel()
	u := &UpdateProvisionedOrgMembershipRequest{}
	u.GetName()
	u = nil
	u.GetName()
}

func TestUpdateProvisionedOrgMembershipRequest_GetSchemas(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	u := &UpdateProvisionedOrgMembershipRequest{Schemas: zeroValue}
	u.GetSchemas()
	u = &UpdateProvisionedOrgMembershipRequest{}
	u.GetSchemas()
	u = nil
	u.GetSchemas()
}

func TestUpdateProvisionedOrgMembershipRequest_GetUserName(tt *testing.T) {
	tt.Parallel()
	u := &UpdateProvisionedOrgMembershipRequest{}
	u.GetUserName()
	u = nil
	u.GetUserName()
}

func TestUpdateRef_GetForce(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	u := &UpdateRef{Force: &zeroValue}
	u.GetForce()
	u = &UpdateRef{}
	u.GetForce()
	u = nil
	u.GetForce()
}

func TestUpdateRef_GetSHA(tt *testing.T) {
	tt.Parallel()
	u := &UpdateRef{}
	u.GetSHA()
	u = nil
	u.GetSHA()
}

func TestUpdateReleaseAssetRequest_GetLabel(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UpdateReleaseAssetRequest{Label: &zeroValue}
	u.GetLabel()
	u = &UpdateReleaseAssetRequest{}
	u.GetLabel()
	u = nil
	u.GetLabel()
}

func TestUpdateReleaseAssetRequest_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UpdateReleaseAssetRequest{Name: &zeroValue}
	u.GetName()
	u = &UpdateReleaseAssetRequest{}
	u.GetName()
	u = nil
	u.GetName()
}

func TestUpdateReleaseAssetRequest_GetState(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UpdateReleaseAssetRequest{State: &zeroValue}
	u.GetState()
	u = &UpdateReleaseAssetRequest{}
	u.GetState()
	u = nil
	u.GetState()
}

func TestUpdateReleaseRequest_GetBody(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UpdateReleaseRequest{Body: &zeroValue}
	u.GetBody()
	u = &UpdateReleaseRequest{}
	u.GetBody()
	u = nil
	u.GetBody()
}

func TestUpdateReleaseRequest_GetDiscussionCategoryName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UpdateReleaseRequest{DiscussionCategoryName: &zeroValue}
	u.GetDiscussionCategoryName()
	u = &UpdateReleaseRequest{}
	u.GetDiscussionCategoryName()
	u = nil
	u.GetDiscussionCategoryName()
}

func TestUpdateReleaseRequest_GetDraft(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	u := &UpdateReleaseRequest{Draft: &zeroValue}
	u.GetDraft()
	u = &UpdateReleaseRequest{}
	u.GetDraft()
	u = nil
	u.GetDraft()
}

func TestUpdateReleaseRequest_GetMakeLatest(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UpdateReleaseRequest{MakeLatest: &zeroValue}
	u.GetMakeLatest()
	u = &UpdateReleaseRequest{}
	u.GetMakeLatest()
	u = nil
	u.GetMakeLatest()
}

func TestUpdateReleaseRequest_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UpdateReleaseRequest{Name: &zeroValue}
	u.GetName()
	u = &UpdateReleaseRequest{}
	u.GetName()
	u = nil
	u.GetName()
}

func TestUpdateReleaseRequest_GetPrerelease(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	u := &UpdateReleaseRequest{Prerelease: &zeroValue}
	u.GetPrerelease()
	u = &UpdateReleaseRequest{}
	u.GetPrerelease()
	u = nil
	u.GetPrerelease()
}

func TestUpdateReleaseRequest_GetTagName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UpdateReleaseRequest{TagName: &zeroValue}
	u.GetTagName()
	u = &UpdateReleaseRequest{}
	u.GetTagName()
	u = nil
	u.GetTagName()
}

func TestUpdateReleaseRequest_GetTargetCommitish(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UpdateReleaseRequest{TargetCommitish: &zeroValue}
	u.GetTargetCommitish()
	u = &UpdateReleaseRequest{}
	u.GetTargetCommitish()
	u = nil
	u.GetTargetCommitish()
}

func TestUpdateRuleParameters_GetUpdateAllowsFetchAndMerge(tt *testing.T) {
	tt.Parallel()
	u := &UpdateRuleParameters{}
	u.GetUpdateAllowsFetchAndMerge()
	u = nil
	u.GetUpdateAllowsFetchAndMerge()
}

func TestUpdateRunnerGroupRequest_GetAllowsPublicRepositories(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	u := &UpdateRunnerGroupRequest{AllowsPublicRepositories: &zeroValue}
	u.GetAllowsPublicRepositories()
	u = &UpdateRunnerGroupRequest{}
	u.GetAllowsPublicRepositories()
	u = nil
	u.GetAllowsPublicRepositories()
}

func TestUpdateRunnerGroupRequest_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UpdateRunnerGroupRequest{Name: &zeroValue}
	u.GetName()
	u = &UpdateRunnerGroupRequest{}
	u.GetName()
	u = nil
	u.GetName()
}

func TestUpdateRunnerGroupRequest_GetNetworkConfigurationID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UpdateRunnerGroupRequest{NetworkConfigurationID: &zeroValue}
	u.GetNetworkConfigurationID()
	u = &UpdateRunnerGroupRequest{}
	u.GetNetworkConfigurationID()
	u = nil
	u.GetNetworkConfigurationID()
}

func TestUpdateRunnerGroupRequest_GetRestrictedToWorkflows(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	u := &UpdateRunnerGroupRequest{RestrictedToWorkflows: &zeroValue}
	u.GetRestrictedToWorkflows()
	u = &UpdateRunnerGroupRequest{}
	u.GetRestrictedToWorkflows()
	u = nil
	u.GetRestrictedToWorkflows()
}

func TestUpdateRunnerGroupRequest_GetSelectedWorkflows(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	u := &UpdateRunnerGroupRequest{SelectedWorkflows: zeroValue}
	u.GetSelectedWorkflows()
	u = &UpdateRunnerGroupRequest{}
	u.GetSelectedWorkflows()
	u = nil
	u.GetSelectedWorkflows()
}

func TestUpdateRunnerGroupRequest_GetVisibility(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UpdateRunnerGroupRequest{Visibility: &zeroValue}
	u.GetVisibility()
	u = &UpdateRunnerGroupRequest{}
	u.GetVisibility()
	u = nil
	u.GetVisibility()
}

func TestUploadLicenseOptions_GetLicense(tt *testing.T) {
	tt.Parallel()
	u := &UploadLicenseOptions{}
	u.GetLicense()
	u = nil
	u.GetLicense()
}

func TestUploadOptions_GetLabel(tt *testing.T) {
	tt.Parallel()
	u := &UploadOptions{}
	u.GetLabel()
	u = nil
	u.GetLabel()
}

func TestUploadOptions_GetMediaType(tt *testing.T) {
	tt.Parallel()
	u := &UploadOptions{}
	u.GetMediaType()
	u = nil
	u.GetMediaType()
}

func TestUploadOptions_GetName(tt *testing.T) {
	tt.Parallel()
	u := &UploadOptions{}
	u.GetName()
	u = nil
	u.GetName()
}

func TestUsageItem_GetDate(tt *testing.T) {
	tt.Parallel()
	u := &UsageItem{}
	u.GetDate()
	u = nil
	u.GetDate()
}

func TestUsageItem_GetDiscountAmount(tt *testing.T) {
	tt.Parallel()
	u := &UsageItem{}
	u.GetDiscountAmount()
	u = nil
	u.GetDiscountAmount()
}

func TestUsageItem_GetGrossAmount(tt *testing.T) {
	tt.Parallel()
	u := &UsageItem{}
	u.GetGrossAmount()
	u = nil
	u.GetGrossAmount()
}

func TestUsageItem_GetNetAmount(tt *testing.T) {
	tt.Parallel()
	u := &UsageItem{}
	u.GetNetAmount()
	u = nil
	u.GetNetAmount()
}

func TestUsageItem_GetOrganizationName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UsageItem{OrganizationName: &zeroValue}
	u.GetOrganizationName()
	u = &UsageItem{}
	u.GetOrganizationName()
	u = nil
	u.GetOrganizationName()
}

func TestUsageItem_GetPricePerUnit(tt *testing.T) {
	tt.Parallel()
	u := &UsageItem{}
	u.GetPricePerUnit()
	u = nil
	u.GetPricePerUnit()
}

func TestUsageItem_GetProduct(tt *testing.T) {
	tt.Parallel()
	u := &UsageItem{}
	u.GetProduct()
	u = nil
	u.GetProduct()
}

func TestUsageItem_GetQuantity(tt *testing.T) {
	tt.Parallel()
	u := &UsageItem{}
	u.GetQuantity()
	u = nil
	u.GetQuantity()
}

func TestUsageItem_GetRepositoryName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UsageItem{RepositoryName: &zeroValue}
	u.GetRepositoryName()
	u = &UsageItem{}
	u.GetRepositoryName()
	u = nil
	u.GetRepositoryName()
}

func TestUsageItem_GetSKU(tt *testing.T) {
	tt.Parallel()
	u := &UsageItem{}
	u.GetSKU()
	u = nil
	u.GetSKU()
}

func TestUsageItem_GetUnitType(tt *testing.T) {
	tt.Parallel()
	u := &UsageItem{}
	u.GetUnitType()
	u = nil
	u.GetUnitType()
}

func TestUsageReport_GetUsageItems(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*UsageItem{}
	u := &UsageReport{UsageItems: zeroValue}
	u.GetUsageItems()
	u = &UsageReport{}
	u.GetUsageItems()
	u = nil
	u.GetUsageItems()
}

func TestUsageReportOptions_GetDay(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	u := &UsageReportOptions{Day: &zeroValue}
	u.GetDay()
	u = &UsageReportOptions{}
	u.GetDay()
	u = nil
	u.GetDay()
}

func TestUsageReportOptions_GetHour(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	u := &UsageReportOptions{Hour: &zeroValue}
	u.GetHour()
	u = &UsageReportOptions{}
	u.GetHour()
	u = nil
	u.GetHour()
}

func TestUsageReportOptions_GetMonth(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	u := &UsageReportOptions{Month: &zeroValue}
	u.GetMonth()
	u = &UsageReportOptions{}
	u.GetMonth()
	u = nil
	u.GetMonth()
}

func TestUsageReportOptions_GetYear(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	u := &UsageReportOptions{Year: &zeroValue}
	u.GetYear()
	u = &UsageReportOptions{}
	u.GetYear()
	u = nil
	u.GetYear()
}

func TestUser_GetAssignment(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &User{Assignment: &zeroValue}
	u.GetAssignment()
	u = &User{}
	u.GetAssignment()
	u = nil
	u.GetAssignment()
}

func TestUser_GetAvatarURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &User{AvatarURL: &zeroValue}
	u.GetAvatarURL()
	u = &User{}
	u.GetAvatarURL()
	u = nil
	u.GetAvatarURL()
}

func TestUser_GetBio(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &User{Bio: &zeroValue}
	u.GetBio()
	u = &User{}
	u.GetBio()
	u = nil
	u.GetBio()
}

func TestUser_GetBlog(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &User{Blog: &zeroValue}
	u.GetBlog()
	u = &User{}
	u.GetBlog()
	u = nil
	u.GetBlog()
}

func TestUser_GetBusinessPlus(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	u := &User{BusinessPlus: &zeroValue}
	u.GetBusinessPlus()
	u = &User{}
	u.GetBusinessPlus()
	u = nil
	u.GetBusinessPlus()
}

func TestUser_GetCollaborators(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	u := &User{Collaborators: &zeroValue}
	u.GetCollaborators()
	u = &User{}
	u.GetCollaborators()
	u = nil
	u.GetCollaborators()
}

func TestUser_GetCompany(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &User{Company: &zeroValue}
	u.GetCompany()
	u = &User{}
	u.GetCompany()
	u = nil
	u.GetCompany()
}

func TestUser_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	u := &User{CreatedAt: &zeroValue}
	u.GetCreatedAt()
	u = &User{}
	u.GetCreatedAt()
	u = nil
	u.GetCreatedAt()
}

func TestUser_GetDiskUsage(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	u := &User{DiskUsage: &zeroValue}
	u.GetDiskUsage()
	u = &User{}
	u.GetDiskUsage()
	u = nil
	u.GetDiskUsage()
}

func TestUser_GetEmail(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &User{Email: &zeroValue}
	u.GetEmail()
	u = &User{}
	u.GetEmail()
	u = nil
	u.GetEmail()
}

func TestUser_GetEventsURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &User{EventsURL: &zeroValue}
	u.GetEventsURL()
	u = &User{}
	u.GetEventsURL()
	u = nil
	u.GetEventsURL()
}

func TestUser_GetFollowers(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	u := &User{Followers: &zeroValue}
	u.GetFollowers()
	u = &User{}
	u.GetFollowers()
	u = nil
	u.GetFollowers()
}

func TestUser_GetFollowersURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &User{FollowersURL: &zeroValue}
	u.GetFollowersURL()
	u = &User{}
	u.GetFollowersURL()
	u = nil
	u.GetFollowersURL()
}

func TestUser_GetFollowing(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	u := &User{Following: &zeroValue}
	u.GetFollowing()
	u = &User{}
	u.GetFollowing()
	u = nil
	u.GetFollowing()
}

func TestUser_GetFollowingURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &User{FollowingURL: &zeroValue}
	u.GetFollowingURL()
	u = &User{}
	u.GetFollowingURL()
	u = nil
	u.GetFollowingURL()
}

func TestUser_GetGistsURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &User{GistsURL: &zeroValue}
	u.GetGistsURL()
	u = &User{}
	u.GetGistsURL()
	u = nil
	u.GetGistsURL()
}

func TestUser_GetGravatarID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &User{GravatarID: &zeroValue}
	u.GetGravatarID()
	u = &User{}
	u.GetGravatarID()
	u = nil
	u.GetGravatarID()
}

func TestUser_GetHireable(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	u := &User{Hireable: &zeroValue}
	u.GetHireable()
	u = &User{}
	u.GetHireable()
	u = nil
	u.GetHireable()
}

func TestUser_GetHTMLURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &User{HTMLURL: &zeroValue}
	u.GetHTMLURL()
	u = &User{}
	u.GetHTMLURL()
	u = nil
	u.GetHTMLURL()
}

func TestUser_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	u := &User{ID: &zeroValue}
	u.GetID()
	u = &User{}
	u.GetID()
	u = nil
	u.GetID()
}

func TestUser_GetInherited(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	u := &User{Inherited: &zeroValue}
	u.GetInherited()
	u = &User{}
	u.GetInherited()
	u = nil
	u.GetInherited()
}

func TestUser_GetInheritedFrom(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*Team{}
	u := &User{InheritedFrom: zeroValue}
	u.GetInheritedFrom()
	u = &User{}
	u.GetInheritedFrom()
	u = nil
	u.GetInheritedFrom()
}

func TestUser_GetLdapDn(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &User{LdapDn: &zeroValue}
	u.GetLdapDn()
	u = &User{}
	u.GetLdapDn()
	u = nil
	u.GetLdapDn()
}

func TestUser_GetLocation(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &User{Location: &zeroValue}
	u.GetLocation()
	u = &User{}
	u.GetLocation()
	u = nil
	u.GetLocation()
}

func TestUser_GetLogin(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &User{Login: &zeroValue}
	u.GetLogin()
	u = &User{}
	u.GetLogin()
	u = nil
	u.GetLogin()
}

func TestUser_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &User{Name: &zeroValue}
	u.GetName()
	u = &User{}
	u.GetName()
	u = nil
	u.GetName()
}

func TestUser_GetNodeID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &User{NodeID: &zeroValue}
	u.GetNodeID()
	u = &User{}
	u.GetNodeID()
	u = nil
	u.GetNodeID()
}

func TestUser_GetNotificationEmail(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &User{NotificationEmail: &zeroValue}
	u.GetNotificationEmail()
	u = &User{}
	u.GetNotificationEmail()
	u = nil
	u.GetNotificationEmail()
}

func TestUser_GetOrganizationsURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &User{OrganizationsURL: &zeroValue}
	u.GetOrganizationsURL()
	u = &User{}
	u.GetOrganizationsURL()
	u = nil
	u.GetOrganizationsURL()
}

func TestUser_GetOwnedPrivateRepos(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	u := &User{OwnedPrivateRepos: &zeroValue}
	u.GetOwnedPrivateRepos()
	u = &User{}
	u.GetOwnedPrivateRepos()
	u = nil
	u.GetOwnedPrivateRepos()
}

func TestUser_GetPermissions(tt *testing.T) {
	tt.Parallel()
	u := &User{}
	u.GetPermissions()
	u = nil
	u.GetPermissions()
}

func TestUser_GetPlan(tt *testing.T) {
	tt.Parallel()
	u := &User{}
	u.GetPlan()
	u = nil
	u.GetPlan()
}

func TestUser_GetPrivateGists(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	u := &User{PrivateGists: &zeroValue}
	u.GetPrivateGists()
	u = &User{}
	u.GetPrivateGists()
	u = nil
	u.GetPrivateGists()
}

func TestUser_GetPublicGists(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	u := &User{PublicGists: &zeroValue}
	u.GetPublicGists()
	u = &User{}
	u.GetPublicGists()
	u = nil
	u.GetPublicGists()
}

func TestUser_GetPublicRepos(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	u := &User{PublicRepos: &zeroValue}
	u.GetPublicRepos()
	u = &User{}
	u.GetPublicRepos()
	u = nil
	u.GetPublicRepos()
}

func TestUser_GetReceivedEventsURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &User{ReceivedEventsURL: &zeroValue}
	u.GetReceivedEventsURL()
	u = &User{}
	u.GetReceivedEventsURL()
	u = nil
	u.GetReceivedEventsURL()
}

func TestUser_GetReposURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &User{ReposURL: &zeroValue}
	u.GetReposURL()
	u = &User{}
	u.GetReposURL()
	u = nil
	u.GetReposURL()
}

func TestUser_GetRole(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &User{Role: &zeroValue}
	u.GetRole()
	u = &User{}
	u.GetRole()
	u = nil
	u.GetRole()
}

func TestUser_GetRoleName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &User{RoleName: &zeroValue}
	u.GetRoleName()
	u = &User{}
	u.GetRoleName()
	u = nil
	u.GetRoleName()
}

func TestUser_GetSiteAdmin(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	u := &User{SiteAdmin: &zeroValue}
	u.GetSiteAdmin()
	u = &User{}
	u.GetSiteAdmin()
	u = nil
	u.GetSiteAdmin()
}

func TestUser_GetStarredURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &User{StarredURL: &zeroValue}
	u.GetStarredURL()
	u = &User{}
	u.GetStarredURL()
	u = nil
	u.GetStarredURL()
}

func TestUser_GetSubscriptionsURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &User{SubscriptionsURL: &zeroValue}
	u.GetSubscriptionsURL()
	u = &User{}
	u.GetSubscriptionsURL()
	u = nil
	u.GetSubscriptionsURL()
}

func TestUser_GetSuspendedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	u := &User{SuspendedAt: &zeroValue}
	u.GetSuspendedAt()
	u = &User{}
	u.GetSuspendedAt()
	u = nil
	u.GetSuspendedAt()
}

func TestUser_GetTextMatches(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*TextMatch{}
	u := &User{TextMatches: zeroValue}
	u.GetTextMatches()
	u = &User{}
	u.GetTextMatches()
	u = nil
	u.GetTextMatches()
}

func TestUser_GetTotalPrivateRepos(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	u := &User{TotalPrivateRepos: &zeroValue}
	u.GetTotalPrivateRepos()
	u = &User{}
	u.GetTotalPrivateRepos()
	u = nil
	u.GetTotalPrivateRepos()
}

func TestUser_GetTwitterUsername(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &User{TwitterUsername: &zeroValue}
	u.GetTwitterUsername()
	u = &User{}
	u.GetTwitterUsername()
	u = nil
	u.GetTwitterUsername()
}

func TestUser_GetTwoFactorAuthentication(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	u := &User{TwoFactorAuthentication: &zeroValue}
	u.GetTwoFactorAuthentication()
	u = &User{}
	u.GetTwoFactorAuthentication()
	u = nil
	u.GetTwoFactorAuthentication()
}

func TestUser_GetType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &User{Type: &zeroValue}
	u.GetType()
	u = &User{}
	u.GetType()
	u = nil
	u.GetType()
}

func TestUser_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	u := &User{UpdatedAt: &zeroValue}
	u.GetUpdatedAt()
	u = &User{}
	u.GetUpdatedAt()
	u = nil
	u.GetUpdatedAt()
}

func TestUser_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &User{URL: &zeroValue}
	u.GetURL()
	u = &User{}
	u.GetURL()
	u = nil
	u.GetURL()
}

func TestUser_GetUserViewType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &User{UserViewType: &zeroValue}
	u.GetUserViewType()
	u = &User{}
	u.GetUserViewType()
	u = nil
	u.GetUserViewType()
}

func TestUserAuthorization_GetApp(tt *testing.T) {
	tt.Parallel()
	u := &UserAuthorization{}
	u.GetApp()
	u = nil
	u.GetApp()
}

func TestUserAuthorization_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	u := &UserAuthorization{CreatedAt: &zeroValue}
	u.GetCreatedAt()
	u = &UserAuthorization{}
	u.GetCreatedAt()
	u = nil
	u.GetCreatedAt()
}

func TestUserAuthorization_GetFingerprint(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UserAuthorization{Fingerprint: &zeroValue}
	u.GetFingerprint()
	u = &UserAuthorization{}
	u.GetFingerprint()
	u = nil
	u.GetFingerprint()
}

func TestUserAuthorization_GetHashedToken(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UserAuthorization{HashedToken: &zeroValue}
	u.GetHashedToken()
	u = &UserAuthorization{}
	u.GetHashedToken()
	u = nil
	u.GetHashedToken()
}

func TestUserAuthorization_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	u := &UserAuthorization{ID: &zeroValue}
	u.GetID()
	u = &UserAuthorization{}
	u.GetID()
	u = nil
	u.GetID()
}

func TestUserAuthorization_GetNote(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UserAuthorization{Note: &zeroValue}
	u.GetNote()
	u = &UserAuthorization{}
	u.GetNote()
	u = nil
	u.GetNote()
}

func TestUserAuthorization_GetNoteURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UserAuthorization{NoteURL: &zeroValue}
	u.GetNoteURL()
	u = &UserAuthorization{}
	u.GetNoteURL()
	u = nil
	u.GetNoteURL()
}

func TestUserAuthorization_GetScopes(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	u := &UserAuthorization{Scopes: zeroValue}
	u.GetScopes()
	u = &UserAuthorization{}
	u.GetScopes()
	u = nil
	u.GetScopes()
}

func TestUserAuthorization_GetToken(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UserAuthorization{Token: &zeroValue}
	u.GetToken()
	u = &UserAuthorization{}
	u.GetToken()
	u = nil
	u.GetToken()
}

func TestUserAuthorization_GetTokenLastEight(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UserAuthorization{TokenLastEight: &zeroValue}
	u.GetTokenLastEight()
	u = &UserAuthorization{}
	u.GetTokenLastEight()
	u = nil
	u.GetTokenLastEight()
}

func TestUserAuthorization_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	u := &UserAuthorization{UpdatedAt: &zeroValue}
	u.GetUpdatedAt()
	u = &UserAuthorization{}
	u.GetUpdatedAt()
	u = nil
	u.GetUpdatedAt()
}

func TestUserAuthorization_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UserAuthorization{URL: &zeroValue}
	u.GetURL()
	u = &UserAuthorization{}
	u.GetURL()
	u = nil
	u.GetURL()
}

func TestUserContext_GetMessage(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UserContext{Message: &zeroValue}
	u.GetMessage()
	u = &UserContext{}
	u.GetMessage()
	u = nil
	u.GetMessage()
}

func TestUserContext_GetOcticon(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UserContext{Octicon: &zeroValue}
	u.GetOcticon()
	u = &UserContext{}
	u.GetOcticon()
	u = nil
	u.GetOcticon()
}

func TestUserEmail_GetEmail(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UserEmail{Email: &zeroValue}
	u.GetEmail()
	u = &UserEmail{}
	u.GetEmail()
	u = nil
	u.GetEmail()
}

func TestUserEmail_GetPrimary(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	u := &UserEmail{Primary: &zeroValue}
	u.GetPrimary()
	u = &UserEmail{}
	u.GetPrimary()
	u = nil
	u.GetPrimary()
}

func TestUserEmail_GetVerified(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	u := &UserEmail{Verified: &zeroValue}
	u.GetVerified()
	u = &UserEmail{}
	u.GetVerified()
	u = nil
	u.GetVerified()
}

func TestUserEmail_GetVisibility(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UserEmail{Visibility: &zeroValue}
	u.GetVisibility()
	u = &UserEmail{}
	u.GetVisibility()
	u = nil
	u.GetVisibility()
}

func TestUserEvent_GetAction(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UserEvent{Action: &zeroValue}
	u.GetAction()
	u = &UserEvent{}
	u.GetAction()
	u = nil
	u.GetAction()
}

func TestUserEvent_GetEnterprise(tt *testing.T) {
	tt.Parallel()
	u := &UserEvent{}
	u.GetEnterprise()
	u = nil
	u.GetEnterprise()
}

func TestUserEvent_GetInstallation(tt *testing.T) {
	tt.Parallel()
	u := &UserEvent{}
	u.GetInstallation()
	u = nil
	u.GetInstallation()
}

func TestUserEvent_GetSender(tt *testing.T) {
	tt.Parallel()
	u := &UserEvent{}
	u.GetSender()
	u = nil
	u.GetSender()
}

func TestUserEvent_GetUser(tt *testing.T) {
	tt.Parallel()
	u := &UserEvent{}
	u.GetUser()
	u = nil
	u.GetUser()
}

func TestUserLDAPMapping_GetAvatarURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UserLDAPMapping{AvatarURL: &zeroValue}
	u.GetAvatarURL()
	u = &UserLDAPMapping{}
	u.GetAvatarURL()
	u = nil
	u.GetAvatarURL()
}

func TestUserLDAPMapping_GetEventsURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UserLDAPMapping{EventsURL: &zeroValue}
	u.GetEventsURL()
	u = &UserLDAPMapping{}
	u.GetEventsURL()
	u = nil
	u.GetEventsURL()
}

func TestUserLDAPMapping_GetFollowersURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UserLDAPMapping{FollowersURL: &zeroValue}
	u.GetFollowersURL()
	u = &UserLDAPMapping{}
	u.GetFollowersURL()
	u = nil
	u.GetFollowersURL()
}

func TestUserLDAPMapping_GetFollowingURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UserLDAPMapping{FollowingURL: &zeroValue}
	u.GetFollowingURL()
	u = &UserLDAPMapping{}
	u.GetFollowingURL()
	u = nil
	u.GetFollowingURL()
}

func TestUserLDAPMapping_GetGistsURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UserLDAPMapping{GistsURL: &zeroValue}
	u.GetGistsURL()
	u = &UserLDAPMapping{}
	u.GetGistsURL()
	u = nil
	u.GetGistsURL()
}

func TestUserLDAPMapping_GetGravatarID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UserLDAPMapping{GravatarID: &zeroValue}
	u.GetGravatarID()
	u = &UserLDAPMapping{}
	u.GetGravatarID()
	u = nil
	u.GetGravatarID()
}

func TestUserLDAPMapping_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	u := &UserLDAPMapping{ID: &zeroValue}
	u.GetID()
	u = &UserLDAPMapping{}
	u.GetID()
	u = nil
	u.GetID()
}

func TestUserLDAPMapping_GetLDAPDN(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UserLDAPMapping{LDAPDN: &zeroValue}
	u.GetLDAPDN()
	u = &UserLDAPMapping{}
	u.GetLDAPDN()
	u = nil
	u.GetLDAPDN()
}

func TestUserLDAPMapping_GetLogin(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UserLDAPMapping{Login: &zeroValue}
	u.GetLogin()
	u = &UserLDAPMapping{}
	u.GetLogin()
	u = nil
	u.GetLogin()
}

func TestUserLDAPMapping_GetOrganizationsURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UserLDAPMapping{OrganizationsURL: &zeroValue}
	u.GetOrganizationsURL()
	u = &UserLDAPMapping{}
	u.GetOrganizationsURL()
	u = nil
	u.GetOrganizationsURL()
}

func TestUserLDAPMapping_GetReceivedEventsURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UserLDAPMapping{ReceivedEventsURL: &zeroValue}
	u.GetReceivedEventsURL()
	u = &UserLDAPMapping{}
	u.GetReceivedEventsURL()
	u = nil
	u.GetReceivedEventsURL()
}

func TestUserLDAPMapping_GetReposURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UserLDAPMapping{ReposURL: &zeroValue}
	u.GetReposURL()
	u = &UserLDAPMapping{}
	u.GetReposURL()
	u = nil
	u.GetReposURL()
}

func TestUserLDAPMapping_GetSiteAdmin(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	u := &UserLDAPMapping{SiteAdmin: &zeroValue}
	u.GetSiteAdmin()
	u = &UserLDAPMapping{}
	u.GetSiteAdmin()
	u = nil
	u.GetSiteAdmin()
}

func TestUserLDAPMapping_GetStarredURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UserLDAPMapping{StarredURL: &zeroValue}
	u.GetStarredURL()
	u = &UserLDAPMapping{}
	u.GetStarredURL()
	u = nil
	u.GetStarredURL()
}

func TestUserLDAPMapping_GetSubscriptionsURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UserLDAPMapping{SubscriptionsURL: &zeroValue}
	u.GetSubscriptionsURL()
	u = &UserLDAPMapping{}
	u.GetSubscriptionsURL()
	u = nil
	u.GetSubscriptionsURL()
}

func TestUserLDAPMapping_GetType(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UserLDAPMapping{Type: &zeroValue}
	u.GetType()
	u = &UserLDAPMapping{}
	u.GetType()
	u = nil
	u.GetType()
}

func TestUserLDAPMapping_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UserLDAPMapping{URL: &zeroValue}
	u.GetURL()
	u = &UserLDAPMapping{}
	u.GetURL()
	u = nil
	u.GetURL()
}

func TestUserListOptions_GetPerPage(tt *testing.T) {
	tt.Parallel()
	u := &UserListOptions{}
	u.GetPerPage()
	u = nil
	u.GetPerPage()
}

func TestUserListOptions_GetSince(tt *testing.T) {
	tt.Parallel()
	u := &UserListOptions{}
	u.GetSince()
	u = nil
	u.GetSince()
}

func TestUserMigration_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UserMigration{CreatedAt: &zeroValue}
	u.GetCreatedAt()
	u = &UserMigration{}
	u.GetCreatedAt()
	u = nil
	u.GetCreatedAt()
}

func TestUserMigration_GetExcludeAttachments(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	u := &UserMigration{ExcludeAttachments: &zeroValue}
	u.GetExcludeAttachments()
	u = &UserMigration{}
	u.GetExcludeAttachments()
	u = nil
	u.GetExcludeAttachments()
}

func TestUserMigration_GetGUID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UserMigration{GUID: &zeroValue}
	u.GetGUID()
	u = &UserMigration{}
	u.GetGUID()
	u = nil
	u.GetGUID()
}

func TestUserMigration_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	u := &UserMigration{ID: &zeroValue}
	u.GetID()
	u = &UserMigration{}
	u.GetID()
	u = nil
	u.GetID()
}

func TestUserMigration_GetLockRepositories(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	u := &UserMigration{LockRepositories: &zeroValue}
	u.GetLockRepositories()
	u = &UserMigration{}
	u.GetLockRepositories()
	u = nil
	u.GetLockRepositories()
}

func TestUserMigration_GetRepositories(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*Repository{}
	u := &UserMigration{Repositories: zeroValue}
	u.GetRepositories()
	u = &UserMigration{}
	u.GetRepositories()
	u = nil
	u.GetRepositories()
}

func TestUserMigration_GetState(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UserMigration{State: &zeroValue}
	u.GetState()
	u = &UserMigration{}
	u.GetState()
	u = nil
	u.GetState()
}

func TestUserMigration_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UserMigration{UpdatedAt: &zeroValue}
	u.GetUpdatedAt()
	u = &UserMigration{}
	u.GetUpdatedAt()
	u = nil
	u.GetUpdatedAt()
}

func TestUserMigration_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UserMigration{URL: &zeroValue}
	u.GetURL()
	u = &UserMigration{}
	u.GetURL()
	u = nil
	u.GetURL()
}

func TestUserMigrationOptions_GetExcludeAttachments(tt *testing.T) {
	tt.Parallel()
	u := &UserMigrationOptions{}
	u.GetExcludeAttachments()
	u = nil
	u.GetExcludeAttachments()
}

func TestUserMigrationOptions_GetLockRepositories(tt *testing.T) {
	tt.Parallel()
	u := &UserMigrationOptions{}
	u.GetLockRepositories()
	u = nil
	u.GetLockRepositories()
}

func TestUsersSearchResult_GetIncompleteResults(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	u := &UsersSearchResult{IncompleteResults: &zeroValue}
	u.GetIncompleteResults()
	u = &UsersSearchResult{}
	u.GetIncompleteResults()
	u = nil
	u.GetIncompleteResults()
}

func TestUsersSearchResult_GetTotal(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	u := &UsersSearchResult{Total: &zeroValue}
	u.GetTotal()
	u = &UsersSearchResult{}
	u.GetTotal()
	u = nil
	u.GetTotal()
}

func TestUsersSearchResult_GetUsers(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*User{}
	u := &UsersSearchResult{Users: zeroValue}
	u.GetUsers()
	u = &UsersSearchResult{}
	u.GetUsers()
	u = nil
	u.GetUsers()
}

func TestUserStats_GetAdminUsers(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	u := &UserStats{AdminUsers: &zeroValue}
	u.GetAdminUsers()
	u = &UserStats{}
	u.GetAdminUsers()
	u = nil
	u.GetAdminUsers()
}

func TestUserStats_GetSuspendedUsers(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	u := &UserStats{SuspendedUsers: &zeroValue}
	u.GetSuspendedUsers()
	u = &UserStats{}
	u.GetSuspendedUsers()
	u = nil
	u.GetSuspendedUsers()
}

func TestUserStats_GetTotalUsers(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	u := &UserStats{TotalUsers: &zeroValue}
	u.GetTotalUsers()
	u = &UserStats{}
	u.GetTotalUsers()
	u = nil
	u.GetTotalUsers()
}

func TestUserSuspendOptions_GetReason(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	u := &UserSuspendOptions{Reason: &zeroValue}
	u.GetReason()
	u = &UserSuspendOptions{}
	u.GetReason()
	u = nil
	u.GetReason()
}

func TestVulnerabilityPackage_GetEcosystem(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	v := &VulnerabilityPackage{Ecosystem: &zeroValue}
	v.GetEcosystem()
	v = &VulnerabilityPackage{}
	v.GetEcosystem()
	v = nil
	v.GetEcosystem()
}

func TestVulnerabilityPackage_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	v := &VulnerabilityPackage{Name: &zeroValue}
	v.GetName()
	v = &VulnerabilityPackage{}
	v.GetName()
	v = nil
	v.GetName()
}

func TestWatchEvent_GetAction(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	w := &WatchEvent{Action: &zeroValue}
	w.GetAction()
	w = &WatchEvent{}
	w.GetAction()
	w = nil
	w.GetAction()
}

func TestWatchEvent_GetInstallation(tt *testing.T) {
	tt.Parallel()
	w := &WatchEvent{}
	w.GetInstallation()
	w = nil
	w.GetInstallation()
}

func TestWatchEvent_GetOrg(tt *testing.T) {
	tt.Parallel()
	w := &WatchEvent{}
	w.GetOrg()
	w = nil
	w.GetOrg()
}

func TestWatchEvent_GetRepo(tt *testing.T) {
	tt.Parallel()
	w := &WatchEvent{}
	w.GetRepo()
	w = nil
	w.GetRepo()
}

func TestWatchEvent_GetSender(tt *testing.T) {
	tt.Parallel()
	w := &WatchEvent{}
	w.GetSender()
	w = nil
	w.GetSender()
}

func TestWeeklyCommitActivity_GetDays(tt *testing.T) {
	tt.Parallel()
	zeroValue := []int{}
	w := &WeeklyCommitActivity{Days: zeroValue}
	w.GetDays()
	w = &WeeklyCommitActivity{}
	w.GetDays()
	w = nil
	w.GetDays()
}

func TestWeeklyCommitActivity_GetTotal(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	w := &WeeklyCommitActivity{Total: &zeroValue}
	w.GetTotal()
	w = &WeeklyCommitActivity{}
	w.GetTotal()
	w = nil
	w.GetTotal()
}

func TestWeeklyCommitActivity_GetWeek(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	w := &WeeklyCommitActivity{Week: &zeroValue}
	w.GetWeek()
	w = &WeeklyCommitActivity{}
	w.GetWeek()
	w = nil
	w.GetWeek()
}

func TestWeeklyStats_GetAdditions(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	w := &WeeklyStats{Additions: &zeroValue}
	w.GetAdditions()
	w = &WeeklyStats{}
	w.GetAdditions()
	w = nil
	w.GetAdditions()
}

func TestWeeklyStats_GetCommits(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	w := &WeeklyStats{Commits: &zeroValue}
	w.GetCommits()
	w = &WeeklyStats{}
	w.GetCommits()
	w = nil
	w.GetCommits()
}

func TestWeeklyStats_GetDeletions(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	w := &WeeklyStats{Deletions: &zeroValue}
	w.GetDeletions()
	w = &WeeklyStats{}
	w.GetDeletions()
	w = nil
	w.GetDeletions()
}

func TestWeeklyStats_GetWeek(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	w := &WeeklyStats{Week: &zeroValue}
	w.GetWeek()
	w = &WeeklyStats{}
	w.GetWeek()
	w = nil
	w.GetWeek()
}

func TestWorkflow_GetBadgeURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	w := &Workflow{BadgeURL: &zeroValue}
	w.GetBadgeURL()
	w = &Workflow{}
	w.GetBadgeURL()
	w = nil
	w.GetBadgeURL()
}

func TestWorkflow_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	w := &Workflow{CreatedAt: &zeroValue}
	w.GetCreatedAt()
	w = &Workflow{}
	w.GetCreatedAt()
	w = nil
	w.GetCreatedAt()
}

func TestWorkflow_GetHTMLURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	w := &Workflow{HTMLURL: &zeroValue}
	w.GetHTMLURL()
	w = &Workflow{}
	w.GetHTMLURL()
	w = nil
	w.GetHTMLURL()
}

func TestWorkflow_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	w := &Workflow{ID: &zeroValue}
	w.GetID()
	w = &Workflow{}
	w.GetID()
	w = nil
	w.GetID()
}

func TestWorkflow_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	w := &Workflow{Name: &zeroValue}
	w.GetName()
	w = &Workflow{}
	w.GetName()
	w = nil
	w.GetName()
}

func TestWorkflow_GetNodeID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	w := &Workflow{NodeID: &zeroValue}
	w.GetNodeID()
	w = &Workflow{}
	w.GetNodeID()
	w = nil
	w.GetNodeID()
}

func TestWorkflow_GetPath(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	w := &Workflow{Path: &zeroValue}
	w.GetPath()
	w = &Workflow{}
	w.GetPath()
	w = nil
	w.GetPath()
}

func TestWorkflow_GetState(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	w := &Workflow{State: &zeroValue}
	w.GetState()
	w = &Workflow{}
	w.GetState()
	w = nil
	w.GetState()
}

func TestWorkflow_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	w := &Workflow{UpdatedAt: &zeroValue}
	w.GetUpdatedAt()
	w = &Workflow{}
	w.GetUpdatedAt()
	w = nil
	w.GetUpdatedAt()
}

func TestWorkflow_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	w := &Workflow{URL: &zeroValue}
	w.GetURL()
	w = &Workflow{}
	w.GetURL()
	w = nil
	w.GetURL()
}

func TestWorkflowBill_GetTotalMS(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	w := &WorkflowBill{TotalMS: &zeroValue}
	w.GetTotalMS()
	w = &WorkflowBill{}
	w.GetTotalMS()
	w = nil
	w.GetTotalMS()
}

func TestWorkflowDispatchEvent_GetInputs(tt *testing.T) {
	tt.Parallel()
	w := &WorkflowDispatchEvent{}
	w.GetInputs()
	w = nil
	w.GetInputs()
}

func TestWorkflowDispatchEvent_GetInstallation(tt *testing.T) {
	tt.Parallel()
	w := &WorkflowDispatchEvent{}
	w.GetInstallation()
	w = nil
	w.GetInstallation()
}

func TestWorkflowDispatchEvent_GetOrg(tt *testing.T) {
	tt.Parallel()
	w := &WorkflowDispatchEvent{}
	w.GetOrg()
	w = nil
	w.GetOrg()
}

func TestWorkflowDispatchEvent_GetRef(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	w := &WorkflowDispatchEvent{Ref: &zeroValue}
	w.GetRef()
	w = &WorkflowDispatchEvent{}
	w.GetRef()
	w = nil
	w.GetRef()
}

func TestWorkflowDispatchEvent_GetRepo(tt *testing.T) {
	tt.Parallel()
	w := &WorkflowDispatchEvent{}
	w.GetRepo()
	w = nil
	w.GetRepo()
}

func TestWorkflowDispatchEvent_GetSender(tt *testing.T) {
	tt.Parallel()
	w := &WorkflowDispatchEvent{}
	w.GetSender()
	w = nil
	w.GetSender()
}

func TestWorkflowDispatchEvent_GetWorkflow(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	w := &WorkflowDispatchEvent{Workflow: &zeroValue}
	w.GetWorkflow()
	w = &WorkflowDispatchEvent{}
	w.GetWorkflow()
	w = nil
	w.GetWorkflow()
}

func TestWorkflowDispatchRunDetails_GetHTMLURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	w := &WorkflowDispatchRunDetails{HTMLURL: &zeroValue}
	w.GetHTMLURL()
	w = &WorkflowDispatchRunDetails{}
	w.GetHTMLURL()
	w = nil
	w.GetHTMLURL()
}

func TestWorkflowDispatchRunDetails_GetRunURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	w := &WorkflowDispatchRunDetails{RunURL: &zeroValue}
	w.GetRunURL()
	w = &WorkflowDispatchRunDetails{}
	w.GetRunURL()
	w = nil
	w.GetRunURL()
}

func TestWorkflowDispatchRunDetails_GetWorkflowRunID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	w := &WorkflowDispatchRunDetails{WorkflowRunID: &zeroValue}
	w.GetWorkflowRunID()
	w = &WorkflowDispatchRunDetails{}
	w.GetWorkflowRunID()
	w = nil
	w.GetWorkflowRunID()
}

func TestWorkflowJob_GetCheckRunURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	w := &WorkflowJob{CheckRunURL: &zeroValue}
	w.GetCheckRunURL()
	w = &WorkflowJob{}
	w.GetCheckRunURL()
	w = nil
	w.GetCheckRunURL()
}

func TestWorkflowJob_GetCompletedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	w := &WorkflowJob{CompletedAt: &zeroValue}
	w.GetCompletedAt()
	w = &WorkflowJob{}
	w.GetCompletedAt()
	w = nil
	w.GetCompletedAt()
}

func TestWorkflowJob_GetConclusion(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	w := &WorkflowJob{Conclusion: &zeroValue}
	w.GetConclusion()
	w = &WorkflowJob{}
	w.GetConclusion()
	w = nil
	w.GetConclusion()
}

func TestWorkflowJob_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	w := &WorkflowJob{CreatedAt: &zeroValue}
	w.GetCreatedAt()
	w = &WorkflowJob{}
	w.GetCreatedAt()
	w = nil
	w.GetCreatedAt()
}

func TestWorkflowJob_GetHeadBranch(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	w := &WorkflowJob{HeadBranch: &zeroValue}
	w.GetHeadBranch()
	w = &WorkflowJob{}
	w.GetHeadBranch()
	w = nil
	w.GetHeadBranch()
}

func TestWorkflowJob_GetHeadSHA(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	w := &WorkflowJob{HeadSHA: &zeroValue}
	w.GetHeadSHA()
	w = &WorkflowJob{}
	w.GetHeadSHA()
	w = nil
	w.GetHeadSHA()
}

func TestWorkflowJob_GetHTMLURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	w := &WorkflowJob{HTMLURL: &zeroValue}
	w.GetHTMLURL()
	w = &WorkflowJob{}
	w.GetHTMLURL()
	w = nil
	w.GetHTMLURL()
}

func TestWorkflowJob_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	w := &WorkflowJob{ID: &zeroValue}
	w.GetID()
	w = &WorkflowJob{}
	w.GetID()
	w = nil
	w.GetID()
}

func TestWorkflowJob_GetLabels(tt *testing.T) {
	tt.Parallel()
	zeroValue := []string{}
	w := &WorkflowJob{Labels: zeroValue}
	w.GetLabels()
	w = &WorkflowJob{}
	w.GetLabels()
	w = nil
	w.GetLabels()
}

func TestWorkflowJob_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	w := &WorkflowJob{Name: &zeroValue}
	w.GetName()
	w = &WorkflowJob{}
	w.GetName()
	w = nil
	w.GetName()
}

func TestWorkflowJob_GetNodeID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	w := &WorkflowJob{NodeID: &zeroValue}
	w.GetNodeID()
	w = &WorkflowJob{}
	w.GetNodeID()
	w = nil
	w.GetNodeID()
}

func TestWorkflowJob_GetRunAttempt(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	w := &WorkflowJob{RunAttempt: &zeroValue}
	w.GetRunAttempt()
	w = &WorkflowJob{}
	w.GetRunAttempt()
	w = nil
	w.GetRunAttempt()
}

func TestWorkflowJob_GetRunID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	w := &WorkflowJob{RunID: &zeroValue}
	w.GetRunID()
	w = &WorkflowJob{}
	w.GetRunID()
	w = nil
	w.GetRunID()
}

func TestWorkflowJob_GetRunnerGroupID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	w := &WorkflowJob{RunnerGroupID: &zeroValue}
	w.GetRunnerGroupID()
	w = &WorkflowJob{}
	w.GetRunnerGroupID()
	w = nil
	w.GetRunnerGroupID()
}

func TestWorkflowJob_GetRunnerGroupName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	w := &WorkflowJob{RunnerGroupName: &zeroValue}
	w.GetRunnerGroupName()
	w = &WorkflowJob{}
	w.GetRunnerGroupName()
	w = nil
	w.GetRunnerGroupName()
}

func TestWorkflowJob_GetRunnerID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	w := &WorkflowJob{RunnerID: &zeroValue}
	w.GetRunnerID()
	w = &WorkflowJob{}
	w.GetRunnerID()
	w = nil
	w.GetRunnerID()
}

func TestWorkflowJob_GetRunnerName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	w := &WorkflowJob{RunnerName: &zeroValue}
	w.GetRunnerName()
	w = &WorkflowJob{}
	w.GetRunnerName()
	w = nil
	w.GetRunnerName()
}

func TestWorkflowJob_GetRunURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	w := &WorkflowJob{RunURL: &zeroValue}
	w.GetRunURL()
	w = &WorkflowJob{}
	w.GetRunURL()
	w = nil
	w.GetRunURL()
}

func TestWorkflowJob_GetStartedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	w := &WorkflowJob{StartedAt: &zeroValue}
	w.GetStartedAt()
	w = &WorkflowJob{}
	w.GetStartedAt()
	w = nil
	w.GetStartedAt()
}

func TestWorkflowJob_GetStatus(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	w := &WorkflowJob{Status: &zeroValue}
	w.GetStatus()
	w = &WorkflowJob{}
	w.GetStatus()
	w = nil
	w.GetStatus()
}

func TestWorkflowJob_GetSteps(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*TaskStep{}
	w := &WorkflowJob{Steps: zeroValue}
	w.GetSteps()
	w = &WorkflowJob{}
	w.GetSteps()
	w = nil
	w.GetSteps()
}

func TestWorkflowJob_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	w := &WorkflowJob{URL: &zeroValue}
	w.GetURL()
	w = &WorkflowJob{}
	w.GetURL()
	w = nil
	w.GetURL()
}

func TestWorkflowJob_GetWorkflowName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	w := &WorkflowJob{WorkflowName: &zeroValue}
	w.GetWorkflowName()
	w = &WorkflowJob{}
	w.GetWorkflowName()
	w = nil
	w.GetWorkflowName()
}

func TestWorkflowJobEvent_GetAction(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	w := &WorkflowJobEvent{Action: &zeroValue}
	w.GetAction()
	w = &WorkflowJobEvent{}
	w.GetAction()
	w = nil
	w.GetAction()
}

func TestWorkflowJobEvent_GetDeployment(tt *testing.T) {
	tt.Parallel()
	w := &WorkflowJobEvent{}
	w.GetDeployment()
	w = nil
	w.GetDeployment()
}

func TestWorkflowJobEvent_GetInstallation(tt *testing.T) {
	tt.Parallel()
	w := &WorkflowJobEvent{}
	w.GetInstallation()
	w = nil
	w.GetInstallation()
}

func TestWorkflowJobEvent_GetOrg(tt *testing.T) {
	tt.Parallel()
	w := &WorkflowJobEvent{}
	w.GetOrg()
	w = nil
	w.GetOrg()
}

func TestWorkflowJobEvent_GetRepo(tt *testing.T) {
	tt.Parallel()
	w := &WorkflowJobEvent{}
	w.GetRepo()
	w = nil
	w.GetRepo()
}

func TestWorkflowJobEvent_GetSender(tt *testing.T) {
	tt.Parallel()
	w := &WorkflowJobEvent{}
	w.GetSender()
	w = nil
	w.GetSender()
}

func TestWorkflowJobEvent_GetWorkflowJob(tt *testing.T) {
	tt.Parallel()
	w := &WorkflowJobEvent{}
	w.GetWorkflowJob()
	w = nil
	w.GetWorkflowJob()
}

func TestWorkflowJobRun_GetConclusion(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	w := &WorkflowJobRun{Conclusion: &zeroValue}
	w.GetConclusion()
	w = &WorkflowJobRun{}
	w.GetConclusion()
	w = nil
	w.GetConclusion()
}

func TestWorkflowJobRun_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	w := &WorkflowJobRun{CreatedAt: &zeroValue}
	w.GetCreatedAt()
	w = &WorkflowJobRun{}
	w.GetCreatedAt()
	w = nil
	w.GetCreatedAt()
}

func TestWorkflowJobRun_GetEnvironment(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	w := &WorkflowJobRun{Environment: &zeroValue}
	w.GetEnvironment()
	w = &WorkflowJobRun{}
	w.GetEnvironment()
	w = nil
	w.GetEnvironment()
}

func TestWorkflowJobRun_GetHTMLURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	w := &WorkflowJobRun{HTMLURL: &zeroValue}
	w.GetHTMLURL()
	w = &WorkflowJobRun{}
	w.GetHTMLURL()
	w = nil
	w.GetHTMLURL()
}

func TestWorkflowJobRun_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	w := &WorkflowJobRun{ID: &zeroValue}
	w.GetID()
	w = &WorkflowJobRun{}
	w.GetID()
	w = nil
	w.GetID()
}

func TestWorkflowJobRun_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	w := &WorkflowJobRun{Name: &zeroValue}
	w.GetName()
	w = &WorkflowJobRun{}
	w.GetName()
	w = nil
	w.GetName()
}

func TestWorkflowJobRun_GetStatus(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	w := &WorkflowJobRun{Status: &zeroValue}
	w.GetStatus()
	w = &WorkflowJobRun{}
	w.GetStatus()
	w = nil
	w.GetStatus()
}

func TestWorkflowJobRun_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	w := &WorkflowJobRun{UpdatedAt: &zeroValue}
	w.GetUpdatedAt()
	w = &WorkflowJobRun{}
	w.GetUpdatedAt()
	w = nil
	w.GetUpdatedAt()
}

func TestWorkflowRun_GetActor(tt *testing.T) {
	tt.Parallel()
	w := &WorkflowRun{}
	w.GetActor()
	w = nil
	w.GetActor()
}

func TestWorkflowRun_GetArtifactsURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	w := &WorkflowRun{ArtifactsURL: &zeroValue}
	w.GetArtifactsURL()
	w = &WorkflowRun{}
	w.GetArtifactsURL()
	w = nil
	w.GetArtifactsURL()
}

func TestWorkflowRun_GetCancelURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	w := &WorkflowRun{CancelURL: &zeroValue}
	w.GetCancelURL()
	w = &WorkflowRun{}
	w.GetCancelURL()
	w = nil
	w.GetCancelURL()
}

func TestWorkflowRun_GetCheckSuiteID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	w := &WorkflowRun{CheckSuiteID: &zeroValue}
	w.GetCheckSuiteID()
	w = &WorkflowRun{}
	w.GetCheckSuiteID()
	w = nil
	w.GetCheckSuiteID()
}

func TestWorkflowRun_GetCheckSuiteNodeID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	w := &WorkflowRun{CheckSuiteNodeID: &zeroValue}
	w.GetCheckSuiteNodeID()
	w = &WorkflowRun{}
	w.GetCheckSuiteNodeID()
	w = nil
	w.GetCheckSuiteNodeID()
}

func TestWorkflowRun_GetCheckSuiteURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	w := &WorkflowRun{CheckSuiteURL: &zeroValue}
	w.GetCheckSuiteURL()
	w = &WorkflowRun{}
	w.GetCheckSuiteURL()
	w = nil
	w.GetCheckSuiteURL()
}

func TestWorkflowRun_GetConclusion(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	w := &WorkflowRun{Conclusion: &zeroValue}
	w.GetConclusion()
	w = &WorkflowRun{}
	w.GetConclusion()
	w = nil
	w.GetConclusion()
}

func TestWorkflowRun_GetCreatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	w := &WorkflowRun{CreatedAt: &zeroValue}
	w.GetCreatedAt()
	w = &WorkflowRun{}
	w.GetCreatedAt()
	w = nil
	w.GetCreatedAt()
}

func TestWorkflowRun_GetDisplayTitle(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	w := &WorkflowRun{DisplayTitle: &zeroValue}
	w.GetDisplayTitle()
	w = &WorkflowRun{}
	w.GetDisplayTitle()
	w = nil
	w.GetDisplayTitle()
}

func TestWorkflowRun_GetEvent(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	w := &WorkflowRun{Event: &zeroValue}
	w.GetEvent()
	w = &WorkflowRun{}
	w.GetEvent()
	w = nil
	w.GetEvent()
}

func TestWorkflowRun_GetHeadBranch(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	w := &WorkflowRun{HeadBranch: &zeroValue}
	w.GetHeadBranch()
	w = &WorkflowRun{}
	w.GetHeadBranch()
	w = nil
	w.GetHeadBranch()
}

func TestWorkflowRun_GetHeadCommit(tt *testing.T) {
	tt.Parallel()
	w := &WorkflowRun{}
	w.GetHeadCommit()
	w = nil
	w.GetHeadCommit()
}

func TestWorkflowRun_GetHeadRepository(tt *testing.T) {
	tt.Parallel()
	w := &WorkflowRun{}
	w.GetHeadRepository()
	w = nil
	w.GetHeadRepository()
}

func TestWorkflowRun_GetHeadSHA(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	w := &WorkflowRun{HeadSHA: &zeroValue}
	w.GetHeadSHA()
	w = &WorkflowRun{}
	w.GetHeadSHA()
	w = nil
	w.GetHeadSHA()
}

func TestWorkflowRun_GetHTMLURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	w := &WorkflowRun{HTMLURL: &zeroValue}
	w.GetHTMLURL()
	w = &WorkflowRun{}
	w.GetHTMLURL()
	w = nil
	w.GetHTMLURL()
}

func TestWorkflowRun_GetID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	w := &WorkflowRun{ID: &zeroValue}
	w.GetID()
	w = &WorkflowRun{}
	w.GetID()
	w = nil
	w.GetID()
}

func TestWorkflowRun_GetJobsURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	w := &WorkflowRun{JobsURL: &zeroValue}
	w.GetJobsURL()
	w = &WorkflowRun{}
	w.GetJobsURL()
	w = nil
	w.GetJobsURL()
}

func TestWorkflowRun_GetLogsURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	w := &WorkflowRun{LogsURL: &zeroValue}
	w.GetLogsURL()
	w = &WorkflowRun{}
	w.GetLogsURL()
	w = nil
	w.GetLogsURL()
}

func TestWorkflowRun_GetName(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	w := &WorkflowRun{Name: &zeroValue}
	w.GetName()
	w = &WorkflowRun{}
	w.GetName()
	w = nil
	w.GetName()
}

func TestWorkflowRun_GetNodeID(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	w := &WorkflowRun{NodeID: &zeroValue}
	w.GetNodeID()
	w = &WorkflowRun{}
	w.GetNodeID()
	w = nil
	w.GetNodeID()
}

func TestWorkflowRun_GetPath(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	w := &WorkflowRun{Path: &zeroValue}
	w.GetPath()
	w = &WorkflowRun{}
	w.GetPath()
	w = nil
	w.GetPath()
}

func TestWorkflowRun_GetPreviousAttemptURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	w := &WorkflowRun{PreviousAttemptURL: &zeroValue}
	w.GetPreviousAttemptURL()
	w = &WorkflowRun{}
	w.GetPreviousAttemptURL()
	w = nil
	w.GetPreviousAttemptURL()
}

func TestWorkflowRun_GetPullRequests(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*PullRequest{}
	w := &WorkflowRun{PullRequests: zeroValue}
	w.GetPullRequests()
	w = &WorkflowRun{}
	w.GetPullRequests()
	w = nil
	w.GetPullRequests()
}

func TestWorkflowRun_GetReferencedWorkflows(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*ReferencedWorkflow{}
	w := &WorkflowRun{ReferencedWorkflows: zeroValue}
	w.GetReferencedWorkflows()
	w = &WorkflowRun{}
	w.GetReferencedWorkflows()
	w = nil
	w.GetReferencedWorkflows()
}

func TestWorkflowRun_GetRepository(tt *testing.T) {
	tt.Parallel()
	w := &WorkflowRun{}
	w.GetRepository()
	w = nil
	w.GetRepository()
}

func TestWorkflowRun_GetRerunURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	w := &WorkflowRun{RerunURL: &zeroValue}
	w.GetRerunURL()
	w = &WorkflowRun{}
	w.GetRerunURL()
	w = nil
	w.GetRerunURL()
}

func TestWorkflowRun_GetRunAttempt(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	w := &WorkflowRun{RunAttempt: &zeroValue}
	w.GetRunAttempt()
	w = &WorkflowRun{}
	w.GetRunAttempt()
	w = nil
	w.GetRunAttempt()
}

func TestWorkflowRun_GetRunNumber(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	w := &WorkflowRun{RunNumber: &zeroValue}
	w.GetRunNumber()
	w = &WorkflowRun{}
	w.GetRunNumber()
	w = nil
	w.GetRunNumber()
}

func TestWorkflowRun_GetRunStartedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	w := &WorkflowRun{RunStartedAt: &zeroValue}
	w.GetRunStartedAt()
	w = &WorkflowRun{}
	w.GetRunStartedAt()
	w = nil
	w.GetRunStartedAt()
}

func TestWorkflowRun_GetStatus(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	w := &WorkflowRun{Status: &zeroValue}
	w.GetStatus()
	w = &WorkflowRun{}
	w.GetStatus()
	w = nil
	w.GetStatus()
}

func TestWorkflowRun_GetTriggeringActor(tt *testing.T) {
	tt.Parallel()
	w := &WorkflowRun{}
	w.GetTriggeringActor()
	w = nil
	w.GetTriggeringActor()
}

func TestWorkflowRun_GetUpdatedAt(tt *testing.T) {
	tt.Parallel()
	var zeroValue Timestamp
	w := &WorkflowRun{UpdatedAt: &zeroValue}
	w.GetUpdatedAt()
	w = &WorkflowRun{}
	w.GetUpdatedAt()
	w = nil
	w.GetUpdatedAt()
}

func TestWorkflowRun_GetURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	w := &WorkflowRun{URL: &zeroValue}
	w.GetURL()
	w = &WorkflowRun{}
	w.GetURL()
	w = nil
	w.GetURL()
}

func TestWorkflowRun_GetWorkflowID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	w := &WorkflowRun{WorkflowID: &zeroValue}
	w.GetWorkflowID()
	w = &WorkflowRun{}
	w.GetWorkflowID()
	w = nil
	w.GetWorkflowID()
}

func TestWorkflowRun_GetWorkflowURL(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	w := &WorkflowRun{WorkflowURL: &zeroValue}
	w.GetWorkflowURL()
	w = &WorkflowRun{}
	w.GetWorkflowURL()
	w = nil
	w.GetWorkflowURL()
}

func TestWorkflowRunAttemptOptions_GetExcludePullRequests(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	w := &WorkflowRunAttemptOptions{ExcludePullRequests: &zeroValue}
	w.GetExcludePullRequests()
	w = &WorkflowRunAttemptOptions{}
	w.GetExcludePullRequests()
	w = nil
	w.GetExcludePullRequests()
}

func TestWorkflowRunBill_GetJobRuns(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*WorkflowRunJobRun{}
	w := &WorkflowRunBill{JobRuns: zeroValue}
	w.GetJobRuns()
	w = &WorkflowRunBill{}
	w.GetJobRuns()
	w = nil
	w.GetJobRuns()
}

func TestWorkflowRunBill_GetJobs(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	w := &WorkflowRunBill{Jobs: &zeroValue}
	w.GetJobs()
	w = &WorkflowRunBill{}
	w.GetJobs()
	w = nil
	w.GetJobs()
}

func TestWorkflowRunBill_GetTotalMS(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	w := &WorkflowRunBill{TotalMS: &zeroValue}
	w.GetTotalMS()
	w = &WorkflowRunBill{}
	w.GetTotalMS()
	w = nil
	w.GetTotalMS()
}

func TestWorkflowRunEvent_GetAction(tt *testing.T) {
	tt.Parallel()
	var zeroValue string
	w := &WorkflowRunEvent{Action: &zeroValue}
	w.GetAction()
	w = &WorkflowRunEvent{}
	w.GetAction()
	w = nil
	w.GetAction()
}

func TestWorkflowRunEvent_GetInstallation(tt *testing.T) {
	tt.Parallel()
	w := &WorkflowRunEvent{}
	w.GetInstallation()
	w = nil
	w.GetInstallation()
}

func TestWorkflowRunEvent_GetOrg(tt *testing.T) {
	tt.Parallel()
	w := &WorkflowRunEvent{}
	w.GetOrg()
	w = nil
	w.GetOrg()
}

func TestWorkflowRunEvent_GetRepo(tt *testing.T) {
	tt.Parallel()
	w := &WorkflowRunEvent{}
	w.GetRepo()
	w = nil
	w.GetRepo()
}

func TestWorkflowRunEvent_GetSender(tt *testing.T) {
	tt.Parallel()
	w := &WorkflowRunEvent{}
	w.GetSender()
	w = nil
	w.GetSender()
}

func TestWorkflowRunEvent_GetWorkflow(tt *testing.T) {
	tt.Parallel()
	w := &WorkflowRunEvent{}
	w.GetWorkflow()
	w = nil
	w.GetWorkflow()
}

func TestWorkflowRunEvent_GetWorkflowRun(tt *testing.T) {
	tt.Parallel()
	w := &WorkflowRunEvent{}
	w.GetWorkflowRun()
	w = nil
	w.GetWorkflowRun()
}

func TestWorkflowRunJobRun_GetDurationMS(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	w := &WorkflowRunJobRun{DurationMS: &zeroValue}
	w.GetDurationMS()
	w = &WorkflowRunJobRun{}
	w.GetDurationMS()
	w = nil
	w.GetDurationMS()
}

func TestWorkflowRunJobRun_GetJobID(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	w := &WorkflowRunJobRun{JobID: &zeroValue}
	w.GetJobID()
	w = &WorkflowRunJobRun{}
	w.GetJobID()
	w = nil
	w.GetJobID()
}

func TestWorkflowRuns_GetTotalCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	w := &WorkflowRuns{TotalCount: &zeroValue}
	w.GetTotalCount()
	w = &WorkflowRuns{}
	w.GetTotalCount()
	w = nil
	w.GetTotalCount()
}

func TestWorkflowRuns_GetWorkflowRuns(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*WorkflowRun{}
	w := &WorkflowRuns{WorkflowRuns: zeroValue}
	w.GetWorkflowRuns()
	w = &WorkflowRuns{}
	w.GetWorkflowRuns()
	w = nil
	w.GetWorkflowRuns()
}

func TestWorkflowRunUsage_GetBillable(tt *testing.T) {
	tt.Parallel()
	w := &WorkflowRunUsage{}
	w.GetBillable()
	w = nil
	w.GetBillable()
}

func TestWorkflowRunUsage_GetRunDurationMS(tt *testing.T) {
	tt.Parallel()
	var zeroValue int64
	w := &WorkflowRunUsage{RunDurationMS: &zeroValue}
	w.GetRunDurationMS()
	w = &WorkflowRunUsage{}
	w.GetRunDurationMS()
	w = nil
	w.GetRunDurationMS()
}

func TestWorkflows_GetTotalCount(tt *testing.T) {
	tt.Parallel()
	var zeroValue int
	w := &Workflows{TotalCount: &zeroValue}
	w.GetTotalCount()
	w = &Workflows{}
	w.GetTotalCount()
	w = nil
	w.GetTotalCount()
}

func TestWorkflows_GetWorkflows(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*Workflow{}
	w := &Workflows{Workflows: zeroValue}
	w.GetWorkflows()
	w = &Workflows{}
	w.GetWorkflows()
	w = nil
	w.GetWorkflows()
}

func TestWorkflowsBranchRule_GetParameters(tt *testing.T) {
	tt.Parallel()
	w := &WorkflowsBranchRule{}
	w.GetParameters()
	w = nil
	w.GetParameters()
}

func TestWorkflowsPermissions_GetRequireApprovalForForkPRWorkflows(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	w := &WorkflowsPermissions{RequireApprovalForForkPRWorkflows: &zeroValue}
	w.GetRequireApprovalForForkPRWorkflows()
	w = &WorkflowsPermissions{}
	w.GetRequireApprovalForForkPRWorkflows()
	w = nil
	w.GetRequireApprovalForForkPRWorkflows()
}

func TestWorkflowsPermissions_GetRunWorkflowsFromForkPullRequests(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	w := &WorkflowsPermissions{RunWorkflowsFromForkPullRequests: &zeroValue}
	w.GetRunWorkflowsFromForkPullRequests()
	w = &WorkflowsPermissions{}
	w.GetRunWorkflowsFromForkPullRequests()
	w = nil
	w.GetRunWorkflowsFromForkPullRequests()
}

func TestWorkflowsPermissions_GetSendSecretsAndVariables(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	w := &WorkflowsPermissions{SendSecretsAndVariables: &zeroValue}
	w.GetSendSecretsAndVariables()
	w = &WorkflowsPermissions{}
	w.GetSendSecretsAndVariables()
	w = nil
	w.GetSendSecretsAndVariables()
}

func TestWorkflowsPermissions_GetSendWriteTokensToWorkflows(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	w := &WorkflowsPermissions{SendWriteTokensToWorkflows: &zeroValue}
	w.GetSendWriteTokensToWorkflows()
	w = &WorkflowsPermissions{}
	w.GetSendWriteTokensToWorkflows()
	w = nil
	w.GetSendWriteTokensToWorkflows()
}

func TestWorkflowsPermissionsOpt_GetRequireApprovalForForkPRWorkflows(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	w := &WorkflowsPermissionsOpt{RequireApprovalForForkPRWorkflows: &zeroValue}
	w.GetRequireApprovalForForkPRWorkflows()
	w = &WorkflowsPermissionsOpt{}
	w.GetRequireApprovalForForkPRWorkflows()
	w = nil
	w.GetRequireApprovalForForkPRWorkflows()
}

func TestWorkflowsPermissionsOpt_GetRunWorkflowsFromForkPullRequests(tt *testing.T) {
	tt.Parallel()
	w := &WorkflowsPermissionsOpt{}
	w.GetRunWorkflowsFromForkPullRequests()
	w = nil
	w.GetRunWorkflowsFromForkPullRequests()
}

func TestWorkflowsPermissionsOpt_GetSendSecretsAndVariables(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	w := &WorkflowsPermissionsOpt{SendSecretsAndVariables: &zeroValue}
	w.GetSendSecretsAndVariables()
	w = &WorkflowsPermissionsOpt{}
	w.GetSendSecretsAndVariables()
	w = nil
	w.GetSendSecretsAndVariables()
}

func TestWorkflowsPermissionsOpt_GetSendWriteTokensToWorkflows(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	w := &WorkflowsPermissionsOpt{SendWriteTokensToWorkflows: &zeroValue}
	w.GetSendWriteTokensToWorkflows()
	w = &WorkflowsPermissionsOpt{}
	w.GetSendWriteTokensToWorkflows()
	w = nil
	w.GetSendWriteTokensToWorkflows()
}

func TestWorkflowsRuleParameters_GetDoNotEnforceOnCreate(tt *testing.T) {
	tt.Parallel()
	var zeroValue bool
	w := &WorkflowsRuleParameters{DoNotEnforceOnCreate: &zeroValue}
	w.GetDoNotEnforceOnCreate()
	w = &WorkflowsRuleParameters{}
	w.GetDoNotEnforceOnCreate()
	w = nil
	w.GetDoNotEnforceOnCreate()
}

func TestWorkflowsRuleParameters_GetWorkflows(tt *testing.T) {
	tt.Parallel()
	zeroValue := []*RuleWorkflow{}
	w := &WorkflowsRuleParameters{Workflows: zeroValue}
	w.GetWorkflows()
	w = &WorkflowsRuleParameters{}
	w.GetWorkflows()
	w = nil
	w.GetWorkflows()
}

func TestWorkflowUsage_GetBillable(tt *testing.T) {
	tt.Parallel()
	w := &WorkflowUsage{}
	w.GetBillable()
	w = nil
	w.GetBillable()
}
