github-accessors_test.go

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

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

package github

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func TestAdvancedSecurityCommittersBreakdown_GetLastPushedDate(tt *testing.T) {
	var zeroValue string
	a := &AdvancedSecurityCommittersBreakdown{LastPushedDate: &zeroValue}
	a.GetLastPushedDate()
	a = &AdvancedSecurityCommittersBreakdown{}
	a.GetLastPushedDate()
	a = nil
	a.GetLastPushedDate()
}

func TestAdvancedSecurityCommittersBreakdown_GetUserLogin(tt *testing.T) {
	var zeroValue string
	a := &AdvancedSecurityCommittersBreakdown{UserLogin: &zeroValue}
	a.GetUserLogin()
	a = &AdvancedSecurityCommittersBreakdown{}
	a.GetUserLogin()
	a = nil
	a.GetUserLogin()
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func TestAuditEntry_GetActive(tt *testing.T) {
	var zeroValue bool
	a := &AuditEntry{Active: &zeroValue}
	a.GetActive()
	a = &AuditEntry{}
	a.GetActive()
	a = nil
	a.GetActive()
}

func TestAuditEntry_GetActiveWas(tt *testing.T) {
	var zeroValue bool
	a := &AuditEntry{ActiveWas: &zeroValue}
	a.GetActiveWas()
	a = &AuditEntry{}
	a.GetActiveWas()
	a = nil
	a.GetActiveWas()
}

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

func TestAuditEntry_GetBlockedUser(tt *testing.T) {
	var zeroValue string
	a := &AuditEntry{BlockedUser: &zeroValue}
	a.GetBlockedUser()
	a = &AuditEntry{}
	a.GetBlockedUser()
	a = nil
	a.GetBlockedUser()
}

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

func TestAuditEntry_GetCancelledAt(tt *testing.T) {
	var zeroValue Timestamp
	a := &AuditEntry{CancelledAt: &zeroValue}
	a.GetCancelledAt()
	a = &AuditEntry{}
	a.GetCancelledAt()
	a = nil
	a.GetCancelledAt()
}

func TestAuditEntry_GetCompletedAt(tt *testing.T) {
	var zeroValue Timestamp
	a := &AuditEntry{CompletedAt: &zeroValue}
	a.GetCompletedAt()
	a = &AuditEntry{}
	a.GetCompletedAt()
	a = nil
	a.GetCompletedAt()
}

func TestAuditEntry_GetConclusion(tt *testing.T) {
	var zeroValue string
	a := &AuditEntry{Conclusion: &zeroValue}
	a.GetConclusion()
	a = &AuditEntry{}
	a.GetConclusion()
	a = nil
	a.GetConclusion()
}

func TestAuditEntry_GetConfig(tt *testing.T) {
	a := &AuditEntry{}
	a.GetConfig()
	a = nil
	a.GetConfig()
}

func TestAuditEntry_GetConfigWas(tt *testing.T) {
	a := &AuditEntry{}
	a.GetConfigWas()
	a = nil
	a.GetConfigWas()
}

func TestAuditEntry_GetContentType(tt *testing.T) {
	var zeroValue string
	a := &AuditEntry{ContentType: &zeroValue}
	a.GetContentType()
	a = &AuditEntry{}
	a.GetContentType()
	a = nil
	a.GetContentType()
}

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

func TestAuditEntry_GetDeployKeyFingerprint(tt *testing.T) {
	var zeroValue string
	a := &AuditEntry{DeployKeyFingerprint: &zeroValue}
	a.GetDeployKeyFingerprint()
	a = &AuditEntry{}
	a.GetDeployKeyFingerprint()
	a = nil
	a.GetDeployKeyFingerprint()
}

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

func TestAuditEntry_GetEmoji(tt *testing.T) {
	var zeroValue string
	a := &AuditEntry{Emoji: &zeroValue}
	a.GetEmoji()
	a = &AuditEntry{}
	a.GetEmoji()
	a = nil
	a.GetEmoji()
}

func TestAuditEntry_GetEnvironmentName(tt *testing.T) {
	var zeroValue string
	a := &AuditEntry{EnvironmentName: &zeroValue}
	a.GetEnvironmentName()
	a = &AuditEntry{}
	a.GetEnvironmentName()
	a = nil
	a.GetEnvironmentName()
}

func TestAuditEntry_GetEvent(tt *testing.T) {
	var zeroValue string
	a := &AuditEntry{Event: &zeroValue}
	a.GetEvent()
	a = &AuditEntry{}
	a.GetEvent()
	a = nil
	a.GetEvent()
}

func TestAuditEntry_GetExplanation(tt *testing.T) {
	var zeroValue string
	a := &AuditEntry{Explanation: &zeroValue}
	a.GetExplanation()
	a = &AuditEntry{}
	a.GetExplanation()
	a = nil
	a.GetExplanation()
}

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

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

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

func TestAuditEntry_GetHookID(tt *testing.T) {
	var zeroValue int64
	a := &AuditEntry{HookID: &zeroValue}
	a.GetHookID()
	a = &AuditEntry{}
	a.GetHookID()
	a = nil
	a.GetHookID()
}

func TestAuditEntry_GetIsHostedRunner(tt *testing.T) {
	var zeroValue bool
	a := &AuditEntry{IsHostedRunner: &zeroValue}
	a.GetIsHostedRunner()
	a = &AuditEntry{}
	a.GetIsHostedRunner()
	a = nil
	a.GetIsHostedRunner()
}

func TestAuditEntry_GetJobName(tt *testing.T) {
	var zeroValue string
	a := &AuditEntry{JobName: &zeroValue}
	a.GetJobName()
	a = &AuditEntry{}
	a.GetJobName()
	a = nil
	a.GetJobName()
}

func TestAuditEntry_GetLimitedAvailability(tt *testing.T) {
	var zeroValue bool
	a := &AuditEntry{LimitedAvailability: &zeroValue}
	a.GetLimitedAvailability()
	a = &AuditEntry{}
	a.GetLimitedAvailability()
	a = nil
	a.GetLimitedAvailability()
}

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

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

func TestAuditEntry_GetOldUser(tt *testing.T) {
	var zeroValue string
	a := &AuditEntry{OldUser: &zeroValue}
	a.GetOldUser()
	a = &AuditEntry{}
	a.GetOldUser()
	a = nil
	a.GetOldUser()
}

func TestAuditEntry_GetOpenSSHPublicKey(tt *testing.T) {
	var zeroValue string
	a := &AuditEntry{OpenSSHPublicKey: &zeroValue}
	a.GetOpenSSHPublicKey()
	a = &AuditEntry{}
	a.GetOpenSSHPublicKey()
	a = nil
	a.GetOpenSSHPublicKey()
}

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

func TestAuditEntry_GetPreviousVisibility(tt *testing.T) {
	var zeroValue string
	a := &AuditEntry{PreviousVisibility: &zeroValue}
	a.GetPreviousVisibility()
	a = &AuditEntry{}
	a.GetPreviousVisibility()
	a = nil
	a.GetPreviousVisibility()
}

func TestAuditEntry_GetReadOnly(tt *testing.T) {
	var zeroValue string
	a := &AuditEntry{ReadOnly: &zeroValue}
	a.GetReadOnly()
	a = &AuditEntry{}
	a.GetReadOnly()
	a = nil
	a.GetReadOnly()
}

func TestAuditEntry_GetRepo(tt *testing.T) {
	var zeroValue string
	a := &AuditEntry{Repo: &zeroValue}
	a.GetRepo()
	a = &AuditEntry{}
	a.GetRepo()
	a = nil
	a.GetRepo()
}

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

func TestAuditEntry_GetRepositoryPublic(tt *testing.T) {
	var zeroValue bool
	a := &AuditEntry{RepositoryPublic: &zeroValue}
	a.GetRepositoryPublic()
	a = &AuditEntry{}
	a.GetRepositoryPublic()
	a = nil
	a.GetRepositoryPublic()
}

func TestAuditEntry_GetRunnerGroupID(tt *testing.T) {
	var zeroValue int64
	a := &AuditEntry{RunnerGroupID: &zeroValue}
	a.GetRunnerGroupID()
	a = &AuditEntry{}
	a.GetRunnerGroupID()
	a = nil
	a.GetRunnerGroupID()
}

func TestAuditEntry_GetRunnerGroupName(tt *testing.T) {
	var zeroValue string
	a := &AuditEntry{RunnerGroupName: &zeroValue}
	a.GetRunnerGroupName()
	a = &AuditEntry{}
	a.GetRunnerGroupName()
	a = nil
	a.GetRunnerGroupName()
}

func TestAuditEntry_GetRunnerID(tt *testing.T) {
	var zeroValue int64
	a := &AuditEntry{RunnerID: &zeroValue}
	a.GetRunnerID()
	a = &AuditEntry{}
	a.GetRunnerID()
	a = nil
	a.GetRunnerID()
}

func TestAuditEntry_GetRunnerName(tt *testing.T) {
	var zeroValue string
	a := &AuditEntry{RunnerName: &zeroValue}
	a.GetRunnerName()
	a = &AuditEntry{}
	a.GetRunnerName()
	a = nil
	a.GetRunnerName()
}

func TestAuditEntry_GetSourceVersion(tt *testing.T) {
	var zeroValue string
	a := &AuditEntry{SourceVersion: &zeroValue}
	a.GetSourceVersion()
	a = &AuditEntry{}
	a.GetSourceVersion()
	a = nil
	a.GetSourceVersion()
}

func TestAuditEntry_GetStartedAt(tt *testing.T) {
	var zeroValue Timestamp
	a := &AuditEntry{StartedAt: &zeroValue}
	a.GetStartedAt()
	a = &AuditEntry{}
	a.GetStartedAt()
	a = nil
	a.GetStartedAt()
}

func TestAuditEntry_GetTargetLogin(tt *testing.T) {
	var zeroValue string
	a := &AuditEntry{TargetLogin: &zeroValue}
	a.GetTargetLogin()
	a = &AuditEntry{}
	a.GetTargetLogin()
	a = nil
	a.GetTargetLogin()
}

func TestAuditEntry_GetTargetVersion(tt *testing.T) {
	var zeroValue string
	a := &AuditEntry{TargetVersion: &zeroValue}
	a.GetTargetVersion()
	a = &AuditEntry{}
	a.GetTargetVersion()
	a = nil
	a.GetTargetVersion()
}

func TestAuditEntry_GetTeam(tt *testing.T) {
	var zeroValue string
	a := &AuditEntry{Team: &zeroValue}
	a.GetTeam()
	a = &AuditEntry{}
	a.GetTeam()
	a = nil
	a.GetTeam()
}

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

func TestAuditEntry_GetTransportProtocol(tt *testing.T) {
	var zeroValue int
	a := &AuditEntry{TransportProtocol: &zeroValue}
	a.GetTransportProtocol()
	a = &AuditEntry{}
	a.GetTransportProtocol()
	a = nil
	a.GetTransportProtocol()
}

func TestAuditEntry_GetTransportProtocolName(tt *testing.T) {
	var zeroValue string
	a := &AuditEntry{TransportProtocolName: &zeroValue}
	a.GetTransportProtocolName()
	a = &AuditEntry{}
	a.GetTransportProtocolName()
	a = nil
	a.GetTransportProtocolName()
}

func TestAuditEntry_GetTriggerID(tt *testing.T) {
	var zeroValue int64
	a := &AuditEntry{TriggerID: &zeroValue}
	a.GetTriggerID()
	a = &AuditEntry{}
	a.GetTriggerID()
	a = nil
	a.GetTriggerID()
}

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

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

func TestAuditEntry_GetWorkflowID(tt *testing.T) {
	var zeroValue int64
	a := &AuditEntry{WorkflowID: &zeroValue}
	a.GetWorkflowID()
	a = &AuditEntry{}
	a.GetWorkflowID()
	a = nil
	a.GetWorkflowID()
}

func TestAuditEntry_GetWorkflowRunID(tt *testing.T) {
	var zeroValue int64
	a := &AuditEntry{WorkflowRunID: &zeroValue}
	a.GetWorkflowRunID()
	a = &AuditEntry{}
	a.GetWorkflowRunID()
	a = nil
	a.GetWorkflowRunID()
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func TestCombinedStatus_GetTotalCount(tt *testing.T) {
	var zeroValue int
	c := &CombinedStatus{TotalCount: &zeroValue}
	c.GetTotalCount()
	c = &CombinedStatus{}
	c.GetTotalCount()
	c = nil
	c.GetTotalCount()
}

func TestComment_GetCreatedAt(tt *testing.T) {
	var zeroValue time.Time
	c := &Comment{CreatedAt: &zeroValue}
	c.GetCreatedAt()
	c = &Comment{}
	c.GetCreatedAt()
	c = nil
	c.GetCreatedAt()
}

func TestCommentStats_GetTotalCommitComments(tt *testing.T) {
	var zeroValue int
	c := &CommentStats{TotalCommitComments: &zeroValue}
	c.GetTotalCommitComments()
	c = &CommentStats{}
	c.GetTotalCommitComments()
	c = nil
	c.GetTotalCommitComments()
}

func TestCommentStats_GetTotalGistComments(tt *testing.T) {
	var zeroValue int
	c := &CommentStats{TotalGistComments: &zeroValue}
	c.GetTotalGistComments()
	c = &CommentStats{}
	c.GetTotalGistComments()
	c = nil
	c.GetTotalGistComments()
}

func TestCommentStats_GetTotalIssueComments(tt *testing.T) {
	var zeroValue int
	c := &CommentStats{TotalIssueComments: &zeroValue}
	c.GetTotalIssueComments()
	c = &CommentStats{}
	c.GetTotalIssueComments()
	c = nil
	c.GetTotalIssueComments()
}

func TestCommentStats_GetTotalPullRequestComments(tt *testing.T) {
	var zeroValue int
	c := &CommentStats{TotalPullRequestComments: &zeroValue}
	c.GetTotalPullRequestComments()
	c = &CommentStats{}
	c.GetTotalPullRequestComments()
	c = nil
	c.GetTotalPullRequestComments()
}

func TestCommit_GetAuthor(tt *testing.T) {
	c := &Commit{}
	c.GetAuthor()
	c = nil
	c.GetAuthor()
}

func TestCommit_GetCommentCount(tt *testing.T) {
	var zeroValue int
	c := &Commit{CommentCount: &zeroValue}
	c.GetCommentCount()
	c = &Commit{}
	c.GetCommentCount()
	c = nil
	c.GetCommentCount()
}

func TestCommit_GetCommitter(tt *testing.T) {
	c := &Commit{}
	c.GetCommitter()
	c = nil
	c.GetCommitter()
}

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

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

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

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

func TestCommit_GetStats(tt *testing.T) {
	c := &Commit{}
	c.GetStats()
	c = nil
	c.GetStats()
}

func TestCommit_GetTree(tt *testing.T) {
	c := &Commit{}
	c.GetTree()
	c = nil
	c.GetTree()
}

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

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

func TestCommitAuthor_GetDate(tt *testing.T) {
	var zeroValue time.Time
	c := &CommitAuthor{Date: &zeroValue}
	c.GetDate()
	c = &CommitAuthor{}
	c.GetDate()
	c = nil
	c.GetDate()
}

func TestCommitAuthor_GetEmail(tt *testing.T) {
	var zeroValue string
	c := &CommitAuthor{Email: &zeroValue}
	c.GetEmail()
	c = &CommitAuthor{}
	c.GetEmail()
	c = nil
	c.GetEmail()
}

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

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

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

func TestCommitCommentEvent_GetComment(tt *testing.T) {
	c := &CommitCommentEvent{}
	c.GetComment()
	c = nil
	c.GetComment()
}

func TestCommitCommentEvent_GetInstallation(tt *testing.T) {
	c := &CommitCommentEvent{}
	c.GetInstallation()
	c = nil
	c.GetInstallation()
}

func TestCommitCommentEvent_GetRepo(tt *testing.T) {
	c := &CommitCommentEvent{}
	c.GetRepo()
	c = nil
	c.GetRepo()
}

func TestCommitCommentEvent_GetSender(tt *testing.T) {
	c := &CommitCommentEvent{}
	c.GetSender()
	c = nil
	c.GetSender()
}

func TestCommitFile_GetAdditions(tt *testing.T) {
	var zeroValue int
	c := &CommitFile{Additions: &zeroValue}
	c.GetAdditions()
	c = &CommitFile{}
	c.GetAdditions()
	c = nil
	c.GetAdditions()
}

func TestCommitFile_GetBlobURL(tt *testing.T) {
	var zeroValue string
	c := &CommitFile{BlobURL: &zeroValue}
	c.GetBlobURL()
	c = &CommitFile{}
	c.GetBlobURL()
	c = nil
	c.GetBlobURL()
}

func TestCommitFile_GetChanges(tt *testing.T) {
	var zeroValue int
	c := &CommitFile{Changes: &zeroValue}
	c.GetChanges()
	c = &CommitFile{}
	c.GetChanges()
	c = nil
	c.GetChanges()
}

func TestCommitFile_GetContentsURL(tt *testing.T) {
	var zeroValue string
	c := &CommitFile{ContentsURL: &zeroValue}
	c.GetContentsURL()
	c = &CommitFile{}
	c.GetContentsURL()
	c = nil
	c.GetContentsURL()
}

func TestCommitFile_GetDeletions(tt *testing.T) {
	var zeroValue int
	c := &CommitFile{Deletions: &zeroValue}
	c.GetDeletions()
	c = &CommitFile{}
	c.GetDeletions()
	c = nil
	c.GetDeletions()
}

func TestCommitFile_GetFilename(tt *testing.T) {
	var zeroValue string
	c := &CommitFile{Filename: &zeroValue}
	c.GetFilename()
	c = &CommitFile{}
	c.GetFilename()
	c = nil
	c.GetFilename()
}

func TestCommitFile_GetPatch(tt *testing.T) {
	var zeroValue string
	c := &CommitFile{Patch: &zeroValue}
	c.GetPatch()
	c = &CommitFile{}
	c.GetPatch()
	c = nil
	c.GetPatch()
}

func TestCommitFile_GetPreviousFilename(tt *testing.T) {
	var zeroValue string
	c := &CommitFile{PreviousFilename: &zeroValue}
	c.GetPreviousFilename()
	c = &CommitFile{}
	c.GetPreviousFilename()
	c = nil
	c.GetPreviousFilename()
}

func TestCommitFile_GetRawURL(tt *testing.T) {
	var zeroValue string
	c := &CommitFile{RawURL: &zeroValue}
	c.GetRawURL()
	c = &CommitFile{}
	c.GetRawURL()
	c = nil
	c.GetRawURL()
}

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

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

func TestCommitResult_GetAuthor(tt *testing.T) {
	c := &CommitResult{}
	c.GetAuthor()
	c = nil
	c.GetAuthor()
}

func TestCommitResult_GetCommentsURL(tt *testing.T) {
	var zeroValue string
	c := &CommitResult{CommentsURL: &zeroValue}
	c.GetCommentsURL()
	c = &CommitResult{}
	c.GetCommentsURL()
	c = nil
	c.GetCommentsURL()
}

func TestCommitResult_GetCommit(tt *testing.T) {
	c := &CommitResult{}
	c.GetCommit()
	c = nil
	c.GetCommit()
}

func TestCommitResult_GetCommitter(tt *testing.T) {
	c := &CommitResult{}
	c.GetCommitter()
	c = nil
	c.GetCommitter()
}

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

func TestCommitResult_GetRepository(tt *testing.T) {
	c := &CommitResult{}
	c.GetRepository()
	c = nil
	c.GetRepository()
}

func TestCommitResult_GetScore(tt *testing.T) {
	c := &CommitResult{}
	c.GetScore()
	c = nil
	c.GetScore()
}

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

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

func TestCommitsComparison_GetAheadBy(tt *testing.T) {
	var zeroValue int
	c := &CommitsComparison{AheadBy: &zeroValue}
	c.GetAheadBy()
	c = &CommitsComparison{}
	c.GetAheadBy()
	c = nil
	c.GetAheadBy()
}

func TestCommitsComparison_GetBaseCommit(tt *testing.T) {
	c := &CommitsComparison{}
	c.GetBaseCommit()
	c = nil
	c.GetBaseCommit()
}

func TestCommitsComparison_GetBehindBy(tt *testing.T) {
	var zeroValue int
	c := &CommitsComparison{BehindBy: &zeroValue}
	c.GetBehindBy()
	c = &CommitsComparison{}
	c.GetBehindBy()
	c = nil
	c.GetBehindBy()
}

func TestCommitsComparison_GetDiffURL(tt *testing.T) {
	var zeroValue string
	c := &CommitsComparison{DiffURL: &zeroValue}
	c.GetDiffURL()
	c = &CommitsComparison{}
	c.GetDiffURL()
	c = nil
	c.GetDiffURL()
}

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

func TestCommitsComparison_GetMergeBaseCommit(tt *testing.T) {
	c := &CommitsComparison{}
	c.GetMergeBaseCommit()
	c = nil
	c.GetMergeBaseCommit()
}

func TestCommitsComparison_GetPatchURL(tt *testing.T) {
	var zeroValue string
	c := &CommitsComparison{PatchURL: &zeroValue}
	c.GetPatchURL()
	c = &CommitsComparison{}
	c.GetPatchURL()
	c = nil
	c.GetPatchURL()
}

func TestCommitsComparison_GetPermalinkURL(tt *testing.T) {
	var zeroValue string
	c := &CommitsComparison{PermalinkURL: &zeroValue}
	c.GetPermalinkURL()
	c = &CommitsComparison{}
	c.GetPermalinkURL()
	c = nil
	c.GetPermalinkURL()
}

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

func TestCommitsComparison_GetTotalCommits(tt *testing.T) {
	var zeroValue int
	c := &CommitsComparison{TotalCommits: &zeroValue}
	c.GetTotalCommits()
	c = &CommitsComparison{}
	c.GetTotalCommits()
	c = nil
	c.GetTotalCommits()
}

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

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

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

func TestCommitStats_GetAdditions(tt *testing.T) {
	var zeroValue int
	c := &CommitStats{Additions: &zeroValue}
	c.GetAdditions()
	c = &CommitStats{}
	c.GetAdditions()
	c = nil
	c.GetAdditions()
}

func TestCommitStats_GetDeletions(tt *testing.T) {
	var zeroValue int
	c := &CommitStats{Deletions: &zeroValue}
	c.GetDeletions()
	c = &CommitStats{}
	c.GetDeletions()
	c = nil
	c.GetDeletions()
}

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

func TestCommunityHealthFiles_GetCodeOfConduct(tt *testing.T) {
	c := &CommunityHealthFiles{}
	c.GetCodeOfConduct()
	c = nil
	c.GetCodeOfConduct()
}

func TestCommunityHealthFiles_GetCodeOfConductFile(tt *testing.T) {
	c := &CommunityHealthFiles{}
	c.GetCodeOfConductFile()
	c = nil
	c.GetCodeOfConductFile()
}

func TestCommunityHealthFiles_GetContributing(tt *testing.T) {
	c := &CommunityHealthFiles{}
	c.GetContributing()
	c = nil
	c.GetContributing()
}

func TestCommunityHealthFiles_GetIssueTemplate(tt *testing.T) {
	c := &CommunityHealthFiles{}
	c.GetIssueTemplate()
	c = nil
	c.GetIssueTemplate()
}

func TestCommunityHealthFiles_GetLicense(tt *testing.T) {
	c := &CommunityHealthFiles{}
	c.GetLicense()
	c = nil
	c.GetLicense()
}

func TestCommunityHealthFiles_GetPullRequestTemplate(tt *testing.T) {
	c := &CommunityHealthFiles{}
	c.GetPullRequestTemplate()
	c = nil
	c.GetPullRequestTemplate()
}

func TestCommunityHealthFiles_GetReadme(tt *testing.T) {
	c := &CommunityHealthFiles{}
	c.GetReadme()
	c = nil
	c.GetReadme()
}

func TestCommunityHealthMetrics_GetContentReportsEnabled(tt *testing.T) {
	var zeroValue bool
	c := &CommunityHealthMetrics{ContentReportsEnabled: &zeroValue}
	c.GetContentReportsEnabled()
	c = &CommunityHealthMetrics{}
	c.GetContentReportsEnabled()
	c = nil
	c.GetContentReportsEnabled()
}

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

func TestCommunityHealthMetrics_GetDocumentation(tt *testing.T) {
	var zeroValue string
	c := &CommunityHealthMetrics{Documentation: &zeroValue}
	c.GetDocumentation()
	c = &CommunityHealthMetrics{}
	c.GetDocumentation()
	c = nil
	c.GetDocumentation()
}

func TestCommunityHealthMetrics_GetFiles(tt *testing.T) {
	c := &CommunityHealthMetrics{}
	c.GetFiles()
	c = nil
	c.GetFiles()
}

func TestCommunityHealthMetrics_GetHealthPercentage(tt *testing.T) {
	var zeroValue int
	c := &CommunityHealthMetrics{HealthPercentage: &zeroValue}
	c.GetHealthPercentage()
	c = &CommunityHealthMetrics{}
	c.GetHealthPercentage()
	c = nil
	c.GetHealthPercentage()
}

func TestCommunityHealthMetrics_GetUpdatedAt(tt *testing.T) {
	var zeroValue time.Time
	c := &CommunityHealthMetrics{UpdatedAt: &zeroValue}
	c.GetUpdatedAt()
	c = &CommunityHealthMetrics{}
	c.GetUpdatedAt()
	c = nil
	c.GetUpdatedAt()
}

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

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

func TestContentReference_GetReference(tt *testing.T) {
	var zeroValue string
	c := &ContentReference{Reference: &zeroValue}
	c.GetReference()
	c = &ContentReference{}
	c.GetReference()
	c = nil
	c.GetReference()
}

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

func TestContentReferenceEvent_GetContentReference(tt *testing.T) {
	c := &ContentReferenceEvent{}
	c.GetContentReference()
	c = nil
	c.GetContentReference()
}

func TestContentReferenceEvent_GetInstallation(tt *testing.T) {
	c := &ContentReferenceEvent{}
	c.GetInstallation()
	c = nil
	c.GetInstallation()
}

func TestContentReferenceEvent_GetRepo(tt *testing.T) {
	c := &ContentReferenceEvent{}
	c.GetRepo()
	c = nil
	c.GetRepo()
}

func TestContentReferenceEvent_GetSender(tt *testing.T) {
	c := &ContentReferenceEvent{}
	c.GetSender()
	c = nil
	c.GetSender()
}

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

func TestContributor_GetContributions(tt *testing.T) {
	var zeroValue int
	c := &Contributor{Contributions: &zeroValue}
	c.GetContributions()
	c = &Contributor{}
	c.GetContributions()
	c = nil
	c.GetContributions()
}

func TestContributor_GetEmail(tt *testing.T) {
	var zeroValue string
	c := &Contributor{Email: &zeroValue}
	c.GetEmail()
	c = &Contributor{}
	c.GetEmail()
	c = nil
	c.GetEmail()
}

func TestContributor_GetEventsURL(tt *testing.T) {
	var zeroValue string
	c := &Contributor{EventsURL: &zeroValue}
	c.GetEventsURL()
	c = &Contributor{}
	c.GetEventsURL()
	c = nil
	c.GetEventsURL()
}

func TestContributor_GetFollowersURL(tt *testing.T) {
	var zeroValue string
	c := &Contributor{FollowersURL: &zeroValue}
	c.GetFollowersURL()
	c = &Contributor{}
	c.GetFollowersURL()
	c = nil
	c.GetFollowersURL()
}

func TestContributor_GetFollowingURL(tt *testing.T) {
	var zeroValue string
	c := &Contributor{FollowingURL: &zeroValue}
	c.GetFollowingURL()
	c = &Contributor{}
	c.GetFollowingURL()
	c = nil
	c.GetFollowingURL()
}

func TestContributor_GetGistsURL(tt *testing.T) {
	var zeroValue string
	c := &Contributor{GistsURL: &zeroValue}
	c.GetGistsURL()
	c = &Contributor{}
	c.GetGistsURL()
	c = nil
	c.GetGistsURL()
}

func TestContributor_GetGravatarID(tt *testing.T) {
	var zeroValue string
	c := &Contributor{GravatarID: &zeroValue}
	c.GetGravatarID()
	c = &Contributor{}
	c.GetGravatarID()
	c = nil
	c.GetGravatarID()
}

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

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

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

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

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

func TestContributor_GetOrganizationsURL(tt *testing.T) {
	var zeroValue string
	c := &Contributor{OrganizationsURL: &zeroValue}
	c.GetOrganizationsURL()
	c = &Contributor{}
	c.GetOrganizationsURL()
	c = nil
	c.GetOrganizationsURL()
}

func TestContributor_GetReceivedEventsURL(tt *testing.T) {
	var zeroValue string
	c := &Contributor{ReceivedEventsURL: &zeroValue}
	c.GetReceivedEventsURL()
	c = &Contributor{}
	c.GetReceivedEventsURL()
	c = nil
	c.GetReceivedEventsURL()
}

func TestContributor_GetReposURL(tt *testing.T) {
	var zeroValue string
	c := &Contributor{ReposURL: &zeroValue}
	c.GetReposURL()
	c = &Contributor{}
	c.GetReposURL()
	c = nil
	c.GetReposURL()
}

func TestContributor_GetSiteAdmin(tt *testing.T) {
	var zeroValue bool
	c := &Contributor{SiteAdmin: &zeroValue}
	c.GetSiteAdmin()
	c = &Contributor{}
	c.GetSiteAdmin()
	c = nil
	c.GetSiteAdmin()
}

func TestContributor_GetStarredURL(tt *testing.T) {
	var zeroValue string
	c := &Contributor{StarredURL: &zeroValue}
	c.GetStarredURL()
	c = &Contributor{}
	c.GetStarredURL()
	c = nil
	c.GetStarredURL()
}

func TestContributor_GetSubscriptionsURL(tt *testing.T) {
	var zeroValue string
	c := &Contributor{SubscriptionsURL: &zeroValue}
	c.GetSubscriptionsURL()
	c = &Contributor{}
	c.GetSubscriptionsURL()
	c = nil
	c.GetSubscriptionsURL()
}

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

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

func TestContributorStats_GetAuthor(tt *testing.T) {
	c := &ContributorStats{}
	c.GetAuthor()
	c = nil
	c.GetAuthor()
}

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

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

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

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

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

func TestCreateCheckRunOptions_GetOutput(tt *testing.T) {
	c := &CreateCheckRunOptions{}
	c.GetOutput()
	c = nil
	c.GetOutput()
}

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

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

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

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

func TestCreateEvent_GetInstallation(tt *testing.T) {
	c := &CreateEvent{}
	c.GetInstallation()
	c = nil
	c.GetInstallation()
}

func TestCreateEvent_GetMasterBranch(tt *testing.T) {
	var zeroValue string
	c := &CreateEvent{MasterBranch: &zeroValue}
	c.GetMasterBranch()
	c = &CreateEvent{}
	c.GetMasterBranch()
	c = nil
	c.GetMasterBranch()
}

func TestCreateEvent_GetPusherType(tt *testing.T) {
	var zeroValue string
	c := &CreateEvent{PusherType: &zeroValue}
	c.GetPusherType()
	c = &CreateEvent{}
	c.GetPusherType()
	c = nil
	c.GetPusherType()
}

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

func TestCreateEvent_GetRefType(tt *testing.T) {
	var zeroValue string
	c := &CreateEvent{RefType: &zeroValue}
	c.GetRefType()
	c = &CreateEvent{}
	c.GetRefType()
	c = nil
	c.GetRefType()
}

func TestCreateEvent_GetRepo(tt *testing.T) {
	c := &CreateEvent{}
	c.GetRepo()
	c = nil
	c.GetRepo()
}

func TestCreateEvent_GetSender(tt *testing.T) {
	c := &CreateEvent{}
	c.GetSender()
	c = nil
	c.GetSender()
}

func TestCreateOrgInvitationOptions_GetEmail(tt *testing.T) {
	var zeroValue string
	c := &CreateOrgInvitationOptions{Email: &zeroValue}
	c.GetEmail()
	c = &CreateOrgInvitationOptions{}
	c.GetEmail()
	c = nil
	c.GetEmail()
}

func TestCreateOrgInvitationOptions_GetInviteeID(tt *testing.T) {
	var zeroValue int64
	c := &CreateOrgInvitationOptions{InviteeID: &zeroValue}
	c.GetInviteeID()
	c = &CreateOrgInvitationOptions{}
	c.GetInviteeID()
	c = nil
	c.GetInviteeID()
}

func TestCreateOrgInvitationOptions_GetRole(tt *testing.T) {
	var zeroValue string
	c := &CreateOrgInvitationOptions{Role: &zeroValue}
	c.GetRole()
	c = &CreateOrgInvitationOptions{}
	c.GetRole()
	c = nil
	c.GetRole()
}

func TestCreateRunnerGroupRequest_GetAllowsPublicRepositories(tt *testing.T) {
	var zeroValue bool
	c := &CreateRunnerGroupRequest{AllowsPublicRepositories: &zeroValue}
	c.GetAllowsPublicRepositories()
	c = &CreateRunnerGroupRequest{}
	c.GetAllowsPublicRepositories()
	c = nil
	c.GetAllowsPublicRepositories()
}

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

func TestCreateRunnerGroupRequest_GetVisibility(tt *testing.T) {
	var zeroValue string
	c := &CreateRunnerGroupRequest{Visibility: &zeroValue}
	c.GetVisibility()
	c = &CreateRunnerGroupRequest{}
	c.GetVisibility()
	c = nil
	c.GetVisibility()
}

func TestCreateUpdateEnvironment_GetDeploymentBranchPolicy(tt *testing.T) {
	c := &CreateUpdateEnvironment{}
	c.GetDeploymentBranchPolicy()
	c = nil
	c.GetDeploymentBranchPolicy()
}

func TestCreateUpdateEnvironment_GetWaitTimer(tt *testing.T) {
	var zeroValue int
	c := &CreateUpdateEnvironment{WaitTimer: &zeroValue}
	c.GetWaitTimer()
	c = &CreateUpdateEnvironment{}
	c.GetWaitTimer()
	c = nil
	c.GetWaitTimer()
}

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

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

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

func TestDeleteEvent_GetInstallation(tt *testing.T) {
	d := &DeleteEvent{}
	d.GetInstallation()
	d = nil
	d.GetInstallation()
}

func TestDeleteEvent_GetPusherType(tt *testing.T) {
	var zeroValue string
	d := &DeleteEvent{PusherType: &zeroValue}
	d.GetPusherType()
	d = &DeleteEvent{}
	d.GetPusherType()
	d = nil
	d.GetPusherType()
}

func TestDeleteEvent_GetRef(tt *testing.T) {
	var zeroValue string
	d := &DeleteEvent{Ref: &zeroValue}
	d.GetRef()
	d = &DeleteEvent{}
	d.GetRef()
	d = nil
	d.GetRef()
}

func TestDeleteEvent_GetRefType(tt *testing.T) {
	var zeroValue string
	d := &DeleteEvent{RefType: &zeroValue}
	d.GetRefType()
	d = &DeleteEvent{}
	d.GetRefType()
	d = nil
	d.GetRefType()
}

func TestDeleteEvent_GetRepo(tt *testing.T) {
	d := &DeleteEvent{}
	d.GetRepo()
	d = nil
	d.GetRepo()
}

func TestDeleteEvent_GetSender(tt *testing.T) {
	d := &DeleteEvent{}
	d.GetSender()
	d = nil
	d.GetSender()
}

func TestDeployKeyEvent_GetAction(tt *testing.T) {
	var zeroValue string
	d := &DeployKeyEvent{Action: &zeroValue}
	d.GetAction()
	d = &DeployKeyEvent{}
	d.GetAction()
	d = nil
	d.GetAction()
}

func TestDeployKeyEvent_GetInstallation(tt *testing.T) {
	d := &DeployKeyEvent{}
	d.GetInstallation()
	d = nil
	d.GetInstallation()
}

func TestDeployKeyEvent_GetKey(tt *testing.T) {
	d := &DeployKeyEvent{}
	d.GetKey()
	d = nil
	d.GetKey()
}

func TestDeployKeyEvent_GetOrganization(tt *testing.T) {
	d := &DeployKeyEvent{}
	d.GetOrganization()
	d = nil
	d.GetOrganization()
}

func TestDeployKeyEvent_GetRepo(tt *testing.T) {
	d := &DeployKeyEvent{}
	d.GetRepo()
	d = nil
	d.GetRepo()
}

func TestDeployKeyEvent_GetSender(tt *testing.T) {
	d := &DeployKeyEvent{}
	d.GetSender()
	d = nil
	d.GetSender()
}

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

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

func TestDeployment_GetDescription(tt *testing.T) {
	var zeroValue string
	d := &Deployment{Description: &zeroValue}
	d.GetDescription()
	d = &Deployment{}
	d.GetDescription()
	d = nil
	d.GetDescription()
}

func TestDeployment_GetEnvironment(tt *testing.T) {
	var zeroValue string
	d := &Deployment{Environment: &zeroValue}
	d.GetEnvironment()
	d = &Deployment{}
	d.GetEnvironment()
	d = nil
	d.GetEnvironment()
}

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

func TestDeployment_GetNodeID(tt *testing.T) {
	var zeroValue string
	d := &Deployment{NodeID: &zeroValue}
	d.GetNodeID()
	d = &Deployment{}
	d.GetNodeID()
	d = nil
	d.GetNodeID()
}

func TestDeployment_GetRef(tt *testing.T) {
	var zeroValue string
	d := &Deployment{Ref: &zeroValue}
	d.GetRef()
	d = &Deployment{}
	d.GetRef()
	d = nil
	d.GetRef()
}

func TestDeployment_GetRepositoryURL(tt *testing.T) {
	var zeroValue string
	d := &Deployment{RepositoryURL: &zeroValue}
	d.GetRepositoryURL()
	d = &Deployment{}
	d.GetRepositoryURL()
	d = nil
	d.GetRepositoryURL()
}

func TestDeployment_GetSHA(tt *testing.T) {
	var zeroValue string
	d := &Deployment{SHA: &zeroValue}
	d.GetSHA()
	d = &Deployment{}
	d.GetSHA()
	d = nil
	d.GetSHA()
}

func TestDeployment_GetStatusesURL(tt *testing.T) {
	var zeroValue string
	d := &Deployment{StatusesURL: &zeroValue}
	d.GetStatusesURL()
	d = &Deployment{}
	d.GetStatusesURL()
	d = nil
	d.GetStatusesURL()
}

func TestDeployment_GetTask(tt *testing.T) {
	var zeroValue string
	d := &Deployment{Task: &zeroValue}
	d.GetTask()
	d = &Deployment{}
	d.GetTask()
	d = nil
	d.GetTask()
}

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

func TestDeployment_GetURL(tt *testing.T) {
	var zeroValue string
	d := &Deployment{URL: &zeroValue}
	d.GetURL()
	d = &Deployment{}
	d.GetURL()
	d = nil
	d.GetURL()
}

func TestDeploymentEvent_GetDeployment(tt *testing.T) {
	d := &DeploymentEvent{}
	d.GetDeployment()
	d = nil
	d.GetDeployment()
}

func TestDeploymentEvent_GetInstallation(tt *testing.T) {
	d := &DeploymentEvent{}
	d.GetInstallation()
	d = nil
	d.GetInstallation()
}

func TestDeploymentEvent_GetRepo(tt *testing.T) {
	d := &DeploymentEvent{}
	d.GetRepo()
	d = nil
	d.GetRepo()
}

func TestDeploymentEvent_GetSender(tt *testing.T) {
	d := &DeploymentEvent{}
	d.GetSender()
	d = nil
	d.GetSender()
}

func TestDeploymentRequest_GetAutoMerge(tt *testing.T) {
	var zeroValue bool
	d := &DeploymentRequest{AutoMerge: &zeroValue}
	d.GetAutoMerge()
	d = &DeploymentRequest{}
	d.GetAutoMerge()
	d = nil
	d.GetAutoMerge()
}

func TestDeploymentRequest_GetDescription(tt *testing.T) {
	var zeroValue string
	d := &DeploymentRequest{Description: &zeroValue}
	d.GetDescription()
	d = &DeploymentRequest{}
	d.GetDescription()
	d = nil
	d.GetDescription()
}

func TestDeploymentRequest_GetEnvironment(tt *testing.T) {
	var zeroValue string
	d := &DeploymentRequest{Environment: &zeroValue}
	d.GetEnvironment()
	d = &DeploymentRequest{}
	d.GetEnvironment()
	d = nil
	d.GetEnvironment()
}

func TestDeploymentRequest_GetProductionEnvironment(tt *testing.T) {
	var zeroValue bool
	d := &DeploymentRequest{ProductionEnvironment: &zeroValue}
	d.GetProductionEnvironment()
	d = &DeploymentRequest{}
	d.GetProductionEnvironment()
	d = nil
	d.GetProductionEnvironment()
}

func TestDeploymentRequest_GetRef(tt *testing.T) {
	var zeroValue string
	d := &DeploymentRequest{Ref: &zeroValue}
	d.GetRef()
	d = &DeploymentRequest{}
	d.GetRef()
	d = nil
	d.GetRef()
}

func TestDeploymentRequest_GetRequiredContexts(tt *testing.T) {
	var zeroValue []string
	d := &DeploymentRequest{RequiredContexts: &zeroValue}
	d.GetRequiredContexts()
	d = &DeploymentRequest{}
	d.GetRequiredContexts()
	d = nil
	d.GetRequiredContexts()
}

func TestDeploymentRequest_GetTask(tt *testing.T) {
	var zeroValue string
	d := &DeploymentRequest{Task: &zeroValue}
	d.GetTask()
	d = &DeploymentRequest{}
	d.GetTask()
	d = nil
	d.GetTask()
}

func TestDeploymentRequest_GetTransientEnvironment(tt *testing.T) {
	var zeroValue bool
	d := &DeploymentRequest{TransientEnvironment: &zeroValue}
	d.GetTransientEnvironment()
	d = &DeploymentRequest{}
	d.GetTransientEnvironment()
	d = nil
	d.GetTransientEnvironment()
}

func TestDeploymentStatus_GetCreatedAt(tt *testing.T) {
	var zeroValue Timestamp
	d := &DeploymentStatus{CreatedAt: &zeroValue}
	d.GetCreatedAt()
	d = &DeploymentStatus{}
	d.GetCreatedAt()
	d = nil
	d.GetCreatedAt()
}

func TestDeploymentStatus_GetCreator(tt *testing.T) {
	d := &DeploymentStatus{}
	d.GetCreator()
	d = nil
	d.GetCreator()
}

func TestDeploymentStatus_GetDeploymentURL(tt *testing.T) {
	var zeroValue string
	d := &DeploymentStatus{DeploymentURL: &zeroValue}
	d.GetDeploymentURL()
	d = &DeploymentStatus{}
	d.GetDeploymentURL()
	d = nil
	d.GetDeploymentURL()
}

func TestDeploymentStatus_GetDescription(tt *testing.T) {
	var zeroValue string
	d := &DeploymentStatus{Description: &zeroValue}
	d.GetDescription()
	d = &DeploymentStatus{}
	d.GetDescription()
	d = nil
	d.GetDescription()
}

func TestDeploymentStatus_GetEnvironment(tt *testing.T) {
	var zeroValue string
	d := &DeploymentStatus{Environment: &zeroValue}
	d.GetEnvironment()
	d = &DeploymentStatus{}
	d.GetEnvironment()
	d = nil
	d.GetEnvironment()
}

func TestDeploymentStatus_GetEnvironmentURL(tt *testing.T) {
	var zeroValue string
	d := &DeploymentStatus{EnvironmentURL: &zeroValue}
	d.GetEnvironmentURL()
	d = &DeploymentStatus{}
	d.GetEnvironmentURL()
	d = nil
	d.GetEnvironmentURL()
}

func TestDeploymentStatus_GetID(tt *testing.T) {
	var zeroValue int64
	d := &DeploymentStatus{ID: &zeroValue}
	d.GetID()
	d = &DeploymentStatus{}
	d.GetID()
	d = nil
	d.GetID()
}

func TestDeploymentStatus_GetLogURL(tt *testing.T) {
	var zeroValue string
	d := &DeploymentStatus{LogURL: &zeroValue}
	d.GetLogURL()
	d = &DeploymentStatus{}
	d.GetLogURL()
	d = nil
	d.GetLogURL()
}

func TestDeploymentStatus_GetNodeID(tt *testing.T) {
	var zeroValue string
	d := &DeploymentStatus{NodeID: &zeroValue}
	d.GetNodeID()
	d = &DeploymentStatus{}
	d.GetNodeID()
	d = nil
	d.GetNodeID()
}

func TestDeploymentStatus_GetRepositoryURL(tt *testing.T) {
	var zeroValue string
	d := &DeploymentStatus{RepositoryURL: &zeroValue}
	d.GetRepositoryURL()
	d = &DeploymentStatus{}
	d.GetRepositoryURL()
	d = nil
	d.GetRepositoryURL()
}

func TestDeploymentStatus_GetState(tt *testing.T) {
	var zeroValue string
	d := &DeploymentStatus{State: &zeroValue}
	d.GetState()
	d = &DeploymentStatus{}
	d.GetState()
	d = nil
	d.GetState()
}

func TestDeploymentStatus_GetTargetURL(tt *testing.T) {
	var zeroValue string
	d := &DeploymentStatus{TargetURL: &zeroValue}
	d.GetTargetURL()
	d = &DeploymentStatus{}
	d.GetTargetURL()
	d = nil
	d.GetTargetURL()
}

func TestDeploymentStatus_GetUpdatedAt(tt *testing.T) {
	var zeroValue Timestamp
	d := &DeploymentStatus{UpdatedAt: &zeroValue}
	d.GetUpdatedAt()
	d = &DeploymentStatus{}
	d.GetUpdatedAt()
	d = nil
	d.GetUpdatedAt()
}

func TestDeploymentStatus_GetURL(tt *testing.T) {
	var zeroValue string
	d := &DeploymentStatus{URL: &zeroValue}
	d.GetURL()
	d = &DeploymentStatus{}
	d.GetURL()
	d = nil
	d.GetURL()
}

func TestDeploymentStatusEvent_GetDeployment(tt *testing.T) {
	d := &DeploymentStatusEvent{}
	d.GetDeployment()
	d = nil
	d.GetDeployment()
}

func TestDeploymentStatusEvent_GetDeploymentStatus(tt *testing.T) {
	d := &DeploymentStatusEvent{}
	d.GetDeploymentStatus()
	d = nil
	d.GetDeploymentStatus()
}

func TestDeploymentStatusEvent_GetInstallation(tt *testing.T) {
	d := &DeploymentStatusEvent{}
	d.GetInstallation()
	d = nil
	d.GetInstallation()
}

func TestDeploymentStatusEvent_GetRepo(tt *testing.T) {
	d := &DeploymentStatusEvent{}
	d.GetRepo()
	d = nil
	d.GetRepo()
}

func TestDeploymentStatusEvent_GetSender(tt *testing.T) {
	d := &DeploymentStatusEvent{}
	d.GetSender()
	d = nil
	d.GetSender()
}

func TestDeploymentStatusRequest_GetAutoInactive(tt *testing.T) {
	var zeroValue bool
	d := &DeploymentStatusRequest{AutoInactive: &zeroValue}
	d.GetAutoInactive()
	d = &DeploymentStatusRequest{}
	d.GetAutoInactive()
	d = nil
	d.GetAutoInactive()
}

func TestDeploymentStatusRequest_GetDescription(tt *testing.T) {
	var zeroValue string
	d := &DeploymentStatusRequest{Description: &zeroValue}
	d.GetDescription()
	d = &DeploymentStatusRequest{}
	d.GetDescription()
	d = nil
	d.GetDescription()
}

func TestDeploymentStatusRequest_GetEnvironment(tt *testing.T) {
	var zeroValue string
	d := &DeploymentStatusRequest{Environment: &zeroValue}
	d.GetEnvironment()
	d = &DeploymentStatusRequest{}
	d.GetEnvironment()
	d = nil
	d.GetEnvironment()
}

func TestDeploymentStatusRequest_GetEnvironmentURL(tt *testing.T) {
	var zeroValue string
	d := &DeploymentStatusRequest{EnvironmentURL: &zeroValue}
	d.GetEnvironmentURL()
	d = &DeploymentStatusRequest{}
	d.GetEnvironmentURL()
	d = nil
	d.GetEnvironmentURL()
}

func TestDeploymentStatusRequest_GetLogURL(tt *testing.T) {
	var zeroValue string
	d := &DeploymentStatusRequest{LogURL: &zeroValue}
	d.GetLogURL()
	d = &DeploymentStatusRequest{}
	d.GetLogURL()
	d = nil
	d.GetLogURL()
}

func TestDeploymentStatusRequest_GetState(tt *testing.T) {
	var zeroValue string
	d := &DeploymentStatusRequest{State: &zeroValue}
	d.GetState()
	d = &DeploymentStatusRequest{}
	d.GetState()
	d = nil
	d.GetState()
}

func TestDiscussion_GetActiveLockReason(tt *testing.T) {
	var zeroValue string
	d := &Discussion{ActiveLockReason: &zeroValue}
	d.GetActiveLockReason()
	d = &Discussion{}
	d.GetActiveLockReason()
	d = nil
	d.GetActiveLockReason()
}

func TestDiscussion_GetAnswerChosenAt(tt *testing.T) {
	var zeroValue Timestamp
	d := &Discussion{AnswerChosenAt: &zeroValue}
	d.GetAnswerChosenAt()
	d = &Discussion{}
	d.GetAnswerChosenAt()
	d = nil
	d.GetAnswerChosenAt()
}

func TestDiscussion_GetAnswerChosenBy(tt *testing.T) {
	var zeroValue string
	d := &Discussion{AnswerChosenBy: &zeroValue}
	d.GetAnswerChosenBy()
	d = &Discussion{}
	d.GetAnswerChosenBy()
	d = nil
	d.GetAnswerChosenBy()
}

func TestDiscussion_GetAnswerHTMLURL(tt *testing.T) {
	var zeroValue string
	d := &Discussion{AnswerHTMLURL: &zeroValue}
	d.GetAnswerHTMLURL()
	d = &Discussion{}
	d.GetAnswerHTMLURL()
	d = nil
	d.GetAnswerHTMLURL()
}

func TestDiscussion_GetAuthorAssociation(tt *testing.T) {
	var zeroValue string
	d := &Discussion{AuthorAssociation: &zeroValue}
	d.GetAuthorAssociation()
	d = &Discussion{}
	d.GetAuthorAssociation()
	d = nil
	d.GetAuthorAssociation()
}

func TestDiscussion_GetBody(tt *testing.T) {
	var zeroValue string
	d := &Discussion{Body: &zeroValue}
	d.GetBody()
	d = &Discussion{}
	d.GetBody()
	d = nil
	d.GetBody()
}

func TestDiscussion_GetComments(tt *testing.T) {
	var zeroValue int
	d := &Discussion{Comments: &zeroValue}
	d.GetComments()
	d = &Discussion{}
	d.GetComments()
	d = nil
	d.GetComments()
}

func TestDiscussion_GetCreatedAt(tt *testing.T) {
	var zeroValue Timestamp
	d := &Discussion{CreatedAt: &zeroValue}
	d.GetCreatedAt()
	d = &Discussion{}
	d.GetCreatedAt()
	d = nil
	d.GetCreatedAt()
}

func TestDiscussion_GetDiscussionCategory(tt *testing.T) {
	d := &Discussion{}
	d.GetDiscussionCategory()
	d = nil
	d.GetDiscussionCategory()
}

func TestDiscussion_GetHTMLURL(tt *testing.T) {
	var zeroValue string
	d := &Discussion{HTMLURL: &zeroValue}
	d.GetHTMLURL()
	d = &Discussion{}
	d.GetHTMLURL()
	d = nil
	d.GetHTMLURL()
}

func TestDiscussion_GetID(tt *testing.T) {
	var zeroValue int64
	d := &Discussion{ID: &zeroValue}
	d.GetID()
	d = &Discussion{}
	d.GetID()
	d = nil
	d.GetID()
}

func TestDiscussion_GetLocked(tt *testing.T) {
	var zeroValue bool
	d := &Discussion{Locked: &zeroValue}
	d.GetLocked()
	d = &Discussion{}
	d.GetLocked()
	d = nil
	d.GetLocked()
}

func TestDiscussion_GetNodeID(tt *testing.T) {
	var zeroValue string
	d := &Discussion{NodeID: &zeroValue}
	d.GetNodeID()
	d = &Discussion{}
	d.GetNodeID()
	d = nil
	d.GetNodeID()
}

func TestDiscussion_GetNumber(tt *testing.T) {
	var zeroValue int
	d := &Discussion{Number: &zeroValue}
	d.GetNumber()
	d = &Discussion{}
	d.GetNumber()
	d = nil
	d.GetNumber()
}

func TestDiscussion_GetRepositoryURL(tt *testing.T) {
	var zeroValue string
	d := &Discussion{RepositoryURL: &zeroValue}
	d.GetRepositoryURL()
	d = &Discussion{}
	d.GetRepositoryURL()
	d = nil
	d.GetRepositoryURL()
}

func TestDiscussion_GetState(tt *testing.T) {
	var zeroValue string
	d := &Discussion{State: &zeroValue}
	d.GetState()
	d = &Discussion{}
	d.GetState()
	d = nil
	d.GetState()
}

func TestDiscussion_GetTitle(tt *testing.T) {
	var zeroValue string
	d := &Discussion{Title: &zeroValue}
	d.GetTitle()
	d = &Discussion{}
	d.GetTitle()
	d = nil
	d.GetTitle()
}

func TestDiscussion_GetUpdatedAt(tt *testing.T) {
	var zeroValue Timestamp
	d := &Discussion{UpdatedAt: &zeroValue}
	d.GetUpdatedAt()
	d = &Discussion{}
	d.GetUpdatedAt()
	d = nil
	d.GetUpdatedAt()
}

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

func TestDiscussionCategory_GetCreatedAt(tt *testing.T) {
	var zeroValue Timestamp
	d := &DiscussionCategory{CreatedAt: &zeroValue}
	d.GetCreatedAt()
	d = &DiscussionCategory{}
	d.GetCreatedAt()
	d = nil
	d.GetCreatedAt()
}

func TestDiscussionCategory_GetDescription(tt *testing.T) {
	var zeroValue string
	d := &DiscussionCategory{Description: &zeroValue}
	d.GetDescription()
	d = &DiscussionCategory{}
	d.GetDescription()
	d = nil
	d.GetDescription()
}

func TestDiscussionCategory_GetEmoji(tt *testing.T) {
	var zeroValue string
	d := &DiscussionCategory{Emoji: &zeroValue}
	d.GetEmoji()
	d = &DiscussionCategory{}
	d.GetEmoji()
	d = nil
	d.GetEmoji()
}

func TestDiscussionCategory_GetID(tt *testing.T) {
	var zeroValue int64
	d := &DiscussionCategory{ID: &zeroValue}
	d.GetID()
	d = &DiscussionCategory{}
	d.GetID()
	d = nil
	d.GetID()
}

func TestDiscussionCategory_GetIsAnswerable(tt *testing.T) {
	var zeroValue bool
	d := &DiscussionCategory{IsAnswerable: &zeroValue}
	d.GetIsAnswerable()
	d = &DiscussionCategory{}
	d.GetIsAnswerable()
	d = nil
	d.GetIsAnswerable()
}

func TestDiscussionCategory_GetName(tt *testing.T) {
	var zeroValue string
	d := &DiscussionCategory{Name: &zeroValue}
	d.GetName()
	d = &DiscussionCategory{}
	d.GetName()
	d = nil
	d.GetName()
}

func TestDiscussionCategory_GetNodeID(tt *testing.T) {
	var zeroValue string
	d := &DiscussionCategory{NodeID: &zeroValue}
	d.GetNodeID()
	d = &DiscussionCategory{}
	d.GetNodeID()
	d = nil
	d.GetNodeID()
}

func TestDiscussionCategory_GetRepositoryID(tt *testing.T) {
	var zeroValue int64
	d := &DiscussionCategory{RepositoryID: &zeroValue}
	d.GetRepositoryID()
	d = &DiscussionCategory{}
	d.GetRepositoryID()
	d = nil
	d.GetRepositoryID()
}

func TestDiscussionCategory_GetSlug(tt *testing.T) {
	var zeroValue string
	d := &DiscussionCategory{Slug: &zeroValue}
	d.GetSlug()
	d = &DiscussionCategory{}
	d.GetSlug()
	d = nil
	d.GetSlug()
}

func TestDiscussionCategory_GetUpdatedAt(tt *testing.T) {
	var zeroValue Timestamp
	d := &DiscussionCategory{UpdatedAt: &zeroValue}
	d.GetUpdatedAt()
	d = &DiscussionCategory{}
	d.GetUpdatedAt()
	d = nil
	d.GetUpdatedAt()
}

func TestDiscussionComment_GetAuthor(tt *testing.T) {
	d := &DiscussionComment{}
	d.GetAuthor()
	d = nil
	d.GetAuthor()
}

func TestDiscussionComment_GetBody(tt *testing.T) {
	var zeroValue string
	d := &DiscussionComment{Body: &zeroValue}
	d.GetBody()
	d = &DiscussionComment{}
	d.GetBody()
	d = nil
	d.GetBody()
}

func TestDiscussionComment_GetBodyHTML(tt *testing.T) {
	var zeroValue string
	d := &DiscussionComment{BodyHTML: &zeroValue}
	d.GetBodyHTML()
	d = &DiscussionComment{}
	d.GetBodyHTML()
	d = nil
	d.GetBodyHTML()
}

func TestDiscussionComment_GetBodyVersion(tt *testing.T) {
	var zeroValue string
	d := &DiscussionComment{BodyVersion: &zeroValue}
	d.GetBodyVersion()
	d = &DiscussionComment{}
	d.GetBodyVersion()
	d = nil
	d.GetBodyVersion()
}

func TestDiscussionComment_GetCreatedAt(tt *testing.T) {
	var zeroValue Timestamp
	d := &DiscussionComment{CreatedAt: &zeroValue}
	d.GetCreatedAt()
	d = &DiscussionComment{}
	d.GetCreatedAt()
	d = nil
	d.GetCreatedAt()
}

func TestDiscussionComment_GetDiscussionURL(tt *testing.T) {
	var zeroValue string
	d := &DiscussionComment{DiscussionURL: &zeroValue}
	d.GetDiscussionURL()
	d = &DiscussionComment{}
	d.GetDiscussionURL()
	d = nil
	d.GetDiscussionURL()
}

func TestDiscussionComment_GetHTMLURL(tt *testing.T) {
	var zeroValue string
	d := &DiscussionComment{HTMLURL: &zeroValue}
	d.GetHTMLURL()
	d = &DiscussionComment{}
	d.GetHTMLURL()
	d = nil
	d.GetHTMLURL()
}

func TestDiscussionComment_GetLastEditedAt(tt *testing.T) {
	var zeroValue Timestamp
	d := &DiscussionComment{LastEditedAt: &zeroValue}
	d.GetLastEditedAt()
	d = &DiscussionComment{}
	d.GetLastEditedAt()
	d = nil
	d.GetLastEditedAt()
}

func TestDiscussionComment_GetNodeID(tt *testing.T) {
	var zeroValue string
	d := &DiscussionComment{NodeID: &zeroValue}
	d.GetNodeID()
	d = &DiscussionComment{}
	d.GetNodeID()
	d = nil
	d.GetNodeID()
}

func TestDiscussionComment_GetNumber(tt *testing.T) {
	var zeroValue int
	d := &DiscussionComment{Number: &zeroValue}
	d.GetNumber()
	d = &DiscussionComment{}
	d.GetNumber()
	d = nil
	d.GetNumber()
}

func TestDiscussionComment_GetReactions(tt *testing.T) {
	d := &DiscussionComment{}
	d.GetReactions()
	d = nil
	d.GetReactions()
}

func TestDiscussionComment_GetUpdatedAt(tt *testing.T) {
	var zeroValue Timestamp
	d := &DiscussionComment{UpdatedAt: &zeroValue}
	d.GetUpdatedAt()
	d = &DiscussionComment{}
	d.GetUpdatedAt()
	d = nil
	d.GetUpdatedAt()
}

func TestDiscussionComment_GetURL(tt *testing.T) {
	var zeroValue string
	d := &DiscussionComment{URL: &zeroValue}
	d.GetURL()
	d = &DiscussionComment{}
	d.GetURL()
	d = nil
	d.GetURL()
}

func TestDiscussionEvent_GetAction(tt *testing.T) {
	var zeroValue string
	d := &DiscussionEvent{Action: &zeroValue}
	d.GetAction()
	d = &DiscussionEvent{}
	d.GetAction()
	d = nil
	d.GetAction()
}

func TestDiscussionEvent_GetDiscussion(tt *testing.T) {
	d := &DiscussionEvent{}
	d.GetDiscussion()
	d = nil
	d.GetDiscussion()
}

func TestDiscussionEvent_GetInstallation(tt *testing.T) {
	d := &DiscussionEvent{}
	d.GetInstallation()
	d = nil
	d.GetInstallation()
}

func TestDiscussionEvent_GetOrg(tt *testing.T) {
	d := &DiscussionEvent{}
	d.GetOrg()
	d = nil
	d.GetOrg()
}

func TestDiscussionEvent_GetRepo(tt *testing.T) {
	d := &DiscussionEvent{}
	d.GetRepo()
	d = nil
	d.GetRepo()
}

func TestDiscussionEvent_GetSender(tt *testing.T) {
	d := &DiscussionEvent{}
	d.GetSender()
	d = nil
	d.GetSender()
}

func TestDismissalRestrictionsRequest_GetTeams(tt *testing.T) {
	var zeroValue []string
	d := &DismissalRestrictionsRequest{Teams: &zeroValue}
	d.GetTeams()
	d = &DismissalRestrictionsRequest{}
	d.GetTeams()
	d = nil
	d.GetTeams()
}

func TestDismissalRestrictionsRequest_GetUsers(tt *testing.T) {
	var zeroValue []string
	d := &DismissalRestrictionsRequest{Users: &zeroValue}
	d.GetUsers()
	d = &DismissalRestrictionsRequest{}
	d.GetUsers()
	d = nil
	d.GetUsers()
}

func TestDismissedReview_GetDismissalCommitID(tt *testing.T) {
	var zeroValue string
	d := &DismissedReview{DismissalCommitID: &zeroValue}
	d.GetDismissalCommitID()
	d = &DismissedReview{}
	d.GetDismissalCommitID()
	d = nil
	d.GetDismissalCommitID()
}

func TestDismissedReview_GetDismissalMessage(tt *testing.T) {
	var zeroValue string
	d := &DismissedReview{DismissalMessage: &zeroValue}
	d.GetDismissalMessage()
	d = &DismissedReview{}
	d.GetDismissalMessage()
	d = nil
	d.GetDismissalMessage()
}

func TestDismissedReview_GetReviewID(tt *testing.T) {
	var zeroValue int64
	d := &DismissedReview{ReviewID: &zeroValue}
	d.GetReviewID()
	d = &DismissedReview{}
	d.GetReviewID()
	d = nil
	d.GetReviewID()
}

func TestDismissedReview_GetState(tt *testing.T) {
	var zeroValue string
	d := &DismissedReview{State: &zeroValue}
	d.GetState()
	d = &DismissedReview{}
	d.GetState()
	d = nil
	d.GetState()
}

func TestDispatchRequestOptions_GetClientPayload(tt *testing.T) {
	var zeroValue json.RawMessage
	d := &DispatchRequestOptions{ClientPayload: &zeroValue}
	d.GetClientPayload()
	d = &DispatchRequestOptions{}
	d.GetClientPayload()
	d = nil
	d.GetClientPayload()
}

func TestDraftReviewComment_GetBody(tt *testing.T) {
	var zeroValue string
	d := &DraftReviewComment{Body: &zeroValue}
	d.GetBody()
	d = &DraftReviewComment{}
	d.GetBody()
	d = nil
	d.GetBody()
}

func TestDraftReviewComment_GetLine(tt *testing.T) {
	var zeroValue int
	d := &DraftReviewComment{Line: &zeroValue}
	d.GetLine()
	d = &DraftReviewComment{}
	d.GetLine()
	d = nil
	d.GetLine()
}

func TestDraftReviewComment_GetPath(tt *testing.T) {
	var zeroValue string
	d := &DraftReviewComment{Path: &zeroValue}
	d.GetPath()
	d = &DraftReviewComment{}
	d.GetPath()
	d = nil
	d.GetPath()
}

func TestDraftReviewComment_GetPosition(tt *testing.T) {
	var zeroValue int
	d := &DraftReviewComment{Position: &zeroValue}
	d.GetPosition()
	d = &DraftReviewComment{}
	d.GetPosition()
	d = nil
	d.GetPosition()
}

func TestDraftReviewComment_GetSide(tt *testing.T) {
	var zeroValue string
	d := &DraftReviewComment{Side: &zeroValue}
	d.GetSide()
	d = &DraftReviewComment{}
	d.GetSide()
	d = nil
	d.GetSide()
}

func TestDraftReviewComment_GetStartLine(tt *testing.T) {
	var zeroValue int
	d := &DraftReviewComment{StartLine: &zeroValue}
	d.GetStartLine()
	d = &DraftReviewComment{}
	d.GetStartLine()
	d = nil
	d.GetStartLine()
}

func TestDraftReviewComment_GetStartSide(tt *testing.T) {
	var zeroValue string
	d := &DraftReviewComment{StartSide: &zeroValue}
	d.GetStartSide()
	d = &DraftReviewComment{}
	d.GetStartSide()
	d = nil
	d.GetStartSide()
}

func TestEditBase_GetRef(tt *testing.T) {
	e := &EditBase{}
	e.GetRef()
	e = nil
	e.GetRef()
}

func TestEditBase_GetSHA(tt *testing.T) {
	e := &EditBase{}
	e.GetSHA()
	e = nil
	e.GetSHA()
}

func TestEditBody_GetFrom(tt *testing.T) {
	var zeroValue string
	e := &EditBody{From: &zeroValue}
	e.GetFrom()
	e = &EditBody{}
	e.GetFrom()
	e = nil
	e.GetFrom()
}

func TestEditChange_GetBase(tt *testing.T) {
	e := &EditChange{}
	e.GetBase()
	e = nil
	e.GetBase()
}

func TestEditChange_GetBody(tt *testing.T) {
	e := &EditChange{}
	e.GetBody()
	e = nil
	e.GetBody()
}

func TestEditChange_GetRepo(tt *testing.T) {
	e := &EditChange{}
	e.GetRepo()
	e = nil
	e.GetRepo()
}

func TestEditChange_GetTitle(tt *testing.T) {
	e := &EditChange{}
	e.GetTitle()
	e = nil
	e.GetTitle()
}

func TestEditRef_GetFrom(tt *testing.T) {
	var zeroValue string
	e := &EditRef{From: &zeroValue}
	e.GetFrom()
	e = &EditRef{}
	e.GetFrom()
	e = nil
	e.GetFrom()
}

func TestEditRepo_GetName(tt *testing.T) {
	e := &EditRepo{}
	e.GetName()
	e = nil
	e.GetName()
}

func TestEditSHA_GetFrom(tt *testing.T) {
	var zeroValue string
	e := &EditSHA{From: &zeroValue}
	e.GetFrom()
	e = &EditSHA{}
	e.GetFrom()
	e = nil
	e.GetFrom()
}

func TestEditTitle_GetFrom(tt *testing.T) {
	var zeroValue string
	e := &EditTitle{From: &zeroValue}
	e.GetFrom()
	e = &EditTitle{}
	e.GetFrom()
	e = nil
	e.GetFrom()
}

func TestEnterprise_GetAvatarURL(tt *testing.T) {
	var zeroValue string
	e := &Enterprise{AvatarURL: &zeroValue}
	e.GetAvatarURL()
	e = &Enterprise{}
	e.GetAvatarURL()
	e = nil
	e.GetAvatarURL()
}

func TestEnterprise_GetCreatedAt(tt *testing.T) {
	var zeroValue Timestamp
	e := &Enterprise{CreatedAt: &zeroValue}
	e.GetCreatedAt()
	e = &Enterprise{}
	e.GetCreatedAt()
	e = nil
	e.GetCreatedAt()
}

func TestEnterprise_GetDescription(tt *testing.T) {
	var zeroValue string
	e := &Enterprise{Description: &zeroValue}
	e.GetDescription()
	e = &Enterprise{}
	e.GetDescription()
	e = nil
	e.GetDescription()
}

func TestEnterprise_GetHTMLURL(tt *testing.T) {
	var zeroValue string
	e := &Enterprise{HTMLURL: &zeroValue}
	e.GetHTMLURL()
	e = &Enterprise{}
	e.GetHTMLURL()
	e = nil
	e.GetHTMLURL()
}

func TestEnterprise_GetID(tt *testing.T) {
	var zeroValue int
	e := &Enterprise{ID: &zeroValue}
	e.GetID()
	e = &Enterprise{}
	e.GetID()
	e = nil
	e.GetID()
}

func TestEnterprise_GetName(tt *testing.T) {
	var zeroValue string
	e := &Enterprise{Name: &zeroValue}
	e.GetName()
	e = &Enterprise{}
	e.GetName()
	e = nil
	e.GetName()
}

func TestEnterprise_GetNodeID(tt *testing.T) {
	var zeroValue string
	e := &Enterprise{NodeID: &zeroValue}
	e.GetNodeID()
	e = &Enterprise{}
	e.GetNodeID()
	e = nil
	e.GetNodeID()
}

func TestEnterprise_GetSlug(tt *testing.T) {
	var zeroValue string
	e := &Enterprise{Slug: &zeroValue}
	e.GetSlug()
	e = &Enterprise{}
	e.GetSlug()
	e = nil
	e.GetSlug()
}

func TestEnterprise_GetUpdatedAt(tt *testing.T) {
	var zeroValue Timestamp
	e := &Enterprise{UpdatedAt: &zeroValue}
	e.GetUpdatedAt()
	e = &Enterprise{}
	e.GetUpdatedAt()
	e = nil
	e.GetUpdatedAt()
}

func TestEnterprise_GetWebsiteURL(tt *testing.T) {
	var zeroValue string
	e := &Enterprise{WebsiteURL: &zeroValue}
	e.GetWebsiteURL()
	e = &Enterprise{}
	e.GetWebsiteURL()
	e = nil
	e.GetWebsiteURL()
}

func TestEnvironment_GetCreatedAt(tt *testing.T) {
	var zeroValue Timestamp
	e := &Environment{CreatedAt: &zeroValue}
	e.GetCreatedAt()
	e = &Environment{}
	e.GetCreatedAt()
	e = nil
	e.GetCreatedAt()
}

func TestEnvironment_GetDeploymentBranchPolicy(tt *testing.T) {
	e := &Environment{}
	e.GetDeploymentBranchPolicy()
	e = nil
	e.GetDeploymentBranchPolicy()
}

func TestEnvironment_GetEnvironmentName(tt *testing.T) {
	var zeroValue string
	e := &Environment{EnvironmentName: &zeroValue}
	e.GetEnvironmentName()
	e = &Environment{}
	e.GetEnvironmentName()
	e = nil
	e.GetEnvironmentName()
}

func TestEnvironment_GetHTMLURL(tt *testing.T) {
	var zeroValue string
	e := &Environment{HTMLURL: &zeroValue}
	e.GetHTMLURL()
	e = &Environment{}
	e.GetHTMLURL()
	e = nil
	e.GetHTMLURL()
}

func TestEnvironment_GetID(tt *testing.T) {
	var zeroValue int64
	e := &Environment{ID: &zeroValue}
	e.GetID()
	e = &Environment{}
	e.GetID()
	e = nil
	e.GetID()
}

func TestEnvironment_GetName(tt *testing.T) {
	var zeroValue string
	e := &Environment{Name: &zeroValue}
	e.GetName()
	e = &Environment{}
	e.GetName()
	e = nil
	e.GetName()
}

func TestEnvironment_GetNodeID(tt *testing.T) {
	var zeroValue string
	e := &Environment{NodeID: &zeroValue}
	e.GetNodeID()
	e = &Environment{}
	e.GetNodeID()
	e = nil
	e.GetNodeID()
}

func TestEnvironment_GetOwner(tt *testing.T) {
	var zeroValue string
	e := &Environment{Owner: &zeroValue}
	e.GetOwner()
	e = &Environment{}
	e.GetOwner()
	e = nil
	e.GetOwner()
}

func TestEnvironment_GetRepo(tt *testing.T) {
	var zeroValue string
	e := &Environment{Repo: &zeroValue}
	e.GetRepo()
	e = &Environment{}
	e.GetRepo()
	e = nil
	e.GetRepo()
}

func TestEnvironment_GetUpdatedAt(tt *testing.T) {
	var zeroValue Timestamp
	e := &Environment{UpdatedAt: &zeroValue}
	e.GetUpdatedAt()
	e = &Environment{}
	e.GetUpdatedAt()
	e = nil
	e.GetUpdatedAt()
}

func TestEnvironment_GetURL(tt *testing.T) {
	var zeroValue string
	e := &Environment{URL: &zeroValue}
	e.GetURL()
	e = &Environment{}
	e.GetURL()
	e = nil
	e.GetURL()
}

func TestEnvironment_GetWaitTimer(tt *testing.T) {
	var zeroValue int
	e := &Environment{WaitTimer: &zeroValue}
	e.GetWaitTimer()
	e = &Environment{}
	e.GetWaitTimer()
	e = nil
	e.GetWaitTimer()
}

func TestEnvResponse_GetTotalCount(tt *testing.T) {
	var zeroValue int
	e := &EnvResponse{TotalCount: &zeroValue}
	e.GetTotalCount()
	e = &EnvResponse{}
	e.GetTotalCount()
	e = nil
	e.GetTotalCount()
}

func TestEnvReviewers_GetID(tt *testing.T) {
	var zeroValue int64
	e := &EnvReviewers{ID: &zeroValue}
	e.GetID()
	e = &EnvReviewers{}
	e.GetID()
	e = nil
	e.GetID()
}

func TestEnvReviewers_GetType(tt *testing.T) {
	var zeroValue string
	e := &EnvReviewers{Type: &zeroValue}
	e.GetType()
	e = &EnvReviewers{}
	e.GetType()
	e = nil
	e.GetType()
}

func TestErrorBlock_GetCreatedAt(tt *testing.T) {
	var zeroValue Timestamp
	e := &ErrorBlock{CreatedAt: &zeroValue}
	e.GetCreatedAt()
	e = &ErrorBlock{}
	e.GetCreatedAt()
	e = nil
	e.GetCreatedAt()
}

func TestErrorResponse_GetBlock(tt *testing.T) {
	e := &ErrorResponse{}
	e.GetBlock()
	e = nil
	e.GetBlock()
}

func TestEvent_GetActor(tt *testing.T) {
	e := &Event{}
	e.GetActor()
	e = nil
	e.GetActor()
}

func TestEvent_GetCreatedAt(tt *testing.T) {
	var zeroValue time.Time
	e := &Event{CreatedAt: &zeroValue}
	e.GetCreatedAt()
	e = &Event{}
	e.GetCreatedAt()
	e = nil
	e.GetCreatedAt()
}

func TestEvent_GetID(tt *testing.T) {
	var zeroValue string
	e := &Event{ID: &zeroValue}
	e.GetID()
	e = &Event{}
	e.GetID()
	e = nil
	e.GetID()
}

func TestEvent_GetOrg(tt *testing.T) {
	e := &Event{}
	e.GetOrg()
	e = nil
	e.GetOrg()
}

func TestEvent_GetPublic(tt *testing.T) {
	var zeroValue bool
	e := &Event{Public: &zeroValue}
	e.GetPublic()
	e = &Event{}
	e.GetPublic()
	e = nil
	e.GetPublic()
}

func TestEvent_GetRawPayload(tt *testing.T) {
	var zeroValue json.RawMessage
	e := &Event{RawPayload: &zeroValue}
	e.GetRawPayload()
	e = &Event{}
	e.GetRawPayload()
	e = nil
	e.GetRawPayload()
}

func TestEvent_GetRepo(tt *testing.T) {
	e := &Event{}
	e.GetRepo()
	e = nil
	e.GetRepo()
}

func TestEvent_GetType(tt *testing.T) {
	var zeroValue string
	e := &Event{Type: &zeroValue}
	e.GetType()
	e = &Event{}
	e.GetType()
	e = nil
	e.GetType()
}

func TestExternalGroup_GetGroupID(tt *testing.T) {
	var zeroValue int64
	e := &ExternalGroup{GroupID: &zeroValue}
	e.GetGroupID()
	e = &ExternalGroup{}
	e.GetGroupID()
	e = nil
	e.GetGroupID()
}

func TestExternalGroup_GetGroupName(tt *testing.T) {
	var zeroValue string
	e := &ExternalGroup{GroupName: &zeroValue}
	e.GetGroupName()
	e = &ExternalGroup{}
	e.GetGroupName()
	e = nil
	e.GetGroupName()
}

func TestExternalGroup_GetUpdatedAt(tt *testing.T) {
	var zeroValue Timestamp
	e := &ExternalGroup{UpdatedAt: &zeroValue}
	e.GetUpdatedAt()
	e = &ExternalGroup{}
	e.GetUpdatedAt()
	e = nil
	e.GetUpdatedAt()
}

func TestExternalGroupMember_GetMemberEmail(tt *testing.T) {
	var zeroValue string
	e := &ExternalGroupMember{MemberEmail: &zeroValue}
	e.GetMemberEmail()
	e = &ExternalGroupMember{}
	e.GetMemberEmail()
	e = nil
	e.GetMemberEmail()
}

func TestExternalGroupMember_GetMemberID(tt *testing.T) {
	var zeroValue int64
	e := &ExternalGroupMember{MemberID: &zeroValue}
	e.GetMemberID()
	e = &ExternalGroupMember{}
	e.GetMemberID()
	e = nil
	e.GetMemberID()
}

func TestExternalGroupMember_GetMemberLogin(tt *testing.T) {
	var zeroValue string
	e := &ExternalGroupMember{MemberLogin: &zeroValue}
	e.GetMemberLogin()
	e = &ExternalGroupMember{}
	e.GetMemberLogin()
	e = nil
	e.GetMemberLogin()
}

func TestExternalGroupMember_GetMemberName(tt *testing.T) {
	var zeroValue string
	e := &ExternalGroupMember{MemberName: &zeroValue}
	e.GetMemberName()
	e = &ExternalGroupMember{}
	e.GetMemberName()
	e = nil
	e.GetMemberName()
}

func TestExternalGroupTeam_GetTeamID(tt *testing.T) {
	var zeroValue int64
	e := &ExternalGroupTeam{TeamID: &zeroValue}
	e.GetTeamID()
	e = &ExternalGroupTeam{}
	e.GetTeamID()
	e = nil
	e.GetTeamID()
}

func TestExternalGroupTeam_GetTeamName(tt *testing.T) {
	var zeroValue string
	e := &ExternalGroupTeam{TeamName: &zeroValue}
	e.GetTeamName()
	e = &ExternalGroupTeam{}
	e.GetTeamName()
	e = nil
	e.GetTeamName()
}

func TestFeedLink_GetHRef(tt *testing.T) {
	var zeroValue string
	f := &FeedLink{HRef: &zeroValue}
	f.GetHRef()
	f = &FeedLink{}
	f.GetHRef()
	f = nil
	f.GetHRef()
}

func TestFeedLink_GetType(tt *testing.T) {
	var zeroValue string
	f := &FeedLink{Type: &zeroValue}
	f.GetType()
	f = &FeedLink{}
	f.GetType()
	f = nil
	f.GetType()
}

func TestFeedLinks_GetCurrentUser(tt *testing.T) {
	f := &FeedLinks{}
	f.GetCurrentUser()
	f = nil
	f.GetCurrentUser()
}

func TestFeedLinks_GetCurrentUserActor(tt *testing.T) {
	f := &FeedLinks{}
	f.GetCurrentUserActor()
	f = nil
	f.GetCurrentUserActor()
}

func TestFeedLinks_GetCurrentUserOrganization(tt *testing.T) {
	f := &FeedLinks{}
	f.GetCurrentUserOrganization()
	f = nil
	f.GetCurrentUserOrganization()
}

func TestFeedLinks_GetCurrentUserPublic(tt *testing.T) {
	f := &FeedLinks{}
	f.GetCurrentUserPublic()
	f = nil
	f.GetCurrentUserPublic()
}

func TestFeedLinks_GetTimeline(tt *testing.T) {
	f := &FeedLinks{}
	f.GetTimeline()
	f = nil
	f.GetTimeline()
}

func TestFeedLinks_GetUser(tt *testing.T) {
	f := &FeedLinks{}
	f.GetUser()
	f = nil
	f.GetUser()
}

func TestFeeds_GetCurrentUserActorURL(tt *testing.T) {
	var zeroValue string
	f := &Feeds{CurrentUserActorURL: &zeroValue}
	f.GetCurrentUserActorURL()
	f = &Feeds{}
	f.GetCurrentUserActorURL()
	f = nil
	f.GetCurrentUserActorURL()
}

func TestFeeds_GetCurrentUserOrganizationURL(tt *testing.T) {
	var zeroValue string
	f := &Feeds{CurrentUserOrganizationURL: &zeroValue}
	f.GetCurrentUserOrganizationURL()
	f = &Feeds{}
	f.GetCurrentUserOrganizationURL()
	f = nil
	f.GetCurrentUserOrganizationURL()
}

func TestFeeds_GetCurrentUserPublicURL(tt *testing.T) {
	var zeroValue string
	f := &Feeds{CurrentUserPublicURL: &zeroValue}
	f.GetCurrentUserPublicURL()
	f = &Feeds{}
	f.GetCurrentUserPublicURL()
	f = nil
	f.GetCurrentUserPublicURL()
}

func TestFeeds_GetCurrentUserURL(tt *testing.T) {
	var zeroValue string
	f := &Feeds{CurrentUserURL: &zeroValue}
	f.GetCurrentUserURL()
	f = &Feeds{}
	f.GetCurrentUserURL()
	f = nil
	f.GetCurrentUserURL()
}

func TestFeeds_GetLinks(tt *testing.T) {
	f := &Feeds{}
	f.GetLinks()
	f = nil
	f.GetLinks()
}

func TestFeeds_GetTimelineURL(tt *testing.T) {
	var zeroValue string
	f := &Feeds{TimelineURL: &zeroValue}
	f.GetTimelineURL()
	f = &Feeds{}
	f.GetTimelineURL()
	f = nil
	f.GetTimelineURL()
}

func TestFeeds_GetUserURL(tt *testing.T) {
	var zeroValue string
	f := &Feeds{UserURL: &zeroValue}
	f.GetUserURL()
	f = &Feeds{}
	f.GetUserURL()
	f = nil
	f.GetUserURL()
}

func TestFirstPatchedVersion_GetIdentifier(tt *testing.T) {
	var zeroValue string
	f := &FirstPatchedVersion{Identifier: &zeroValue}
	f.GetIdentifier()
	f = &FirstPatchedVersion{}
	f.GetIdentifier()
	f = nil
	f.GetIdentifier()
}

func TestForkEvent_GetForkee(tt *testing.T) {
	f := &ForkEvent{}
	f.GetForkee()
	f = nil
	f.GetForkee()
}

func TestForkEvent_GetInstallation(tt *testing.T) {
	f := &ForkEvent{}
	f.GetInstallation()
	f = nil
	f.GetInstallation()
}

func TestForkEvent_GetRepo(tt *testing.T) {
	f := &ForkEvent{}
	f.GetRepo()
	f = nil
	f.GetRepo()
}

func TestForkEvent_GetSender(tt *testing.T) {
	f := &ForkEvent{}
	f.GetSender()
	f = nil
	f.GetSender()
}

func TestGenerateNotesOptions_GetPreviousTagName(tt *testing.T) {
	var zeroValue string
	g := &GenerateNotesOptions{PreviousTagName: &zeroValue}
	g.GetPreviousTagName()
	g = &GenerateNotesOptions{}
	g.GetPreviousTagName()
	g = nil
	g.GetPreviousTagName()
}

func TestGenerateNotesOptions_GetTargetCommitish(tt *testing.T) {
	var zeroValue string
	g := &GenerateNotesOptions{TargetCommitish: &zeroValue}
	g.GetTargetCommitish()
	g = &GenerateNotesOptions{}
	g.GetTargetCommitish()
	g = nil
	g.GetTargetCommitish()
}

func TestGetAuditLogOptions_GetInclude(tt *testing.T) {
	var zeroValue string
	g := &GetAuditLogOptions{Include: &zeroValue}
	g.GetInclude()
	g = &GetAuditLogOptions{}
	g.GetInclude()
	g = nil
	g.GetInclude()
}

func TestGetAuditLogOptions_GetOrder(tt *testing.T) {
	var zeroValue string
	g := &GetAuditLogOptions{Order: &zeroValue}
	g.GetOrder()
	g = &GetAuditLogOptions{}
	g.GetOrder()
	g = nil
	g.GetOrder()
}

func TestGetAuditLogOptions_GetPhrase(tt *testing.T) {
	var zeroValue string
	g := &GetAuditLogOptions{Phrase: &zeroValue}
	g.GetPhrase()
	g = &GetAuditLogOptions{}
	g.GetPhrase()
	g = nil
	g.GetPhrase()
}

func TestGist_GetComments(tt *testing.T) {
	var zeroValue int
	g := &Gist{Comments: &zeroValue}
	g.GetComments()
	g = &Gist{}
	g.GetComments()
	g = nil
	g.GetComments()
}

func TestGist_GetCreatedAt(tt *testing.T) {
	var zeroValue time.Time
	g := &Gist{CreatedAt: &zeroValue}
	g.GetCreatedAt()
	g = &Gist{}
	g.GetCreatedAt()
	g = nil
	g.GetCreatedAt()
}

func TestGist_GetDescription(tt *testing.T) {
	var zeroValue string
	g := &Gist{Description: &zeroValue}
	g.GetDescription()
	g = &Gist{}
	g.GetDescription()
	g = nil
	g.GetDescription()
}

func TestGist_GetFiles(tt *testing.T) {
	zeroValue := map[GistFilename]GistFile{}
	g := &Gist{Files: zeroValue}
	g.GetFiles()
	g = &Gist{}
	g.GetFiles()
	g = nil
	g.GetFiles()
}

func TestGist_GetGitPullURL(tt *testing.T) {
	var zeroValue string
	g := &Gist{GitPullURL: &zeroValue}
	g.GetGitPullURL()
	g = &Gist{}
	g.GetGitPullURL()
	g = nil
	g.GetGitPullURL()
}

func TestGist_GetGitPushURL(tt *testing.T) {
	var zeroValue string
	g := &Gist{GitPushURL: &zeroValue}
	g.GetGitPushURL()
	g = &Gist{}
	g.GetGitPushURL()
	g = nil
	g.GetGitPushURL()
}

func TestGist_GetHTMLURL(tt *testing.T) {
	var zeroValue string
	g := &Gist{HTMLURL: &zeroValue}
	g.GetHTMLURL()
	g = &Gist{}
	g.GetHTMLURL()
	g = nil
	g.GetHTMLURL()
}

func TestGist_GetID(tt *testing.T) {
	var zeroValue string
	g := &Gist{ID: &zeroValue}
	g.GetID()
	g = &Gist{}
	g.GetID()
	g = nil
	g.GetID()
}

func TestGist_GetNodeID(tt *testing.T) {
	var zeroValue string
	g := &Gist{NodeID: &zeroValue}
	g.GetNodeID()
	g = &Gist{}
	g.GetNodeID()
	g = nil
	g.GetNodeID()
}

func TestGist_GetOwner(tt *testing.T) {
	g := &Gist{}
	g.GetOwner()
	g = nil
	g.GetOwner()
}

func TestGist_GetPublic(tt *testing.T) {
	var zeroValue bool
	g := &Gist{Public: &zeroValue}
	g.GetPublic()
	g = &Gist{}
	g.GetPublic()
	g = nil
	g.GetPublic()
}

func TestGist_GetUpdatedAt(tt *testing.T) {
	var zeroValue time.Time
	g := &Gist{UpdatedAt: &zeroValue}
	g.GetUpdatedAt()
	g = &Gist{}
	g.GetUpdatedAt()
	g = nil
	g.GetUpdatedAt()
}

func TestGistComment_GetBody(tt *testing.T) {
	var zeroValue string
	g := &GistComment{Body: &zeroValue}
	g.GetBody()
	g = &GistComment{}
	g.GetBody()
	g = nil
	g.GetBody()
}

func TestGistComment_GetCreatedAt(tt *testing.T) {
	var zeroValue time.Time
	g := &GistComment{CreatedAt: &zeroValue}
	g.GetCreatedAt()
	g = &GistComment{}
	g.GetCreatedAt()
	g = nil
	g.GetCreatedAt()
}

func TestGistComment_GetID(tt *testing.T) {
	var zeroValue int64
	g := &GistComment{ID: &zeroValue}
	g.GetID()
	g = &GistComment{}
	g.GetID()
	g = nil
	g.GetID()
}

func TestGistComment_GetURL(tt *testing.T) {
	var zeroValue string
	g := &GistComment{URL: &zeroValue}
	g.GetURL()
	g = &GistComment{}
	g.GetURL()
	g = nil
	g.GetURL()
}

func TestGistComment_GetUser(tt *testing.T) {
	g := &GistComment{}
	g.GetUser()
	g = nil
	g.GetUser()
}

func TestGistCommit_GetChangeStatus(tt *testing.T) {
	g := &GistCommit{}
	g.GetChangeStatus()
	g = nil
	g.GetChangeStatus()
}

func TestGistCommit_GetCommittedAt(tt *testing.T) {
	var zeroValue Timestamp
	g := &GistCommit{CommittedAt: &zeroValue}
	g.GetCommittedAt()
	g = &GistCommit{}
	g.GetCommittedAt()
	g = nil
	g.GetCommittedAt()
}

func TestGistCommit_GetNodeID(tt *testing.T) {
	var zeroValue string
	g := &GistCommit{NodeID: &zeroValue}
	g.GetNodeID()
	g = &GistCommit{}
	g.GetNodeID()
	g = nil
	g.GetNodeID()
}

func TestGistCommit_GetURL(tt *testing.T) {
	var zeroValue string
	g := &GistCommit{URL: &zeroValue}
	g.GetURL()
	g = &GistCommit{}
	g.GetURL()
	g = nil
	g.GetURL()
}

func TestGistCommit_GetUser(tt *testing.T) {
	g := &GistCommit{}
	g.GetUser()
	g = nil
	g.GetUser()
}

func TestGistCommit_GetVersion(tt *testing.T) {
	var zeroValue string
	g := &GistCommit{Version: &zeroValue}
	g.GetVersion()
	g = &GistCommit{}
	g.GetVersion()
	g = nil
	g.GetVersion()
}

func TestGistFile_GetContent(tt *testing.T) {
	var zeroValue string
	g := &GistFile{Content: &zeroValue}
	g.GetContent()
	g = &GistFile{}
	g.GetContent()
	g = nil
	g.GetContent()
}

func TestGistFile_GetFilename(tt *testing.T) {
	var zeroValue string
	g := &GistFile{Filename: &zeroValue}
	g.GetFilename()
	g = &GistFile{}
	g.GetFilename()
	g = nil
	g.GetFilename()
}

func TestGistFile_GetLanguage(tt *testing.T) {
	var zeroValue string
	g := &GistFile{Language: &zeroValue}
	g.GetLanguage()
	g = &GistFile{}
	g.GetLanguage()
	g = nil
	g.GetLanguage()
}

func TestGistFile_GetRawURL(tt *testing.T) {
	var zeroValue string
	g := &GistFile{RawURL: &zeroValue}
	g.GetRawURL()
	g = &GistFile{}
	g.GetRawURL()
	g = nil
	g.GetRawURL()
}

func TestGistFile_GetSize(tt *testing.T) {
	var zeroValue int
	g := &GistFile{Size: &zeroValue}
	g.GetSize()
	g = &GistFile{}
	g.GetSize()
	g = nil
	g.GetSize()
}

func TestGistFile_GetType(tt *testing.T) {
	var zeroValue string
	g := &GistFile{Type: &zeroValue}
	g.GetType()
	g = &GistFile{}
	g.GetType()
	g = nil
	g.GetType()
}

func TestGistFork_GetCreatedAt(tt *testing.T) {
	var zeroValue Timestamp
	g := &GistFork{CreatedAt: &zeroValue}
	g.GetCreatedAt()
	g = &GistFork{}
	g.GetCreatedAt()
	g = nil
	g.GetCreatedAt()
}

func TestGistFork_GetID(tt *testing.T) {
	var zeroValue string
	g := &GistFork{ID: &zeroValue}
	g.GetID()
	g = &GistFork{}
	g.GetID()
	g = nil
	g.GetID()
}

func TestGistFork_GetNodeID(tt *testing.T) {
	var zeroValue string
	g := &GistFork{NodeID: &zeroValue}
	g.GetNodeID()
	g = &GistFork{}
	g.GetNodeID()
	g = nil
	g.GetNodeID()
}

func TestGistFork_GetUpdatedAt(tt *testing.T) {
	var zeroValue Timestamp
	g := &GistFork{UpdatedAt: &zeroValue}
	g.GetUpdatedAt()
	g = &GistFork{}
	g.GetUpdatedAt()
	g = nil
	g.GetUpdatedAt()
}

func TestGistFork_GetURL(tt *testing.T) {
	var zeroValue string
	g := &GistFork{URL: &zeroValue}
	g.GetURL()
	g = &GistFork{}
	g.GetURL()
	g = nil
	g.GetURL()
}

func TestGistFork_GetUser(tt *testing.T) {
	g := &GistFork{}
	g.GetUser()
	g = nil
	g.GetUser()
}

func TestGistStats_GetPrivateGists(tt *testing.T) {
	var zeroValue int
	g := &GistStats{PrivateGists: &zeroValue}
	g.GetPrivateGists()
	g = &GistStats{}
	g.GetPrivateGists()
	g = nil
	g.GetPrivateGists()
}

func TestGistStats_GetPublicGists(tt *testing.T) {
	var zeroValue int
	g := &GistStats{PublicGists: &zeroValue}
	g.GetPublicGists()
	g = &GistStats{}
	g.GetPublicGists()
	g = nil
	g.GetPublicGists()
}

func TestGistStats_GetTotalGists(tt *testing.T) {
	var zeroValue int
	g := &GistStats{TotalGists: &zeroValue}
	g.GetTotalGists()
	g = &GistStats{}
	g.GetTotalGists()
	g = nil
	g.GetTotalGists()
}

func TestGitHubAppAuthorizationEvent_GetAction(tt *testing.T) {
	var zeroValue string
	g := &GitHubAppAuthorizationEvent{Action: &zeroValue}
	g.GetAction()
	g = &GitHubAppAuthorizationEvent{}
	g.GetAction()
	g = nil
	g.GetAction()
}

func TestGitHubAppAuthorizationEvent_GetInstallation(tt *testing.T) {
	g := &GitHubAppAuthorizationEvent{}
	g.GetInstallation()
	g = nil
	g.GetInstallation()
}

func TestGitHubAppAuthorizationEvent_GetSender(tt *testing.T) {
	g := &GitHubAppAuthorizationEvent{}
	g.GetSender()
	g = nil
	g.GetSender()
}

func TestGitignore_GetName(tt *testing.T) {
	var zeroValue string
	g := &Gitignore{Name: &zeroValue}
	g.GetName()
	g = &Gitignore{}
	g.GetName()
	g = nil
	g.GetName()
}

func TestGitignore_GetSource(tt *testing.T) {
	var zeroValue string
	g := &Gitignore{Source: &zeroValue}
	g.GetSource()
	g = &Gitignore{}
	g.GetSource()
	g = nil
	g.GetSource()
}

func TestGitObject_GetSHA(tt *testing.T) {
	var zeroValue string
	g := &GitObject{SHA: &zeroValue}
	g.GetSHA()
	g = &GitObject{}
	g.GetSHA()
	g = nil
	g.GetSHA()
}

func TestGitObject_GetType(tt *testing.T) {
	var zeroValue string
	g := &GitObject{Type: &zeroValue}
	g.GetType()
	g = &GitObject{}
	g.GetType()
	g = nil
	g.GetType()
}

func TestGitObject_GetURL(tt *testing.T) {
	var zeroValue string
	g := &GitObject{URL: &zeroValue}
	g.GetURL()
	g = &GitObject{}
	g.GetURL()
	g = nil
	g.GetURL()
}

func TestGollumEvent_GetInstallation(tt *testing.T) {
	g := &GollumEvent{}
	g.GetInstallation()
	g = nil
	g.GetInstallation()
}

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

func TestGollumEvent_GetSender(tt *testing.T) {
	g := &GollumEvent{}
	g.GetSender()
	g = nil
	g.GetSender()
}

func TestGPGEmail_GetEmail(tt *testing.T) {
	var zeroValue string
	g := &GPGEmail{Email: &zeroValue}
	g.GetEmail()
	g = &GPGEmail{}
	g.GetEmail()
	g = nil
	g.GetEmail()
}

func TestGPGEmail_GetVerified(tt *testing.T) {
	var zeroValue bool
	g := &GPGEmail{Verified: &zeroValue}
	g.GetVerified()
	g = &GPGEmail{}
	g.GetVerified()
	g = nil
	g.GetVerified()
}

func TestGPGKey_GetCanCertify(tt *testing.T) {
	var zeroValue bool
	g := &GPGKey{CanCertify: &zeroValue}
	g.GetCanCertify()
	g = &GPGKey{}
	g.GetCanCertify()
	g = nil
	g.GetCanCertify()
}

func TestGPGKey_GetCanEncryptComms(tt *testing.T) {
	var zeroValue bool
	g := &GPGKey{CanEncryptComms: &zeroValue}
	g.GetCanEncryptComms()
	g = &GPGKey{}
	g.GetCanEncryptComms()
	g = nil
	g.GetCanEncryptComms()
}

func TestGPGKey_GetCanEncryptStorage(tt *testing.T) {
	var zeroValue bool
	g := &GPGKey{CanEncryptStorage: &zeroValue}
	g.GetCanEncryptStorage()
	g = &GPGKey{}
	g.GetCanEncryptStorage()
	g = nil
	g.GetCanEncryptStorage()
}

func TestGPGKey_GetCanSign(tt *testing.T) {
	var zeroValue bool
	g := &GPGKey{CanSign: &zeroValue}
	g.GetCanSign()
	g = &GPGKey{}
	g.GetCanSign()
	g = nil
	g.GetCanSign()
}

func TestGPGKey_GetCreatedAt(tt *testing.T) {
	var zeroValue time.Time
	g := &GPGKey{CreatedAt: &zeroValue}
	g.GetCreatedAt()
	g = &GPGKey{}
	g.GetCreatedAt()
	g = nil
	g.GetCreatedAt()
}

func TestGPGKey_GetExpiresAt(tt *testing.T) {
	var zeroValue time.Time
	g := &GPGKey{ExpiresAt: &zeroValue}
	g.GetExpiresAt()
	g = &GPGKey{}
	g.GetExpiresAt()
	g = nil
	g.GetExpiresAt()
}

func TestGPGKey_GetID(tt *testing.T) {
	var zeroValue int64
	g := &GPGKey{ID: &zeroValue}
	g.GetID()
	g = &GPGKey{}
	g.GetID()
	g = nil
	g.GetID()
}

func TestGPGKey_GetKeyID(tt *testing.T) {
	var zeroValue string
	g := &GPGKey{KeyID: &zeroValue}
	g.GetKeyID()
	g = &GPGKey{}
	g.GetKeyID()
	g = nil
	g.GetKeyID()
}

func TestGPGKey_GetPrimaryKeyID(tt *testing.T) {
	var zeroValue int64
	g := &GPGKey{PrimaryKeyID: &zeroValue}
	g.GetPrimaryKeyID()
	g = &GPGKey{}
	g.GetPrimaryKeyID()
	g = nil
	g.GetPrimaryKeyID()
}

func TestGPGKey_GetPublicKey(tt *testing.T) {
	var zeroValue string
	g := &GPGKey{PublicKey: &zeroValue}
	g.GetPublicKey()
	g = &GPGKey{}
	g.GetPublicKey()
	g = nil
	g.GetPublicKey()
}

func TestGPGKey_GetRawKey(tt *testing.T) {
	var zeroValue string
	g := &GPGKey{RawKey: &zeroValue}
	g.GetRawKey()
	g = &GPGKey{}
	g.GetRawKey()
	g = nil
	g.GetRawKey()
}

func TestGrant_GetApp(tt *testing.T) {
	g := &Grant{}
	g.GetApp()
	g = nil
	g.GetApp()
}

func TestGrant_GetCreatedAt(tt *testing.T) {
	var zeroValue Timestamp
	g := &Grant{CreatedAt: &zeroValue}
	g.GetCreatedAt()
	g = &Grant{}
	g.GetCreatedAt()
	g = nil
	g.GetCreatedAt()
}

func TestGrant_GetID(tt *testing.T) {
	var zeroValue int64
	g := &Grant{ID: &zeroValue}
	g.GetID()
	g = &Grant{}
	g.GetID()
	g = nil
	g.GetID()
}

func TestGrant_GetUpdatedAt(tt *testing.T) {
	var zeroValue Timestamp
	g := &Grant{UpdatedAt: &zeroValue}
	g.GetUpdatedAt()
	g = &Grant{}
	g.GetUpdatedAt()
	g = nil
	g.GetUpdatedAt()
}

func TestGrant_GetURL(tt *testing.T) {
	var zeroValue string
	g := &Grant{URL: &zeroValue}
	g.GetURL()
	g = &Grant{}
	g.GetURL()
	g = nil
	g.GetURL()
}

func TestHeadCommit_GetAuthor(tt *testing.T) {
	h := &HeadCommit{}
	h.GetAuthor()
	h = nil
	h.GetAuthor()
}

func TestHeadCommit_GetCommitter(tt *testing.T) {
	h := &HeadCommit{}
	h.GetCommitter()
	h = nil
	h.GetCommitter()
}

func TestHeadCommit_GetDistinct(tt *testing.T) {
	var zeroValue bool
	h := &HeadCommit{Distinct: &zeroValue}
	h.GetDistinct()
	h = &HeadCommit{}
	h.GetDistinct()
	h = nil
	h.GetDistinct()
}

func TestHeadCommit_GetID(tt *testing.T) {
	var zeroValue string
	h := &HeadCommit{ID: &zeroValue}
	h.GetID()
	h = &HeadCommit{}
	h.GetID()
	h = nil
	h.GetID()
}

func TestHeadCommit_GetMessage(tt *testing.T) {
	var zeroValue string
	h := &HeadCommit{Message: &zeroValue}
	h.GetMessage()
	h = &HeadCommit{}
	h.GetMessage()
	h = nil
	h.GetMessage()
}

func TestHeadCommit_GetSHA(tt *testing.T) {
	var zeroValue string
	h := &HeadCommit{SHA: &zeroValue}
	h.GetSHA()
	h = &HeadCommit{}
	h.GetSHA()
	h = nil
	h.GetSHA()
}

func TestHeadCommit_GetTimestamp(tt *testing.T) {
	var zeroValue Timestamp
	h := &HeadCommit{Timestamp: &zeroValue}
	h.GetTimestamp()
	h = &HeadCommit{}
	h.GetTimestamp()
	h = nil
	h.GetTimestamp()
}

func TestHeadCommit_GetTreeID(tt *testing.T) {
	var zeroValue string
	h := &HeadCommit{TreeID: &zeroValue}
	h.GetTreeID()
	h = &HeadCommit{}
	h.GetTreeID()
	h = nil
	h.GetTreeID()
}

func TestHeadCommit_GetURL(tt *testing.T) {
	var zeroValue string
	h := &HeadCommit{URL: &zeroValue}
	h.GetURL()
	h = &HeadCommit{}
	h.GetURL()
	h = nil
	h.GetURL()
}

func TestHook_GetActive(tt *testing.T) {
	var zeroValue bool
	h := &Hook{Active: &zeroValue}
	h.GetActive()
	h = &Hook{}
	h.GetActive()
	h = nil
	h.GetActive()
}

func TestHook_GetCreatedAt(tt *testing.T) {
	var zeroValue time.Time
	h := &Hook{CreatedAt: &zeroValue}
	h.GetCreatedAt()
	h = &Hook{}
	h.GetCreatedAt()
	h = nil
	h.GetCreatedAt()
}

func TestHook_GetID(tt *testing.T) {
	var zeroValue int64
	h := &Hook{ID: &zeroValue}
	h.GetID()
	h = &Hook{}
	h.GetID()
	h = nil
	h.GetID()
}

func TestHook_GetName(tt *testing.T) {
	var zeroValue string
	h := &Hook{Name: &zeroValue}
	h.GetName()
	h = &Hook{}
	h.GetName()
	h = nil
	h.GetName()
}

func TestHook_GetPingURL(tt *testing.T) {
	var zeroValue string
	h := &Hook{PingURL: &zeroValue}
	h.GetPingURL()
	h = &Hook{}
	h.GetPingURL()
	h = nil
	h.GetPingURL()
}

func TestHook_GetTestURL(tt *testing.T) {
	var zeroValue string
	h := &Hook{TestURL: &zeroValue}
	h.GetTestURL()
	h = &Hook{}
	h.GetTestURL()
	h = nil
	h.GetTestURL()
}

func TestHook_GetType(tt *testing.T) {
	var zeroValue string
	h := &Hook{Type: &zeroValue}
	h.GetType()
	h = &Hook{}
	h.GetType()
	h = nil
	h.GetType()
}

func TestHook_GetUpdatedAt(tt *testing.T) {
	var zeroValue time.Time
	h := &Hook{UpdatedAt: &zeroValue}
	h.GetUpdatedAt()
	h = &Hook{}
	h.GetUpdatedAt()
	h = nil
	h.GetUpdatedAt()
}

func TestHook_GetURL(tt *testing.T) {
	var zeroValue string
	h := &Hook{URL: &zeroValue}
	h.GetURL()
	h = &Hook{}
	h.GetURL()
	h = nil
	h.GetURL()
}

func TestHookConfig_GetContentType(tt *testing.T) {
	var zeroValue string
	h := &HookConfig{ContentType: &zeroValue}
	h.GetContentType()
	h = &HookConfig{}
	h.GetContentType()
	h = nil
	h.GetContentType()
}

func TestHookConfig_GetInsecureSSL(tt *testing.T) {
	var zeroValue string
	h := &HookConfig{InsecureSSL: &zeroValue}
	h.GetInsecureSSL()
	h = &HookConfig{}
	h.GetInsecureSSL()
	h = nil
	h.GetInsecureSSL()
}

func TestHookConfig_GetSecret(tt *testing.T) {
	var zeroValue string
	h := &HookConfig{Secret: &zeroValue}
	h.GetSecret()
	h = &HookConfig{}
	h.GetSecret()
	h = nil
	h.GetSecret()
}

func TestHookConfig_GetURL(tt *testing.T) {
	var zeroValue string
	h := &HookConfig{URL: &zeroValue}
	h.GetURL()
	h = &HookConfig{}
	h.GetURL()
	h = nil
	h.GetURL()
}

func TestHookDelivery_GetAction(tt *testing.T) {
	var zeroValue string
	h := &HookDelivery{Action: &zeroValue}
	h.GetAction()
	h = &HookDelivery{}
	h.GetAction()
	h = nil
	h.GetAction()
}

func TestHookDelivery_GetDeliveredAt(tt *testing.T) {
	var zeroValue Timestamp
	h := &HookDelivery{DeliveredAt: &zeroValue}
	h.GetDeliveredAt()
	h = &HookDelivery{}
	h.GetDeliveredAt()
	h = nil
	h.GetDeliveredAt()
}

func TestHookDelivery_GetDuration(tt *testing.T) {
	h := &HookDelivery{}
	h.GetDuration()
	h = nil
	h.GetDuration()
}

func TestHookDelivery_GetEvent(tt *testing.T) {
	var zeroValue string
	h := &HookDelivery{Event: &zeroValue}
	h.GetEvent()
	h = &HookDelivery{}
	h.GetEvent()
	h = nil
	h.GetEvent()
}

func TestHookDelivery_GetGUID(tt *testing.T) {
	var zeroValue string
	h := &HookDelivery{GUID: &zeroValue}
	h.GetGUID()
	h = &HookDelivery{}
	h.GetGUID()
	h = nil
	h.GetGUID()
}

func TestHookDelivery_GetID(tt *testing.T) {
	var zeroValue int64
	h := &HookDelivery{ID: &zeroValue}
	h.GetID()
	h = &HookDelivery{}
	h.GetID()
	h = nil
	h.GetID()
}

func TestHookDelivery_GetInstallationID(tt *testing.T) {
	var zeroValue int64
	h := &HookDelivery{InstallationID: &zeroValue}
	h.GetInstallationID()
	h = &HookDelivery{}
	h.GetInstallationID()
	h = nil
	h.GetInstallationID()
}

func TestHookDelivery_GetRedelivery(tt *testing.T) {
	var zeroValue bool
	h := &HookDelivery{Redelivery: &zeroValue}
	h.GetRedelivery()
	h = &HookDelivery{}
	h.GetRedelivery()
	h = nil
	h.GetRedelivery()
}

func TestHookDelivery_GetRepositoryID(tt *testing.T) {
	var zeroValue int64
	h := &HookDelivery{RepositoryID: &zeroValue}
	h.GetRepositoryID()
	h = &HookDelivery{}
	h.GetRepositoryID()
	h = nil
	h.GetRepositoryID()
}

func TestHookDelivery_GetRequest(tt *testing.T) {
	h := &HookDelivery{}
	h.GetRequest()
	h = nil
	h.GetRequest()
}

func TestHookDelivery_GetResponse(tt *testing.T) {
	h := &HookDelivery{}
	h.GetResponse()
	h = nil
	h.GetResponse()
}

func TestHookDelivery_GetStatus(tt *testing.T) {
	var zeroValue string
	h := &HookDelivery{Status: &zeroValue}
	h.GetStatus()
	h = &HookDelivery{}
	h.GetStatus()
	h = nil
	h.GetStatus()
}

func TestHookDelivery_GetStatusCode(tt *testing.T) {
	var zeroValue int
	h := &HookDelivery{StatusCode: &zeroValue}
	h.GetStatusCode()
	h = &HookDelivery{}
	h.GetStatusCode()
	h = nil
	h.GetStatusCode()
}

func TestHookRequest_GetHeaders(tt *testing.T) {
	zeroValue := map[string]string{}
	h := &HookRequest{Headers: zeroValue}
	h.GetHeaders()
	h = &HookRequest{}
	h.GetHeaders()
	h = nil
	h.GetHeaders()
}

func TestHookRequest_GetRawPayload(tt *testing.T) {
	var zeroValue json.RawMessage
	h := &HookRequest{RawPayload: &zeroValue}
	h.GetRawPayload()
	h = &HookRequest{}
	h.GetRawPayload()
	h = nil
	h.GetRawPayload()
}

func TestHookResponse_GetHeaders(tt *testing.T) {
	zeroValue := map[string]string{}
	h := &HookResponse{Headers: zeroValue}
	h.GetHeaders()
	h = &HookResponse{}
	h.GetHeaders()
	h = nil
	h.GetHeaders()
}

func TestHookResponse_GetRawPayload(tt *testing.T) {
	var zeroValue json.RawMessage
	h := &HookResponse{RawPayload: &zeroValue}
	h.GetRawPayload()
	h = &HookResponse{}
	h.GetRawPayload()
	h = nil
	h.GetRawPayload()
}

func TestHookStats_GetActiveHooks(tt *testing.T) {
	var zeroValue int
	h := &HookStats{ActiveHooks: &zeroValue}
	h.GetActiveHooks()
	h = &HookStats{}
	h.GetActiveHooks()
	h = nil
	h.GetActiveHooks()
}

func TestHookStats_GetInactiveHooks(tt *testing.T) {
	var zeroValue int
	h := &HookStats{InactiveHooks: &zeroValue}
	h.GetInactiveHooks()
	h = &HookStats{}
	h.GetInactiveHooks()
	h = nil
	h.GetInactiveHooks()
}

func TestHookStats_GetTotalHooks(tt *testing.T) {
	var zeroValue int
	h := &HookStats{TotalHooks: &zeroValue}
	h.GetTotalHooks()
	h = &HookStats{}
	h.GetTotalHooks()
	h = nil
	h.GetTotalHooks()
}

func TestIDPGroup_GetGroupDescription(tt *testing.T) {
	var zeroValue string
	i := &IDPGroup{GroupDescription: &zeroValue}
	i.GetGroupDescription()
	i = &IDPGroup{}
	i.GetGroupDescription()
	i = nil
	i.GetGroupDescription()
}

func TestIDPGroup_GetGroupID(tt *testing.T) {
	var zeroValue string
	i := &IDPGroup{GroupID: &zeroValue}
	i.GetGroupID()
	i = &IDPGroup{}
	i.GetGroupID()
	i = nil
	i.GetGroupID()
}

func TestIDPGroup_GetGroupName(tt *testing.T) {
	var zeroValue string
	i := &IDPGroup{GroupName: &zeroValue}
	i.GetGroupName()
	i = &IDPGroup{}
	i.GetGroupName()
	i = nil
	i.GetGroupName()
}

func TestImport_GetAuthorsCount(tt *testing.T) {
	var zeroValue int
	i := &Import{AuthorsCount: &zeroValue}
	i.GetAuthorsCount()
	i = &Import{}
	i.GetAuthorsCount()
	i = nil
	i.GetAuthorsCount()
}

func TestImport_GetAuthorsURL(tt *testing.T) {
	var zeroValue string
	i := &Import{AuthorsURL: &zeroValue}
	i.GetAuthorsURL()
	i = &Import{}
	i.GetAuthorsURL()
	i = nil
	i.GetAuthorsURL()
}

func TestImport_GetCommitCount(tt *testing.T) {
	var zeroValue int
	i := &Import{CommitCount: &zeroValue}
	i.GetCommitCount()
	i = &Import{}
	i.GetCommitCount()
	i = nil
	i.GetCommitCount()
}

func TestImport_GetFailedStep(tt *testing.T) {
	var zeroValue string
	i := &Import{FailedStep: &zeroValue}
	i.GetFailedStep()
	i = &Import{}
	i.GetFailedStep()
	i = nil
	i.GetFailedStep()
}

func TestImport_GetHasLargeFiles(tt *testing.T) {
	var zeroValue bool
	i := &Import{HasLargeFiles: &zeroValue}
	i.GetHasLargeFiles()
	i = &Import{}
	i.GetHasLargeFiles()
	i = nil
	i.GetHasLargeFiles()
}

func TestImport_GetHTMLURL(tt *testing.T) {
	var zeroValue string
	i := &Import{HTMLURL: &zeroValue}
	i.GetHTMLURL()
	i = &Import{}
	i.GetHTMLURL()
	i = nil
	i.GetHTMLURL()
}

func TestImport_GetHumanName(tt *testing.T) {
	var zeroValue string
	i := &Import{HumanName: &zeroValue}
	i.GetHumanName()
	i = &Import{}
	i.GetHumanName()
	i = nil
	i.GetHumanName()
}

func TestImport_GetLargeFilesCount(tt *testing.T) {
	var zeroValue int
	i := &Import{LargeFilesCount: &zeroValue}
	i.GetLargeFilesCount()
	i = &Import{}
	i.GetLargeFilesCount()
	i = nil
	i.GetLargeFilesCount()
}

func TestImport_GetLargeFilesSize(tt *testing.T) {
	var zeroValue int
	i := &Import{LargeFilesSize: &zeroValue}
	i.GetLargeFilesSize()
	i = &Import{}
	i.GetLargeFilesSize()
	i = nil
	i.GetLargeFilesSize()
}

func TestImport_GetMessage(tt *testing.T) {
	var zeroValue string
	i := &Import{Message: &zeroValue}
	i.GetMessage()
	i = &Import{}
	i.GetMessage()
	i = nil
	i.GetMessage()
}

func TestImport_GetPercent(tt *testing.T) {
	var zeroValue int
	i := &Import{Percent: &zeroValue}
	i.GetPercent()
	i = &Import{}
	i.GetPercent()
	i = nil
	i.GetPercent()
}

func TestImport_GetPushPercent(tt *testing.T) {
	var zeroValue int
	i := &Import{PushPercent: &zeroValue}
	i.GetPushPercent()
	i = &Import{}
	i.GetPushPercent()
	i = nil
	i.GetPushPercent()
}

func TestImport_GetRepositoryURL(tt *testing.T) {
	var zeroValue string
	i := &Import{RepositoryURL: &zeroValue}
	i.GetRepositoryURL()
	i = &Import{}
	i.GetRepositoryURL()
	i = nil
	i.GetRepositoryURL()
}

func TestImport_GetStatus(tt *testing.T) {
	var zeroValue string
	i := &Import{Status: &zeroValue}
	i.GetStatus()
	i = &Import{}
	i.GetStatus()
	i = nil
	i.GetStatus()
}

func TestImport_GetStatusText(tt *testing.T) {
	var zeroValue string
	i := &Import{StatusText: &zeroValue}
	i.GetStatusText()
	i = &Import{}
	i.GetStatusText()
	i = nil
	i.GetStatusText()
}

func TestImport_GetTFVCProject(tt *testing.T) {
	var zeroValue string
	i := &Import{TFVCProject: &zeroValue}
	i.GetTFVCProject()
	i = &Import{}
	i.GetTFVCProject()
	i = nil
	i.GetTFVCProject()
}

func TestImport_GetURL(tt *testing.T) {
	var zeroValue string
	i := &Import{URL: &zeroValue}
	i.GetURL()
	i = &Import{}
	i.GetURL()
	i = nil
	i.GetURL()
}

func TestImport_GetUseLFS(tt *testing.T) {
	var zeroValue string
	i := &Import{UseLFS: &zeroValue}
	i.GetUseLFS()
	i = &Import{}
	i.GetUseLFS()
	i = nil
	i.GetUseLFS()
}

func TestImport_GetVCS(tt *testing.T) {
	var zeroValue string
	i := &Import{VCS: &zeroValue}
	i.GetVCS()
	i = &Import{}
	i.GetVCS()
	i = nil
	i.GetVCS()
}

func TestImport_GetVCSPassword(tt *testing.T) {
	var zeroValue string
	i := &Import{VCSPassword: &zeroValue}
	i.GetVCSPassword()
	i = &Import{}
	i.GetVCSPassword()
	i = nil
	i.GetVCSPassword()
}

func TestImport_GetVCSURL(tt *testing.T) {
	var zeroValue string
	i := &Import{VCSURL: &zeroValue}
	i.GetVCSURL()
	i = &Import{}
	i.GetVCSURL()
	i = nil
	i.GetVCSURL()
}

func TestImport_GetVCSUsername(tt *testing.T) {
	var zeroValue string
	i := &Import{VCSUsername: &zeroValue}
	i.GetVCSUsername()
	i = &Import{}
	i.GetVCSUsername()
	i = nil
	i.GetVCSUsername()
}

func TestInstallation_GetAccessTokensURL(tt *testing.T) {
	var zeroValue string
	i := &Installation{AccessTokensURL: &zeroValue}
	i.GetAccessTokensURL()
	i = &Installation{}
	i.GetAccessTokensURL()
	i = nil
	i.GetAccessTokensURL()
}

func TestInstallation_GetAccount(tt *testing.T) {
	i := &Installation{}
	i.GetAccount()
	i = nil
	i.GetAccount()
}

func TestInstallation_GetAppID(tt *testing.T) {
	var zeroValue int64
	i := &Installation{AppID: &zeroValue}
	i.GetAppID()
	i = &Installation{}
	i.GetAppID()
	i = nil
	i.GetAppID()
}

func TestInstallation_GetAppSlug(tt *testing.T) {
	var zeroValue string
	i := &Installation{AppSlug: &zeroValue}
	i.GetAppSlug()
	i = &Installation{}
	i.GetAppSlug()
	i = nil
	i.GetAppSlug()
}

func TestInstallation_GetCreatedAt(tt *testing.T) {
	var zeroValue Timestamp
	i := &Installation{CreatedAt: &zeroValue}
	i.GetCreatedAt()
	i = &Installation{}
	i.GetCreatedAt()
	i = nil
	i.GetCreatedAt()
}

func TestInstallation_GetHasMultipleSingleFiles(tt *testing.T) {
	var zeroValue bool
	i := &Installation{HasMultipleSingleFiles: &zeroValue}
	i.GetHasMultipleSingleFiles()
	i = &Installation{}
	i.GetHasMultipleSingleFiles()
	i = nil
	i.GetHasMultipleSingleFiles()
}

func TestInstallation_GetHTMLURL(tt *testing.T) {
	var zeroValue string
	i := &Installation{HTMLURL: &zeroValue}
	i.GetHTMLURL()
	i = &Installation{}
	i.GetHTMLURL()
	i = nil
	i.GetHTMLURL()
}

func TestInstallation_GetID(tt *testing.T) {
	var zeroValue int64
	i := &Installation{ID: &zeroValue}
	i.GetID()
	i = &Installation{}
	i.GetID()
	i = nil
	i.GetID()
}

func TestInstallation_GetNodeID(tt *testing.T) {
	var zeroValue string
	i := &Installation{NodeID: &zeroValue}
	i.GetNodeID()
	i = &Installation{}
	i.GetNodeID()
	i = nil
	i.GetNodeID()
}

func TestInstallation_GetPermissions(tt *testing.T) {
	i := &Installation{}
	i.GetPermissions()
	i = nil
	i.GetPermissions()
}

func TestInstallation_GetRepositoriesURL(tt *testing.T) {
	var zeroValue string
	i := &Installation{RepositoriesURL: &zeroValue}
	i.GetRepositoriesURL()
	i = &Installation{}
	i.GetRepositoriesURL()
	i = nil
	i.GetRepositoriesURL()
}

func TestInstallation_GetRepositorySelection(tt *testing.T) {
	var zeroValue string
	i := &Installation{RepositorySelection: &zeroValue}
	i.GetRepositorySelection()
	i = &Installation{}
	i.GetRepositorySelection()
	i = nil
	i.GetRepositorySelection()
}

func TestInstallation_GetSingleFileName(tt *testing.T) {
	var zeroValue string
	i := &Installation{SingleFileName: &zeroValue}
	i.GetSingleFileName()
	i = &Installation{}
	i.GetSingleFileName()
	i = nil
	i.GetSingleFileName()
}

func TestInstallation_GetSuspendedAt(tt *testing.T) {
	var zeroValue Timestamp
	i := &Installation{SuspendedAt: &zeroValue}
	i.GetSuspendedAt()
	i = &Installation{}
	i.GetSuspendedAt()
	i = nil
	i.GetSuspendedAt()
}

func TestInstallation_GetSuspendedBy(tt *testing.T) {
	i := &Installation{}
	i.GetSuspendedBy()
	i = nil
	i.GetSuspendedBy()
}

func TestInstallation_GetTargetID(tt *testing.T) {
	var zeroValue int64
	i := &Installation{TargetID: &zeroValue}
	i.GetTargetID()
	i = &Installation{}
	i.GetTargetID()
	i = nil
	i.GetTargetID()
}

func TestInstallation_GetTargetType(tt *testing.T) {
	var zeroValue string
	i := &Installation{TargetType: &zeroValue}
	i.GetTargetType()
	i = &Installation{}
	i.GetTargetType()
	i = nil
	i.GetTargetType()
}

func TestInstallation_GetUpdatedAt(tt *testing.T) {
	var zeroValue Timestamp
	i := &Installation{UpdatedAt: &zeroValue}
	i.GetUpdatedAt()
	i = &Installation{}
	i.GetUpdatedAt()
	i = nil
	i.GetUpdatedAt()
}

func TestInstallationEvent_GetAction(tt *testing.T) {
	var zeroValue string
	i := &InstallationEvent{Action: &zeroValue}
	i.GetAction()
	i = &InstallationEvent{}
	i.GetAction()
	i = nil
	i.GetAction()
}

func TestInstallationEvent_GetInstallation(tt *testing.T) {
	i := &InstallationEvent{}
	i.GetInstallation()
	i = nil
	i.GetInstallation()
}

func TestInstallationEvent_GetSender(tt *testing.T) {
	i := &InstallationEvent{}
	i.GetSender()
	i = nil
	i.GetSender()
}

func TestInstallationPermissions_GetActions(tt *testing.T) {
	var zeroValue string
	i := &InstallationPermissions{Actions: &zeroValue}
	i.GetActions()
	i = &InstallationPermissions{}
	i.GetActions()
	i = nil
	i.GetActions()
}

func TestInstallationPermissions_GetAdministration(tt *testing.T) {
	var zeroValue string
	i := &InstallationPermissions{Administration: &zeroValue}
	i.GetAdministration()
	i = &InstallationPermissions{}
	i.GetAdministration()
	i = nil
	i.GetAdministration()
}

func TestInstallationPermissions_GetBlocking(tt *testing.T) {
	var zeroValue string
	i := &InstallationPermissions{Blocking: &zeroValue}
	i.GetBlocking()
	i = &InstallationPermissions{}
	i.GetBlocking()
	i = nil
	i.GetBlocking()
}

func TestInstallationPermissions_GetChecks(tt *testing.T) {
	var zeroValue string
	i := &InstallationPermissions{Checks: &zeroValue}
	i.GetChecks()
	i = &InstallationPermissions{}
	i.GetChecks()
	i = nil
	i.GetChecks()
}

func TestInstallationPermissions_GetContentReferences(tt *testing.T) {
	var zeroValue string
	i := &InstallationPermissions{ContentReferences: &zeroValue}
	i.GetContentReferences()
	i = &InstallationPermissions{}
	i.GetContentReferences()
	i = nil
	i.GetContentReferences()
}

func TestInstallationPermissions_GetContents(tt *testing.T) {
	var zeroValue string
	i := &InstallationPermissions{Contents: &zeroValue}
	i.GetContents()
	i = &InstallationPermissions{}
	i.GetContents()
	i = nil
	i.GetContents()
}

func TestInstallationPermissions_GetDeployments(tt *testing.T) {
	var zeroValue string
	i := &InstallationPermissions{Deployments: &zeroValue}
	i.GetDeployments()
	i = &InstallationPermissions{}
	i.GetDeployments()
	i = nil
	i.GetDeployments()
}

func TestInstallationPermissions_GetEmails(tt *testing.T) {
	var zeroValue string
	i := &InstallationPermissions{Emails: &zeroValue}
	i.GetEmails()
	i = &InstallationPermissions{}
	i.GetEmails()
	i = nil
	i.GetEmails()
}

func TestInstallationPermissions_GetEnvironments(tt *testing.T) {
	var zeroValue string
	i := &InstallationPermissions{Environments: &zeroValue}
	i.GetEnvironments()
	i = &InstallationPermissions{}
	i.GetEnvironments()
	i = nil
	i.GetEnvironments()
}

func TestInstallationPermissions_GetFollowers(tt *testing.T) {
	var zeroValue string
	i := &InstallationPermissions{Followers: &zeroValue}
	i.GetFollowers()
	i = &InstallationPermissions{}
	i.GetFollowers()
	i = nil
	i.GetFollowers()
}

func TestInstallationPermissions_GetIssues(tt *testing.T) {
	var zeroValue string
	i := &InstallationPermissions{Issues: &zeroValue}
	i.GetIssues()
	i = &InstallationPermissions{}
	i.GetIssues()
	i = nil
	i.GetIssues()
}

func TestInstallationPermissions_GetMembers(tt *testing.T) {
	var zeroValue string
	i := &InstallationPermissions{Members: &zeroValue}
	i.GetMembers()
	i = &InstallationPermissions{}
	i.GetMembers()
	i = nil
	i.GetMembers()
}

func TestInstallationPermissions_GetMetadata(tt *testing.T) {
	var zeroValue string
	i := &InstallationPermissions{Metadata: &zeroValue}
	i.GetMetadata()
	i = &InstallationPermissions{}
	i.GetMetadata()
	i = nil
	i.GetMetadata()
}

func TestInstallationPermissions_GetOrganizationAdministration(tt *testing.T) {
	var zeroValue string
	i := &InstallationPermissions{OrganizationAdministration: &zeroValue}
	i.GetOrganizationAdministration()
	i = &InstallationPermissions{}
	i.GetOrganizationAdministration()
	i = nil
	i.GetOrganizationAdministration()
}

func TestInstallationPermissions_GetOrganizationHooks(tt *testing.T) {
	var zeroValue string
	i := &InstallationPermissions{OrganizationHooks: &zeroValue}
	i.GetOrganizationHooks()
	i = &InstallationPermissions{}
	i.GetOrganizationHooks()
	i = nil
	i.GetOrganizationHooks()
}

func TestInstallationPermissions_GetOrganizationPlan(tt *testing.T) {
	var zeroValue string
	i := &InstallationPermissions{OrganizationPlan: &zeroValue}
	i.GetOrganizationPlan()
	i = &InstallationPermissions{}
	i.GetOrganizationPlan()
	i = nil
	i.GetOrganizationPlan()
}

func TestInstallationPermissions_GetOrganizationPreReceiveHooks(tt *testing.T) {
	var zeroValue string
	i := &InstallationPermissions{OrganizationPreReceiveHooks: &zeroValue}
	i.GetOrganizationPreReceiveHooks()
	i = &InstallationPermissions{}
	i.GetOrganizationPreReceiveHooks()
	i = nil
	i.GetOrganizationPreReceiveHooks()
}

func TestInstallationPermissions_GetOrganizationProjects(tt *testing.T) {
	var zeroValue string
	i := &InstallationPermissions{OrganizationProjects: &zeroValue}
	i.GetOrganizationProjects()
	i = &InstallationPermissions{}
	i.GetOrganizationProjects()
	i = nil
	i.GetOrganizationProjects()
}

func TestInstallationPermissions_GetOrganizationSecrets(tt *testing.T) {
	var zeroValue string
	i := &InstallationPermissions{OrganizationSecrets: &zeroValue}
	i.GetOrganizationSecrets()
	i = &InstallationPermissions{}
	i.GetOrganizationSecrets()
	i = nil
	i.GetOrganizationSecrets()
}

func TestInstallationPermissions_GetOrganizationSelfHostedRunners(tt *testing.T) {
	var zeroValue string
	i := &InstallationPermissions{OrganizationSelfHostedRunners: &zeroValue}
	i.GetOrganizationSelfHostedRunners()
	i = &InstallationPermissions{}
	i.GetOrganizationSelfHostedRunners()
	i = nil
	i.GetOrganizationSelfHostedRunners()
}

func TestInstallationPermissions_GetOrganizationUserBlocking(tt *testing.T) {
	var zeroValue string
	i := &InstallationPermissions{OrganizationUserBlocking: &zeroValue}
	i.GetOrganizationUserBlocking()
	i = &InstallationPermissions{}
	i.GetOrganizationUserBlocking()
	i = nil
	i.GetOrganizationUserBlocking()
}

func TestInstallationPermissions_GetPackages(tt *testing.T) {
	var zeroValue string
	i := &InstallationPermissions{Packages: &zeroValue}
	i.GetPackages()
	i = &InstallationPermissions{}
	i.GetPackages()
	i = nil
	i.GetPackages()
}

func TestInstallationPermissions_GetPages(tt *testing.T) {
	var zeroValue string
	i := &InstallationPermissions{Pages: &zeroValue}
	i.GetPages()
	i = &InstallationPermissions{}
	i.GetPages()
	i = nil
	i.GetPages()
}

func TestInstallationPermissions_GetPullRequests(tt *testing.T) {
	var zeroValue string
	i := &InstallationPermissions{PullRequests: &zeroValue}
	i.GetPullRequests()
	i = &InstallationPermissions{}
	i.GetPullRequests()
	i = nil
	i.GetPullRequests()
}

func TestInstallationPermissions_GetRepositoryHooks(tt *testing.T) {
	var zeroValue string
	i := &InstallationPermissions{RepositoryHooks: &zeroValue}
	i.GetRepositoryHooks()
	i = &InstallationPermissions{}
	i.GetRepositoryHooks()
	i = nil
	i.GetRepositoryHooks()
}

func TestInstallationPermissions_GetRepositoryPreReceiveHooks(tt *testing.T) {
	var zeroValue string
	i := &InstallationPermissions{RepositoryPreReceiveHooks: &zeroValue}
	i.GetRepositoryPreReceiveHooks()
	i = &InstallationPermissions{}
	i.GetRepositoryPreReceiveHooks()
	i = nil
	i.GetRepositoryPreReceiveHooks()
}

func TestInstallationPermissions_GetRepositoryProjects(tt *testing.T) {
	var zeroValue string
	i := &InstallationPermissions{RepositoryProjects: &zeroValue}
	i.GetRepositoryProjects()
	i = &InstallationPermissions{}
	i.GetRepositoryProjects()
	i = nil
	i.GetRepositoryProjects()
}

func TestInstallationPermissions_GetSecrets(tt *testing.T) {
	var zeroValue string
	i := &InstallationPermissions{Secrets: &zeroValue}
	i.GetSecrets()
	i = &InstallationPermissions{}
	i.GetSecrets()
	i = nil
	i.GetSecrets()
}

func TestInstallationPermissions_GetSecretScanningAlerts(tt *testing.T) {
	var zeroValue string
	i := &InstallationPermissions{SecretScanningAlerts: &zeroValue}
	i.GetSecretScanningAlerts()
	i = &InstallationPermissions{}
	i.GetSecretScanningAlerts()
	i = nil
	i.GetSecretScanningAlerts()
}

func TestInstallationPermissions_GetSecurityEvents(tt *testing.T) {
	var zeroValue string
	i := &InstallationPermissions{SecurityEvents: &zeroValue}
	i.GetSecurityEvents()
	i = &InstallationPermissions{}
	i.GetSecurityEvents()
	i = nil
	i.GetSecurityEvents()
}

func TestInstallationPermissions_GetSingleFile(tt *testing.T) {
	var zeroValue string
	i := &InstallationPermissions{SingleFile: &zeroValue}
	i.GetSingleFile()
	i = &InstallationPermissions{}
	i.GetSingleFile()
	i = nil
	i.GetSingleFile()
}

func TestInstallationPermissions_GetStatuses(tt *testing.T) {
	var zeroValue string
	i := &InstallationPermissions{Statuses: &zeroValue}
	i.GetStatuses()
	i = &InstallationPermissions{}
	i.GetStatuses()
	i = nil
	i.GetStatuses()
}

func TestInstallationPermissions_GetTeamDiscussions(tt *testing.T) {
	var zeroValue string
	i := &InstallationPermissions{TeamDiscussions: &zeroValue}
	i.GetTeamDiscussions()
	i = &InstallationPermissions{}
	i.GetTeamDiscussions()
	i = nil
	i.GetTeamDiscussions()
}

func TestInstallationPermissions_GetVulnerabilityAlerts(tt *testing.T) {
	var zeroValue string
	i := &InstallationPermissions{VulnerabilityAlerts: &zeroValue}
	i.GetVulnerabilityAlerts()
	i = &InstallationPermissions{}
	i.GetVulnerabilityAlerts()
	i = nil
	i.GetVulnerabilityAlerts()
}

func TestInstallationPermissions_GetWorkflows(tt *testing.T) {
	var zeroValue string
	i := &InstallationPermissions{Workflows: &zeroValue}
	i.GetWorkflows()
	i = &InstallationPermissions{}
	i.GetWorkflows()
	i = nil
	i.GetWorkflows()
}

func TestInstallationRepositoriesEvent_GetAction(tt *testing.T) {
	var zeroValue string
	i := &InstallationRepositoriesEvent{Action: &zeroValue}
	i.GetAction()
	i = &InstallationRepositoriesEvent{}
	i.GetAction()
	i = nil
	i.GetAction()
}

func TestInstallationRepositoriesEvent_GetInstallation(tt *testing.T) {
	i := &InstallationRepositoriesEvent{}
	i.GetInstallation()
	i = nil
	i.GetInstallation()
}

func TestInstallationRepositoriesEvent_GetRepositorySelection(tt *testing.T) {
	var zeroValue string
	i := &InstallationRepositoriesEvent{RepositorySelection: &zeroValue}
	i.GetRepositorySelection()
	i = &InstallationRepositoriesEvent{}
	i.GetRepositorySelection()
	i = nil
	i.GetRepositorySelection()
}

func TestInstallationRepositoriesEvent_GetSender(tt *testing.T) {
	i := &InstallationRepositoriesEvent{}
	i.GetSender()
	i = nil
	i.GetSender()
}

func TestInstallationToken_GetExpiresAt(tt *testing.T) {
	var zeroValue time.Time
	i := &InstallationToken{ExpiresAt: &zeroValue}
	i.GetExpiresAt()
	i = &InstallationToken{}
	i.GetExpiresAt()
	i = nil
	i.GetExpiresAt()
}

func TestInstallationToken_GetPermissions(tt *testing.T) {
	i := &InstallationToken{}
	i.GetPermissions()
	i = nil
	i.GetPermissions()
}

func TestInstallationToken_GetToken(tt *testing.T) {
	var zeroValue string
	i := &InstallationToken{Token: &zeroValue}
	i.GetToken()
	i = &InstallationToken{}
	i.GetToken()
	i = nil
	i.GetToken()
}

func TestInstallationTokenOptions_GetPermissions(tt *testing.T) {
	i := &InstallationTokenOptions{}
	i.GetPermissions()
	i = nil
	i.GetPermissions()
}

func TestInteractionRestriction_GetExpiresAt(tt *testing.T) {
	var zeroValue Timestamp
	i := &InteractionRestriction{ExpiresAt: &zeroValue}
	i.GetExpiresAt()
	i = &InteractionRestriction{}
	i.GetExpiresAt()
	i = nil
	i.GetExpiresAt()
}

func TestInteractionRestriction_GetLimit(tt *testing.T) {
	var zeroValue string
	i := &InteractionRestriction{Limit: &zeroValue}
	i.GetLimit()
	i = &InteractionRestriction{}
	i.GetLimit()
	i = nil
	i.GetLimit()
}

func TestInteractionRestriction_GetOrigin(tt *testing.T) {
	var zeroValue string
	i := &InteractionRestriction{Origin: &zeroValue}
	i.GetOrigin()
	i = &InteractionRestriction{}
	i.GetOrigin()
	i = nil
	i.GetOrigin()
}

func TestInvitation_GetCreatedAt(tt *testing.T) {
	var zeroValue time.Time
	i := &Invitation{CreatedAt: &zeroValue}
	i.GetCreatedAt()
	i = &Invitation{}
	i.GetCreatedAt()
	i = nil
	i.GetCreatedAt()
}

func TestInvitation_GetEmail(tt *testing.T) {
	var zeroValue string
	i := &Invitation{Email: &zeroValue}
	i.GetEmail()
	i = &Invitation{}
	i.GetEmail()
	i = nil
	i.GetEmail()
}

func TestInvitation_GetFailedAt(tt *testing.T) {
	var zeroValue Timestamp
	i := &Invitation{FailedAt: &zeroValue}
	i.GetFailedAt()
	i = &Invitation{}
	i.GetFailedAt()
	i = nil
	i.GetFailedAt()
}

func TestInvitation_GetFailedReason(tt *testing.T) {
	var zeroValue string
	i := &Invitation{FailedReason: &zeroValue}
	i.GetFailedReason()
	i = &Invitation{}
	i.GetFailedReason()
	i = nil
	i.GetFailedReason()
}

func TestInvitation_GetID(tt *testing.T) {
	var zeroValue int64
	i := &Invitation{ID: &zeroValue}
	i.GetID()
	i = &Invitation{}
	i.GetID()
	i = nil
	i.GetID()
}

func TestInvitation_GetInvitationTeamURL(tt *testing.T) {
	var zeroValue string
	i := &Invitation{InvitationTeamURL: &zeroValue}
	i.GetInvitationTeamURL()
	i = &Invitation{}
	i.GetInvitationTeamURL()
	i = nil
	i.GetInvitationTeamURL()
}

func TestInvitation_GetInviter(tt *testing.T) {
	i := &Invitation{}
	i.GetInviter()
	i = nil
	i.GetInviter()
}

func TestInvitation_GetLogin(tt *testing.T) {
	var zeroValue string
	i := &Invitation{Login: &zeroValue}
	i.GetLogin()
	i = &Invitation{}
	i.GetLogin()
	i = nil
	i.GetLogin()
}

func TestInvitation_GetNodeID(tt *testing.T) {
	var zeroValue string
	i := &Invitation{NodeID: &zeroValue}
	i.GetNodeID()
	i = &Invitation{}
	i.GetNodeID()
	i = nil
	i.GetNodeID()
}

func TestInvitation_GetRole(tt *testing.T) {
	var zeroValue string
	i := &Invitation{Role: &zeroValue}
	i.GetRole()
	i = &Invitation{}
	i.GetRole()
	i = nil
	i.GetRole()
}

func TestInvitation_GetTeamCount(tt *testing.T) {
	var zeroValue int
	i := &Invitation{TeamCount: &zeroValue}
	i.GetTeamCount()
	i = &Invitation{}
	i.GetTeamCount()
	i = nil
	i.GetTeamCount()
}

func TestIssue_GetActiveLockReason(tt *testing.T) {
	var zeroValue string
	i := &Issue{ActiveLockReason: &zeroValue}
	i.GetActiveLockReason()
	i = &Issue{}
	i.GetActiveLockReason()
	i = nil
	i.GetActiveLockReason()
}

func TestIssue_GetAssignee(tt *testing.T) {
	i := &Issue{}
	i.GetAssignee()
	i = nil
	i.GetAssignee()
}

func TestIssue_GetAuthorAssociation(tt *testing.T) {
	var zeroValue string
	i := &Issue{AuthorAssociation: &zeroValue}
	i.GetAuthorAssociation()
	i = &Issue{}
	i.GetAuthorAssociation()
	i = nil
	i.GetAuthorAssociation()
}

func TestIssue_GetBody(tt *testing.T) {
	var zeroValue string
	i := &Issue{Body: &zeroValue}
	i.GetBody()
	i = &Issue{}
	i.GetBody()
	i = nil
	i.GetBody()
}

func TestIssue_GetClosedAt(tt *testing.T) {
	var zeroValue time.Time
	i := &Issue{ClosedAt: &zeroValue}
	i.GetClosedAt()
	i = &Issue{}
	i.GetClosedAt()
	i = nil
	i.GetClosedAt()
}

func TestIssue_GetClosedBy(tt *testing.T) {
	i := &Issue{}
	i.GetClosedBy()
	i = nil
	i.GetClosedBy()
}

func TestIssue_GetComments(tt *testing.T) {
	var zeroValue int
	i := &Issue{Comments: &zeroValue}
	i.GetComments()
	i = &Issue{}
	i.GetComments()
	i = nil
	i.GetComments()
}

func TestIssue_GetCommentsURL(tt *testing.T) {
	var zeroValue string
	i := &Issue{CommentsURL: &zeroValue}
	i.GetCommentsURL()
	i = &Issue{}
	i.GetCommentsURL()
	i = nil
	i.GetCommentsURL()
}

func TestIssue_GetCreatedAt(tt *testing.T) {
	var zeroValue time.Time
	i := &Issue{CreatedAt: &zeroValue}
	i.GetCreatedAt()
	i = &Issue{}
	i.GetCreatedAt()
	i = nil
	i.GetCreatedAt()
}

func TestIssue_GetEventsURL(tt *testing.T) {
	var zeroValue string
	i := &Issue{EventsURL: &zeroValue}
	i.GetEventsURL()
	i = &Issue{}
	i.GetEventsURL()
	i = nil
	i.GetEventsURL()
}

func TestIssue_GetHTMLURL(tt *testing.T) {
	var zeroValue string
	i := &Issue{HTMLURL: &zeroValue}
	i.GetHTMLURL()
	i = &Issue{}
	i.GetHTMLURL()
	i = nil
	i.GetHTMLURL()
}

func TestIssue_GetID(tt *testing.T) {
	var zeroValue int64
	i := &Issue{ID: &zeroValue}
	i.GetID()
	i = &Issue{}
	i.GetID()
	i = nil
	i.GetID()
}

func TestIssue_GetLabelsURL(tt *testing.T) {
	var zeroValue string
	i := &Issue{LabelsURL: &zeroValue}
	i.GetLabelsURL()
	i = &Issue{}
	i.GetLabelsURL()
	i = nil
	i.GetLabelsURL()
}

func TestIssue_GetLocked(tt *testing.T) {
	var zeroValue bool
	i := &Issue{Locked: &zeroValue}
	i.GetLocked()
	i = &Issue{}
	i.GetLocked()
	i = nil
	i.GetLocked()
}

func TestIssue_GetMilestone(tt *testing.T) {
	i := &Issue{}
	i.GetMilestone()
	i = nil
	i.GetMilestone()
}

func TestIssue_GetNodeID(tt *testing.T) {
	var zeroValue string
	i := &Issue{NodeID: &zeroValue}
	i.GetNodeID()
	i = &Issue{}
	i.GetNodeID()
	i = nil
	i.GetNodeID()
}

func TestIssue_GetNumber(tt *testing.T) {
	var zeroValue int
	i := &Issue{Number: &zeroValue}
	i.GetNumber()
	i = &Issue{}
	i.GetNumber()
	i = nil
	i.GetNumber()
}

func TestIssue_GetPullRequestLinks(tt *testing.T) {
	i := &Issue{}
	i.GetPullRequestLinks()
	i = nil
	i.GetPullRequestLinks()
}

func TestIssue_GetReactions(tt *testing.T) {
	i := &Issue{}
	i.GetReactions()
	i = nil
	i.GetReactions()
}

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

func TestIssue_GetRepositoryURL(tt *testing.T) {
	var zeroValue string
	i := &Issue{RepositoryURL: &zeroValue}
	i.GetRepositoryURL()
	i = &Issue{}
	i.GetRepositoryURL()
	i = nil
	i.GetRepositoryURL()
}

func TestIssue_GetState(tt *testing.T) {
	var zeroValue string
	i := &Issue{State: &zeroValue}
	i.GetState()
	i = &Issue{}
	i.GetState()
	i = nil
	i.GetState()
}

func TestIssue_GetTitle(tt *testing.T) {
	var zeroValue string
	i := &Issue{Title: &zeroValue}
	i.GetTitle()
	i = &Issue{}
	i.GetTitle()
	i = nil
	i.GetTitle()
}

func TestIssue_GetUpdatedAt(tt *testing.T) {
	var zeroValue time.Time
	i := &Issue{UpdatedAt: &zeroValue}
	i.GetUpdatedAt()
	i = &Issue{}
	i.GetUpdatedAt()
	i = nil
	i.GetUpdatedAt()
}

func TestIssue_GetURL(tt *testing.T) {
	var zeroValue string
	i := &Issue{URL: &zeroValue}
	i.GetURL()
	i = &Issue{}
	i.GetURL()
	i = nil
	i.GetURL()
}

func TestIssue_GetUser(tt *testing.T) {
	i := &Issue{}
	i.GetUser()
	i = nil
	i.GetUser()
}

func TestIssueComment_GetAuthorAssociation(tt *testing.T) {
	var zeroValue string
	i := &IssueComment{AuthorAssociation: &zeroValue}
	i.GetAuthorAssociation()
	i = &IssueComment{}
	i.GetAuthorAssociation()
	i = nil
	i.GetAuthorAssociation()
}

func TestIssueComment_GetBody(tt *testing.T) {
	var zeroValue string
	i := &IssueComment{Body: &zeroValue}
	i.GetBody()
	i = &IssueComment{}
	i.GetBody()
	i = nil
	i.GetBody()
}

func TestIssueComment_GetCreatedAt(tt *testing.T) {
	var zeroValue time.Time
	i := &IssueComment{CreatedAt: &zeroValue}
	i.GetCreatedAt()
	i = &IssueComment{}
	i.GetCreatedAt()
	i = nil
	i.GetCreatedAt()
}

func TestIssueComment_GetHTMLURL(tt *testing.T) {
	var zeroValue string
	i := &IssueComment{HTMLURL: &zeroValue}
	i.GetHTMLURL()
	i = &IssueComment{}
	i.GetHTMLURL()
	i = nil
	i.GetHTMLURL()
}

func TestIssueComment_GetID(tt *testing.T) {
	var zeroValue int64
	i := &IssueComment{ID: &zeroValue}
	i.GetID()
	i = &IssueComment{}
	i.GetID()
	i = nil
	i.GetID()
}

func TestIssueComment_GetIssueURL(tt *testing.T) {
	var zeroValue string
	i := &IssueComment{IssueURL: &zeroValue}
	i.GetIssueURL()
	i = &IssueComment{}
	i.GetIssueURL()
	i = nil
	i.GetIssueURL()
}

func TestIssueComment_GetNodeID(tt *testing.T) {
	var zeroValue string
	i := &IssueComment{NodeID: &zeroValue}
	i.GetNodeID()
	i = &IssueComment{}
	i.GetNodeID()
	i = nil
	i.GetNodeID()
}

func TestIssueComment_GetReactions(tt *testing.T) {
	i := &IssueComment{}
	i.GetReactions()
	i = nil
	i.GetReactions()
}

func TestIssueComment_GetUpdatedAt(tt *testing.T) {
	var zeroValue time.Time
	i := &IssueComment{UpdatedAt: &zeroValue}
	i.GetUpdatedAt()
	i = &IssueComment{}
	i.GetUpdatedAt()
	i = nil
	i.GetUpdatedAt()
}

func TestIssueComment_GetURL(tt *testing.T) {
	var zeroValue string
	i := &IssueComment{URL: &zeroValue}
	i.GetURL()
	i = &IssueComment{}
	i.GetURL()
	i = nil
	i.GetURL()
}

func TestIssueComment_GetUser(tt *testing.T) {
	i := &IssueComment{}
	i.GetUser()
	i = nil
	i.GetUser()
}

func TestIssueCommentEvent_GetAction(tt *testing.T) {
	var zeroValue string
	i := &IssueCommentEvent{Action: &zeroValue}
	i.GetAction()
	i = &IssueCommentEvent{}
	i.GetAction()
	i = nil
	i.GetAction()
}

func TestIssueCommentEvent_GetChanges(tt *testing.T) {
	i := &IssueCommentEvent{}
	i.GetChanges()
	i = nil
	i.GetChanges()
}

func TestIssueCommentEvent_GetComment(tt *testing.T) {
	i := &IssueCommentEvent{}
	i.GetComment()
	i = nil
	i.GetComment()
}

func TestIssueCommentEvent_GetInstallation(tt *testing.T) {
	i := &IssueCommentEvent{}
	i.GetInstallation()
	i = nil
	i.GetInstallation()
}

func TestIssueCommentEvent_GetIssue(tt *testing.T) {
	i := &IssueCommentEvent{}
	i.GetIssue()
	i = nil
	i.GetIssue()
}

func TestIssueCommentEvent_GetOrganization(tt *testing.T) {
	i := &IssueCommentEvent{}
	i.GetOrganization()
	i = nil
	i.GetOrganization()
}

func TestIssueCommentEvent_GetRepo(tt *testing.T) {
	i := &IssueCommentEvent{}
	i.GetRepo()
	i = nil
	i.GetRepo()
}

func TestIssueCommentEvent_GetSender(tt *testing.T) {
	i := &IssueCommentEvent{}
	i.GetSender()
	i = nil
	i.GetSender()
}

func TestIssueEvent_GetActor(tt *testing.T) {
	i := &IssueEvent{}
	i.GetActor()
	i = nil
	i.GetActor()
}

func TestIssueEvent_GetAssignee(tt *testing.T) {
	i := &IssueEvent{}
	i.GetAssignee()
	i = nil
	i.GetAssignee()
}

func TestIssueEvent_GetAssigner(tt *testing.T) {
	i := &IssueEvent{}
	i.GetAssigner()
	i = nil
	i.GetAssigner()
}

func TestIssueEvent_GetCommitID(tt *testing.T) {
	var zeroValue string
	i := &IssueEvent{CommitID: &zeroValue}
	i.GetCommitID()
	i = &IssueEvent{}
	i.GetCommitID()
	i = nil
	i.GetCommitID()
}

func TestIssueEvent_GetCreatedAt(tt *testing.T) {
	var zeroValue time.Time
	i := &IssueEvent{CreatedAt: &zeroValue}
	i.GetCreatedAt()
	i = &IssueEvent{}
	i.GetCreatedAt()
	i = nil
	i.GetCreatedAt()
}

func TestIssueEvent_GetDismissedReview(tt *testing.T) {
	i := &IssueEvent{}
	i.GetDismissedReview()
	i = nil
	i.GetDismissedReview()
}

func TestIssueEvent_GetEvent(tt *testing.T) {
	var zeroValue string
	i := &IssueEvent{Event: &zeroValue}
	i.GetEvent()
	i = &IssueEvent{}
	i.GetEvent()
	i = nil
	i.GetEvent()
}

func TestIssueEvent_GetID(tt *testing.T) {
	var zeroValue int64
	i := &IssueEvent{ID: &zeroValue}
	i.GetID()
	i = &IssueEvent{}
	i.GetID()
	i = nil
	i.GetID()
}

func TestIssueEvent_GetIssue(tt *testing.T) {
	i := &IssueEvent{}
	i.GetIssue()
	i = nil
	i.GetIssue()
}

func TestIssueEvent_GetLabel(tt *testing.T) {
	i := &IssueEvent{}
	i.GetLabel()
	i = nil
	i.GetLabel()
}

func TestIssueEvent_GetLockReason(tt *testing.T) {
	var zeroValue string
	i := &IssueEvent{LockReason: &zeroValue}
	i.GetLockReason()
	i = &IssueEvent{}
	i.GetLockReason()
	i = nil
	i.GetLockReason()
}

func TestIssueEvent_GetMilestone(tt *testing.T) {
	i := &IssueEvent{}
	i.GetMilestone()
	i = nil
	i.GetMilestone()
}

func TestIssueEvent_GetProjectCard(tt *testing.T) {
	i := &IssueEvent{}
	i.GetProjectCard()
	i = nil
	i.GetProjectCard()
}

func TestIssueEvent_GetRename(tt *testing.T) {
	i := &IssueEvent{}
	i.GetRename()
	i = nil
	i.GetRename()
}

func TestIssueEvent_GetRequestedReviewer(tt *testing.T) {
	i := &IssueEvent{}
	i.GetRequestedReviewer()
	i = nil
	i.GetRequestedReviewer()
}

func TestIssueEvent_GetReviewRequester(tt *testing.T) {
	i := &IssueEvent{}
	i.GetReviewRequester()
	i = nil
	i.GetReviewRequester()
}

func TestIssueEvent_GetURL(tt *testing.T) {
	var zeroValue string
	i := &IssueEvent{URL: &zeroValue}
	i.GetURL()
	i = &IssueEvent{}
	i.GetURL()
	i = nil
	i.GetURL()
}

func TestIssueImport_GetAssignee(tt *testing.T) {
	var zeroValue string
	i := &IssueImport{Assignee: &zeroValue}
	i.GetAssignee()
	i = &IssueImport{}
	i.GetAssignee()
	i = nil
	i.GetAssignee()
}

func TestIssueImport_GetClosed(tt *testing.T) {
	var zeroValue bool
	i := &IssueImport{Closed: &zeroValue}
	i.GetClosed()
	i = &IssueImport{}
	i.GetClosed()
	i = nil
	i.GetClosed()
}

func TestIssueImport_GetClosedAt(tt *testing.T) {
	var zeroValue time.Time
	i := &IssueImport{ClosedAt: &zeroValue}
	i.GetClosedAt()
	i = &IssueImport{}
	i.GetClosedAt()
	i = nil
	i.GetClosedAt()
}

func TestIssueImport_GetCreatedAt(tt *testing.T) {
	var zeroValue time.Time
	i := &IssueImport{CreatedAt: &zeroValue}
	i.GetCreatedAt()
	i = &IssueImport{}
	i.GetCreatedAt()
	i = nil
	i.GetCreatedAt()
}

func TestIssueImport_GetMilestone(tt *testing.T) {
	var zeroValue int
	i := &IssueImport{Milestone: &zeroValue}
	i.GetMilestone()
	i = &IssueImport{}
	i.GetMilestone()
	i = nil
	i.GetMilestone()
}

func TestIssueImport_GetUpdatedAt(tt *testing.T) {
	var zeroValue time.Time
	i := &IssueImport{UpdatedAt: &zeroValue}
	i.GetUpdatedAt()
	i = &IssueImport{}
	i.GetUpdatedAt()
	i = nil
	i.GetUpdatedAt()
}

func TestIssueImportError_GetCode(tt *testing.T) {
	var zeroValue string
	i := &IssueImportError{Code: &zeroValue}
	i.GetCode()
	i = &IssueImportError{}
	i.GetCode()
	i = nil
	i.GetCode()
}

func TestIssueImportError_GetField(tt *testing.T) {
	var zeroValue string
	i := &IssueImportError{Field: &zeroValue}
	i.GetField()
	i = &IssueImportError{}
	i.GetField()
	i = nil
	i.GetField()
}

func TestIssueImportError_GetLocation(tt *testing.T) {
	var zeroValue string
	i := &IssueImportError{Location: &zeroValue}
	i.GetLocation()
	i = &IssueImportError{}
	i.GetLocation()
	i = nil
	i.GetLocation()
}

func TestIssueImportError_GetResource(tt *testing.T) {
	var zeroValue string
	i := &IssueImportError{Resource: &zeroValue}
	i.GetResource()
	i = &IssueImportError{}
	i.GetResource()
	i = nil
	i.GetResource()
}

func TestIssueImportError_GetValue(tt *testing.T) {
	var zeroValue string
	i := &IssueImportError{Value: &zeroValue}
	i.GetValue()
	i = &IssueImportError{}
	i.GetValue()
	i = nil
	i.GetValue()
}

func TestIssueImportResponse_GetCreatedAt(tt *testing.T) {
	var zeroValue time.Time
	i := &IssueImportResponse{CreatedAt: &zeroValue}
	i.GetCreatedAt()
	i = &IssueImportResponse{}
	i.GetCreatedAt()
	i = nil
	i.GetCreatedAt()
}

func TestIssueImportResponse_GetDocumentationURL(tt *testing.T) {
	var zeroValue string
	i := &IssueImportResponse{DocumentationURL: &zeroValue}
	i.GetDocumentationURL()
	i = &IssueImportResponse{}
	i.GetDocumentationURL()
	i = nil
	i.GetDocumentationURL()
}

func TestIssueImportResponse_GetID(tt *testing.T) {
	var zeroValue int
	i := &IssueImportResponse{ID: &zeroValue}
	i.GetID()
	i = &IssueImportResponse{}
	i.GetID()
	i = nil
	i.GetID()
}

func TestIssueImportResponse_GetImportIssuesURL(tt *testing.T) {
	var zeroValue string
	i := &IssueImportResponse{ImportIssuesURL: &zeroValue}
	i.GetImportIssuesURL()
	i = &IssueImportResponse{}
	i.GetImportIssuesURL()
	i = nil
	i.GetImportIssuesURL()
}

func TestIssueImportResponse_GetMessage(tt *testing.T) {
	var zeroValue string
	i := &IssueImportResponse{Message: &zeroValue}
	i.GetMessage()
	i = &IssueImportResponse{}
	i.GetMessage()
	i = nil
	i.GetMessage()
}

func TestIssueImportResponse_GetRepositoryURL(tt *testing.T) {
	var zeroValue string
	i := &IssueImportResponse{RepositoryURL: &zeroValue}
	i.GetRepositoryURL()
	i = &IssueImportResponse{}
	i.GetRepositoryURL()
	i = nil
	i.GetRepositoryURL()
}

func TestIssueImportResponse_GetStatus(tt *testing.T) {
	var zeroValue string
	i := &IssueImportResponse{Status: &zeroValue}
	i.GetStatus()
	i = &IssueImportResponse{}
	i.GetStatus()
	i = nil
	i.GetStatus()
}

func TestIssueImportResponse_GetUpdatedAt(tt *testing.T) {
	var zeroValue time.Time
	i := &IssueImportResponse{UpdatedAt: &zeroValue}
	i.GetUpdatedAt()
	i = &IssueImportResponse{}
	i.GetUpdatedAt()
	i = nil
	i.GetUpdatedAt()
}

func TestIssueImportResponse_GetURL(tt *testing.T) {
	var zeroValue string
	i := &IssueImportResponse{URL: &zeroValue}
	i.GetURL()
	i = &IssueImportResponse{}
	i.GetURL()
	i = nil
	i.GetURL()
}

func TestIssueListCommentsOptions_GetDirection(tt *testing.T) {
	var zeroValue string
	i := &IssueListCommentsOptions{Direction: &zeroValue}
	i.GetDirection()
	i = &IssueListCommentsOptions{}
	i.GetDirection()
	i = nil
	i.GetDirection()
}

func TestIssueListCommentsOptions_GetSince(tt *testing.T) {
	var zeroValue time.Time
	i := &IssueListCommentsOptions{Since: &zeroValue}
	i.GetSince()
	i = &IssueListCommentsOptions{}
	i.GetSince()
	i = nil
	i.GetSince()
}

func TestIssueListCommentsOptions_GetSort(tt *testing.T) {
	var zeroValue string
	i := &IssueListCommentsOptions{Sort: &zeroValue}
	i.GetSort()
	i = &IssueListCommentsOptions{}
	i.GetSort()
	i = nil
	i.GetSort()
}

func TestIssueRequest_GetAssignee(tt *testing.T) {
	var zeroValue string
	i := &IssueRequest{Assignee: &zeroValue}
	i.GetAssignee()
	i = &IssueRequest{}
	i.GetAssignee()
	i = nil
	i.GetAssignee()
}

func TestIssueRequest_GetAssignees(tt *testing.T) {
	var zeroValue []string
	i := &IssueRequest{Assignees: &zeroValue}
	i.GetAssignees()
	i = &IssueRequest{}
	i.GetAssignees()
	i = nil
	i.GetAssignees()
}

func TestIssueRequest_GetBody(tt *testing.T) {
	var zeroValue string
	i := &IssueRequest{Body: &zeroValue}
	i.GetBody()
	i = &IssueRequest{}
	i.GetBody()
	i = nil
	i.GetBody()
}

func TestIssueRequest_GetLabels(tt *testing.T) {
	var zeroValue []string
	i := &IssueRequest{Labels: &zeroValue}
	i.GetLabels()
	i = &IssueRequest{}
	i.GetLabels()
	i = nil
	i.GetLabels()
}

func TestIssueRequest_GetMilestone(tt *testing.T) {
	var zeroValue int
	i := &IssueRequest{Milestone: &zeroValue}
	i.GetMilestone()
	i = &IssueRequest{}
	i.GetMilestone()
	i = nil
	i.GetMilestone()
}

func TestIssueRequest_GetState(tt *testing.T) {
	var zeroValue string
	i := &IssueRequest{State: &zeroValue}
	i.GetState()
	i = &IssueRequest{}
	i.GetState()
	i = nil
	i.GetState()
}

func TestIssueRequest_GetTitle(tt *testing.T) {
	var zeroValue string
	i := &IssueRequest{Title: &zeroValue}
	i.GetTitle()
	i = &IssueRequest{}
	i.GetTitle()
	i = nil
	i.GetTitle()
}

func TestIssuesEvent_GetAction(tt *testing.T) {
	var zeroValue string
	i := &IssuesEvent{Action: &zeroValue}
	i.GetAction()
	i = &IssuesEvent{}
	i.GetAction()
	i = nil
	i.GetAction()
}

func TestIssuesEvent_GetAssignee(tt *testing.T) {
	i := &IssuesEvent{}
	i.GetAssignee()
	i = nil
	i.GetAssignee()
}

func TestIssuesEvent_GetChanges(tt *testing.T) {
	i := &IssuesEvent{}
	i.GetChanges()
	i = nil
	i.GetChanges()
}

func TestIssuesEvent_GetInstallation(tt *testing.T) {
	i := &IssuesEvent{}
	i.GetInstallation()
	i = nil
	i.GetInstallation()
}

func TestIssuesEvent_GetIssue(tt *testing.T) {
	i := &IssuesEvent{}
	i.GetIssue()
	i = nil
	i.GetIssue()
}

func TestIssuesEvent_GetLabel(tt *testing.T) {
	i := &IssuesEvent{}
	i.GetLabel()
	i = nil
	i.GetLabel()
}

func TestIssuesEvent_GetRepo(tt *testing.T) {
	i := &IssuesEvent{}
	i.GetRepo()
	i = nil
	i.GetRepo()
}

func TestIssuesEvent_GetSender(tt *testing.T) {
	i := &IssuesEvent{}
	i.GetSender()
	i = nil
	i.GetSender()
}

func TestIssuesSearchResult_GetIncompleteResults(tt *testing.T) {
	var zeroValue bool
	i := &IssuesSearchResult{IncompleteResults: &zeroValue}
	i.GetIncompleteResults()
	i = &IssuesSearchResult{}
	i.GetIncompleteResults()
	i = nil
	i.GetIncompleteResults()
}

func TestIssuesSearchResult_GetTotal(tt *testing.T) {
	var zeroValue int
	i := &IssuesSearchResult{Total: &zeroValue}
	i.GetTotal()
	i = &IssuesSearchResult{}
	i.GetTotal()
	i = nil
	i.GetTotal()
}

func TestIssueStats_GetClosedIssues(tt *testing.T) {
	var zeroValue int
	i := &IssueStats{ClosedIssues: &zeroValue}
	i.GetClosedIssues()
	i = &IssueStats{}
	i.GetClosedIssues()
	i = nil
	i.GetClosedIssues()
}

func TestIssueStats_GetOpenIssues(tt *testing.T) {
	var zeroValue int
	i := &IssueStats{OpenIssues: &zeroValue}
	i.GetOpenIssues()
	i = &IssueStats{}
	i.GetOpenIssues()
	i = nil
	i.GetOpenIssues()
}

func TestIssueStats_GetTotalIssues(tt *testing.T) {
	var zeroValue int
	i := &IssueStats{TotalIssues: &zeroValue}
	i.GetTotalIssues()
	i = &IssueStats{}
	i.GetTotalIssues()
	i = nil
	i.GetTotalIssues()
}

func TestJobs_GetTotalCount(tt *testing.T) {
	var zeroValue int
	j := &Jobs{TotalCount: &zeroValue}
	j.GetTotalCount()
	j = &Jobs{}
	j.GetTotalCount()
	j = nil
	j.GetTotalCount()
}

func TestKey_GetCreatedAt(tt *testing.T) {
	var zeroValue Timestamp
	k := &Key{CreatedAt: &zeroValue}
	k.GetCreatedAt()
	k = &Key{}
	k.GetCreatedAt()
	k = nil
	k.GetCreatedAt()
}

func TestKey_GetID(tt *testing.T) {
	var zeroValue int64
	k := &Key{ID: &zeroValue}
	k.GetID()
	k = &Key{}
	k.GetID()
	k = nil
	k.GetID()
}

func TestKey_GetKey(tt *testing.T) {
	var zeroValue string
	k := &Key{Key: &zeroValue}
	k.GetKey()
	k = &Key{}
	k.GetKey()
	k = nil
	k.GetKey()
}

func TestKey_GetReadOnly(tt *testing.T) {
	var zeroValue bool
	k := &Key{ReadOnly: &zeroValue}
	k.GetReadOnly()
	k = &Key{}
	k.GetReadOnly()
	k = nil
	k.GetReadOnly()
}

func TestKey_GetTitle(tt *testing.T) {
	var zeroValue string
	k := &Key{Title: &zeroValue}
	k.GetTitle()
	k = &Key{}
	k.GetTitle()
	k = nil
	k.GetTitle()
}

func TestKey_GetURL(tt *testing.T) {
	var zeroValue string
	k := &Key{URL: &zeroValue}
	k.GetURL()
	k = &Key{}
	k.GetURL()
	k = nil
	k.GetURL()
}

func TestKey_GetVerified(tt *testing.T) {
	var zeroValue bool
	k := &Key{Verified: &zeroValue}
	k.GetVerified()
	k = &Key{}
	k.GetVerified()
	k = nil
	k.GetVerified()
}

func TestLabel_GetColor(tt *testing.T) {
	var zeroValue string
	l := &Label{Color: &zeroValue}
	l.GetColor()
	l = &Label{}
	l.GetColor()
	l = nil
	l.GetColor()
}

func TestLabel_GetDefault(tt *testing.T) {
	var zeroValue bool
	l := &Label{Default: &zeroValue}
	l.GetDefault()
	l = &Label{}
	l.GetDefault()
	l = nil
	l.GetDefault()
}

func TestLabel_GetDescription(tt *testing.T) {
	var zeroValue string
	l := &Label{Description: &zeroValue}
	l.GetDescription()
	l = &Label{}
	l.GetDescription()
	l = nil
	l.GetDescription()
}

func TestLabel_GetID(tt *testing.T) {
	var zeroValue int64
	l := &Label{ID: &zeroValue}
	l.GetID()
	l = &Label{}
	l.GetID()
	l = nil
	l.GetID()
}

func TestLabel_GetName(tt *testing.T) {
	var zeroValue string
	l := &Label{Name: &zeroValue}
	l.GetName()
	l = &Label{}
	l.GetName()
	l = nil
	l.GetName()
}

func TestLabel_GetNodeID(tt *testing.T) {
	var zeroValue string
	l := &Label{NodeID: &zeroValue}
	l.GetNodeID()
	l = &Label{}
	l.GetNodeID()
	l = nil
	l.GetNodeID()
}

func TestLabel_GetURL(tt *testing.T) {
	var zeroValue string
	l := &Label{URL: &zeroValue}
	l.GetURL()
	l = &Label{}
	l.GetURL()
	l = nil
	l.GetURL()
}

func TestLabelEvent_GetAction(tt *testing.T) {
	var zeroValue string
	l := &LabelEvent{Action: &zeroValue}
	l.GetAction()
	l = &LabelEvent{}
	l.GetAction()
	l = nil
	l.GetAction()
}

func TestLabelEvent_GetChanges(tt *testing.T) {
	l := &LabelEvent{}
	l.GetChanges()
	l = nil
	l.GetChanges()
}

func TestLabelEvent_GetInstallation(tt *testing.T) {
	l := &LabelEvent{}
	l.GetInstallation()
	l = nil
	l.GetInstallation()
}

func TestLabelEvent_GetLabel(tt *testing.T) {
	l := &LabelEvent{}
	l.GetLabel()
	l = nil
	l.GetLabel()
}

func TestLabelEvent_GetOrg(tt *testing.T) {
	l := &LabelEvent{}
	l.GetOrg()
	l = nil
	l.GetOrg()
}

func TestLabelEvent_GetRepo(tt *testing.T) {
	l := &LabelEvent{}
	l.GetRepo()
	l = nil
	l.GetRepo()
}

func TestLabelResult_GetColor(tt *testing.T) {
	var zeroValue string
	l := &LabelResult{Color: &zeroValue}
	l.GetColor()
	l = &LabelResult{}
	l.GetColor()
	l = nil
	l.GetColor()
}

func TestLabelResult_GetDefault(tt *testing.T) {
	var zeroValue bool
	l := &LabelResult{Default: &zeroValue}
	l.GetDefault()
	l = &LabelResult{}
	l.GetDefault()
	l = nil
	l.GetDefault()
}

func TestLabelResult_GetDescription(tt *testing.T) {
	var zeroValue string
	l := &LabelResult{Description: &zeroValue}
	l.GetDescription()
	l = &LabelResult{}
	l.GetDescription()
	l = nil
	l.GetDescription()
}

func TestLabelResult_GetID(tt *testing.T) {
	var zeroValue int64
	l := &LabelResult{ID: &zeroValue}
	l.GetID()
	l = &LabelResult{}
	l.GetID()
	l = nil
	l.GetID()
}

func TestLabelResult_GetName(tt *testing.T) {
	var zeroValue string
	l := &LabelResult{Name: &zeroValue}
	l.GetName()
	l = &LabelResult{}
	l.GetName()
	l = nil
	l.GetName()
}

func TestLabelResult_GetScore(tt *testing.T) {
	l := &LabelResult{}
	l.GetScore()
	l = nil
	l.GetScore()
}

func TestLabelResult_GetURL(tt *testing.T) {
	var zeroValue string
	l := &LabelResult{URL: &zeroValue}
	l.GetURL()
	l = &LabelResult{}
	l.GetURL()
	l = nil
	l.GetURL()
}

func TestLabelsSearchResult_GetIncompleteResults(tt *testing.T) {
	var zeroValue bool
	l := &LabelsSearchResult{IncompleteResults: &zeroValue}
	l.GetIncompleteResults()
	l = &LabelsSearchResult{}
	l.GetIncompleteResults()
	l = nil
	l.GetIncompleteResults()
}

func TestLabelsSearchResult_GetTotal(tt *testing.T) {
	var zeroValue int
	l := &LabelsSearchResult{Total: &zeroValue}
	l.GetTotal()
	l = &LabelsSearchResult{}
	l.GetTotal()
	l = nil
	l.GetTotal()
}

func TestLargeFile_GetOID(tt *testing.T) {
	var zeroValue string
	l := &LargeFile{OID: &zeroValue}
	l.GetOID()
	l = &LargeFile{}
	l.GetOID()
	l = nil
	l.GetOID()
}

func TestLargeFile_GetPath(tt *testing.T) {
	var zeroValue string
	l := &LargeFile{Path: &zeroValue}
	l.GetPath()
	l = &LargeFile{}
	l.GetPath()
	l = nil
	l.GetPath()
}

func TestLargeFile_GetRefName(tt *testing.T) {
	var zeroValue string
	l := &LargeFile{RefName: &zeroValue}
	l.GetRefName()
	l = &LargeFile{}
	l.GetRefName()
	l = nil
	l.GetRefName()
}

func TestLargeFile_GetSize(tt *testing.T) {
	var zeroValue int
	l := &LargeFile{Size: &zeroValue}
	l.GetSize()
	l = &LargeFile{}
	l.GetSize()
	l = nil
	l.GetSize()
}

func TestLicense_GetBody(tt *testing.T) {
	var zeroValue string
	l := &License{Body: &zeroValue}
	l.GetBody()
	l = &License{}
	l.GetBody()
	l = nil
	l.GetBody()
}

func TestLicense_GetConditions(tt *testing.T) {
	var zeroValue []string
	l := &License{Conditions: &zeroValue}
	l.GetConditions()
	l = &License{}
	l.GetConditions()
	l = nil
	l.GetConditions()
}

func TestLicense_GetDescription(tt *testing.T) {
	var zeroValue string
	l := &License{Description: &zeroValue}
	l.GetDescription()
	l = &License{}
	l.GetDescription()
	l = nil
	l.GetDescription()
}

func TestLicense_GetFeatured(tt *testing.T) {
	var zeroValue bool
	l := &License{Featured: &zeroValue}
	l.GetFeatured()
	l = &License{}
	l.GetFeatured()
	l = nil
	l.GetFeatured()
}

func TestLicense_GetHTMLURL(tt *testing.T) {
	var zeroValue string
	l := &License{HTMLURL: &zeroValue}
	l.GetHTMLURL()
	l = &License{}
	l.GetHTMLURL()
	l = nil
	l.GetHTMLURL()
}

func TestLicense_GetImplementation(tt *testing.T) {
	var zeroValue string
	l := &License{Implementation: &zeroValue}
	l.GetImplementation()
	l = &License{}
	l.GetImplementation()
	l = nil
	l.GetImplementation()
}

func TestLicense_GetKey(tt *testing.T) {
	var zeroValue string
	l := &License{Key: &zeroValue}
	l.GetKey()
	l = &License{}
	l.GetKey()
	l = nil
	l.GetKey()
}

func TestLicense_GetLimitations(tt *testing.T) {
	var zeroValue []string
	l := &License{Limitations: &zeroValue}
	l.GetLimitations()
	l = &License{}
	l.GetLimitations()
	l = nil
	l.GetLimitations()
}

func TestLicense_GetName(tt *testing.T) {
	var zeroValue string
	l := &License{Name: &zeroValue}
	l.GetName()
	l = &License{}
	l.GetName()
	l = nil
	l.GetName()
}

func TestLicense_GetPermissions(tt *testing.T) {
	var zeroValue []string
	l := &License{Permissions: &zeroValue}
	l.GetPermissions()
	l = &License{}
	l.GetPermissions()
	l = nil
	l.GetPermissions()
}

func TestLicense_GetSPDXID(tt *testing.T) {
	var zeroValue string
	l := &License{SPDXID: &zeroValue}
	l.GetSPDXID()
	l = &License{}
	l.GetSPDXID()
	l = nil
	l.GetSPDXID()
}

func TestLicense_GetURL(tt *testing.T) {
	var zeroValue string
	l := &License{URL: &zeroValue}
	l.GetURL()
	l = &License{}
	l.GetURL()
	l = nil
	l.GetURL()
}

func TestListCheckRunsOptions_GetAppID(tt *testing.T) {
	var zeroValue int64
	l := &ListCheckRunsOptions{AppID: &zeroValue}
	l.GetAppID()
	l = &ListCheckRunsOptions{}
	l.GetAppID()
	l = nil
	l.GetAppID()
}

func TestListCheckRunsOptions_GetCheckName(tt *testing.T) {
	var zeroValue string
	l := &ListCheckRunsOptions{CheckName: &zeroValue}
	l.GetCheckName()
	l = &ListCheckRunsOptions{}
	l.GetCheckName()
	l = nil
	l.GetCheckName()
}

func TestListCheckRunsOptions_GetFilter(tt *testing.T) {
	var zeroValue string
	l := &ListCheckRunsOptions{Filter: &zeroValue}
	l.GetFilter()
	l = &ListCheckRunsOptions{}
	l.GetFilter()
	l = nil
	l.GetFilter()
}

func TestListCheckRunsOptions_GetStatus(tt *testing.T) {
	var zeroValue string
	l := &ListCheckRunsOptions{Status: &zeroValue}
	l.GetStatus()
	l = &ListCheckRunsOptions{}
	l.GetStatus()
	l = nil
	l.GetStatus()
}

func TestListCheckRunsResults_GetTotal(tt *testing.T) {
	var zeroValue int
	l := &ListCheckRunsResults{Total: &zeroValue}
	l.GetTotal()
	l = &ListCheckRunsResults{}
	l.GetTotal()
	l = nil
	l.GetTotal()
}

func TestListCheckSuiteOptions_GetAppID(tt *testing.T) {
	var zeroValue int
	l := &ListCheckSuiteOptions{AppID: &zeroValue}
	l.GetAppID()
	l = &ListCheckSuiteOptions{}
	l.GetAppID()
	l = nil
	l.GetAppID()
}

func TestListCheckSuiteOptions_GetCheckName(tt *testing.T) {
	var zeroValue string
	l := &ListCheckSuiteOptions{CheckName: &zeroValue}
	l.GetCheckName()
	l = &ListCheckSuiteOptions{}
	l.GetCheckName()
	l = nil
	l.GetCheckName()
}

func TestListCheckSuiteResults_GetTotal(tt *testing.T) {
	var zeroValue int
	l := &ListCheckSuiteResults{Total: &zeroValue}
	l.GetTotal()
	l = &ListCheckSuiteResults{}
	l.GetTotal()
	l = nil
	l.GetTotal()
}

func TestListCollaboratorOptions_GetAffiliation(tt *testing.T) {
	var zeroValue string
	l := &ListCollaboratorOptions{Affiliation: &zeroValue}
	l.GetAffiliation()
	l = &ListCollaboratorOptions{}
	l.GetAffiliation()
	l = nil
	l.GetAffiliation()
}

func TestListExternalGroupsOptions_GetDisplayName(tt *testing.T) {
	var zeroValue string
	l := &ListExternalGroupsOptions{DisplayName: &zeroValue}
	l.GetDisplayName()
	l = &ListExternalGroupsOptions{}
	l.GetDisplayName()
	l = nil
	l.GetDisplayName()
}

func TestListRepositories_GetTotalCount(tt *testing.T) {
	var zeroValue int
	l := &ListRepositories{TotalCount: &zeroValue}
	l.GetTotalCount()
	l = &ListRepositories{}
	l.GetTotalCount()
	l = nil
	l.GetTotalCount()
}

func TestListSCIMProvisionedIdentitiesOptions_GetCount(tt *testing.T) {
	var zeroValue int
	l := &ListSCIMProvisionedIdentitiesOptions{Count: &zeroValue}
	l.GetCount()
	l = &ListSCIMProvisionedIdentitiesOptions{}
	l.GetCount()
	l = nil
	l.GetCount()
}

func TestListSCIMProvisionedIdentitiesOptions_GetFilter(tt *testing.T) {
	var zeroValue string
	l := &ListSCIMProvisionedIdentitiesOptions{Filter: &zeroValue}
	l.GetFilter()
	l = &ListSCIMProvisionedIdentitiesOptions{}
	l.GetFilter()
	l = nil
	l.GetFilter()
}

func TestListSCIMProvisionedIdentitiesOptions_GetStartIndex(tt *testing.T) {
	var zeroValue int
	l := &ListSCIMProvisionedIdentitiesOptions{StartIndex: &zeroValue}
	l.GetStartIndex()
	l = &ListSCIMProvisionedIdentitiesOptions{}
	l.GetStartIndex()
	l = nil
	l.GetStartIndex()
}

func TestLocation_GetEndColumn(tt *testing.T) {
	var zeroValue int
	l := &Location{EndColumn: &zeroValue}
	l.GetEndColumn()
	l = &Location{}
	l.GetEndColumn()
	l = nil
	l.GetEndColumn()
}

func TestLocation_GetEndLine(tt *testing.T) {
	var zeroValue int
	l := &Location{EndLine: &zeroValue}
	l.GetEndLine()
	l = &Location{}
	l.GetEndLine()
	l = nil
	l.GetEndLine()
}

func TestLocation_GetPath(tt *testing.T) {
	var zeroValue string
	l := &Location{Path: &zeroValue}
	l.GetPath()
	l = &Location{}
	l.GetPath()
	l = nil
	l.GetPath()
}

func TestLocation_GetStartColumn(tt *testing.T) {
	var zeroValue int
	l := &Location{StartColumn: &zeroValue}
	l.GetStartColumn()
	l = &Location{}
	l.GetStartColumn()
	l = nil
	l.GetStartColumn()
}

func TestLocation_GetStartLine(tt *testing.T) {
	var zeroValue int
	l := &Location{StartLine: &zeroValue}
	l.GetStartLine()
	l = &Location{}
	l.GetStartLine()
	l = nil
	l.GetStartLine()
}

func TestMarketplacePendingChange_GetEffectiveDate(tt *testing.T) {
	var zeroValue Timestamp
	m := &MarketplacePendingChange{EffectiveDate: &zeroValue}
	m.GetEffectiveDate()
	m = &MarketplacePendingChange{}
	m.GetEffectiveDate()
	m = nil
	m.GetEffectiveDate()
}

func TestMarketplacePendingChange_GetID(tt *testing.T) {
	var zeroValue int64
	m := &MarketplacePendingChange{ID: &zeroValue}
	m.GetID()
	m = &MarketplacePendingChange{}
	m.GetID()
	m = nil
	m.GetID()
}

func TestMarketplacePendingChange_GetPlan(tt *testing.T) {
	m := &MarketplacePendingChange{}
	m.GetPlan()
	m = nil
	m.GetPlan()
}

func TestMarketplacePendingChange_GetUnitCount(tt *testing.T) {
	var zeroValue int
	m := &MarketplacePendingChange{UnitCount: &zeroValue}
	m.GetUnitCount()
	m = &MarketplacePendingChange{}
	m.GetUnitCount()
	m = nil
	m.GetUnitCount()
}

func TestMarketplacePlan_GetAccountsURL(tt *testing.T) {
	var zeroValue string
	m := &MarketplacePlan{AccountsURL: &zeroValue}
	m.GetAccountsURL()
	m = &MarketplacePlan{}
	m.GetAccountsURL()
	m = nil
	m.GetAccountsURL()
}

func TestMarketplacePlan_GetBullets(tt *testing.T) {
	var zeroValue []string
	m := &MarketplacePlan{Bullets: &zeroValue}
	m.GetBullets()
	m = &MarketplacePlan{}
	m.GetBullets()
	m = nil
	m.GetBullets()
}

func TestMarketplacePlan_GetDescription(tt *testing.T) {
	var zeroValue string
	m := &MarketplacePlan{Description: &zeroValue}
	m.GetDescription()
	m = &MarketplacePlan{}
	m.GetDescription()
	m = nil
	m.GetDescription()
}

func TestMarketplacePlan_GetHasFreeTrial(tt *testing.T) {
	var zeroValue bool
	m := &MarketplacePlan{HasFreeTrial: &zeroValue}
	m.GetHasFreeTrial()
	m = &MarketplacePlan{}
	m.GetHasFreeTrial()
	m = nil
	m.GetHasFreeTrial()
}

func TestMarketplacePlan_GetID(tt *testing.T) {
	var zeroValue int64
	m := &MarketplacePlan{ID: &zeroValue}
	m.GetID()
	m = &MarketplacePlan{}
	m.GetID()
	m = nil
	m.GetID()
}

func TestMarketplacePlan_GetMonthlyPriceInCents(tt *testing.T) {
	var zeroValue int
	m := &MarketplacePlan{MonthlyPriceInCents: &zeroValue}
	m.GetMonthlyPriceInCents()
	m = &MarketplacePlan{}
	m.GetMonthlyPriceInCents()
	m = nil
	m.GetMonthlyPriceInCents()
}

func TestMarketplacePlan_GetName(tt *testing.T) {
	var zeroValue string
	m := &MarketplacePlan{Name: &zeroValue}
	m.GetName()
	m = &MarketplacePlan{}
	m.GetName()
	m = nil
	m.GetName()
}

func TestMarketplacePlan_GetNumber(tt *testing.T) {
	var zeroValue int
	m := &MarketplacePlan{Number: &zeroValue}
	m.GetNumber()
	m = &MarketplacePlan{}
	m.GetNumber()
	m = nil
	m.GetNumber()
}

func TestMarketplacePlan_GetPriceModel(tt *testing.T) {
	var zeroValue string
	m := &MarketplacePlan{PriceModel: &zeroValue}
	m.GetPriceModel()
	m = &MarketplacePlan{}
	m.GetPriceModel()
	m = nil
	m.GetPriceModel()
}

func TestMarketplacePlan_GetState(tt *testing.T) {
	var zeroValue string
	m := &MarketplacePlan{State: &zeroValue}
	m.GetState()
	m = &MarketplacePlan{}
	m.GetState()
	m = nil
	m.GetState()
}

func TestMarketplacePlan_GetUnitName(tt *testing.T) {
	var zeroValue string
	m := &MarketplacePlan{UnitName: &zeroValue}
	m.GetUnitName()
	m = &MarketplacePlan{}
	m.GetUnitName()
	m = nil
	m.GetUnitName()
}

func TestMarketplacePlan_GetURL(tt *testing.T) {
	var zeroValue string
	m := &MarketplacePlan{URL: &zeroValue}
	m.GetURL()
	m = &MarketplacePlan{}
	m.GetURL()
	m = nil
	m.GetURL()
}

func TestMarketplacePlan_GetYearlyPriceInCents(tt *testing.T) {
	var zeroValue int
	m := &MarketplacePlan{YearlyPriceInCents: &zeroValue}
	m.GetYearlyPriceInCents()
	m = &MarketplacePlan{}
	m.GetYearlyPriceInCents()
	m = nil
	m.GetYearlyPriceInCents()
}

func TestMarketplacePlanAccount_GetID(tt *testing.T) {
	var zeroValue int64
	m := &MarketplacePlanAccount{ID: &zeroValue}
	m.GetID()
	m = &MarketplacePlanAccount{}
	m.GetID()
	m = nil
	m.GetID()
}

func TestMarketplacePlanAccount_GetLogin(tt *testing.T) {
	var zeroValue string
	m := &MarketplacePlanAccount{Login: &zeroValue}
	m.GetLogin()
	m = &MarketplacePlanAccount{}
	m.GetLogin()
	m = nil
	m.GetLogin()
}

func TestMarketplacePlanAccount_GetMarketplacePendingChange(tt *testing.T) {
	m := &MarketplacePlanAccount{}
	m.GetMarketplacePendingChange()
	m = nil
	m.GetMarketplacePendingChange()
}

func TestMarketplacePlanAccount_GetMarketplacePurchase(tt *testing.T) {
	m := &MarketplacePlanAccount{}
	m.GetMarketplacePurchase()
	m = nil
	m.GetMarketplacePurchase()
}

func TestMarketplacePlanAccount_GetOrganizationBillingEmail(tt *testing.T) {
	var zeroValue string
	m := &MarketplacePlanAccount{OrganizationBillingEmail: &zeroValue}
	m.GetOrganizationBillingEmail()
	m = &MarketplacePlanAccount{}
	m.GetOrganizationBillingEmail()
	m = nil
	m.GetOrganizationBillingEmail()
}

func TestMarketplacePlanAccount_GetType(tt *testing.T) {
	var zeroValue string
	m := &MarketplacePlanAccount{Type: &zeroValue}
	m.GetType()
	m = &MarketplacePlanAccount{}
	m.GetType()
	m = nil
	m.GetType()
}

func TestMarketplacePlanAccount_GetURL(tt *testing.T) {
	var zeroValue string
	m := &MarketplacePlanAccount{URL: &zeroValue}
	m.GetURL()
	m = &MarketplacePlanAccount{}
	m.GetURL()
	m = nil
	m.GetURL()
}

func TestMarketplacePurchase_GetBillingCycle(tt *testing.T) {
	var zeroValue string
	m := &MarketplacePurchase{BillingCycle: &zeroValue}
	m.GetBillingCycle()
	m = &MarketplacePurchase{}
	m.GetBillingCycle()
	m = nil
	m.GetBillingCycle()
}

func TestMarketplacePurchase_GetFreeTrialEndsOn(tt *testing.T) {
	var zeroValue Timestamp
	m := &MarketplacePurchase{FreeTrialEndsOn: &zeroValue}
	m.GetFreeTrialEndsOn()
	m = &MarketplacePurchase{}
	m.GetFreeTrialEndsOn()
	m = nil
	m.GetFreeTrialEndsOn()
}

func TestMarketplacePurchase_GetNextBillingDate(tt *testing.T) {
	var zeroValue Timestamp
	m := &MarketplacePurchase{NextBillingDate: &zeroValue}
	m.GetNextBillingDate()
	m = &MarketplacePurchase{}
	m.GetNextBillingDate()
	m = nil
	m.GetNextBillingDate()
}

func TestMarketplacePurchase_GetOnFreeTrial(tt *testing.T) {
	var zeroValue bool
	m := &MarketplacePurchase{OnFreeTrial: &zeroValue}
	m.GetOnFreeTrial()
	m = &MarketplacePurchase{}
	m.GetOnFreeTrial()
	m = nil
	m.GetOnFreeTrial()
}

func TestMarketplacePurchase_GetPlan(tt *testing.T) {
	m := &MarketplacePurchase{}
	m.GetPlan()
	m = nil
	m.GetPlan()
}

func TestMarketplacePurchase_GetUnitCount(tt *testing.T) {
	var zeroValue int
	m := &MarketplacePurchase{UnitCount: &zeroValue}
	m.GetUnitCount()
	m = &MarketplacePurchase{}
	m.GetUnitCount()
	m = nil
	m.GetUnitCount()
}

func TestMarketplacePurchase_GetUpdatedAt(tt *testing.T) {
	var zeroValue Timestamp
	m := &MarketplacePurchase{UpdatedAt: &zeroValue}
	m.GetUpdatedAt()
	m = &MarketplacePurchase{}
	m.GetUpdatedAt()
	m = nil
	m.GetUpdatedAt()
}

func TestMarketplacePurchaseEvent_GetAction(tt *testing.T) {
	var zeroValue string
	m := &MarketplacePurchaseEvent{Action: &zeroValue}
	m.GetAction()
	m = &MarketplacePurchaseEvent{}
	m.GetAction()
	m = nil
	m.GetAction()
}

func TestMarketplacePurchaseEvent_GetEffectiveDate(tt *testing.T) {
	var zeroValue Timestamp
	m := &MarketplacePurchaseEvent{EffectiveDate: &zeroValue}
	m.GetEffectiveDate()
	m = &MarketplacePurchaseEvent{}
	m.GetEffectiveDate()
	m = nil
	m.GetEffectiveDate()
}

func TestMarketplacePurchaseEvent_GetInstallation(tt *testing.T) {
	m := &MarketplacePurchaseEvent{}
	m.GetInstallation()
	m = nil
	m.GetInstallation()
}

func TestMarketplacePurchaseEvent_GetMarketplacePurchase(tt *testing.T) {
	m := &MarketplacePurchaseEvent{}
	m.GetMarketplacePurchase()
	m = nil
	m.GetMarketplacePurchase()
}

func TestMarketplacePurchaseEvent_GetPreviousMarketplacePurchase(tt *testing.T) {
	m := &MarketplacePurchaseEvent{}
	m.GetPreviousMarketplacePurchase()
	m = nil
	m.GetPreviousMarketplacePurchase()
}

func TestMarketplacePurchaseEvent_GetSender(tt *testing.T) {
	m := &MarketplacePurchaseEvent{}
	m.GetSender()
	m = nil
	m.GetSender()
}

func TestMatch_GetText(tt *testing.T) {
	var zeroValue string
	m := &Match{Text: &zeroValue}
	m.GetText()
	m = &Match{}
	m.GetText()
	m = nil
	m.GetText()
}

func TestMemberEvent_GetAction(tt *testing.T) {
	var zeroValue string
	m := &MemberEvent{Action: &zeroValue}
	m.GetAction()
	m = &MemberEvent{}
	m.GetAction()
	m = nil
	m.GetAction()
}

func TestMemberEvent_GetInstallation(tt *testing.T) {
	m := &MemberEvent{}
	m.GetInstallation()
	m = nil
	m.GetInstallation()
}

func TestMemberEvent_GetMember(tt *testing.T) {
	m := &MemberEvent{}
	m.GetMember()
	m = nil
	m.GetMember()
}

func TestMemberEvent_GetRepo(tt *testing.T) {
	m := &MemberEvent{}
	m.GetRepo()
	m = nil
	m.GetRepo()
}

func TestMemberEvent_GetSender(tt *testing.T) {
	m := &MemberEvent{}
	m.GetSender()
	m = nil
	m.GetSender()
}

func TestMembership_GetOrganization(tt *testing.T) {
	m := &Membership{}
	m.GetOrganization()
	m = nil
	m.GetOrganization()
}

func TestMembership_GetOrganizationURL(tt *testing.T) {
	var zeroValue string
	m := &Membership{OrganizationURL: &zeroValue}
	m.GetOrganizationURL()
	m = &Membership{}
	m.GetOrganizationURL()
	m = nil
	m.GetOrganizationURL()
}

func TestMembership_GetRole(tt *testing.T) {
	var zeroValue string
	m := &Membership{Role: &zeroValue}
	m.GetRole()
	m = &Membership{}
	m.GetRole()
	m = nil
	m.GetRole()
}

func TestMembership_GetState(tt *testing.T) {
	var zeroValue string
	m := &Membership{State: &zeroValue}
	m.GetState()
	m = &Membership{}
	m.GetState()
	m = nil
	m.GetState()
}

func TestMembership_GetURL(tt *testing.T) {
	var zeroValue string
	m := &Membership{URL: &zeroValue}
	m.GetURL()
	m = &Membership{}
	m.GetURL()
	m = nil
	m.GetURL()
}

func TestMembership_GetUser(tt *testing.T) {
	m := &Membership{}
	m.GetUser()
	m = nil
	m.GetUser()
}

func TestMembershipEvent_GetAction(tt *testing.T) {
	var zeroValue string
	m := &MembershipEvent{Action: &zeroValue}
	m.GetAction()
	m = &MembershipEvent{}
	m.GetAction()
	m = nil
	m.GetAction()
}

func TestMembershipEvent_GetInstallation(tt *testing.T) {
	m := &MembershipEvent{}
	m.GetInstallation()
	m = nil
	m.GetInstallation()
}

func TestMembershipEvent_GetMember(tt *testing.T) {
	m := &MembershipEvent{}
	m.GetMember()
	m = nil
	m.GetMember()
}

func TestMembershipEvent_GetOrg(tt *testing.T) {
	m := &MembershipEvent{}
	m.GetOrg()
	m = nil
	m.GetOrg()
}

func TestMembershipEvent_GetScope(tt *testing.T) {
	var zeroValue string
	m := &MembershipEvent{Scope: &zeroValue}
	m.GetScope()
	m = &MembershipEvent{}
	m.GetScope()
	m = nil
	m.GetScope()
}

func TestMembershipEvent_GetSender(tt *testing.T) {
	m := &MembershipEvent{}
	m.GetSender()
	m = nil
	m.GetSender()
}

func TestMembershipEvent_GetTeam(tt *testing.T) {
	m := &MembershipEvent{}
	m.GetTeam()
	m = nil
	m.GetTeam()
}

func TestMessage_GetText(tt *testing.T) {
	var zeroValue string
	m := &Message{Text: &zeroValue}
	m.GetText()
	m = &Message{}
	m.GetText()
	m = nil
	m.GetText()
}

func TestMetaEvent_GetAction(tt *testing.T) {
	var zeroValue string
	m := &MetaEvent{Action: &zeroValue}
	m.GetAction()
	m = &MetaEvent{}
	m.GetAction()
	m = nil
	m.GetAction()
}

func TestMetaEvent_GetHook(tt *testing.T) {
	m := &MetaEvent{}
	m.GetHook()
	m = nil
	m.GetHook()
}

func TestMetaEvent_GetHookID(tt *testing.T) {
	var zeroValue int64
	m := &MetaEvent{HookID: &zeroValue}
	m.GetHookID()
	m = &MetaEvent{}
	m.GetHookID()
	m = nil
	m.GetHookID()
}

func TestMetaEvent_GetInstallation(tt *testing.T) {
	m := &MetaEvent{}
	m.GetInstallation()
	m = nil
	m.GetInstallation()
}

func TestMetric_GetHTMLURL(tt *testing.T) {
	var zeroValue string
	m := &Metric{HTMLURL: &zeroValue}
	m.GetHTMLURL()
	m = &Metric{}
	m.GetHTMLURL()
	m = nil
	m.GetHTMLURL()
}

func TestMetric_GetKey(tt *testing.T) {
	var zeroValue string
	m := &Metric{Key: &zeroValue}
	m.GetKey()
	m = &Metric{}
	m.GetKey()
	m = nil
	m.GetKey()
}

func TestMetric_GetName(tt *testing.T) {
	var zeroValue string
	m := &Metric{Name: &zeroValue}
	m.GetName()
	m = &Metric{}
	m.GetName()
	m = nil
	m.GetName()
}

func TestMetric_GetNodeID(tt *testing.T) {
	var zeroValue string
	m := &Metric{NodeID: &zeroValue}
	m.GetNodeID()
	m = &Metric{}
	m.GetNodeID()
	m = nil
	m.GetNodeID()
}

func TestMetric_GetSPDXID(tt *testing.T) {
	var zeroValue string
	m := &Metric{SPDXID: &zeroValue}
	m.GetSPDXID()
	m = &Metric{}
	m.GetSPDXID()
	m = nil
	m.GetSPDXID()
}

func TestMetric_GetURL(tt *testing.T) {
	var zeroValue string
	m := &Metric{URL: &zeroValue}
	m.GetURL()
	m = &Metric{}
	m.GetURL()
	m = nil
	m.GetURL()
}

func TestMigration_GetCreatedAt(tt *testing.T) {
	var zeroValue string
	m := &Migration{CreatedAt: &zeroValue}
	m.GetCreatedAt()
	m = &Migration{}
	m.GetCreatedAt()
	m = nil
	m.GetCreatedAt()
}

func TestMigration_GetExcludeAttachments(tt *testing.T) {
	var zeroValue bool
	m := &Migration{ExcludeAttachments: &zeroValue}
	m.GetExcludeAttachments()
	m = &Migration{}
	m.GetExcludeAttachments()
	m = nil
	m.GetExcludeAttachments()
}

func TestMigration_GetGUID(tt *testing.T) {
	var zeroValue string
	m := &Migration{GUID: &zeroValue}
	m.GetGUID()
	m = &Migration{}
	m.GetGUID()
	m = nil
	m.GetGUID()
}

func TestMigration_GetID(tt *testing.T) {
	var zeroValue int64
	m := &Migration{ID: &zeroValue}
	m.GetID()
	m = &Migration{}
	m.GetID()
	m = nil
	m.GetID()
}

func TestMigration_GetLockRepositories(tt *testing.T) {
	var zeroValue bool
	m := &Migration{LockRepositories: &zeroValue}
	m.GetLockRepositories()
	m = &Migration{}
	m.GetLockRepositories()
	m = nil
	m.GetLockRepositories()
}

func TestMigration_GetState(tt *testing.T) {
	var zeroValue string
	m := &Migration{State: &zeroValue}
	m.GetState()
	m = &Migration{}
	m.GetState()
	m = nil
	m.GetState()
}

func TestMigration_GetUpdatedAt(tt *testing.T) {
	var zeroValue string
	m := &Migration{UpdatedAt: &zeroValue}
	m.GetUpdatedAt()
	m = &Migration{}
	m.GetUpdatedAt()
	m = nil
	m.GetUpdatedAt()
}

func TestMigration_GetURL(tt *testing.T) {
	var zeroValue string
	m := &Migration{URL: &zeroValue}
	m.GetURL()
	m = &Migration{}
	m.GetURL()
	m = nil
	m.GetURL()
}

func TestMilestone_GetClosedAt(tt *testing.T) {
	var zeroValue time.Time
	m := &Milestone{ClosedAt: &zeroValue}
	m.GetClosedAt()
	m = &Milestone{}
	m.GetClosedAt()
	m = nil
	m.GetClosedAt()
}

func TestMilestone_GetClosedIssues(tt *testing.T) {
	var zeroValue int
	m := &Milestone{ClosedIssues: &zeroValue}
	m.GetClosedIssues()
	m = &Milestone{}
	m.GetClosedIssues()
	m = nil
	m.GetClosedIssues()
}

func TestMilestone_GetCreatedAt(tt *testing.T) {
	var zeroValue time.Time
	m := &Milestone{CreatedAt: &zeroValue}
	m.GetCreatedAt()
	m = &Milestone{}
	m.GetCreatedAt()
	m = nil
	m.GetCreatedAt()
}

func TestMilestone_GetCreator(tt *testing.T) {
	m := &Milestone{}
	m.GetCreator()
	m = nil
	m.GetCreator()
}

func TestMilestone_GetDescription(tt *testing.T) {
	var zeroValue string
	m := &Milestone{Description: &zeroValue}
	m.GetDescription()
	m = &Milestone{}
	m.GetDescription()
	m = nil
	m.GetDescription()
}

func TestMilestone_GetDueOn(tt *testing.T) {
	var zeroValue time.Time
	m := &Milestone{DueOn: &zeroValue}
	m.GetDueOn()
	m = &Milestone{}
	m.GetDueOn()
	m = nil
	m.GetDueOn()
}

func TestMilestone_GetHTMLURL(tt *testing.T) {
	var zeroValue string
	m := &Milestone{HTMLURL: &zeroValue}
	m.GetHTMLURL()
	m = &Milestone{}
	m.GetHTMLURL()
	m = nil
	m.GetHTMLURL()
}

func TestMilestone_GetID(tt *testing.T) {
	var zeroValue int64
	m := &Milestone{ID: &zeroValue}
	m.GetID()
	m = &Milestone{}
	m.GetID()
	m = nil
	m.GetID()
}

func TestMilestone_GetLabelsURL(tt *testing.T) {
	var zeroValue string
	m := &Milestone{LabelsURL: &zeroValue}
	m.GetLabelsURL()
	m = &Milestone{}
	m.GetLabelsURL()
	m = nil
	m.GetLabelsURL()
}

func TestMilestone_GetNodeID(tt *testing.T) {
	var zeroValue string
	m := &Milestone{NodeID: &zeroValue}
	m.GetNodeID()
	m = &Milestone{}
	m.GetNodeID()
	m = nil
	m.GetNodeID()
}

func TestMilestone_GetNumber(tt *testing.T) {
	var zeroValue int
	m := &Milestone{Number: &zeroValue}
	m.GetNumber()
	m = &Milestone{}
	m.GetNumber()
	m = nil
	m.GetNumber()
}

func TestMilestone_GetOpenIssues(tt *testing.T) {
	var zeroValue int
	m := &Milestone{OpenIssues: &zeroValue}
	m.GetOpenIssues()
	m = &Milestone{}
	m.GetOpenIssues()
	m = nil
	m.GetOpenIssues()
}

func TestMilestone_GetState(tt *testing.T) {
	var zeroValue string
	m := &Milestone{State: &zeroValue}
	m.GetState()
	m = &Milestone{}
	m.GetState()
	m = nil
	m.GetState()
}

func TestMilestone_GetTitle(tt *testing.T) {
	var zeroValue string
	m := &Milestone{Title: &zeroValue}
	m.GetTitle()
	m = &Milestone{}
	m.GetTitle()
	m = nil
	m.GetTitle()
}

func TestMilestone_GetUpdatedAt(tt *testing.T) {
	var zeroValue time.Time
	m := &Milestone{UpdatedAt: &zeroValue}
	m.GetUpdatedAt()
	m = &Milestone{}
	m.GetUpdatedAt()
	m = nil
	m.GetUpdatedAt()
}

func TestMilestone_GetURL(tt *testing.T) {
	var zeroValue string
	m := &Milestone{URL: &zeroValue}
	m.GetURL()
	m = &Milestone{}
	m.GetURL()
	m = nil
	m.GetURL()
}

func TestMilestoneEvent_GetAction(tt *testing.T) {
	var zeroValue string
	m := &MilestoneEvent{Action: &zeroValue}
	m.GetAction()
	m = &MilestoneEvent{}
	m.GetAction()
	m = nil
	m.GetAction()
}

func TestMilestoneEvent_GetChanges(tt *testing.T) {
	m := &MilestoneEvent{}
	m.GetChanges()
	m = nil
	m.GetChanges()
}

func TestMilestoneEvent_GetInstallation(tt *testing.T) {
	m := &MilestoneEvent{}
	m.GetInstallation()
	m = nil
	m.GetInstallation()
}

func TestMilestoneEvent_GetMilestone(tt *testing.T) {
	m := &MilestoneEvent{}
	m.GetMilestone()
	m = nil
	m.GetMilestone()
}

func TestMilestoneEvent_GetOrg(tt *testing.T) {
	m := &MilestoneEvent{}
	m.GetOrg()
	m = nil
	m.GetOrg()
}

func TestMilestoneEvent_GetRepo(tt *testing.T) {
	m := &MilestoneEvent{}
	m.GetRepo()
	m = nil
	m.GetRepo()
}

func TestMilestoneEvent_GetSender(tt *testing.T) {
	m := &MilestoneEvent{}
	m.GetSender()
	m = nil
	m.GetSender()
}

func TestMilestoneStats_GetClosedMilestones(tt *testing.T) {
	var zeroValue int
	m := &MilestoneStats{ClosedMilestones: &zeroValue}
	m.GetClosedMilestones()
	m = &MilestoneStats{}
	m.GetClosedMilestones()
	m = nil
	m.GetClosedMilestones()
}

func TestMilestoneStats_GetOpenMilestones(tt *testing.T) {
	var zeroValue int
	m := &MilestoneStats{OpenMilestones: &zeroValue}
	m.GetOpenMilestones()
	m = &MilestoneStats{}
	m.GetOpenMilestones()
	m = nil
	m.GetOpenMilestones()
}

func TestMilestoneStats_GetTotalMilestones(tt *testing.T) {
	var zeroValue int
	m := &MilestoneStats{TotalMilestones: &zeroValue}
	m.GetTotalMilestones()
	m = &MilestoneStats{}
	m.GetTotalMilestones()
	m = nil
	m.GetTotalMilestones()
}

func TestMostRecentInstance_GetAnalysisKey(tt *testing.T) {
	var zeroValue string
	m := &MostRecentInstance{AnalysisKey: &zeroValue}
	m.GetAnalysisKey()
	m = &MostRecentInstance{}
	m.GetAnalysisKey()
	m = nil
	m.GetAnalysisKey()
}

func TestMostRecentInstance_GetCommitSHA(tt *testing.T) {
	var zeroValue string
	m := &MostRecentInstance{CommitSHA: &zeroValue}
	m.GetCommitSHA()
	m = &MostRecentInstance{}
	m.GetCommitSHA()
	m = nil
	m.GetCommitSHA()
}

func TestMostRecentInstance_GetEnvironment(tt *testing.T) {
	var zeroValue string
	m := &MostRecentInstance{Environment: &zeroValue}
	m.GetEnvironment()
	m = &MostRecentInstance{}
	m.GetEnvironment()
	m = nil
	m.GetEnvironment()
}

func TestMostRecentInstance_GetLocation(tt *testing.T) {
	m := &MostRecentInstance{}
	m.GetLocation()
	m = nil
	m.GetLocation()
}

func TestMostRecentInstance_GetMessage(tt *testing.T) {
	m := &MostRecentInstance{}
	m.GetMessage()
	m = nil
	m.GetMessage()
}

func TestMostRecentInstance_GetRef(tt *testing.T) {
	var zeroValue string
	m := &MostRecentInstance{Ref: &zeroValue}
	m.GetRef()
	m = &MostRecentInstance{}
	m.GetRef()
	m = nil
	m.GetRef()
}

func TestMostRecentInstance_GetState(tt *testing.T) {
	var zeroValue string
	m := &MostRecentInstance{State: &zeroValue}
	m.GetState()
	m = &MostRecentInstance{}
	m.GetState()
	m = nil
	m.GetState()
}

func TestNewPullRequest_GetBase(tt *testing.T) {
	var zeroValue string
	n := &NewPullRequest{Base: &zeroValue}
	n.GetBase()
	n = &NewPullRequest{}
	n.GetBase()
	n = nil
	n.GetBase()
}

func TestNewPullRequest_GetBody(tt *testing.T) {
	var zeroValue string
	n := &NewPullRequest{Body: &zeroValue}
	n.GetBody()
	n = &NewPullRequest{}
	n.GetBody()
	n = nil
	n.GetBody()
}

func TestNewPullRequest_GetDraft(tt *testing.T) {
	var zeroValue bool
	n := &NewPullRequest{Draft: &zeroValue}
	n.GetDraft()
	n = &NewPullRequest{}
	n.GetDraft()
	n = nil
	n.GetDraft()
}

func TestNewPullRequest_GetHead(tt *testing.T) {
	var zeroValue string
	n := &NewPullRequest{Head: &zeroValue}
	n.GetHead()
	n = &NewPullRequest{}
	n.GetHead()
	n = nil
	n.GetHead()
}

func TestNewPullRequest_GetIssue(tt *testing.T) {
	var zeroValue int
	n := &NewPullRequest{Issue: &zeroValue}
	n.GetIssue()
	n = &NewPullRequest{}
	n.GetIssue()
	n = nil
	n.GetIssue()
}

func TestNewPullRequest_GetMaintainerCanModify(tt *testing.T) {
	var zeroValue bool
	n := &NewPullRequest{MaintainerCanModify: &zeroValue}
	n.GetMaintainerCanModify()
	n = &NewPullRequest{}
	n.GetMaintainerCanModify()
	n = nil
	n.GetMaintainerCanModify()
}

func TestNewPullRequest_GetTitle(tt *testing.T) {
	var zeroValue string
	n := &NewPullRequest{Title: &zeroValue}
	n.GetTitle()
	n = &NewPullRequest{}
	n.GetTitle()
	n = nil
	n.GetTitle()
}

func TestNewTeam_GetDescription(tt *testing.T) {
	var zeroValue string
	n := &NewTeam{Description: &zeroValue}
	n.GetDescription()
	n = &NewTeam{}
	n.GetDescription()
	n = nil
	n.GetDescription()
}

func TestNewTeam_GetLDAPDN(tt *testing.T) {
	var zeroValue string
	n := &NewTeam{LDAPDN: &zeroValue}
	n.GetLDAPDN()
	n = &NewTeam{}
	n.GetLDAPDN()
	n = nil
	n.GetLDAPDN()
}

func TestNewTeam_GetParentTeamID(tt *testing.T) {
	var zeroValue int64
	n := &NewTeam{ParentTeamID: &zeroValue}
	n.GetParentTeamID()
	n = &NewTeam{}
	n.GetParentTeamID()
	n = nil
	n.GetParentTeamID()
}

func TestNewTeam_GetPermission(tt *testing.T) {
	var zeroValue string
	n := &NewTeam{Permission: &zeroValue}
	n.GetPermission()
	n = &NewTeam{}
	n.GetPermission()
	n = nil
	n.GetPermission()
}

func TestNewTeam_GetPrivacy(tt *testing.T) {
	var zeroValue string
	n := &NewTeam{Privacy: &zeroValue}
	n.GetPrivacy()
	n = &NewTeam{}
	n.GetPrivacy()
	n = nil
	n.GetPrivacy()
}

func TestNotification_GetID(tt *testing.T) {
	var zeroValue string
	n := &Notification{ID: &zeroValue}
	n.GetID()
	n = &Notification{}
	n.GetID()
	n = nil
	n.GetID()
}

func TestNotification_GetLastReadAt(tt *testing.T) {
	var zeroValue time.Time
	n := &Notification{LastReadAt: &zeroValue}
	n.GetLastReadAt()
	n = &Notification{}
	n.GetLastReadAt()
	n = nil
	n.GetLastReadAt()
}

func TestNotification_GetReason(tt *testing.T) {
	var zeroValue string
	n := &Notification{Reason: &zeroValue}
	n.GetReason()
	n = &Notification{}
	n.GetReason()
	n = nil
	n.GetReason()
}

func TestNotification_GetRepository(tt *testing.T) {
	n := &Notification{}
	n.GetRepository()
	n = nil
	n.GetRepository()
}

func TestNotification_GetSubject(tt *testing.T) {
	n := &Notification{}
	n.GetSubject()
	n = nil
	n.GetSubject()
}

func TestNotification_GetUnread(tt *testing.T) {
	var zeroValue bool
	n := &Notification{Unread: &zeroValue}
	n.GetUnread()
	n = &Notification{}
	n.GetUnread()
	n = nil
	n.GetUnread()
}

func TestNotification_GetUpdatedAt(tt *testing.T) {
	var zeroValue time.Time
	n := &Notification{UpdatedAt: &zeroValue}
	n.GetUpdatedAt()
	n = &Notification{}
	n.GetUpdatedAt()
	n = nil
	n.GetUpdatedAt()
}

func TestNotification_GetURL(tt *testing.T) {
	var zeroValue string
	n := &Notification{URL: &zeroValue}
	n.GetURL()
	n = &Notification{}
	n.GetURL()
	n = nil
	n.GetURL()
}

func TestNotificationSubject_GetLatestCommentURL(tt *testing.T) {
	var zeroValue string
	n := &NotificationSubject{LatestCommentURL: &zeroValue}
	n.GetLatestCommentURL()
	n = &NotificationSubject{}
	n.GetLatestCommentURL()
	n = nil
	n.GetLatestCommentURL()
}

func TestNotificationSubject_GetTitle(tt *testing.T) {
	var zeroValue string
	n := &NotificationSubject{Title: &zeroValue}
	n.GetTitle()
	n = &NotificationSubject{}
	n.GetTitle()
	n = nil
	n.GetTitle()
}

func TestNotificationSubject_GetType(tt *testing.T) {
	var zeroValue string
	n := &NotificationSubject{Type: &zeroValue}
	n.GetType()
	n = &NotificationSubject{}
	n.GetType()
	n = nil
	n.GetType()
}

func TestNotificationSubject_GetURL(tt *testing.T) {
	var zeroValue string
	n := &NotificationSubject{URL: &zeroValue}
	n.GetURL()
	n = &NotificationSubject{}
	n.GetURL()
	n = nil
	n.GetURL()
}

func TestOAuthAPP_GetClientID(tt *testing.T) {
	var zeroValue string
	o := &OAuthAPP{ClientID: &zeroValue}
	o.GetClientID()
	o = &OAuthAPP{}
	o.GetClientID()
	o = nil
	o.GetClientID()
}

func TestOAuthAPP_GetName(tt *testing.T) {
	var zeroValue string
	o := &OAuthAPP{Name: &zeroValue}
	o.GetName()
	o = &OAuthAPP{}
	o.GetName()
	o = nil
	o.GetName()
}

func TestOAuthAPP_GetURL(tt *testing.T) {
	var zeroValue string
	o := &OAuthAPP{URL: &zeroValue}
	o.GetURL()
	o = &OAuthAPP{}
	o.GetURL()
	o = nil
	o.GetURL()
}

func TestOrganization_GetAvatarURL(tt *testing.T) {
	var zeroValue string
	o := &Organization{AvatarURL: &zeroValue}
	o.GetAvatarURL()
	o = &Organization{}
	o.GetAvatarURL()
	o = nil
	o.GetAvatarURL()
}

func TestOrganization_GetBillingEmail(tt *testing.T) {
	var zeroValue string
	o := &Organization{BillingEmail: &zeroValue}
	o.GetBillingEmail()
	o = &Organization{}
	o.GetBillingEmail()
	o = nil
	o.GetBillingEmail()
}

func TestOrganization_GetBlog(tt *testing.T) {
	var zeroValue string
	o := &Organization{Blog: &zeroValue}
	o.GetBlog()
	o = &Organization{}
	o.GetBlog()
	o = nil
	o.GetBlog()
}

func TestOrganization_GetCollaborators(tt *testing.T) {
	var zeroValue int
	o := &Organization{Collaborators: &zeroValue}
	o.GetCollaborators()
	o = &Organization{}
	o.GetCollaborators()
	o = nil
	o.GetCollaborators()
}

func TestOrganization_GetCompany(tt *testing.T) {
	var zeroValue string
	o := &Organization{Company: &zeroValue}
	o.GetCompany()
	o = &Organization{}
	o.GetCompany()
	o = nil
	o.GetCompany()
}

func TestOrganization_GetCreatedAt(tt *testing.T) {
	var zeroValue time.Time
	o := &Organization{CreatedAt: &zeroValue}
	o.GetCreatedAt()
	o = &Organization{}
	o.GetCreatedAt()
	o = nil
	o.GetCreatedAt()
}

func TestOrganization_GetDefaultRepoPermission(tt *testing.T) {
	var zeroValue string
	o := &Organization{DefaultRepoPermission: &zeroValue}
	o.GetDefaultRepoPermission()
	o = &Organization{}
	o.GetDefaultRepoPermission()
	o = nil
	o.GetDefaultRepoPermission()
}

func TestOrganization_GetDefaultRepoSettings(tt *testing.T) {
	var zeroValue string
	o := &Organization{DefaultRepoSettings: &zeroValue}
	o.GetDefaultRepoSettings()
	o = &Organization{}
	o.GetDefaultRepoSettings()
	o = nil
	o.GetDefaultRepoSettings()
}

func TestOrganization_GetDescription(tt *testing.T) {
	var zeroValue string
	o := &Organization{Description: &zeroValue}
	o.GetDescription()
	o = &Organization{}
	o.GetDescription()
	o = nil
	o.GetDescription()
}

func TestOrganization_GetDiskUsage(tt *testing.T) {
	var zeroValue int
	o := &Organization{DiskUsage: &zeroValue}
	o.GetDiskUsage()
	o = &Organization{}
	o.GetDiskUsage()
	o = nil
	o.GetDiskUsage()
}

func TestOrganization_GetEmail(tt *testing.T) {
	var zeroValue string
	o := &Organization{Email: &zeroValue}
	o.GetEmail()
	o = &Organization{}
	o.GetEmail()
	o = nil
	o.GetEmail()
}

func TestOrganization_GetEventsURL(tt *testing.T) {
	var zeroValue string
	o := &Organization{EventsURL: &zeroValue}
	o.GetEventsURL()
	o = &Organization{}
	o.GetEventsURL()
	o = nil
	o.GetEventsURL()
}

func TestOrganization_GetFollowers(tt *testing.T) {
	var zeroValue int
	o := &Organization{Followers: &zeroValue}
	o.GetFollowers()
	o = &Organization{}
	o.GetFollowers()
	o = nil
	o.GetFollowers()
}

func TestOrganization_GetFollowing(tt *testing.T) {
	var zeroValue int
	o := &Organization{Following: &zeroValue}
	o.GetFollowing()
	o = &Organization{}
	o.GetFollowing()
	o = nil
	o.GetFollowing()
}

func TestOrganization_GetHasOrganizationProjects(tt *testing.T) {
	var zeroValue bool
	o := &Organization{HasOrganizationProjects: &zeroValue}
	o.GetHasOrganizationProjects()
	o = &Organization{}
	o.GetHasOrganizationProjects()
	o = nil
	o.GetHasOrganizationProjects()
}

func TestOrganization_GetHasRepositoryProjects(tt *testing.T) {
	var zeroValue bool
	o := &Organization{HasRepositoryProjects: &zeroValue}
	o.GetHasRepositoryProjects()
	o = &Organization{}
	o.GetHasRepositoryProjects()
	o = nil
	o.GetHasRepositoryProjects()
}

func TestOrganization_GetHooksURL(tt *testing.T) {
	var zeroValue string
	o := &Organization{HooksURL: &zeroValue}
	o.GetHooksURL()
	o = &Organization{}
	o.GetHooksURL()
	o = nil
	o.GetHooksURL()
}

func TestOrganization_GetHTMLURL(tt *testing.T) {
	var zeroValue string
	o := &Organization{HTMLURL: &zeroValue}
	o.GetHTMLURL()
	o = &Organization{}
	o.GetHTMLURL()
	o = nil
	o.GetHTMLURL()
}

func TestOrganization_GetID(tt *testing.T) {
	var zeroValue int64
	o := &Organization{ID: &zeroValue}
	o.GetID()
	o = &Organization{}
	o.GetID()
	o = nil
	o.GetID()
}

func TestOrganization_GetIssuesURL(tt *testing.T) {
	var zeroValue string
	o := &Organization{IssuesURL: &zeroValue}
	o.GetIssuesURL()
	o = &Organization{}
	o.GetIssuesURL()
	o = nil
	o.GetIssuesURL()
}

func TestOrganization_GetIsVerified(tt *testing.T) {
	var zeroValue bool
	o := &Organization{IsVerified: &zeroValue}
	o.GetIsVerified()
	o = &Organization{}
	o.GetIsVerified()
	o = nil
	o.GetIsVerified()
}

func TestOrganization_GetLocation(tt *testing.T) {
	var zeroValue string
	o := &Organization{Location: &zeroValue}
	o.GetLocation()
	o = &Organization{}
	o.GetLocation()
	o = nil
	o.GetLocation()
}

func TestOrganization_GetLogin(tt *testing.T) {
	var zeroValue string
	o := &Organization{Login: &zeroValue}
	o.GetLogin()
	o = &Organization{}
	o.GetLogin()
	o = nil
	o.GetLogin()
}

func TestOrganization_GetMembersAllowedRepositoryCreationType(tt *testing.T) {
	var zeroValue string
	o := &Organization{MembersAllowedRepositoryCreationType: &zeroValue}
	o.GetMembersAllowedRepositoryCreationType()
	o = &Organization{}
	o.GetMembersAllowedRepositoryCreationType()
	o = nil
	o.GetMembersAllowedRepositoryCreationType()
}

func TestOrganization_GetMembersCanCreateInternalRepos(tt *testing.T) {
	var zeroValue bool
	o := &Organization{MembersCanCreateInternalRepos: &zeroValue}
	o.GetMembersCanCreateInternalRepos()
	o = &Organization{}
	o.GetMembersCanCreateInternalRepos()
	o = nil
	o.GetMembersCanCreateInternalRepos()
}

func TestOrganization_GetMembersCanCreatePages(tt *testing.T) {
	var zeroValue bool
	o := &Organization{MembersCanCreatePages: &zeroValue}
	o.GetMembersCanCreatePages()
	o = &Organization{}
	o.GetMembersCanCreatePages()
	o = nil
	o.GetMembersCanCreatePages()
}

func TestOrganization_GetMembersCanCreatePrivatePages(tt *testing.T) {
	var zeroValue bool
	o := &Organization{MembersCanCreatePrivatePages: &zeroValue}
	o.GetMembersCanCreatePrivatePages()
	o = &Organization{}
	o.GetMembersCanCreatePrivatePages()
	o = nil
	o.GetMembersCanCreatePrivatePages()
}

func TestOrganization_GetMembersCanCreatePrivateRepos(tt *testing.T) {
	var zeroValue bool
	o := &Organization{MembersCanCreatePrivateRepos: &zeroValue}
	o.GetMembersCanCreatePrivateRepos()
	o = &Organization{}
	o.GetMembersCanCreatePrivateRepos()
	o = nil
	o.GetMembersCanCreatePrivateRepos()
}

func TestOrganization_GetMembersCanCreatePublicPages(tt *testing.T) {
	var zeroValue bool
	o := &Organization{MembersCanCreatePublicPages: &zeroValue}
	o.GetMembersCanCreatePublicPages()
	o = &Organization{}
	o.GetMembersCanCreatePublicPages()
	o = nil
	o.GetMembersCanCreatePublicPages()
}

func TestOrganization_GetMembersCanCreatePublicRepos(tt *testing.T) {
	var zeroValue bool
	o := &Organization{MembersCanCreatePublicRepos: &zeroValue}
	o.GetMembersCanCreatePublicRepos()
	o = &Organization{}
	o.GetMembersCanCreatePublicRepos()
	o = nil
	o.GetMembersCanCreatePublicRepos()
}

func TestOrganization_GetMembersCanCreateRepos(tt *testing.T) {
	var zeroValue bool
	o := &Organization{MembersCanCreateRepos: &zeroValue}
	o.GetMembersCanCreateRepos()
	o = &Organization{}
	o.GetMembersCanCreateRepos()
	o = nil
	o.GetMembersCanCreateRepos()
}

func TestOrganization_GetMembersURL(tt *testing.T) {
	var zeroValue string
	o := &Organization{MembersURL: &zeroValue}
	o.GetMembersURL()
	o = &Organization{}
	o.GetMembersURL()
	o = nil
	o.GetMembersURL()
}

func TestOrganization_GetName(tt *testing.T) {
	var zeroValue string
	o := &Organization{Name: &zeroValue}
	o.GetName()
	o = &Organization{}
	o.GetName()
	o = nil
	o.GetName()
}

func TestOrganization_GetNodeID(tt *testing.T) {
	var zeroValue string
	o := &Organization{NodeID: &zeroValue}
	o.GetNodeID()
	o = &Organization{}
	o.GetNodeID()
	o = nil
	o.GetNodeID()
}

func TestOrganization_GetOwnedPrivateRepos(tt *testing.T) {
	var zeroValue int
	o := &Organization{OwnedPrivateRepos: &zeroValue}
	o.GetOwnedPrivateRepos()
	o = &Organization{}
	o.GetOwnedPrivateRepos()
	o = nil
	o.GetOwnedPrivateRepos()
}

func TestOrganization_GetPlan(tt *testing.T) {
	o := &Organization{}
	o.GetPlan()
	o = nil
	o.GetPlan()
}

func TestOrganization_GetPrivateGists(tt *testing.T) {
	var zeroValue int
	o := &Organization{PrivateGists: &zeroValue}
	o.GetPrivateGists()
	o = &Organization{}
	o.GetPrivateGists()
	o = nil
	o.GetPrivateGists()
}

func TestOrganization_GetPublicGists(tt *testing.T) {
	var zeroValue int
	o := &Organization{PublicGists: &zeroValue}
	o.GetPublicGists()
	o = &Organization{}
	o.GetPublicGists()
	o = nil
	o.GetPublicGists()
}

func TestOrganization_GetPublicMembersURL(tt *testing.T) {
	var zeroValue string
	o := &Organization{PublicMembersURL: &zeroValue}
	o.GetPublicMembersURL()
	o = &Organization{}
	o.GetPublicMembersURL()
	o = nil
	o.GetPublicMembersURL()
}

func TestOrganization_GetPublicRepos(tt *testing.T) {
	var zeroValue int
	o := &Organization{PublicRepos: &zeroValue}
	o.GetPublicRepos()
	o = &Organization{}
	o.GetPublicRepos()
	o = nil
	o.GetPublicRepos()
}

func TestOrganization_GetReposURL(tt *testing.T) {
	var zeroValue string
	o := &Organization{ReposURL: &zeroValue}
	o.GetReposURL()
	o = &Organization{}
	o.GetReposURL()
	o = nil
	o.GetReposURL()
}

func TestOrganization_GetTotalPrivateRepos(tt *testing.T) {
	var zeroValue int
	o := &Organization{TotalPrivateRepos: &zeroValue}
	o.GetTotalPrivateRepos()
	o = &Organization{}
	o.GetTotalPrivateRepos()
	o = nil
	o.GetTotalPrivateRepos()
}

func TestOrganization_GetTwitterUsername(tt *testing.T) {
	var zeroValue string
	o := &Organization{TwitterUsername: &zeroValue}
	o.GetTwitterUsername()
	o = &Organization{}
	o.GetTwitterUsername()
	o = nil
	o.GetTwitterUsername()
}

func TestOrganization_GetTwoFactorRequirementEnabled(tt *testing.T) {
	var zeroValue bool
	o := &Organization{TwoFactorRequirementEnabled: &zeroValue}
	o.GetTwoFactorRequirementEnabled()
	o = &Organization{}
	o.GetTwoFactorRequirementEnabled()
	o = nil
	o.GetTwoFactorRequirementEnabled()
}

func TestOrganization_GetType(tt *testing.T) {
	var zeroValue string
	o := &Organization{Type: &zeroValue}
	o.GetType()
	o = &Organization{}
	o.GetType()
	o = nil
	o.GetType()
}

func TestOrganization_GetUpdatedAt(tt *testing.T) {
	var zeroValue time.Time
	o := &Organization{UpdatedAt: &zeroValue}
	o.GetUpdatedAt()
	o = &Organization{}
	o.GetUpdatedAt()
	o = nil
	o.GetUpdatedAt()
}

func TestOrganization_GetURL(tt *testing.T) {
	var zeroValue string
	o := &Organization{URL: &zeroValue}
	o.GetURL()
	o = &Organization{}
	o.GetURL()
	o = nil
	o.GetURL()
}

func TestOrganizationCustomRepoRoles_GetTotalCount(tt *testing.T) {
	var zeroValue int
	o := &OrganizationCustomRepoRoles{TotalCount: &zeroValue}
	o.GetTotalCount()
	o = &OrganizationCustomRepoRoles{}
	o.GetTotalCount()
	o = nil
	o.GetTotalCount()
}

func TestOrganizationEvent_GetAction(tt *testing.T) {
	var zeroValue string
	o := &OrganizationEvent{Action: &zeroValue}
	o.GetAction()
	o = &OrganizationEvent{}
	o.GetAction()
	o = nil
	o.GetAction()
}

func TestOrganizationEvent_GetInstallation(tt *testing.T) {
	o := &OrganizationEvent{}
	o.GetInstallation()
	o = nil
	o.GetInstallation()
}

func TestOrganizationEvent_GetInvitation(tt *testing.T) {
	o := &OrganizationEvent{}
	o.GetInvitation()
	o = nil
	o.GetInvitation()
}

func TestOrganizationEvent_GetMembership(tt *testing.T) {
	o := &OrganizationEvent{}
	o.GetMembership()
	o = nil
	o.GetMembership()
}

func TestOrganizationEvent_GetOrganization(tt *testing.T) {
	o := &OrganizationEvent{}
	o.GetOrganization()
	o = nil
	o.GetOrganization()
}

func TestOrganizationEvent_GetSender(tt *testing.T) {
	o := &OrganizationEvent{}
	o.GetSender()
	o = nil
	o.GetSender()
}

func TestOrganizationInstallations_GetTotalCount(tt *testing.T) {
	var zeroValue int
	o := &OrganizationInstallations{TotalCount: &zeroValue}
	o.GetTotalCount()
	o = &OrganizationInstallations{}
	o.GetTotalCount()
	o = nil
	o.GetTotalCount()
}

func TestOrgBlockEvent_GetAction(tt *testing.T) {
	var zeroValue string
	o := &OrgBlockEvent{Action: &zeroValue}
	o.GetAction()
	o = &OrgBlockEvent{}
	o.GetAction()
	o = nil
	o.GetAction()
}

func TestOrgBlockEvent_GetBlockedUser(tt *testing.T) {
	o := &OrgBlockEvent{}
	o.GetBlockedUser()
	o = nil
	o.GetBlockedUser()
}

func TestOrgBlockEvent_GetInstallation(tt *testing.T) {
	o := &OrgBlockEvent{}
	o.GetInstallation()
	o = nil
	o.GetInstallation()
}

func TestOrgBlockEvent_GetOrganization(tt *testing.T) {
	o := &OrgBlockEvent{}
	o.GetOrganization()
	o = nil
	o.GetOrganization()
}

func TestOrgBlockEvent_GetSender(tt *testing.T) {
	o := &OrgBlockEvent{}
	o.GetSender()
	o = nil
	o.GetSender()
}

func TestOrgStats_GetDisabledOrgs(tt *testing.T) {
	var zeroValue int
	o := &OrgStats{DisabledOrgs: &zeroValue}
	o.GetDisabledOrgs()
	o = &OrgStats{}
	o.GetDisabledOrgs()
	o = nil
	o.GetDisabledOrgs()
}

func TestOrgStats_GetTotalOrgs(tt *testing.T) {
	var zeroValue int
	o := &OrgStats{TotalOrgs: &zeroValue}
	o.GetTotalOrgs()
	o = &OrgStats{}
	o.GetTotalOrgs()
	o = nil
	o.GetTotalOrgs()
}

func TestOrgStats_GetTotalTeamMembers(tt *testing.T) {
	var zeroValue int
	o := &OrgStats{TotalTeamMembers: &zeroValue}
	o.GetTotalTeamMembers()
	o = &OrgStats{}
	o.GetTotalTeamMembers()
	o = nil
	o.GetTotalTeamMembers()
}

func TestOrgStats_GetTotalTeams(tt *testing.T) {
	var zeroValue int
	o := &OrgStats{TotalTeams: &zeroValue}
	o.GetTotalTeams()
	o = &OrgStats{}
	o.GetTotalTeams()
	o = nil
	o.GetTotalTeams()
}

func TestPackage_GetCreatedAt(tt *testing.T) {
	var zeroValue Timestamp
	p := &Package{CreatedAt: &zeroValue}
	p.GetCreatedAt()
	p = &Package{}
	p.GetCreatedAt()
	p = nil
	p.GetCreatedAt()
}

func TestPackage_GetHTMLURL(tt *testing.T) {
	var zeroValue string
	p := &Package{HTMLURL: &zeroValue}
	p.GetHTMLURL()
	p = &Package{}
	p.GetHTMLURL()
	p = nil
	p.GetHTMLURL()
}

func TestPackage_GetID(tt *testing.T) {
	var zeroValue int64
	p := &Package{ID: &zeroValue}
	p.GetID()
	p = &Package{}
	p.GetID()
	p = nil
	p.GetID()
}

func TestPackage_GetName(tt *testing.T) {
	var zeroValue string
	p := &Package{Name: &zeroValue}
	p.GetName()
	p = &Package{}
	p.GetName()
	p = nil
	p.GetName()
}

func TestPackage_GetOwner(tt *testing.T) {
	p := &Package{}
	p.GetOwner()
	p = nil
	p.GetOwner()
}

func TestPackage_GetPackageType(tt *testing.T) {
	var zeroValue string
	p := &Package{PackageType: &zeroValue}
	p.GetPackageType()
	p = &Package{}
	p.GetPackageType()
	p = nil
	p.GetPackageType()
}

func TestPackage_GetPackageVersion(tt *testing.T) {
	p := &Package{}
	p.GetPackageVersion()
	p = nil
	p.GetPackageVersion()
}

func TestPackage_GetRegistry(tt *testing.T) {
	p := &Package{}
	p.GetRegistry()
	p = nil
	p.GetRegistry()
}

func TestPackage_GetRepository(tt *testing.T) {
	p := &Package{}
	p.GetRepository()
	p = nil
	p.GetRepository()
}

func TestPackage_GetUpdatedAt(tt *testing.T) {
	var zeroValue Timestamp
	p := &Package{UpdatedAt: &zeroValue}
	p.GetUpdatedAt()
	p = &Package{}
	p.GetUpdatedAt()
	p = nil
	p.GetUpdatedAt()
}

func TestPackage_GetURL(tt *testing.T) {
	var zeroValue string
	p := &Package{URL: &zeroValue}
	p.GetURL()
	p = &Package{}
	p.GetURL()
	p = nil
	p.GetURL()
}

func TestPackage_GetVersionCount(tt *testing.T) {
	var zeroValue int64
	p := &Package{VersionCount: &zeroValue}
	p.GetVersionCount()
	p = &Package{}
	p.GetVersionCount()
	p = nil
	p.GetVersionCount()
}

func TestPackage_GetVisibility(tt *testing.T) {
	var zeroValue string
	p := &Package{Visibility: &zeroValue}
	p.GetVisibility()
	p = &Package{}
	p.GetVisibility()
	p = nil
	p.GetVisibility()
}

func TestPackageEvent_GetAction(tt *testing.T) {
	var zeroValue string
	p := &PackageEvent{Action: &zeroValue}
	p.GetAction()
	p = &PackageEvent{}
	p.GetAction()
	p = nil
	p.GetAction()
}

func TestPackageEvent_GetInstallation(tt *testing.T) {
	p := &PackageEvent{}
	p.GetInstallation()
	p = nil
	p.GetInstallation()
}

func TestPackageEvent_GetOrg(tt *testing.T) {
	p := &PackageEvent{}
	p.GetOrg()
	p = nil
	p.GetOrg()
}

func TestPackageEvent_GetPackage(tt *testing.T) {
	p := &PackageEvent{}
	p.GetPackage()
	p = nil
	p.GetPackage()
}

func TestPackageEvent_GetRepo(tt *testing.T) {
	p := &PackageEvent{}
	p.GetRepo()
	p = nil
	p.GetRepo()
}

func TestPackageEvent_GetSender(tt *testing.T) {
	p := &PackageEvent{}
	p.GetSender()
	p = nil
	p.GetSender()
}

func TestPackageFile_GetAuthor(tt *testing.T) {
	p := &PackageFile{}
	p.GetAuthor()
	p = nil
	p.GetAuthor()
}

func TestPackageFile_GetContentType(tt *testing.T) {
	var zeroValue string
	p := &PackageFile{ContentType: &zeroValue}
	p.GetContentType()
	p = &PackageFile{}
	p.GetContentType()
	p = nil
	p.GetContentType()
}

func TestPackageFile_GetCreatedAt(tt *testing.T) {
	var zeroValue Timestamp
	p := &PackageFile{CreatedAt: &zeroValue}
	p.GetCreatedAt()
	p = &PackageFile{}
	p.GetCreatedAt()
	p = nil
	p.GetCreatedAt()
}

func TestPackageFile_GetDownloadURL(tt *testing.T) {
	var zeroValue string
	p := &PackageFile{DownloadURL: &zeroValue}
	p.GetDownloadURL()
	p = &PackageFile{}
	p.GetDownloadURL()
	p = nil
	p.GetDownloadURL()
}

func TestPackageFile_GetID(tt *testing.T) {
	var zeroValue int64
	p := &PackageFile{ID: &zeroValue}
	p.GetID()
	p = &PackageFile{}
	p.GetID()
	p = nil
	p.GetID()
}

func TestPackageFile_GetMD5(tt *testing.T) {
	var zeroValue string
	p := &PackageFile{MD5: &zeroValue}
	p.GetMD5()
	p = &PackageFile{}
	p.GetMD5()
	p = nil
	p.GetMD5()
}

func TestPackageFile_GetName(tt *testing.T) {
	var zeroValue string
	p := &PackageFile{Name: &zeroValue}
	p.GetName()
	p = &PackageFile{}
	p.GetName()
	p = nil
	p.GetName()
}

func TestPackageFile_GetSHA1(tt *testing.T) {
	var zeroValue string
	p := &PackageFile{SHA1: &zeroValue}
	p.GetSHA1()
	p = &PackageFile{}
	p.GetSHA1()
	p = nil
	p.GetSHA1()
}

func TestPackageFile_GetSHA256(tt *testing.T) {
	var zeroValue string
	p := &PackageFile{SHA256: &zeroValue}
	p.GetSHA256()
	p = &PackageFile{}
	p.GetSHA256()
	p = nil
	p.GetSHA256()
}

func TestPackageFile_GetSize(tt *testing.T) {
	var zeroValue int64
	p := &PackageFile{Size: &zeroValue}
	p.GetSize()
	p = &PackageFile{}
	p.GetSize()
	p = nil
	p.GetSize()
}

func TestPackageFile_GetState(tt *testing.T) {
	var zeroValue string
	p := &PackageFile{State: &zeroValue}
	p.GetState()
	p = &PackageFile{}
	p.GetState()
	p = nil
	p.GetState()
}

func TestPackageFile_GetUpdatedAt(tt *testing.T) {
	var zeroValue Timestamp
	p := &PackageFile{UpdatedAt: &zeroValue}
	p.GetUpdatedAt()
	p = &PackageFile{}
	p.GetUpdatedAt()
	p = nil
	p.GetUpdatedAt()
}

func TestPackageListOptions_GetPackageType(tt *testing.T) {
	var zeroValue string
	p := &PackageListOptions{PackageType: &zeroValue}
	p.GetPackageType()
	p = &PackageListOptions{}
	p.GetPackageType()
	p = nil
	p.GetPackageType()
}

func TestPackageListOptions_GetState(tt *testing.T) {
	var zeroValue string
	p := &PackageListOptions{State: &zeroValue}
	p.GetState()
	p = &PackageListOptions{}
	p.GetState()
	p = nil
	p.GetState()
}

func TestPackageListOptions_GetVisibility(tt *testing.T) {
	var zeroValue string
	p := &PackageListOptions{Visibility: &zeroValue}
	p.GetVisibility()
	p = &PackageListOptions{}
	p.GetVisibility()
	p = nil
	p.GetVisibility()
}

func TestPackageMetadata_GetContainer(tt *testing.T) {
	p := &PackageMetadata{}
	p.GetContainer()
	p = nil
	p.GetContainer()
}

func TestPackageMetadata_GetPackageType(tt *testing.T) {
	var zeroValue string
	p := &PackageMetadata{PackageType: &zeroValue}
	p.GetPackageType()
	p = &PackageMetadata{}
	p.GetPackageType()
	p = nil
	p.GetPackageType()
}

func TestPackageRegistry_GetAboutURL(tt *testing.T) {
	var zeroValue string
	p := &PackageRegistry{AboutURL: &zeroValue}
	p.GetAboutURL()
	p = &PackageRegistry{}
	p.GetAboutURL()
	p = nil
	p.GetAboutURL()
}

func TestPackageRegistry_GetName(tt *testing.T) {
	var zeroValue string
	p := &PackageRegistry{Name: &zeroValue}
	p.GetName()
	p = &PackageRegistry{}
	p.GetName()
	p = nil
	p.GetName()
}

func TestPackageRegistry_GetType(tt *testing.T) {
	var zeroValue string
	p := &PackageRegistry{Type: &zeroValue}
	p.GetType()
	p = &PackageRegistry{}
	p.GetType()
	p = nil
	p.GetType()
}

func TestPackageRegistry_GetURL(tt *testing.T) {
	var zeroValue string
	p := &PackageRegistry{URL: &zeroValue}
	p.GetURL()
	p = &PackageRegistry{}
	p.GetURL()
	p = nil
	p.GetURL()
}

func TestPackageRegistry_GetVendor(tt *testing.T) {
	var zeroValue string
	p := &PackageRegistry{Vendor: &zeroValue}
	p.GetVendor()
	p = &PackageRegistry{}
	p.GetVendor()
	p = nil
	p.GetVendor()
}

func TestPackageRelease_GetAuthor(tt *testing.T) {
	p := &PackageRelease{}
	p.GetAuthor()
	p = nil
	p.GetAuthor()
}

func TestPackageRelease_GetCreatedAt(tt *testing.T) {
	var zeroValue Timestamp
	p := &PackageRelease{CreatedAt: &zeroValue}
	p.GetCreatedAt()
	p = &PackageRelease{}
	p.GetCreatedAt()
	p = nil
	p.GetCreatedAt()
}

func TestPackageRelease_GetDraft(tt *testing.T) {
	var zeroValue bool
	p := &PackageRelease{Draft: &zeroValue}
	p.GetDraft()
	p = &PackageRelease{}
	p.GetDraft()
	p = nil
	p.GetDraft()
}

func TestPackageRelease_GetHTMLURL(tt *testing.T) {
	var zeroValue string
	p := &PackageRelease{HTMLURL: &zeroValue}
	p.GetHTMLURL()
	p = &PackageRelease{}
	p.GetHTMLURL()
	p = nil
	p.GetHTMLURL()
}

func TestPackageRelease_GetID(tt *testing.T) {
	var zeroValue int64
	p := &PackageRelease{ID: &zeroValue}
	p.GetID()
	p = &PackageRelease{}
	p.GetID()
	p = nil
	p.GetID()
}

func TestPackageRelease_GetName(tt *testing.T) {
	var zeroValue string
	p := &PackageRelease{Name: &zeroValue}
	p.GetName()
	p = &PackageRelease{}
	p.GetName()
	p = nil
	p.GetName()
}

func TestPackageRelease_GetPrerelease(tt *testing.T) {
	var zeroValue bool
	p := &PackageRelease{Prerelease: &zeroValue}
	p.GetPrerelease()
	p = &PackageRelease{}
	p.GetPrerelease()
	p = nil
	p.GetPrerelease()
}

func TestPackageRelease_GetPublishedAt(tt *testing.T) {
	var zeroValue Timestamp
	p := &PackageRelease{PublishedAt: &zeroValue}
	p.GetPublishedAt()
	p = &PackageRelease{}
	p.GetPublishedAt()
	p = nil
	p.GetPublishedAt()
}

func TestPackageRelease_GetTagName(tt *testing.T) {
	var zeroValue string
	p := &PackageRelease{TagName: &zeroValue}
	p.GetTagName()
	p = &PackageRelease{}
	p.GetTagName()
	p = nil
	p.GetTagName()
}

func TestPackageRelease_GetTargetCommitish(tt *testing.T) {
	var zeroValue string
	p := &PackageRelease{TargetCommitish: &zeroValue}
	p.GetTargetCommitish()
	p = &PackageRelease{}
	p.GetTargetCommitish()
	p = nil
	p.GetTargetCommitish()
}

func TestPackageRelease_GetURL(tt *testing.T) {
	var zeroValue string
	p := &PackageRelease{URL: &zeroValue}
	p.GetURL()
	p = &PackageRelease{}
	p.GetURL()
	p = nil
	p.GetURL()
}

func TestPackageVersion_GetAuthor(tt *testing.T) {
	p := &PackageVersion{}
	p.GetAuthor()
	p = nil
	p.GetAuthor()
}

func TestPackageVersion_GetBody(tt *testing.T) {
	var zeroValue string
	p := &PackageVersion{Body: &zeroValue}
	p.GetBody()
	p = &PackageVersion{}
	p.GetBody()
	p = nil
	p.GetBody()
}

func TestPackageVersion_GetBodyHTML(tt *testing.T) {
	var zeroValue string
	p := &PackageVersion{BodyHTML: &zeroValue}
	p.GetBodyHTML()
	p = &PackageVersion{}
	p.GetBodyHTML()
	p = nil
	p.GetBodyHTML()
}

func TestPackageVersion_GetCreatedAt(tt *testing.T) {
	var zeroValue Timestamp
	p := &PackageVersion{CreatedAt: &zeroValue}
	p.GetCreatedAt()
	p = &PackageVersion{}
	p.GetCreatedAt()
	p = nil
	p.GetCreatedAt()
}

func TestPackageVersion_GetDraft(tt *testing.T) {
	var zeroValue bool
	p := &PackageVersion{Draft: &zeroValue}
	p.GetDraft()
	p = &PackageVersion{}
	p.GetDraft()
	p = nil
	p.GetDraft()
}

func TestPackageVersion_GetHTMLURL(tt *testing.T) {
	var zeroValue string
	p := &PackageVersion{HTMLURL: &zeroValue}
	p.GetHTMLURL()
	p = &PackageVersion{}
	p.GetHTMLURL()
	p = nil
	p.GetHTMLURL()
}

func TestPackageVersion_GetID(tt *testing.T) {
	var zeroValue int64
	p := &PackageVersion{ID: &zeroValue}
	p.GetID()
	p = &PackageVersion{}
	p.GetID()
	p = nil
	p.GetID()
}

func TestPackageVersion_GetInstallationCommand(tt *testing.T) {
	var zeroValue string
	p := &PackageVersion{InstallationCommand: &zeroValue}
	p.GetInstallationCommand()
	p = &PackageVersion{}
	p.GetInstallationCommand()
	p = nil
	p.GetInstallationCommand()
}

func TestPackageVersion_GetManifest(tt *testing.T) {
	var zeroValue string
	p := &PackageVersion{Manifest: &zeroValue}
	p.GetManifest()
	p = &PackageVersion{}
	p.GetManifest()
	p = nil
	p.GetManifest()
}

func TestPackageVersion_GetMetadata(tt *testing.T) {
	p := &PackageVersion{}
	p.GetMetadata()
	p = nil
	p.GetMetadata()
}

func TestPackageVersion_GetName(tt *testing.T) {
	var zeroValue string
	p := &PackageVersion{Name: &zeroValue}
	p.GetName()
	p = &PackageVersion{}
	p.GetName()
	p = nil
	p.GetName()
}

func TestPackageVersion_GetPackageHTMLURL(tt *testing.T) {
	var zeroValue string
	p := &PackageVersion{PackageHTMLURL: &zeroValue}
	p.GetPackageHTMLURL()
	p = &PackageVersion{}
	p.GetPackageHTMLURL()
	p = nil
	p.GetPackageHTMLURL()
}

func TestPackageVersion_GetPrerelease(tt *testing.T) {
	var zeroValue bool
	p := &PackageVersion{Prerelease: &zeroValue}
	p.GetPrerelease()
	p = &PackageVersion{}
	p.GetPrerelease()
	p = nil
	p.GetPrerelease()
}

func TestPackageVersion_GetRelease(tt *testing.T) {
	p := &PackageVersion{}
	p.GetRelease()
	p = nil
	p.GetRelease()
}

func TestPackageVersion_GetSummary(tt *testing.T) {
	var zeroValue string
	p := &PackageVersion{Summary: &zeroValue}
	p.GetSummary()
	p = &PackageVersion{}
	p.GetSummary()
	p = nil
	p.GetSummary()
}

func TestPackageVersion_GetTagName(tt *testing.T) {
	var zeroValue string
	p := &PackageVersion{TagName: &zeroValue}
	p.GetTagName()
	p = &PackageVersion{}
	p.GetTagName()
	p = nil
	p.GetTagName()
}

func TestPackageVersion_GetTargetCommitish(tt *testing.T) {
	var zeroValue string
	p := &PackageVersion{TargetCommitish: &zeroValue}
	p.GetTargetCommitish()
	p = &PackageVersion{}
	p.GetTargetCommitish()
	p = nil
	p.GetTargetCommitish()
}

func TestPackageVersion_GetTargetOID(tt *testing.T) {
	var zeroValue string
	p := &PackageVersion{TargetOID: &zeroValue}
	p.GetTargetOID()
	p = &PackageVersion{}
	p.GetTargetOID()
	p = nil
	p.GetTargetOID()
}

func TestPackageVersion_GetUpdatedAt(tt *testing.T) {
	var zeroValue Timestamp
	p := &PackageVersion{UpdatedAt: &zeroValue}
	p.GetUpdatedAt()
	p = &PackageVersion{}
	p.GetUpdatedAt()
	p = nil
	p.GetUpdatedAt()
}

func TestPackageVersion_GetURL(tt *testing.T) {
	var zeroValue string
	p := &PackageVersion{URL: &zeroValue}
	p.GetURL()
	p = &PackageVersion{}
	p.GetURL()
	p = nil
	p.GetURL()
}

func TestPackageVersion_GetVersion(tt *testing.T) {
	var zeroValue string
	p := &PackageVersion{Version: &zeroValue}
	p.GetVersion()
	p = &PackageVersion{}
	p.GetVersion()
	p = nil
	p.GetVersion()
}

func TestPage_GetAction(tt *testing.T) {
	var zeroValue string
	p := &Page{Action: &zeroValue}
	p.GetAction()
	p = &Page{}
	p.GetAction()
	p = nil
	p.GetAction()
}

func TestPage_GetHTMLURL(tt *testing.T) {
	var zeroValue string
	p := &Page{HTMLURL: &zeroValue}
	p.GetHTMLURL()
	p = &Page{}
	p.GetHTMLURL()
	p = nil
	p.GetHTMLURL()
}

func TestPage_GetPageName(tt *testing.T) {
	var zeroValue string
	p := &Page{PageName: &zeroValue}
	p.GetPageName()
	p = &Page{}
	p.GetPageName()
	p = nil
	p.GetPageName()
}

func TestPage_GetSHA(tt *testing.T) {
	var zeroValue string
	p := &Page{SHA: &zeroValue}
	p.GetSHA()
	p = &Page{}
	p.GetSHA()
	p = nil
	p.GetSHA()
}

func TestPage_GetSummary(tt *testing.T) {
	var zeroValue string
	p := &Page{Summary: &zeroValue}
	p.GetSummary()
	p = &Page{}
	p.GetSummary()
	p = nil
	p.GetSummary()
}

func TestPage_GetTitle(tt *testing.T) {
	var zeroValue string
	p := &Page{Title: &zeroValue}
	p.GetTitle()
	p = &Page{}
	p.GetTitle()
	p = nil
	p.GetTitle()
}

func TestPageBuildEvent_GetBuild(tt *testing.T) {
	p := &PageBuildEvent{}
	p.GetBuild()
	p = nil
	p.GetBuild()
}

func TestPageBuildEvent_GetID(tt *testing.T) {
	var zeroValue int64
	p := &PageBuildEvent{ID: &zeroValue}
	p.GetID()
	p = &PageBuildEvent{}
	p.GetID()
	p = nil
	p.GetID()
}

func TestPageBuildEvent_GetInstallation(tt *testing.T) {
	p := &PageBuildEvent{}
	p.GetInstallation()
	p = nil
	p.GetInstallation()
}

func TestPageBuildEvent_GetRepo(tt *testing.T) {
	p := &PageBuildEvent{}
	p.GetRepo()
	p = nil
	p.GetRepo()
}

func TestPageBuildEvent_GetSender(tt *testing.T) {
	p := &PageBuildEvent{}
	p.GetSender()
	p = nil
	p.GetSender()
}

func TestPages_GetCNAME(tt *testing.T) {
	var zeroValue string
	p := &Pages{CNAME: &zeroValue}
	p.GetCNAME()
	p = &Pages{}
	p.GetCNAME()
	p = nil
	p.GetCNAME()
}

func TestPages_GetCustom404(tt *testing.T) {
	var zeroValue bool
	p := &Pages{Custom404: &zeroValue}
	p.GetCustom404()
	p = &Pages{}
	p.GetCustom404()
	p = nil
	p.GetCustom404()
}

func TestPages_GetHTMLURL(tt *testing.T) {
	var zeroValue string
	p := &Pages{HTMLURL: &zeroValue}
	p.GetHTMLURL()
	p = &Pages{}
	p.GetHTMLURL()
	p = nil
	p.GetHTMLURL()
}

func TestPages_GetHTTPSCertificate(tt *testing.T) {
	p := &Pages{}
	p.GetHTTPSCertificate()
	p = nil
	p.GetHTTPSCertificate()
}

func TestPages_GetHTTPSEnforced(tt *testing.T) {
	var zeroValue bool
	p := &Pages{HTTPSEnforced: &zeroValue}
	p.GetHTTPSEnforced()
	p = &Pages{}
	p.GetHTTPSEnforced()
	p = nil
	p.GetHTTPSEnforced()
}

func TestPages_GetPublic(tt *testing.T) {
	var zeroValue bool
	p := &Pages{Public: &zeroValue}
	p.GetPublic()
	p = &Pages{}
	p.GetPublic()
	p = nil
	p.GetPublic()
}

func TestPages_GetSource(tt *testing.T) {
	p := &Pages{}
	p.GetSource()
	p = nil
	p.GetSource()
}

func TestPages_GetStatus(tt *testing.T) {
	var zeroValue string
	p := &Pages{Status: &zeroValue}
	p.GetStatus()
	p = &Pages{}
	p.GetStatus()
	p = nil
	p.GetStatus()
}

func TestPages_GetURL(tt *testing.T) {
	var zeroValue string
	p := &Pages{URL: &zeroValue}
	p.GetURL()
	p = &Pages{}
	p.GetURL()
	p = nil
	p.GetURL()
}

func TestPagesBuild_GetCommit(tt *testing.T) {
	var zeroValue string
	p := &PagesBuild{Commit: &zeroValue}
	p.GetCommit()
	p = &PagesBuild{}
	p.GetCommit()
	p = nil
	p.GetCommit()
}

func TestPagesBuild_GetCreatedAt(tt *testing.T) {
	var zeroValue Timestamp
	p := &PagesBuild{CreatedAt: &zeroValue}
	p.GetCreatedAt()
	p = &PagesBuild{}
	p.GetCreatedAt()
	p = nil
	p.GetCreatedAt()
}

func TestPagesBuild_GetDuration(tt *testing.T) {
	var zeroValue int
	p := &PagesBuild{Duration: &zeroValue}
	p.GetDuration()
	p = &PagesBuild{}
	p.GetDuration()
	p = nil
	p.GetDuration()
}

func TestPagesBuild_GetError(tt *testing.T) {
	p := &PagesBuild{}
	p.GetError()
	p = nil
	p.GetError()
}

func TestPagesBuild_GetPusher(tt *testing.T) {
	p := &PagesBuild{}
	p.GetPusher()
	p = nil
	p.GetPusher()
}

func TestPagesBuild_GetStatus(tt *testing.T) {
	var zeroValue string
	p := &PagesBuild{Status: &zeroValue}
	p.GetStatus()
	p = &PagesBuild{}
	p.GetStatus()
	p = nil
	p.GetStatus()
}

func TestPagesBuild_GetUpdatedAt(tt *testing.T) {
	var zeroValue Timestamp
	p := &PagesBuild{UpdatedAt: &zeroValue}
	p.GetUpdatedAt()
	p = &PagesBuild{}
	p.GetUpdatedAt()
	p = nil
	p.GetUpdatedAt()
}

func TestPagesBuild_GetURL(tt *testing.T) {
	var zeroValue string
	p := &PagesBuild{URL: &zeroValue}
	p.GetURL()
	p = &PagesBuild{}
	p.GetURL()
	p = nil
	p.GetURL()
}

func TestPagesError_GetMessage(tt *testing.T) {
	var zeroValue string
	p := &PagesError{Message: &zeroValue}
	p.GetMessage()
	p = &PagesError{}
	p.GetMessage()
	p = nil
	p.GetMessage()
}

func TestPagesHTTPSCertificate_GetDescription(tt *testing.T) {
	var zeroValue string
	p := &PagesHTTPSCertificate{Description: &zeroValue}
	p.GetDescription()
	p = &PagesHTTPSCertificate{}
	p.GetDescription()
	p = nil
	p.GetDescription()
}

func TestPagesHTTPSCertificate_GetExpiresAt(tt *testing.T) {
	var zeroValue string
	p := &PagesHTTPSCertificate{ExpiresAt: &zeroValue}
	p.GetExpiresAt()
	p = &PagesHTTPSCertificate{}
	p.GetExpiresAt()
	p = nil
	p.GetExpiresAt()
}

func TestPagesHTTPSCertificate_GetState(tt *testing.T) {
	var zeroValue string
	p := &PagesHTTPSCertificate{State: &zeroValue}
	p.GetState()
	p = &PagesHTTPSCertificate{}
	p.GetState()
	p = nil
	p.GetState()
}

func TestPagesSource_GetBranch(tt *testing.T) {
	var zeroValue string
	p := &PagesSource{Branch: &zeroValue}
	p.GetBranch()
	p = &PagesSource{}
	p.GetBranch()
	p = nil
	p.GetBranch()
}

func TestPagesSource_GetPath(tt *testing.T) {
	var zeroValue string
	p := &PagesSource{Path: &zeroValue}
	p.GetPath()
	p = &PagesSource{}
	p.GetPath()
	p = nil
	p.GetPath()
}

func TestPageStats_GetTotalPages(tt *testing.T) {
	var zeroValue int
	p := &PageStats{TotalPages: &zeroValue}
	p.GetTotalPages()
	p = &PageStats{}
	p.GetTotalPages()
	p = nil
	p.GetTotalPages()
}

func TestPagesUpdate_GetCNAME(tt *testing.T) {
	var zeroValue string
	p := &PagesUpdate{CNAME: &zeroValue}
	p.GetCNAME()
	p = &PagesUpdate{}
	p.GetCNAME()
	p = nil
	p.GetCNAME()
}

func TestPagesUpdate_GetHTTPSEnforced(tt *testing.T) {
	var zeroValue bool
	p := &PagesUpdate{HTTPSEnforced: &zeroValue}
	p.GetHTTPSEnforced()
	p = &PagesUpdate{}
	p.GetHTTPSEnforced()
	p = nil
	p.GetHTTPSEnforced()
}

func TestPagesUpdate_GetPublic(tt *testing.T) {
	var zeroValue bool
	p := &PagesUpdate{Public: &zeroValue}
	p.GetPublic()
	p = &PagesUpdate{}
	p.GetPublic()
	p = nil
	p.GetPublic()
}

func TestPagesUpdate_GetSource(tt *testing.T) {
	var zeroValue string
	p := &PagesUpdate{Source: &zeroValue}
	p.GetSource()
	p = &PagesUpdate{}
	p.GetSource()
	p = nil
	p.GetSource()
}

func TestPingEvent_GetHook(tt *testing.T) {
	p := &PingEvent{}
	p.GetHook()
	p = nil
	p.GetHook()
}

func TestPingEvent_GetHookID(tt *testing.T) {
	var zeroValue int64
	p := &PingEvent{HookID: &zeroValue}
	p.GetHookID()
	p = &PingEvent{}
	p.GetHookID()
	p = nil
	p.GetHookID()
}

func TestPingEvent_GetInstallation(tt *testing.T) {
	p := &PingEvent{}
	p.GetInstallation()
	p = nil
	p.GetInstallation()
}

func TestPingEvent_GetZen(tt *testing.T) {
	var zeroValue string
	p := &PingEvent{Zen: &zeroValue}
	p.GetZen()
	p = &PingEvent{}
	p.GetZen()
	p = nil
	p.GetZen()
}

func TestPlan_GetCollaborators(tt *testing.T) {
	var zeroValue int
	p := &Plan{Collaborators: &zeroValue}
	p.GetCollaborators()
	p = &Plan{}
	p.GetCollaborators()
	p = nil
	p.GetCollaborators()
}

func TestPlan_GetFilledSeats(tt *testing.T) {
	var zeroValue int
	p := &Plan{FilledSeats: &zeroValue}
	p.GetFilledSeats()
	p = &Plan{}
	p.GetFilledSeats()
	p = nil
	p.GetFilledSeats()
}

func TestPlan_GetName(tt *testing.T) {
	var zeroValue string
	p := &Plan{Name: &zeroValue}
	p.GetName()
	p = &Plan{}
	p.GetName()
	p = nil
	p.GetName()
}

func TestPlan_GetPrivateRepos(tt *testing.T) {
	var zeroValue int
	p := &Plan{PrivateRepos: &zeroValue}
	p.GetPrivateRepos()
	p = &Plan{}
	p.GetPrivateRepos()
	p = nil
	p.GetPrivateRepos()
}

func TestPlan_GetSeats(tt *testing.T) {
	var zeroValue int
	p := &Plan{Seats: &zeroValue}
	p.GetSeats()
	p = &Plan{}
	p.GetSeats()
	p = nil
	p.GetSeats()
}

func TestPlan_GetSpace(tt *testing.T) {
	var zeroValue int
	p := &Plan{Space: &zeroValue}
	p.GetSpace()
	p = &Plan{}
	p.GetSpace()
	p = nil
	p.GetSpace()
}

func TestPreReceiveHook_GetConfigURL(tt *testing.T) {
	var zeroValue string
	p := &PreReceiveHook{ConfigURL: &zeroValue}
	p.GetConfigURL()
	p = &PreReceiveHook{}
	p.GetConfigURL()
	p = nil
	p.GetConfigURL()
}

func TestPreReceiveHook_GetEnforcement(tt *testing.T) {
	var zeroValue string
	p := &PreReceiveHook{Enforcement: &zeroValue}
	p.GetEnforcement()
	p = &PreReceiveHook{}
	p.GetEnforcement()
	p = nil
	p.GetEnforcement()
}

func TestPreReceiveHook_GetID(tt *testing.T) {
	var zeroValue int64
	p := &PreReceiveHook{ID: &zeroValue}
	p.GetID()
	p = &PreReceiveHook{}
	p.GetID()
	p = nil
	p.GetID()
}

func TestPreReceiveHook_GetName(tt *testing.T) {
	var zeroValue string
	p := &PreReceiveHook{Name: &zeroValue}
	p.GetName()
	p = &PreReceiveHook{}
	p.GetName()
	p = nil
	p.GetName()
}

func TestPRLink_GetHRef(tt *testing.T) {
	var zeroValue string
	p := &PRLink{HRef: &zeroValue}
	p.GetHRef()
	p = &PRLink{}
	p.GetHRef()
	p = nil
	p.GetHRef()
}

func TestPRLinks_GetComments(tt *testing.T) {
	p := &PRLinks{}
	p.GetComments()
	p = nil
	p.GetComments()
}

func TestPRLinks_GetCommits(tt *testing.T) {
	p := &PRLinks{}
	p.GetCommits()
	p = nil
	p.GetCommits()
}

func TestPRLinks_GetHTML(tt *testing.T) {
	p := &PRLinks{}
	p.GetHTML()
	p = nil
	p.GetHTML()
}

func TestPRLinks_GetIssue(tt *testing.T) {
	p := &PRLinks{}
	p.GetIssue()
	p = nil
	p.GetIssue()
}

func TestPRLinks_GetReviewComment(tt *testing.T) {
	p := &PRLinks{}
	p.GetReviewComment()
	p = nil
	p.GetReviewComment()
}

func TestPRLinks_GetReviewComments(tt *testing.T) {
	p := &PRLinks{}
	p.GetReviewComments()
	p = nil
	p.GetReviewComments()
}

func TestPRLinks_GetSelf(tt *testing.T) {
	p := &PRLinks{}
	p.GetSelf()
	p = nil
	p.GetSelf()
}

func TestPRLinks_GetStatuses(tt *testing.T) {
	p := &PRLinks{}
	p.GetStatuses()
	p = nil
	p.GetStatuses()
}

func TestProject_GetBody(tt *testing.T) {
	var zeroValue string
	p := &Project{Body: &zeroValue}
	p.GetBody()
	p = &Project{}
	p.GetBody()
	p = nil
	p.GetBody()
}

func TestProject_GetColumnsURL(tt *testing.T) {
	var zeroValue string
	p := &Project{ColumnsURL: &zeroValue}
	p.GetColumnsURL()
	p = &Project{}
	p.GetColumnsURL()
	p = nil
	p.GetColumnsURL()
}

func TestProject_GetCreatedAt(tt *testing.T) {
	var zeroValue Timestamp
	p := &Project{CreatedAt: &zeroValue}
	p.GetCreatedAt()
	p = &Project{}
	p.GetCreatedAt()
	p = nil
	p.GetCreatedAt()
}

func TestProject_GetCreator(tt *testing.T) {
	p := &Project{}
	p.GetCreator()
	p = nil
	p.GetCreator()
}

func TestProject_GetHTMLURL(tt *testing.T) {
	var zeroValue string
	p := &Project{HTMLURL: &zeroValue}
	p.GetHTMLURL()
	p = &Project{}
	p.GetHTMLURL()
	p = nil
	p.GetHTMLURL()
}

func TestProject_GetID(tt *testing.T) {
	var zeroValue int64
	p := &Project{ID: &zeroValue}
	p.GetID()
	p = &Project{}
	p.GetID()
	p = nil
	p.GetID()
}

func TestProject_GetName(tt *testing.T) {
	var zeroValue string
	p := &Project{Name: &zeroValue}
	p.GetName()
	p = &Project{}
	p.GetName()
	p = nil
	p.GetName()
}

func TestProject_GetNodeID(tt *testing.T) {
	var zeroValue string
	p := &Project{NodeID: &zeroValue}
	p.GetNodeID()
	p = &Project{}
	p.GetNodeID()
	p = nil
	p.GetNodeID()
}

func TestProject_GetNumber(tt *testing.T) {
	var zeroValue int
	p := &Project{Number: &zeroValue}
	p.GetNumber()
	p = &Project{}
	p.GetNumber()
	p = nil
	p.GetNumber()
}

func TestProject_GetOrganizationPermission(tt *testing.T) {
	var zeroValue string
	p := &Project{OrganizationPermission: &zeroValue}
	p.GetOrganizationPermission()
	p = &Project{}
	p.GetOrganizationPermission()
	p = nil
	p.GetOrganizationPermission()
}

func TestProject_GetOwnerURL(tt *testing.T) {
	var zeroValue string
	p := &Project{OwnerURL: &zeroValue}
	p.GetOwnerURL()
	p = &Project{}
	p.GetOwnerURL()
	p = nil
	p.GetOwnerURL()
}

func TestProject_GetPrivate(tt *testing.T) {
	var zeroValue bool
	p := &Project{Private: &zeroValue}
	p.GetPrivate()
	p = &Project{}
	p.GetPrivate()
	p = nil
	p.GetPrivate()
}

func TestProject_GetState(tt *testing.T) {
	var zeroValue string
	p := &Project{State: &zeroValue}
	p.GetState()
	p = &Project{}
	p.GetState()
	p = nil
	p.GetState()
}

func TestProject_GetUpdatedAt(tt *testing.T) {
	var zeroValue Timestamp
	p := &Project{UpdatedAt: &zeroValue}
	p.GetUpdatedAt()
	p = &Project{}
	p.GetUpdatedAt()
	p = nil
	p.GetUpdatedAt()
}

func TestProject_GetURL(tt *testing.T) {
	var zeroValue string
	p := &Project{URL: &zeroValue}
	p.GetURL()
	p = &Project{}
	p.GetURL()
	p = nil
	p.GetURL()
}

func TestProjectBody_GetFrom(tt *testing.T) {
	var zeroValue string
	p := &ProjectBody{From: &zeroValue}
	p.GetFrom()
	p = &ProjectBody{}
	p.GetFrom()
	p = nil
	p.GetFrom()
}

func TestProjectCard_GetArchived(tt *testing.T) {
	var zeroValue bool
	p := &ProjectCard{Archived: &zeroValue}
	p.GetArchived()
	p = &ProjectCard{}
	p.GetArchived()
	p = nil
	p.GetArchived()
}

func TestProjectCard_GetColumnID(tt *testing.T) {
	var zeroValue int64
	p := &ProjectCard{ColumnID: &zeroValue}
	p.GetColumnID()
	p = &ProjectCard{}
	p.GetColumnID()
	p = nil
	p.GetColumnID()
}

func TestProjectCard_GetColumnName(tt *testing.T) {
	var zeroValue string
	p := &ProjectCard{ColumnName: &zeroValue}
	p.GetColumnName()
	p = &ProjectCard{}
	p.GetColumnName()
	p = nil
	p.GetColumnName()
}

func TestProjectCard_GetColumnURL(tt *testing.T) {
	var zeroValue string
	p := &ProjectCard{ColumnURL: &zeroValue}
	p.GetColumnURL()
	p = &ProjectCard{}
	p.GetColumnURL()
	p = nil
	p.GetColumnURL()
}

func TestProjectCard_GetContentURL(tt *testing.T) {
	var zeroValue string
	p := &ProjectCard{ContentURL: &zeroValue}
	p.GetContentURL()
	p = &ProjectCard{}
	p.GetContentURL()
	p = nil
	p.GetContentURL()
}

func TestProjectCard_GetCreatedAt(tt *testing.T) {
	var zeroValue Timestamp
	p := &ProjectCard{CreatedAt: &zeroValue}
	p.GetCreatedAt()
	p = &ProjectCard{}
	p.GetCreatedAt()
	p = nil
	p.GetCreatedAt()
}

func TestProjectCard_GetCreator(tt *testing.T) {
	p := &ProjectCard{}
	p.GetCreator()
	p = nil
	p.GetCreator()
}

func TestProjectCard_GetID(tt *testing.T) {
	var zeroValue int64
	p := &ProjectCard{ID: &zeroValue}
	p.GetID()
	p = &ProjectCard{}
	p.GetID()
	p = nil
	p.GetID()
}

func TestProjectCard_GetNodeID(tt *testing.T) {
	var zeroValue string
	p := &ProjectCard{NodeID: &zeroValue}
	p.GetNodeID()
	p = &ProjectCard{}
	p.GetNodeID()
	p = nil
	p.GetNodeID()
}

func TestProjectCard_GetNote(tt *testing.T) {
	var zeroValue string
	p := &ProjectCard{Note: &zeroValue}
	p.GetNote()
	p = &ProjectCard{}
	p.GetNote()
	p = nil
	p.GetNote()
}

func TestProjectCard_GetPreviousColumnName(tt *testing.T) {
	var zeroValue string
	p := &ProjectCard{PreviousColumnName: &zeroValue}
	p.GetPreviousColumnName()
	p = &ProjectCard{}
	p.GetPreviousColumnName()
	p = nil
	p.GetPreviousColumnName()
}

func TestProjectCard_GetProjectID(tt *testing.T) {
	var zeroValue int64
	p := &ProjectCard{ProjectID: &zeroValue}
	p.GetProjectID()
	p = &ProjectCard{}
	p.GetProjectID()
	p = nil
	p.GetProjectID()
}

func TestProjectCard_GetProjectURL(tt *testing.T) {
	var zeroValue string
	p := &ProjectCard{ProjectURL: &zeroValue}
	p.GetProjectURL()
	p = &ProjectCard{}
	p.GetProjectURL()
	p = nil
	p.GetProjectURL()
}

func TestProjectCard_GetUpdatedAt(tt *testing.T) {
	var zeroValue Timestamp
	p := &ProjectCard{UpdatedAt: &zeroValue}
	p.GetUpdatedAt()
	p = &ProjectCard{}
	p.GetUpdatedAt()
	p = nil
	p.GetUpdatedAt()
}

func TestProjectCard_GetURL(tt *testing.T) {
	var zeroValue string
	p := &ProjectCard{URL: &zeroValue}
	p.GetURL()
	p = &ProjectCard{}
	p.GetURL()
	p = nil
	p.GetURL()
}

func TestProjectCardChange_GetNote(tt *testing.T) {
	p := &ProjectCardChange{}
	p.GetNote()
	p = nil
	p.GetNote()
}

func TestProjectCardEvent_GetAction(tt *testing.T) {
	var zeroValue string
	p := &ProjectCardEvent{Action: &zeroValue}
	p.GetAction()
	p = &ProjectCardEvent{}
	p.GetAction()
	p = nil
	p.GetAction()
}

func TestProjectCardEvent_GetAfterID(tt *testing.T) {
	var zeroValue int64
	p := &ProjectCardEvent{AfterID: &zeroValue}
	p.GetAfterID()
	p = &ProjectCardEvent{}
	p.GetAfterID()
	p = nil
	p.GetAfterID()
}

func TestProjectCardEvent_GetChanges(tt *testing.T) {
	p := &ProjectCardEvent{}
	p.GetChanges()
	p = nil
	p.GetChanges()
}

func TestProjectCardEvent_GetInstallation(tt *testing.T) {
	p := &ProjectCardEvent{}
	p.GetInstallation()
	p = nil
	p.GetInstallation()
}

func TestProjectCardEvent_GetOrg(tt *testing.T) {
	p := &ProjectCardEvent{}
	p.GetOrg()
	p = nil
	p.GetOrg()
}

func TestProjectCardEvent_GetProjectCard(tt *testing.T) {
	p := &ProjectCardEvent{}
	p.GetProjectCard()
	p = nil
	p.GetProjectCard()
}

func TestProjectCardEvent_GetRepo(tt *testing.T) {
	p := &ProjectCardEvent{}
	p.GetRepo()
	p = nil
	p.GetRepo()
}

func TestProjectCardEvent_GetSender(tt *testing.T) {
	p := &ProjectCardEvent{}
	p.GetSender()
	p = nil
	p.GetSender()
}

func TestProjectCardListOptions_GetArchivedState(tt *testing.T) {
	var zeroValue string
	p := &ProjectCardListOptions{ArchivedState: &zeroValue}
	p.GetArchivedState()
	p = &ProjectCardListOptions{}
	p.GetArchivedState()
	p = nil
	p.GetArchivedState()
}

func TestProjectCardNote_GetFrom(tt *testing.T) {
	var zeroValue string
	p := &ProjectCardNote{From: &zeroValue}
	p.GetFrom()
	p = &ProjectCardNote{}
	p.GetFrom()
	p = nil
	p.GetFrom()
}

func TestProjectCardOptions_GetArchived(tt *testing.T) {
	var zeroValue bool
	p := &ProjectCardOptions{Archived: &zeroValue}
	p.GetArchived()
	p = &ProjectCardOptions{}
	p.GetArchived()
	p = nil
	p.GetArchived()
}

func TestProjectChange_GetBody(tt *testing.T) {
	p := &ProjectChange{}
	p.GetBody()
	p = nil
	p.GetBody()
}

func TestProjectChange_GetName(tt *testing.T) {
	p := &ProjectChange{}
	p.GetName()
	p = nil
	p.GetName()
}

func TestProjectCollaboratorOptions_GetPermission(tt *testing.T) {
	var zeroValue string
	p := &ProjectCollaboratorOptions{Permission: &zeroValue}
	p.GetPermission()
	p = &ProjectCollaboratorOptions{}
	p.GetPermission()
	p = nil
	p.GetPermission()
}

func TestProjectColumn_GetCardsURL(tt *testing.T) {
	var zeroValue string
	p := &ProjectColumn{CardsURL: &zeroValue}
	p.GetCardsURL()
	p = &ProjectColumn{}
	p.GetCardsURL()
	p = nil
	p.GetCardsURL()
}

func TestProjectColumn_GetCreatedAt(tt *testing.T) {
	var zeroValue Timestamp
	p := &ProjectColumn{CreatedAt: &zeroValue}
	p.GetCreatedAt()
	p = &ProjectColumn{}
	p.GetCreatedAt()
	p = nil
	p.GetCreatedAt()
}

func TestProjectColumn_GetID(tt *testing.T) {
	var zeroValue int64
	p := &ProjectColumn{ID: &zeroValue}
	p.GetID()
	p = &ProjectColumn{}
	p.GetID()
	p = nil
	p.GetID()
}

func TestProjectColumn_GetName(tt *testing.T) {
	var zeroValue string
	p := &ProjectColumn{Name: &zeroValue}
	p.GetName()
	p = &ProjectColumn{}
	p.GetName()
	p = nil
	p.GetName()
}

func TestProjectColumn_GetNodeID(tt *testing.T) {
	var zeroValue string
	p := &ProjectColumn{NodeID: &zeroValue}
	p.GetNodeID()
	p = &ProjectColumn{}
	p.GetNodeID()
	p = nil
	p.GetNodeID()
}

func TestProjectColumn_GetProjectURL(tt *testing.T) {
	var zeroValue string
	p := &ProjectColumn{ProjectURL: &zeroValue}
	p.GetProjectURL()
	p = &ProjectColumn{}
	p.GetProjectURL()
	p = nil
	p.GetProjectURL()
}

func TestProjectColumn_GetUpdatedAt(tt *testing.T) {
	var zeroValue Timestamp
	p := &ProjectColumn{UpdatedAt: &zeroValue}
	p.GetUpdatedAt()
	p = &ProjectColumn{}
	p.GetUpdatedAt()
	p = nil
	p.GetUpdatedAt()
}

func TestProjectColumn_GetURL(tt *testing.T) {
	var zeroValue string
	p := &ProjectColumn{URL: &zeroValue}
	p.GetURL()
	p = &ProjectColumn{}
	p.GetURL()
	p = nil
	p.GetURL()
}

func TestProjectColumnChange_GetName(tt *testing.T) {
	p := &ProjectColumnChange{}
	p.GetName()
	p = nil
	p.GetName()
}

func TestProjectColumnEvent_GetAction(tt *testing.T) {
	var zeroValue string
	p := &ProjectColumnEvent{Action: &zeroValue}
	p.GetAction()
	p = &ProjectColumnEvent{}
	p.GetAction()
	p = nil
	p.GetAction()
}

func TestProjectColumnEvent_GetAfterID(tt *testing.T) {
	var zeroValue int64
	p := &ProjectColumnEvent{AfterID: &zeroValue}
	p.GetAfterID()
	p = &ProjectColumnEvent{}
	p.GetAfterID()
	p = nil
	p.GetAfterID()
}

func TestProjectColumnEvent_GetChanges(tt *testing.T) {
	p := &ProjectColumnEvent{}
	p.GetChanges()
	p = nil
	p.GetChanges()
}

func TestProjectColumnEvent_GetInstallation(tt *testing.T) {
	p := &ProjectColumnEvent{}
	p.GetInstallation()
	p = nil
	p.GetInstallation()
}

func TestProjectColumnEvent_GetOrg(tt *testing.T) {
	p := &ProjectColumnEvent{}
	p.GetOrg()
	p = nil
	p.GetOrg()
}

func TestProjectColumnEvent_GetProjectColumn(tt *testing.T) {
	p := &ProjectColumnEvent{}
	p.GetProjectColumn()
	p = nil
	p.GetProjectColumn()
}

func TestProjectColumnEvent_GetRepo(tt *testing.T) {
	p := &ProjectColumnEvent{}
	p.GetRepo()
	p = nil
	p.GetRepo()
}

func TestProjectColumnEvent_GetSender(tt *testing.T) {
	p := &ProjectColumnEvent{}
	p.GetSender()
	p = nil
	p.GetSender()
}

func TestProjectColumnName_GetFrom(tt *testing.T) {
	var zeroValue string
	p := &ProjectColumnName{From: &zeroValue}
	p.GetFrom()
	p = &ProjectColumnName{}
	p.GetFrom()
	p = nil
	p.GetFrom()
}

func TestProjectEvent_GetAction(tt *testing.T) {
	var zeroValue string
	p := &ProjectEvent{Action: &zeroValue}
	p.GetAction()
	p = &ProjectEvent{}
	p.GetAction()
	p = nil
	p.GetAction()
}

func TestProjectEvent_GetChanges(tt *testing.T) {
	p := &ProjectEvent{}
	p.GetChanges()
	p = nil
	p.GetChanges()
}

func TestProjectEvent_GetInstallation(tt *testing.T) {
	p := &ProjectEvent{}
	p.GetInstallation()
	p = nil
	p.GetInstallation()
}

func TestProjectEvent_GetOrg(tt *testing.T) {
	p := &ProjectEvent{}
	p.GetOrg()
	p = nil
	p.GetOrg()
}

func TestProjectEvent_GetProject(tt *testing.T) {
	p := &ProjectEvent{}
	p.GetProject()
	p = nil
	p.GetProject()
}

func TestProjectEvent_GetRepo(tt *testing.T) {
	p := &ProjectEvent{}
	p.GetRepo()
	p = nil
	p.GetRepo()
}

func TestProjectEvent_GetSender(tt *testing.T) {
	p := &ProjectEvent{}
	p.GetSender()
	p = nil
	p.GetSender()
}

func TestProjectName_GetFrom(tt *testing.T) {
	var zeroValue string
	p := &ProjectName{From: &zeroValue}
	p.GetFrom()
	p = &ProjectName{}
	p.GetFrom()
	p = nil
	p.GetFrom()
}

func TestProjectOptions_GetBody(tt *testing.T) {
	var zeroValue string
	p := &ProjectOptions{Body: &zeroValue}
	p.GetBody()
	p = &ProjectOptions{}
	p.GetBody()
	p = nil
	p.GetBody()
}

func TestProjectOptions_GetName(tt *testing.T) {
	var zeroValue string
	p := &ProjectOptions{Name: &zeroValue}
	p.GetName()
	p = &ProjectOptions{}
	p.GetName()
	p = nil
	p.GetName()
}

func TestProjectOptions_GetOrganizationPermission(tt *testing.T) {
	var zeroValue string
	p := &ProjectOptions{OrganizationPermission: &zeroValue}
	p.GetOrganizationPermission()
	p = &ProjectOptions{}
	p.GetOrganizationPermission()
	p = nil
	p.GetOrganizationPermission()
}

func TestProjectOptions_GetPrivate(tt *testing.T) {
	var zeroValue bool
	p := &ProjectOptions{Private: &zeroValue}
	p.GetPrivate()
	p = &ProjectOptions{}
	p.GetPrivate()
	p = nil
	p.GetPrivate()
}

func TestProjectOptions_GetState(tt *testing.T) {
	var zeroValue string
	p := &ProjectOptions{State: &zeroValue}
	p.GetState()
	p = &ProjectOptions{}
	p.GetState()
	p = nil
	p.GetState()
}

func TestProjectPermissionLevel_GetPermission(tt *testing.T) {
	var zeroValue string
	p := &ProjectPermissionLevel{Permission: &zeroValue}
	p.GetPermission()
	p = &ProjectPermissionLevel{}
	p.GetPermission()
	p = nil
	p.GetPermission()
}

func TestProjectPermissionLevel_GetUser(tt *testing.T) {
	p := &ProjectPermissionLevel{}
	p.GetUser()
	p = nil
	p.GetUser()
}

func TestProtection_GetAllowDeletions(tt *testing.T) {
	p := &Protection{}
	p.GetAllowDeletions()
	p = nil
	p.GetAllowDeletions()
}

func TestProtection_GetAllowForcePushes(tt *testing.T) {
	p := &Protection{}
	p.GetAllowForcePushes()
	p = nil
	p.GetAllowForcePushes()
}

func TestProtection_GetEnforceAdmins(tt *testing.T) {
	p := &Protection{}
	p.GetEnforceAdmins()
	p = nil
	p.GetEnforceAdmins()
}

func TestProtection_GetRequiredConversationResolution(tt *testing.T) {
	p := &Protection{}
	p.GetRequiredConversationResolution()
	p = nil
	p.GetRequiredConversationResolution()
}

func TestProtection_GetRequiredPullRequestReviews(tt *testing.T) {
	p := &Protection{}
	p.GetRequiredPullRequestReviews()
	p = nil
	p.GetRequiredPullRequestReviews()
}

func TestProtection_GetRequiredStatusChecks(tt *testing.T) {
	p := &Protection{}
	p.GetRequiredStatusChecks()
	p = nil
	p.GetRequiredStatusChecks()
}

func TestProtection_GetRequireLinearHistory(tt *testing.T) {
	p := &Protection{}
	p.GetRequireLinearHistory()
	p = nil
	p.GetRequireLinearHistory()
}

func TestProtection_GetRestrictions(tt *testing.T) {
	p := &Protection{}
	p.GetRestrictions()
	p = nil
	p.GetRestrictions()
}

func TestProtectionChanges_GetAuthorizedActorNames(tt *testing.T) {
	p := &ProtectionChanges{}
	p.GetAuthorizedActorNames()
	p = nil
	p.GetAuthorizedActorNames()
}

func TestProtectionChanges_GetAuthorizedActorsOnly(tt *testing.T) {
	p := &ProtectionChanges{}
	p.GetAuthorizedActorsOnly()
	p = nil
	p.GetAuthorizedActorsOnly()
}

func TestProtectionRequest_GetAllowDeletions(tt *testing.T) {
	var zeroValue bool
	p := &ProtectionRequest{AllowDeletions: &zeroValue}
	p.GetAllowDeletions()
	p = &ProtectionRequest{}
	p.GetAllowDeletions()
	p = nil
	p.GetAllowDeletions()
}

func TestProtectionRequest_GetAllowForcePushes(tt *testing.T) {
	var zeroValue bool
	p := &ProtectionRequest{AllowForcePushes: &zeroValue}
	p.GetAllowForcePushes()
	p = &ProtectionRequest{}
	p.GetAllowForcePushes()
	p = nil
	p.GetAllowForcePushes()
}

func TestProtectionRequest_GetRequiredConversationResolution(tt *testing.T) {
	var zeroValue bool
	p := &ProtectionRequest{RequiredConversationResolution: &zeroValue}
	p.GetRequiredConversationResolution()
	p = &ProtectionRequest{}
	p.GetRequiredConversationResolution()
	p = nil
	p.GetRequiredConversationResolution()
}

func TestProtectionRequest_GetRequiredPullRequestReviews(tt *testing.T) {
	p := &ProtectionRequest{}
	p.GetRequiredPullRequestReviews()
	p = nil
	p.GetRequiredPullRequestReviews()
}

func TestProtectionRequest_GetRequiredStatusChecks(tt *testing.T) {
	p := &ProtectionRequest{}
	p.GetRequiredStatusChecks()
	p = nil
	p.GetRequiredStatusChecks()
}

func TestProtectionRequest_GetRequireLinearHistory(tt *testing.T) {
	var zeroValue bool
	p := &ProtectionRequest{RequireLinearHistory: &zeroValue}
	p.GetRequireLinearHistory()
	p = &ProtectionRequest{}
	p.GetRequireLinearHistory()
	p = nil
	p.GetRequireLinearHistory()
}

func TestProtectionRequest_GetRestrictions(tt *testing.T) {
	p := &ProtectionRequest{}
	p.GetRestrictions()
	p = nil
	p.GetRestrictions()
}

func TestProtectionRule_GetID(tt *testing.T) {
	var zeroValue int64
	p := &ProtectionRule{ID: &zeroValue}
	p.GetID()
	p = &ProtectionRule{}
	p.GetID()
	p = nil
	p.GetID()
}

func TestProtectionRule_GetNodeID(tt *testing.T) {
	var zeroValue string
	p := &ProtectionRule{NodeID: &zeroValue}
	p.GetNodeID()
	p = &ProtectionRule{}
	p.GetNodeID()
	p = nil
	p.GetNodeID()
}

func TestProtectionRule_GetType(tt *testing.T) {
	var zeroValue string
	p := &ProtectionRule{Type: &zeroValue}
	p.GetType()
	p = &ProtectionRule{}
	p.GetType()
	p = nil
	p.GetType()
}

func TestProtectionRule_GetWaitTimer(tt *testing.T) {
	var zeroValue int
	p := &ProtectionRule{WaitTimer: &zeroValue}
	p.GetWaitTimer()
	p = &ProtectionRule{}
	p.GetWaitTimer()
	p = nil
	p.GetWaitTimer()
}

func TestPublicEvent_GetInstallation(tt *testing.T) {
	p := &PublicEvent{}
	p.GetInstallation()
	p = nil
	p.GetInstallation()
}

func TestPublicEvent_GetRepo(tt *testing.T) {
	p := &PublicEvent{}
	p.GetRepo()
	p = nil
	p.GetRepo()
}

func TestPublicEvent_GetSender(tt *testing.T) {
	p := &PublicEvent{}
	p.GetSender()
	p = nil
	p.GetSender()
}

func TestPublicKey_GetKey(tt *testing.T) {
	var zeroValue string
	p := &PublicKey{Key: &zeroValue}
	p.GetKey()
	p = &PublicKey{}
	p.GetKey()
	p = nil
	p.GetKey()
}

func TestPublicKey_GetKeyID(tt *testing.T) {
	var zeroValue string
	p := &PublicKey{KeyID: &zeroValue}
	p.GetKeyID()
	p = &PublicKey{}
	p.GetKeyID()
	p = nil
	p.GetKeyID()
}

func TestPullRequest_GetActiveLockReason(tt *testing.T) {
	var zeroValue string
	p := &PullRequest{ActiveLockReason: &zeroValue}
	p.GetActiveLockReason()
	p = &PullRequest{}
	p.GetActiveLockReason()
	p = nil
	p.GetActiveLockReason()
}

func TestPullRequest_GetAdditions(tt *testing.T) {
	var zeroValue int
	p := &PullRequest{Additions: &zeroValue}
	p.GetAdditions()
	p = &PullRequest{}
	p.GetAdditions()
	p = nil
	p.GetAdditions()
}

func TestPullRequest_GetAssignee(tt *testing.T) {
	p := &PullRequest{}
	p.GetAssignee()
	p = nil
	p.GetAssignee()
}

func TestPullRequest_GetAuthorAssociation(tt *testing.T) {
	var zeroValue string
	p := &PullRequest{AuthorAssociation: &zeroValue}
	p.GetAuthorAssociation()
	p = &PullRequest{}
	p.GetAuthorAssociation()
	p = nil
	p.GetAuthorAssociation()
}

func TestPullRequest_GetAutoMerge(tt *testing.T) {
	p := &PullRequest{}
	p.GetAutoMerge()
	p = nil
	p.GetAutoMerge()
}

func TestPullRequest_GetBase(tt *testing.T) {
	p := &PullRequest{}
	p.GetBase()
	p = nil
	p.GetBase()
}

func TestPullRequest_GetBody(tt *testing.T) {
	var zeroValue string
	p := &PullRequest{Body: &zeroValue}
	p.GetBody()
	p = &PullRequest{}
	p.GetBody()
	p = nil
	p.GetBody()
}

func TestPullRequest_GetChangedFiles(tt *testing.T) {
	var zeroValue int
	p := &PullRequest{ChangedFiles: &zeroValue}
	p.GetChangedFiles()
	p = &PullRequest{}
	p.GetChangedFiles()
	p = nil
	p.GetChangedFiles()
}

func TestPullRequest_GetClosedAt(tt *testing.T) {
	var zeroValue time.Time
	p := &PullRequest{ClosedAt: &zeroValue}
	p.GetClosedAt()
	p = &PullRequest{}
	p.GetClosedAt()
	p = nil
	p.GetClosedAt()
}

func TestPullRequest_GetComments(tt *testing.T) {
	var zeroValue int
	p := &PullRequest{Comments: &zeroValue}
	p.GetComments()
	p = &PullRequest{}
	p.GetComments()
	p = nil
	p.GetComments()
}

func TestPullRequest_GetCommentsURL(tt *testing.T) {
	var zeroValue string
	p := &PullRequest{CommentsURL: &zeroValue}
	p.GetCommentsURL()
	p = &PullRequest{}
	p.GetCommentsURL()
	p = nil
	p.GetCommentsURL()
}

func TestPullRequest_GetCommits(tt *testing.T) {
	var zeroValue int
	p := &PullRequest{Commits: &zeroValue}
	p.GetCommits()
	p = &PullRequest{}
	p.GetCommits()
	p = nil
	p.GetCommits()
}

func TestPullRequest_GetCommitsURL(tt *testing.T) {
	var zeroValue string
	p := &PullRequest{CommitsURL: &zeroValue}
	p.GetCommitsURL()
	p = &PullRequest{}
	p.GetCommitsURL()
	p = nil
	p.GetCommitsURL()
}

func TestPullRequest_GetCreatedAt(tt *testing.T) {
	var zeroValue time.Time
	p := &PullRequest{CreatedAt: &zeroValue}
	p.GetCreatedAt()
	p = &PullRequest{}
	p.GetCreatedAt()
	p = nil
	p.GetCreatedAt()
}

func TestPullRequest_GetDeletions(tt *testing.T) {
	var zeroValue int
	p := &PullRequest{Deletions: &zeroValue}
	p.GetDeletions()
	p = &PullRequest{}
	p.GetDeletions()
	p = nil
	p.GetDeletions()
}

func TestPullRequest_GetDiffURL(tt *testing.T) {
	var zeroValue string
	p := &PullRequest{DiffURL: &zeroValue}
	p.GetDiffURL()
	p = &PullRequest{}
	p.GetDiffURL()
	p = nil
	p.GetDiffURL()
}

func TestPullRequest_GetDraft(tt *testing.T) {
	var zeroValue bool
	p := &PullRequest{Draft: &zeroValue}
	p.GetDraft()
	p = &PullRequest{}
	p.GetDraft()
	p = nil
	p.GetDraft()
}

func TestPullRequest_GetHead(tt *testing.T) {
	p := &PullRequest{}
	p.GetHead()
	p = nil
	p.GetHead()
}

func TestPullRequest_GetHTMLURL(tt *testing.T) {
	var zeroValue string
	p := &PullRequest{HTMLURL: &zeroValue}
	p.GetHTMLURL()
	p = &PullRequest{}
	p.GetHTMLURL()
	p = nil
	p.GetHTMLURL()
}

func TestPullRequest_GetID(tt *testing.T) {
	var zeroValue int64
	p := &PullRequest{ID: &zeroValue}
	p.GetID()
	p = &PullRequest{}
	p.GetID()
	p = nil
	p.GetID()
}

func TestPullRequest_GetIssueURL(tt *testing.T) {
	var zeroValue string
	p := &PullRequest{IssueURL: &zeroValue}
	p.GetIssueURL()
	p = &PullRequest{}
	p.GetIssueURL()
	p = nil
	p.GetIssueURL()
}

func TestPullRequest_GetLinks(tt *testing.T) {
	p := &PullRequest{}
	p.GetLinks()
	p = nil
	p.GetLinks()
}

func TestPullRequest_GetLocked(tt *testing.T) {
	var zeroValue bool
	p := &PullRequest{Locked: &zeroValue}
	p.GetLocked()
	p = &PullRequest{}
	p.GetLocked()
	p = nil
	p.GetLocked()
}

func TestPullRequest_GetMaintainerCanModify(tt *testing.T) {
	var zeroValue bool
	p := &PullRequest{MaintainerCanModify: &zeroValue}
	p.GetMaintainerCanModify()
	p = &PullRequest{}
	p.GetMaintainerCanModify()
	p = nil
	p.GetMaintainerCanModify()
}

func TestPullRequest_GetMergeable(tt *testing.T) {
	var zeroValue bool
	p := &PullRequest{Mergeable: &zeroValue}
	p.GetMergeable()
	p = &PullRequest{}
	p.GetMergeable()
	p = nil
	p.GetMergeable()
}

func TestPullRequest_GetMergeableState(tt *testing.T) {
	var zeroValue string
	p := &PullRequest{MergeableState: &zeroValue}
	p.GetMergeableState()
	p = &PullRequest{}
	p.GetMergeableState()
	p = nil
	p.GetMergeableState()
}

func TestPullRequest_GetMergeCommitSHA(tt *testing.T) {
	var zeroValue string
	p := &PullRequest{MergeCommitSHA: &zeroValue}
	p.GetMergeCommitSHA()
	p = &PullRequest{}
	p.GetMergeCommitSHA()
	p = nil
	p.GetMergeCommitSHA()
}

func TestPullRequest_GetMerged(tt *testing.T) {
	var zeroValue bool
	p := &PullRequest{Merged: &zeroValue}
	p.GetMerged()
	p = &PullRequest{}
	p.GetMerged()
	p = nil
	p.GetMerged()
}

func TestPullRequest_GetMergedAt(tt *testing.T) {
	var zeroValue time.Time
	p := &PullRequest{MergedAt: &zeroValue}
	p.GetMergedAt()
	p = &PullRequest{}
	p.GetMergedAt()
	p = nil
	p.GetMergedAt()
}

func TestPullRequest_GetMergedBy(tt *testing.T) {
	p := &PullRequest{}
	p.GetMergedBy()
	p = nil
	p.GetMergedBy()
}

func TestPullRequest_GetMilestone(tt *testing.T) {
	p := &PullRequest{}
	p.GetMilestone()
	p = nil
	p.GetMilestone()
}

func TestPullRequest_GetNodeID(tt *testing.T) {
	var zeroValue string
	p := &PullRequest{NodeID: &zeroValue}
	p.GetNodeID()
	p = &PullRequest{}
	p.GetNodeID()
	p = nil
	p.GetNodeID()
}

func TestPullRequest_GetNumber(tt *testing.T) {
	var zeroValue int
	p := &PullRequest{Number: &zeroValue}
	p.GetNumber()
	p = &PullRequest{}
	p.GetNumber()
	p = nil
	p.GetNumber()
}

func TestPullRequest_GetPatchURL(tt *testing.T) {
	var zeroValue string
	p := &PullRequest{PatchURL: &zeroValue}
	p.GetPatchURL()
	p = &PullRequest{}
	p.GetPatchURL()
	p = nil
	p.GetPatchURL()
}

func TestPullRequest_GetRebaseable(tt *testing.T) {
	var zeroValue bool
	p := &PullRequest{Rebaseable: &zeroValue}
	p.GetRebaseable()
	p = &PullRequest{}
	p.GetRebaseable()
	p = nil
	p.GetRebaseable()
}

func TestPullRequest_GetReviewComments(tt *testing.T) {
	var zeroValue int
	p := &PullRequest{ReviewComments: &zeroValue}
	p.GetReviewComments()
	p = &PullRequest{}
	p.GetReviewComments()
	p = nil
	p.GetReviewComments()
}

func TestPullRequest_GetReviewCommentsURL(tt *testing.T) {
	var zeroValue string
	p := &PullRequest{ReviewCommentsURL: &zeroValue}
	p.GetReviewCommentsURL()
	p = &PullRequest{}
	p.GetReviewCommentsURL()
	p = nil
	p.GetReviewCommentsURL()
}

func TestPullRequest_GetReviewCommentURL(tt *testing.T) {
	var zeroValue string
	p := &PullRequest{ReviewCommentURL: &zeroValue}
	p.GetReviewCommentURL()
	p = &PullRequest{}
	p.GetReviewCommentURL()
	p = nil
	p.GetReviewCommentURL()
}

func TestPullRequest_GetState(tt *testing.T) {
	var zeroValue string
	p := &PullRequest{State: &zeroValue}
	p.GetState()
	p = &PullRequest{}
	p.GetState()
	p = nil
	p.GetState()
}

func TestPullRequest_GetStatusesURL(tt *testing.T) {
	var zeroValue string
	p := &PullRequest{StatusesURL: &zeroValue}
	p.GetStatusesURL()
	p = &PullRequest{}
	p.GetStatusesURL()
	p = nil
	p.GetStatusesURL()
}

func TestPullRequest_GetTitle(tt *testing.T) {
	var zeroValue string
	p := &PullRequest{Title: &zeroValue}
	p.GetTitle()
	p = &PullRequest{}
	p.GetTitle()
	p = nil
	p.GetTitle()
}

func TestPullRequest_GetUpdatedAt(tt *testing.T) {
	var zeroValue time.Time
	p := &PullRequest{UpdatedAt: &zeroValue}
	p.GetUpdatedAt()
	p = &PullRequest{}
	p.GetUpdatedAt()
	p = nil
	p.GetUpdatedAt()
}

func TestPullRequest_GetURL(tt *testing.T) {
	var zeroValue string
	p := &PullRequest{URL: &zeroValue}
	p.GetURL()
	p = &PullRequest{}
	p.GetURL()
	p = nil
	p.GetURL()
}

func TestPullRequest_GetUser(tt *testing.T) {
	p := &PullRequest{}
	p.GetUser()
	p = nil
	p.GetUser()
}

func TestPullRequestAutoMerge_GetCommitMessage(tt *testing.T) {
	var zeroValue string
	p := &PullRequestAutoMerge{CommitMessage: &zeroValue}
	p.GetCommitMessage()
	p = &PullRequestAutoMerge{}
	p.GetCommitMessage()
	p = nil
	p.GetCommitMessage()
}

func TestPullRequestAutoMerge_GetCommitTitle(tt *testing.T) {
	var zeroValue string
	p := &PullRequestAutoMerge{CommitTitle: &zeroValue}
	p.GetCommitTitle()
	p = &PullRequestAutoMerge{}
	p.GetCommitTitle()
	p = nil
	p.GetCommitTitle()
}

func TestPullRequestAutoMerge_GetEnabledBy(tt *testing.T) {
	p := &PullRequestAutoMerge{}
	p.GetEnabledBy()
	p = nil
	p.GetEnabledBy()
}

func TestPullRequestAutoMerge_GetMergeMethod(tt *testing.T) {
	var zeroValue string
	p := &PullRequestAutoMerge{MergeMethod: &zeroValue}
	p.GetMergeMethod()
	p = &PullRequestAutoMerge{}
	p.GetMergeMethod()
	p = nil
	p.GetMergeMethod()
}

func TestPullRequestBranch_GetLabel(tt *testing.T) {
	var zeroValue string
	p := &PullRequestBranch{Label: &zeroValue}
	p.GetLabel()
	p = &PullRequestBranch{}
	p.GetLabel()
	p = nil
	p.GetLabel()
}

func TestPullRequestBranch_GetRef(tt *testing.T) {
	var zeroValue string
	p := &PullRequestBranch{Ref: &zeroValue}
	p.GetRef()
	p = &PullRequestBranch{}
	p.GetRef()
	p = nil
	p.GetRef()
}

func TestPullRequestBranch_GetRepo(tt *testing.T) {
	p := &PullRequestBranch{}
	p.GetRepo()
	p = nil
	p.GetRepo()
}

func TestPullRequestBranch_GetSHA(tt *testing.T) {
	var zeroValue string
	p := &PullRequestBranch{SHA: &zeroValue}
	p.GetSHA()
	p = &PullRequestBranch{}
	p.GetSHA()
	p = nil
	p.GetSHA()
}

func TestPullRequestBranch_GetUser(tt *testing.T) {
	p := &PullRequestBranch{}
	p.GetUser()
	p = nil
	p.GetUser()
}

func TestPullRequestBranchUpdateOptions_GetExpectedHeadSHA(tt *testing.T) {
	var zeroValue string
	p := &PullRequestBranchUpdateOptions{ExpectedHeadSHA: &zeroValue}
	p.GetExpectedHeadSHA()
	p = &PullRequestBranchUpdateOptions{}
	p.GetExpectedHeadSHA()
	p = nil
	p.GetExpectedHeadSHA()
}

func TestPullRequestBranchUpdateResponse_GetMessage(tt *testing.T) {
	var zeroValue string
	p := &PullRequestBranchUpdateResponse{Message: &zeroValue}
	p.GetMessage()
	p = &PullRequestBranchUpdateResponse{}
	p.GetMessage()
	p = nil
	p.GetMessage()
}

func TestPullRequestBranchUpdateResponse_GetURL(tt *testing.T) {
	var zeroValue string
	p := &PullRequestBranchUpdateResponse{URL: &zeroValue}
	p.GetURL()
	p = &PullRequestBranchUpdateResponse{}
	p.GetURL()
	p = nil
	p.GetURL()
}

func TestPullRequestComment_GetAuthorAssociation(tt *testing.T) {
	var zeroValue string
	p := &PullRequestComment{AuthorAssociation: &zeroValue}
	p.GetAuthorAssociation()
	p = &PullRequestComment{}
	p.GetAuthorAssociation()
	p = nil
	p.GetAuthorAssociation()
}

func TestPullRequestComment_GetBody(tt *testing.T) {
	var zeroValue string
	p := &PullRequestComment{Body: &zeroValue}
	p.GetBody()
	p = &PullRequestComment{}
	p.GetBody()
	p = nil
	p.GetBody()
}

func TestPullRequestComment_GetCommitID(tt *testing.T) {
	var zeroValue string
	p := &PullRequestComment{CommitID: &zeroValue}
	p.GetCommitID()
	p = &PullRequestComment{}
	p.GetCommitID()
	p = nil
	p.GetCommitID()
}

func TestPullRequestComment_GetCreatedAt(tt *testing.T) {
	var zeroValue time.Time
	p := &PullRequestComment{CreatedAt: &zeroValue}
	p.GetCreatedAt()
	p = &PullRequestComment{}
	p.GetCreatedAt()
	p = nil
	p.GetCreatedAt()
}

func TestPullRequestComment_GetDiffHunk(tt *testing.T) {
	var zeroValue string
	p := &PullRequestComment{DiffHunk: &zeroValue}
	p.GetDiffHunk()
	p = &PullRequestComment{}
	p.GetDiffHunk()
	p = nil
	p.GetDiffHunk()
}

func TestPullRequestComment_GetHTMLURL(tt *testing.T) {
	var zeroValue string
	p := &PullRequestComment{HTMLURL: &zeroValue}
	p.GetHTMLURL()
	p = &PullRequestComment{}
	p.GetHTMLURL()
	p = nil
	p.GetHTMLURL()
}

func TestPullRequestComment_GetID(tt *testing.T) {
	var zeroValue int64
	p := &PullRequestComment{ID: &zeroValue}
	p.GetID()
	p = &PullRequestComment{}
	p.GetID()
	p = nil
	p.GetID()
}

func TestPullRequestComment_GetInReplyTo(tt *testing.T) {
	var zeroValue int64
	p := &PullRequestComment{InReplyTo: &zeroValue}
	p.GetInReplyTo()
	p = &PullRequestComment{}
	p.GetInReplyTo()
	p = nil
	p.GetInReplyTo()
}

func TestPullRequestComment_GetLine(tt *testing.T) {
	var zeroValue int
	p := &PullRequestComment{Line: &zeroValue}
	p.GetLine()
	p = &PullRequestComment{}
	p.GetLine()
	p = nil
	p.GetLine()
}

func TestPullRequestComment_GetNodeID(tt *testing.T) {
	var zeroValue string
	p := &PullRequestComment{NodeID: &zeroValue}
	p.GetNodeID()
	p = &PullRequestComment{}
	p.GetNodeID()
	p = nil
	p.GetNodeID()
}

func TestPullRequestComment_GetOriginalCommitID(tt *testing.T) {
	var zeroValue string
	p := &PullRequestComment{OriginalCommitID: &zeroValue}
	p.GetOriginalCommitID()
	p = &PullRequestComment{}
	p.GetOriginalCommitID()
	p = nil
	p.GetOriginalCommitID()
}

func TestPullRequestComment_GetOriginalLine(tt *testing.T) {
	var zeroValue int
	p := &PullRequestComment{OriginalLine: &zeroValue}
	p.GetOriginalLine()
	p = &PullRequestComment{}
	p.GetOriginalLine()
	p = nil
	p.GetOriginalLine()
}

func TestPullRequestComment_GetOriginalPosition(tt *testing.T) {
	var zeroValue int
	p := &PullRequestComment{OriginalPosition: &zeroValue}
	p.GetOriginalPosition()
	p = &PullRequestComment{}
	p.GetOriginalPosition()
	p = nil
	p.GetOriginalPosition()
}

func TestPullRequestComment_GetOriginalStartLine(tt *testing.T) {
	var zeroValue int
	p := &PullRequestComment{OriginalStartLine: &zeroValue}
	p.GetOriginalStartLine()
	p = &PullRequestComment{}
	p.GetOriginalStartLine()
	p = nil
	p.GetOriginalStartLine()
}

func TestPullRequestComment_GetPath(tt *testing.T) {
	var zeroValue string
	p := &PullRequestComment{Path: &zeroValue}
	p.GetPath()
	p = &PullRequestComment{}
	p.GetPath()
	p = nil
	p.GetPath()
}

func TestPullRequestComment_GetPosition(tt *testing.T) {
	var zeroValue int
	p := &PullRequestComment{Position: &zeroValue}
	p.GetPosition()
	p = &PullRequestComment{}
	p.GetPosition()
	p = nil
	p.GetPosition()
}

func TestPullRequestComment_GetPullRequestReviewID(tt *testing.T) {
	var zeroValue int64
	p := &PullRequestComment{PullRequestReviewID: &zeroValue}
	p.GetPullRequestReviewID()
	p = &PullRequestComment{}
	p.GetPullRequestReviewID()
	p = nil
	p.GetPullRequestReviewID()
}

func TestPullRequestComment_GetPullRequestURL(tt *testing.T) {
	var zeroValue string
	p := &PullRequestComment{PullRequestURL: &zeroValue}
	p.GetPullRequestURL()
	p = &PullRequestComment{}
	p.GetPullRequestURL()
	p = nil
	p.GetPullRequestURL()
}

func TestPullRequestComment_GetReactions(tt *testing.T) {
	p := &PullRequestComment{}
	p.GetReactions()
	p = nil
	p.GetReactions()
}

func TestPullRequestComment_GetSide(tt *testing.T) {
	var zeroValue string
	p := &PullRequestComment{Side: &zeroValue}
	p.GetSide()
	p = &PullRequestComment{}
	p.GetSide()
	p = nil
	p.GetSide()
}

func TestPullRequestComment_GetStartLine(tt *testing.T) {
	var zeroValue int
	p := &PullRequestComment{StartLine: &zeroValue}
	p.GetStartLine()
	p = &PullRequestComment{}
	p.GetStartLine()
	p = nil
	p.GetStartLine()
}

func TestPullRequestComment_GetStartSide(tt *testing.T) {
	var zeroValue string
	p := &PullRequestComment{StartSide: &zeroValue}
	p.GetStartSide()
	p = &PullRequestComment{}
	p.GetStartSide()
	p = nil
	p.GetStartSide()
}

func TestPullRequestComment_GetUpdatedAt(tt *testing.T) {
	var zeroValue time.Time
	p := &PullRequestComment{UpdatedAt: &zeroValue}
	p.GetUpdatedAt()
	p = &PullRequestComment{}
	p.GetUpdatedAt()
	p = nil
	p.GetUpdatedAt()
}

func TestPullRequestComment_GetURL(tt *testing.T) {
	var zeroValue string
	p := &PullRequestComment{URL: &zeroValue}
	p.GetURL()
	p = &PullRequestComment{}
	p.GetURL()
	p = nil
	p.GetURL()
}

func TestPullRequestComment_GetUser(tt *testing.T) {
	p := &PullRequestComment{}
	p.GetUser()
	p = nil
	p.GetUser()
}

func TestPullRequestEvent_GetAction(tt *testing.T) {
	var zeroValue string
	p := &PullRequestEvent{Action: &zeroValue}
	p.GetAction()
	p = &PullRequestEvent{}
	p.GetAction()
	p = nil
	p.GetAction()
}

func TestPullRequestEvent_GetAfter(tt *testing.T) {
	var zeroValue string
	p := &PullRequestEvent{After: &zeroValue}
	p.GetAfter()
	p = &PullRequestEvent{}
	p.GetAfter()
	p = nil
	p.GetAfter()
}

func TestPullRequestEvent_GetAssignee(tt *testing.T) {
	p := &PullRequestEvent{}
	p.GetAssignee()
	p = nil
	p.GetAssignee()
}

func TestPullRequestEvent_GetBefore(tt *testing.T) {
	var zeroValue string
	p := &PullRequestEvent{Before: &zeroValue}
	p.GetBefore()
	p = &PullRequestEvent{}
	p.GetBefore()
	p = nil
	p.GetBefore()
}

func TestPullRequestEvent_GetChanges(tt *testing.T) {
	p := &PullRequestEvent{}
	p.GetChanges()
	p = nil
	p.GetChanges()
}

func TestPullRequestEvent_GetInstallation(tt *testing.T) {
	p := &PullRequestEvent{}
	p.GetInstallation()
	p = nil
	p.GetInstallation()
}

func TestPullRequestEvent_GetLabel(tt *testing.T) {
	p := &PullRequestEvent{}
	p.GetLabel()
	p = nil
	p.GetLabel()
}

func TestPullRequestEvent_GetNumber(tt *testing.T) {
	var zeroValue int
	p := &PullRequestEvent{Number: &zeroValue}
	p.GetNumber()
	p = &PullRequestEvent{}
	p.GetNumber()
	p = nil
	p.GetNumber()
}

func TestPullRequestEvent_GetOrganization(tt *testing.T) {
	p := &PullRequestEvent{}
	p.GetOrganization()
	p = nil
	p.GetOrganization()
}

func TestPullRequestEvent_GetPullRequest(tt *testing.T) {
	p := &PullRequestEvent{}
	p.GetPullRequest()
	p = nil
	p.GetPullRequest()
}

func TestPullRequestEvent_GetRepo(tt *testing.T) {
	p := &PullRequestEvent{}
	p.GetRepo()
	p = nil
	p.GetRepo()
}

func TestPullRequestEvent_GetRequestedReviewer(tt *testing.T) {
	p := &PullRequestEvent{}
	p.GetRequestedReviewer()
	p = nil
	p.GetRequestedReviewer()
}

func TestPullRequestEvent_GetRequestedTeam(tt *testing.T) {
	p := &PullRequestEvent{}
	p.GetRequestedTeam()
	p = nil
	p.GetRequestedTeam()
}

func TestPullRequestEvent_GetSender(tt *testing.T) {
	p := &PullRequestEvent{}
	p.GetSender()
	p = nil
	p.GetSender()
}

func TestPullRequestLinks_GetDiffURL(tt *testing.T) {
	var zeroValue string
	p := &PullRequestLinks{DiffURL: &zeroValue}
	p.GetDiffURL()
	p = &PullRequestLinks{}
	p.GetDiffURL()
	p = nil
	p.GetDiffURL()
}

func TestPullRequestLinks_GetHTMLURL(tt *testing.T) {
	var zeroValue string
	p := &PullRequestLinks{HTMLURL: &zeroValue}
	p.GetHTMLURL()
	p = &PullRequestLinks{}
	p.GetHTMLURL()
	p = nil
	p.GetHTMLURL()
}

func TestPullRequestLinks_GetPatchURL(tt *testing.T) {
	var zeroValue string
	p := &PullRequestLinks{PatchURL: &zeroValue}
	p.GetPatchURL()
	p = &PullRequestLinks{}
	p.GetPatchURL()
	p = nil
	p.GetPatchURL()
}

func TestPullRequestLinks_GetURL(tt *testing.T) {
	var zeroValue string
	p := &PullRequestLinks{URL: &zeroValue}
	p.GetURL()
	p = &PullRequestLinks{}
	p.GetURL()
	p = nil
	p.GetURL()
}

func TestPullRequestMergeResult_GetMerged(tt *testing.T) {
	var zeroValue bool
	p := &PullRequestMergeResult{Merged: &zeroValue}
	p.GetMerged()
	p = &PullRequestMergeResult{}
	p.GetMerged()
	p = nil
	p.GetMerged()
}

func TestPullRequestMergeResult_GetMessage(tt *testing.T) {
	var zeroValue string
	p := &PullRequestMergeResult{Message: &zeroValue}
	p.GetMessage()
	p = &PullRequestMergeResult{}
	p.GetMessage()
	p = nil
	p.GetMessage()
}

func TestPullRequestMergeResult_GetSHA(tt *testing.T) {
	var zeroValue string
	p := &PullRequestMergeResult{SHA: &zeroValue}
	p.GetSHA()
	p = &PullRequestMergeResult{}
	p.GetSHA()
	p = nil
	p.GetSHA()
}

func TestPullRequestReview_GetAuthorAssociation(tt *testing.T) {
	var zeroValue string
	p := &PullRequestReview{AuthorAssociation: &zeroValue}
	p.GetAuthorAssociation()
	p = &PullRequestReview{}
	p.GetAuthorAssociation()
	p = nil
	p.GetAuthorAssociation()
}

func TestPullRequestReview_GetBody(tt *testing.T) {
	var zeroValue string
	p := &PullRequestReview{Body: &zeroValue}
	p.GetBody()
	p = &PullRequestReview{}
	p.GetBody()
	p = nil
	p.GetBody()
}

func TestPullRequestReview_GetCommitID(tt *testing.T) {
	var zeroValue string
	p := &PullRequestReview{CommitID: &zeroValue}
	p.GetCommitID()
	p = &PullRequestReview{}
	p.GetCommitID()
	p = nil
	p.GetCommitID()
}

func TestPullRequestReview_GetHTMLURL(tt *testing.T) {
	var zeroValue string
	p := &PullRequestReview{HTMLURL: &zeroValue}
	p.GetHTMLURL()
	p = &PullRequestReview{}
	p.GetHTMLURL()
	p = nil
	p.GetHTMLURL()
}

func TestPullRequestReview_GetID(tt *testing.T) {
	var zeroValue int64
	p := &PullRequestReview{ID: &zeroValue}
	p.GetID()
	p = &PullRequestReview{}
	p.GetID()
	p = nil
	p.GetID()
}

func TestPullRequestReview_GetNodeID(tt *testing.T) {
	var zeroValue string
	p := &PullRequestReview{NodeID: &zeroValue}
	p.GetNodeID()
	p = &PullRequestReview{}
	p.GetNodeID()
	p = nil
	p.GetNodeID()
}

func TestPullRequestReview_GetPullRequestURL(tt *testing.T) {
	var zeroValue string
	p := &PullRequestReview{PullRequestURL: &zeroValue}
	p.GetPullRequestURL()
	p = &PullRequestReview{}
	p.GetPullRequestURL()
	p = nil
	p.GetPullRequestURL()
}

func TestPullRequestReview_GetState(tt *testing.T) {
	var zeroValue string
	p := &PullRequestReview{State: &zeroValue}
	p.GetState()
	p = &PullRequestReview{}
	p.GetState()
	p = nil
	p.GetState()
}

func TestPullRequestReview_GetSubmittedAt(tt *testing.T) {
	var zeroValue time.Time
	p := &PullRequestReview{SubmittedAt: &zeroValue}
	p.GetSubmittedAt()
	p = &PullRequestReview{}
	p.GetSubmittedAt()
	p = nil
	p.GetSubmittedAt()
}

func TestPullRequestReview_GetUser(tt *testing.T) {
	p := &PullRequestReview{}
	p.GetUser()
	p = nil
	p.GetUser()
}

func TestPullRequestReviewCommentEvent_GetAction(tt *testing.T) {
	var zeroValue string
	p := &PullRequestReviewCommentEvent{Action: &zeroValue}
	p.GetAction()
	p = &PullRequestReviewCommentEvent{}
	p.GetAction()
	p = nil
	p.GetAction()
}

func TestPullRequestReviewCommentEvent_GetChanges(tt *testing.T) {
	p := &PullRequestReviewCommentEvent{}
	p.GetChanges()
	p = nil
	p.GetChanges()
}

func TestPullRequestReviewCommentEvent_GetComment(tt *testing.T) {
	p := &PullRequestReviewCommentEvent{}
	p.GetComment()
	p = nil
	p.GetComment()
}

func TestPullRequestReviewCommentEvent_GetInstallation(tt *testing.T) {
	p := &PullRequestReviewCommentEvent{}
	p.GetInstallation()
	p = nil
	p.GetInstallation()
}

func TestPullRequestReviewCommentEvent_GetPullRequest(tt *testing.T) {
	p := &PullRequestReviewCommentEvent{}
	p.GetPullRequest()
	p = nil
	p.GetPullRequest()
}

func TestPullRequestReviewCommentEvent_GetRepo(tt *testing.T) {
	p := &PullRequestReviewCommentEvent{}
	p.GetRepo()
	p = nil
	p.GetRepo()
}

func TestPullRequestReviewCommentEvent_GetSender(tt *testing.T) {
	p := &PullRequestReviewCommentEvent{}
	p.GetSender()
	p = nil
	p.GetSender()
}

func TestPullRequestReviewDismissalRequest_GetMessage(tt *testing.T) {
	var zeroValue string
	p := &PullRequestReviewDismissalRequest{Message: &zeroValue}
	p.GetMessage()
	p = &PullRequestReviewDismissalRequest{}
	p.GetMessage()
	p = nil
	p.GetMessage()
}

func TestPullRequestReviewEvent_GetAction(tt *testing.T) {
	var zeroValue string
	p := &PullRequestReviewEvent{Action: &zeroValue}
	p.GetAction()
	p = &PullRequestReviewEvent{}
	p.GetAction()
	p = nil
	p.GetAction()
}

func TestPullRequestReviewEvent_GetInstallation(tt *testing.T) {
	p := &PullRequestReviewEvent{}
	p.GetInstallation()
	p = nil
	p.GetInstallation()
}

func TestPullRequestReviewEvent_GetOrganization(tt *testing.T) {
	p := &PullRequestReviewEvent{}
	p.GetOrganization()
	p = nil
	p.GetOrganization()
}

func TestPullRequestReviewEvent_GetPullRequest(tt *testing.T) {
	p := &PullRequestReviewEvent{}
	p.GetPullRequest()
	p = nil
	p.GetPullRequest()
}

func TestPullRequestReviewEvent_GetRepo(tt *testing.T) {
	p := &PullRequestReviewEvent{}
	p.GetRepo()
	p = nil
	p.GetRepo()
}

func TestPullRequestReviewEvent_GetReview(tt *testing.T) {
	p := &PullRequestReviewEvent{}
	p.GetReview()
	p = nil
	p.GetReview()
}

func TestPullRequestReviewEvent_GetSender(tt *testing.T) {
	p := &PullRequestReviewEvent{}
	p.GetSender()
	p = nil
	p.GetSender()
}

func TestPullRequestReviewRequest_GetBody(tt *testing.T) {
	var zeroValue string
	p := &PullRequestReviewRequest{Body: &zeroValue}
	p.GetBody()
	p = &PullRequestReviewRequest{}
	p.GetBody()
	p = nil
	p.GetBody()
}

func TestPullRequestReviewRequest_GetCommitID(tt *testing.T) {
	var zeroValue string
	p := &PullRequestReviewRequest{CommitID: &zeroValue}
	p.GetCommitID()
	p = &PullRequestReviewRequest{}
	p.GetCommitID()
	p = nil
	p.GetCommitID()
}

func TestPullRequestReviewRequest_GetEvent(tt *testing.T) {
	var zeroValue string
	p := &PullRequestReviewRequest{Event: &zeroValue}
	p.GetEvent()
	p = &PullRequestReviewRequest{}
	p.GetEvent()
	p = nil
	p.GetEvent()
}

func TestPullRequestReviewRequest_GetNodeID(tt *testing.T) {
	var zeroValue string
	p := &PullRequestReviewRequest{NodeID: &zeroValue}
	p.GetNodeID()
	p = &PullRequestReviewRequest{}
	p.GetNodeID()
	p = nil
	p.GetNodeID()
}

func TestPullRequestReviewsEnforcement_GetDismissalRestrictions(tt *testing.T) {
	p := &PullRequestReviewsEnforcement{}
	p.GetDismissalRestrictions()
	p = nil
	p.GetDismissalRestrictions()
}

func TestPullRequestReviewsEnforcementRequest_GetDismissalRestrictionsRequest(tt *testing.T) {
	p := &PullRequestReviewsEnforcementRequest{}
	p.GetDismissalRestrictionsRequest()
	p = nil
	p.GetDismissalRestrictionsRequest()
}

func TestPullRequestReviewsEnforcementUpdate_GetDismissalRestrictionsRequest(tt *testing.T) {
	p := &PullRequestReviewsEnforcementUpdate{}
	p.GetDismissalRestrictionsRequest()
	p = nil
	p.GetDismissalRestrictionsRequest()
}

func TestPullRequestReviewsEnforcementUpdate_GetDismissStaleReviews(tt *testing.T) {
	var zeroValue bool
	p := &PullRequestReviewsEnforcementUpdate{DismissStaleReviews: &zeroValue}
	p.GetDismissStaleReviews()
	p = &PullRequestReviewsEnforcementUpdate{}
	p.GetDismissStaleReviews()
	p = nil
	p.GetDismissStaleReviews()
}

func TestPullRequestReviewsEnforcementUpdate_GetRequireCodeOwnerReviews(tt *testing.T) {
	var zeroValue bool
	p := &PullRequestReviewsEnforcementUpdate{RequireCodeOwnerReviews: &zeroValue}
	p.GetRequireCodeOwnerReviews()
	p = &PullRequestReviewsEnforcementUpdate{}
	p.GetRequireCodeOwnerReviews()
	p = nil
	p.GetRequireCodeOwnerReviews()
}

func TestPullRequestReviewThreadEvent_GetAction(tt *testing.T) {
	var zeroValue string
	p := &PullRequestReviewThreadEvent{Action: &zeroValue}
	p.GetAction()
	p = &PullRequestReviewThreadEvent{}
	p.GetAction()
	p = nil
	p.GetAction()
}

func TestPullRequestReviewThreadEvent_GetInstallation(tt *testing.T) {
	p := &PullRequestReviewThreadEvent{}
	p.GetInstallation()
	p = nil
	p.GetInstallation()
}

func TestPullRequestReviewThreadEvent_GetPullRequest(tt *testing.T) {
	p := &PullRequestReviewThreadEvent{}
	p.GetPullRequest()
	p = nil
	p.GetPullRequest()
}

func TestPullRequestReviewThreadEvent_GetRepo(tt *testing.T) {
	p := &PullRequestReviewThreadEvent{}
	p.GetRepo()
	p = nil
	p.GetRepo()
}

func TestPullRequestReviewThreadEvent_GetSender(tt *testing.T) {
	p := &PullRequestReviewThreadEvent{}
	p.GetSender()
	p = nil
	p.GetSender()
}

func TestPullRequestReviewThreadEvent_GetThread(tt *testing.T) {
	p := &PullRequestReviewThreadEvent{}
	p.GetThread()
	p = nil
	p.GetThread()
}

func TestPullRequestTargetEvent_GetAction(tt *testing.T) {
	var zeroValue string
	p := &PullRequestTargetEvent{Action: &zeroValue}
	p.GetAction()
	p = &PullRequestTargetEvent{}
	p.GetAction()
	p = nil
	p.GetAction()
}

func TestPullRequestTargetEvent_GetAfter(tt *testing.T) {
	var zeroValue string
	p := &PullRequestTargetEvent{After: &zeroValue}
	p.GetAfter()
	p = &PullRequestTargetEvent{}
	p.GetAfter()
	p = nil
	p.GetAfter()
}

func TestPullRequestTargetEvent_GetAssignee(tt *testing.T) {
	p := &PullRequestTargetEvent{}
	p.GetAssignee()
	p = nil
	p.GetAssignee()
}

func TestPullRequestTargetEvent_GetBefore(tt *testing.T) {
	var zeroValue string
	p := &PullRequestTargetEvent{Before: &zeroValue}
	p.GetBefore()
	p = &PullRequestTargetEvent{}
	p.GetBefore()
	p = nil
	p.GetBefore()
}

func TestPullRequestTargetEvent_GetChanges(tt *testing.T) {
	p := &PullRequestTargetEvent{}
	p.GetChanges()
	p = nil
	p.GetChanges()
}

func TestPullRequestTargetEvent_GetInstallation(tt *testing.T) {
	p := &PullRequestTargetEvent{}
	p.GetInstallation()
	p = nil
	p.GetInstallation()
}

func TestPullRequestTargetEvent_GetLabel(tt *testing.T) {
	p := &PullRequestTargetEvent{}
	p.GetLabel()
	p = nil
	p.GetLabel()
}

func TestPullRequestTargetEvent_GetNumber(tt *testing.T) {
	var zeroValue int
	p := &PullRequestTargetEvent{Number: &zeroValue}
	p.GetNumber()
	p = &PullRequestTargetEvent{}
	p.GetNumber()
	p = nil
	p.GetNumber()
}

func TestPullRequestTargetEvent_GetOrganization(tt *testing.T) {
	p := &PullRequestTargetEvent{}
	p.GetOrganization()
	p = nil
	p.GetOrganization()
}

func TestPullRequestTargetEvent_GetPullRequest(tt *testing.T) {
	p := &PullRequestTargetEvent{}
	p.GetPullRequest()
	p = nil
	p.GetPullRequest()
}

func TestPullRequestTargetEvent_GetRepo(tt *testing.T) {
	p := &PullRequestTargetEvent{}
	p.GetRepo()
	p = nil
	p.GetRepo()
}

func TestPullRequestTargetEvent_GetRequestedReviewer(tt *testing.T) {
	p := &PullRequestTargetEvent{}
	p.GetRequestedReviewer()
	p = nil
	p.GetRequestedReviewer()
}

func TestPullRequestTargetEvent_GetRequestedTeam(tt *testing.T) {
	p := &PullRequestTargetEvent{}
	p.GetRequestedTeam()
	p = nil
	p.GetRequestedTeam()
}

func TestPullRequestTargetEvent_GetSender(tt *testing.T) {
	p := &PullRequestTargetEvent{}
	p.GetSender()
	p = nil
	p.GetSender()
}

func TestPullRequestThread_GetID(tt *testing.T) {
	var zeroValue int64
	p := &PullRequestThread{ID: &zeroValue}
	p.GetID()
	p = &PullRequestThread{}
	p.GetID()
	p = nil
	p.GetID()
}

func TestPullRequestThread_GetNodeID(tt *testing.T) {
	var zeroValue string
	p := &PullRequestThread{NodeID: &zeroValue}
	p.GetNodeID()
	p = &PullRequestThread{}
	p.GetNodeID()
	p = nil
	p.GetNodeID()
}

func TestPullStats_GetMergablePulls(tt *testing.T) {
	var zeroValue int
	p := &PullStats{MergablePulls: &zeroValue}
	p.GetMergablePulls()
	p = &PullStats{}
	p.GetMergablePulls()
	p = nil
	p.GetMergablePulls()
}

func TestPullStats_GetMergedPulls(tt *testing.T) {
	var zeroValue int
	p := &PullStats{MergedPulls: &zeroValue}
	p.GetMergedPulls()
	p = &PullStats{}
	p.GetMergedPulls()
	p = nil
	p.GetMergedPulls()
}

func TestPullStats_GetTotalPulls(tt *testing.T) {
	var zeroValue int
	p := &PullStats{TotalPulls: &zeroValue}
	p.GetTotalPulls()
	p = &PullStats{}
	p.GetTotalPulls()
	p = nil
	p.GetTotalPulls()
}

func TestPullStats_GetUnmergablePulls(tt *testing.T) {
	var zeroValue int
	p := &PullStats{UnmergablePulls: &zeroValue}
	p.GetUnmergablePulls()
	p = &PullStats{}
	p.GetUnmergablePulls()
	p = nil
	p.GetUnmergablePulls()
}

func TestPunchCard_GetCommits(tt *testing.T) {
	var zeroValue int
	p := &PunchCard{Commits: &zeroValue}
	p.GetCommits()
	p = &PunchCard{}
	p.GetCommits()
	p = nil
	p.GetCommits()
}

func TestPunchCard_GetDay(tt *testing.T) {
	var zeroValue int
	p := &PunchCard{Day: &zeroValue}
	p.GetDay()
	p = &PunchCard{}
	p.GetDay()
	p = nil
	p.GetDay()
}

func TestPunchCard_GetHour(tt *testing.T) {
	var zeroValue int
	p := &PunchCard{Hour: &zeroValue}
	p.GetHour()
	p = &PunchCard{}
	p.GetHour()
	p = nil
	p.GetHour()
}

func TestPushEvent_GetAction(tt *testing.T) {
	var zeroValue string
	p := &PushEvent{Action: &zeroValue}
	p.GetAction()
	p = &PushEvent{}
	p.GetAction()
	p = nil
	p.GetAction()
}

func TestPushEvent_GetAfter(tt *testing.T) {
	var zeroValue string
	p := &PushEvent{After: &zeroValue}
	p.GetAfter()
	p = &PushEvent{}
	p.GetAfter()
	p = nil
	p.GetAfter()
}

func TestPushEvent_GetBaseRef(tt *testing.T) {
	var zeroValue string
	p := &PushEvent{BaseRef: &zeroValue}
	p.GetBaseRef()
	p = &PushEvent{}
	p.GetBaseRef()
	p = nil
	p.GetBaseRef()
}

func TestPushEvent_GetBefore(tt *testing.T) {
	var zeroValue string
	p := &PushEvent{Before: &zeroValue}
	p.GetBefore()
	p = &PushEvent{}
	p.GetBefore()
	p = nil
	p.GetBefore()
}

func TestPushEvent_GetCompare(tt *testing.T) {
	var zeroValue string
	p := &PushEvent{Compare: &zeroValue}
	p.GetCompare()
	p = &PushEvent{}
	p.GetCompare()
	p = nil
	p.GetCompare()
}

func TestPushEvent_GetCreated(tt *testing.T) {
	var zeroValue bool
	p := &PushEvent{Created: &zeroValue}
	p.GetCreated()
	p = &PushEvent{}
	p.GetCreated()
	p = nil
	p.GetCreated()
}

func TestPushEvent_GetDeleted(tt *testing.T) {
	var zeroValue bool
	p := &PushEvent{Deleted: &zeroValue}
	p.GetDeleted()
	p = &PushEvent{}
	p.GetDeleted()
	p = nil
	p.GetDeleted()
}

func TestPushEvent_GetDistinctSize(tt *testing.T) {
	var zeroValue int
	p := &PushEvent{DistinctSize: &zeroValue}
	p.GetDistinctSize()
	p = &PushEvent{}
	p.GetDistinctSize()
	p = nil
	p.GetDistinctSize()
}

func TestPushEvent_GetForced(tt *testing.T) {
	var zeroValue bool
	p := &PushEvent{Forced: &zeroValue}
	p.GetForced()
	p = &PushEvent{}
	p.GetForced()
	p = nil
	p.GetForced()
}

func TestPushEvent_GetHead(tt *testing.T) {
	var zeroValue string
	p := &PushEvent{Head: &zeroValue}
	p.GetHead()
	p = &PushEvent{}
	p.GetHead()
	p = nil
	p.GetHead()
}

func TestPushEvent_GetHeadCommit(tt *testing.T) {
	p := &PushEvent{}
	p.GetHeadCommit()
	p = nil
	p.GetHeadCommit()
}

func TestPushEvent_GetInstallation(tt *testing.T) {
	p := &PushEvent{}
	p.GetInstallation()
	p = nil
	p.GetInstallation()
}

func TestPushEvent_GetOrganization(tt *testing.T) {
	p := &PushEvent{}
	p.GetOrganization()
	p = nil
	p.GetOrganization()
}

func TestPushEvent_GetPusher(tt *testing.T) {
	p := &PushEvent{}
	p.GetPusher()
	p = nil
	p.GetPusher()
}

func TestPushEvent_GetPushID(tt *testing.T) {
	var zeroValue int64
	p := &PushEvent{PushID: &zeroValue}
	p.GetPushID()
	p = &PushEvent{}
	p.GetPushID()
	p = nil
	p.GetPushID()
}

func TestPushEvent_GetRef(tt *testing.T) {
	var zeroValue string
	p := &PushEvent{Ref: &zeroValue}
	p.GetRef()
	p = &PushEvent{}
	p.GetRef()
	p = nil
	p.GetRef()
}

func TestPushEvent_GetRepo(tt *testing.T) {
	p := &PushEvent{}
	p.GetRepo()
	p = nil
	p.GetRepo()
}

func TestPushEvent_GetSender(tt *testing.T) {
	p := &PushEvent{}
	p.GetSender()
	p = nil
	p.GetSender()
}

func TestPushEvent_GetSize(tt *testing.T) {
	var zeroValue int
	p := &PushEvent{Size: &zeroValue}
	p.GetSize()
	p = &PushEvent{}
	p.GetSize()
	p = nil
	p.GetSize()
}

func TestPushEventRepoOwner_GetEmail(tt *testing.T) {
	var zeroValue string
	p := &PushEventRepoOwner{Email: &zeroValue}
	p.GetEmail()
	p = &PushEventRepoOwner{}
	p.GetEmail()
	p = nil
	p.GetEmail()
}

func TestPushEventRepoOwner_GetName(tt *testing.T) {
	var zeroValue string
	p := &PushEventRepoOwner{Name: &zeroValue}
	p.GetName()
	p = &PushEventRepoOwner{}
	p.GetName()
	p = nil
	p.GetName()
}

func TestPushEventRepository_GetArchived(tt *testing.T) {
	var zeroValue bool
	p := &PushEventRepository{Archived: &zeroValue}
	p.GetArchived()
	p = &PushEventRepository{}
	p.GetArchived()
	p = nil
	p.GetArchived()
}

func TestPushEventRepository_GetArchiveURL(tt *testing.T) {
	var zeroValue string
	p := &PushEventRepository{ArchiveURL: &zeroValue}
	p.GetArchiveURL()
	p = &PushEventRepository{}
	p.GetArchiveURL()
	p = nil
	p.GetArchiveURL()
}

func TestPushEventRepository_GetCloneURL(tt *testing.T) {
	var zeroValue string
	p := &PushEventRepository{CloneURL: &zeroValue}
	p.GetCloneURL()
	p = &PushEventRepository{}
	p.GetCloneURL()
	p = nil
	p.GetCloneURL()
}

func TestPushEventRepository_GetCreatedAt(tt *testing.T) {
	var zeroValue Timestamp
	p := &PushEventRepository{CreatedAt: &zeroValue}
	p.GetCreatedAt()
	p = &PushEventRepository{}
	p.GetCreatedAt()
	p = nil
	p.GetCreatedAt()
}

func TestPushEventRepository_GetDefaultBranch(tt *testing.T) {
	var zeroValue string
	p := &PushEventRepository{DefaultBranch: &zeroValue}
	p.GetDefaultBranch()
	p = &PushEventRepository{}
	p.GetDefaultBranch()
	p = nil
	p.GetDefaultBranch()
}

func TestPushEventRepository_GetDescription(tt *testing.T) {
	var zeroValue string
	p := &PushEventRepository{Description: &zeroValue}
	p.GetDescription()
	p = &PushEventRepository{}
	p.GetDescription()
	p = nil
	p.GetDescription()
}

func TestPushEventRepository_GetDisabled(tt *testing.T) {
	var zeroValue bool
	p := &PushEventRepository{Disabled: &zeroValue}
	p.GetDisabled()
	p = &PushEventRepository{}
	p.GetDisabled()
	p = nil
	p.GetDisabled()
}

func TestPushEventRepository_GetFork(tt *testing.T) {
	var zeroValue bool
	p := &PushEventRepository{Fork: &zeroValue}
	p.GetFork()
	p = &PushEventRepository{}
	p.GetFork()
	p = nil
	p.GetFork()
}

func TestPushEventRepository_GetForksCount(tt *testing.T) {
	var zeroValue int
	p := &PushEventRepository{ForksCount: &zeroValue}
	p.GetForksCount()
	p = &PushEventRepository{}
	p.GetForksCount()
	p = nil
	p.GetForksCount()
}

func TestPushEventRepository_GetFullName(tt *testing.T) {
	var zeroValue string
	p := &PushEventRepository{FullName: &zeroValue}
	p.GetFullName()
	p = &PushEventRepository{}
	p.GetFullName()
	p = nil
	p.GetFullName()
}

func TestPushEventRepository_GetGitURL(tt *testing.T) {
	var zeroValue string
	p := &PushEventRepository{GitURL: &zeroValue}
	p.GetGitURL()
	p = &PushEventRepository{}
	p.GetGitURL()
	p = nil
	p.GetGitURL()
}

func TestPushEventRepository_GetHasDownloads(tt *testing.T) {
	var zeroValue bool
	p := &PushEventRepository{HasDownloads: &zeroValue}
	p.GetHasDownloads()
	p = &PushEventRepository{}
	p.GetHasDownloads()
	p = nil
	p.GetHasDownloads()
}

func TestPushEventRepository_GetHasIssues(tt *testing.T) {
	var zeroValue bool
	p := &PushEventRepository{HasIssues: &zeroValue}
	p.GetHasIssues()
	p = &PushEventRepository{}
	p.GetHasIssues()
	p = nil
	p.GetHasIssues()
}

func TestPushEventRepository_GetHasPages(tt *testing.T) {
	var zeroValue bool
	p := &PushEventRepository{HasPages: &zeroValue}
	p.GetHasPages()
	p = &PushEventRepository{}
	p.GetHasPages()
	p = nil
	p.GetHasPages()
}

func TestPushEventRepository_GetHasWiki(tt *testing.T) {
	var zeroValue bool
	p := &PushEventRepository{HasWiki: &zeroValue}
	p.GetHasWiki()
	p = &PushEventRepository{}
	p.GetHasWiki()
	p = nil
	p.GetHasWiki()
}

func TestPushEventRepository_GetHomepage(tt *testing.T) {
	var zeroValue string
	p := &PushEventRepository{Homepage: &zeroValue}
	p.GetHomepage()
	p = &PushEventRepository{}
	p.GetHomepage()
	p = nil
	p.GetHomepage()
}

func TestPushEventRepository_GetHTMLURL(tt *testing.T) {
	var zeroValue string
	p := &PushEventRepository{HTMLURL: &zeroValue}
	p.GetHTMLURL()
	p = &PushEventRepository{}
	p.GetHTMLURL()
	p = nil
	p.GetHTMLURL()
}

func TestPushEventRepository_GetID(tt *testing.T) {
	var zeroValue int64
	p := &PushEventRepository{ID: &zeroValue}
	p.GetID()
	p = &PushEventRepository{}
	p.GetID()
	p = nil
	p.GetID()
}

func TestPushEventRepository_GetLanguage(tt *testing.T) {
	var zeroValue string
	p := &PushEventRepository{Language: &zeroValue}
	p.GetLanguage()
	p = &PushEventRepository{}
	p.GetLanguage()
	p = nil
	p.GetLanguage()
}

func TestPushEventRepository_GetMasterBranch(tt *testing.T) {
	var zeroValue string
	p := &PushEventRepository{MasterBranch: &zeroValue}
	p.GetMasterBranch()
	p = &PushEventRepository{}
	p.GetMasterBranch()
	p = nil
	p.GetMasterBranch()
}

func TestPushEventRepository_GetName(tt *testing.T) {
	var zeroValue string
	p := &PushEventRepository{Name: &zeroValue}
	p.GetName()
	p = &PushEventRepository{}
	p.GetName()
	p = nil
	p.GetName()
}

func TestPushEventRepository_GetNodeID(tt *testing.T) {
	var zeroValue string
	p := &PushEventRepository{NodeID: &zeroValue}
	p.GetNodeID()
	p = &PushEventRepository{}
	p.GetNodeID()
	p = nil
	p.GetNodeID()
}

func TestPushEventRepository_GetOpenIssuesCount(tt *testing.T) {
	var zeroValue int
	p := &PushEventRepository{OpenIssuesCount: &zeroValue}
	p.GetOpenIssuesCount()
	p = &PushEventRepository{}
	p.GetOpenIssuesCount()
	p = nil
	p.GetOpenIssuesCount()
}

func TestPushEventRepository_GetOrganization(tt *testing.T) {
	var zeroValue string
	p := &PushEventRepository{Organization: &zeroValue}
	p.GetOrganization()
	p = &PushEventRepository{}
	p.GetOrganization()
	p = nil
	p.GetOrganization()
}

func TestPushEventRepository_GetOwner(tt *testing.T) {
	p := &PushEventRepository{}
	p.GetOwner()
	p = nil
	p.GetOwner()
}

func TestPushEventRepository_GetPrivate(tt *testing.T) {
	var zeroValue bool
	p := &PushEventRepository{Private: &zeroValue}
	p.GetPrivate()
	p = &PushEventRepository{}
	p.GetPrivate()
	p = nil
	p.GetPrivate()
}

func TestPushEventRepository_GetPullsURL(tt *testing.T) {
	var zeroValue string
	p := &PushEventRepository{PullsURL: &zeroValue}
	p.GetPullsURL()
	p = &PushEventRepository{}
	p.GetPullsURL()
	p = nil
	p.GetPullsURL()
}

func TestPushEventRepository_GetPushedAt(tt *testing.T) {
	var zeroValue Timestamp
	p := &PushEventRepository{PushedAt: &zeroValue}
	p.GetPushedAt()
	p = &PushEventRepository{}
	p.GetPushedAt()
	p = nil
	p.GetPushedAt()
}

func TestPushEventRepository_GetSize(tt *testing.T) {
	var zeroValue int
	p := &PushEventRepository{Size: &zeroValue}
	p.GetSize()
	p = &PushEventRepository{}
	p.GetSize()
	p = nil
	p.GetSize()
}

func TestPushEventRepository_GetSSHURL(tt *testing.T) {
	var zeroValue string
	p := &PushEventRepository{SSHURL: &zeroValue}
	p.GetSSHURL()
	p = &PushEventRepository{}
	p.GetSSHURL()
	p = nil
	p.GetSSHURL()
}

func TestPushEventRepository_GetStargazersCount(tt *testing.T) {
	var zeroValue int
	p := &PushEventRepository{StargazersCount: &zeroValue}
	p.GetStargazersCount()
	p = &PushEventRepository{}
	p.GetStargazersCount()
	p = nil
	p.GetStargazersCount()
}

func TestPushEventRepository_GetStatusesURL(tt *testing.T) {
	var zeroValue string
	p := &PushEventRepository{StatusesURL: &zeroValue}
	p.GetStatusesURL()
	p = &PushEventRepository{}
	p.GetStatusesURL()
	p = nil
	p.GetStatusesURL()
}

func TestPushEventRepository_GetSVNURL(tt *testing.T) {
	var zeroValue string
	p := &PushEventRepository{SVNURL: &zeroValue}
	p.GetSVNURL()
	p = &PushEventRepository{}
	p.GetSVNURL()
	p = nil
	p.GetSVNURL()
}

func TestPushEventRepository_GetUpdatedAt(tt *testing.T) {
	var zeroValue Timestamp
	p := &PushEventRepository{UpdatedAt: &zeroValue}
	p.GetUpdatedAt()
	p = &PushEventRepository{}
	p.GetUpdatedAt()
	p = nil
	p.GetUpdatedAt()
}

func TestPushEventRepository_GetURL(tt *testing.T) {
	var zeroValue string
	p := &PushEventRepository{URL: &zeroValue}
	p.GetURL()
	p = &PushEventRepository{}
	p.GetURL()
	p = nil
	p.GetURL()
}

func TestPushEventRepository_GetWatchersCount(tt *testing.T) {
	var zeroValue int
	p := &PushEventRepository{WatchersCount: &zeroValue}
	p.GetWatchersCount()
	p = &PushEventRepository{}
	p.GetWatchersCount()
	p = nil
	p.GetWatchersCount()
}

func TestRateLimits_GetActionsRunnerRegistration(tt *testing.T) {
	r := &RateLimits{}
	r.GetActionsRunnerRegistration()
	r = nil
	r.GetActionsRunnerRegistration()
}

func TestRateLimits_GetCodeScanningUpload(tt *testing.T) {
	r := &RateLimits{}
	r.GetCodeScanningUpload()
	r = nil
	r.GetCodeScanningUpload()
}

func TestRateLimits_GetCore(tt *testing.T) {
	r := &RateLimits{}
	r.GetCore()
	r = nil
	r.GetCore()
}

func TestRateLimits_GetGraphQL(tt *testing.T) {
	r := &RateLimits{}
	r.GetGraphQL()
	r = nil
	r.GetGraphQL()
}

func TestRateLimits_GetIntegrationManifest(tt *testing.T) {
	r := &RateLimits{}
	r.GetIntegrationManifest()
	r = nil
	r.GetIntegrationManifest()
}

func TestRateLimits_GetSCIM(tt *testing.T) {
	r := &RateLimits{}
	r.GetSCIM()
	r = nil
	r.GetSCIM()
}

func TestRateLimits_GetSearch(tt *testing.T) {
	r := &RateLimits{}
	r.GetSearch()
	r = nil
	r.GetSearch()
}

func TestRateLimits_GetSourceImport(tt *testing.T) {
	r := &RateLimits{}
	r.GetSourceImport()
	r = nil
	r.GetSourceImport()
}

func TestReaction_GetContent(tt *testing.T) {
	var zeroValue string
	r := &Reaction{Content: &zeroValue}
	r.GetContent()
	r = &Reaction{}
	r.GetContent()
	r = nil
	r.GetContent()
}

func TestReaction_GetID(tt *testing.T) {
	var zeroValue int64
	r := &Reaction{ID: &zeroValue}
	r.GetID()
	r = &Reaction{}
	r.GetID()
	r = nil
	r.GetID()
}

func TestReaction_GetNodeID(tt *testing.T) {
	var zeroValue string
	r := &Reaction{NodeID: &zeroValue}
	r.GetNodeID()
	r = &Reaction{}
	r.GetNodeID()
	r = nil
	r.GetNodeID()
}

func TestReaction_GetUser(tt *testing.T) {
	r := &Reaction{}
	r.GetUser()
	r = nil
	r.GetUser()
}

func TestReactions_GetConfused(tt *testing.T) {
	var zeroValue int
	r := &Reactions{Confused: &zeroValue}
	r.GetConfused()
	r = &Reactions{}
	r.GetConfused()
	r = nil
	r.GetConfused()
}

func TestReactions_GetEyes(tt *testing.T) {
	var zeroValue int
	r := &Reactions{Eyes: &zeroValue}
	r.GetEyes()
	r = &Reactions{}
	r.GetEyes()
	r = nil
	r.GetEyes()
}

func TestReactions_GetHeart(tt *testing.T) {
	var zeroValue int
	r := &Reactions{Heart: &zeroValue}
	r.GetHeart()
	r = &Reactions{}
	r.GetHeart()
	r = nil
	r.GetHeart()
}

func TestReactions_GetHooray(tt *testing.T) {
	var zeroValue int
	r := &Reactions{Hooray: &zeroValue}
	r.GetHooray()
	r = &Reactions{}
	r.GetHooray()
	r = nil
	r.GetHooray()
}

func TestReactions_GetLaugh(tt *testing.T) {
	var zeroValue int
	r := &Reactions{Laugh: &zeroValue}
	r.GetLaugh()
	r = &Reactions{}
	r.GetLaugh()
	r = nil
	r.GetLaugh()
}

func TestReactions_GetMinusOne(tt *testing.T) {
	var zeroValue int
	r := &Reactions{MinusOne: &zeroValue}
	r.GetMinusOne()
	r = &Reactions{}
	r.GetMinusOne()
	r = nil
	r.GetMinusOne()
}

func TestReactions_GetPlusOne(tt *testing.T) {
	var zeroValue int
	r := &Reactions{PlusOne: &zeroValue}
	r.GetPlusOne()
	r = &Reactions{}
	r.GetPlusOne()
	r = nil
	r.GetPlusOne()
}

func TestReactions_GetRocket(tt *testing.T) {
	var zeroValue int
	r := &Reactions{Rocket: &zeroValue}
	r.GetRocket()
	r = &Reactions{}
	r.GetRocket()
	r = nil
	r.GetRocket()
}

func TestReactions_GetTotalCount(tt *testing.T) {
	var zeroValue int
	r := &Reactions{TotalCount: &zeroValue}
	r.GetTotalCount()
	r = &Reactions{}
	r.GetTotalCount()
	r = nil
	r.GetTotalCount()
}

func TestReactions_GetURL(tt *testing.T) {
	var zeroValue string
	r := &Reactions{URL: &zeroValue}
	r.GetURL()
	r = &Reactions{}
	r.GetURL()
	r = nil
	r.GetURL()
}

func TestReference_GetNodeID(tt *testing.T) {
	var zeroValue string
	r := &Reference{NodeID: &zeroValue}
	r.GetNodeID()
	r = &Reference{}
	r.GetNodeID()
	r = nil
	r.GetNodeID()
}

func TestReference_GetObject(tt *testing.T) {
	r := &Reference{}
	r.GetObject()
	r = nil
	r.GetObject()
}

func TestReference_GetRef(tt *testing.T) {
	var zeroValue string
	r := &Reference{Ref: &zeroValue}
	r.GetRef()
	r = &Reference{}
	r.GetRef()
	r = nil
	r.GetRef()
}

func TestReference_GetURL(tt *testing.T) {
	var zeroValue string
	r := &Reference{URL: &zeroValue}
	r.GetURL()
	r = &Reference{}
	r.GetURL()
	r = nil
	r.GetURL()
}

func TestRegistrationToken_GetExpiresAt(tt *testing.T) {
	var zeroValue Timestamp
	r := &RegistrationToken{ExpiresAt: &zeroValue}
	r.GetExpiresAt()
	r = &RegistrationToken{}
	r.GetExpiresAt()
	r = nil
	r.GetExpiresAt()
}

func TestRegistrationToken_GetToken(tt *testing.T) {
	var zeroValue string
	r := &RegistrationToken{Token: &zeroValue}
	r.GetToken()
	r = &RegistrationToken{}
	r.GetToken()
	r = nil
	r.GetToken()
}

func TestReleaseAsset_GetBrowserDownloadURL(tt *testing.T) {
	var zeroValue string
	r := &ReleaseAsset{BrowserDownloadURL: &zeroValue}
	r.GetBrowserDownloadURL()
	r = &ReleaseAsset{}
	r.GetBrowserDownloadURL()
	r = nil
	r.GetBrowserDownloadURL()
}

func TestReleaseAsset_GetContentType(tt *testing.T) {
	var zeroValue string
	r := &ReleaseAsset{ContentType: &zeroValue}
	r.GetContentType()
	r = &ReleaseAsset{}
	r.GetContentType()
	r = nil
	r.GetContentType()
}

func TestReleaseAsset_GetCreatedAt(tt *testing.T) {
	var zeroValue Timestamp
	r := &ReleaseAsset{CreatedAt: &zeroValue}
	r.GetCreatedAt()
	r = &ReleaseAsset{}
	r.GetCreatedAt()
	r = nil
	r.GetCreatedAt()
}

func TestReleaseAsset_GetDownloadCount(tt *testing.T) {
	var zeroValue int
	r := &ReleaseAsset{DownloadCount: &zeroValue}
	r.GetDownloadCount()
	r = &ReleaseAsset{}
	r.GetDownloadCount()
	r = nil
	r.GetDownloadCount()
}

func TestReleaseAsset_GetID(tt *testing.T) {
	var zeroValue int64
	r := &ReleaseAsset{ID: &zeroValue}
	r.GetID()
	r = &ReleaseAsset{}
	r.GetID()
	r = nil
	r.GetID()
}

func TestReleaseAsset_GetLabel(tt *testing.T) {
	var zeroValue string
	r := &ReleaseAsset{Label: &zeroValue}
	r.GetLabel()
	r = &ReleaseAsset{}
	r.GetLabel()
	r = nil
	r.GetLabel()
}

func TestReleaseAsset_GetName(tt *testing.T) {
	var zeroValue string
	r := &ReleaseAsset{Name: &zeroValue}
	r.GetName()
	r = &ReleaseAsset{}
	r.GetName()
	r = nil
	r.GetName()
}

func TestReleaseAsset_GetNodeID(tt *testing.T) {
	var zeroValue string
	r := &ReleaseAsset{NodeID: &zeroValue}
	r.GetNodeID()
	r = &ReleaseAsset{}
	r.GetNodeID()
	r = nil
	r.GetNodeID()
}

func TestReleaseAsset_GetSize(tt *testing.T) {
	var zeroValue int
	r := &ReleaseAsset{Size: &zeroValue}
	r.GetSize()
	r = &ReleaseAsset{}
	r.GetSize()
	r = nil
	r.GetSize()
}

func TestReleaseAsset_GetState(tt *testing.T) {
	var zeroValue string
	r := &ReleaseAsset{State: &zeroValue}
	r.GetState()
	r = &ReleaseAsset{}
	r.GetState()
	r = nil
	r.GetState()
}

func TestReleaseAsset_GetUpdatedAt(tt *testing.T) {
	var zeroValue Timestamp
	r := &ReleaseAsset{UpdatedAt: &zeroValue}
	r.GetUpdatedAt()
	r = &ReleaseAsset{}
	r.GetUpdatedAt()
	r = nil
	r.GetUpdatedAt()
}

func TestReleaseAsset_GetUploader(tt *testing.T) {
	r := &ReleaseAsset{}
	r.GetUploader()
	r = nil
	r.GetUploader()
}

func TestReleaseAsset_GetURL(tt *testing.T) {
	var zeroValue string
	r := &ReleaseAsset{URL: &zeroValue}
	r.GetURL()
	r = &ReleaseAsset{}
	r.GetURL()
	r = nil
	r.GetURL()
}

func TestReleaseEvent_GetAction(tt *testing.T) {
	var zeroValue string
	r := &ReleaseEvent{Action: &zeroValue}
	r.GetAction()
	r = &ReleaseEvent{}
	r.GetAction()
	r = nil
	r.GetAction()
}

func TestReleaseEvent_GetInstallation(tt *testing.T) {
	r := &ReleaseEvent{}
	r.GetInstallation()
	r = nil
	r.GetInstallation()
}

func TestReleaseEvent_GetRelease(tt *testing.T) {
	r := &ReleaseEvent{}
	r.GetRelease()
	r = nil
	r.GetRelease()
}

func TestReleaseEvent_GetRepo(tt *testing.T) {
	r := &ReleaseEvent{}
	r.GetRepo()
	r = nil
	r.GetRepo()
}

func TestReleaseEvent_GetSender(tt *testing.T) {
	r := &ReleaseEvent{}
	r.GetSender()
	r = nil
	r.GetSender()
}

func TestRemoveToken_GetExpiresAt(tt *testing.T) {
	var zeroValue Timestamp
	r := &RemoveToken{ExpiresAt: &zeroValue}
	r.GetExpiresAt()
	r = &RemoveToken{}
	r.GetExpiresAt()
	r = nil
	r.GetExpiresAt()
}

func TestRemoveToken_GetToken(tt *testing.T) {
	var zeroValue string
	r := &RemoveToken{Token: &zeroValue}
	r.GetToken()
	r = &RemoveToken{}
	r.GetToken()
	r = nil
	r.GetToken()
}

func TestRename_GetFrom(tt *testing.T) {
	var zeroValue string
	r := &Rename{From: &zeroValue}
	r.GetFrom()
	r = &Rename{}
	r.GetFrom()
	r = nil
	r.GetFrom()
}

func TestRename_GetTo(tt *testing.T) {
	var zeroValue string
	r := &Rename{To: &zeroValue}
	r.GetTo()
	r = &Rename{}
	r.GetTo()
	r = nil
	r.GetTo()
}

func TestRenameOrgResponse_GetMessage(tt *testing.T) {
	var zeroValue string
	r := &RenameOrgResponse{Message: &zeroValue}
	r.GetMessage()
	r = &RenameOrgResponse{}
	r.GetMessage()
	r = nil
	r.GetMessage()
}

func TestRenameOrgResponse_GetURL(tt *testing.T) {
	var zeroValue string
	r := &RenameOrgResponse{URL: &zeroValue}
	r.GetURL()
	r = &RenameOrgResponse{}
	r.GetURL()
	r = nil
	r.GetURL()
}

func TestRepoMergeUpstreamRequest_GetBranch(tt *testing.T) {
	var zeroValue string
	r := &RepoMergeUpstreamRequest{Branch: &zeroValue}
	r.GetBranch()
	r = &RepoMergeUpstreamRequest{}
	r.GetBranch()
	r = nil
	r.GetBranch()
}

func TestRepoMergeUpstreamResult_GetBaseBranch(tt *testing.T) {
	var zeroValue string
	r := &RepoMergeUpstreamResult{BaseBranch: &zeroValue}
	r.GetBaseBranch()
	r = &RepoMergeUpstreamResult{}
	r.GetBaseBranch()
	r = nil
	r.GetBaseBranch()
}

func TestRepoMergeUpstreamResult_GetMergeType(tt *testing.T) {
	var zeroValue string
	r := &RepoMergeUpstreamResult{MergeType: &zeroValue}
	r.GetMergeType()
	r = &RepoMergeUpstreamResult{}
	r.GetMergeType()
	r = nil
	r.GetMergeType()
}

func TestRepoMergeUpstreamResult_GetMessage(tt *testing.T) {
	var zeroValue string
	r := &RepoMergeUpstreamResult{Message: &zeroValue}
	r.GetMessage()
	r = &RepoMergeUpstreamResult{}
	r.GetMessage()
	r = nil
	r.GetMessage()
}

func TestRepoName_GetFrom(tt *testing.T) {
	var zeroValue string
	r := &RepoName{From: &zeroValue}
	r.GetFrom()
	r = &RepoName{}
	r.GetFrom()
	r = nil
	r.GetFrom()
}

func TestRepositoriesSearchResult_GetIncompleteResults(tt *testing.T) {
	var zeroValue bool
	r := &RepositoriesSearchResult{IncompleteResults: &zeroValue}
	r.GetIncompleteResults()
	r = &RepositoriesSearchResult{}
	r.GetIncompleteResults()
	r = nil
	r.GetIncompleteResults()
}

func TestRepositoriesSearchResult_GetTotal(tt *testing.T) {
	var zeroValue int
	r := &RepositoriesSearchResult{Total: &zeroValue}
	r.GetTotal()
	r = &RepositoriesSearchResult{}
	r.GetTotal()
	r = nil
	r.GetTotal()
}

func TestRepository_GetAllowAutoMerge(tt *testing.T) {
	var zeroValue bool
	r := &Repository{AllowAutoMerge: &zeroValue}
	r.GetAllowAutoMerge()
	r = &Repository{}
	r.GetAllowAutoMerge()
	r = nil
	r.GetAllowAutoMerge()
}

func TestRepository_GetAllowForking(tt *testing.T) {
	var zeroValue bool
	r := &Repository{AllowForking: &zeroValue}
	r.GetAllowForking()
	r = &Repository{}
	r.GetAllowForking()
	r = nil
	r.GetAllowForking()
}

func TestRepository_GetAllowMergeCommit(tt *testing.T) {
	var zeroValue bool
	r := &Repository{AllowMergeCommit: &zeroValue}
	r.GetAllowMergeCommit()
	r = &Repository{}
	r.GetAllowMergeCommit()
	r = nil
	r.GetAllowMergeCommit()
}

func TestRepository_GetAllowRebaseMerge(tt *testing.T) {
	var zeroValue bool
	r := &Repository{AllowRebaseMerge: &zeroValue}
	r.GetAllowRebaseMerge()
	r = &Repository{}
	r.GetAllowRebaseMerge()
	r = nil
	r.GetAllowRebaseMerge()
}

func TestRepository_GetAllowSquashMerge(tt *testing.T) {
	var zeroValue bool
	r := &Repository{AllowSquashMerge: &zeroValue}
	r.GetAllowSquashMerge()
	r = &Repository{}
	r.GetAllowSquashMerge()
	r = nil
	r.GetAllowSquashMerge()
}

func TestRepository_GetAllowUpdateBranch(tt *testing.T) {
	var zeroValue bool
	r := &Repository{AllowUpdateBranch: &zeroValue}
	r.GetAllowUpdateBranch()
	r = &Repository{}
	r.GetAllowUpdateBranch()
	r = nil
	r.GetAllowUpdateBranch()
}

func TestRepository_GetArchived(tt *testing.T) {
	var zeroValue bool
	r := &Repository{Archived: &zeroValue}
	r.GetArchived()
	r = &Repository{}
	r.GetArchived()
	r = nil
	r.GetArchived()
}

func TestRepository_GetArchiveURL(tt *testing.T) {
	var zeroValue string
	r := &Repository{ArchiveURL: &zeroValue}
	r.GetArchiveURL()
	r = &Repository{}
	r.GetArchiveURL()
	r = nil
	r.GetArchiveURL()
}

func TestRepository_GetAssigneesURL(tt *testing.T) {
	var zeroValue string
	r := &Repository{AssigneesURL: &zeroValue}
	r.GetAssigneesURL()
	r = &Repository{}
	r.GetAssigneesURL()
	r = nil
	r.GetAssigneesURL()
}

func TestRepository_GetAutoInit(tt *testing.T) {
	var zeroValue bool
	r := &Repository{AutoInit: &zeroValue}
	r.GetAutoInit()
	r = &Repository{}
	r.GetAutoInit()
	r = nil
	r.GetAutoInit()
}

func TestRepository_GetBlobsURL(tt *testing.T) {
	var zeroValue string
	r := &Repository{BlobsURL: &zeroValue}
	r.GetBlobsURL()
	r = &Repository{}
	r.GetBlobsURL()
	r = nil
	r.GetBlobsURL()
}

func TestRepository_GetBranchesURL(tt *testing.T) {
	var zeroValue string
	r := &Repository{BranchesURL: &zeroValue}
	r.GetBranchesURL()
	r = &Repository{}
	r.GetBranchesURL()
	r = nil
	r.GetBranchesURL()
}

func TestRepository_GetCloneURL(tt *testing.T) {
	var zeroValue string
	r := &Repository{CloneURL: &zeroValue}
	r.GetCloneURL()
	r = &Repository{}
	r.GetCloneURL()
	r = nil
	r.GetCloneURL()
}

func TestRepository_GetCodeOfConduct(tt *testing.T) {
	r := &Repository{}
	r.GetCodeOfConduct()
	r = nil
	r.GetCodeOfConduct()
}

func TestRepository_GetCollaboratorsURL(tt *testing.T) {
	var zeroValue string
	r := &Repository{CollaboratorsURL: &zeroValue}
	r.GetCollaboratorsURL()
	r = &Repository{}
	r.GetCollaboratorsURL()
	r = nil
	r.GetCollaboratorsURL()
}

func TestRepository_GetCommentsURL(tt *testing.T) {
	var zeroValue string
	r := &Repository{CommentsURL: &zeroValue}
	r.GetCommentsURL()
	r = &Repository{}
	r.GetCommentsURL()
	r = nil
	r.GetCommentsURL()
}

func TestRepository_GetCommitsURL(tt *testing.T) {
	var zeroValue string
	r := &Repository{CommitsURL: &zeroValue}
	r.GetCommitsURL()
	r = &Repository{}
	r.GetCommitsURL()
	r = nil
	r.GetCommitsURL()
}

func TestRepository_GetCompareURL(tt *testing.T) {
	var zeroValue string
	r := &Repository{CompareURL: &zeroValue}
	r.GetCompareURL()
	r = &Repository{}
	r.GetCompareURL()
	r = nil
	r.GetCompareURL()
}

func TestRepository_GetContentsURL(tt *testing.T) {
	var zeroValue string
	r := &Repository{ContentsURL: &zeroValue}
	r.GetContentsURL()
	r = &Repository{}
	r.GetContentsURL()
	r = nil
	r.GetContentsURL()
}

func TestRepository_GetContributorsURL(tt *testing.T) {
	var zeroValue string
	r := &Repository{ContributorsURL: &zeroValue}
	r.GetContributorsURL()
	r = &Repository{}
	r.GetContributorsURL()
	r = nil
	r.GetContributorsURL()
}

func TestRepository_GetCreatedAt(tt *testing.T) {
	var zeroValue Timestamp
	r := &Repository{CreatedAt: &zeroValue}
	r.GetCreatedAt()
	r = &Repository{}
	r.GetCreatedAt()
	r = nil
	r.GetCreatedAt()
}

func TestRepository_GetDefaultBranch(tt *testing.T) {
	var zeroValue string
	r := &Repository{DefaultBranch: &zeroValue}
	r.GetDefaultBranch()
	r = &Repository{}
	r.GetDefaultBranch()
	r = nil
	r.GetDefaultBranch()
}

func TestRepository_GetDeleteBranchOnMerge(tt *testing.T) {
	var zeroValue bool
	r := &Repository{DeleteBranchOnMerge: &zeroValue}
	r.GetDeleteBranchOnMerge()
	r = &Repository{}
	r.GetDeleteBranchOnMerge()
	r = nil
	r.GetDeleteBranchOnMerge()
}

func TestRepository_GetDeploymentsURL(tt *testing.T) {
	var zeroValue string
	r := &Repository{DeploymentsURL: &zeroValue}
	r.GetDeploymentsURL()
	r = &Repository{}
	r.GetDeploymentsURL()
	r = nil
	r.GetDeploymentsURL()
}

func TestRepository_GetDescription(tt *testing.T) {
	var zeroValue string
	r := &Repository{Description: &zeroValue}
	r.GetDescription()
	r = &Repository{}
	r.GetDescription()
	r = nil
	r.GetDescription()
}

func TestRepository_GetDisabled(tt *testing.T) {
	var zeroValue bool
	r := &Repository{Disabled: &zeroValue}
	r.GetDisabled()
	r = &Repository{}
	r.GetDisabled()
	r = nil
	r.GetDisabled()
}

func TestRepository_GetDownloadsURL(tt *testing.T) {
	var zeroValue string
	r := &Repository{DownloadsURL: &zeroValue}
	r.GetDownloadsURL()
	r = &Repository{}
	r.GetDownloadsURL()
	r = nil
	r.GetDownloadsURL()
}

func TestRepository_GetEventsURL(tt *testing.T) {
	var zeroValue string
	r := &Repository{EventsURL: &zeroValue}
	r.GetEventsURL()
	r = &Repository{}
	r.GetEventsURL()
	r = nil
	r.GetEventsURL()
}

func TestRepository_GetFork(tt *testing.T) {
	var zeroValue bool
	r := &Repository{Fork: &zeroValue}
	r.GetFork()
	r = &Repository{}
	r.GetFork()
	r = nil
	r.GetFork()
}

func TestRepository_GetForksCount(tt *testing.T) {
	var zeroValue int
	r := &Repository{ForksCount: &zeroValue}
	r.GetForksCount()
	r = &Repository{}
	r.GetForksCount()
	r = nil
	r.GetForksCount()
}

func TestRepository_GetForksURL(tt *testing.T) {
	var zeroValue string
	r := &Repository{ForksURL: &zeroValue}
	r.GetForksURL()
	r = &Repository{}
	r.GetForksURL()
	r = nil
	r.GetForksURL()
}

func TestRepository_GetFullName(tt *testing.T) {
	var zeroValue string
	r := &Repository{FullName: &zeroValue}
	r.GetFullName()
	r = &Repository{}
	r.GetFullName()
	r = nil
	r.GetFullName()
}

func TestRepository_GetGitCommitsURL(tt *testing.T) {
	var zeroValue string
	r := &Repository{GitCommitsURL: &zeroValue}
	r.GetGitCommitsURL()
	r = &Repository{}
	r.GetGitCommitsURL()
	r = nil
	r.GetGitCommitsURL()
}

func TestRepository_GetGitignoreTemplate(tt *testing.T) {
	var zeroValue string
	r := &Repository{GitignoreTemplate: &zeroValue}
	r.GetGitignoreTemplate()
	r = &Repository{}
	r.GetGitignoreTemplate()
	r = nil
	r.GetGitignoreTemplate()
}

func TestRepository_GetGitRefsURL(tt *testing.T) {
	var zeroValue string
	r := &Repository{GitRefsURL: &zeroValue}
	r.GetGitRefsURL()
	r = &Repository{}
	r.GetGitRefsURL()
	r = nil
	r.GetGitRefsURL()
}

func TestRepository_GetGitTagsURL(tt *testing.T) {
	var zeroValue string
	r := &Repository{GitTagsURL: &zeroValue}
	r.GetGitTagsURL()
	r = &Repository{}
	r.GetGitTagsURL()
	r = nil
	r.GetGitTagsURL()
}

func TestRepository_GetGitURL(tt *testing.T) {
	var zeroValue string
	r := &Repository{GitURL: &zeroValue}
	r.GetGitURL()
	r = &Repository{}
	r.GetGitURL()
	r = nil
	r.GetGitURL()
}

func TestRepository_GetHasDownloads(tt *testing.T) {
	var zeroValue bool
	r := &Repository{HasDownloads: &zeroValue}
	r.GetHasDownloads()
	r = &Repository{}
	r.GetHasDownloads()
	r = nil
	r.GetHasDownloads()
}

func TestRepository_GetHasIssues(tt *testing.T) {
	var zeroValue bool
	r := &Repository{HasIssues: &zeroValue}
	r.GetHasIssues()
	r = &Repository{}
	r.GetHasIssues()
	r = nil
	r.GetHasIssues()
}

func TestRepository_GetHasPages(tt *testing.T) {
	var zeroValue bool
	r := &Repository{HasPages: &zeroValue}
	r.GetHasPages()
	r = &Repository{}
	r.GetHasPages()
	r = nil
	r.GetHasPages()
}

func TestRepository_GetHasProjects(tt *testing.T) {
	var zeroValue bool
	r := &Repository{HasProjects: &zeroValue}
	r.GetHasProjects()
	r = &Repository{}
	r.GetHasProjects()
	r = nil
	r.GetHasProjects()
}

func TestRepository_GetHasWiki(tt *testing.T) {
	var zeroValue bool
	r := &Repository{HasWiki: &zeroValue}
	r.GetHasWiki()
	r = &Repository{}
	r.GetHasWiki()
	r = nil
	r.GetHasWiki()
}

func TestRepository_GetHomepage(tt *testing.T) {
	var zeroValue string
	r := &Repository{Homepage: &zeroValue}
	r.GetHomepage()
	r = &Repository{}
	r.GetHomepage()
	r = nil
	r.GetHomepage()
}

func TestRepository_GetHooksURL(tt *testing.T) {
	var zeroValue string
	r := &Repository{HooksURL: &zeroValue}
	r.GetHooksURL()
	r = &Repository{}
	r.GetHooksURL()
	r = nil
	r.GetHooksURL()
}

func TestRepository_GetHTMLURL(tt *testing.T) {
	var zeroValue string
	r := &Repository{HTMLURL: &zeroValue}
	r.GetHTMLURL()
	r = &Repository{}
	r.GetHTMLURL()
	r = nil
	r.GetHTMLURL()
}

func TestRepository_GetID(tt *testing.T) {
	var zeroValue int64
	r := &Repository{ID: &zeroValue}
	r.GetID()
	r = &Repository{}
	r.GetID()
	r = nil
	r.GetID()
}

func TestRepository_GetIssueCommentURL(tt *testing.T) {
	var zeroValue string
	r := &Repository{IssueCommentURL: &zeroValue}
	r.GetIssueCommentURL()
	r = &Repository{}
	r.GetIssueCommentURL()
	r = nil
	r.GetIssueCommentURL()
}

func TestRepository_GetIssueEventsURL(tt *testing.T) {
	var zeroValue string
	r := &Repository{IssueEventsURL: &zeroValue}
	r.GetIssueEventsURL()
	r = &Repository{}
	r.GetIssueEventsURL()
	r = nil
	r.GetIssueEventsURL()
}

func TestRepository_GetIssuesURL(tt *testing.T) {
	var zeroValue string
	r := &Repository{IssuesURL: &zeroValue}
	r.GetIssuesURL()
	r = &Repository{}
	r.GetIssuesURL()
	r = nil
	r.GetIssuesURL()
}

func TestRepository_GetIsTemplate(tt *testing.T) {
	var zeroValue bool
	r := &Repository{IsTemplate: &zeroValue}
	r.GetIsTemplate()
	r = &Repository{}
	r.GetIsTemplate()
	r = nil
	r.GetIsTemplate()
}

func TestRepository_GetKeysURL(tt *testing.T) {
	var zeroValue string
	r := &Repository{KeysURL: &zeroValue}
	r.GetKeysURL()
	r = &Repository{}
	r.GetKeysURL()
	r = nil
	r.GetKeysURL()
}

func TestRepository_GetLabelsURL(tt *testing.T) {
	var zeroValue string
	r := &Repository{LabelsURL: &zeroValue}
	r.GetLabelsURL()
	r = &Repository{}
	r.GetLabelsURL()
	r = nil
	r.GetLabelsURL()
}

func TestRepository_GetLanguage(tt *testing.T) {
	var zeroValue string
	r := &Repository{Language: &zeroValue}
	r.GetLanguage()
	r = &Repository{}
	r.GetLanguage()
	r = nil
	r.GetLanguage()
}

func TestRepository_GetLanguagesURL(tt *testing.T) {
	var zeroValue string
	r := &Repository{LanguagesURL: &zeroValue}
	r.GetLanguagesURL()
	r = &Repository{}
	r.GetLanguagesURL()
	r = nil
	r.GetLanguagesURL()
}

func TestRepository_GetLicense(tt *testing.T) {
	r := &Repository{}
	r.GetLicense()
	r = nil
	r.GetLicense()
}

func TestRepository_GetLicenseTemplate(tt *testing.T) {
	var zeroValue string
	r := &Repository{LicenseTemplate: &zeroValue}
	r.GetLicenseTemplate()
	r = &Repository{}
	r.GetLicenseTemplate()
	r = nil
	r.GetLicenseTemplate()
}

func TestRepository_GetMasterBranch(tt *testing.T) {
	var zeroValue string
	r := &Repository{MasterBranch: &zeroValue}
	r.GetMasterBranch()
	r = &Repository{}
	r.GetMasterBranch()
	r = nil
	r.GetMasterBranch()
}

func TestRepository_GetMergesURL(tt *testing.T) {
	var zeroValue string
	r := &Repository{MergesURL: &zeroValue}
	r.GetMergesURL()
	r = &Repository{}
	r.GetMergesURL()
	r = nil
	r.GetMergesURL()
}

func TestRepository_GetMilestonesURL(tt *testing.T) {
	var zeroValue string
	r := &Repository{MilestonesURL: &zeroValue}
	r.GetMilestonesURL()
	r = &Repository{}
	r.GetMilestonesURL()
	r = nil
	r.GetMilestonesURL()
}

func TestRepository_GetMirrorURL(tt *testing.T) {
	var zeroValue string
	r := &Repository{MirrorURL: &zeroValue}
	r.GetMirrorURL()
	r = &Repository{}
	r.GetMirrorURL()
	r = nil
	r.GetMirrorURL()
}

func TestRepository_GetName(tt *testing.T) {
	var zeroValue string
	r := &Repository{Name: &zeroValue}
	r.GetName()
	r = &Repository{}
	r.GetName()
	r = nil
	r.GetName()
}

func TestRepository_GetNetworkCount(tt *testing.T) {
	var zeroValue int
	r := &Repository{NetworkCount: &zeroValue}
	r.GetNetworkCount()
	r = &Repository{}
	r.GetNetworkCount()
	r = nil
	r.GetNetworkCount()
}

func TestRepository_GetNodeID(tt *testing.T) {
	var zeroValue string
	r := &Repository{NodeID: &zeroValue}
	r.GetNodeID()
	r = &Repository{}
	r.GetNodeID()
	r = nil
	r.GetNodeID()
}

func TestRepository_GetNotificationsURL(tt *testing.T) {
	var zeroValue string
	r := &Repository{NotificationsURL: &zeroValue}
	r.GetNotificationsURL()
	r = &Repository{}
	r.GetNotificationsURL()
	r = nil
	r.GetNotificationsURL()
}

func TestRepository_GetOpenIssues(tt *testing.T) {
	var zeroValue int
	r := &Repository{OpenIssues: &zeroValue}
	r.GetOpenIssues()
	r = &Repository{}
	r.GetOpenIssues()
	r = nil
	r.GetOpenIssues()
}

func TestRepository_GetOpenIssuesCount(tt *testing.T) {
	var zeroValue int
	r := &Repository{OpenIssuesCount: &zeroValue}
	r.GetOpenIssuesCount()
	r = &Repository{}
	r.GetOpenIssuesCount()
	r = nil
	r.GetOpenIssuesCount()
}

func TestRepository_GetOrganization(tt *testing.T) {
	r := &Repository{}
	r.GetOrganization()
	r = nil
	r.GetOrganization()
}

func TestRepository_GetOwner(tt *testing.T) {
	r := &Repository{}
	r.GetOwner()
	r = nil
	r.GetOwner()
}

func TestRepository_GetParent(tt *testing.T) {
	r := &Repository{}
	r.GetParent()
	r = nil
	r.GetParent()
}

func TestRepository_GetPermissions(tt *testing.T) {
	zeroValue := map[string]bool{}
	r := &Repository{Permissions: zeroValue}
	r.GetPermissions()
	r = &Repository{}
	r.GetPermissions()
	r = nil
	r.GetPermissions()
}

func TestRepository_GetPrivate(tt *testing.T) {
	var zeroValue bool
	r := &Repository{Private: &zeroValue}
	r.GetPrivate()
	r = &Repository{}
	r.GetPrivate()
	r = nil
	r.GetPrivate()
}

func TestRepository_GetPullsURL(tt *testing.T) {
	var zeroValue string
	r := &Repository{PullsURL: &zeroValue}
	r.GetPullsURL()
	r = &Repository{}
	r.GetPullsURL()
	r = nil
	r.GetPullsURL()
}

func TestRepository_GetPushedAt(tt *testing.T) {
	var zeroValue Timestamp
	r := &Repository{PushedAt: &zeroValue}
	r.GetPushedAt()
	r = &Repository{}
	r.GetPushedAt()
	r = nil
	r.GetPushedAt()
}

func TestRepository_GetReleasesURL(tt *testing.T) {
	var zeroValue string
	r := &Repository{ReleasesURL: &zeroValue}
	r.GetReleasesURL()
	r = &Repository{}
	r.GetReleasesURL()
	r = nil
	r.GetReleasesURL()
}

func TestRepository_GetSecurityAndAnalysis(tt *testing.T) {
	r := &Repository{}
	r.GetSecurityAndAnalysis()
	r = nil
	r.GetSecurityAndAnalysis()
}

func TestRepository_GetSize(tt *testing.T) {
	var zeroValue int
	r := &Repository{Size: &zeroValue}
	r.GetSize()
	r = &Repository{}
	r.GetSize()
	r = nil
	r.GetSize()
}

func TestRepository_GetSource(tt *testing.T) {
	r := &Repository{}
	r.GetSource()
	r = nil
	r.GetSource()
}

func TestRepository_GetSSHURL(tt *testing.T) {
	var zeroValue string
	r := &Repository{SSHURL: &zeroValue}
	r.GetSSHURL()
	r = &Repository{}
	r.GetSSHURL()
	r = nil
	r.GetSSHURL()
}

func TestRepository_GetStargazersCount(tt *testing.T) {
	var zeroValue int
	r := &Repository{StargazersCount: &zeroValue}
	r.GetStargazersCount()
	r = &Repository{}
	r.GetStargazersCount()
	r = nil
	r.GetStargazersCount()
}

func TestRepository_GetStargazersURL(tt *testing.T) {
	var zeroValue string
	r := &Repository{StargazersURL: &zeroValue}
	r.GetStargazersURL()
	r = &Repository{}
	r.GetStargazersURL()
	r = nil
	r.GetStargazersURL()
}

func TestRepository_GetStatusesURL(tt *testing.T) {
	var zeroValue string
	r := &Repository{StatusesURL: &zeroValue}
	r.GetStatusesURL()
	r = &Repository{}
	r.GetStatusesURL()
	r = nil
	r.GetStatusesURL()
}

func TestRepository_GetSubscribersCount(tt *testing.T) {
	var zeroValue int
	r := &Repository{SubscribersCount: &zeroValue}
	r.GetSubscribersCount()
	r = &Repository{}
	r.GetSubscribersCount()
	r = nil
	r.GetSubscribersCount()
}

func TestRepository_GetSubscribersURL(tt *testing.T) {
	var zeroValue string
	r := &Repository{SubscribersURL: &zeroValue}
	r.GetSubscribersURL()
	r = &Repository{}
	r.GetSubscribersURL()
	r = nil
	r.GetSubscribersURL()
}

func TestRepository_GetSubscriptionURL(tt *testing.T) {
	var zeroValue string
	r := &Repository{SubscriptionURL: &zeroValue}
	r.GetSubscriptionURL()
	r = &Repository{}
	r.GetSubscriptionURL()
	r = nil
	r.GetSubscriptionURL()
}

func TestRepository_GetSVNURL(tt *testing.T) {
	var zeroValue string
	r := &Repository{SVNURL: &zeroValue}
	r.GetSVNURL()
	r = &Repository{}
	r.GetSVNURL()
	r = nil
	r.GetSVNURL()
}

func TestRepository_GetTagsURL(tt *testing.T) {
	var zeroValue string
	r := &Repository{TagsURL: &zeroValue}
	r.GetTagsURL()
	r = &Repository{}
	r.GetTagsURL()
	r = nil
	r.GetTagsURL()
}

func TestRepository_GetTeamID(tt *testing.T) {
	var zeroValue int64
	r := &Repository{TeamID: &zeroValue}
	r.GetTeamID()
	r = &Repository{}
	r.GetTeamID()
	r = nil
	r.GetTeamID()
}

func TestRepository_GetTeamsURL(tt *testing.T) {
	var zeroValue string
	r := &Repository{TeamsURL: &zeroValue}
	r.GetTeamsURL()
	r = &Repository{}
	r.GetTeamsURL()
	r = nil
	r.GetTeamsURL()
}

func TestRepository_GetTemplateRepository(tt *testing.T) {
	r := &Repository{}
	r.GetTemplateRepository()
	r = nil
	r.GetTemplateRepository()
}

func TestRepository_GetTreesURL(tt *testing.T) {
	var zeroValue string
	r := &Repository{TreesURL: &zeroValue}
	r.GetTreesURL()
	r = &Repository{}
	r.GetTreesURL()
	r = nil
	r.GetTreesURL()
}

func TestRepository_GetUpdatedAt(tt *testing.T) {
	var zeroValue Timestamp
	r := &Repository{UpdatedAt: &zeroValue}
	r.GetUpdatedAt()
	r = &Repository{}
	r.GetUpdatedAt()
	r = nil
	r.GetUpdatedAt()
}

func TestRepository_GetURL(tt *testing.T) {
	var zeroValue string
	r := &Repository{URL: &zeroValue}
	r.GetURL()
	r = &Repository{}
	r.GetURL()
	r = nil
	r.GetURL()
}

func TestRepository_GetVisibility(tt *testing.T) {
	var zeroValue string
	r := &Repository{Visibility: &zeroValue}
	r.GetVisibility()
	r = &Repository{}
	r.GetVisibility()
	r = nil
	r.GetVisibility()
}

func TestRepository_GetWatchers(tt *testing.T) {
	var zeroValue int
	r := &Repository{Watchers: &zeroValue}
	r.GetWatchers()
	r = &Repository{}
	r.GetWatchers()
	r = nil
	r.GetWatchers()
}

func TestRepository_GetWatchersCount(tt *testing.T) {
	var zeroValue int
	r := &Repository{WatchersCount: &zeroValue}
	r.GetWatchersCount()
	r = &Repository{}
	r.GetWatchersCount()
	r = nil
	r.GetWatchersCount()
}

func TestRepositoryActiveCommitters_GetAdvancedSecurityCommitters(tt *testing.T) {
	var zeroValue int
	r := &RepositoryActiveCommitters{AdvancedSecurityCommitters: &zeroValue}
	r.GetAdvancedSecurityCommitters()
	r = &RepositoryActiveCommitters{}
	r.GetAdvancedSecurityCommitters()
	r = nil
	r.GetAdvancedSecurityCommitters()
}

func TestRepositoryActiveCommitters_GetName(tt *testing.T) {
	var zeroValue string
	r := &RepositoryActiveCommitters{Name: &zeroValue}
	r.GetName()
	r = &RepositoryActiveCommitters{}
	r.GetName()
	r = nil
	r.GetName()
}

func TestRepositoryComment_GetBody(tt *testing.T) {
	var zeroValue string
	r := &RepositoryComment{Body: &zeroValue}
	r.GetBody()
	r = &RepositoryComment{}
	r.GetBody()
	r = nil
	r.GetBody()
}

func TestRepositoryComment_GetCommitID(tt *testing.T) {
	var zeroValue string
	r := &RepositoryComment{CommitID: &zeroValue}
	r.GetCommitID()
	r = &RepositoryComment{}
	r.GetCommitID()
	r = nil
	r.GetCommitID()
}

func TestRepositoryComment_GetCreatedAt(tt *testing.T) {
	var zeroValue time.Time
	r := &RepositoryComment{CreatedAt: &zeroValue}
	r.GetCreatedAt()
	r = &RepositoryComment{}
	r.GetCreatedAt()
	r = nil
	r.GetCreatedAt()
}

func TestRepositoryComment_GetHTMLURL(tt *testing.T) {
	var zeroValue string
	r := &RepositoryComment{HTMLURL: &zeroValue}
	r.GetHTMLURL()
	r = &RepositoryComment{}
	r.GetHTMLURL()
	r = nil
	r.GetHTMLURL()
}

func TestRepositoryComment_GetID(tt *testing.T) {
	var zeroValue int64
	r := &RepositoryComment{ID: &zeroValue}
	r.GetID()
	r = &RepositoryComment{}
	r.GetID()
	r = nil
	r.GetID()
}

func TestRepositoryComment_GetNodeID(tt *testing.T) {
	var zeroValue string
	r := &RepositoryComment{NodeID: &zeroValue}
	r.GetNodeID()
	r = &RepositoryComment{}
	r.GetNodeID()
	r = nil
	r.GetNodeID()
}

func TestRepositoryComment_GetPath(tt *testing.T) {
	var zeroValue string
	r := &RepositoryComment{Path: &zeroValue}
	r.GetPath()
	r = &RepositoryComment{}
	r.GetPath()
	r = nil
	r.GetPath()
}

func TestRepositoryComment_GetPosition(tt *testing.T) {
	var zeroValue int
	r := &RepositoryComment{Position: &zeroValue}
	r.GetPosition()
	r = &RepositoryComment{}
	r.GetPosition()
	r = nil
	r.GetPosition()
}

func TestRepositoryComment_GetReactions(tt *testing.T) {
	r := &RepositoryComment{}
	r.GetReactions()
	r = nil
	r.GetReactions()
}

func TestRepositoryComment_GetUpdatedAt(tt *testing.T) {
	var zeroValue time.Time
	r := &RepositoryComment{UpdatedAt: &zeroValue}
	r.GetUpdatedAt()
	r = &RepositoryComment{}
	r.GetUpdatedAt()
	r = nil
	r.GetUpdatedAt()
}

func TestRepositoryComment_GetURL(tt *testing.T) {
	var zeroValue string
	r := &RepositoryComment{URL: &zeroValue}
	r.GetURL()
	r = &RepositoryComment{}
	r.GetURL()
	r = nil
	r.GetURL()
}

func TestRepositoryComment_GetUser(tt *testing.T) {
	r := &RepositoryComment{}
	r.GetUser()
	r = nil
	r.GetUser()
}

func TestRepositoryCommit_GetAuthor(tt *testing.T) {
	r := &RepositoryCommit{}
	r.GetAuthor()
	r = nil
	r.GetAuthor()
}

func TestRepositoryCommit_GetCommentsURL(tt *testing.T) {
	var zeroValue string
	r := &RepositoryCommit{CommentsURL: &zeroValue}
	r.GetCommentsURL()
	r = &RepositoryCommit{}
	r.GetCommentsURL()
	r = nil
	r.GetCommentsURL()
}

func TestRepositoryCommit_GetCommit(tt *testing.T) {
	r := &RepositoryCommit{}
	r.GetCommit()
	r = nil
	r.GetCommit()
}

func TestRepositoryCommit_GetCommitter(tt *testing.T) {
	r := &RepositoryCommit{}
	r.GetCommitter()
	r = nil
	r.GetCommitter()
}

func TestRepositoryCommit_GetHTMLURL(tt *testing.T) {
	var zeroValue string
	r := &RepositoryCommit{HTMLURL: &zeroValue}
	r.GetHTMLURL()
	r = &RepositoryCommit{}
	r.GetHTMLURL()
	r = nil
	r.GetHTMLURL()
}

func TestRepositoryCommit_GetNodeID(tt *testing.T) {
	var zeroValue string
	r := &RepositoryCommit{NodeID: &zeroValue}
	r.GetNodeID()
	r = &RepositoryCommit{}
	r.GetNodeID()
	r = nil
	r.GetNodeID()
}

func TestRepositoryCommit_GetSHA(tt *testing.T) {
	var zeroValue string
	r := &RepositoryCommit{SHA: &zeroValue}
	r.GetSHA()
	r = &RepositoryCommit{}
	r.GetSHA()
	r = nil
	r.GetSHA()
}

func TestRepositoryCommit_GetStats(tt *testing.T) {
	r := &RepositoryCommit{}
	r.GetStats()
	r = nil
	r.GetStats()
}

func TestRepositoryCommit_GetURL(tt *testing.T) {
	var zeroValue string
	r := &RepositoryCommit{URL: &zeroValue}
	r.GetURL()
	r = &RepositoryCommit{}
	r.GetURL()
	r = nil
	r.GetURL()
}

func TestRepositoryContent_GetDownloadURL(tt *testing.T) {
	var zeroValue string
	r := &RepositoryContent{DownloadURL: &zeroValue}
	r.GetDownloadURL()
	r = &RepositoryContent{}
	r.GetDownloadURL()
	r = nil
	r.GetDownloadURL()
}

func TestRepositoryContent_GetEncoding(tt *testing.T) {
	var zeroValue string
	r := &RepositoryContent{Encoding: &zeroValue}
	r.GetEncoding()
	r = &RepositoryContent{}
	r.GetEncoding()
	r = nil
	r.GetEncoding()
}

func TestRepositoryContent_GetGitURL(tt *testing.T) {
	var zeroValue string
	r := &RepositoryContent{GitURL: &zeroValue}
	r.GetGitURL()
	r = &RepositoryContent{}
	r.GetGitURL()
	r = nil
	r.GetGitURL()
}

func TestRepositoryContent_GetHTMLURL(tt *testing.T) {
	var zeroValue string
	r := &RepositoryContent{HTMLURL: &zeroValue}
	r.GetHTMLURL()
	r = &RepositoryContent{}
	r.GetHTMLURL()
	r = nil
	r.GetHTMLURL()
}

func TestRepositoryContent_GetName(tt *testing.T) {
	var zeroValue string
	r := &RepositoryContent{Name: &zeroValue}
	r.GetName()
	r = &RepositoryContent{}
	r.GetName()
	r = nil
	r.GetName()
}

func TestRepositoryContent_GetPath(tt *testing.T) {
	var zeroValue string
	r := &RepositoryContent{Path: &zeroValue}
	r.GetPath()
	r = &RepositoryContent{}
	r.GetPath()
	r = nil
	r.GetPath()
}

func TestRepositoryContent_GetSHA(tt *testing.T) {
	var zeroValue string
	r := &RepositoryContent{SHA: &zeroValue}
	r.GetSHA()
	r = &RepositoryContent{}
	r.GetSHA()
	r = nil
	r.GetSHA()
}

func TestRepositoryContent_GetSize(tt *testing.T) {
	var zeroValue int
	r := &RepositoryContent{Size: &zeroValue}
	r.GetSize()
	r = &RepositoryContent{}
	r.GetSize()
	r = nil
	r.GetSize()
}

func TestRepositoryContent_GetTarget(tt *testing.T) {
	var zeroValue string
	r := &RepositoryContent{Target: &zeroValue}
	r.GetTarget()
	r = &RepositoryContent{}
	r.GetTarget()
	r = nil
	r.GetTarget()
}

func TestRepositoryContent_GetType(tt *testing.T) {
	var zeroValue string
	r := &RepositoryContent{Type: &zeroValue}
	r.GetType()
	r = &RepositoryContent{}
	r.GetType()
	r = nil
	r.GetType()
}

func TestRepositoryContent_GetURL(tt *testing.T) {
	var zeroValue string
	r := &RepositoryContent{URL: &zeroValue}
	r.GetURL()
	r = &RepositoryContent{}
	r.GetURL()
	r = nil
	r.GetURL()
}

func TestRepositoryContentFileOptions_GetAuthor(tt *testing.T) {
	r := &RepositoryContentFileOptions{}
	r.GetAuthor()
	r = nil
	r.GetAuthor()
}

func TestRepositoryContentFileOptions_GetBranch(tt *testing.T) {
	var zeroValue string
	r := &RepositoryContentFileOptions{Branch: &zeroValue}
	r.GetBranch()
	r = &RepositoryContentFileOptions{}
	r.GetBranch()
	r = nil
	r.GetBranch()
}

func TestRepositoryContentFileOptions_GetCommitter(tt *testing.T) {
	r := &RepositoryContentFileOptions{}
	r.GetCommitter()
	r = nil
	r.GetCommitter()
}

func TestRepositoryContentFileOptions_GetMessage(tt *testing.T) {
	var zeroValue string
	r := &RepositoryContentFileOptions{Message: &zeroValue}
	r.GetMessage()
	r = &RepositoryContentFileOptions{}
	r.GetMessage()
	r = nil
	r.GetMessage()
}

func TestRepositoryContentFileOptions_GetSHA(tt *testing.T) {
	var zeroValue string
	r := &RepositoryContentFileOptions{SHA: &zeroValue}
	r.GetSHA()
	r = &RepositoryContentFileOptions{}
	r.GetSHA()
	r = nil
	r.GetSHA()
}

func TestRepositoryContentResponse_GetContent(tt *testing.T) {
	r := &RepositoryContentResponse{}
	r.GetContent()
	r = nil
	r.GetContent()
}

func TestRepositoryDispatchEvent_GetAction(tt *testing.T) {
	var zeroValue string
	r := &RepositoryDispatchEvent{Action: &zeroValue}
	r.GetAction()
	r = &RepositoryDispatchEvent{}
	r.GetAction()
	r = nil
	r.GetAction()
}

func TestRepositoryDispatchEvent_GetBranch(tt *testing.T) {
	var zeroValue string
	r := &RepositoryDispatchEvent{Branch: &zeroValue}
	r.GetBranch()
	r = &RepositoryDispatchEvent{}
	r.GetBranch()
	r = nil
	r.GetBranch()
}

func TestRepositoryDispatchEvent_GetInstallation(tt *testing.T) {
	r := &RepositoryDispatchEvent{}
	r.GetInstallation()
	r = nil
	r.GetInstallation()
}

func TestRepositoryDispatchEvent_GetOrg(tt *testing.T) {
	r := &RepositoryDispatchEvent{}
	r.GetOrg()
	r = nil
	r.GetOrg()
}

func TestRepositoryDispatchEvent_GetRepo(tt *testing.T) {
	r := &RepositoryDispatchEvent{}
	r.GetRepo()
	r = nil
	r.GetRepo()
}

func TestRepositoryDispatchEvent_GetSender(tt *testing.T) {
	r := &RepositoryDispatchEvent{}
	r.GetSender()
	r = nil
	r.GetSender()
}

func TestRepositoryEvent_GetAction(tt *testing.T) {
	var zeroValue string
	r := &RepositoryEvent{Action: &zeroValue}
	r.GetAction()
	r = &RepositoryEvent{}
	r.GetAction()
	r = nil
	r.GetAction()
}

func TestRepositoryEvent_GetChanges(tt *testing.T) {
	r := &RepositoryEvent{}
	r.GetChanges()
	r = nil
	r.GetChanges()
}

func TestRepositoryEvent_GetInstallation(tt *testing.T) {
	r := &RepositoryEvent{}
	r.GetInstallation()
	r = nil
	r.GetInstallation()
}

func TestRepositoryEvent_GetOrg(tt *testing.T) {
	r := &RepositoryEvent{}
	r.GetOrg()
	r = nil
	r.GetOrg()
}

func TestRepositoryEvent_GetRepo(tt *testing.T) {
	r := &RepositoryEvent{}
	r.GetRepo()
	r = nil
	r.GetRepo()
}

func TestRepositoryEvent_GetSender(tt *testing.T) {
	r := &RepositoryEvent{}
	r.GetSender()
	r = nil
	r.GetSender()
}

func TestRepositoryImportEvent_GetOrg(tt *testing.T) {
	r := &RepositoryImportEvent{}
	r.GetOrg()
	r = nil
	r.GetOrg()
}

func TestRepositoryImportEvent_GetRepo(tt *testing.T) {
	r := &RepositoryImportEvent{}
	r.GetRepo()
	r = nil
	r.GetRepo()
}

func TestRepositoryImportEvent_GetSender(tt *testing.T) {
	r := &RepositoryImportEvent{}
	r.GetSender()
	r = nil
	r.GetSender()
}

func TestRepositoryImportEvent_GetStatus(tt *testing.T) {
	var zeroValue string
	r := &RepositoryImportEvent{Status: &zeroValue}
	r.GetStatus()
	r = &RepositoryImportEvent{}
	r.GetStatus()
	r = nil
	r.GetStatus()
}

func TestRepositoryInvitation_GetCreatedAt(tt *testing.T) {
	var zeroValue Timestamp
	r := &RepositoryInvitation{CreatedAt: &zeroValue}
	r.GetCreatedAt()
	r = &RepositoryInvitation{}
	r.GetCreatedAt()
	r = nil
	r.GetCreatedAt()
}

func TestRepositoryInvitation_GetHTMLURL(tt *testing.T) {
	var zeroValue string
	r := &RepositoryInvitation{HTMLURL: &zeroValue}
	r.GetHTMLURL()
	r = &RepositoryInvitation{}
	r.GetHTMLURL()
	r = nil
	r.GetHTMLURL()
}

func TestRepositoryInvitation_GetID(tt *testing.T) {
	var zeroValue int64
	r := &RepositoryInvitation{ID: &zeroValue}
	r.GetID()
	r = &RepositoryInvitation{}
	r.GetID()
	r = nil
	r.GetID()
}

func TestRepositoryInvitation_GetInvitee(tt *testing.T) {
	r := &RepositoryInvitation{}
	r.GetInvitee()
	r = nil
	r.GetInvitee()
}

func TestRepositoryInvitation_GetInviter(tt *testing.T) {
	r := &RepositoryInvitation{}
	r.GetInviter()
	r = nil
	r.GetInviter()
}

func TestRepositoryInvitation_GetPermissions(tt *testing.T) {
	var zeroValue string
	r := &RepositoryInvitation{Permissions: &zeroValue}
	r.GetPermissions()
	r = &RepositoryInvitation{}
	r.GetPermissions()
	r = nil
	r.GetPermissions()
}

func TestRepositoryInvitation_GetRepo(tt *testing.T) {
	r := &RepositoryInvitation{}
	r.GetRepo()
	r = nil
	r.GetRepo()
}

func TestRepositoryInvitation_GetURL(tt *testing.T) {
	var zeroValue string
	r := &RepositoryInvitation{URL: &zeroValue}
	r.GetURL()
	r = &RepositoryInvitation{}
	r.GetURL()
	r = nil
	r.GetURL()
}

func TestRepositoryLicense_GetContent(tt *testing.T) {
	var zeroValue string
	r := &RepositoryLicense{Content: &zeroValue}
	r.GetContent()
	r = &RepositoryLicense{}
	r.GetContent()
	r = nil
	r.GetContent()
}

func TestRepositoryLicense_GetDownloadURL(tt *testing.T) {
	var zeroValue string
	r := &RepositoryLicense{DownloadURL: &zeroValue}
	r.GetDownloadURL()
	r = &RepositoryLicense{}
	r.GetDownloadURL()
	r = nil
	r.GetDownloadURL()
}

func TestRepositoryLicense_GetEncoding(tt *testing.T) {
	var zeroValue string
	r := &RepositoryLicense{Encoding: &zeroValue}
	r.GetEncoding()
	r = &RepositoryLicense{}
	r.GetEncoding()
	r = nil
	r.GetEncoding()
}

func TestRepositoryLicense_GetGitURL(tt *testing.T) {
	var zeroValue string
	r := &RepositoryLicense{GitURL: &zeroValue}
	r.GetGitURL()
	r = &RepositoryLicense{}
	r.GetGitURL()
	r = nil
	r.GetGitURL()
}

func TestRepositoryLicense_GetHTMLURL(tt *testing.T) {
	var zeroValue string
	r := &RepositoryLicense{HTMLURL: &zeroValue}
	r.GetHTMLURL()
	r = &RepositoryLicense{}
	r.GetHTMLURL()
	r = nil
	r.GetHTMLURL()
}

func TestRepositoryLicense_GetLicense(tt *testing.T) {
	r := &RepositoryLicense{}
	r.GetLicense()
	r = nil
	r.GetLicense()
}

func TestRepositoryLicense_GetName(tt *testing.T) {
	var zeroValue string
	r := &RepositoryLicense{Name: &zeroValue}
	r.GetName()
	r = &RepositoryLicense{}
	r.GetName()
	r = nil
	r.GetName()
}

func TestRepositoryLicense_GetPath(tt *testing.T) {
	var zeroValue string
	r := &RepositoryLicense{Path: &zeroValue}
	r.GetPath()
	r = &RepositoryLicense{}
	r.GetPath()
	r = nil
	r.GetPath()
}

func TestRepositoryLicense_GetSHA(tt *testing.T) {
	var zeroValue string
	r := &RepositoryLicense{SHA: &zeroValue}
	r.GetSHA()
	r = &RepositoryLicense{}
	r.GetSHA()
	r = nil
	r.GetSHA()
}

func TestRepositoryLicense_GetSize(tt *testing.T) {
	var zeroValue int
	r := &RepositoryLicense{Size: &zeroValue}
	r.GetSize()
	r = &RepositoryLicense{}
	r.GetSize()
	r = nil
	r.GetSize()
}

func TestRepositoryLicense_GetType(tt *testing.T) {
	var zeroValue string
	r := &RepositoryLicense{Type: &zeroValue}
	r.GetType()
	r = &RepositoryLicense{}
	r.GetType()
	r = nil
	r.GetType()
}

func TestRepositoryLicense_GetURL(tt *testing.T) {
	var zeroValue string
	r := &RepositoryLicense{URL: &zeroValue}
	r.GetURL()
	r = &RepositoryLicense{}
	r.GetURL()
	r = nil
	r.GetURL()
}

func TestRepositoryMergeRequest_GetBase(tt *testing.T) {
	var zeroValue string
	r := &RepositoryMergeRequest{Base: &zeroValue}
	r.GetBase()
	r = &RepositoryMergeRequest{}
	r.GetBase()
	r = nil
	r.GetBase()
}

func TestRepositoryMergeRequest_GetCommitMessage(tt *testing.T) {
	var zeroValue string
	r := &RepositoryMergeRequest{CommitMessage: &zeroValue}
	r.GetCommitMessage()
	r = &RepositoryMergeRequest{}
	r.GetCommitMessage()
	r = nil
	r.GetCommitMessage()
}

func TestRepositoryMergeRequest_GetHead(tt *testing.T) {
	var zeroValue string
	r := &RepositoryMergeRequest{Head: &zeroValue}
	r.GetHead()
	r = &RepositoryMergeRequest{}
	r.GetHead()
	r = nil
	r.GetHead()
}

func TestRepositoryPermissionLevel_GetPermission(tt *testing.T) {
	var zeroValue string
	r := &RepositoryPermissionLevel{Permission: &zeroValue}
	r.GetPermission()
	r = &RepositoryPermissionLevel{}
	r.GetPermission()
	r = nil
	r.GetPermission()
}

func TestRepositoryPermissionLevel_GetUser(tt *testing.T) {
	r := &RepositoryPermissionLevel{}
	r.GetUser()
	r = nil
	r.GetUser()
}

func TestRepositoryRelease_GetAssetsURL(tt *testing.T) {
	var zeroValue string
	r := &RepositoryRelease{AssetsURL: &zeroValue}
	r.GetAssetsURL()
	r = &RepositoryRelease{}
	r.GetAssetsURL()
	r = nil
	r.GetAssetsURL()
}

func TestRepositoryRelease_GetAuthor(tt *testing.T) {
	r := &RepositoryRelease{}
	r.GetAuthor()
	r = nil
	r.GetAuthor()
}

func TestRepositoryRelease_GetBody(tt *testing.T) {
	var zeroValue string
	r := &RepositoryRelease{Body: &zeroValue}
	r.GetBody()
	r = &RepositoryRelease{}
	r.GetBody()
	r = nil
	r.GetBody()
}

func TestRepositoryRelease_GetCreatedAt(tt *testing.T) {
	var zeroValue Timestamp
	r := &RepositoryRelease{CreatedAt: &zeroValue}
	r.GetCreatedAt()
	r = &RepositoryRelease{}
	r.GetCreatedAt()
	r = nil
	r.GetCreatedAt()
}

func TestRepositoryRelease_GetDiscussionCategoryName(tt *testing.T) {
	var zeroValue string
	r := &RepositoryRelease{DiscussionCategoryName: &zeroValue}
	r.GetDiscussionCategoryName()
	r = &RepositoryRelease{}
	r.GetDiscussionCategoryName()
	r = nil
	r.GetDiscussionCategoryName()
}

func TestRepositoryRelease_GetDraft(tt *testing.T) {
	var zeroValue bool
	r := &RepositoryRelease{Draft: &zeroValue}
	r.GetDraft()
	r = &RepositoryRelease{}
	r.GetDraft()
	r = nil
	r.GetDraft()
}

func TestRepositoryRelease_GetGenerateReleaseNotes(tt *testing.T) {
	var zeroValue bool
	r := &RepositoryRelease{GenerateReleaseNotes: &zeroValue}
	r.GetGenerateReleaseNotes()
	r = &RepositoryRelease{}
	r.GetGenerateReleaseNotes()
	r = nil
	r.GetGenerateReleaseNotes()
}

func TestRepositoryRelease_GetHTMLURL(tt *testing.T) {
	var zeroValue string
	r := &RepositoryRelease{HTMLURL: &zeroValue}
	r.GetHTMLURL()
	r = &RepositoryRelease{}
	r.GetHTMLURL()
	r = nil
	r.GetHTMLURL()
}

func TestRepositoryRelease_GetID(tt *testing.T) {
	var zeroValue int64
	r := &RepositoryRelease{ID: &zeroValue}
	r.GetID()
	r = &RepositoryRelease{}
	r.GetID()
	r = nil
	r.GetID()
}

func TestRepositoryRelease_GetName(tt *testing.T) {
	var zeroValue string
	r := &RepositoryRelease{Name: &zeroValue}
	r.GetName()
	r = &RepositoryRelease{}
	r.GetName()
	r = nil
	r.GetName()
}

func TestRepositoryRelease_GetNodeID(tt *testing.T) {
	var zeroValue string
	r := &RepositoryRelease{NodeID: &zeroValue}
	r.GetNodeID()
	r = &RepositoryRelease{}
	r.GetNodeID()
	r = nil
	r.GetNodeID()
}

func TestRepositoryRelease_GetPrerelease(tt *testing.T) {
	var zeroValue bool
	r := &RepositoryRelease{Prerelease: &zeroValue}
	r.GetPrerelease()
	r = &RepositoryRelease{}
	r.GetPrerelease()
	r = nil
	r.GetPrerelease()
}

func TestRepositoryRelease_GetPublishedAt(tt *testing.T) {
	var zeroValue Timestamp
	r := &RepositoryRelease{PublishedAt: &zeroValue}
	r.GetPublishedAt()
	r = &RepositoryRelease{}
	r.GetPublishedAt()
	r = nil
	r.GetPublishedAt()
}

func TestRepositoryRelease_GetTagName(tt *testing.T) {
	var zeroValue string
	r := &RepositoryRelease{TagName: &zeroValue}
	r.GetTagName()
	r = &RepositoryRelease{}
	r.GetTagName()
	r = nil
	r.GetTagName()
}

func TestRepositoryRelease_GetTarballURL(tt *testing.T) {
	var zeroValue string
	r := &RepositoryRelease{TarballURL: &zeroValue}
	r.GetTarballURL()
	r = &RepositoryRelease{}
	r.GetTarballURL()
	r = nil
	r.GetTarballURL()
}

func TestRepositoryRelease_GetTargetCommitish(tt *testing.T) {
	var zeroValue string
	r := &RepositoryRelease{TargetCommitish: &zeroValue}
	r.GetTargetCommitish()
	r = &RepositoryRelease{}
	r.GetTargetCommitish()
	r = nil
	r.GetTargetCommitish()
}

func TestRepositoryRelease_GetUploadURL(tt *testing.T) {
	var zeroValue string
	r := &RepositoryRelease{UploadURL: &zeroValue}
	r.GetUploadURL()
	r = &RepositoryRelease{}
	r.GetUploadURL()
	r = nil
	r.GetUploadURL()
}

func TestRepositoryRelease_GetURL(tt *testing.T) {
	var zeroValue string
	r := &RepositoryRelease{URL: &zeroValue}
	r.GetURL()
	r = &RepositoryRelease{}
	r.GetURL()
	r = nil
	r.GetURL()
}

func TestRepositoryRelease_GetZipballURL(tt *testing.T) {
	var zeroValue string
	r := &RepositoryRelease{ZipballURL: &zeroValue}
	r.GetZipballURL()
	r = &RepositoryRelease{}
	r.GetZipballURL()
	r = nil
	r.GetZipballURL()
}

func TestRepositoryTag_GetCommit(tt *testing.T) {
	r := &RepositoryTag{}
	r.GetCommit()
	r = nil
	r.GetCommit()
}

func TestRepositoryTag_GetName(tt *testing.T) {
	var zeroValue string
	r := &RepositoryTag{Name: &zeroValue}
	r.GetName()
	r = &RepositoryTag{}
	r.GetName()
	r = nil
	r.GetName()
}

func TestRepositoryTag_GetTarballURL(tt *testing.T) {
	var zeroValue string
	r := &RepositoryTag{TarballURL: &zeroValue}
	r.GetTarballURL()
	r = &RepositoryTag{}
	r.GetTarballURL()
	r = nil
	r.GetTarballURL()
}

func TestRepositoryTag_GetZipballURL(tt *testing.T) {
	var zeroValue string
	r := &RepositoryTag{ZipballURL: &zeroValue}
	r.GetZipballURL()
	r = &RepositoryTag{}
	r.GetZipballURL()
	r = nil
	r.GetZipballURL()
}

func TestRepositoryVulnerabilityAlert_GetAffectedPackageName(tt *testing.T) {
	var zeroValue string
	r := &RepositoryVulnerabilityAlert{AffectedPackageName: &zeroValue}
	r.GetAffectedPackageName()
	r = &RepositoryVulnerabilityAlert{}
	r.GetAffectedPackageName()
	r = nil
	r.GetAffectedPackageName()
}

func TestRepositoryVulnerabilityAlert_GetAffectedRange(tt *testing.T) {
	var zeroValue string
	r := &RepositoryVulnerabilityAlert{AffectedRange: &zeroValue}
	r.GetAffectedRange()
	r = &RepositoryVulnerabilityAlert{}
	r.GetAffectedRange()
	r = nil
	r.GetAffectedRange()
}

func TestRepositoryVulnerabilityAlert_GetCreatedAt(tt *testing.T) {
	var zeroValue Timestamp
	r := &RepositoryVulnerabilityAlert{CreatedAt: &zeroValue}
	r.GetCreatedAt()
	r = &RepositoryVulnerabilityAlert{}
	r.GetCreatedAt()
	r = nil
	r.GetCreatedAt()
}

func TestRepositoryVulnerabilityAlert_GetDismissedAt(tt *testing.T) {
	var zeroValue Timestamp
	r := &RepositoryVulnerabilityAlert{DismissedAt: &zeroValue}
	r.GetDismissedAt()
	r = &RepositoryVulnerabilityAlert{}
	r.GetDismissedAt()
	r = nil
	r.GetDismissedAt()
}

func TestRepositoryVulnerabilityAlert_GetDismisser(tt *testing.T) {
	r := &RepositoryVulnerabilityAlert{}
	r.GetDismisser()
	r = nil
	r.GetDismisser()
}

func TestRepositoryVulnerabilityAlert_GetDismissReason(tt *testing.T) {
	var zeroValue string
	r := &RepositoryVulnerabilityAlert{DismissReason: &zeroValue}
	r.GetDismissReason()
	r = &RepositoryVulnerabilityAlert{}
	r.GetDismissReason()
	r = nil
	r.GetDismissReason()
}

func TestRepositoryVulnerabilityAlert_GetExternalIdentifier(tt *testing.T) {
	var zeroValue string
	r := &RepositoryVulnerabilityAlert{ExternalIdentifier: &zeroValue}
	r.GetExternalIdentifier()
	r = &RepositoryVulnerabilityAlert{}
	r.GetExternalIdentifier()
	r = nil
	r.GetExternalIdentifier()
}

func TestRepositoryVulnerabilityAlert_GetExternalReference(tt *testing.T) {
	var zeroValue string
	r := &RepositoryVulnerabilityAlert{ExternalReference: &zeroValue}
	r.GetExternalReference()
	r = &RepositoryVulnerabilityAlert{}
	r.GetExternalReference()
	r = nil
	r.GetExternalReference()
}

func TestRepositoryVulnerabilityAlert_GetFixedIn(tt *testing.T) {
	var zeroValue string
	r := &RepositoryVulnerabilityAlert{FixedIn: &zeroValue}
	r.GetFixedIn()
	r = &RepositoryVulnerabilityAlert{}
	r.GetFixedIn()
	r = nil
	r.GetFixedIn()
}

func TestRepositoryVulnerabilityAlert_GetGitHubSecurityAdvisoryID(tt *testing.T) {
	var zeroValue string
	r := &RepositoryVulnerabilityAlert{GitHubSecurityAdvisoryID: &zeroValue}
	r.GetGitHubSecurityAdvisoryID()
	r = &RepositoryVulnerabilityAlert{}
	r.GetGitHubSecurityAdvisoryID()
	r = nil
	r.GetGitHubSecurityAdvisoryID()
}

func TestRepositoryVulnerabilityAlert_GetID(tt *testing.T) {
	var zeroValue int64
	r := &RepositoryVulnerabilityAlert{ID: &zeroValue}
	r.GetID()
	r = &RepositoryVulnerabilityAlert{}
	r.GetID()
	r = nil
	r.GetID()
}

func TestRepositoryVulnerabilityAlert_GetSeverity(tt *testing.T) {
	var zeroValue string
	r := &RepositoryVulnerabilityAlert{Severity: &zeroValue}
	r.GetSeverity()
	r = &RepositoryVulnerabilityAlert{}
	r.GetSeverity()
	r = nil
	r.GetSeverity()
}

func TestRepositoryVulnerabilityAlertEvent_GetAction(tt *testing.T) {
	var zeroValue string
	r := &RepositoryVulnerabilityAlertEvent{Action: &zeroValue}
	r.GetAction()
	r = &RepositoryVulnerabilityAlertEvent{}
	r.GetAction()
	r = nil
	r.GetAction()
}

func TestRepositoryVulnerabilityAlertEvent_GetAlert(tt *testing.T) {
	r := &RepositoryVulnerabilityAlertEvent{}
	r.GetAlert()
	r = nil
	r.GetAlert()
}

func TestRepositoryVulnerabilityAlertEvent_GetInstallation(tt *testing.T) {
	r := &RepositoryVulnerabilityAlertEvent{}
	r.GetInstallation()
	r = nil
	r.GetInstallation()
}

func TestRepositoryVulnerabilityAlertEvent_GetRepository(tt *testing.T) {
	r := &RepositoryVulnerabilityAlertEvent{}
	r.GetRepository()
	r = nil
	r.GetRepository()
}

func TestRepositoryVulnerabilityAlertEvent_GetSender(tt *testing.T) {
	r := &RepositoryVulnerabilityAlertEvent{}
	r.GetSender()
	r = nil
	r.GetSender()
}

func TestRepoStats_GetForkRepos(tt *testing.T) {
	var zeroValue int
	r := &RepoStats{ForkRepos: &zeroValue}
	r.GetForkRepos()
	r = &RepoStats{}
	r.GetForkRepos()
	r = nil
	r.GetForkRepos()
}

func TestRepoStats_GetOrgRepos(tt *testing.T) {
	var zeroValue int
	r := &RepoStats{OrgRepos: &zeroValue}
	r.GetOrgRepos()
	r = &RepoStats{}
	r.GetOrgRepos()
	r = nil
	r.GetOrgRepos()
}

func TestRepoStats_GetRootRepos(tt *testing.T) {
	var zeroValue int
	r := &RepoStats{RootRepos: &zeroValue}
	r.GetRootRepos()
	r = &RepoStats{}
	r.GetRootRepos()
	r = nil
	r.GetRootRepos()
}

func TestRepoStats_GetTotalPushes(tt *testing.T) {
	var zeroValue int
	r := &RepoStats{TotalPushes: &zeroValue}
	r.GetTotalPushes()
	r = &RepoStats{}
	r.GetTotalPushes()
	r = nil
	r.GetTotalPushes()
}

func TestRepoStats_GetTotalRepos(tt *testing.T) {
	var zeroValue int
	r := &RepoStats{TotalRepos: &zeroValue}
	r.GetTotalRepos()
	r = &RepoStats{}
	r.GetTotalRepos()
	r = nil
	r.GetTotalRepos()
}

func TestRepoStats_GetTotalWikis(tt *testing.T) {
	var zeroValue int
	r := &RepoStats{TotalWikis: &zeroValue}
	r.GetTotalWikis()
	r = &RepoStats{}
	r.GetTotalWikis()
	r = nil
	r.GetTotalWikis()
}

func TestRepoStatus_GetAvatarURL(tt *testing.T) {
	var zeroValue string
	r := &RepoStatus{AvatarURL: &zeroValue}
	r.GetAvatarURL()
	r = &RepoStatus{}
	r.GetAvatarURL()
	r = nil
	r.GetAvatarURL()
}

func TestRepoStatus_GetContext(tt *testing.T) {
	var zeroValue string
	r := &RepoStatus{Context: &zeroValue}
	r.GetContext()
	r = &RepoStatus{}
	r.GetContext()
	r = nil
	r.GetContext()
}

func TestRepoStatus_GetCreatedAt(tt *testing.T) {
	var zeroValue time.Time
	r := &RepoStatus{CreatedAt: &zeroValue}
	r.GetCreatedAt()
	r = &RepoStatus{}
	r.GetCreatedAt()
	r = nil
	r.GetCreatedAt()
}

func TestRepoStatus_GetCreator(tt *testing.T) {
	r := &RepoStatus{}
	r.GetCreator()
	r = nil
	r.GetCreator()
}

func TestRepoStatus_GetDescription(tt *testing.T) {
	var zeroValue string
	r := &RepoStatus{Description: &zeroValue}
	r.GetDescription()
	r = &RepoStatus{}
	r.GetDescription()
	r = nil
	r.GetDescription()
}

func TestRepoStatus_GetID(tt *testing.T) {
	var zeroValue int64
	r := &RepoStatus{ID: &zeroValue}
	r.GetID()
	r = &RepoStatus{}
	r.GetID()
	r = nil
	r.GetID()
}

func TestRepoStatus_GetNodeID(tt *testing.T) {
	var zeroValue string
	r := &RepoStatus{NodeID: &zeroValue}
	r.GetNodeID()
	r = &RepoStatus{}
	r.GetNodeID()
	r = nil
	r.GetNodeID()
}

func TestRepoStatus_GetState(tt *testing.T) {
	var zeroValue string
	r := &RepoStatus{State: &zeroValue}
	r.GetState()
	r = &RepoStatus{}
	r.GetState()
	r = nil
	r.GetState()
}

func TestRepoStatus_GetTargetURL(tt *testing.T) {
	var zeroValue string
	r := &RepoStatus{TargetURL: &zeroValue}
	r.GetTargetURL()
	r = &RepoStatus{}
	r.GetTargetURL()
	r = nil
	r.GetTargetURL()
}

func TestRepoStatus_GetUpdatedAt(tt *testing.T) {
	var zeroValue time.Time
	r := &RepoStatus{UpdatedAt: &zeroValue}
	r.GetUpdatedAt()
	r = &RepoStatus{}
	r.GetUpdatedAt()
	r = nil
	r.GetUpdatedAt()
}

func TestRepoStatus_GetURL(tt *testing.T) {
	var zeroValue string
	r := &RepoStatus{URL: &zeroValue}
	r.GetURL()
	r = &RepoStatus{}
	r.GetURL()
	r = nil
	r.GetURL()
}

func TestRequiredReviewer_GetType(tt *testing.T) {
	var zeroValue string
	r := &RequiredReviewer{Type: &zeroValue}
	r.GetType()
	r = &RequiredReviewer{}
	r.GetType()
	r = nil
	r.GetType()
}

func TestRequiredStatusCheck_GetAppID(tt *testing.T) {
	var zeroValue int64
	r := &RequiredStatusCheck{AppID: &zeroValue}
	r.GetAppID()
	r = &RequiredStatusCheck{}
	r.GetAppID()
	r = nil
	r.GetAppID()
}

func TestRequiredStatusChecksRequest_GetStrict(tt *testing.T) {
	var zeroValue bool
	r := &RequiredStatusChecksRequest{Strict: &zeroValue}
	r.GetStrict()
	r = &RequiredStatusChecksRequest{}
	r.GetStrict()
	r = nil
	r.GetStrict()
}

func TestReviewersRequest_GetNodeID(tt *testing.T) {
	var zeroValue string
	r := &ReviewersRequest{NodeID: &zeroValue}
	r.GetNodeID()
	r = &ReviewersRequest{}
	r.GetNodeID()
	r = nil
	r.GetNodeID()
}

func TestRule_GetDescription(tt *testing.T) {
	var zeroValue string
	r := &Rule{Description: &zeroValue}
	r.GetDescription()
	r = &Rule{}
	r.GetDescription()
	r = nil
	r.GetDescription()
}

func TestRule_GetFullDescription(tt *testing.T) {
	var zeroValue string
	r := &Rule{FullDescription: &zeroValue}
	r.GetFullDescription()
	r = &Rule{}
	r.GetFullDescription()
	r = nil
	r.GetFullDescription()
}

func TestRule_GetHelp(tt *testing.T) {
	var zeroValue string
	r := &Rule{Help: &zeroValue}
	r.GetHelp()
	r = &Rule{}
	r.GetHelp()
	r = nil
	r.GetHelp()
}

func TestRule_GetID(tt *testing.T) {
	var zeroValue string
	r := &Rule{ID: &zeroValue}
	r.GetID()
	r = &Rule{}
	r.GetID()
	r = nil
	r.GetID()
}

func TestRule_GetName(tt *testing.T) {
	var zeroValue string
	r := &Rule{Name: &zeroValue}
	r.GetName()
	r = &Rule{}
	r.GetName()
	r = nil
	r.GetName()
}

func TestRule_GetSecuritySeverityLevel(tt *testing.T) {
	var zeroValue string
	r := &Rule{SecuritySeverityLevel: &zeroValue}
	r.GetSecuritySeverityLevel()
	r = &Rule{}
	r.GetSecuritySeverityLevel()
	r = nil
	r.GetSecuritySeverityLevel()
}

func TestRule_GetSeverity(tt *testing.T) {
	var zeroValue string
	r := &Rule{Severity: &zeroValue}
	r.GetSeverity()
	r = &Rule{}
	r.GetSeverity()
	r = nil
	r.GetSeverity()
}

func TestRunner_GetBusy(tt *testing.T) {
	var zeroValue bool
	r := &Runner{Busy: &zeroValue}
	r.GetBusy()
	r = &Runner{}
	r.GetBusy()
	r = nil
	r.GetBusy()
}

func TestRunner_GetID(tt *testing.T) {
	var zeroValue int64
	r := &Runner{ID: &zeroValue}
	r.GetID()
	r = &Runner{}
	r.GetID()
	r = nil
	r.GetID()
}

func TestRunner_GetName(tt *testing.T) {
	var zeroValue string
	r := &Runner{Name: &zeroValue}
	r.GetName()
	r = &Runner{}
	r.GetName()
	r = nil
	r.GetName()
}

func TestRunner_GetOS(tt *testing.T) {
	var zeroValue string
	r := &Runner{OS: &zeroValue}
	r.GetOS()
	r = &Runner{}
	r.GetOS()
	r = nil
	r.GetOS()
}

func TestRunner_GetStatus(tt *testing.T) {
	var zeroValue string
	r := &Runner{Status: &zeroValue}
	r.GetStatus()
	r = &Runner{}
	r.GetStatus()
	r = nil
	r.GetStatus()
}

func TestRunnerApplicationDownload_GetArchitecture(tt *testing.T) {
	var zeroValue string
	r := &RunnerApplicationDownload{Architecture: &zeroValue}
	r.GetArchitecture()
	r = &RunnerApplicationDownload{}
	r.GetArchitecture()
	r = nil
	r.GetArchitecture()
}

func TestRunnerApplicationDownload_GetDownloadURL(tt *testing.T) {
	var zeroValue string
	r := &RunnerApplicationDownload{DownloadURL: &zeroValue}
	r.GetDownloadURL()
	r = &RunnerApplicationDownload{}
	r.GetDownloadURL()
	r = nil
	r.GetDownloadURL()
}

func TestRunnerApplicationDownload_GetFilename(tt *testing.T) {
	var zeroValue string
	r := &RunnerApplicationDownload{Filename: &zeroValue}
	r.GetFilename()
	r = &RunnerApplicationDownload{}
	r.GetFilename()
	r = nil
	r.GetFilename()
}

func TestRunnerApplicationDownload_GetOS(tt *testing.T) {
	var zeroValue string
	r := &RunnerApplicationDownload{OS: &zeroValue}
	r.GetOS()
	r = &RunnerApplicationDownload{}
	r.GetOS()
	r = nil
	r.GetOS()
}

func TestRunnerApplicationDownload_GetSHA256Checksum(tt *testing.T) {
	var zeroValue string
	r := &RunnerApplicationDownload{SHA256Checksum: &zeroValue}
	r.GetSHA256Checksum()
	r = &RunnerApplicationDownload{}
	r.GetSHA256Checksum()
	r = nil
	r.GetSHA256Checksum()
}

func TestRunnerApplicationDownload_GetTempDownloadToken(tt *testing.T) {
	var zeroValue string
	r := &RunnerApplicationDownload{TempDownloadToken: &zeroValue}
	r.GetTempDownloadToken()
	r = &RunnerApplicationDownload{}
	r.GetTempDownloadToken()
	r = nil
	r.GetTempDownloadToken()
}

func TestRunnerGroup_GetAllowsPublicRepositories(tt *testing.T) {
	var zeroValue bool
	r := &RunnerGroup{AllowsPublicRepositories: &zeroValue}
	r.GetAllowsPublicRepositories()
	r = &RunnerGroup{}
	r.GetAllowsPublicRepositories()
	r = nil
	r.GetAllowsPublicRepositories()
}

func TestRunnerGroup_GetDefault(tt *testing.T) {
	var zeroValue bool
	r := &RunnerGroup{Default: &zeroValue}
	r.GetDefault()
	r = &RunnerGroup{}
	r.GetDefault()
	r = nil
	r.GetDefault()
}

func TestRunnerGroup_GetID(tt *testing.T) {
	var zeroValue int64
	r := &RunnerGroup{ID: &zeroValue}
	r.GetID()
	r = &RunnerGroup{}
	r.GetID()
	r = nil
	r.GetID()
}

func TestRunnerGroup_GetInherited(tt *testing.T) {
	var zeroValue bool
	r := &RunnerGroup{Inherited: &zeroValue}
	r.GetInherited()
	r = &RunnerGroup{}
	r.GetInherited()
	r = nil
	r.GetInherited()
}

func TestRunnerGroup_GetName(tt *testing.T) {
	var zeroValue string
	r := &RunnerGroup{Name: &zeroValue}
	r.GetName()
	r = &RunnerGroup{}
	r.GetName()
	r = nil
	r.GetName()
}

func TestRunnerGroup_GetRunnersURL(tt *testing.T) {
	var zeroValue string
	r := &RunnerGroup{RunnersURL: &zeroValue}
	r.GetRunnersURL()
	r = &RunnerGroup{}
	r.GetRunnersURL()
	r = nil
	r.GetRunnersURL()
}

func TestRunnerGroup_GetSelectedRepositoriesURL(tt *testing.T) {
	var zeroValue string
	r := &RunnerGroup{SelectedRepositoriesURL: &zeroValue}
	r.GetSelectedRepositoriesURL()
	r = &RunnerGroup{}
	r.GetSelectedRepositoriesURL()
	r = nil
	r.GetSelectedRepositoriesURL()
}

func TestRunnerGroup_GetVisibility(tt *testing.T) {
	var zeroValue string
	r := &RunnerGroup{Visibility: &zeroValue}
	r.GetVisibility()
	r = &RunnerGroup{}
	r.GetVisibility()
	r = nil
	r.GetVisibility()
}

func TestRunnerLabels_GetID(tt *testing.T) {
	var zeroValue int64
	r := &RunnerLabels{ID: &zeroValue}
	r.GetID()
	r = &RunnerLabels{}
	r.GetID()
	r = nil
	r.GetID()
}

func TestRunnerLabels_GetName(tt *testing.T) {
	var zeroValue string
	r := &RunnerLabels{Name: &zeroValue}
	r.GetName()
	r = &RunnerLabels{}
	r.GetName()
	r = nil
	r.GetName()
}

func TestRunnerLabels_GetType(tt *testing.T) {
	var zeroValue string
	r := &RunnerLabels{Type: &zeroValue}
	r.GetType()
	r = &RunnerLabels{}
	r.GetType()
	r = nil
	r.GetType()
}

func TestSarifAnalysis_GetCheckoutURI(tt *testing.T) {
	var zeroValue string
	s := &SarifAnalysis{CheckoutURI: &zeroValue}
	s.GetCheckoutURI()
	s = &SarifAnalysis{}
	s.GetCheckoutURI()
	s = nil
	s.GetCheckoutURI()
}

func TestSarifAnalysis_GetCommitSHA(tt *testing.T) {
	var zeroValue string
	s := &SarifAnalysis{CommitSHA: &zeroValue}
	s.GetCommitSHA()
	s = &SarifAnalysis{}
	s.GetCommitSHA()
	s = nil
	s.GetCommitSHA()
}

func TestSarifAnalysis_GetRef(tt *testing.T) {
	var zeroValue string
	s := &SarifAnalysis{Ref: &zeroValue}
	s.GetRef()
	s = &SarifAnalysis{}
	s.GetRef()
	s = nil
	s.GetRef()
}

func TestSarifAnalysis_GetSarif(tt *testing.T) {
	var zeroValue string
	s := &SarifAnalysis{Sarif: &zeroValue}
	s.GetSarif()
	s = &SarifAnalysis{}
	s.GetSarif()
	s = nil
	s.GetSarif()
}

func TestSarifAnalysis_GetStartedAt(tt *testing.T) {
	var zeroValue Timestamp
	s := &SarifAnalysis{StartedAt: &zeroValue}
	s.GetStartedAt()
	s = &SarifAnalysis{}
	s.GetStartedAt()
	s = nil
	s.GetStartedAt()
}

func TestSarifAnalysis_GetToolName(tt *testing.T) {
	var zeroValue string
	s := &SarifAnalysis{ToolName: &zeroValue}
	s.GetToolName()
	s = &SarifAnalysis{}
	s.GetToolName()
	s = nil
	s.GetToolName()
}

func TestSarifID_GetID(tt *testing.T) {
	var zeroValue string
	s := &SarifID{ID: &zeroValue}
	s.GetID()
	s = &SarifID{}
	s.GetID()
	s = nil
	s.GetID()
}

func TestSarifID_GetURL(tt *testing.T) {
	var zeroValue string
	s := &SarifID{URL: &zeroValue}
	s.GetURL()
	s = &SarifID{}
	s.GetURL()
	s = nil
	s.GetURL()
}

func TestScanningAnalysis_GetAnalysisKey(tt *testing.T) {
	var zeroValue string
	s := &ScanningAnalysis{AnalysisKey: &zeroValue}
	s.GetAnalysisKey()
	s = &ScanningAnalysis{}
	s.GetAnalysisKey()
	s = nil
	s.GetAnalysisKey()
}

func TestScanningAnalysis_GetCategory(tt *testing.T) {
	var zeroValue string
	s := &ScanningAnalysis{Category: &zeroValue}
	s.GetCategory()
	s = &ScanningAnalysis{}
	s.GetCategory()
	s = nil
	s.GetCategory()
}

func TestScanningAnalysis_GetCommitSHA(tt *testing.T) {
	var zeroValue string
	s := &ScanningAnalysis{CommitSHA: &zeroValue}
	s.GetCommitSHA()
	s = &ScanningAnalysis{}
	s.GetCommitSHA()
	s = nil
	s.GetCommitSHA()
}

func TestScanningAnalysis_GetCreatedAt(tt *testing.T) {
	var zeroValue Timestamp
	s := &ScanningAnalysis{CreatedAt: &zeroValue}
	s.GetCreatedAt()
	s = &ScanningAnalysis{}
	s.GetCreatedAt()
	s = nil
	s.GetCreatedAt()
}

func TestScanningAnalysis_GetDeletable(tt *testing.T) {
	var zeroValue bool
	s := &ScanningAnalysis{Deletable: &zeroValue}
	s.GetDeletable()
	s = &ScanningAnalysis{}
	s.GetDeletable()
	s = nil
	s.GetDeletable()
}

func TestScanningAnalysis_GetEnvironment(tt *testing.T) {
	var zeroValue string
	s := &ScanningAnalysis{Environment: &zeroValue}
	s.GetEnvironment()
	s = &ScanningAnalysis{}
	s.GetEnvironment()
	s = nil
	s.GetEnvironment()
}

func TestScanningAnalysis_GetError(tt *testing.T) {
	var zeroValue string
	s := &ScanningAnalysis{Error: &zeroValue}
	s.GetError()
	s = &ScanningAnalysis{}
	s.GetError()
	s = nil
	s.GetError()
}

func TestScanningAnalysis_GetID(tt *testing.T) {
	var zeroValue int64
	s := &ScanningAnalysis{ID: &zeroValue}
	s.GetID()
	s = &ScanningAnalysis{}
	s.GetID()
	s = nil
	s.GetID()
}

func TestScanningAnalysis_GetRef(tt *testing.T) {
	var zeroValue string
	s := &ScanningAnalysis{Ref: &zeroValue}
	s.GetRef()
	s = &ScanningAnalysis{}
	s.GetRef()
	s = nil
	s.GetRef()
}

func TestScanningAnalysis_GetResultsCount(tt *testing.T) {
	var zeroValue int
	s := &ScanningAnalysis{ResultsCount: &zeroValue}
	s.GetResultsCount()
	s = &ScanningAnalysis{}
	s.GetResultsCount()
	s = nil
	s.GetResultsCount()
}

func TestScanningAnalysis_GetRulesCount(tt *testing.T) {
	var zeroValue int
	s := &ScanningAnalysis{RulesCount: &zeroValue}
	s.GetRulesCount()
	s = &ScanningAnalysis{}
	s.GetRulesCount()
	s = nil
	s.GetRulesCount()
}

func TestScanningAnalysis_GetSarifID(tt *testing.T) {
	var zeroValue string
	s := &ScanningAnalysis{SarifID: &zeroValue}
	s.GetSarifID()
	s = &ScanningAnalysis{}
	s.GetSarifID()
	s = nil
	s.GetSarifID()
}

func TestScanningAnalysis_GetTool(tt *testing.T) {
	s := &ScanningAnalysis{}
	s.GetTool()
	s = nil
	s.GetTool()
}

func TestScanningAnalysis_GetURL(tt *testing.T) {
	var zeroValue string
	s := &ScanningAnalysis{URL: &zeroValue}
	s.GetURL()
	s = &ScanningAnalysis{}
	s.GetURL()
	s = nil
	s.GetURL()
}

func TestScanningAnalysis_GetWarning(tt *testing.T) {
	var zeroValue string
	s := &ScanningAnalysis{Warning: &zeroValue}
	s.GetWarning()
	s = &ScanningAnalysis{}
	s.GetWarning()
	s = nil
	s.GetWarning()
}

func TestSCIMUserAttributes_GetActive(tt *testing.T) {
	var zeroValue bool
	s := &SCIMUserAttributes{Active: &zeroValue}
	s.GetActive()
	s = &SCIMUserAttributes{}
	s.GetActive()
	s = nil
	s.GetActive()
}

func TestSCIMUserAttributes_GetDisplayName(tt *testing.T) {
	var zeroValue string
	s := &SCIMUserAttributes{DisplayName: &zeroValue}
	s.GetDisplayName()
	s = &SCIMUserAttributes{}
	s.GetDisplayName()
	s = nil
	s.GetDisplayName()
}

func TestSCIMUserAttributes_GetExternalID(tt *testing.T) {
	var zeroValue string
	s := &SCIMUserAttributes{ExternalID: &zeroValue}
	s.GetExternalID()
	s = &SCIMUserAttributes{}
	s.GetExternalID()
	s = nil
	s.GetExternalID()
}

func TestSCIMUserEmail_GetPrimary(tt *testing.T) {
	var zeroValue bool
	s := &SCIMUserEmail{Primary: &zeroValue}
	s.GetPrimary()
	s = &SCIMUserEmail{}
	s.GetPrimary()
	s = nil
	s.GetPrimary()
}

func TestSCIMUserEmail_GetType(tt *testing.T) {
	var zeroValue string
	s := &SCIMUserEmail{Type: &zeroValue}
	s.GetType()
	s = &SCIMUserEmail{}
	s.GetType()
	s = nil
	s.GetType()
}

func TestSCIMUserName_GetFormatted(tt *testing.T) {
	var zeroValue string
	s := &SCIMUserName{Formatted: &zeroValue}
	s.GetFormatted()
	s = &SCIMUserName{}
	s.GetFormatted()
	s = nil
	s.GetFormatted()
}

func TestSecretScanning_GetStatus(tt *testing.T) {
	var zeroValue string
	s := &SecretScanning{Status: &zeroValue}
	s.GetStatus()
	s = &SecretScanning{}
	s.GetStatus()
	s = nil
	s.GetStatus()
}

func TestSecretScanningAlert_GetCreatedAt(tt *testing.T) {
	var zeroValue Timestamp
	s := &SecretScanningAlert{CreatedAt: &zeroValue}
	s.GetCreatedAt()
	s = &SecretScanningAlert{}
	s.GetCreatedAt()
	s = nil
	s.GetCreatedAt()
}

func TestSecretScanningAlert_GetHTMLURL(tt *testing.T) {
	var zeroValue string
	s := &SecretScanningAlert{HTMLURL: &zeroValue}
	s.GetHTMLURL()
	s = &SecretScanningAlert{}
	s.GetHTMLURL()
	s = nil
	s.GetHTMLURL()
}

func TestSecretScanningAlert_GetLocationsURL(tt *testing.T) {
	var zeroValue string
	s := &SecretScanningAlert{LocationsURL: &zeroValue}
	s.GetLocationsURL()
	s = &SecretScanningAlert{}
	s.GetLocationsURL()
	s = nil
	s.GetLocationsURL()
}

func TestSecretScanningAlert_GetNumber(tt *testing.T) {
	var zeroValue int
	s := &SecretScanningAlert{Number: &zeroValue}
	s.GetNumber()
	s = &SecretScanningAlert{}
	s.GetNumber()
	s = nil
	s.GetNumber()
}

func TestSecretScanningAlert_GetResolution(tt *testing.T) {
	var zeroValue string
	s := &SecretScanningAlert{Resolution: &zeroValue}
	s.GetResolution()
	s = &SecretScanningAlert{}
	s.GetResolution()
	s = nil
	s.GetResolution()
}

func TestSecretScanningAlert_GetResolvedAt(tt *testing.T) {
	var zeroValue Timestamp
	s := &SecretScanningAlert{ResolvedAt: &zeroValue}
	s.GetResolvedAt()
	s = &SecretScanningAlert{}
	s.GetResolvedAt()
	s = nil
	s.GetResolvedAt()
}

func TestSecretScanningAlert_GetResolvedBy(tt *testing.T) {
	s := &SecretScanningAlert{}
	s.GetResolvedBy()
	s = nil
	s.GetResolvedBy()
}

func TestSecretScanningAlert_GetSecret(tt *testing.T) {
	var zeroValue string
	s := &SecretScanningAlert{Secret: &zeroValue}
	s.GetSecret()
	s = &SecretScanningAlert{}
	s.GetSecret()
	s = nil
	s.GetSecret()
}

func TestSecretScanningAlert_GetSecretType(tt *testing.T) {
	var zeroValue string
	s := &SecretScanningAlert{SecretType: &zeroValue}
	s.GetSecretType()
	s = &SecretScanningAlert{}
	s.GetSecretType()
	s = nil
	s.GetSecretType()
}

func TestSecretScanningAlert_GetState(tt *testing.T) {
	var zeroValue string
	s := &SecretScanningAlert{State: &zeroValue}
	s.GetState()
	s = &SecretScanningAlert{}
	s.GetState()
	s = nil
	s.GetState()
}

func TestSecretScanningAlert_GetURL(tt *testing.T) {
	var zeroValue string
	s := &SecretScanningAlert{URL: &zeroValue}
	s.GetURL()
	s = &SecretScanningAlert{}
	s.GetURL()
	s = nil
	s.GetURL()
}

func TestSecretScanningAlertEvent_GetAction(tt *testing.T) {
	var zeroValue string
	s := &SecretScanningAlertEvent{Action: &zeroValue}
	s.GetAction()
	s = &SecretScanningAlertEvent{}
	s.GetAction()
	s = nil
	s.GetAction()
}

func TestSecretScanningAlertEvent_GetAlert(tt *testing.T) {
	s := &SecretScanningAlertEvent{}
	s.GetAlert()
	s = nil
	s.GetAlert()
}

func TestSecretScanningAlertEvent_GetEnterprise(tt *testing.T) {
	s := &SecretScanningAlertEvent{}
	s.GetEnterprise()
	s = nil
	s.GetEnterprise()
}

func TestSecretScanningAlertEvent_GetInstallation(tt *testing.T) {
	s := &SecretScanningAlertEvent{}
	s.GetInstallation()
	s = nil
	s.GetInstallation()
}

func TestSecretScanningAlertEvent_GetOrganization(tt *testing.T) {
	s := &SecretScanningAlertEvent{}
	s.GetOrganization()
	s = nil
	s.GetOrganization()
}

func TestSecretScanningAlertEvent_GetRepo(tt *testing.T) {
	s := &SecretScanningAlertEvent{}
	s.GetRepo()
	s = nil
	s.GetRepo()
}

func TestSecretScanningAlertEvent_GetSender(tt *testing.T) {
	s := &SecretScanningAlertEvent{}
	s.GetSender()
	s = nil
	s.GetSender()
}

func TestSecretScanningAlertLocation_GetDetails(tt *testing.T) {
	s := &SecretScanningAlertLocation{}
	s.GetDetails()
	s = nil
	s.GetDetails()
}

func TestSecretScanningAlertLocation_GetType(tt *testing.T) {
	var zeroValue string
	s := &SecretScanningAlertLocation{Type: &zeroValue}
	s.GetType()
	s = &SecretScanningAlertLocation{}
	s.GetType()
	s = nil
	s.GetType()
}

func TestSecretScanningAlertLocationDetails_GetBlobSHA(tt *testing.T) {
	var zeroValue string
	s := &SecretScanningAlertLocationDetails{BlobSHA: &zeroValue}
	s.GetBlobSHA()
	s = &SecretScanningAlertLocationDetails{}
	s.GetBlobSHA()
	s = nil
	s.GetBlobSHA()
}

func TestSecretScanningAlertLocationDetails_GetBlobURL(tt *testing.T) {
	var zeroValue string
	s := &SecretScanningAlertLocationDetails{BlobURL: &zeroValue}
	s.GetBlobURL()
	s = &SecretScanningAlertLocationDetails{}
	s.GetBlobURL()
	s = nil
	s.GetBlobURL()
}

func TestSecretScanningAlertLocationDetails_GetCommitSHA(tt *testing.T) {
	var zeroValue string
	s := &SecretScanningAlertLocationDetails{CommitSHA: &zeroValue}
	s.GetCommitSHA()
	s = &SecretScanningAlertLocationDetails{}
	s.GetCommitSHA()
	s = nil
	s.GetCommitSHA()
}

func TestSecretScanningAlertLocationDetails_GetCommitURL(tt *testing.T) {
	var zeroValue string
	s := &SecretScanningAlertLocationDetails{CommitURL: &zeroValue}
	s.GetCommitURL()
	s = &SecretScanningAlertLocationDetails{}
	s.GetCommitURL()
	s = nil
	s.GetCommitURL()
}

func TestSecretScanningAlertLocationDetails_GetEndColumn(tt *testing.T) {
	var zeroValue int
	s := &SecretScanningAlertLocationDetails{EndColumn: &zeroValue}
	s.GetEndColumn()
	s = &SecretScanningAlertLocationDetails{}
	s.GetEndColumn()
	s = nil
	s.GetEndColumn()
}

func TestSecretScanningAlertLocationDetails_GetEndLine(tt *testing.T) {
	var zeroValue int
	s := &SecretScanningAlertLocationDetails{EndLine: &zeroValue}
	s.GetEndLine()
	s = &SecretScanningAlertLocationDetails{}
	s.GetEndLine()
	s = nil
	s.GetEndLine()
}

func TestSecretScanningAlertLocationDetails_GetPath(tt *testing.T) {
	var zeroValue string
	s := &SecretScanningAlertLocationDetails{Path: &zeroValue}
	s.GetPath()
	s = &SecretScanningAlertLocationDetails{}
	s.GetPath()
	s = nil
	s.GetPath()
}

func TestSecretScanningAlertLocationDetails_GetStartColumn(tt *testing.T) {
	var zeroValue int
	s := &SecretScanningAlertLocationDetails{StartColumn: &zeroValue}
	s.GetStartColumn()
	s = &SecretScanningAlertLocationDetails{}
	s.GetStartColumn()
	s = nil
	s.GetStartColumn()
}

func TestSecretScanningAlertLocationDetails_GetStartline(tt *testing.T) {
	var zeroValue int
	s := &SecretScanningAlertLocationDetails{Startline: &zeroValue}
	s.GetStartline()
	s = &SecretScanningAlertLocationDetails{}
	s.GetStartline()
	s = nil
	s.GetStartline()
}

func TestSecretScanningAlertUpdateOptions_GetResolution(tt *testing.T) {
	var zeroValue string
	s := &SecretScanningAlertUpdateOptions{Resolution: &zeroValue}
	s.GetResolution()
	s = &SecretScanningAlertUpdateOptions{}
	s.GetResolution()
	s = nil
	s.GetResolution()
}

func TestSecretScanningAlertUpdateOptions_GetSecretType(tt *testing.T) {
	var zeroValue string
	s := &SecretScanningAlertUpdateOptions{SecretType: &zeroValue}
	s.GetSecretType()
	s = &SecretScanningAlertUpdateOptions{}
	s.GetSecretType()
	s = nil
	s.GetSecretType()
}

func TestSecretScanningAlertUpdateOptions_GetState(tt *testing.T) {
	var zeroValue string
	s := &SecretScanningAlertUpdateOptions{State: &zeroValue}
	s.GetState()
	s = &SecretScanningAlertUpdateOptions{}
	s.GetState()
	s = nil
	s.GetState()
}

func TestSecurityAdvisory_GetDescription(tt *testing.T) {
	var zeroValue string
	s := &SecurityAdvisory{Description: &zeroValue}
	s.GetDescription()
	s = &SecurityAdvisory{}
	s.GetDescription()
	s = nil
	s.GetDescription()
}

func TestSecurityAdvisory_GetGHSAID(tt *testing.T) {
	var zeroValue string
	s := &SecurityAdvisory{GHSAID: &zeroValue}
	s.GetGHSAID()
	s = &SecurityAdvisory{}
	s.GetGHSAID()
	s = nil
	s.GetGHSAID()
}

func TestSecurityAdvisory_GetPublishedAt(tt *testing.T) {
	var zeroValue Timestamp
	s := &SecurityAdvisory{PublishedAt: &zeroValue}
	s.GetPublishedAt()
	s = &SecurityAdvisory{}
	s.GetPublishedAt()
	s = nil
	s.GetPublishedAt()
}

func TestSecurityAdvisory_GetSeverity(tt *testing.T) {
	var zeroValue string
	s := &SecurityAdvisory{Severity: &zeroValue}
	s.GetSeverity()
	s = &SecurityAdvisory{}
	s.GetSeverity()
	s = nil
	s.GetSeverity()
}

func TestSecurityAdvisory_GetSummary(tt *testing.T) {
	var zeroValue string
	s := &SecurityAdvisory{Summary: &zeroValue}
	s.GetSummary()
	s = &SecurityAdvisory{}
	s.GetSummary()
	s = nil
	s.GetSummary()
}

func TestSecurityAdvisory_GetUpdatedAt(tt *testing.T) {
	var zeroValue Timestamp
	s := &SecurityAdvisory{UpdatedAt: &zeroValue}
	s.GetUpdatedAt()
	s = &SecurityAdvisory{}
	s.GetUpdatedAt()
	s = nil
	s.GetUpdatedAt()
}

func TestSecurityAdvisory_GetWithdrawnAt(tt *testing.T) {
	var zeroValue Timestamp
	s := &SecurityAdvisory{WithdrawnAt: &zeroValue}
	s.GetWithdrawnAt()
	s = &SecurityAdvisory{}
	s.GetWithdrawnAt()
	s = nil
	s.GetWithdrawnAt()
}

func TestSecurityAdvisoryEvent_GetAction(tt *testing.T) {
	var zeroValue string
	s := &SecurityAdvisoryEvent{Action: &zeroValue}
	s.GetAction()
	s = &SecurityAdvisoryEvent{}
	s.GetAction()
	s = nil
	s.GetAction()
}

func TestSecurityAdvisoryEvent_GetSecurityAdvisory(tt *testing.T) {
	s := &SecurityAdvisoryEvent{}
	s.GetSecurityAdvisory()
	s = nil
	s.GetSecurityAdvisory()
}

func TestSecurityAndAnalysis_GetAdvancedSecurity(tt *testing.T) {
	s := &SecurityAndAnalysis{}
	s.GetAdvancedSecurity()
	s = nil
	s.GetAdvancedSecurity()
}

func TestSecurityAndAnalysis_GetSecretScanning(tt *testing.T) {
	s := &SecurityAndAnalysis{}
	s.GetSecretScanning()
	s = nil
	s.GetSecretScanning()
}

func TestSelectedReposList_GetTotalCount(tt *testing.T) {
	var zeroValue int
	s := &SelectedReposList{TotalCount: &zeroValue}
	s.GetTotalCount()
	s = &SelectedReposList{}
	s.GetTotalCount()
	s = nil
	s.GetTotalCount()
}

func TestServiceHook_GetName(tt *testing.T) {
	var zeroValue string
	s := &ServiceHook{Name: &zeroValue}
	s.GetName()
	s = &ServiceHook{}
	s.GetName()
	s = nil
	s.GetName()
}

func TestSignaturesProtectedBranch_GetEnabled(tt *testing.T) {
	var zeroValue bool
	s := &SignaturesProtectedBranch{Enabled: &zeroValue}
	s.GetEnabled()
	s = &SignaturesProtectedBranch{}
	s.GetEnabled()
	s = nil
	s.GetEnabled()
}

func TestSignaturesProtectedBranch_GetURL(tt *testing.T) {
	var zeroValue string
	s := &SignaturesProtectedBranch{URL: &zeroValue}
	s.GetURL()
	s = &SignaturesProtectedBranch{}
	s.GetURL()
	s = nil
	s.GetURL()
}

func TestSignatureVerification_GetPayload(tt *testing.T) {
	var zeroValue string
	s := &SignatureVerification{Payload: &zeroValue}
	s.GetPayload()
	s = &SignatureVerification{}
	s.GetPayload()
	s = nil
	s.GetPayload()
}

func TestSignatureVerification_GetReason(tt *testing.T) {
	var zeroValue string
	s := &SignatureVerification{Reason: &zeroValue}
	s.GetReason()
	s = &SignatureVerification{}
	s.GetReason()
	s = nil
	s.GetReason()
}

func TestSignatureVerification_GetSignature(tt *testing.T) {
	var zeroValue string
	s := &SignatureVerification{Signature: &zeroValue}
	s.GetSignature()
	s = &SignatureVerification{}
	s.GetSignature()
	s = nil
	s.GetSignature()
}

func TestSignatureVerification_GetVerified(tt *testing.T) {
	var zeroValue bool
	s := &SignatureVerification{Verified: &zeroValue}
	s.GetVerified()
	s = &SignatureVerification{}
	s.GetVerified()
	s = nil
	s.GetVerified()
}

func TestSource_GetActor(tt *testing.T) {
	s := &Source{}
	s.GetActor()
	s = nil
	s.GetActor()
}

func TestSource_GetID(tt *testing.T) {
	var zeroValue int64
	s := &Source{ID: &zeroValue}
	s.GetID()
	s = &Source{}
	s.GetID()
	s = nil
	s.GetID()
}

func TestSource_GetIssue(tt *testing.T) {
	s := &Source{}
	s.GetIssue()
	s = nil
	s.GetIssue()
}

func TestSource_GetType(tt *testing.T) {
	var zeroValue string
	s := &Source{Type: &zeroValue}
	s.GetType()
	s = &Source{}
	s.GetType()
	s = nil
	s.GetType()
}

func TestSource_GetURL(tt *testing.T) {
	var zeroValue string
	s := &Source{URL: &zeroValue}
	s.GetURL()
	s = &Source{}
	s.GetURL()
	s = nil
	s.GetURL()
}

func TestSourceImportAuthor_GetEmail(tt *testing.T) {
	var zeroValue string
	s := &SourceImportAuthor{Email: &zeroValue}
	s.GetEmail()
	s = &SourceImportAuthor{}
	s.GetEmail()
	s = nil
	s.GetEmail()
}

func TestSourceImportAuthor_GetID(tt *testing.T) {
	var zeroValue int64
	s := &SourceImportAuthor{ID: &zeroValue}
	s.GetID()
	s = &SourceImportAuthor{}
	s.GetID()
	s = nil
	s.GetID()
}

func TestSourceImportAuthor_GetImportURL(tt *testing.T) {
	var zeroValue string
	s := &SourceImportAuthor{ImportURL: &zeroValue}
	s.GetImportURL()
	s = &SourceImportAuthor{}
	s.GetImportURL()
	s = nil
	s.GetImportURL()
}

func TestSourceImportAuthor_GetName(tt *testing.T) {
	var zeroValue string
	s := &SourceImportAuthor{Name: &zeroValue}
	s.GetName()
	s = &SourceImportAuthor{}
	s.GetName()
	s = nil
	s.GetName()
}

func TestSourceImportAuthor_GetRemoteID(tt *testing.T) {
	var zeroValue string
	s := &SourceImportAuthor{RemoteID: &zeroValue}
	s.GetRemoteID()
	s = &SourceImportAuthor{}
	s.GetRemoteID()
	s = nil
	s.GetRemoteID()
}

func TestSourceImportAuthor_GetRemoteName(tt *testing.T) {
	var zeroValue string
	s := &SourceImportAuthor{RemoteName: &zeroValue}
	s.GetRemoteName()
	s = &SourceImportAuthor{}
	s.GetRemoteName()
	s = nil
	s.GetRemoteName()
}

func TestSourceImportAuthor_GetURL(tt *testing.T) {
	var zeroValue string
	s := &SourceImportAuthor{URL: &zeroValue}
	s.GetURL()
	s = &SourceImportAuthor{}
	s.GetURL()
	s = nil
	s.GetURL()
}

func TestStarEvent_GetAction(tt *testing.T) {
	var zeroValue string
	s := &StarEvent{Action: &zeroValue}
	s.GetAction()
	s = &StarEvent{}
	s.GetAction()
	s = nil
	s.GetAction()
}

func TestStarEvent_GetInstallation(tt *testing.T) {
	s := &StarEvent{}
	s.GetInstallation()
	s = nil
	s.GetInstallation()
}

func TestStarEvent_GetOrg(tt *testing.T) {
	s := &StarEvent{}
	s.GetOrg()
	s = nil
	s.GetOrg()
}

func TestStarEvent_GetRepo(tt *testing.T) {
	s := &StarEvent{}
	s.GetRepo()
	s = nil
	s.GetRepo()
}

func TestStarEvent_GetSender(tt *testing.T) {
	s := &StarEvent{}
	s.GetSender()
	s = nil
	s.GetSender()
}

func TestStarEvent_GetStarredAt(tt *testing.T) {
	var zeroValue Timestamp
	s := &StarEvent{StarredAt: &zeroValue}
	s.GetStarredAt()
	s = &StarEvent{}
	s.GetStarredAt()
	s = nil
	s.GetStarredAt()
}

func TestStargazer_GetStarredAt(tt *testing.T) {
	var zeroValue Timestamp
	s := &Stargazer{StarredAt: &zeroValue}
	s.GetStarredAt()
	s = &Stargazer{}
	s.GetStarredAt()
	s = nil
	s.GetStarredAt()
}

func TestStargazer_GetUser(tt *testing.T) {
	s := &Stargazer{}
	s.GetUser()
	s = nil
	s.GetUser()
}

func TestStarredRepository_GetRepository(tt *testing.T) {
	s := &StarredRepository{}
	s.GetRepository()
	s = nil
	s.GetRepository()
}

func TestStarredRepository_GetStarredAt(tt *testing.T) {
	var zeroValue Timestamp
	s := &StarredRepository{StarredAt: &zeroValue}
	s.GetStarredAt()
	s = &StarredRepository{}
	s.GetStarredAt()
	s = nil
	s.GetStarredAt()
}

func TestStatusEvent_GetCommit(tt *testing.T) {
	s := &StatusEvent{}
	s.GetCommit()
	s = nil
	s.GetCommit()
}

func TestStatusEvent_GetContext(tt *testing.T) {
	var zeroValue string
	s := &StatusEvent{Context: &zeroValue}
	s.GetContext()
	s = &StatusEvent{}
	s.GetContext()
	s = nil
	s.GetContext()
}

func TestStatusEvent_GetCreatedAt(tt *testing.T) {
	var zeroValue Timestamp
	s := &StatusEvent{CreatedAt: &zeroValue}
	s.GetCreatedAt()
	s = &StatusEvent{}
	s.GetCreatedAt()
	s = nil
	s.GetCreatedAt()
}

func TestStatusEvent_GetDescription(tt *testing.T) {
	var zeroValue string
	s := &StatusEvent{Description: &zeroValue}
	s.GetDescription()
	s = &StatusEvent{}
	s.GetDescription()
	s = nil
	s.GetDescription()
}

func TestStatusEvent_GetID(tt *testing.T) {
	var zeroValue int64
	s := &StatusEvent{ID: &zeroValue}
	s.GetID()
	s = &StatusEvent{}
	s.GetID()
	s = nil
	s.GetID()
}

func TestStatusEvent_GetInstallation(tt *testing.T) {
	s := &StatusEvent{}
	s.GetInstallation()
	s = nil
	s.GetInstallation()
}

func TestStatusEvent_GetName(tt *testing.T) {
	var zeroValue string
	s := &StatusEvent{Name: &zeroValue}
	s.GetName()
	s = &StatusEvent{}
	s.GetName()
	s = nil
	s.GetName()
}

func TestStatusEvent_GetRepo(tt *testing.T) {
	s := &StatusEvent{}
	s.GetRepo()
	s = nil
	s.GetRepo()
}

func TestStatusEvent_GetSender(tt *testing.T) {
	s := &StatusEvent{}
	s.GetSender()
	s = nil
	s.GetSender()
}

func TestStatusEvent_GetSHA(tt *testing.T) {
	var zeroValue string
	s := &StatusEvent{SHA: &zeroValue}
	s.GetSHA()
	s = &StatusEvent{}
	s.GetSHA()
	s = nil
	s.GetSHA()
}

func TestStatusEvent_GetState(tt *testing.T) {
	var zeroValue string
	s := &StatusEvent{State: &zeroValue}
	s.GetState()
	s = &StatusEvent{}
	s.GetState()
	s = nil
	s.GetState()
}

func TestStatusEvent_GetTargetURL(tt *testing.T) {
	var zeroValue string
	s := &StatusEvent{TargetURL: &zeroValue}
	s.GetTargetURL()
	s = &StatusEvent{}
	s.GetTargetURL()
	s = nil
	s.GetTargetURL()
}

func TestStatusEvent_GetUpdatedAt(tt *testing.T) {
	var zeroValue Timestamp
	s := &StatusEvent{UpdatedAt: &zeroValue}
	s.GetUpdatedAt()
	s = &StatusEvent{}
	s.GetUpdatedAt()
	s = nil
	s.GetUpdatedAt()
}

func TestSubscription_GetCreatedAt(tt *testing.T) {
	var zeroValue Timestamp
	s := &Subscription{CreatedAt: &zeroValue}
	s.GetCreatedAt()
	s = &Subscription{}
	s.GetCreatedAt()
	s = nil
	s.GetCreatedAt()
}

func TestSubscription_GetIgnored(tt *testing.T) {
	var zeroValue bool
	s := &Subscription{Ignored: &zeroValue}
	s.GetIgnored()
	s = &Subscription{}
	s.GetIgnored()
	s = nil
	s.GetIgnored()
}

func TestSubscription_GetReason(tt *testing.T) {
	var zeroValue string
	s := &Subscription{Reason: &zeroValue}
	s.GetReason()
	s = &Subscription{}
	s.GetReason()
	s = nil
	s.GetReason()
}

func TestSubscription_GetRepositoryURL(tt *testing.T) {
	var zeroValue string
	s := &Subscription{RepositoryURL: &zeroValue}
	s.GetRepositoryURL()
	s = &Subscription{}
	s.GetRepositoryURL()
	s = nil
	s.GetRepositoryURL()
}

func TestSubscription_GetSubscribed(tt *testing.T) {
	var zeroValue bool
	s := &Subscription{Subscribed: &zeroValue}
	s.GetSubscribed()
	s = &Subscription{}
	s.GetSubscribed()
	s = nil
	s.GetSubscribed()
}

func TestSubscription_GetThreadURL(tt *testing.T) {
	var zeroValue string
	s := &Subscription{ThreadURL: &zeroValue}
	s.GetThreadURL()
	s = &Subscription{}
	s.GetThreadURL()
	s = nil
	s.GetThreadURL()
}

func TestSubscription_GetURL(tt *testing.T) {
	var zeroValue string
	s := &Subscription{URL: &zeroValue}
	s.GetURL()
	s = &Subscription{}
	s.GetURL()
	s = nil
	s.GetURL()
}

func TestTag_GetMessage(tt *testing.T) {
	var zeroValue string
	t := &Tag{Message: &zeroValue}
	t.GetMessage()
	t = &Tag{}
	t.GetMessage()
	t = nil
	t.GetMessage()
}

func TestTag_GetNodeID(tt *testing.T) {
	var zeroValue string
	t := &Tag{NodeID: &zeroValue}
	t.GetNodeID()
	t = &Tag{}
	t.GetNodeID()
	t = nil
	t.GetNodeID()
}

func TestTag_GetObject(tt *testing.T) {
	t := &Tag{}
	t.GetObject()
	t = nil
	t.GetObject()
}

func TestTag_GetSHA(tt *testing.T) {
	var zeroValue string
	t := &Tag{SHA: &zeroValue}
	t.GetSHA()
	t = &Tag{}
	t.GetSHA()
	t = nil
	t.GetSHA()
}

func TestTag_GetTag(tt *testing.T) {
	var zeroValue string
	t := &Tag{Tag: &zeroValue}
	t.GetTag()
	t = &Tag{}
	t.GetTag()
	t = nil
	t.GetTag()
}

func TestTag_GetTagger(tt *testing.T) {
	t := &Tag{}
	t.GetTagger()
	t = nil
	t.GetTagger()
}

func TestTag_GetURL(tt *testing.T) {
	var zeroValue string
	t := &Tag{URL: &zeroValue}
	t.GetURL()
	t = &Tag{}
	t.GetURL()
	t = nil
	t.GetURL()
}

func TestTag_GetVerification(tt *testing.T) {
	t := &Tag{}
	t.GetVerification()
	t = nil
	t.GetVerification()
}

func TestTaskStep_GetCompletedAt(tt *testing.T) {
	var zeroValue Timestamp
	t := &TaskStep{CompletedAt: &zeroValue}
	t.GetCompletedAt()
	t = &TaskStep{}
	t.GetCompletedAt()
	t = nil
	t.GetCompletedAt()
}

func TestTaskStep_GetConclusion(tt *testing.T) {
	var zeroValue string
	t := &TaskStep{Conclusion: &zeroValue}
	t.GetConclusion()
	t = &TaskStep{}
	t.GetConclusion()
	t = nil
	t.GetConclusion()
}

func TestTaskStep_GetName(tt *testing.T) {
	var zeroValue string
	t := &TaskStep{Name: &zeroValue}
	t.GetName()
	t = &TaskStep{}
	t.GetName()
	t = nil
	t.GetName()
}

func TestTaskStep_GetNumber(tt *testing.T) {
	var zeroValue int64
	t := &TaskStep{Number: &zeroValue}
	t.GetNumber()
	t = &TaskStep{}
	t.GetNumber()
	t = nil
	t.GetNumber()
}

func TestTaskStep_GetStartedAt(tt *testing.T) {
	var zeroValue Timestamp
	t := &TaskStep{StartedAt: &zeroValue}
	t.GetStartedAt()
	t = &TaskStep{}
	t.GetStartedAt()
	t = nil
	t.GetStartedAt()
}

func TestTaskStep_GetStatus(tt *testing.T) {
	var zeroValue string
	t := &TaskStep{Status: &zeroValue}
	t.GetStatus()
	t = &TaskStep{}
	t.GetStatus()
	t = nil
	t.GetStatus()
}

func TestTeam_GetDescription(tt *testing.T) {
	var zeroValue string
	t := &Team{Description: &zeroValue}
	t.GetDescription()
	t = &Team{}
	t.GetDescription()
	t = nil
	t.GetDescription()
}

func TestTeam_GetHTMLURL(tt *testing.T) {
	var zeroValue string
	t := &Team{HTMLURL: &zeroValue}
	t.GetHTMLURL()
	t = &Team{}
	t.GetHTMLURL()
	t = nil
	t.GetHTMLURL()
}

func TestTeam_GetID(tt *testing.T) {
	var zeroValue int64
	t := &Team{ID: &zeroValue}
	t.GetID()
	t = &Team{}
	t.GetID()
	t = nil
	t.GetID()
}

func TestTeam_GetLDAPDN(tt *testing.T) {
	var zeroValue string
	t := &Team{LDAPDN: &zeroValue}
	t.GetLDAPDN()
	t = &Team{}
	t.GetLDAPDN()
	t = nil
	t.GetLDAPDN()
}

func TestTeam_GetMembersCount(tt *testing.T) {
	var zeroValue int
	t := &Team{MembersCount: &zeroValue}
	t.GetMembersCount()
	t = &Team{}
	t.GetMembersCount()
	t = nil
	t.GetMembersCount()
}

func TestTeam_GetMembersURL(tt *testing.T) {
	var zeroValue string
	t := &Team{MembersURL: &zeroValue}
	t.GetMembersURL()
	t = &Team{}
	t.GetMembersURL()
	t = nil
	t.GetMembersURL()
}

func TestTeam_GetName(tt *testing.T) {
	var zeroValue string
	t := &Team{Name: &zeroValue}
	t.GetName()
	t = &Team{}
	t.GetName()
	t = nil
	t.GetName()
}

func TestTeam_GetNodeID(tt *testing.T) {
	var zeroValue string
	t := &Team{NodeID: &zeroValue}
	t.GetNodeID()
	t = &Team{}
	t.GetNodeID()
	t = nil
	t.GetNodeID()
}

func TestTeam_GetOrganization(tt *testing.T) {
	t := &Team{}
	t.GetOrganization()
	t = nil
	t.GetOrganization()
}

func TestTeam_GetParent(tt *testing.T) {
	t := &Team{}
	t.GetParent()
	t = nil
	t.GetParent()
}

func TestTeam_GetPermission(tt *testing.T) {
	var zeroValue string
	t := &Team{Permission: &zeroValue}
	t.GetPermission()
	t = &Team{}
	t.GetPermission()
	t = nil
	t.GetPermission()
}

func TestTeam_GetPermissions(tt *testing.T) {
	zeroValue := map[string]bool{}
	t := &Team{Permissions: zeroValue}
	t.GetPermissions()
	t = &Team{}
	t.GetPermissions()
	t = nil
	t.GetPermissions()
}

func TestTeam_GetPrivacy(tt *testing.T) {
	var zeroValue string
	t := &Team{Privacy: &zeroValue}
	t.GetPrivacy()
	t = &Team{}
	t.GetPrivacy()
	t = nil
	t.GetPrivacy()
}

func TestTeam_GetReposCount(tt *testing.T) {
	var zeroValue int
	t := &Team{ReposCount: &zeroValue}
	t.GetReposCount()
	t = &Team{}
	t.GetReposCount()
	t = nil
	t.GetReposCount()
}

func TestTeam_GetRepositoriesURL(tt *testing.T) {
	var zeroValue string
	t := &Team{RepositoriesURL: &zeroValue}
	t.GetRepositoriesURL()
	t = &Team{}
	t.GetRepositoriesURL()
	t = nil
	t.GetRepositoriesURL()
}

func TestTeam_GetSlug(tt *testing.T) {
	var zeroValue string
	t := &Team{Slug: &zeroValue}
	t.GetSlug()
	t = &Team{}
	t.GetSlug()
	t = nil
	t.GetSlug()
}

func TestTeam_GetURL(tt *testing.T) {
	var zeroValue string
	t := &Team{URL: &zeroValue}
	t.GetURL()
	t = &Team{}
	t.GetURL()
	t = nil
	t.GetURL()
}

func TestTeamAddEvent_GetInstallation(tt *testing.T) {
	t := &TeamAddEvent{}
	t.GetInstallation()
	t = nil
	t.GetInstallation()
}

func TestTeamAddEvent_GetOrg(tt *testing.T) {
	t := &TeamAddEvent{}
	t.GetOrg()
	t = nil
	t.GetOrg()
}

func TestTeamAddEvent_GetRepo(tt *testing.T) {
	t := &TeamAddEvent{}
	t.GetRepo()
	t = nil
	t.GetRepo()
}

func TestTeamAddEvent_GetSender(tt *testing.T) {
	t := &TeamAddEvent{}
	t.GetSender()
	t = nil
	t.GetSender()
}

func TestTeamAddEvent_GetTeam(tt *testing.T) {
	t := &TeamAddEvent{}
	t.GetTeam()
	t = nil
	t.GetTeam()
}

func TestTeamChange_GetDescription(tt *testing.T) {
	t := &TeamChange{}
	t.GetDescription()
	t = nil
	t.GetDescription()
}

func TestTeamChange_GetName(tt *testing.T) {
	t := &TeamChange{}
	t.GetName()
	t = nil
	t.GetName()
}

func TestTeamChange_GetPrivacy(tt *testing.T) {
	t := &TeamChange{}
	t.GetPrivacy()
	t = nil
	t.GetPrivacy()
}

func TestTeamChange_GetRepository(tt *testing.T) {
	t := &TeamChange{}
	t.GetRepository()
	t = nil
	t.GetRepository()
}

func TestTeamDescription_GetFrom(tt *testing.T) {
	var zeroValue string
	t := &TeamDescription{From: &zeroValue}
	t.GetFrom()
	t = &TeamDescription{}
	t.GetFrom()
	t = nil
	t.GetFrom()
}

func TestTeamDiscussion_GetAuthor(tt *testing.T) {
	t := &TeamDiscussion{}
	t.GetAuthor()
	t = nil
	t.GetAuthor()
}

func TestTeamDiscussion_GetBody(tt *testing.T) {
	var zeroValue string
	t := &TeamDiscussion{Body: &zeroValue}
	t.GetBody()
	t = &TeamDiscussion{}
	t.GetBody()
	t = nil
	t.GetBody()
}

func TestTeamDiscussion_GetBodyHTML(tt *testing.T) {
	var zeroValue string
	t := &TeamDiscussion{BodyHTML: &zeroValue}
	t.GetBodyHTML()
	t = &TeamDiscussion{}
	t.GetBodyHTML()
	t = nil
	t.GetBodyHTML()
}

func TestTeamDiscussion_GetBodyVersion(tt *testing.T) {
	var zeroValue string
	t := &TeamDiscussion{BodyVersion: &zeroValue}
	t.GetBodyVersion()
	t = &TeamDiscussion{}
	t.GetBodyVersion()
	t = nil
	t.GetBodyVersion()
}

func TestTeamDiscussion_GetCommentsCount(tt *testing.T) {
	var zeroValue int
	t := &TeamDiscussion{CommentsCount: &zeroValue}
	t.GetCommentsCount()
	t = &TeamDiscussion{}
	t.GetCommentsCount()
	t = nil
	t.GetCommentsCount()
}

func TestTeamDiscussion_GetCommentsURL(tt *testing.T) {
	var zeroValue string
	t := &TeamDiscussion{CommentsURL: &zeroValue}
	t.GetCommentsURL()
	t = &TeamDiscussion{}
	t.GetCommentsURL()
	t = nil
	t.GetCommentsURL()
}

func TestTeamDiscussion_GetCreatedAt(tt *testing.T) {
	var zeroValue Timestamp
	t := &TeamDiscussion{CreatedAt: &zeroValue}
	t.GetCreatedAt()
	t = &TeamDiscussion{}
	t.GetCreatedAt()
	t = nil
	t.GetCreatedAt()
}

func TestTeamDiscussion_GetHTMLURL(tt *testing.T) {
	var zeroValue string
	t := &TeamDiscussion{HTMLURL: &zeroValue}
	t.GetHTMLURL()
	t = &TeamDiscussion{}
	t.GetHTMLURL()
	t = nil
	t.GetHTMLURL()
}

func TestTeamDiscussion_GetLastEditedAt(tt *testing.T) {
	var zeroValue Timestamp
	t := &TeamDiscussion{LastEditedAt: &zeroValue}
	t.GetLastEditedAt()
	t = &TeamDiscussion{}
	t.GetLastEditedAt()
	t = nil
	t.GetLastEditedAt()
}

func TestTeamDiscussion_GetNodeID(tt *testing.T) {
	var zeroValue string
	t := &TeamDiscussion{NodeID: &zeroValue}
	t.GetNodeID()
	t = &TeamDiscussion{}
	t.GetNodeID()
	t = nil
	t.GetNodeID()
}

func TestTeamDiscussion_GetNumber(tt *testing.T) {
	var zeroValue int
	t := &TeamDiscussion{Number: &zeroValue}
	t.GetNumber()
	t = &TeamDiscussion{}
	t.GetNumber()
	t = nil
	t.GetNumber()
}

func TestTeamDiscussion_GetPinned(tt *testing.T) {
	var zeroValue bool
	t := &TeamDiscussion{Pinned: &zeroValue}
	t.GetPinned()
	t = &TeamDiscussion{}
	t.GetPinned()
	t = nil
	t.GetPinned()
}

func TestTeamDiscussion_GetPrivate(tt *testing.T) {
	var zeroValue bool
	t := &TeamDiscussion{Private: &zeroValue}
	t.GetPrivate()
	t = &TeamDiscussion{}
	t.GetPrivate()
	t = nil
	t.GetPrivate()
}

func TestTeamDiscussion_GetReactions(tt *testing.T) {
	t := &TeamDiscussion{}
	t.GetReactions()
	t = nil
	t.GetReactions()
}

func TestTeamDiscussion_GetTeamURL(tt *testing.T) {
	var zeroValue string
	t := &TeamDiscussion{TeamURL: &zeroValue}
	t.GetTeamURL()
	t = &TeamDiscussion{}
	t.GetTeamURL()
	t = nil
	t.GetTeamURL()
}

func TestTeamDiscussion_GetTitle(tt *testing.T) {
	var zeroValue string
	t := &TeamDiscussion{Title: &zeroValue}
	t.GetTitle()
	t = &TeamDiscussion{}
	t.GetTitle()
	t = nil
	t.GetTitle()
}

func TestTeamDiscussion_GetUpdatedAt(tt *testing.T) {
	var zeroValue Timestamp
	t := &TeamDiscussion{UpdatedAt: &zeroValue}
	t.GetUpdatedAt()
	t = &TeamDiscussion{}
	t.GetUpdatedAt()
	t = nil
	t.GetUpdatedAt()
}

func TestTeamDiscussion_GetURL(tt *testing.T) {
	var zeroValue string
	t := &TeamDiscussion{URL: &zeroValue}
	t.GetURL()
	t = &TeamDiscussion{}
	t.GetURL()
	t = nil
	t.GetURL()
}

func TestTeamEvent_GetAction(tt *testing.T) {
	var zeroValue string
	t := &TeamEvent{Action: &zeroValue}
	t.GetAction()
	t = &TeamEvent{}
	t.GetAction()
	t = nil
	t.GetAction()
}

func TestTeamEvent_GetChanges(tt *testing.T) {
	t := &TeamEvent{}
	t.GetChanges()
	t = nil
	t.GetChanges()
}

func TestTeamEvent_GetInstallation(tt *testing.T) {
	t := &TeamEvent{}
	t.GetInstallation()
	t = nil
	t.GetInstallation()
}

func TestTeamEvent_GetOrg(tt *testing.T) {
	t := &TeamEvent{}
	t.GetOrg()
	t = nil
	t.GetOrg()
}

func TestTeamEvent_GetRepo(tt *testing.T) {
	t := &TeamEvent{}
	t.GetRepo()
	t = nil
	t.GetRepo()
}

func TestTeamEvent_GetSender(tt *testing.T) {
	t := &TeamEvent{}
	t.GetSender()
	t = nil
	t.GetSender()
}

func TestTeamEvent_GetTeam(tt *testing.T) {
	t := &TeamEvent{}
	t.GetTeam()
	t = nil
	t.GetTeam()
}

func TestTeamLDAPMapping_GetDescription(tt *testing.T) {
	var zeroValue string
	t := &TeamLDAPMapping{Description: &zeroValue}
	t.GetDescription()
	t = &TeamLDAPMapping{}
	t.GetDescription()
	t = nil
	t.GetDescription()
}

func TestTeamLDAPMapping_GetID(tt *testing.T) {
	var zeroValue int64
	t := &TeamLDAPMapping{ID: &zeroValue}
	t.GetID()
	t = &TeamLDAPMapping{}
	t.GetID()
	t = nil
	t.GetID()
}

func TestTeamLDAPMapping_GetLDAPDN(tt *testing.T) {
	var zeroValue string
	t := &TeamLDAPMapping{LDAPDN: &zeroValue}
	t.GetLDAPDN()
	t = &TeamLDAPMapping{}
	t.GetLDAPDN()
	t = nil
	t.GetLDAPDN()
}

func TestTeamLDAPMapping_GetMembersURL(tt *testing.T) {
	var zeroValue string
	t := &TeamLDAPMapping{MembersURL: &zeroValue}
	t.GetMembersURL()
	t = &TeamLDAPMapping{}
	t.GetMembersURL()
	t = nil
	t.GetMembersURL()
}

func TestTeamLDAPMapping_GetName(tt *testing.T) {
	var zeroValue string
	t := &TeamLDAPMapping{Name: &zeroValue}
	t.GetName()
	t = &TeamLDAPMapping{}
	t.GetName()
	t = nil
	t.GetName()
}

func TestTeamLDAPMapping_GetPermission(tt *testing.T) {
	var zeroValue string
	t := &TeamLDAPMapping{Permission: &zeroValue}
	t.GetPermission()
	t = &TeamLDAPMapping{}
	t.GetPermission()
	t = nil
	t.GetPermission()
}

func TestTeamLDAPMapping_GetPrivacy(tt *testing.T) {
	var zeroValue string
	t := &TeamLDAPMapping{Privacy: &zeroValue}
	t.GetPrivacy()
	t = &TeamLDAPMapping{}
	t.GetPrivacy()
	t = nil
	t.GetPrivacy()
}

func TestTeamLDAPMapping_GetRepositoriesURL(tt *testing.T) {
	var zeroValue string
	t := &TeamLDAPMapping{RepositoriesURL: &zeroValue}
	t.GetRepositoriesURL()
	t = &TeamLDAPMapping{}
	t.GetRepositoriesURL()
	t = nil
	t.GetRepositoriesURL()
}

func TestTeamLDAPMapping_GetSlug(tt *testing.T) {
	var zeroValue string
	t := &TeamLDAPMapping{Slug: &zeroValue}
	t.GetSlug()
	t = &TeamLDAPMapping{}
	t.GetSlug()
	t = nil
	t.GetSlug()
}

func TestTeamLDAPMapping_GetURL(tt *testing.T) {
	var zeroValue string
	t := &TeamLDAPMapping{URL: &zeroValue}
	t.GetURL()
	t = &TeamLDAPMapping{}
	t.GetURL()
	t = nil
	t.GetURL()
}

func TestTeamName_GetFrom(tt *testing.T) {
	var zeroValue string
	t := &TeamName{From: &zeroValue}
	t.GetFrom()
	t = &TeamName{}
	t.GetFrom()
	t = nil
	t.GetFrom()
}

func TestTeamPermissions_GetFrom(tt *testing.T) {
	t := &TeamPermissions{}
	t.GetFrom()
	t = nil
	t.GetFrom()
}

func TestTeamPermissionsFrom_GetAdmin(tt *testing.T) {
	var zeroValue bool
	t := &TeamPermissionsFrom{Admin: &zeroValue}
	t.GetAdmin()
	t = &TeamPermissionsFrom{}
	t.GetAdmin()
	t = nil
	t.GetAdmin()
}

func TestTeamPermissionsFrom_GetPull(tt *testing.T) {
	var zeroValue bool
	t := &TeamPermissionsFrom{Pull: &zeroValue}
	t.GetPull()
	t = &TeamPermissionsFrom{}
	t.GetPull()
	t = nil
	t.GetPull()
}

func TestTeamPermissionsFrom_GetPush(tt *testing.T) {
	var zeroValue bool
	t := &TeamPermissionsFrom{Push: &zeroValue}
	t.GetPush()
	t = &TeamPermissionsFrom{}
	t.GetPush()
	t = nil
	t.GetPush()
}

func TestTeamPrivacy_GetFrom(tt *testing.T) {
	var zeroValue string
	t := &TeamPrivacy{From: &zeroValue}
	t.GetFrom()
	t = &TeamPrivacy{}
	t.GetFrom()
	t = nil
	t.GetFrom()
}

func TestTeamProjectOptions_GetPermission(tt *testing.T) {
	var zeroValue string
	t := &TeamProjectOptions{Permission: &zeroValue}
	t.GetPermission()
	t = &TeamProjectOptions{}
	t.GetPermission()
	t = nil
	t.GetPermission()
}

func TestTeamRepository_GetPermissions(tt *testing.T) {
	t := &TeamRepository{}
	t.GetPermissions()
	t = nil
	t.GetPermissions()
}

func TestTemplateRepoRequest_GetDescription(tt *testing.T) {
	var zeroValue string
	t := &TemplateRepoRequest{Description: &zeroValue}
	t.GetDescription()
	t = &TemplateRepoRequest{}
	t.GetDescription()
	t = nil
	t.GetDescription()
}

func TestTemplateRepoRequest_GetIncludeAllBranches(tt *testing.T) {
	var zeroValue bool
	t := &TemplateRepoRequest{IncludeAllBranches: &zeroValue}
	t.GetIncludeAllBranches()
	t = &TemplateRepoRequest{}
	t.GetIncludeAllBranches()
	t = nil
	t.GetIncludeAllBranches()
}

func TestTemplateRepoRequest_GetName(tt *testing.T) {
	var zeroValue string
	t := &TemplateRepoRequest{Name: &zeroValue}
	t.GetName()
	t = &TemplateRepoRequest{}
	t.GetName()
	t = nil
	t.GetName()
}

func TestTemplateRepoRequest_GetOwner(tt *testing.T) {
	var zeroValue string
	t := &TemplateRepoRequest{Owner: &zeroValue}
	t.GetOwner()
	t = &TemplateRepoRequest{}
	t.GetOwner()
	t = nil
	t.GetOwner()
}

func TestTemplateRepoRequest_GetPrivate(tt *testing.T) {
	var zeroValue bool
	t := &TemplateRepoRequest{Private: &zeroValue}
	t.GetPrivate()
	t = &TemplateRepoRequest{}
	t.GetPrivate()
	t = nil
	t.GetPrivate()
}

func TestTextMatch_GetFragment(tt *testing.T) {
	var zeroValue string
	t := &TextMatch{Fragment: &zeroValue}
	t.GetFragment()
	t = &TextMatch{}
	t.GetFragment()
	t = nil
	t.GetFragment()
}

func TestTextMatch_GetObjectType(tt *testing.T) {
	var zeroValue string
	t := &TextMatch{ObjectType: &zeroValue}
	t.GetObjectType()
	t = &TextMatch{}
	t.GetObjectType()
	t = nil
	t.GetObjectType()
}

func TestTextMatch_GetObjectURL(tt *testing.T) {
	var zeroValue string
	t := &TextMatch{ObjectURL: &zeroValue}
	t.GetObjectURL()
	t = &TextMatch{}
	t.GetObjectURL()
	t = nil
	t.GetObjectURL()
}

func TestTextMatch_GetProperty(tt *testing.T) {
	var zeroValue string
	t := &TextMatch{Property: &zeroValue}
	t.GetProperty()
	t = &TextMatch{}
	t.GetProperty()
	t = nil
	t.GetProperty()
}

func TestTimeline_GetActor(tt *testing.T) {
	t := &Timeline{}
	t.GetActor()
	t = nil
	t.GetActor()
}

func TestTimeline_GetAssignee(tt *testing.T) {
	t := &Timeline{}
	t.GetAssignee()
	t = nil
	t.GetAssignee()
}

func TestTimeline_GetAssigner(tt *testing.T) {
	t := &Timeline{}
	t.GetAssigner()
	t = nil
	t.GetAssigner()
}

func TestTimeline_GetAuthor(tt *testing.T) {
	t := &Timeline{}
	t.GetAuthor()
	t = nil
	t.GetAuthor()
}

func TestTimeline_GetBody(tt *testing.T) {
	var zeroValue string
	t := &Timeline{Body: &zeroValue}
	t.GetBody()
	t = &Timeline{}
	t.GetBody()
	t = nil
	t.GetBody()
}

func TestTimeline_GetCommitID(tt *testing.T) {
	var zeroValue string
	t := &Timeline{CommitID: &zeroValue}
	t.GetCommitID()
	t = &Timeline{}
	t.GetCommitID()
	t = nil
	t.GetCommitID()
}

func TestTimeline_GetCommitter(tt *testing.T) {
	t := &Timeline{}
	t.GetCommitter()
	t = nil
	t.GetCommitter()
}

func TestTimeline_GetCommitURL(tt *testing.T) {
	var zeroValue string
	t := &Timeline{CommitURL: &zeroValue}
	t.GetCommitURL()
	t = &Timeline{}
	t.GetCommitURL()
	t = nil
	t.GetCommitURL()
}

func TestTimeline_GetCreatedAt(tt *testing.T) {
	var zeroValue time.Time
	t := &Timeline{CreatedAt: &zeroValue}
	t.GetCreatedAt()
	t = &Timeline{}
	t.GetCreatedAt()
	t = nil
	t.GetCreatedAt()
}

func TestTimeline_GetEvent(tt *testing.T) {
	var zeroValue string
	t := &Timeline{Event: &zeroValue}
	t.GetEvent()
	t = &Timeline{}
	t.GetEvent()
	t = nil
	t.GetEvent()
}

func TestTimeline_GetID(tt *testing.T) {
	var zeroValue int64
	t := &Timeline{ID: &zeroValue}
	t.GetID()
	t = &Timeline{}
	t.GetID()
	t = nil
	t.GetID()
}

func TestTimeline_GetLabel(tt *testing.T) {
	t := &Timeline{}
	t.GetLabel()
	t = nil
	t.GetLabel()
}

func TestTimeline_GetMessage(tt *testing.T) {
	var zeroValue string
	t := &Timeline{Message: &zeroValue}
	t.GetMessage()
	t = &Timeline{}
	t.GetMessage()
	t = nil
	t.GetMessage()
}

func TestTimeline_GetMilestone(tt *testing.T) {
	t := &Timeline{}
	t.GetMilestone()
	t = nil
	t.GetMilestone()
}

func TestTimeline_GetProjectCard(tt *testing.T) {
	t := &Timeline{}
	t.GetProjectCard()
	t = nil
	t.GetProjectCard()
}

func TestTimeline_GetRename(tt *testing.T) {
	t := &Timeline{}
	t.GetRename()
	t = nil
	t.GetRename()
}

func TestTimeline_GetRequester(tt *testing.T) {
	t := &Timeline{}
	t.GetRequester()
	t = nil
	t.GetRequester()
}

func TestTimeline_GetReviewer(tt *testing.T) {
	t := &Timeline{}
	t.GetReviewer()
	t = nil
	t.GetReviewer()
}

func TestTimeline_GetSHA(tt *testing.T) {
	var zeroValue string
	t := &Timeline{SHA: &zeroValue}
	t.GetSHA()
	t = &Timeline{}
	t.GetSHA()
	t = nil
	t.GetSHA()
}

func TestTimeline_GetSource(tt *testing.T) {
	t := &Timeline{}
	t.GetSource()
	t = nil
	t.GetSource()
}

func TestTimeline_GetState(tt *testing.T) {
	var zeroValue string
	t := &Timeline{State: &zeroValue}
	t.GetState()
	t = &Timeline{}
	t.GetState()
	t = nil
	t.GetState()
}

func TestTimeline_GetSubmittedAt(tt *testing.T) {
	var zeroValue time.Time
	t := &Timeline{SubmittedAt: &zeroValue}
	t.GetSubmittedAt()
	t = &Timeline{}
	t.GetSubmittedAt()
	t = nil
	t.GetSubmittedAt()
}

func TestTimeline_GetURL(tt *testing.T) {
	var zeroValue string
	t := &Timeline{URL: &zeroValue}
	t.GetURL()
	t = &Timeline{}
	t.GetURL()
	t = nil
	t.GetURL()
}

func TestTimeline_GetUser(tt *testing.T) {
	t := &Timeline{}
	t.GetUser()
	t = nil
	t.GetUser()
}

func TestTool_GetGUID(tt *testing.T) {
	var zeroValue string
	t := &Tool{GUID: &zeroValue}
	t.GetGUID()
	t = &Tool{}
	t.GetGUID()
	t = nil
	t.GetGUID()
}

func TestTool_GetName(tt *testing.T) {
	var zeroValue string
	t := &Tool{Name: &zeroValue}
	t.GetName()
	t = &Tool{}
	t.GetName()
	t = nil
	t.GetName()
}

func TestTool_GetVersion(tt *testing.T) {
	var zeroValue string
	t := &Tool{Version: &zeroValue}
	t.GetVersion()
	t = &Tool{}
	t.GetVersion()
	t = nil
	t.GetVersion()
}

func TestTopicResult_GetCreatedAt(tt *testing.T) {
	var zeroValue Timestamp
	t := &TopicResult{CreatedAt: &zeroValue}
	t.GetCreatedAt()
	t = &TopicResult{}
	t.GetCreatedAt()
	t = nil
	t.GetCreatedAt()
}

func TestTopicResult_GetCreatedBy(tt *testing.T) {
	var zeroValue string
	t := &TopicResult{CreatedBy: &zeroValue}
	t.GetCreatedBy()
	t = &TopicResult{}
	t.GetCreatedBy()
	t = nil
	t.GetCreatedBy()
}

func TestTopicResult_GetCurated(tt *testing.T) {
	var zeroValue bool
	t := &TopicResult{Curated: &zeroValue}
	t.GetCurated()
	t = &TopicResult{}
	t.GetCurated()
	t = nil
	t.GetCurated()
}

func TestTopicResult_GetDescription(tt *testing.T) {
	var zeroValue string
	t := &TopicResult{Description: &zeroValue}
	t.GetDescription()
	t = &TopicResult{}
	t.GetDescription()
	t = nil
	t.GetDescription()
}

func TestTopicResult_GetDisplayName(tt *testing.T) {
	var zeroValue string
	t := &TopicResult{DisplayName: &zeroValue}
	t.GetDisplayName()
	t = &TopicResult{}
	t.GetDisplayName()
	t = nil
	t.GetDisplayName()
}

func TestTopicResult_GetFeatured(tt *testing.T) {
	var zeroValue bool
	t := &TopicResult{Featured: &zeroValue}
	t.GetFeatured()
	t = &TopicResult{}
	t.GetFeatured()
	t = nil
	t.GetFeatured()
}

func TestTopicResult_GetName(tt *testing.T) {
	var zeroValue string
	t := &TopicResult{Name: &zeroValue}
	t.GetName()
	t = &TopicResult{}
	t.GetName()
	t = nil
	t.GetName()
}

func TestTopicResult_GetScore(tt *testing.T) {
	t := &TopicResult{}
	t.GetScore()
	t = nil
	t.GetScore()
}

func TestTopicResult_GetShortDescription(tt *testing.T) {
	var zeroValue string
	t := &TopicResult{ShortDescription: &zeroValue}
	t.GetShortDescription()
	t = &TopicResult{}
	t.GetShortDescription()
	t = nil
	t.GetShortDescription()
}

func TestTopicResult_GetUpdatedAt(tt *testing.T) {
	var zeroValue string
	t := &TopicResult{UpdatedAt: &zeroValue}
	t.GetUpdatedAt()
	t = &TopicResult{}
	t.GetUpdatedAt()
	t = nil
	t.GetUpdatedAt()
}

func TestTopicsSearchResult_GetIncompleteResults(tt *testing.T) {
	var zeroValue bool
	t := &TopicsSearchResult{IncompleteResults: &zeroValue}
	t.GetIncompleteResults()
	t = &TopicsSearchResult{}
	t.GetIncompleteResults()
	t = nil
	t.GetIncompleteResults()
}

func TestTopicsSearchResult_GetTotal(tt *testing.T) {
	var zeroValue int
	t := &TopicsSearchResult{Total: &zeroValue}
	t.GetTotal()
	t = &TopicsSearchResult{}
	t.GetTotal()
	t = nil
	t.GetTotal()
}

func TestTrafficClones_GetCount(tt *testing.T) {
	var zeroValue int
	t := &TrafficClones{Count: &zeroValue}
	t.GetCount()
	t = &TrafficClones{}
	t.GetCount()
	t = nil
	t.GetCount()
}

func TestTrafficClones_GetUniques(tt *testing.T) {
	var zeroValue int
	t := &TrafficClones{Uniques: &zeroValue}
	t.GetUniques()
	t = &TrafficClones{}
	t.GetUniques()
	t = nil
	t.GetUniques()
}

func TestTrafficData_GetCount(tt *testing.T) {
	var zeroValue int
	t := &TrafficData{Count: &zeroValue}
	t.GetCount()
	t = &TrafficData{}
	t.GetCount()
	t = nil
	t.GetCount()
}

func TestTrafficData_GetTimestamp(tt *testing.T) {
	var zeroValue Timestamp
	t := &TrafficData{Timestamp: &zeroValue}
	t.GetTimestamp()
	t = &TrafficData{}
	t.GetTimestamp()
	t = nil
	t.GetTimestamp()
}

func TestTrafficData_GetUniques(tt *testing.T) {
	var zeroValue int
	t := &TrafficData{Uniques: &zeroValue}
	t.GetUniques()
	t = &TrafficData{}
	t.GetUniques()
	t = nil
	t.GetUniques()
}

func TestTrafficPath_GetCount(tt *testing.T) {
	var zeroValue int
	t := &TrafficPath{Count: &zeroValue}
	t.GetCount()
	t = &TrafficPath{}
	t.GetCount()
	t = nil
	t.GetCount()
}

func TestTrafficPath_GetPath(tt *testing.T) {
	var zeroValue string
	t := &TrafficPath{Path: &zeroValue}
	t.GetPath()
	t = &TrafficPath{}
	t.GetPath()
	t = nil
	t.GetPath()
}

func TestTrafficPath_GetTitle(tt *testing.T) {
	var zeroValue string
	t := &TrafficPath{Title: &zeroValue}
	t.GetTitle()
	t = &TrafficPath{}
	t.GetTitle()
	t = nil
	t.GetTitle()
}

func TestTrafficPath_GetUniques(tt *testing.T) {
	var zeroValue int
	t := &TrafficPath{Uniques: &zeroValue}
	t.GetUniques()
	t = &TrafficPath{}
	t.GetUniques()
	t = nil
	t.GetUniques()
}

func TestTrafficReferrer_GetCount(tt *testing.T) {
	var zeroValue int
	t := &TrafficReferrer{Count: &zeroValue}
	t.GetCount()
	t = &TrafficReferrer{}
	t.GetCount()
	t = nil
	t.GetCount()
}

func TestTrafficReferrer_GetReferrer(tt *testing.T) {
	var zeroValue string
	t := &TrafficReferrer{Referrer: &zeroValue}
	t.GetReferrer()
	t = &TrafficReferrer{}
	t.GetReferrer()
	t = nil
	t.GetReferrer()
}

func TestTrafficReferrer_GetUniques(tt *testing.T) {
	var zeroValue int
	t := &TrafficReferrer{Uniques: &zeroValue}
	t.GetUniques()
	t = &TrafficReferrer{}
	t.GetUniques()
	t = nil
	t.GetUniques()
}

func TestTrafficViews_GetCount(tt *testing.T) {
	var zeroValue int
	t := &TrafficViews{Count: &zeroValue}
	t.GetCount()
	t = &TrafficViews{}
	t.GetCount()
	t = nil
	t.GetCount()
}

func TestTrafficViews_GetUniques(tt *testing.T) {
	var zeroValue int
	t := &TrafficViews{Uniques: &zeroValue}
	t.GetUniques()
	t = &TrafficViews{}
	t.GetUniques()
	t = nil
	t.GetUniques()
}

func TestTree_GetSHA(tt *testing.T) {
	var zeroValue string
	t := &Tree{SHA: &zeroValue}
	t.GetSHA()
	t = &Tree{}
	t.GetSHA()
	t = nil
	t.GetSHA()
}

func TestTree_GetTruncated(tt *testing.T) {
	var zeroValue bool
	t := &Tree{Truncated: &zeroValue}
	t.GetTruncated()
	t = &Tree{}
	t.GetTruncated()
	t = nil
	t.GetTruncated()
}

func TestTreeEntry_GetContent(tt *testing.T) {
	var zeroValue string
	t := &TreeEntry{Content: &zeroValue}
	t.GetContent()
	t = &TreeEntry{}
	t.GetContent()
	t = nil
	t.GetContent()
}

func TestTreeEntry_GetMode(tt *testing.T) {
	var zeroValue string
	t := &TreeEntry{Mode: &zeroValue}
	t.GetMode()
	t = &TreeEntry{}
	t.GetMode()
	t = nil
	t.GetMode()
}

func TestTreeEntry_GetPath(tt *testing.T) {
	var zeroValue string
	t := &TreeEntry{Path: &zeroValue}
	t.GetPath()
	t = &TreeEntry{}
	t.GetPath()
	t = nil
	t.GetPath()
}

func TestTreeEntry_GetSHA(tt *testing.T) {
	var zeroValue string
	t := &TreeEntry{SHA: &zeroValue}
	t.GetSHA()
	t = &TreeEntry{}
	t.GetSHA()
	t = nil
	t.GetSHA()
}

func TestTreeEntry_GetSize(tt *testing.T) {
	var zeroValue int
	t := &TreeEntry{Size: &zeroValue}
	t.GetSize()
	t = &TreeEntry{}
	t.GetSize()
	t = nil
	t.GetSize()
}

func TestTreeEntry_GetType(tt *testing.T) {
	var zeroValue string
	t := &TreeEntry{Type: &zeroValue}
	t.GetType()
	t = &TreeEntry{}
	t.GetType()
	t = nil
	t.GetType()
}

func TestTreeEntry_GetURL(tt *testing.T) {
	var zeroValue string
	t := &TreeEntry{URL: &zeroValue}
	t.GetURL()
	t = &TreeEntry{}
	t.GetURL()
	t = nil
	t.GetURL()
}

func TestUpdateAttributeForSCIMUserOperations_GetPath(tt *testing.T) {
	var zeroValue string
	u := &UpdateAttributeForSCIMUserOperations{Path: &zeroValue}
	u.GetPath()
	u = &UpdateAttributeForSCIMUserOperations{}
	u.GetPath()
	u = nil
	u.GetPath()
}

func TestUpdateCheckRunOptions_GetCompletedAt(tt *testing.T) {
	var zeroValue Timestamp
	u := &UpdateCheckRunOptions{CompletedAt: &zeroValue}
	u.GetCompletedAt()
	u = &UpdateCheckRunOptions{}
	u.GetCompletedAt()
	u = nil
	u.GetCompletedAt()
}

func TestUpdateCheckRunOptions_GetConclusion(tt *testing.T) {
	var zeroValue string
	u := &UpdateCheckRunOptions{Conclusion: &zeroValue}
	u.GetConclusion()
	u = &UpdateCheckRunOptions{}
	u.GetConclusion()
	u = nil
	u.GetConclusion()
}

func TestUpdateCheckRunOptions_GetDetailsURL(tt *testing.T) {
	var zeroValue string
	u := &UpdateCheckRunOptions{DetailsURL: &zeroValue}
	u.GetDetailsURL()
	u = &UpdateCheckRunOptions{}
	u.GetDetailsURL()
	u = nil
	u.GetDetailsURL()
}

func TestUpdateCheckRunOptions_GetExternalID(tt *testing.T) {
	var zeroValue string
	u := &UpdateCheckRunOptions{ExternalID: &zeroValue}
	u.GetExternalID()
	u = &UpdateCheckRunOptions{}
	u.GetExternalID()
	u = nil
	u.GetExternalID()
}

func TestUpdateCheckRunOptions_GetOutput(tt *testing.T) {
	u := &UpdateCheckRunOptions{}
	u.GetOutput()
	u = nil
	u.GetOutput()
}

func TestUpdateCheckRunOptions_GetStatus(tt *testing.T) {
	var zeroValue string
	u := &UpdateCheckRunOptions{Status: &zeroValue}
	u.GetStatus()
	u = &UpdateCheckRunOptions{}
	u.GetStatus()
	u = nil
	u.GetStatus()
}

func TestUpdateRunnerGroupRequest_GetAllowsPublicRepositories(tt *testing.T) {
	var zeroValue bool
	u := &UpdateRunnerGroupRequest{AllowsPublicRepositories: &zeroValue}
	u.GetAllowsPublicRepositories()
	u = &UpdateRunnerGroupRequest{}
	u.GetAllowsPublicRepositories()
	u = nil
	u.GetAllowsPublicRepositories()
}

func TestUpdateRunnerGroupRequest_GetName(tt *testing.T) {
	var zeroValue string
	u := &UpdateRunnerGroupRequest{Name: &zeroValue}
	u.GetName()
	u = &UpdateRunnerGroupRequest{}
	u.GetName()
	u = nil
	u.GetName()
}

func TestUpdateRunnerGroupRequest_GetVisibility(tt *testing.T) {
	var zeroValue string
	u := &UpdateRunnerGroupRequest{Visibility: &zeroValue}
	u.GetVisibility()
	u = &UpdateRunnerGroupRequest{}
	u.GetVisibility()
	u = nil
	u.GetVisibility()
}

func TestUser_GetAvatarURL(tt *testing.T) {
	var zeroValue string
	u := &User{AvatarURL: &zeroValue}
	u.GetAvatarURL()
	u = &User{}
	u.GetAvatarURL()
	u = nil
	u.GetAvatarURL()
}

func TestUser_GetBio(tt *testing.T) {
	var zeroValue string
	u := &User{Bio: &zeroValue}
	u.GetBio()
	u = &User{}
	u.GetBio()
	u = nil
	u.GetBio()
}

func TestUser_GetBlog(tt *testing.T) {
	var zeroValue string
	u := &User{Blog: &zeroValue}
	u.GetBlog()
	u = &User{}
	u.GetBlog()
	u = nil
	u.GetBlog()
}

func TestUser_GetCollaborators(tt *testing.T) {
	var zeroValue int
	u := &User{Collaborators: &zeroValue}
	u.GetCollaborators()
	u = &User{}
	u.GetCollaborators()
	u = nil
	u.GetCollaborators()
}

func TestUser_GetCompany(tt *testing.T) {
	var zeroValue string
	u := &User{Company: &zeroValue}
	u.GetCompany()
	u = &User{}
	u.GetCompany()
	u = nil
	u.GetCompany()
}

func TestUser_GetCreatedAt(tt *testing.T) {
	var zeroValue Timestamp
	u := &User{CreatedAt: &zeroValue}
	u.GetCreatedAt()
	u = &User{}
	u.GetCreatedAt()
	u = nil
	u.GetCreatedAt()
}

func TestUser_GetDiskUsage(tt *testing.T) {
	var zeroValue int
	u := &User{DiskUsage: &zeroValue}
	u.GetDiskUsage()
	u = &User{}
	u.GetDiskUsage()
	u = nil
	u.GetDiskUsage()
}

func TestUser_GetEmail(tt *testing.T) {
	var zeroValue string
	u := &User{Email: &zeroValue}
	u.GetEmail()
	u = &User{}
	u.GetEmail()
	u = nil
	u.GetEmail()
}

func TestUser_GetEventsURL(tt *testing.T) {
	var zeroValue string
	u := &User{EventsURL: &zeroValue}
	u.GetEventsURL()
	u = &User{}
	u.GetEventsURL()
	u = nil
	u.GetEventsURL()
}

func TestUser_GetFollowers(tt *testing.T) {
	var zeroValue int
	u := &User{Followers: &zeroValue}
	u.GetFollowers()
	u = &User{}
	u.GetFollowers()
	u = nil
	u.GetFollowers()
}

func TestUser_GetFollowersURL(tt *testing.T) {
	var zeroValue string
	u := &User{FollowersURL: &zeroValue}
	u.GetFollowersURL()
	u = &User{}
	u.GetFollowersURL()
	u = nil
	u.GetFollowersURL()
}

func TestUser_GetFollowing(tt *testing.T) {
	var zeroValue int
	u := &User{Following: &zeroValue}
	u.GetFollowing()
	u = &User{}
	u.GetFollowing()
	u = nil
	u.GetFollowing()
}

func TestUser_GetFollowingURL(tt *testing.T) {
	var zeroValue string
	u := &User{FollowingURL: &zeroValue}
	u.GetFollowingURL()
	u = &User{}
	u.GetFollowingURL()
	u = nil
	u.GetFollowingURL()
}

func TestUser_GetGistsURL(tt *testing.T) {
	var zeroValue string
	u := &User{GistsURL: &zeroValue}
	u.GetGistsURL()
	u = &User{}
	u.GetGistsURL()
	u = nil
	u.GetGistsURL()
}

func TestUser_GetGravatarID(tt *testing.T) {
	var zeroValue string
	u := &User{GravatarID: &zeroValue}
	u.GetGravatarID()
	u = &User{}
	u.GetGravatarID()
	u = nil
	u.GetGravatarID()
}

func TestUser_GetHireable(tt *testing.T) {
	var zeroValue bool
	u := &User{Hireable: &zeroValue}
	u.GetHireable()
	u = &User{}
	u.GetHireable()
	u = nil
	u.GetHireable()
}

func TestUser_GetHTMLURL(tt *testing.T) {
	var zeroValue string
	u := &User{HTMLURL: &zeroValue}
	u.GetHTMLURL()
	u = &User{}
	u.GetHTMLURL()
	u = nil
	u.GetHTMLURL()
}

func TestUser_GetID(tt *testing.T) {
	var zeroValue int64
	u := &User{ID: &zeroValue}
	u.GetID()
	u = &User{}
	u.GetID()
	u = nil
	u.GetID()
}

func TestUser_GetLdapDn(tt *testing.T) {
	var zeroValue string
	u := &User{LdapDn: &zeroValue}
	u.GetLdapDn()
	u = &User{}
	u.GetLdapDn()
	u = nil
	u.GetLdapDn()
}

func TestUser_GetLocation(tt *testing.T) {
	var zeroValue string
	u := &User{Location: &zeroValue}
	u.GetLocation()
	u = &User{}
	u.GetLocation()
	u = nil
	u.GetLocation()
}

func TestUser_GetLogin(tt *testing.T) {
	var zeroValue string
	u := &User{Login: &zeroValue}
	u.GetLogin()
	u = &User{}
	u.GetLogin()
	u = nil
	u.GetLogin()
}

func TestUser_GetName(tt *testing.T) {
	var zeroValue string
	u := &User{Name: &zeroValue}
	u.GetName()
	u = &User{}
	u.GetName()
	u = nil
	u.GetName()
}

func TestUser_GetNodeID(tt *testing.T) {
	var zeroValue string
	u := &User{NodeID: &zeroValue}
	u.GetNodeID()
	u = &User{}
	u.GetNodeID()
	u = nil
	u.GetNodeID()
}

func TestUser_GetOrganizationsURL(tt *testing.T) {
	var zeroValue string
	u := &User{OrganizationsURL: &zeroValue}
	u.GetOrganizationsURL()
	u = &User{}
	u.GetOrganizationsURL()
	u = nil
	u.GetOrganizationsURL()
}

func TestUser_GetOwnedPrivateRepos(tt *testing.T) {
	var zeroValue int
	u := &User{OwnedPrivateRepos: &zeroValue}
	u.GetOwnedPrivateRepos()
	u = &User{}
	u.GetOwnedPrivateRepos()
	u = nil
	u.GetOwnedPrivateRepos()
}

func TestUser_GetPermissions(tt *testing.T) {
	zeroValue := map[string]bool{}
	u := &User{Permissions: zeroValue}
	u.GetPermissions()
	u = &User{}
	u.GetPermissions()
	u = nil
	u.GetPermissions()
}

func TestUser_GetPlan(tt *testing.T) {
	u := &User{}
	u.GetPlan()
	u = nil
	u.GetPlan()
}

func TestUser_GetPrivateGists(tt *testing.T) {
	var zeroValue int
	u := &User{PrivateGists: &zeroValue}
	u.GetPrivateGists()
	u = &User{}
	u.GetPrivateGists()
	u = nil
	u.GetPrivateGists()
}

func TestUser_GetPublicGists(tt *testing.T) {
	var zeroValue int
	u := &User{PublicGists: &zeroValue}
	u.GetPublicGists()
	u = &User{}
	u.GetPublicGists()
	u = nil
	u.GetPublicGists()
}

func TestUser_GetPublicRepos(tt *testing.T) {
	var zeroValue int
	u := &User{PublicRepos: &zeroValue}
	u.GetPublicRepos()
	u = &User{}
	u.GetPublicRepos()
	u = nil
	u.GetPublicRepos()
}

func TestUser_GetReceivedEventsURL(tt *testing.T) {
	var zeroValue string
	u := &User{ReceivedEventsURL: &zeroValue}
	u.GetReceivedEventsURL()
	u = &User{}
	u.GetReceivedEventsURL()
	u = nil
	u.GetReceivedEventsURL()
}

func TestUser_GetReposURL(tt *testing.T) {
	var zeroValue string
	u := &User{ReposURL: &zeroValue}
	u.GetReposURL()
	u = &User{}
	u.GetReposURL()
	u = nil
	u.GetReposURL()
}

func TestUser_GetSiteAdmin(tt *testing.T) {
	var zeroValue bool
	u := &User{SiteAdmin: &zeroValue}
	u.GetSiteAdmin()
	u = &User{}
	u.GetSiteAdmin()
	u = nil
	u.GetSiteAdmin()
}

func TestUser_GetStarredURL(tt *testing.T) {
	var zeroValue string
	u := &User{StarredURL: &zeroValue}
	u.GetStarredURL()
	u = &User{}
	u.GetStarredURL()
	u = nil
	u.GetStarredURL()
}

func TestUser_GetSubscriptionsURL(tt *testing.T) {
	var zeroValue string
	u := &User{SubscriptionsURL: &zeroValue}
	u.GetSubscriptionsURL()
	u = &User{}
	u.GetSubscriptionsURL()
	u = nil
	u.GetSubscriptionsURL()
}

func TestUser_GetSuspendedAt(tt *testing.T) {
	var zeroValue Timestamp
	u := &User{SuspendedAt: &zeroValue}
	u.GetSuspendedAt()
	u = &User{}
	u.GetSuspendedAt()
	u = nil
	u.GetSuspendedAt()
}

func TestUser_GetTotalPrivateRepos(tt *testing.T) {
	var zeroValue int
	u := &User{TotalPrivateRepos: &zeroValue}
	u.GetTotalPrivateRepos()
	u = &User{}
	u.GetTotalPrivateRepos()
	u = nil
	u.GetTotalPrivateRepos()
}

func TestUser_GetTwitterUsername(tt *testing.T) {
	var zeroValue string
	u := &User{TwitterUsername: &zeroValue}
	u.GetTwitterUsername()
	u = &User{}
	u.GetTwitterUsername()
	u = nil
	u.GetTwitterUsername()
}

func TestUser_GetTwoFactorAuthentication(tt *testing.T) {
	var zeroValue bool
	u := &User{TwoFactorAuthentication: &zeroValue}
	u.GetTwoFactorAuthentication()
	u = &User{}
	u.GetTwoFactorAuthentication()
	u = nil
	u.GetTwoFactorAuthentication()
}

func TestUser_GetType(tt *testing.T) {
	var zeroValue string
	u := &User{Type: &zeroValue}
	u.GetType()
	u = &User{}
	u.GetType()
	u = nil
	u.GetType()
}

func TestUser_GetUpdatedAt(tt *testing.T) {
	var zeroValue Timestamp
	u := &User{UpdatedAt: &zeroValue}
	u.GetUpdatedAt()
	u = &User{}
	u.GetUpdatedAt()
	u = nil
	u.GetUpdatedAt()
}

func TestUser_GetURL(tt *testing.T) {
	var zeroValue string
	u := &User{URL: &zeroValue}
	u.GetURL()
	u = &User{}
	u.GetURL()
	u = nil
	u.GetURL()
}

func TestUserAuthorization_GetApp(tt *testing.T) {
	u := &UserAuthorization{}
	u.GetApp()
	u = nil
	u.GetApp()
}

func TestUserAuthorization_GetCreatedAt(tt *testing.T) {
	var zeroValue Timestamp
	u := &UserAuthorization{CreatedAt: &zeroValue}
	u.GetCreatedAt()
	u = &UserAuthorization{}
	u.GetCreatedAt()
	u = nil
	u.GetCreatedAt()
}

func TestUserAuthorization_GetFingerprint(tt *testing.T) {
	var zeroValue string
	u := &UserAuthorization{Fingerprint: &zeroValue}
	u.GetFingerprint()
	u = &UserAuthorization{}
	u.GetFingerprint()
	u = nil
	u.GetFingerprint()
}

func TestUserAuthorization_GetHashedToken(tt *testing.T) {
	var zeroValue string
	u := &UserAuthorization{HashedToken: &zeroValue}
	u.GetHashedToken()
	u = &UserAuthorization{}
	u.GetHashedToken()
	u = nil
	u.GetHashedToken()
}

func TestUserAuthorization_GetID(tt *testing.T) {
	var zeroValue int64
	u := &UserAuthorization{ID: &zeroValue}
	u.GetID()
	u = &UserAuthorization{}
	u.GetID()
	u = nil
	u.GetID()
}

func TestUserAuthorization_GetNote(tt *testing.T) {
	var zeroValue string
	u := &UserAuthorization{Note: &zeroValue}
	u.GetNote()
	u = &UserAuthorization{}
	u.GetNote()
	u = nil
	u.GetNote()
}

func TestUserAuthorization_GetNoteURL(tt *testing.T) {
	var zeroValue string
	u := &UserAuthorization{NoteURL: &zeroValue}
	u.GetNoteURL()
	u = &UserAuthorization{}
	u.GetNoteURL()
	u = nil
	u.GetNoteURL()
}

func TestUserAuthorization_GetToken(tt *testing.T) {
	var zeroValue string
	u := &UserAuthorization{Token: &zeroValue}
	u.GetToken()
	u = &UserAuthorization{}
	u.GetToken()
	u = nil
	u.GetToken()
}

func TestUserAuthorization_GetTokenLastEight(tt *testing.T) {
	var zeroValue string
	u := &UserAuthorization{TokenLastEight: &zeroValue}
	u.GetTokenLastEight()
	u = &UserAuthorization{}
	u.GetTokenLastEight()
	u = nil
	u.GetTokenLastEight()
}

func TestUserAuthorization_GetUpdatedAt(tt *testing.T) {
	var zeroValue Timestamp
	u := &UserAuthorization{UpdatedAt: &zeroValue}
	u.GetUpdatedAt()
	u = &UserAuthorization{}
	u.GetUpdatedAt()
	u = nil
	u.GetUpdatedAt()
}

func TestUserAuthorization_GetURL(tt *testing.T) {
	var zeroValue string
	u := &UserAuthorization{URL: &zeroValue}
	u.GetURL()
	u = &UserAuthorization{}
	u.GetURL()
	u = nil
	u.GetURL()
}

func TestUserContext_GetMessage(tt *testing.T) {
	var zeroValue string
	u := &UserContext{Message: &zeroValue}
	u.GetMessage()
	u = &UserContext{}
	u.GetMessage()
	u = nil
	u.GetMessage()
}

func TestUserContext_GetOcticon(tt *testing.T) {
	var zeroValue string
	u := &UserContext{Octicon: &zeroValue}
	u.GetOcticon()
	u = &UserContext{}
	u.GetOcticon()
	u = nil
	u.GetOcticon()
}

func TestUserEmail_GetEmail(tt *testing.T) {
	var zeroValue string
	u := &UserEmail{Email: &zeroValue}
	u.GetEmail()
	u = &UserEmail{}
	u.GetEmail()
	u = nil
	u.GetEmail()
}

func TestUserEmail_GetPrimary(tt *testing.T) {
	var zeroValue bool
	u := &UserEmail{Primary: &zeroValue}
	u.GetPrimary()
	u = &UserEmail{}
	u.GetPrimary()
	u = nil
	u.GetPrimary()
}

func TestUserEmail_GetVerified(tt *testing.T) {
	var zeroValue bool
	u := &UserEmail{Verified: &zeroValue}
	u.GetVerified()
	u = &UserEmail{}
	u.GetVerified()
	u = nil
	u.GetVerified()
}

func TestUserEmail_GetVisibility(tt *testing.T) {
	var zeroValue string
	u := &UserEmail{Visibility: &zeroValue}
	u.GetVisibility()
	u = &UserEmail{}
	u.GetVisibility()
	u = nil
	u.GetVisibility()
}

func TestUserEvent_GetAction(tt *testing.T) {
	var zeroValue string
	u := &UserEvent{Action: &zeroValue}
	u.GetAction()
	u = &UserEvent{}
	u.GetAction()
	u = nil
	u.GetAction()
}

func TestUserEvent_GetEnterprise(tt *testing.T) {
	u := &UserEvent{}
	u.GetEnterprise()
	u = nil
	u.GetEnterprise()
}

func TestUserEvent_GetInstallation(tt *testing.T) {
	u := &UserEvent{}
	u.GetInstallation()
	u = nil
	u.GetInstallation()
}

func TestUserEvent_GetSender(tt *testing.T) {
	u := &UserEvent{}
	u.GetSender()
	u = nil
	u.GetSender()
}

func TestUserEvent_GetUser(tt *testing.T) {
	u := &UserEvent{}
	u.GetUser()
	u = nil
	u.GetUser()
}

func TestUserLDAPMapping_GetAvatarURL(tt *testing.T) {
	var zeroValue string
	u := &UserLDAPMapping{AvatarURL: &zeroValue}
	u.GetAvatarURL()
	u = &UserLDAPMapping{}
	u.GetAvatarURL()
	u = nil
	u.GetAvatarURL()
}

func TestUserLDAPMapping_GetEventsURL(tt *testing.T) {
	var zeroValue string
	u := &UserLDAPMapping{EventsURL: &zeroValue}
	u.GetEventsURL()
	u = &UserLDAPMapping{}
	u.GetEventsURL()
	u = nil
	u.GetEventsURL()
}

func TestUserLDAPMapping_GetFollowersURL(tt *testing.T) {
	var zeroValue string
	u := &UserLDAPMapping{FollowersURL: &zeroValue}
	u.GetFollowersURL()
	u = &UserLDAPMapping{}
	u.GetFollowersURL()
	u = nil
	u.GetFollowersURL()
}

func TestUserLDAPMapping_GetFollowingURL(tt *testing.T) {
	var zeroValue string
	u := &UserLDAPMapping{FollowingURL: &zeroValue}
	u.GetFollowingURL()
	u = &UserLDAPMapping{}
	u.GetFollowingURL()
	u = nil
	u.GetFollowingURL()
}

func TestUserLDAPMapping_GetGistsURL(tt *testing.T) {
	var zeroValue string
	u := &UserLDAPMapping{GistsURL: &zeroValue}
	u.GetGistsURL()
	u = &UserLDAPMapping{}
	u.GetGistsURL()
	u = nil
	u.GetGistsURL()
}

func TestUserLDAPMapping_GetGravatarID(tt *testing.T) {
	var zeroValue string
	u := &UserLDAPMapping{GravatarID: &zeroValue}
	u.GetGravatarID()
	u = &UserLDAPMapping{}
	u.GetGravatarID()
	u = nil
	u.GetGravatarID()
}

func TestUserLDAPMapping_GetID(tt *testing.T) {
	var zeroValue int64
	u := &UserLDAPMapping{ID: &zeroValue}
	u.GetID()
	u = &UserLDAPMapping{}
	u.GetID()
	u = nil
	u.GetID()
}

func TestUserLDAPMapping_GetLDAPDN(tt *testing.T) {
	var zeroValue string
	u := &UserLDAPMapping{LDAPDN: &zeroValue}
	u.GetLDAPDN()
	u = &UserLDAPMapping{}
	u.GetLDAPDN()
	u = nil
	u.GetLDAPDN()
}

func TestUserLDAPMapping_GetLogin(tt *testing.T) {
	var zeroValue string
	u := &UserLDAPMapping{Login: &zeroValue}
	u.GetLogin()
	u = &UserLDAPMapping{}
	u.GetLogin()
	u = nil
	u.GetLogin()
}

func TestUserLDAPMapping_GetOrganizationsURL(tt *testing.T) {
	var zeroValue string
	u := &UserLDAPMapping{OrganizationsURL: &zeroValue}
	u.GetOrganizationsURL()
	u = &UserLDAPMapping{}
	u.GetOrganizationsURL()
	u = nil
	u.GetOrganizationsURL()
}

func TestUserLDAPMapping_GetReceivedEventsURL(tt *testing.T) {
	var zeroValue string
	u := &UserLDAPMapping{ReceivedEventsURL: &zeroValue}
	u.GetReceivedEventsURL()
	u = &UserLDAPMapping{}
	u.GetReceivedEventsURL()
	u = nil
	u.GetReceivedEventsURL()
}

func TestUserLDAPMapping_GetReposURL(tt *testing.T) {
	var zeroValue string
	u := &UserLDAPMapping{ReposURL: &zeroValue}
	u.GetReposURL()
	u = &UserLDAPMapping{}
	u.GetReposURL()
	u = nil
	u.GetReposURL()
}

func TestUserLDAPMapping_GetSiteAdmin(tt *testing.T) {
	var zeroValue bool
	u := &UserLDAPMapping{SiteAdmin: &zeroValue}
	u.GetSiteAdmin()
	u = &UserLDAPMapping{}
	u.GetSiteAdmin()
	u = nil
	u.GetSiteAdmin()
}

func TestUserLDAPMapping_GetStarredURL(tt *testing.T) {
	var zeroValue string
	u := &UserLDAPMapping{StarredURL: &zeroValue}
	u.GetStarredURL()
	u = &UserLDAPMapping{}
	u.GetStarredURL()
	u = nil
	u.GetStarredURL()
}

func TestUserLDAPMapping_GetSubscriptionsURL(tt *testing.T) {
	var zeroValue string
	u := &UserLDAPMapping{SubscriptionsURL: &zeroValue}
	u.GetSubscriptionsURL()
	u = &UserLDAPMapping{}
	u.GetSubscriptionsURL()
	u = nil
	u.GetSubscriptionsURL()
}

func TestUserLDAPMapping_GetType(tt *testing.T) {
	var zeroValue string
	u := &UserLDAPMapping{Type: &zeroValue}
	u.GetType()
	u = &UserLDAPMapping{}
	u.GetType()
	u = nil
	u.GetType()
}

func TestUserLDAPMapping_GetURL(tt *testing.T) {
	var zeroValue string
	u := &UserLDAPMapping{URL: &zeroValue}
	u.GetURL()
	u = &UserLDAPMapping{}
	u.GetURL()
	u = nil
	u.GetURL()
}

func TestUserMigration_GetCreatedAt(tt *testing.T) {
	var zeroValue string
	u := &UserMigration{CreatedAt: &zeroValue}
	u.GetCreatedAt()
	u = &UserMigration{}
	u.GetCreatedAt()
	u = nil
	u.GetCreatedAt()
}

func TestUserMigration_GetExcludeAttachments(tt *testing.T) {
	var zeroValue bool
	u := &UserMigration{ExcludeAttachments: &zeroValue}
	u.GetExcludeAttachments()
	u = &UserMigration{}
	u.GetExcludeAttachments()
	u = nil
	u.GetExcludeAttachments()
}

func TestUserMigration_GetGUID(tt *testing.T) {
	var zeroValue string
	u := &UserMigration{GUID: &zeroValue}
	u.GetGUID()
	u = &UserMigration{}
	u.GetGUID()
	u = nil
	u.GetGUID()
}

func TestUserMigration_GetID(tt *testing.T) {
	var zeroValue int64
	u := &UserMigration{ID: &zeroValue}
	u.GetID()
	u = &UserMigration{}
	u.GetID()
	u = nil
	u.GetID()
}

func TestUserMigration_GetLockRepositories(tt *testing.T) {
	var zeroValue bool
	u := &UserMigration{LockRepositories: &zeroValue}
	u.GetLockRepositories()
	u = &UserMigration{}
	u.GetLockRepositories()
	u = nil
	u.GetLockRepositories()
}

func TestUserMigration_GetState(tt *testing.T) {
	var zeroValue string
	u := &UserMigration{State: &zeroValue}
	u.GetState()
	u = &UserMigration{}
	u.GetState()
	u = nil
	u.GetState()
}

func TestUserMigration_GetUpdatedAt(tt *testing.T) {
	var zeroValue string
	u := &UserMigration{UpdatedAt: &zeroValue}
	u.GetUpdatedAt()
	u = &UserMigration{}
	u.GetUpdatedAt()
	u = nil
	u.GetUpdatedAt()
}

func TestUserMigration_GetURL(tt *testing.T) {
	var zeroValue string
	u := &UserMigration{URL: &zeroValue}
	u.GetURL()
	u = &UserMigration{}
	u.GetURL()
	u = nil
	u.GetURL()
}

func TestUsersSearchResult_GetIncompleteResults(tt *testing.T) {
	var zeroValue bool
	u := &UsersSearchResult{IncompleteResults: &zeroValue}
	u.GetIncompleteResults()
	u = &UsersSearchResult{}
	u.GetIncompleteResults()
	u = nil
	u.GetIncompleteResults()
}

func TestUsersSearchResult_GetTotal(tt *testing.T) {
	var zeroValue int
	u := &UsersSearchResult{Total: &zeroValue}
	u.GetTotal()
	u = &UsersSearchResult{}
	u.GetTotal()
	u = nil
	u.GetTotal()
}

func TestUserStats_GetAdminUsers(tt *testing.T) {
	var zeroValue int
	u := &UserStats{AdminUsers: &zeroValue}
	u.GetAdminUsers()
	u = &UserStats{}
	u.GetAdminUsers()
	u = nil
	u.GetAdminUsers()
}

func TestUserStats_GetSuspendedUsers(tt *testing.T) {
	var zeroValue int
	u := &UserStats{SuspendedUsers: &zeroValue}
	u.GetSuspendedUsers()
	u = &UserStats{}
	u.GetSuspendedUsers()
	u = nil
	u.GetSuspendedUsers()
}

func TestUserStats_GetTotalUsers(tt *testing.T) {
	var zeroValue int
	u := &UserStats{TotalUsers: &zeroValue}
	u.GetTotalUsers()
	u = &UserStats{}
	u.GetTotalUsers()
	u = nil
	u.GetTotalUsers()
}

func TestUserSuspendOptions_GetReason(tt *testing.T) {
	var zeroValue string
	u := &UserSuspendOptions{Reason: &zeroValue}
	u.GetReason()
	u = &UserSuspendOptions{}
	u.GetReason()
	u = nil
	u.GetReason()
}

func TestVulnerabilityPackage_GetEcosystem(tt *testing.T) {
	var zeroValue string
	v := &VulnerabilityPackage{Ecosystem: &zeroValue}
	v.GetEcosystem()
	v = &VulnerabilityPackage{}
	v.GetEcosystem()
	v = nil
	v.GetEcosystem()
}

func TestVulnerabilityPackage_GetName(tt *testing.T) {
	var zeroValue string
	v := &VulnerabilityPackage{Name: &zeroValue}
	v.GetName()
	v = &VulnerabilityPackage{}
	v.GetName()
	v = nil
	v.GetName()
}

func TestWatchEvent_GetAction(tt *testing.T) {
	var zeroValue string
	w := &WatchEvent{Action: &zeroValue}
	w.GetAction()
	w = &WatchEvent{}
	w.GetAction()
	w = nil
	w.GetAction()
}

func TestWatchEvent_GetInstallation(tt *testing.T) {
	w := &WatchEvent{}
	w.GetInstallation()
	w = nil
	w.GetInstallation()
}

func TestWatchEvent_GetRepo(tt *testing.T) {
	w := &WatchEvent{}
	w.GetRepo()
	w = nil
	w.GetRepo()
}

func TestWatchEvent_GetSender(tt *testing.T) {
	w := &WatchEvent{}
	w.GetSender()
	w = nil
	w.GetSender()
}

func TestWeeklyCommitActivity_GetTotal(tt *testing.T) {
	var zeroValue int
	w := &WeeklyCommitActivity{Total: &zeroValue}
	w.GetTotal()
	w = &WeeklyCommitActivity{}
	w.GetTotal()
	w = nil
	w.GetTotal()
}

func TestWeeklyCommitActivity_GetWeek(tt *testing.T) {
	var zeroValue Timestamp
	w := &WeeklyCommitActivity{Week: &zeroValue}
	w.GetWeek()
	w = &WeeklyCommitActivity{}
	w.GetWeek()
	w = nil
	w.GetWeek()
}

func TestWeeklyStats_GetAdditions(tt *testing.T) {
	var zeroValue int
	w := &WeeklyStats{Additions: &zeroValue}
	w.GetAdditions()
	w = &WeeklyStats{}
	w.GetAdditions()
	w = nil
	w.GetAdditions()
}

func TestWeeklyStats_GetCommits(tt *testing.T) {
	var zeroValue int
	w := &WeeklyStats{Commits: &zeroValue}
	w.GetCommits()
	w = &WeeklyStats{}
	w.GetCommits()
	w = nil
	w.GetCommits()
}

func TestWeeklyStats_GetDeletions(tt *testing.T) {
	var zeroValue int
	w := &WeeklyStats{Deletions: &zeroValue}
	w.GetDeletions()
	w = &WeeklyStats{}
	w.GetDeletions()
	w = nil
	w.GetDeletions()
}

func TestWeeklyStats_GetWeek(tt *testing.T) {
	var zeroValue Timestamp
	w := &WeeklyStats{Week: &zeroValue}
	w.GetWeek()
	w = &WeeklyStats{}
	w.GetWeek()
	w = nil
	w.GetWeek()
}

func TestWorkflow_GetBadgeURL(tt *testing.T) {
	var zeroValue string
	w := &Workflow{BadgeURL: &zeroValue}
	w.GetBadgeURL()
	w = &Workflow{}
	w.GetBadgeURL()
	w = nil
	w.GetBadgeURL()
}

func TestWorkflow_GetCreatedAt(tt *testing.T) {
	var zeroValue Timestamp
	w := &Workflow{CreatedAt: &zeroValue}
	w.GetCreatedAt()
	w = &Workflow{}
	w.GetCreatedAt()
	w = nil
	w.GetCreatedAt()
}

func TestWorkflow_GetHTMLURL(tt *testing.T) {
	var zeroValue string
	w := &Workflow{HTMLURL: &zeroValue}
	w.GetHTMLURL()
	w = &Workflow{}
	w.GetHTMLURL()
	w = nil
	w.GetHTMLURL()
}

func TestWorkflow_GetID(tt *testing.T) {
	var zeroValue int64
	w := &Workflow{ID: &zeroValue}
	w.GetID()
	w = &Workflow{}
	w.GetID()
	w = nil
	w.GetID()
}

func TestWorkflow_GetName(tt *testing.T) {
	var zeroValue string
	w := &Workflow{Name: &zeroValue}
	w.GetName()
	w = &Workflow{}
	w.GetName()
	w = nil
	w.GetName()
}

func TestWorkflow_GetNodeID(tt *testing.T) {
	var zeroValue string
	w := &Workflow{NodeID: &zeroValue}
	w.GetNodeID()
	w = &Workflow{}
	w.GetNodeID()
	w = nil
	w.GetNodeID()
}

func TestWorkflow_GetPath(tt *testing.T) {
	var zeroValue string
	w := &Workflow{Path: &zeroValue}
	w.GetPath()
	w = &Workflow{}
	w.GetPath()
	w = nil
	w.GetPath()
}

func TestWorkflow_GetState(tt *testing.T) {
	var zeroValue string
	w := &Workflow{State: &zeroValue}
	w.GetState()
	w = &Workflow{}
	w.GetState()
	w = nil
	w.GetState()
}

func TestWorkflow_GetUpdatedAt(tt *testing.T) {
	var zeroValue Timestamp
	w := &Workflow{UpdatedAt: &zeroValue}
	w.GetUpdatedAt()
	w = &Workflow{}
	w.GetUpdatedAt()
	w = nil
	w.GetUpdatedAt()
}

func TestWorkflow_GetURL(tt *testing.T) {
	var zeroValue string
	w := &Workflow{URL: &zeroValue}
	w.GetURL()
	w = &Workflow{}
	w.GetURL()
	w = nil
	w.GetURL()
}

func TestWorkflowBill_GetTotalMS(tt *testing.T) {
	var zeroValue int64
	w := &WorkflowBill{TotalMS: &zeroValue}
	w.GetTotalMS()
	w = &WorkflowBill{}
	w.GetTotalMS()
	w = nil
	w.GetTotalMS()
}

func TestWorkflowDispatchEvent_GetInstallation(tt *testing.T) {
	w := &WorkflowDispatchEvent{}
	w.GetInstallation()
	w = nil
	w.GetInstallation()
}

func TestWorkflowDispatchEvent_GetOrg(tt *testing.T) {
	w := &WorkflowDispatchEvent{}
	w.GetOrg()
	w = nil
	w.GetOrg()
}

func TestWorkflowDispatchEvent_GetRef(tt *testing.T) {
	var zeroValue string
	w := &WorkflowDispatchEvent{Ref: &zeroValue}
	w.GetRef()
	w = &WorkflowDispatchEvent{}
	w.GetRef()
	w = nil
	w.GetRef()
}

func TestWorkflowDispatchEvent_GetRepo(tt *testing.T) {
	w := &WorkflowDispatchEvent{}
	w.GetRepo()
	w = nil
	w.GetRepo()
}

func TestWorkflowDispatchEvent_GetSender(tt *testing.T) {
	w := &WorkflowDispatchEvent{}
	w.GetSender()
	w = nil
	w.GetSender()
}

func TestWorkflowDispatchEvent_GetWorkflow(tt *testing.T) {
	var zeroValue string
	w := &WorkflowDispatchEvent{Workflow: &zeroValue}
	w.GetWorkflow()
	w = &WorkflowDispatchEvent{}
	w.GetWorkflow()
	w = nil
	w.GetWorkflow()
}

func TestWorkflowEnvironment_GetMacOS(tt *testing.T) {
	w := &WorkflowEnvironment{}
	w.GetMacOS()
	w = nil
	w.GetMacOS()
}

func TestWorkflowEnvironment_GetUbuntu(tt *testing.T) {
	w := &WorkflowEnvironment{}
	w.GetUbuntu()
	w = nil
	w.GetUbuntu()
}

func TestWorkflowEnvironment_GetWindows(tt *testing.T) {
	w := &WorkflowEnvironment{}
	w.GetWindows()
	w = nil
	w.GetWindows()
}

func TestWorkflowJob_GetCheckRunURL(tt *testing.T) {
	var zeroValue string
	w := &WorkflowJob{CheckRunURL: &zeroValue}
	w.GetCheckRunURL()
	w = &WorkflowJob{}
	w.GetCheckRunURL()
	w = nil
	w.GetCheckRunURL()
}

func TestWorkflowJob_GetCompletedAt(tt *testing.T) {
	var zeroValue Timestamp
	w := &WorkflowJob{CompletedAt: &zeroValue}
	w.GetCompletedAt()
	w = &WorkflowJob{}
	w.GetCompletedAt()
	w = nil
	w.GetCompletedAt()
}

func TestWorkflowJob_GetConclusion(tt *testing.T) {
	var zeroValue string
	w := &WorkflowJob{Conclusion: &zeroValue}
	w.GetConclusion()
	w = &WorkflowJob{}
	w.GetConclusion()
	w = nil
	w.GetConclusion()
}

func TestWorkflowJob_GetHeadSHA(tt *testing.T) {
	var zeroValue string
	w := &WorkflowJob{HeadSHA: &zeroValue}
	w.GetHeadSHA()
	w = &WorkflowJob{}
	w.GetHeadSHA()
	w = nil
	w.GetHeadSHA()
}

func TestWorkflowJob_GetHTMLURL(tt *testing.T) {
	var zeroValue string
	w := &WorkflowJob{HTMLURL: &zeroValue}
	w.GetHTMLURL()
	w = &WorkflowJob{}
	w.GetHTMLURL()
	w = nil
	w.GetHTMLURL()
}

func TestWorkflowJob_GetID(tt *testing.T) {
	var zeroValue int64
	w := &WorkflowJob{ID: &zeroValue}
	w.GetID()
	w = &WorkflowJob{}
	w.GetID()
	w = nil
	w.GetID()
}

func TestWorkflowJob_GetName(tt *testing.T) {
	var zeroValue string
	w := &WorkflowJob{Name: &zeroValue}
	w.GetName()
	w = &WorkflowJob{}
	w.GetName()
	w = nil
	w.GetName()
}

func TestWorkflowJob_GetNodeID(tt *testing.T) {
	var zeroValue string
	w := &WorkflowJob{NodeID: &zeroValue}
	w.GetNodeID()
	w = &WorkflowJob{}
	w.GetNodeID()
	w = nil
	w.GetNodeID()
}

func TestWorkflowJob_GetRunID(tt *testing.T) {
	var zeroValue int64
	w := &WorkflowJob{RunID: &zeroValue}
	w.GetRunID()
	w = &WorkflowJob{}
	w.GetRunID()
	w = nil
	w.GetRunID()
}

func TestWorkflowJob_GetRunnerGroupID(tt *testing.T) {
	var zeroValue int64
	w := &WorkflowJob{RunnerGroupID: &zeroValue}
	w.GetRunnerGroupID()
	w = &WorkflowJob{}
	w.GetRunnerGroupID()
	w = nil
	w.GetRunnerGroupID()
}

func TestWorkflowJob_GetRunnerGroupName(tt *testing.T) {
	var zeroValue string
	w := &WorkflowJob{RunnerGroupName: &zeroValue}
	w.GetRunnerGroupName()
	w = &WorkflowJob{}
	w.GetRunnerGroupName()
	w = nil
	w.GetRunnerGroupName()
}

func TestWorkflowJob_GetRunnerID(tt *testing.T) {
	var zeroValue int64
	w := &WorkflowJob{RunnerID: &zeroValue}
	w.GetRunnerID()
	w = &WorkflowJob{}
	w.GetRunnerID()
	w = nil
	w.GetRunnerID()
}

func TestWorkflowJob_GetRunnerName(tt *testing.T) {
	var zeroValue string
	w := &WorkflowJob{RunnerName: &zeroValue}
	w.GetRunnerName()
	w = &WorkflowJob{}
	w.GetRunnerName()
	w = nil
	w.GetRunnerName()
}

func TestWorkflowJob_GetRunURL(tt *testing.T) {
	var zeroValue string
	w := &WorkflowJob{RunURL: &zeroValue}
	w.GetRunURL()
	w = &WorkflowJob{}
	w.GetRunURL()
	w = nil
	w.GetRunURL()
}

func TestWorkflowJob_GetStartedAt(tt *testing.T) {
	var zeroValue Timestamp
	w := &WorkflowJob{StartedAt: &zeroValue}
	w.GetStartedAt()
	w = &WorkflowJob{}
	w.GetStartedAt()
	w = nil
	w.GetStartedAt()
}

func TestWorkflowJob_GetStatus(tt *testing.T) {
	var zeroValue string
	w := &WorkflowJob{Status: &zeroValue}
	w.GetStatus()
	w = &WorkflowJob{}
	w.GetStatus()
	w = nil
	w.GetStatus()
}

func TestWorkflowJob_GetURL(tt *testing.T) {
	var zeroValue string
	w := &WorkflowJob{URL: &zeroValue}
	w.GetURL()
	w = &WorkflowJob{}
	w.GetURL()
	w = nil
	w.GetURL()
}

func TestWorkflowJobEvent_GetAction(tt *testing.T) {
	var zeroValue string
	w := &WorkflowJobEvent{Action: &zeroValue}
	w.GetAction()
	w = &WorkflowJobEvent{}
	w.GetAction()
	w = nil
	w.GetAction()
}

func TestWorkflowJobEvent_GetInstallation(tt *testing.T) {
	w := &WorkflowJobEvent{}
	w.GetInstallation()
	w = nil
	w.GetInstallation()
}

func TestWorkflowJobEvent_GetOrg(tt *testing.T) {
	w := &WorkflowJobEvent{}
	w.GetOrg()
	w = nil
	w.GetOrg()
}

func TestWorkflowJobEvent_GetRepo(tt *testing.T) {
	w := &WorkflowJobEvent{}
	w.GetRepo()
	w = nil
	w.GetRepo()
}

func TestWorkflowJobEvent_GetSender(tt *testing.T) {
	w := &WorkflowJobEvent{}
	w.GetSender()
	w = nil
	w.GetSender()
}

func TestWorkflowJobEvent_GetWorkflowJob(tt *testing.T) {
	w := &WorkflowJobEvent{}
	w.GetWorkflowJob()
	w = nil
	w.GetWorkflowJob()
}

func TestWorkflowRun_GetArtifactsURL(tt *testing.T) {
	var zeroValue string
	w := &WorkflowRun{ArtifactsURL: &zeroValue}
	w.GetArtifactsURL()
	w = &WorkflowRun{}
	w.GetArtifactsURL()
	w = nil
	w.GetArtifactsURL()
}

func TestWorkflowRun_GetCancelURL(tt *testing.T) {
	var zeroValue string
	w := &WorkflowRun{CancelURL: &zeroValue}
	w.GetCancelURL()
	w = &WorkflowRun{}
	w.GetCancelURL()
	w = nil
	w.GetCancelURL()
}

func TestWorkflowRun_GetCheckSuiteID(tt *testing.T) {
	var zeroValue int64
	w := &WorkflowRun{CheckSuiteID: &zeroValue}
	w.GetCheckSuiteID()
	w = &WorkflowRun{}
	w.GetCheckSuiteID()
	w = nil
	w.GetCheckSuiteID()
}

func TestWorkflowRun_GetCheckSuiteNodeID(tt *testing.T) {
	var zeroValue string
	w := &WorkflowRun{CheckSuiteNodeID: &zeroValue}
	w.GetCheckSuiteNodeID()
	w = &WorkflowRun{}
	w.GetCheckSuiteNodeID()
	w = nil
	w.GetCheckSuiteNodeID()
}

func TestWorkflowRun_GetCheckSuiteURL(tt *testing.T) {
	var zeroValue string
	w := &WorkflowRun{CheckSuiteURL: &zeroValue}
	w.GetCheckSuiteURL()
	w = &WorkflowRun{}
	w.GetCheckSuiteURL()
	w = nil
	w.GetCheckSuiteURL()
}

func TestWorkflowRun_GetConclusion(tt *testing.T) {
	var zeroValue string
	w := &WorkflowRun{Conclusion: &zeroValue}
	w.GetConclusion()
	w = &WorkflowRun{}
	w.GetConclusion()
	w = nil
	w.GetConclusion()
}

func TestWorkflowRun_GetCreatedAt(tt *testing.T) {
	var zeroValue Timestamp
	w := &WorkflowRun{CreatedAt: &zeroValue}
	w.GetCreatedAt()
	w = &WorkflowRun{}
	w.GetCreatedAt()
	w = nil
	w.GetCreatedAt()
}

func TestWorkflowRun_GetEvent(tt *testing.T) {
	var zeroValue string
	w := &WorkflowRun{Event: &zeroValue}
	w.GetEvent()
	w = &WorkflowRun{}
	w.GetEvent()
	w = nil
	w.GetEvent()
}

func TestWorkflowRun_GetHeadBranch(tt *testing.T) {
	var zeroValue string
	w := &WorkflowRun{HeadBranch: &zeroValue}
	w.GetHeadBranch()
	w = &WorkflowRun{}
	w.GetHeadBranch()
	w = nil
	w.GetHeadBranch()
}

func TestWorkflowRun_GetHeadCommit(tt *testing.T) {
	w := &WorkflowRun{}
	w.GetHeadCommit()
	w = nil
	w.GetHeadCommit()
}

func TestWorkflowRun_GetHeadRepository(tt *testing.T) {
	w := &WorkflowRun{}
	w.GetHeadRepository()
	w = nil
	w.GetHeadRepository()
}

func TestWorkflowRun_GetHeadSHA(tt *testing.T) {
	var zeroValue string
	w := &WorkflowRun{HeadSHA: &zeroValue}
	w.GetHeadSHA()
	w = &WorkflowRun{}
	w.GetHeadSHA()
	w = nil
	w.GetHeadSHA()
}

func TestWorkflowRun_GetHTMLURL(tt *testing.T) {
	var zeroValue string
	w := &WorkflowRun{HTMLURL: &zeroValue}
	w.GetHTMLURL()
	w = &WorkflowRun{}
	w.GetHTMLURL()
	w = nil
	w.GetHTMLURL()
}

func TestWorkflowRun_GetID(tt *testing.T) {
	var zeroValue int64
	w := &WorkflowRun{ID: &zeroValue}
	w.GetID()
	w = &WorkflowRun{}
	w.GetID()
	w = nil
	w.GetID()
}

func TestWorkflowRun_GetJobsURL(tt *testing.T) {
	var zeroValue string
	w := &WorkflowRun{JobsURL: &zeroValue}
	w.GetJobsURL()
	w = &WorkflowRun{}
	w.GetJobsURL()
	w = nil
	w.GetJobsURL()
}

func TestWorkflowRun_GetLogsURL(tt *testing.T) {
	var zeroValue string
	w := &WorkflowRun{LogsURL: &zeroValue}
	w.GetLogsURL()
	w = &WorkflowRun{}
	w.GetLogsURL()
	w = nil
	w.GetLogsURL()
}

func TestWorkflowRun_GetName(tt *testing.T) {
	var zeroValue string
	w := &WorkflowRun{Name: &zeroValue}
	w.GetName()
	w = &WorkflowRun{}
	w.GetName()
	w = nil
	w.GetName()
}

func TestWorkflowRun_GetNodeID(tt *testing.T) {
	var zeroValue string
	w := &WorkflowRun{NodeID: &zeroValue}
	w.GetNodeID()
	w = &WorkflowRun{}
	w.GetNodeID()
	w = nil
	w.GetNodeID()
}

func TestWorkflowRun_GetPreviousAttemptURL(tt *testing.T) {
	var zeroValue string
	w := &WorkflowRun{PreviousAttemptURL: &zeroValue}
	w.GetPreviousAttemptURL()
	w = &WorkflowRun{}
	w.GetPreviousAttemptURL()
	w = nil
	w.GetPreviousAttemptURL()
}

func TestWorkflowRun_GetRepository(tt *testing.T) {
	w := &WorkflowRun{}
	w.GetRepository()
	w = nil
	w.GetRepository()
}

func TestWorkflowRun_GetRerunURL(tt *testing.T) {
	var zeroValue string
	w := &WorkflowRun{RerunURL: &zeroValue}
	w.GetRerunURL()
	w = &WorkflowRun{}
	w.GetRerunURL()
	w = nil
	w.GetRerunURL()
}

func TestWorkflowRun_GetRunAttempt(tt *testing.T) {
	var zeroValue int
	w := &WorkflowRun{RunAttempt: &zeroValue}
	w.GetRunAttempt()
	w = &WorkflowRun{}
	w.GetRunAttempt()
	w = nil
	w.GetRunAttempt()
}

func TestWorkflowRun_GetRunNumber(tt *testing.T) {
	var zeroValue int
	w := &WorkflowRun{RunNumber: &zeroValue}
	w.GetRunNumber()
	w = &WorkflowRun{}
	w.GetRunNumber()
	w = nil
	w.GetRunNumber()
}

func TestWorkflowRun_GetRunStartedAt(tt *testing.T) {
	var zeroValue Timestamp
	w := &WorkflowRun{RunStartedAt: &zeroValue}
	w.GetRunStartedAt()
	w = &WorkflowRun{}
	w.GetRunStartedAt()
	w = nil
	w.GetRunStartedAt()
}

func TestWorkflowRun_GetStatus(tt *testing.T) {
	var zeroValue string
	w := &WorkflowRun{Status: &zeroValue}
	w.GetStatus()
	w = &WorkflowRun{}
	w.GetStatus()
	w = nil
	w.GetStatus()
}

func TestWorkflowRun_GetUpdatedAt(tt *testing.T) {
	var zeroValue Timestamp
	w := &WorkflowRun{UpdatedAt: &zeroValue}
	w.GetUpdatedAt()
	w = &WorkflowRun{}
	w.GetUpdatedAt()
	w = nil
	w.GetUpdatedAt()
}

func TestWorkflowRun_GetURL(tt *testing.T) {
	var zeroValue string
	w := &WorkflowRun{URL: &zeroValue}
	w.GetURL()
	w = &WorkflowRun{}
	w.GetURL()
	w = nil
	w.GetURL()
}

func TestWorkflowRun_GetWorkflowID(tt *testing.T) {
	var zeroValue int64
	w := &WorkflowRun{WorkflowID: &zeroValue}
	w.GetWorkflowID()
	w = &WorkflowRun{}
	w.GetWorkflowID()
	w = nil
	w.GetWorkflowID()
}

func TestWorkflowRun_GetWorkflowURL(tt *testing.T) {
	var zeroValue string
	w := &WorkflowRun{WorkflowURL: &zeroValue}
	w.GetWorkflowURL()
	w = &WorkflowRun{}
	w.GetWorkflowURL()
	w = nil
	w.GetWorkflowURL()
}

func TestWorkflowRunAttemptOptions_GetExcludePullRequests(tt *testing.T) {
	var zeroValue bool
	w := &WorkflowRunAttemptOptions{ExcludePullRequests: &zeroValue}
	w.GetExcludePullRequests()
	w = &WorkflowRunAttemptOptions{}
	w.GetExcludePullRequests()
	w = nil
	w.GetExcludePullRequests()
}

func TestWorkflowRunBill_GetJobs(tt *testing.T) {
	var zeroValue int
	w := &WorkflowRunBill{Jobs: &zeroValue}
	w.GetJobs()
	w = &WorkflowRunBill{}
	w.GetJobs()
	w = nil
	w.GetJobs()
}

func TestWorkflowRunBill_GetTotalMS(tt *testing.T) {
	var zeroValue int64
	w := &WorkflowRunBill{TotalMS: &zeroValue}
	w.GetTotalMS()
	w = &WorkflowRunBill{}
	w.GetTotalMS()
	w = nil
	w.GetTotalMS()
}

func TestWorkflowRunEnvironment_GetMacOS(tt *testing.T) {
	w := &WorkflowRunEnvironment{}
	w.GetMacOS()
	w = nil
	w.GetMacOS()
}

func TestWorkflowRunEnvironment_GetUbuntu(tt *testing.T) {
	w := &WorkflowRunEnvironment{}
	w.GetUbuntu()
	w = nil
	w.GetUbuntu()
}

func TestWorkflowRunEnvironment_GetWindows(tt *testing.T) {
	w := &WorkflowRunEnvironment{}
	w.GetWindows()
	w = nil
	w.GetWindows()
}

func TestWorkflowRunEvent_GetAction(tt *testing.T) {
	var zeroValue string
	w := &WorkflowRunEvent{Action: &zeroValue}
	w.GetAction()
	w = &WorkflowRunEvent{}
	w.GetAction()
	w = nil
	w.GetAction()
}

func TestWorkflowRunEvent_GetInstallation(tt *testing.T) {
	w := &WorkflowRunEvent{}
	w.GetInstallation()
	w = nil
	w.GetInstallation()
}

func TestWorkflowRunEvent_GetOrg(tt *testing.T) {
	w := &WorkflowRunEvent{}
	w.GetOrg()
	w = nil
	w.GetOrg()
}

func TestWorkflowRunEvent_GetRepo(tt *testing.T) {
	w := &WorkflowRunEvent{}
	w.GetRepo()
	w = nil
	w.GetRepo()
}

func TestWorkflowRunEvent_GetSender(tt *testing.T) {
	w := &WorkflowRunEvent{}
	w.GetSender()
	w = nil
	w.GetSender()
}

func TestWorkflowRunEvent_GetWorkflow(tt *testing.T) {
	w := &WorkflowRunEvent{}
	w.GetWorkflow()
	w = nil
	w.GetWorkflow()
}

func TestWorkflowRunEvent_GetWorkflowRun(tt *testing.T) {
	w := &WorkflowRunEvent{}
	w.GetWorkflowRun()
	w = nil
	w.GetWorkflowRun()
}

func TestWorkflowRunJobRun_GetDurationMS(tt *testing.T) {
	var zeroValue int64
	w := &WorkflowRunJobRun{DurationMS: &zeroValue}
	w.GetDurationMS()
	w = &WorkflowRunJobRun{}
	w.GetDurationMS()
	w = nil
	w.GetDurationMS()
}

func TestWorkflowRunJobRun_GetJobID(tt *testing.T) {
	var zeroValue int
	w := &WorkflowRunJobRun{JobID: &zeroValue}
	w.GetJobID()
	w = &WorkflowRunJobRun{}
	w.GetJobID()
	w = nil
	w.GetJobID()
}

func TestWorkflowRuns_GetTotalCount(tt *testing.T) {
	var zeroValue int
	w := &WorkflowRuns{TotalCount: &zeroValue}
	w.GetTotalCount()
	w = &WorkflowRuns{}
	w.GetTotalCount()
	w = nil
	w.GetTotalCount()
}

func TestWorkflowRunUsage_GetBillable(tt *testing.T) {
	w := &WorkflowRunUsage{}
	w.GetBillable()
	w = nil
	w.GetBillable()
}

func TestWorkflowRunUsage_GetRunDurationMS(tt *testing.T) {
	var zeroValue int64
	w := &WorkflowRunUsage{RunDurationMS: &zeroValue}
	w.GetRunDurationMS()
	w = &WorkflowRunUsage{}
	w.GetRunDurationMS()
	w = nil
	w.GetRunDurationMS()
}

func TestWorkflows_GetTotalCount(tt *testing.T) {
	var zeroValue int
	w := &Workflows{TotalCount: &zeroValue}
	w.GetTotalCount()
	w = &Workflows{}
	w.GetTotalCount()
	w = nil
	w.GetTotalCount()
}

func TestWorkflowUsage_GetBillable(tt *testing.T) {
	w := &WorkflowUsage{}
	w.GetBillable()
	w = nil
	w.GetBillable()
}