▽

Source file src/github.com/google/go-github/v47/github/github-accessors_test.go

Documentation: github.com/google/go-github/v47/github

     1  // Copyright 2017 The go-github AUTHORS. All rights reserved.
     2  //
     3  // Use of this source code is governed by a BSD-style
     4  // license that can be found in the LICENSE file.
     5  
     6  // Code generated by gen-accessors; DO NOT EDIT.
     7  // Instead, please run "go generate ./..." as described here:
     8  // https://github.com/google/go-github/blob/master/CONTRIBUTING.md#submitting-a-patch
     9  
    10  package github
    11  
    12  import (
    13  	"encoding/json"
    14  	"testing"
    15  	"time"
    16  )
    17  
    18  func TestAbuseRateLimitError_GetRetryAfter(tt *testing.T) {
    19  	var zeroValue time.Duration
    20  	a := &AbuseRateLimitError{RetryAfter: &zeroValue}
    21  	a.GetRetryAfter()
    22  	a = &AbuseRateLimitError{}
    23  	a.GetRetryAfter()
    24  	a = nil
    25  	a.GetRetryAfter()
    26  }
    27  
    28  func TestActionsAllowed_GetGithubOwnedAllowed(tt *testing.T) {
    29  	var zeroValue bool
    30  	a := &ActionsAllowed{GithubOwnedAllowed: &zeroValue}
    31  	a.GetGithubOwnedAllowed()
    32  	a = &ActionsAllowed{}
    33  	a.GetGithubOwnedAllowed()
    34  	a = nil
    35  	a.GetGithubOwnedAllowed()
    36  }
    37  
    38  func TestActionsAllowed_GetVerifiedAllowed(tt *testing.T) {
    39  	var zeroValue bool
    40  	a := &ActionsAllowed{VerifiedAllowed: &zeroValue}
    41  	a.GetVerifiedAllowed()
    42  	a = &ActionsAllowed{}
    43  	a.GetVerifiedAllowed()
    44  	a = nil
    45  	a.GetVerifiedAllowed()
    46  }
    47  
    48  func TestActionsPermissions_GetAllowedActions(tt *testing.T) {
    49  	var zeroValue string
    50  	a := &ActionsPermissions{AllowedActions: &zeroValue}
    51  	a.GetAllowedActions()
    52  	a = &ActionsPermissions{}
    53  	a.GetAllowedActions()
    54  	a = nil
    55  	a.GetAllowedActions()
    56  }
    57  
    58  func TestActionsPermissions_GetEnabledRepositories(tt *testing.T) {
    59  	var zeroValue string
    60  	a := &ActionsPermissions{EnabledRepositories: &zeroValue}
    61  	a.GetEnabledRepositories()
    62  	a = &ActionsPermissions{}
    63  	a.GetEnabledRepositories()
    64  	a = nil
    65  	a.GetEnabledRepositories()
    66  }
    67  
    68  func TestActionsPermissions_GetSelectedActionsURL(tt *testing.T) {
    69  	var zeroValue string
    70  	a := &ActionsPermissions{SelectedActionsURL: &zeroValue}
    71  	a.GetSelectedActionsURL()
    72  	a = &ActionsPermissions{}
    73  	a.GetSelectedActionsURL()
    74  	a = nil
    75  	a.GetSelectedActionsURL()
    76  }
    77  
    78  func TestActionsPermissionsRepository_GetAllowedActions(tt *testing.T) {
    79  	var zeroValue string
    80  	a := &ActionsPermissionsRepository{AllowedActions: &zeroValue}
    81  	a.GetAllowedActions()
    82  	a = &ActionsPermissionsRepository{}
    83  	a.GetAllowedActions()
    84  	a = nil
    85  	a.GetAllowedActions()
    86  }
    87  
    88  func TestActionsPermissionsRepository_GetEnabled(tt *testing.T) {
    89  	var zeroValue bool
    90  	a := &ActionsPermissionsRepository{Enabled: &zeroValue}
    91  	a.GetEnabled()
    92  	a = &ActionsPermissionsRepository{}
    93  	a.GetEnabled()
    94  	a = nil
    95  	a.GetEnabled()
    96  }
    97  
    98  func TestActionsPermissionsRepository_GetSelectedActionsURL(tt *testing.T) {
    99  	var zeroValue string
   100  	a := &ActionsPermissionsRepository{SelectedActionsURL: &zeroValue}
   101  	a.GetSelectedActionsURL()
   102  	a = &ActionsPermissionsRepository{}
   103  	a.GetSelectedActionsURL()
   104  	a = nil
   105  	a.GetSelectedActionsURL()
   106  }
   107  
   108  func TestAdminEnforcement_GetURL(tt *testing.T) {
   109  	var zeroValue string
   110  	a := &AdminEnforcement{URL: &zeroValue}
   111  	a.GetURL()
   112  	a = &AdminEnforcement{}
   113  	a.GetURL()
   114  	a = nil
   115  	a.GetURL()
   116  }
   117  
   118  func TestAdminStats_GetComments(tt *testing.T) {
   119  	a := &AdminStats{}
   120  	a.GetComments()
   121  	a = nil
   122  	a.GetComments()
   123  }
   124  
   125  func TestAdminStats_GetGists(tt *testing.T) {
   126  	a := &AdminStats{}
   127  	a.GetGists()
   128  	a = nil
   129  	a.GetGists()
   130  }
   131  
   132  func TestAdminStats_GetHooks(tt *testing.T) {
   133  	a := &AdminStats{}
   134  	a.GetHooks()
   135  	a = nil
   136  	a.GetHooks()
   137  }
   138  
   139  func TestAdminStats_GetIssues(tt *testing.T) {
   140  	a := &AdminStats{}
   141  	a.GetIssues()
   142  	a = nil
   143  	a.GetIssues()
   144  }
   145  
   146  func TestAdminStats_GetMilestones(tt *testing.T) {
   147  	a := &AdminStats{}
   148  	a.GetMilestones()
   149  	a = nil
   150  	a.GetMilestones()
   151  }
   152  
   153  func TestAdminStats_GetOrgs(tt *testing.T) {
   154  	a := &AdminStats{}
   155  	a.GetOrgs()
   156  	a = nil
   157  	a.GetOrgs()
   158  }
   159  
   160  func TestAdminStats_GetPages(tt *testing.T) {
   161  	a := &AdminStats{}
   162  	a.GetPages()
   163  	a = nil
   164  	a.GetPages()
   165  }
   166  
   167  func TestAdminStats_GetPulls(tt *testing.T) {
   168  	a := &AdminStats{}
   169  	a.GetPulls()
   170  	a = nil
   171  	a.GetPulls()
   172  }
   173  
   174  func TestAdminStats_GetRepos(tt *testing.T) {
   175  	a := &AdminStats{}
   176  	a.GetRepos()
   177  	a = nil
   178  	a.GetRepos()
   179  }
   180  
   181  func TestAdminStats_GetUsers(tt *testing.T) {
   182  	a := &AdminStats{}
   183  	a.GetUsers()
   184  	a = nil
   185  	a.GetUsers()
   186  }
   187  
   188  func TestAdvancedSecurity_GetStatus(tt *testing.T) {
   189  	var zeroValue string
   190  	a := &AdvancedSecurity{Status: &zeroValue}
   191  	a.GetStatus()
   192  	a = &AdvancedSecurity{}
   193  	a.GetStatus()
   194  	a = nil
   195  	a.GetStatus()
   196  }
   197  
   198  func TestAdvancedSecurityCommittersBreakdown_GetLastPushedDate(tt *testing.T) {
   199  	var zeroValue string
   200  	a := &AdvancedSecurityCommittersBreakdown{LastPushedDate: &zeroValue}
   201  	a.GetLastPushedDate()
   202  	a = &AdvancedSecurityCommittersBreakdown{}
   203  	a.GetLastPushedDate()
   204  	a = nil
   205  	a.GetLastPushedDate()
   206  }
   207  
   208  func TestAdvancedSecurityCommittersBreakdown_GetUserLogin(tt *testing.T) {
   209  	var zeroValue string
   210  	a := &AdvancedSecurityCommittersBreakdown{UserLogin: &zeroValue}
   211  	a.GetUserLogin()
   212  	a = &AdvancedSecurityCommittersBreakdown{}
   213  	a.GetUserLogin()
   214  	a = nil
   215  	a.GetUserLogin()
   216  }
   217  
   218  func TestAdvisoryIdentifier_GetType(tt *testing.T) {
   219  	var zeroValue string
   220  	a := &AdvisoryIdentifier{Type: &zeroValue}
   221  	a.GetType()
   222  	a = &AdvisoryIdentifier{}
   223  	a.GetType()
   224  	a = nil
   225  	a.GetType()
   226  }
   227  
   228  func TestAdvisoryIdentifier_GetValue(tt *testing.T) {
   229  	var zeroValue string
   230  	a := &AdvisoryIdentifier{Value: &zeroValue}
   231  	a.GetValue()
   232  	a = &AdvisoryIdentifier{}
   233  	a.GetValue()
   234  	a = nil
   235  	a.GetValue()
   236  }
   237  
   238  func TestAdvisoryReference_GetURL(tt *testing.T) {
   239  	var zeroValue string
   240  	a := &AdvisoryReference{URL: &zeroValue}
   241  	a.GetURL()
   242  	a = &AdvisoryReference{}
   243  	a.GetURL()
   244  	a = nil
   245  	a.GetURL()
   246  }
   247  
   248  func TestAdvisoryVulnerability_GetFirstPatchedVersion(tt *testing.T) {
   249  	a := &AdvisoryVulnerability{}
   250  	a.GetFirstPatchedVersion()
   251  	a = nil
   252  	a.GetFirstPatchedVersion()
   253  }
   254  
   255  func TestAdvisoryVulnerability_GetPackage(tt *testing.T) {
   256  	a := &AdvisoryVulnerability{}
   257  	a.GetPackage()
   258  	a = nil
   259  	a.GetPackage()
   260  }
   261  
   262  func TestAdvisoryVulnerability_GetSeverity(tt *testing.T) {
   263  	var zeroValue string
   264  	a := &AdvisoryVulnerability{Severity: &zeroValue}
   265  	a.GetSeverity()
   266  	a = &AdvisoryVulnerability{}
   267  	a.GetSeverity()
   268  	a = nil
   269  	a.GetSeverity()
   270  }
   271  
   272  func TestAdvisoryVulnerability_GetVulnerableVersionRange(tt *testing.T) {
   273  	var zeroValue string
   274  	a := &AdvisoryVulnerability{VulnerableVersionRange: &zeroValue}
   275  	a.GetVulnerableVersionRange()
   276  	a = &AdvisoryVulnerability{}
   277  	a.GetVulnerableVersionRange()
   278  	a = nil
   279  	a.GetVulnerableVersionRange()
   280  }
   281  
   282  func TestAlert_GetClosedAt(tt *testing.T) {
   283  	var zeroValue Timestamp
   284  	a := &Alert{ClosedAt: &zeroValue}
   285  	a.GetClosedAt()
   286  	a = &Alert{}
   287  	a.GetClosedAt()
   288  	a = nil
   289  	a.GetClosedAt()
   290  }
   291  
   292  func TestAlert_GetClosedBy(tt *testing.T) {
   293  	a := &Alert{}
   294  	a.GetClosedBy()
   295  	a = nil
   296  	a.GetClosedBy()
   297  }
   298  
   299  func TestAlert_GetCreatedAt(tt *testing.T) {
   300  	var zeroValue Timestamp
   301  	a := &Alert{CreatedAt: &zeroValue}
   302  	a.GetCreatedAt()
   303  	a = &Alert{}
   304  	a.GetCreatedAt()
   305  	a = nil
   306  	a.GetCreatedAt()
   307  }
   308  
   309  func TestAlert_GetDismissedAt(tt *testing.T) {
   310  	var zeroValue Timestamp
   311  	a := &Alert{DismissedAt: &zeroValue}
   312  	a.GetDismissedAt()
   313  	a = &Alert{}
   314  	a.GetDismissedAt()
   315  	a = nil
   316  	a.GetDismissedAt()
   317  }
   318  
   319  func TestAlert_GetDismissedBy(tt *testing.T) {
   320  	a := &Alert{}
   321  	a.GetDismissedBy()
   322  	a = nil
   323  	a.GetDismissedBy()
   324  }
   325  
   326  func TestAlert_GetDismissedReason(tt *testing.T) {
   327  	var zeroValue string
   328  	a := &Alert{DismissedReason: &zeroValue}
   329  	a.GetDismissedReason()
   330  	a = &Alert{}
   331  	a.GetDismissedReason()
   332  	a = nil
   333  	a.GetDismissedReason()
   334  }
   335  
   336  func TestAlert_GetFixedAt(tt *testing.T) {
   337  	var zeroValue Timestamp
   338  	a := &Alert{FixedAt: &zeroValue}
   339  	a.GetFixedAt()
   340  	a = &Alert{}
   341  	a.GetFixedAt()
   342  	a = nil
   343  	a.GetFixedAt()
   344  }
   345  
   346  func TestAlert_GetHTMLURL(tt *testing.T) {
   347  	var zeroValue string
   348  	a := &Alert{HTMLURL: &zeroValue}
   349  	a.GetHTMLURL()
   350  	a = &Alert{}
   351  	a.GetHTMLURL()
   352  	a = nil
   353  	a.GetHTMLURL()
   354  }
   355  
   356  func TestAlert_GetInstancesURL(tt *testing.T) {
   357  	var zeroValue string
   358  	a := &Alert{InstancesURL: &zeroValue}
   359  	a.GetInstancesURL()
   360  	a = &Alert{}
   361  	a.GetInstancesURL()
   362  	a = nil
   363  	a.GetInstancesURL()
   364  }
   365  
   366  func TestAlert_GetMostRecentInstance(tt *testing.T) {
   367  	a := &Alert{}
   368  	a.GetMostRecentInstance()
   369  	a = nil
   370  	a.GetMostRecentInstance()
   371  }
   372  
   373  func TestAlert_GetNumber(tt *testing.T) {
   374  	var zeroValue int
   375  	a := &Alert{Number: &zeroValue}
   376  	a.GetNumber()
   377  	a = &Alert{}
   378  	a.GetNumber()
   379  	a = nil
   380  	a.GetNumber()
   381  }
   382  
   383  func TestAlert_GetRepository(tt *testing.T) {
   384  	a := &Alert{}
   385  	a.GetRepository()
   386  	a = nil
   387  	a.GetRepository()
   388  }
   389  
   390  func TestAlert_GetRule(tt *testing.T) {
   391  	a := &Alert{}
   392  	a.GetRule()
   393  	a = nil
   394  	a.GetRule()
   395  }
   396  
   397  func TestAlert_GetRuleDescription(tt *testing.T) {
   398  	var zeroValue string
   399  	a := &Alert{RuleDescription: &zeroValue}
   400  	a.GetRuleDescription()
   401  	a = &Alert{}
   402  	a.GetRuleDescription()
   403  	a = nil
   404  	a.GetRuleDescription()
   405  }
   406  
   407  func TestAlert_GetRuleID(tt *testing.T) {
   408  	var zeroValue string
   409  	a := &Alert{RuleID: &zeroValue}
   410  	a.GetRuleID()
   411  	a = &Alert{}
   412  	a.GetRuleID()
   413  	a = nil
   414  	a.GetRuleID()
   415  }
   416  
   417  func TestAlert_GetRuleSeverity(tt *testing.T) {
   418  	var zeroValue string
   419  	a := &Alert{RuleSeverity: &zeroValue}
   420  	a.GetRuleSeverity()
   421  	a = &Alert{}
   422  	a.GetRuleSeverity()
   423  	a = nil
   424  	a.GetRuleSeverity()
   425  }
   426  
   427  func TestAlert_GetState(tt *testing.T) {
   428  	var zeroValue string
   429  	a := &Alert{State: &zeroValue}
   430  	a.GetState()
   431  	a = &Alert{}
   432  	a.GetState()
   433  	a = nil
   434  	a.GetState()
   435  }
   436  
   437  func TestAlert_GetTool(tt *testing.T) {
   438  	a := &Alert{}
   439  	a.GetTool()
   440  	a = nil
   441  	a.GetTool()
   442  }
   443  
   444  func TestAlert_GetUpdatedAt(tt *testing.T) {
   445  	var zeroValue Timestamp
   446  	a := &Alert{UpdatedAt: &zeroValue}
   447  	a.GetUpdatedAt()
   448  	a = &Alert{}
   449  	a.GetUpdatedAt()
   450  	a = nil
   451  	a.GetUpdatedAt()
   452  }
   453  
   454  func TestAlert_GetURL(tt *testing.T) {
   455  	var zeroValue string
   456  	a := &Alert{URL: &zeroValue}
   457  	a.GetURL()
   458  	a = &Alert{}
   459  	a.GetURL()
   460  	a = nil
   461  	a.GetURL()
   462  }
   463  
   464  func TestAnalysesListOptions_GetRef(tt *testing.T) {
   465  	var zeroValue string
   466  	a := &AnalysesListOptions{Ref: &zeroValue}
   467  	a.GetRef()
   468  	a = &AnalysesListOptions{}
   469  	a.GetRef()
   470  	a = nil
   471  	a.GetRef()
   472  }
   473  
   474  func TestAnalysesListOptions_GetSarifID(tt *testing.T) {
   475  	var zeroValue string
   476  	a := &AnalysesListOptions{SarifID: &zeroValue}
   477  	a.GetSarifID()
   478  	a = &AnalysesListOptions{}
   479  	a.GetSarifID()
   480  	a = nil
   481  	a.GetSarifID()
   482  }
   483  
   484  func TestAPIMeta_GetSSHKeyFingerprints(tt *testing.T) {
   485  	zeroValue := map[string]string{}
   486  	a := &APIMeta{SSHKeyFingerprints: zeroValue}
   487  	a.GetSSHKeyFingerprints()
   488  	a = &APIMeta{}
   489  	a.GetSSHKeyFingerprints()
   490  	a = nil
   491  	a.GetSSHKeyFingerprints()
   492  }
   493  
   494  func TestAPIMeta_GetVerifiablePasswordAuthentication(tt *testing.T) {
   495  	var zeroValue bool
   496  	a := &APIMeta{VerifiablePasswordAuthentication: &zeroValue}
   497  	a.GetVerifiablePasswordAuthentication()
   498  	a = &APIMeta{}
   499  	a.GetVerifiablePasswordAuthentication()
   500  	a = nil
   501  	a.GetVerifiablePasswordAuthentication()
   502  }
   503  
   504  func TestApp_GetCreatedAt(tt *testing.T) {
   505  	var zeroValue Timestamp
   506  	a := &App{CreatedAt: &zeroValue}
   507  	a.GetCreatedAt()
   508  	a = &App{}
   509  	a.GetCreatedAt()
   510  	a = nil
   511  	a.GetCreatedAt()
   512  }
   513  
   514  func TestApp_GetDescription(tt *testing.T) {
   515  	var zeroValue string
   516  	a := &App{Description: &zeroValue}
   517  	a.GetDescription()
   518  	a = &App{}
   519  	a.GetDescription()
   520  	a = nil
   521  	a.GetDescription()
   522  }
   523  
   524  func TestApp_GetExternalURL(tt *testing.T) {
   525  	var zeroValue string
   526  	a := &App{ExternalURL: &zeroValue}
   527  	a.GetExternalURL()
   528  	a = &App{}
   529  	a.GetExternalURL()
   530  	a = nil
   531  	a.GetExternalURL()
   532  }
   533  
   534  func TestApp_GetHTMLURL(tt *testing.T) {
   535  	var zeroValue string
   536  	a := &App{HTMLURL: &zeroValue}
   537  	a.GetHTMLURL()
   538  	a = &App{}
   539  	a.GetHTMLURL()
   540  	a = nil
   541  	a.GetHTMLURL()
   542  }
   543  
   544  func TestApp_GetID(tt *testing.T) {
   545  	var zeroValue int64
   546  	a := &App{ID: &zeroValue}
   547  	a.GetID()
   548  	a = &App{}
   549  	a.GetID()
   550  	a = nil
   551  	a.GetID()
   552  }
   553  
   554  func TestApp_GetName(tt *testing.T) {
   555  	var zeroValue string
   556  	a := &App{Name: &zeroValue}
   557  	a.GetName()
   558  	a = &App{}
   559  	a.GetName()
   560  	a = nil
   561  	a.GetName()
   562  }
   563  
   564  func TestApp_GetNodeID(tt *testing.T) {
   565  	var zeroValue string
   566  	a := &App{NodeID: &zeroValue}
   567  	a.GetNodeID()
   568  	a = &App{}
   569  	a.GetNodeID()
   570  	a = nil
   571  	a.GetNodeID()
   572  }
   573  
   574  func TestApp_GetOwner(tt *testing.T) {
   575  	a := &App{}
   576  	a.GetOwner()
   577  	a = nil
   578  	a.GetOwner()
   579  }
   580  
   581  func TestApp_GetPermissions(tt *testing.T) {
   582  	a := &App{}
   583  	a.GetPermissions()
   584  	a = nil
   585  	a.GetPermissions()
   586  }
   587  
   588  func TestApp_GetSlug(tt *testing.T) {
   589  	var zeroValue string
   590  	a := &App{Slug: &zeroValue}
   591  	a.GetSlug()
   592  	a = &App{}
   593  	a.GetSlug()
   594  	a = nil
   595  	a.GetSlug()
   596  }
   597  
   598  func TestApp_GetUpdatedAt(tt *testing.T) {
   599  	var zeroValue Timestamp
   600  	a := &App{UpdatedAt: &zeroValue}
   601  	a.GetUpdatedAt()
   602  	a = &App{}
   603  	a.GetUpdatedAt()
   604  	a = nil
   605  	a.GetUpdatedAt()
   606  }
   607  
   608  func TestAppConfig_GetClientID(tt *testing.T) {
   609  	var zeroValue string
   610  	a := &AppConfig{ClientID: &zeroValue}
   611  	a.GetClientID()
   612  	a = &AppConfig{}
   613  	a.GetClientID()
   614  	a = nil
   615  	a.GetClientID()
   616  }
   617  
   618  func TestAppConfig_GetClientSecret(tt *testing.T) {
   619  	var zeroValue string
   620  	a := &AppConfig{ClientSecret: &zeroValue}
   621  	a.GetClientSecret()
   622  	a = &AppConfig{}
   623  	a.GetClientSecret()
   624  	a = nil
   625  	a.GetClientSecret()
   626  }
   627  
   628  func TestAppConfig_GetCreatedAt(tt *testing.T) {
   629  	var zeroValue Timestamp
   630  	a := &AppConfig{CreatedAt: &zeroValue}
   631  	a.GetCreatedAt()
   632  	a = &AppConfig{}
   633  	a.GetCreatedAt()
   634  	a = nil
   635  	a.GetCreatedAt()
   636  }
   637  
   638  func TestAppConfig_GetDescription(tt *testing.T) {
   639  	var zeroValue string
   640  	a := &AppConfig{Description: &zeroValue}
   641  	a.GetDescription()
   642  	a = &AppConfig{}
   643  	a.GetDescription()
   644  	a = nil
   645  	a.GetDescription()
   646  }
   647  
   648  func TestAppConfig_GetExternalURL(tt *testing.T) {
   649  	var zeroValue string
   650  	a := &AppConfig{ExternalURL: &zeroValue}
   651  	a.GetExternalURL()
   652  	a = &AppConfig{}
   653  	a.GetExternalURL()
   654  	a = nil
   655  	a.GetExternalURL()
   656  }
   657  
   658  func TestAppConfig_GetHTMLURL(tt *testing.T) {
   659  	var zeroValue string
   660  	a := &AppConfig{HTMLURL: &zeroValue}
   661  	a.GetHTMLURL()
   662  	a = &AppConfig{}
   663  	a.GetHTMLURL()
   664  	a = nil
   665  	a.GetHTMLURL()
   666  }
   667  
   668  func TestAppConfig_GetID(tt *testing.T) {
   669  	var zeroValue int64
   670  	a := &AppConfig{ID: &zeroValue}
   671  	a.GetID()
   672  	a = &AppConfig{}
   673  	a.GetID()
   674  	a = nil
   675  	a.GetID()
   676  }
   677  
   678  func TestAppConfig_GetName(tt *testing.T) {
   679  	var zeroValue string
   680  	a := &AppConfig{Name: &zeroValue}
   681  	a.GetName()
   682  	a = &AppConfig{}
   683  	a.GetName()
   684  	a = nil
   685  	a.GetName()
   686  }
   687  
   688  func TestAppConfig_GetNodeID(tt *testing.T) {
   689  	var zeroValue string
   690  	a := &AppConfig{NodeID: &zeroValue}
   691  	a.GetNodeID()
   692  	a = &AppConfig{}
   693  	a.GetNodeID()
   694  	a = nil
   695  	a.GetNodeID()
   696  }
   697  
   698  func TestAppConfig_GetOwner(tt *testing.T) {
   699  	a := &AppConfig{}
   700  	a.GetOwner()
   701  	a = nil
   702  	a.GetOwner()
   703  }
   704  
   705  func TestAppConfig_GetPEM(tt *testing.T) {
   706  	var zeroValue string
   707  	a := &AppConfig{PEM: &zeroValue}
   708  	a.GetPEM()
   709  	a = &AppConfig{}
   710  	a.GetPEM()
   711  	a = nil
   712  	a.GetPEM()
   713  }
   714  
   715  func TestAppConfig_GetSlug(tt *testing.T) {
   716  	var zeroValue string
   717  	a := &AppConfig{Slug: &zeroValue}
   718  	a.GetSlug()
   719  	a = &AppConfig{}
   720  	a.GetSlug()
   721  	a = nil
   722  	a.GetSlug()
   723  }
   724  
   725  func TestAppConfig_GetUpdatedAt(tt *testing.T) {
   726  	var zeroValue Timestamp
   727  	a := &AppConfig{UpdatedAt: &zeroValue}
   728  	a.GetUpdatedAt()
   729  	a = &AppConfig{}
   730  	a.GetUpdatedAt()
   731  	a = nil
   732  	a.GetUpdatedAt()
   733  }
   734  
   735  func TestAppConfig_GetWebhookSecret(tt *testing.T) {
   736  	var zeroValue string
   737  	a := &AppConfig{WebhookSecret: &zeroValue}
   738  	a.GetWebhookSecret()
   739  	a = &AppConfig{}
   740  	a.GetWebhookSecret()
   741  	a = nil
   742  	a.GetWebhookSecret()
   743  }
   744  
   745  func TestArtifact_GetArchiveDownloadURL(tt *testing.T) {
   746  	var zeroValue string
   747  	a := &Artifact{ArchiveDownloadURL: &zeroValue}
   748  	a.GetArchiveDownloadURL()
   749  	a = &Artifact{}
   750  	a.GetArchiveDownloadURL()
   751  	a = nil
   752  	a.GetArchiveDownloadURL()
   753  }
   754  
   755  func TestArtifact_GetCreatedAt(tt *testing.T) {
   756  	var zeroValue Timestamp
   757  	a := &Artifact{CreatedAt: &zeroValue}
   758  	a.GetCreatedAt()
   759  	a = &Artifact{}
   760  	a.GetCreatedAt()
   761  	a = nil
   762  	a.GetCreatedAt()
   763  }
   764  
   765  func TestArtifact_GetExpired(tt *testing.T) {
   766  	var zeroValue bool
   767  	a := &Artifact{Expired: &zeroValue}
   768  	a.GetExpired()
   769  	a = &Artifact{}
   770  	a.GetExpired()
   771  	a = nil
   772  	a.GetExpired()
   773  }
   774  
   775  func TestArtifact_GetExpiresAt(tt *testing.T) {
   776  	var zeroValue Timestamp
   777  	a := &Artifact{ExpiresAt: &zeroValue}
   778  	a.GetExpiresAt()
   779  	a = &Artifact{}
   780  	a.GetExpiresAt()
   781  	a = nil
   782  	a.GetExpiresAt()
   783  }
   784  
   785  func TestArtifact_GetID(tt *testing.T) {
   786  	var zeroValue int64
   787  	a := &Artifact{ID: &zeroValue}
   788  	a.GetID()
   789  	a = &Artifact{}
   790  	a.GetID()
   791  	a = nil
   792  	a.GetID()
   793  }
   794  
   795  func TestArtifact_GetName(tt *testing.T) {
   796  	var zeroValue string
   797  	a := &Artifact{Name: &zeroValue}
   798  	a.GetName()
   799  	a = &Artifact{}
   800  	a.GetName()
   801  	a = nil
   802  	a.GetName()
   803  }
   804  
   805  func TestArtifact_GetNodeID(tt *testing.T) {
   806  	var zeroValue string
   807  	a := &Artifact{NodeID: &zeroValue}
   808  	a.GetNodeID()
   809  	a = &Artifact{}
   810  	a.GetNodeID()
   811  	a = nil
   812  	a.GetNodeID()
   813  }
   814  
   815  func TestArtifact_GetSizeInBytes(tt *testing.T) {
   816  	var zeroValue int64
   817  	a := &Artifact{SizeInBytes: &zeroValue}
   818  	a.GetSizeInBytes()
   819  	a = &Artifact{}
   820  	a.GetSizeInBytes()
   821  	a = nil
   822  	a.GetSizeInBytes()
   823  }
   824  
   825  func TestArtifactList_GetTotalCount(tt *testing.T) {
   826  	var zeroValue int64
   827  	a := &ArtifactList{TotalCount: &zeroValue}
   828  	a.GetTotalCount()
   829  	a = &ArtifactList{}
   830  	a.GetTotalCount()
   831  	a = nil
   832  	a.GetTotalCount()
   833  }
   834  
   835  func TestAttachment_GetBody(tt *testing.T) {
   836  	var zeroValue string
   837  	a := &Attachment{Body: &zeroValue}
   838  	a.GetBody()
   839  	a = &Attachment{}
   840  	a.GetBody()
   841  	a = nil
   842  	a.GetBody()
   843  }
   844  
   845  func TestAttachment_GetID(tt *testing.T) {
   846  	var zeroValue int64
   847  	a := &Attachment{ID: &zeroValue}
   848  	a.GetID()
   849  	a = &Attachment{}
   850  	a.GetID()
   851  	a = nil
   852  	a.GetID()
   853  }
   854  
   855  func TestAttachment_GetTitle(tt *testing.T) {
   856  	var zeroValue string
   857  	a := &Attachment{Title: &zeroValue}
   858  	a.GetTitle()
   859  	a = &Attachment{}
   860  	a.GetTitle()
   861  	a = nil
   862  	a.GetTitle()
   863  }
   864  
   865  func TestAuditEntry_GetAction(tt *testing.T) {
   866  	var zeroValue string
   867  	a := &AuditEntry{Action: &zeroValue}
   868  	a.GetAction()
   869  	a = &AuditEntry{}
   870  	a.GetAction()
   871  	a = nil
   872  	a.GetAction()
   873  }
   874  
   875  func TestAuditEntry_GetActive(tt *testing.T) {
   876  	var zeroValue bool
   877  	a := &AuditEntry{Active: &zeroValue}
   878  	a.GetActive()
   879  	a = &AuditEntry{}
   880  	a.GetActive()
   881  	a = nil
   882  	a.GetActive()
   883  }
   884  
   885  func TestAuditEntry_GetActiveWas(tt *testing.T) {
   886  	var zeroValue bool
   887  	a := &AuditEntry{ActiveWas: &zeroValue}
   888  	a.GetActiveWas()
   889  	a = &AuditEntry{}
   890  	a.GetActiveWas()
   891  	a = nil
   892  	a.GetActiveWas()
   893  }
   894  
   895  func TestAuditEntry_GetActor(tt *testing.T) {
   896  	var zeroValue string
   897  	a := &AuditEntry{Actor: &zeroValue}
   898  	a.GetActor()
   899  	a = &AuditEntry{}
   900  	a.GetActor()
   901  	a = nil
   902  	a.GetActor()
   903  }
   904  
   905  func TestAuditEntry_GetBlockedUser(tt *testing.T) {
   906  	var zeroValue string
   907  	a := &AuditEntry{BlockedUser: &zeroValue}
   908  	a.GetBlockedUser()
   909  	a = &AuditEntry{}
   910  	a.GetBlockedUser()
   911  	a = nil
   912  	a.GetBlockedUser()
   913  }
   914  
   915  func TestAuditEntry_GetBusiness(tt *testing.T) {
   916  	var zeroValue string
   917  	a := &AuditEntry{Business: &zeroValue}
   918  	a.GetBusiness()
   919  	a = &AuditEntry{}
   920  	a.GetBusiness()
   921  	a = nil
   922  	a.GetBusiness()
   923  }
   924  
   925  func TestAuditEntry_GetCancelledAt(tt *testing.T) {
   926  	var zeroValue Timestamp
   927  	a := &AuditEntry{CancelledAt: &zeroValue}
   928  	a.GetCancelledAt()
   929  	a = &AuditEntry{}
   930  	a.GetCancelledAt()
   931  	a = nil
   932  	a.GetCancelledAt()
   933  }
   934  
   935  func TestAuditEntry_GetCompletedAt(tt *testing.T) {
   936  	var zeroValue Timestamp
   937  	a := &AuditEntry{CompletedAt: &zeroValue}
   938  	a.GetCompletedAt()
   939  	a = &AuditEntry{}
   940  	a.GetCompletedAt()
   941  	a = nil
   942  	a.GetCompletedAt()
   943  }
   944  
   945  func TestAuditEntry_GetConclusion(tt *testing.T) {
   946  	var zeroValue string
   947  	a := &AuditEntry{Conclusion: &zeroValue}
   948  	a.GetConclusion()
   949  	a = &AuditEntry{}
   950  	a.GetConclusion()
   951  	a = nil
   952  	a.GetConclusion()
   953  }
   954  
   955  func TestAuditEntry_GetConfig(tt *testing.T) {
   956  	a := &AuditEntry{}
   957  	a.GetConfig()
   958  	a = nil
   959  	a.GetConfig()
   960  }
   961  
   962  func TestAuditEntry_GetConfigWas(tt *testing.T) {
   963  	a := &AuditEntry{}
   964  	a.GetConfigWas()
   965  	a = nil
   966  	a.GetConfigWas()
   967  }
   968  
   969  func TestAuditEntry_GetContentType(tt *testing.T) {
   970  	var zeroValue string
   971  	a := &AuditEntry{ContentType: &zeroValue}
   972  	a.GetContentType()
   973  	a = &AuditEntry{}
   974  	a.GetContentType()
   975  	a = nil
   976  	a.GetContentType()
   977  }
   978  
   979  func TestAuditEntry_GetCreatedAt(tt *testing.T) {
   980  	var zeroValue Timestamp
   981  	a := &AuditEntry{CreatedAt: &zeroValue}
   982  	a.GetCreatedAt()
   983  	a = &AuditEntry{}
   984  	a.GetCreatedAt()
   985  	a = nil
   986  	a.GetCreatedAt()
   987  }
   988  
   989  func TestAuditEntry_GetDeployKeyFingerprint(tt *testing.T) {
   990  	var zeroValue string
   991  	a := &AuditEntry{DeployKeyFingerprint: &zeroValue}
   992  	a.GetDeployKeyFingerprint()
   993  	a = &AuditEntry{}
   994  	a.GetDeployKeyFingerprint()
   995  	a = nil
   996  	a.GetDeployKeyFingerprint()
   997  }
   998  
   999  func TestAuditEntry_GetDocumentID(tt *testing.T) {
  1000  	var zeroValue string
  1001  	a := &AuditEntry{DocumentID: &zeroValue}
  1002  	a.GetDocumentID()
  1003  	a = &AuditEntry{}
  1004  	a.GetDocumentID()
  1005  	a = nil
  1006  	a.GetDocumentID()
  1007  }
  1008  
  1009  func TestAuditEntry_GetEmoji(tt *testing.T) {
  1010  	var zeroValue string
  1011  	a := &AuditEntry{Emoji: &zeroValue}
  1012  	a.GetEmoji()
  1013  	a = &AuditEntry{}
  1014  	a.GetEmoji()
  1015  	a = nil
  1016  	a.GetEmoji()
  1017  }
  1018  
  1019  func TestAuditEntry_GetEnvironmentName(tt *testing.T) {
  1020  	var zeroValue string
  1021  	a := &AuditEntry{EnvironmentName: &zeroValue}
  1022  	a.GetEnvironmentName()
  1023  	a = &AuditEntry{}
  1024  	a.GetEnvironmentName()
  1025  	a = nil
  1026  	a.GetEnvironmentName()
  1027  }
  1028  
  1029  func TestAuditEntry_GetEvent(tt *testing.T) {
  1030  	var zeroValue string
  1031  	a := &AuditEntry{Event: &zeroValue}
  1032  	a.GetEvent()
  1033  	a = &AuditEntry{}
  1034  	a.GetEvent()
  1035  	a = nil
  1036  	a.GetEvent()
  1037  }
  1038  
  1039  func TestAuditEntry_GetExplanation(tt *testing.T) {
  1040  	var zeroValue string
  1041  	a := &AuditEntry{Explanation: &zeroValue}
  1042  	a.GetExplanation()
  1043  	a = &AuditEntry{}
  1044  	a.GetExplanation()
  1045  	a = nil
  1046  	a.GetExplanation()
  1047  }
  1048  
  1049  func TestAuditEntry_GetFingerprint(tt *testing.T) {
  1050  	var zeroValue string
  1051  	a := &AuditEntry{Fingerprint: &zeroValue}
  1052  	a.GetFingerprint()
  1053  	a = &AuditEntry{}
  1054  	a.GetFingerprint()
  1055  	a = nil
  1056  	a.GetFingerprint()
  1057  }
  1058  
  1059  func TestAuditEntry_GetHeadBranch(tt *testing.T) {
  1060  	var zeroValue string
  1061  	a := &AuditEntry{HeadBranch: &zeroValue}
  1062  	a.GetHeadBranch()
  1063  	a = &AuditEntry{}
  1064  	a.GetHeadBranch()
  1065  	a = nil
  1066  	a.GetHeadBranch()
  1067  }
  1068  
  1069  func TestAuditEntry_GetHeadSHA(tt *testing.T) {
  1070  	var zeroValue string
  1071  	a := &AuditEntry{HeadSHA: &zeroValue}
  1072  	a.GetHeadSHA()
  1073  	a = &AuditEntry{}
  1074  	a.GetHeadSHA()
  1075  	a = nil
  1076  	a.GetHeadSHA()
  1077  }
  1078  
  1079  func TestAuditEntry_GetHookID(tt *testing.T) {
  1080  	var zeroValue int64
  1081  	a := &AuditEntry{HookID: &zeroValue}
  1082  	a.GetHookID()
  1083  	a = &AuditEntry{}
  1084  	a.GetHookID()
  1085  	a = nil
  1086  	a.GetHookID()
  1087  }
  1088  
  1089  func TestAuditEntry_GetIsHostedRunner(tt *testing.T) {
  1090  	var zeroValue bool
  1091  	a := &AuditEntry{IsHostedRunner: &zeroValue}
  1092  	a.GetIsHostedRunner()
  1093  	a = &AuditEntry{}
  1094  	a.GetIsHostedRunner()
  1095  	a = nil
  1096  	a.GetIsHostedRunner()
  1097  }
  1098  
  1099  func TestAuditEntry_GetJobName(tt *testing.T) {
  1100  	var zeroValue string
  1101  	a := &AuditEntry{JobName: &zeroValue}
  1102  	a.GetJobName()
  1103  	a = &AuditEntry{}
  1104  	a.GetJobName()
  1105  	a = nil
  1106  	a.GetJobName()
  1107  }
  1108  
  1109  func TestAuditEntry_GetLimitedAvailability(tt *testing.T) {
  1110  	var zeroValue bool
  1111  	a := &AuditEntry{LimitedAvailability: &zeroValue}
  1112  	a.GetLimitedAvailability()
  1113  	a = &AuditEntry{}
  1114  	a.GetLimitedAvailability()
  1115  	a = nil
  1116  	a.GetLimitedAvailability()
  1117  }
  1118  
  1119  func TestAuditEntry_GetMessage(tt *testing.T) {
  1120  	var zeroValue string
  1121  	a := &AuditEntry{Message: &zeroValue}
  1122  	a.GetMessage()
  1123  	a = &AuditEntry{}
  1124  	a.GetMessage()
  1125  	a = nil
  1126  	a.GetMessage()
  1127  }
  1128  
  1129  func TestAuditEntry_GetName(tt *testing.T) {
  1130  	var zeroValue string
  1131  	a := &AuditEntry{Name: &zeroValue}
  1132  	a.GetName()
  1133  	a = &AuditEntry{}
  1134  	a.GetName()
  1135  	a = nil
  1136  	a.GetName()
  1137  }
  1138  
  1139  func TestAuditEntry_GetOldUser(tt *testing.T) {
  1140  	var zeroValue string
  1141  	a := &AuditEntry{OldUser: &zeroValue}
  1142  	a.GetOldUser()
  1143  	a = &AuditEntry{}
  1144  	a.GetOldUser()
  1145  	a = nil
  1146  	a.GetOldUser()
  1147  }
  1148  
  1149  func TestAuditEntry_GetOpenSSHPublicKey(tt *testing.T) {
  1150  	var zeroValue string
  1151  	a := &AuditEntry{OpenSSHPublicKey: &zeroValue}
  1152  	a.GetOpenSSHPublicKey()
  1153  	a = &AuditEntry{}
  1154  	a.GetOpenSSHPublicKey()
  1155  	a = nil
  1156  	a.GetOpenSSHPublicKey()
  1157  }
  1158  
  1159  func TestAuditEntry_GetOrg(tt *testing.T) {
  1160  	var zeroValue string
  1161  	a := &AuditEntry{Org: &zeroValue}
  1162  	a.GetOrg()
  1163  	a = &AuditEntry{}
  1164  	a.GetOrg()
  1165  	a = nil
  1166  	a.GetOrg()
  1167  }
  1168  
  1169  func TestAuditEntry_GetPreviousVisibility(tt *testing.T) {
  1170  	var zeroValue string
  1171  	a := &AuditEntry{PreviousVisibility: &zeroValue}
  1172  	a.GetPreviousVisibility()
  1173  	a = &AuditEntry{}
  1174  	a.GetPreviousVisibility()
  1175  	a = nil
  1176  	a.GetPreviousVisibility()
  1177  }
  1178  
  1179  func TestAuditEntry_GetReadOnly(tt *testing.T) {
  1180  	var zeroValue string
  1181  	a := &AuditEntry{ReadOnly: &zeroValue}
  1182  	a.GetReadOnly()
  1183  	a = &AuditEntry{}
  1184  	a.GetReadOnly()
  1185  	a = nil
  1186  	a.GetReadOnly()
  1187  }
  1188  
  1189  func TestAuditEntry_GetRepo(tt *testing.T) {
  1190  	var zeroValue string
  1191  	a := &AuditEntry{Repo: &zeroValue}
  1192  	a.GetRepo()
  1193  	a = &AuditEntry{}
  1194  	a.GetRepo()
  1195  	a = nil
  1196  	a.GetRepo()
  1197  }
  1198  
  1199  func TestAuditEntry_GetRepository(tt *testing.T) {
  1200  	var zeroValue string
  1201  	a := &AuditEntry{Repository: &zeroValue}
  1202  	a.GetRepository()
  1203  	a = &AuditEntry{}
  1204  	a.GetRepository()
  1205  	a = nil
  1206  	a.GetRepository()
  1207  }
  1208  
  1209  func TestAuditEntry_GetRepositoryPublic(tt *testing.T) {
  1210  	var zeroValue bool
  1211  	a := &AuditEntry{RepositoryPublic: &zeroValue}
  1212  	a.GetRepositoryPublic()
  1213  	a = &AuditEntry{}
  1214  	a.GetRepositoryPublic()
  1215  	a = nil
  1216  	a.GetRepositoryPublic()
  1217  }
  1218  
  1219  func TestAuditEntry_GetRunAttempt(tt *testing.T) {
  1220  	var zeroValue int64
  1221  	a := &AuditEntry{RunAttempt: &zeroValue}
  1222  	a.GetRunAttempt()
  1223  	a = &AuditEntry{}
  1224  	a.GetRunAttempt()
  1225  	a = nil
  1226  	a.GetRunAttempt()
  1227  }
  1228  
  1229  func TestAuditEntry_GetRunnerGroupID(tt *testing.T) {
  1230  	var zeroValue int64
  1231  	a := &AuditEntry{RunnerGroupID: &zeroValue}
  1232  	a.GetRunnerGroupID()
  1233  	a = &AuditEntry{}
  1234  	a.GetRunnerGroupID()
  1235  	a = nil
  1236  	a.GetRunnerGroupID()
  1237  }
  1238  
  1239  func TestAuditEntry_GetRunnerGroupName(tt *testing.T) {
  1240  	var zeroValue string
  1241  	a := &AuditEntry{RunnerGroupName: &zeroValue}
  1242  	a.GetRunnerGroupName()
  1243  	a = &AuditEntry{}
  1244  	a.GetRunnerGroupName()
  1245  	a = nil
  1246  	a.GetRunnerGroupName()
  1247  }
  1248  
  1249  func TestAuditEntry_GetRunnerID(tt *testing.T) {
  1250  	var zeroValue int64
  1251  	a := &AuditEntry{RunnerID: &zeroValue}
  1252  	a.GetRunnerID()
  1253  	a = &AuditEntry{}
  1254  	a.GetRunnerID()
  1255  	a = nil
  1256  	a.GetRunnerID()
  1257  }
  1258  
  1259  func TestAuditEntry_GetRunnerName(tt *testing.T) {
  1260  	var zeroValue string
  1261  	a := &AuditEntry{RunnerName: &zeroValue}
  1262  	a.GetRunnerName()
  1263  	a = &AuditEntry{}
  1264  	a.GetRunnerName()
  1265  	a = nil
  1266  	a.GetRunnerName()
  1267  }
  1268  
  1269  func TestAuditEntry_GetSourceVersion(tt *testing.T) {
  1270  	var zeroValue string
  1271  	a := &AuditEntry{SourceVersion: &zeroValue}
  1272  	a.GetSourceVersion()
  1273  	a = &AuditEntry{}
  1274  	a.GetSourceVersion()
  1275  	a = nil
  1276  	a.GetSourceVersion()
  1277  }
  1278  
  1279  func TestAuditEntry_GetStartedAt(tt *testing.T) {
  1280  	var zeroValue Timestamp
  1281  	a := &AuditEntry{StartedAt: &zeroValue}
  1282  	a.GetStartedAt()
  1283  	a = &AuditEntry{}
  1284  	a.GetStartedAt()
  1285  	a = nil
  1286  	a.GetStartedAt()
  1287  }
  1288  
  1289  func TestAuditEntry_GetTargetLogin(tt *testing.T) {
  1290  	var zeroValue string
  1291  	a := &AuditEntry{TargetLogin: &zeroValue}
  1292  	a.GetTargetLogin()
  1293  	a = &AuditEntry{}
  1294  	a.GetTargetLogin()
  1295  	a = nil
  1296  	a.GetTargetLogin()
  1297  }
  1298  
  1299  func TestAuditEntry_GetTargetVersion(tt *testing.T) {
  1300  	var zeroValue string
  1301  	a := &AuditEntry{TargetVersion: &zeroValue}
  1302  	a.GetTargetVersion()
  1303  	a = &AuditEntry{}
  1304  	a.GetTargetVersion()
  1305  	a = nil
  1306  	a.GetTargetVersion()
  1307  }
  1308  
  1309  func TestAuditEntry_GetTeam(tt *testing.T) {
  1310  	var zeroValue string
  1311  	a := &AuditEntry{Team: &zeroValue}
  1312  	a.GetTeam()
  1313  	a = &AuditEntry{}
  1314  	a.GetTeam()
  1315  	a = nil
  1316  	a.GetTeam()
  1317  }
  1318  
  1319  func TestAuditEntry_GetTimestamp(tt *testing.T) {
  1320  	var zeroValue Timestamp
  1321  	a := &AuditEntry{Timestamp: &zeroValue}
  1322  	a.GetTimestamp()
  1323  	a = &AuditEntry{}
  1324  	a.GetTimestamp()
  1325  	a = nil
  1326  	a.GetTimestamp()
  1327  }
  1328  
  1329  func TestAuditEntry_GetTransportProtocol(tt *testing.T) {
  1330  	var zeroValue int
  1331  	a := &AuditEntry{TransportProtocol: &zeroValue}
  1332  	a.GetTransportProtocol()
  1333  	a = &AuditEntry{}
  1334  	a.GetTransportProtocol()
  1335  	a = nil
  1336  	a.GetTransportProtocol()
  1337  }
  1338  
  1339  func TestAuditEntry_GetTransportProtocolName(tt *testing.T) {
  1340  	var zeroValue string
  1341  	a := &AuditEntry{TransportProtocolName: &zeroValue}
  1342  	a.GetTransportProtocolName()
  1343  	a = &AuditEntry{}
  1344  	a.GetTransportProtocolName()
  1345  	a = nil
  1346  	a.GetTransportProtocolName()
  1347  }
  1348  
  1349  func TestAuditEntry_GetTriggerID(tt *testing.T) {
  1350  	var zeroValue int64
  1351  	a := &AuditEntry{TriggerID: &zeroValue}
  1352  	a.GetTriggerID()
  1353  	a = &AuditEntry{}
  1354  	a.GetTriggerID()
  1355  	a = nil
  1356  	a.GetTriggerID()
  1357  }
  1358  
  1359  func TestAuditEntry_GetUser(tt *testing.T) {
  1360  	var zeroValue string
  1361  	a := &AuditEntry{User: &zeroValue}
  1362  	a.GetUser()
  1363  	a = &AuditEntry{}
  1364  	a.GetUser()
  1365  	a = nil
  1366  	a.GetUser()
  1367  }
  1368  
  1369  func TestAuditEntry_GetVisibility(tt *testing.T) {
  1370  	var zeroValue string
  1371  	a := &AuditEntry{Visibility: &zeroValue}
  1372  	a.GetVisibility()
  1373  	a = &AuditEntry{}
  1374  	a.GetVisibility()
  1375  	a = nil
  1376  	a.GetVisibility()
  1377  }
  1378  
  1379  func TestAuditEntry_GetWorkflowID(tt *testing.T) {
  1380  	var zeroValue int64
  1381  	a := &AuditEntry{WorkflowID: &zeroValue}
  1382  	a.GetWorkflowID()
  1383  	a = &AuditEntry{}
  1384  	a.GetWorkflowID()
  1385  	a = nil
  1386  	a.GetWorkflowID()
  1387  }
  1388  
  1389  func TestAuditEntry_GetWorkflowRunID(tt *testing.T) {
  1390  	var zeroValue int64
  1391  	a := &AuditEntry{WorkflowRunID: &zeroValue}
  1392  	a.GetWorkflowRunID()
  1393  	a = &AuditEntry{}
  1394  	a.GetWorkflowRunID()
  1395  	a = nil
  1396  	a.GetWorkflowRunID()
  1397  }
  1398  
  1399  func TestAuthorization_GetApp(tt *testing.T) {
  1400  	a := &Authorization{}
  1401  	a.GetApp()
  1402  	a = nil
  1403  	a.GetApp()
  1404  }
  1405  
  1406  func TestAuthorization_GetCreatedAt(tt *testing.T) {
  1407  	var zeroValue Timestamp
  1408  	a := &Authorization{CreatedAt: &zeroValue}
  1409  	a.GetCreatedAt()
  1410  	a = &Authorization{}
  1411  	a.GetCreatedAt()
  1412  	a = nil
  1413  	a.GetCreatedAt()
  1414  }
  1415  
  1416  func TestAuthorization_GetFingerprint(tt *testing.T) {
  1417  	var zeroValue string
  1418  	a := &Authorization{Fingerprint: &zeroValue}
  1419  	a.GetFingerprint()
  1420  	a = &Authorization{}
  1421  	a.GetFingerprint()
  1422  	a = nil
  1423  	a.GetFingerprint()
  1424  }
  1425  
  1426  func TestAuthorization_GetHashedToken(tt *testing.T) {
  1427  	var zeroValue string
  1428  	a := &Authorization{HashedToken: &zeroValue}
  1429  	a.GetHashedToken()
  1430  	a = &Authorization{}
  1431  	a.GetHashedToken()
  1432  	a = nil
  1433  	a.GetHashedToken()
  1434  }
  1435  
  1436  func TestAuthorization_GetID(tt *testing.T) {
  1437  	var zeroValue int64
  1438  	a := &Authorization{ID: &zeroValue}
  1439  	a.GetID()
  1440  	a = &Authorization{}
  1441  	a.GetID()
  1442  	a = nil
  1443  	a.GetID()
  1444  }
  1445  
  1446  func TestAuthorization_GetNote(tt *testing.T) {
  1447  	var zeroValue string
  1448  	a := &Authorization{Note: &zeroValue}
  1449  	a.GetNote()
  1450  	a = &Authorization{}
  1451  	a.GetNote()
  1452  	a = nil
  1453  	a.GetNote()
  1454  }
  1455  
  1456  func TestAuthorization_GetNoteURL(tt *testing.T) {
  1457  	var zeroValue string
  1458  	a := &Authorization{NoteURL: &zeroValue}
  1459  	a.GetNoteURL()
  1460  	a = &Authorization{}
  1461  	a.GetNoteURL()
  1462  	a = nil
  1463  	a.GetNoteURL()
  1464  }
  1465  
  1466  func TestAuthorization_GetToken(tt *testing.T) {
  1467  	var zeroValue string
  1468  	a := &Authorization{Token: &zeroValue}
  1469  	a.GetToken()
  1470  	a = &Authorization{}
  1471  	a.GetToken()
  1472  	a = nil
  1473  	a.GetToken()
  1474  }
  1475  
  1476  func TestAuthorization_GetTokenLastEight(tt *testing.T) {
  1477  	var zeroValue string
  1478  	a := &Authorization{TokenLastEight: &zeroValue}
  1479  	a.GetTokenLastEight()
  1480  	a = &Authorization{}
  1481  	a.GetTokenLastEight()
  1482  	a = nil
  1483  	a.GetTokenLastEight()
  1484  }
  1485  
  1486  func TestAuthorization_GetUpdatedAt(tt *testing.T) {
  1487  	var zeroValue Timestamp
  1488  	a := &Authorization{UpdatedAt: &zeroValue}
  1489  	a.GetUpdatedAt()
  1490  	a = &Authorization{}
  1491  	a.GetUpdatedAt()
  1492  	a = nil
  1493  	a.GetUpdatedAt()
  1494  }
  1495  
  1496  func TestAuthorization_GetURL(tt *testing.T) {
  1497  	var zeroValue string
  1498  	a := &Authorization{URL: &zeroValue}
  1499  	a.GetURL()
  1500  	a = &Authorization{}
  1501  	a.GetURL()
  1502  	a = nil
  1503  	a.GetURL()
  1504  }
  1505  
  1506  func TestAuthorization_GetUser(tt *testing.T) {
  1507  	a := &Authorization{}
  1508  	a.GetUser()
  1509  	a = nil
  1510  	a.GetUser()
  1511  }
  1512  
  1513  func TestAuthorizationApp_GetClientID(tt *testing.T) {
  1514  	var zeroValue string
  1515  	a := &AuthorizationApp{ClientID: &zeroValue}
  1516  	a.GetClientID()
  1517  	a = &AuthorizationApp{}
  1518  	a.GetClientID()
  1519  	a = nil
  1520  	a.GetClientID()
  1521  }
  1522  
  1523  func TestAuthorizationApp_GetName(tt *testing.T) {
  1524  	var zeroValue string
  1525  	a := &AuthorizationApp{Name: &zeroValue}
  1526  	a.GetName()
  1527  	a = &AuthorizationApp{}
  1528  	a.GetName()
  1529  	a = nil
  1530  	a.GetName()
  1531  }
  1532  
  1533  func TestAuthorizationApp_GetURL(tt *testing.T) {
  1534  	var zeroValue string
  1535  	a := &AuthorizationApp{URL: &zeroValue}
  1536  	a.GetURL()
  1537  	a = &AuthorizationApp{}
  1538  	a.GetURL()
  1539  	a = nil
  1540  	a.GetURL()
  1541  }
  1542  
  1543  func TestAuthorizationRequest_GetClientID(tt *testing.T) {
  1544  	var zeroValue string
  1545  	a := &AuthorizationRequest{ClientID: &zeroValue}
  1546  	a.GetClientID()
  1547  	a = &AuthorizationRequest{}
  1548  	a.GetClientID()
  1549  	a = nil
  1550  	a.GetClientID()
  1551  }
  1552  
  1553  func TestAuthorizationRequest_GetClientSecret(tt *testing.T) {
  1554  	var zeroValue string
  1555  	a := &AuthorizationRequest{ClientSecret: &zeroValue}
  1556  	a.GetClientSecret()
  1557  	a = &AuthorizationRequest{}
  1558  	a.GetClientSecret()
  1559  	a = nil
  1560  	a.GetClientSecret()
  1561  }
  1562  
  1563  func TestAuthorizationRequest_GetFingerprint(tt *testing.T) {
  1564  	var zeroValue string
  1565  	a := &AuthorizationRequest{Fingerprint: &zeroValue}
  1566  	a.GetFingerprint()
  1567  	a = &AuthorizationRequest{}
  1568  	a.GetFingerprint()
  1569  	a = nil
  1570  	a.GetFingerprint()
  1571  }
  1572  
  1573  func TestAuthorizationRequest_GetNote(tt *testing.T) {
  1574  	var zeroValue string
  1575  	a := &AuthorizationRequest{Note: &zeroValue}
  1576  	a.GetNote()
  1577  	a = &AuthorizationRequest{}
  1578  	a.GetNote()
  1579  	a = nil
  1580  	a.GetNote()
  1581  }
  1582  
  1583  func TestAuthorizationRequest_GetNoteURL(tt *testing.T) {
  1584  	var zeroValue string
  1585  	a := &AuthorizationRequest{NoteURL: &zeroValue}
  1586  	a.GetNoteURL()
  1587  	a = &AuthorizationRequest{}
  1588  	a.GetNoteURL()
  1589  	a = nil
  1590  	a.GetNoteURL()
  1591  }
  1592  
  1593  func TestAuthorizationUpdateRequest_GetFingerprint(tt *testing.T) {
  1594  	var zeroValue string
  1595  	a := &AuthorizationUpdateRequest{Fingerprint: &zeroValue}
  1596  	a.GetFingerprint()
  1597  	a = &AuthorizationUpdateRequest{}
  1598  	a.GetFingerprint()
  1599  	a = nil
  1600  	a.GetFingerprint()
  1601  }
  1602  
  1603  func TestAuthorizationUpdateRequest_GetNote(tt *testing.T) {
  1604  	var zeroValue string
  1605  	a := &AuthorizationUpdateRequest{Note: &zeroValue}
  1606  	a.GetNote()
  1607  	a = &AuthorizationUpdateRequest{}
  1608  	a.GetNote()
  1609  	a = nil
  1610  	a.GetNote()
  1611  }
  1612  
  1613  func TestAuthorizationUpdateRequest_GetNoteURL(tt *testing.T) {
  1614  	var zeroValue string
  1615  	a := &AuthorizationUpdateRequest{NoteURL: &zeroValue}
  1616  	a.GetNoteURL()
  1617  	a = &AuthorizationUpdateRequest{}
  1618  	a.GetNoteURL()
  1619  	a = nil
  1620  	a.GetNoteURL()
  1621  }
  1622  
  1623  func TestAuthorizedActorsOnly_GetFrom(tt *testing.T) {
  1624  	var zeroValue bool
  1625  	a := &AuthorizedActorsOnly{From: &zeroValue}
  1626  	a.GetFrom()
  1627  	a = &AuthorizedActorsOnly{}
  1628  	a.GetFrom()
  1629  	a = nil
  1630  	a.GetFrom()
  1631  }
  1632  
  1633  func TestAutolink_GetID(tt *testing.T) {
  1634  	var zeroValue int64
  1635  	a := &Autolink{ID: &zeroValue}
  1636  	a.GetID()
  1637  	a = &Autolink{}
  1638  	a.GetID()
  1639  	a = nil
  1640  	a.GetID()
  1641  }
  1642  
  1643  func TestAutolink_GetIsAlphanumeric(tt *testing.T) {
  1644  	var zeroValue bool
  1645  	a := &Autolink{IsAlphanumeric: &zeroValue}
  1646  	a.GetIsAlphanumeric()
  1647  	a = &Autolink{}
  1648  	a.GetIsAlphanumeric()
  1649  	a = nil
  1650  	a.GetIsAlphanumeric()
  1651  }
  1652  
  1653  func TestAutolink_GetKeyPrefix(tt *testing.T) {
  1654  	var zeroValue string
  1655  	a := &Autolink{KeyPrefix: &zeroValue}
  1656  	a.GetKeyPrefix()
  1657  	a = &Autolink{}
  1658  	a.GetKeyPrefix()
  1659  	a = nil
  1660  	a.GetKeyPrefix()
  1661  }
  1662  
  1663  func TestAutolink_GetURLTemplate(tt *testing.T) {
  1664  	var zeroValue string
  1665  	a := &Autolink{URLTemplate: &zeroValue}
  1666  	a.GetURLTemplate()
  1667  	a = &Autolink{}
  1668  	a.GetURLTemplate()
  1669  	a = nil
  1670  	a.GetURLTemplate()
  1671  }
  1672  
  1673  func TestAutolinkOptions_GetIsAlphanumeric(tt *testing.T) {
  1674  	var zeroValue bool
  1675  	a := &AutolinkOptions{IsAlphanumeric: &zeroValue}
  1676  	a.GetIsAlphanumeric()
  1677  	a = &AutolinkOptions{}
  1678  	a.GetIsAlphanumeric()
  1679  	a = nil
  1680  	a.GetIsAlphanumeric()
  1681  }
  1682  
  1683  func TestAutolinkOptions_GetKeyPrefix(tt *testing.T) {
  1684  	var zeroValue string
  1685  	a := &AutolinkOptions{KeyPrefix: &zeroValue}
  1686  	a.GetKeyPrefix()
  1687  	a = &AutolinkOptions{}
  1688  	a.GetKeyPrefix()
  1689  	a = nil
  1690  	a.GetKeyPrefix()
  1691  }
  1692  
  1693  func TestAutolinkOptions_GetURLTemplate(tt *testing.T) {
  1694  	var zeroValue string
  1695  	a := &AutolinkOptions{URLTemplate: &zeroValue}
  1696  	a.GetURLTemplate()
  1697  	a = &AutolinkOptions{}
  1698  	a.GetURLTemplate()
  1699  	a = nil
  1700  	a.GetURLTemplate()
  1701  }
  1702  
  1703  func TestAutoTriggerCheck_GetAppID(tt *testing.T) {
  1704  	var zeroValue int64
  1705  	a := &AutoTriggerCheck{AppID: &zeroValue}
  1706  	a.GetAppID()
  1707  	a = &AutoTriggerCheck{}
  1708  	a.GetAppID()
  1709  	a = nil
  1710  	a.GetAppID()
  1711  }
  1712  
  1713  func TestAutoTriggerCheck_GetSetting(tt *testing.T) {
  1714  	var zeroValue bool
  1715  	a := &AutoTriggerCheck{Setting: &zeroValue}
  1716  	a.GetSetting()
  1717  	a = &AutoTriggerCheck{}
  1718  	a.GetSetting()
  1719  	a = nil
  1720  	a.GetSetting()
  1721  }
  1722  
  1723  func TestBlob_GetContent(tt *testing.T) {
  1724  	var zeroValue string
  1725  	b := &Blob{Content: &zeroValue}
  1726  	b.GetContent()
  1727  	b = &Blob{}
  1728  	b.GetContent()
  1729  	b = nil
  1730  	b.GetContent()
  1731  }
  1732  
  1733  func TestBlob_GetEncoding(tt *testing.T) {
  1734  	var zeroValue string
  1735  	b := &Blob{Encoding: &zeroValue}
  1736  	b.GetEncoding()
  1737  	b = &Blob{}
  1738  	b.GetEncoding()
  1739  	b = nil
  1740  	b.GetEncoding()
  1741  }
  1742  
  1743  func TestBlob_GetNodeID(tt *testing.T) {
  1744  	var zeroValue string
  1745  	b := &Blob{NodeID: &zeroValue}
  1746  	b.GetNodeID()
  1747  	b = &Blob{}
  1748  	b.GetNodeID()
  1749  	b = nil
  1750  	b.GetNodeID()
  1751  }
  1752  
  1753  func TestBlob_GetSHA(tt *testing.T) {
  1754  	var zeroValue string
  1755  	b := &Blob{SHA: &zeroValue}
  1756  	b.GetSHA()
  1757  	b = &Blob{}
  1758  	b.GetSHA()
  1759  	b = nil
  1760  	b.GetSHA()
  1761  }
  1762  
  1763  func TestBlob_GetSize(tt *testing.T) {
  1764  	var zeroValue int
  1765  	b := &Blob{Size: &zeroValue}
  1766  	b.GetSize()
  1767  	b = &Blob{}
  1768  	b.GetSize()
  1769  	b = nil
  1770  	b.GetSize()
  1771  }
  1772  
  1773  func TestBlob_GetURL(tt *testing.T) {
  1774  	var zeroValue string
  1775  	b := &Blob{URL: &zeroValue}
  1776  	b.GetURL()
  1777  	b = &Blob{}
  1778  	b.GetURL()
  1779  	b = nil
  1780  	b.GetURL()
  1781  }
  1782  
  1783  func TestBranch_GetCommit(tt *testing.T) {
  1784  	b := &Branch{}
  1785  	b.GetCommit()
  1786  	b = nil
  1787  	b.GetCommit()
  1788  }
  1789  
  1790  func TestBranch_GetName(tt *testing.T) {
  1791  	var zeroValue string
  1792  	b := &Branch{Name: &zeroValue}
  1793  	b.GetName()
  1794  	b = &Branch{}
  1795  	b.GetName()
  1796  	b = nil
  1797  	b.GetName()
  1798  }
  1799  
  1800  func TestBranch_GetProtected(tt *testing.T) {
  1801  	var zeroValue bool
  1802  	b := &Branch{Protected: &zeroValue}
  1803  	b.GetProtected()
  1804  	b = &Branch{}
  1805  	b.GetProtected()
  1806  	b = nil
  1807  	b.GetProtected()
  1808  }
  1809  
  1810  func TestBranchCommit_GetCommit(tt *testing.T) {
  1811  	b := &BranchCommit{}
  1812  	b.GetCommit()
  1813  	b = nil
  1814  	b.GetCommit()
  1815  }
  1816  
  1817  func TestBranchCommit_GetName(tt *testing.T) {
  1818  	var zeroValue string
  1819  	b := &BranchCommit{Name: &zeroValue}
  1820  	b.GetName()
  1821  	b = &BranchCommit{}
  1822  	b.GetName()
  1823  	b = nil
  1824  	b.GetName()
  1825  }
  1826  
  1827  func TestBranchCommit_GetProtected(tt *testing.T) {
  1828  	var zeroValue bool
  1829  	b := &BranchCommit{Protected: &zeroValue}
  1830  	b.GetProtected()
  1831  	b = &BranchCommit{}
  1832  	b.GetProtected()
  1833  	b = nil
  1834  	b.GetProtected()
  1835  }
  1836  
  1837  func TestBranchListOptions_GetProtected(tt *testing.T) {
  1838  	var zeroValue bool
  1839  	b := &BranchListOptions{Protected: &zeroValue}
  1840  	b.GetProtected()
  1841  	b = &BranchListOptions{}
  1842  	b.GetProtected()
  1843  	b = nil
  1844  	b.GetProtected()
  1845  }
  1846  
  1847  func TestBranchPolicy_GetCustomBranchPolicies(tt *testing.T) {
  1848  	var zeroValue bool
  1849  	b := &BranchPolicy{CustomBranchPolicies: &zeroValue}
  1850  	b.GetCustomBranchPolicies()
  1851  	b = &BranchPolicy{}
  1852  	b.GetCustomBranchPolicies()
  1853  	b = nil
  1854  	b.GetCustomBranchPolicies()
  1855  }
  1856  
  1857  func TestBranchPolicy_GetProtectedBranches(tt *testing.T) {
  1858  	var zeroValue bool
  1859  	b := &BranchPolicy{ProtectedBranches: &zeroValue}
  1860  	b.GetProtectedBranches()
  1861  	b = &BranchPolicy{}
  1862  	b.GetProtectedBranches()
  1863  	b = nil
  1864  	b.GetProtectedBranches()
  1865  }
  1866  
  1867  func TestBranchProtectionRule_GetAdminEnforced(tt *testing.T) {
  1868  	var zeroValue bool
  1869  	b := &BranchProtectionRule{AdminEnforced: &zeroValue}
  1870  	b.GetAdminEnforced()
  1871  	b = &BranchProtectionRule{}
  1872  	b.GetAdminEnforced()
  1873  	b = nil
  1874  	b.GetAdminEnforced()
  1875  }
  1876  
  1877  func TestBranchProtectionRule_GetAllowDeletionsEnforcementLevel(tt *testing.T) {
  1878  	var zeroValue string
  1879  	b := &BranchProtectionRule{AllowDeletionsEnforcementLevel: &zeroValue}
  1880  	b.GetAllowDeletionsEnforcementLevel()
  1881  	b = &BranchProtectionRule{}
  1882  	b.GetAllowDeletionsEnforcementLevel()
  1883  	b = nil
  1884  	b.GetAllowDeletionsEnforcementLevel()
  1885  }
  1886  
  1887  func TestBranchProtectionRule_GetAllowForcePushesEnforcementLevel(tt *testing.T) {
  1888  	var zeroValue string
  1889  	b := &BranchProtectionRule{AllowForcePushesEnforcementLevel: &zeroValue}
  1890  	b.GetAllowForcePushesEnforcementLevel()
  1891  	b = &BranchProtectionRule{}
  1892  	b.GetAllowForcePushesEnforcementLevel()
  1893  	b = nil
  1894  	b.GetAllowForcePushesEnforcementLevel()
  1895  }
  1896  
  1897  func TestBranchProtectionRule_GetAuthorizedActorsOnly(tt *testing.T) {
  1898  	var zeroValue bool
  1899  	b := &BranchProtectionRule{AuthorizedActorsOnly: &zeroValue}
  1900  	b.GetAuthorizedActorsOnly()
  1901  	b = &BranchProtectionRule{}
  1902  	b.GetAuthorizedActorsOnly()
  1903  	b = nil
  1904  	b.GetAuthorizedActorsOnly()
  1905  }
  1906  
  1907  func TestBranchProtectionRule_GetAuthorizedDismissalActorsOnly(tt *testing.T) {
  1908  	var zeroValue bool
  1909  	b := &BranchProtectionRule{AuthorizedDismissalActorsOnly: &zeroValue}
  1910  	b.GetAuthorizedDismissalActorsOnly()
  1911  	b = &BranchProtectionRule{}
  1912  	b.GetAuthorizedDismissalActorsOnly()
  1913  	b = nil
  1914  	b.GetAuthorizedDismissalActorsOnly()
  1915  }
  1916  
  1917  func TestBranchProtectionRule_GetCreatedAt(tt *testing.T) {
  1918  	var zeroValue Timestamp
  1919  	b := &BranchProtectionRule{CreatedAt: &zeroValue}
  1920  	b.GetCreatedAt()
  1921  	b = &BranchProtectionRule{}
  1922  	b.GetCreatedAt()
  1923  	b = nil
  1924  	b.GetCreatedAt()
  1925  }
  1926  
  1927  func TestBranchProtectionRule_GetDismissStaleReviewsOnPush(tt *testing.T) {
  1928  	var zeroValue bool
  1929  	b := &BranchProtectionRule{DismissStaleReviewsOnPush: &zeroValue}
  1930  	b.GetDismissStaleReviewsOnPush()
  1931  	b = &BranchProtectionRule{}
  1932  	b.GetDismissStaleReviewsOnPush()
  1933  	b = nil
  1934  	b.GetDismissStaleReviewsOnPush()
  1935  }
  1936  
  1937  func TestBranchProtectionRule_GetID(tt *testing.T) {
  1938  	var zeroValue int64
  1939  	b := &BranchProtectionRule{ID: &zeroValue}
  1940  	b.GetID()
  1941  	b = &BranchProtectionRule{}
  1942  	b.GetID()
  1943  	b = nil
  1944  	b.GetID()
  1945  }
  1946  
  1947  func TestBranchProtectionRule_GetIgnoreApprovalsFromContributors(tt *testing.T) {
  1948  	var zeroValue bool
  1949  	b := &BranchProtectionRule{IgnoreApprovalsFromContributors: &zeroValue}
  1950  	b.GetIgnoreApprovalsFromContributors()
  1951  	b = &BranchProtectionRule{}
  1952  	b.GetIgnoreApprovalsFromContributors()
  1953  	b = nil
  1954  	b.GetIgnoreApprovalsFromContributors()
  1955  }
  1956  
  1957  func TestBranchProtectionRule_GetLinearHistoryRequirementEnforcementLevel(tt *testing.T) {
  1958  	var zeroValue string
  1959  	b := &BranchProtectionRule{LinearHistoryRequirementEnforcementLevel: &zeroValue}
  1960  	b.GetLinearHistoryRequirementEnforcementLevel()
  1961  	b = &BranchProtectionRule{}
  1962  	b.GetLinearHistoryRequirementEnforcementLevel()
  1963  	b = nil
  1964  	b.GetLinearHistoryRequirementEnforcementLevel()
  1965  }
  1966  
  1967  func TestBranchProtectionRule_GetMergeQueueEnforcementLevel(tt *testing.T) {
  1968  	var zeroValue string
  1969  	b := &BranchProtectionRule{MergeQueueEnforcementLevel: &zeroValue}
  1970  	b.GetMergeQueueEnforcementLevel()
  1971  	b = &BranchProtectionRule{}
  1972  	b.GetMergeQueueEnforcementLevel()
  1973  	b = nil
  1974  	b.GetMergeQueueEnforcementLevel()
  1975  }
  1976  
  1977  func TestBranchProtectionRule_GetName(tt *testing.T) {
  1978  	var zeroValue string
  1979  	b := &BranchProtectionRule{Name: &zeroValue}
  1980  	b.GetName()
  1981  	b = &BranchProtectionRule{}
  1982  	b.GetName()
  1983  	b = nil
  1984  	b.GetName()
  1985  }
  1986  
  1987  func TestBranchProtectionRule_GetPullRequestReviewsEnforcementLevel(tt *testing.T) {
  1988  	var zeroValue string
  1989  	b := &BranchProtectionRule{PullRequestReviewsEnforcementLevel: &zeroValue}
  1990  	b.GetPullRequestReviewsEnforcementLevel()
  1991  	b = &BranchProtectionRule{}
  1992  	b.GetPullRequestReviewsEnforcementLevel()
  1993  	b = nil
  1994  	b.GetPullRequestReviewsEnforcementLevel()
  1995  }
  1996  
  1997  func TestBranchProtectionRule_GetRepositoryID(tt *testing.T) {
  1998  	var zeroValue int64
  1999  	b := &BranchProtectionRule{RepositoryID: &zeroValue}
  2000  	b.GetRepositoryID()
  2001  	b = &BranchProtectionRule{}
  2002  	b.GetRepositoryID()
  2003  	b = nil
  2004  	b.GetRepositoryID()
  2005  }
  2006  
  2007  func TestBranchProtectionRule_GetRequireCodeOwnerReview(tt *testing.T) {
  2008  	var zeroValue bool
  2009  	b := &BranchProtectionRule{RequireCodeOwnerReview: &zeroValue}
  2010  	b.GetRequireCodeOwnerReview()
  2011  	b = &BranchProtectionRule{}
  2012  	b.GetRequireCodeOwnerReview()
  2013  	b = nil
  2014  	b.GetRequireCodeOwnerReview()
  2015  }
  2016  
  2017  func TestBranchProtectionRule_GetRequiredApprovingReviewCount(tt *testing.T) {
  2018  	var zeroValue int
  2019  	b := &BranchProtectionRule{RequiredApprovingReviewCount: &zeroValue}
  2020  	b.GetRequiredApprovingReviewCount()
  2021  	b = &BranchProtectionRule{}
  2022  	b.GetRequiredApprovingReviewCount()
  2023  	b = nil
  2024  	b.GetRequiredApprovingReviewCount()
  2025  }
  2026  
  2027  func TestBranchProtectionRule_GetRequiredConversationResolutionLevel(tt *testing.T) {
  2028  	var zeroValue string
  2029  	b := &BranchProtectionRule{RequiredConversationResolutionLevel: &zeroValue}
  2030  	b.GetRequiredConversationResolutionLevel()
  2031  	b = &BranchProtectionRule{}
  2032  	b.GetRequiredConversationResolutionLevel()
  2033  	b = nil
  2034  	b.GetRequiredConversationResolutionLevel()
  2035  }
  2036  
  2037  func TestBranchProtectionRule_GetRequiredDeploymentsEnforcementLevel(tt *testing.T) {
  2038  	var zeroValue string
  2039  	b := &BranchProtectionRule{RequiredDeploymentsEnforcementLevel: &zeroValue}
  2040  	b.GetRequiredDeploymentsEnforcementLevel()
  2041  	b = &BranchProtectionRule{}
  2042  	b.GetRequiredDeploymentsEnforcementLevel()
  2043  	b = nil
  2044  	b.GetRequiredDeploymentsEnforcementLevel()
  2045  }
  2046  
  2047  func TestBranchProtectionRule_GetRequiredStatusChecksEnforcementLevel(tt *testing.T) {
  2048  	var zeroValue string
  2049  	b := &BranchProtectionRule{RequiredStatusChecksEnforcementLevel: &zeroValue}
  2050  	b.GetRequiredStatusChecksEnforcementLevel()
  2051  	b = &BranchProtectionRule{}
  2052  	b.GetRequiredStatusChecksEnforcementLevel()
  2053  	b = nil
  2054  	b.GetRequiredStatusChecksEnforcementLevel()
  2055  }
  2056  
  2057  func TestBranchProtectionRule_GetSignatureRequirementEnforcementLevel(tt *testing.T) {
  2058  	var zeroValue string
  2059  	b := &BranchProtectionRule{SignatureRequirementEnforcementLevel: &zeroValue}
  2060  	b.GetSignatureRequirementEnforcementLevel()
  2061  	b = &BranchProtectionRule{}
  2062  	b.GetSignatureRequirementEnforcementLevel()
  2063  	b = nil
  2064  	b.GetSignatureRequirementEnforcementLevel()
  2065  }
  2066  
  2067  func TestBranchProtectionRule_GetStrictRequiredStatusChecksPolicy(tt *testing.T) {
  2068  	var zeroValue bool
  2069  	b := &BranchProtectionRule{StrictRequiredStatusChecksPolicy: &zeroValue}
  2070  	b.GetStrictRequiredStatusChecksPolicy()
  2071  	b = &BranchProtectionRule{}
  2072  	b.GetStrictRequiredStatusChecksPolicy()
  2073  	b = nil
  2074  	b.GetStrictRequiredStatusChecksPolicy()
  2075  }
  2076  
  2077  func TestBranchProtectionRule_GetUpdatedAt(tt *testing.T) {
  2078  	var zeroValue Timestamp
  2079  	b := &BranchProtectionRule{UpdatedAt: &zeroValue}
  2080  	b.GetUpdatedAt()
  2081  	b = &BranchProtectionRule{}
  2082  	b.GetUpdatedAt()
  2083  	b = nil
  2084  	b.GetUpdatedAt()
  2085  }
  2086  
  2087  func TestBranchProtectionRuleEvent_GetAction(tt *testing.T) {
  2088  	var zeroValue string
  2089  	b := &BranchProtectionRuleEvent{Action: &zeroValue}
  2090  	b.GetAction()
  2091  	b = &BranchProtectionRuleEvent{}
  2092  	b.GetAction()
  2093  	b = nil
  2094  	b.GetAction()
  2095  }
  2096  
  2097  func TestBranchProtectionRuleEvent_GetChanges(tt *testing.T) {
  2098  	b := &BranchProtectionRuleEvent{}
  2099  	b.GetChanges()
  2100  	b = nil
  2101  	b.GetChanges()
  2102  }
  2103  
  2104  func TestBranchProtectionRuleEvent_GetInstallation(tt *testing.T) {
  2105  	b := &BranchProtectionRuleEvent{}
  2106  	b.GetInstallation()
  2107  	b = nil
  2108  	b.GetInstallation()
  2109  }
  2110  
  2111  func TestBranchProtectionRuleEvent_GetOrg(tt *testing.T) {
  2112  	b := &BranchProtectionRuleEvent{}
  2113  	b.GetOrg()
  2114  	b = nil
  2115  	b.GetOrg()
  2116  }
  2117  
  2118  func TestBranchProtectionRuleEvent_GetRepo(tt *testing.T) {
  2119  	b := &BranchProtectionRuleEvent{}
  2120  	b.GetRepo()
  2121  	b = nil
  2122  	b.GetRepo()
  2123  }
  2124  
  2125  func TestBranchProtectionRuleEvent_GetRule(tt *testing.T) {
  2126  	b := &BranchProtectionRuleEvent{}
  2127  	b.GetRule()
  2128  	b = nil
  2129  	b.GetRule()
  2130  }
  2131  
  2132  func TestBranchProtectionRuleEvent_GetSender(tt *testing.T) {
  2133  	b := &BranchProtectionRuleEvent{}
  2134  	b.GetSender()
  2135  	b = nil
  2136  	b.GetSender()
  2137  }
  2138  
  2139  func TestCheckRun_GetApp(tt *testing.T) {
  2140  	c := &CheckRun{}
  2141  	c.GetApp()
  2142  	c = nil
  2143  	c.GetApp()
  2144  }
  2145  
  2146  func TestCheckRun_GetCheckSuite(tt *testing.T) {
  2147  	c := &CheckRun{}
  2148  	c.GetCheckSuite()
  2149  	c = nil
  2150  	c.GetCheckSuite()
  2151  }
  2152  
  2153  func TestCheckRun_GetCompletedAt(tt *testing.T) {
  2154  	var zeroValue Timestamp
  2155  	c := &CheckRun{CompletedAt: &zeroValue}
  2156  	c.GetCompletedAt()
  2157  	c = &CheckRun{}
  2158  	c.GetCompletedAt()
  2159  	c = nil
  2160  	c.GetCompletedAt()
  2161  }
  2162  
  2163  func TestCheckRun_GetConclusion(tt *testing.T) {
  2164  	var zeroValue string
  2165  	c := &CheckRun{Conclusion: &zeroValue}
  2166  	c.GetConclusion()
  2167  	c = &CheckRun{}
  2168  	c.GetConclusion()
  2169  	c = nil
  2170  	c.GetConclusion()
  2171  }
  2172  
  2173  func TestCheckRun_GetDetailsURL(tt *testing.T) {
  2174  	var zeroValue string
  2175  	c := &CheckRun{DetailsURL: &zeroValue}
  2176  	c.GetDetailsURL()
  2177  	c = &CheckRun{}
  2178  	c.GetDetailsURL()
  2179  	c = nil
  2180  	c.GetDetailsURL()
  2181  }
  2182  
  2183  func TestCheckRun_GetExternalID(tt *testing.T) {
  2184  	var zeroValue string
  2185  	c := &CheckRun{ExternalID: &zeroValue}
  2186  	c.GetExternalID()
  2187  	c = &CheckRun{}
  2188  	c.GetExternalID()
  2189  	c = nil
  2190  	c.GetExternalID()
  2191  }
  2192  
  2193  func TestCheckRun_GetHeadSHA(tt *testing.T) {
  2194  	var zeroValue string
  2195  	c := &CheckRun{HeadSHA: &zeroValue}
  2196  	c.GetHeadSHA()
  2197  	c = &CheckRun{}
  2198  	c.GetHeadSHA()
  2199  	c = nil
  2200  	c.GetHeadSHA()
  2201  }
  2202  
  2203  func TestCheckRun_GetHTMLURL(tt *testing.T) {
  2204  	var zeroValue string
  2205  	c := &CheckRun{HTMLURL: &zeroValue}
  2206  	c.GetHTMLURL()
  2207  	c = &CheckRun{}
  2208  	c.GetHTMLURL()
  2209  	c = nil
  2210  	c.GetHTMLURL()
  2211  }
  2212  
  2213  func TestCheckRun_GetID(tt *testing.T) {
  2214  	var zeroValue int64
  2215  	c := &CheckRun{ID: &zeroValue}
  2216  	c.GetID()
  2217  	c = &CheckRun{}
  2218  	c.GetID()
  2219  	c = nil
  2220  	c.GetID()
  2221  }
  2222  
  2223  func TestCheckRun_GetName(tt *testing.T) {
  2224  	var zeroValue string
  2225  	c := &CheckRun{Name: &zeroValue}
  2226  	c.GetName()
  2227  	c = &CheckRun{}
  2228  	c.GetName()
  2229  	c = nil
  2230  	c.GetName()
  2231  }
  2232  
  2233  func TestCheckRun_GetNodeID(tt *testing.T) {
  2234  	var zeroValue string
  2235  	c := &CheckRun{NodeID: &zeroValue}
  2236  	c.GetNodeID()
  2237  	c = &CheckRun{}
  2238  	c.GetNodeID()
  2239  	c = nil
  2240  	c.GetNodeID()
  2241  }
  2242  
  2243  func TestCheckRun_GetOutput(tt *testing.T) {
  2244  	c := &CheckRun{}
  2245  	c.GetOutput()
  2246  	c = nil
  2247  	c.GetOutput()
  2248  }
  2249  
  2250  func TestCheckRun_GetStartedAt(tt *testing.T) {
  2251  	var zeroValue Timestamp
  2252  	c := &CheckRun{StartedAt: &zeroValue}
  2253  	c.GetStartedAt()
  2254  	c = &CheckRun{}
  2255  	c.GetStartedAt()
  2256  	c = nil
  2257  	c.GetStartedAt()
  2258  }
  2259  
  2260  func TestCheckRun_GetStatus(tt *testing.T) {
  2261  	var zeroValue string
  2262  	c := &CheckRun{Status: &zeroValue}
  2263  	c.GetStatus()
  2264  	c = &CheckRun{}
  2265  	c.GetStatus()
  2266  	c = nil
  2267  	c.GetStatus()
  2268  }
  2269  
  2270  func TestCheckRun_GetURL(tt *testing.T) {
  2271  	var zeroValue string
  2272  	c := &CheckRun{URL: &zeroValue}
  2273  	c.GetURL()
  2274  	c = &CheckRun{}
  2275  	c.GetURL()
  2276  	c = nil
  2277  	c.GetURL()
  2278  }
  2279  
  2280  func TestCheckRunAnnotation_GetAnnotationLevel(tt *testing.T) {
  2281  	var zeroValue string
  2282  	c := &CheckRunAnnotation{AnnotationLevel: &zeroValue}
  2283  	c.GetAnnotationLevel()
  2284  	c = &CheckRunAnnotation{}
  2285  	c.GetAnnotationLevel()
  2286  	c = nil
  2287  	c.GetAnnotationLevel()
  2288  }
  2289  
  2290  func TestCheckRunAnnotation_GetEndColumn(tt *testing.T) {
  2291  	var zeroValue int
  2292  	c := &CheckRunAnnotation{EndColumn: &zeroValue}
  2293  	c.GetEndColumn()
  2294  	c = &CheckRunAnnotation{}
  2295  	c.GetEndColumn()
  2296  	c = nil
  2297  	c.GetEndColumn()
  2298  }
  2299  
  2300  func TestCheckRunAnnotation_GetEndLine(tt *testing.T) {
  2301  	var zeroValue int
  2302  	c := &CheckRunAnnotation{EndLine: &zeroValue}
  2303  	c.GetEndLine()
  2304  	c = &CheckRunAnnotation{}
  2305  	c.GetEndLine()
  2306  	c = nil
  2307  	c.GetEndLine()
  2308  }
  2309  
  2310  func TestCheckRunAnnotation_GetMessage(tt *testing.T) {
  2311  	var zeroValue string
  2312  	c := &CheckRunAnnotation{Message: &zeroValue}
  2313  	c.GetMessage()
  2314  	c = &CheckRunAnnotation{}
  2315  	c.GetMessage()
  2316  	c = nil
  2317  	c.GetMessage()
  2318  }
  2319  
  2320  func TestCheckRunAnnotation_GetPath(tt *testing.T) {
  2321  	var zeroValue string
  2322  	c := &CheckRunAnnotation{Path: &zeroValue}
  2323  	c.GetPath()
  2324  	c = &CheckRunAnnotation{}
  2325  	c.GetPath()
  2326  	c = nil
  2327  	c.GetPath()
  2328  }
  2329  
  2330  func TestCheckRunAnnotation_GetRawDetails(tt *testing.T) {
  2331  	var zeroValue string
  2332  	c := &CheckRunAnnotation{RawDetails: &zeroValue}
  2333  	c.GetRawDetails()
  2334  	c = &CheckRunAnnotation{}
  2335  	c.GetRawDetails()
  2336  	c = nil
  2337  	c.GetRawDetails()
  2338  }
  2339  
  2340  func TestCheckRunAnnotation_GetStartColumn(tt *testing.T) {
  2341  	var zeroValue int
  2342  	c := &CheckRunAnnotation{StartColumn: &zeroValue}
  2343  	c.GetStartColumn()
  2344  	c = &CheckRunAnnotation{}
  2345  	c.GetStartColumn()
  2346  	c = nil
  2347  	c.GetStartColumn()
  2348  }
  2349  
  2350  func TestCheckRunAnnotation_GetStartLine(tt *testing.T) {
  2351  	var zeroValue int
  2352  	c := &CheckRunAnnotation{StartLine: &zeroValue}
  2353  	c.GetStartLine()
  2354  	c = &CheckRunAnnotation{}
  2355  	c.GetStartLine()
  2356  	c = nil
  2357  	c.GetStartLine()
  2358  }
  2359  
  2360  func TestCheckRunAnnotation_GetTitle(tt *testing.T) {
  2361  	var zeroValue string
  2362  	c := &CheckRunAnnotation{Title: &zeroValue}
  2363  	c.GetTitle()
  2364  	c = &CheckRunAnnotation{}
  2365  	c.GetTitle()
  2366  	c = nil
  2367  	c.GetTitle()
  2368  }
  2369  
  2370  func TestCheckRunEvent_GetAction(tt *testing.T) {
  2371  	var zeroValue string
  2372  	c := &CheckRunEvent{Action: &zeroValue}
  2373  	c.GetAction()
  2374  	c = &CheckRunEvent{}
  2375  	c.GetAction()
  2376  	c = nil
  2377  	c.GetAction()
  2378  }
  2379  
  2380  func TestCheckRunEvent_GetCheckRun(tt *testing.T) {
  2381  	c := &CheckRunEvent{}
  2382  	c.GetCheckRun()
  2383  	c = nil
  2384  	c.GetCheckRun()
  2385  }
  2386  
  2387  func TestCheckRunEvent_GetInstallation(tt *testing.T) {
  2388  	c := &CheckRunEvent{}
  2389  	c.GetInstallation()
  2390  	c = nil
  2391  	c.GetInstallation()
  2392  }
  2393  
  2394  func TestCheckRunEvent_GetOrg(tt *testing.T) {
  2395  	c := &CheckRunEvent{}
  2396  	c.GetOrg()
  2397  	c = nil
  2398  	c.GetOrg()
  2399  }
  2400  
  2401  func TestCheckRunEvent_GetRepo(tt *testing.T) {
  2402  	c := &CheckRunEvent{}
  2403  	c.GetRepo()
  2404  	c = nil
  2405  	c.GetRepo()
  2406  }
  2407  
  2408  func TestCheckRunEvent_GetRequestedAction(tt *testing.T) {
  2409  	c := &CheckRunEvent{}
  2410  	c.GetRequestedAction()
  2411  	c = nil
  2412  	c.GetRequestedAction()
  2413  }
  2414  
  2415  func TestCheckRunEvent_GetSender(tt *testing.T) {
  2416  	c := &CheckRunEvent{}
  2417  	c.GetSender()
  2418  	c = nil
  2419  	c.GetSender()
  2420  }
  2421  
  2422  func TestCheckRunImage_GetAlt(tt *testing.T) {
  2423  	var zeroValue string
  2424  	c := &CheckRunImage{Alt: &zeroValue}
  2425  	c.GetAlt()
  2426  	c = &CheckRunImage{}
  2427  	c.GetAlt()
  2428  	c = nil
  2429  	c.GetAlt()
  2430  }
  2431  
  2432  func TestCheckRunImage_GetCaption(tt *testing.T) {
  2433  	var zeroValue string
  2434  	c := &CheckRunImage{Caption: &zeroValue}
  2435  	c.GetCaption()
  2436  	c = &CheckRunImage{}
  2437  	c.GetCaption()
  2438  	c = nil
  2439  	c.GetCaption()
  2440  }
  2441  
  2442  func TestCheckRunImage_GetImageURL(tt *testing.T) {
  2443  	var zeroValue string
  2444  	c := &CheckRunImage{ImageURL: &zeroValue}
  2445  	c.GetImageURL()
  2446  	c = &CheckRunImage{}
  2447  	c.GetImageURL()
  2448  	c = nil
  2449  	c.GetImageURL()
  2450  }
  2451  
  2452  func TestCheckRunOutput_GetAnnotationsCount(tt *testing.T) {
  2453  	var zeroValue int
  2454  	c := &CheckRunOutput{AnnotationsCount: &zeroValue}
  2455  	c.GetAnnotationsCount()
  2456  	c = &CheckRunOutput{}
  2457  	c.GetAnnotationsCount()
  2458  	c = nil
  2459  	c.GetAnnotationsCount()
  2460  }
  2461  
  2462  func TestCheckRunOutput_GetAnnotationsURL(tt *testing.T) {
  2463  	var zeroValue string
  2464  	c := &CheckRunOutput{AnnotationsURL: &zeroValue}
  2465  	c.GetAnnotationsURL()
  2466  	c = &CheckRunOutput{}
  2467  	c.GetAnnotationsURL()
  2468  	c = nil
  2469  	c.GetAnnotationsURL()
  2470  }
  2471  
  2472  func TestCheckRunOutput_GetSummary(tt *testing.T) {
  2473  	var zeroValue string
  2474  	c := &CheckRunOutput{Summary: &zeroValue}
  2475  	c.GetSummary()
  2476  	c = &CheckRunOutput{}
  2477  	c.GetSummary()
  2478  	c = nil
  2479  	c.GetSummary()
  2480  }
  2481  
  2482  func TestCheckRunOutput_GetText(tt *testing.T) {
  2483  	var zeroValue string
  2484  	c := &CheckRunOutput{Text: &zeroValue}
  2485  	c.GetText()
  2486  	c = &CheckRunOutput{}
  2487  	c.GetText()
  2488  	c = nil
  2489  	c.GetText()
  2490  }
  2491  
  2492  func TestCheckRunOutput_GetTitle(tt *testing.T) {
  2493  	var zeroValue string
  2494  	c := &CheckRunOutput{Title: &zeroValue}
  2495  	c.GetTitle()
  2496  	c = &CheckRunOutput{}
  2497  	c.GetTitle()
  2498  	c = nil
  2499  	c.GetTitle()
  2500  }
  2501  
  2502  func TestCheckSuite_GetAfterSHA(tt *testing.T) {
  2503  	var zeroValue string
  2504  	c := &CheckSuite{AfterSHA: &zeroValue}
  2505  	c.GetAfterSHA()
  2506  	c = &CheckSuite{}
  2507  	c.GetAfterSHA()
  2508  	c = nil
  2509  	c.GetAfterSHA()
  2510  }
  2511  
  2512  func TestCheckSuite_GetApp(tt *testing.T) {
  2513  	c := &CheckSuite{}
  2514  	c.GetApp()
  2515  	c = nil
  2516  	c.GetApp()
  2517  }
  2518  
  2519  func TestCheckSuite_GetBeforeSHA(tt *testing.T) {
  2520  	var zeroValue string
  2521  	c := &CheckSuite{BeforeSHA: &zeroValue}
  2522  	c.GetBeforeSHA()
  2523  	c = &CheckSuite{}
  2524  	c.GetBeforeSHA()
  2525  	c = nil
  2526  	c.GetBeforeSHA()
  2527  }
  2528  
  2529  func TestCheckSuite_GetConclusion(tt *testing.T) {
  2530  	var zeroValue string
  2531  	c := &CheckSuite{Conclusion: &zeroValue}
  2532  	c.GetConclusion()
  2533  	c = &CheckSuite{}
  2534  	c.GetConclusion()
  2535  	c = nil
  2536  	c.GetConclusion()
  2537  }
  2538  
  2539  func TestCheckSuite_GetCreatedAt(tt *testing.T) {
  2540  	var zeroValue Timestamp
  2541  	c := &CheckSuite{CreatedAt: &zeroValue}
  2542  	c.GetCreatedAt()
  2543  	c = &CheckSuite{}
  2544  	c.GetCreatedAt()
  2545  	c = nil
  2546  	c.GetCreatedAt()
  2547  }
  2548  
  2549  func TestCheckSuite_GetHeadBranch(tt *testing.T) {
  2550  	var zeroValue string
  2551  	c := &CheckSuite{HeadBranch: &zeroValue}
  2552  	c.GetHeadBranch()
  2553  	c = &CheckSuite{}
  2554  	c.GetHeadBranch()
  2555  	c = nil
  2556  	c.GetHeadBranch()
  2557  }
  2558  
  2559  func TestCheckSuite_GetHeadCommit(tt *testing.T) {
  2560  	c := &CheckSuite{}
  2561  	c.GetHeadCommit()
  2562  	c = nil
  2563  	c.GetHeadCommit()
  2564  }
  2565  
  2566  func TestCheckSuite_GetHeadSHA(tt *testing.T) {
  2567  	var zeroValue string
  2568  	c := &CheckSuite{HeadSHA: &zeroValue}
  2569  	c.GetHeadSHA()
  2570  	c = &CheckSuite{}
  2571  	c.GetHeadSHA()
  2572  	c = nil
  2573  	c.GetHeadSHA()
  2574  }
  2575  
  2576  func TestCheckSuite_GetID(tt *testing.T) {
  2577  	var zeroValue int64
  2578  	c := &CheckSuite{ID: &zeroValue}
  2579  	c.GetID()
  2580  	c = &CheckSuite{}
  2581  	c.GetID()
  2582  	c = nil
  2583  	c.GetID()
  2584  }
  2585  
  2586  func TestCheckSuite_GetNodeID(tt *testing.T) {
  2587  	var zeroValue string
  2588  	c := &CheckSuite{NodeID: &zeroValue}
  2589  	c.GetNodeID()
  2590  	c = &CheckSuite{}
  2591  	c.GetNodeID()
  2592  	c = nil
  2593  	c.GetNodeID()
  2594  }
  2595  
  2596  func TestCheckSuite_GetRepository(tt *testing.T) {
  2597  	c := &CheckSuite{}
  2598  	c.GetRepository()
  2599  	c = nil
  2600  	c.GetRepository()
  2601  }
  2602  
  2603  func TestCheckSuite_GetStatus(tt *testing.T) {
  2604  	var zeroValue string
  2605  	c := &CheckSuite{Status: &zeroValue}
  2606  	c.GetStatus()
  2607  	c = &CheckSuite{}
  2608  	c.GetStatus()
  2609  	c = nil
  2610  	c.GetStatus()
  2611  }
  2612  
  2613  func TestCheckSuite_GetUpdatedAt(tt *testing.T) {
  2614  	var zeroValue Timestamp
  2615  	c := &CheckSuite{UpdatedAt: &zeroValue}
  2616  	c.GetUpdatedAt()
  2617  	c = &CheckSuite{}
  2618  	c.GetUpdatedAt()
  2619  	c = nil
  2620  	c.GetUpdatedAt()
  2621  }
  2622  
  2623  func TestCheckSuite_GetURL(tt *testing.T) {
  2624  	var zeroValue string
  2625  	c := &CheckSuite{URL: &zeroValue}
  2626  	c.GetURL()
  2627  	c = &CheckSuite{}
  2628  	c.GetURL()
  2629  	c = nil
  2630  	c.GetURL()
  2631  }
  2632  
  2633  func TestCheckSuiteEvent_GetAction(tt *testing.T) {
  2634  	var zeroValue string
  2635  	c := &CheckSuiteEvent{Action: &zeroValue}
  2636  	c.GetAction()
  2637  	c = &CheckSuiteEvent{}
  2638  	c.GetAction()
  2639  	c = nil
  2640  	c.GetAction()
  2641  }
  2642  
  2643  func TestCheckSuiteEvent_GetCheckSuite(tt *testing.T) {
  2644  	c := &CheckSuiteEvent{}
  2645  	c.GetCheckSuite()
  2646  	c = nil
  2647  	c.GetCheckSuite()
  2648  }
  2649  
  2650  func TestCheckSuiteEvent_GetInstallation(tt *testing.T) {
  2651  	c := &CheckSuiteEvent{}
  2652  	c.GetInstallation()
  2653  	c = nil
  2654  	c.GetInstallation()
  2655  }
  2656  
  2657  func TestCheckSuiteEvent_GetOrg(tt *testing.T) {
  2658  	c := &CheckSuiteEvent{}
  2659  	c.GetOrg()
  2660  	c = nil
  2661  	c.GetOrg()
  2662  }
  2663  
  2664  func TestCheckSuiteEvent_GetRepo(tt *testing.T) {
  2665  	c := &CheckSuiteEvent{}
  2666  	c.GetRepo()
  2667  	c = nil
  2668  	c.GetRepo()
  2669  }
  2670  
  2671  func TestCheckSuiteEvent_GetSender(tt *testing.T) {
  2672  	c := &CheckSuiteEvent{}
  2673  	c.GetSender()
  2674  	c = nil
  2675  	c.GetSender()
  2676  }
  2677  
  2678  func TestCheckSuitePreferenceResults_GetPreferences(tt *testing.T) {
  2679  	c := &CheckSuitePreferenceResults{}
  2680  	c.GetPreferences()
  2681  	c = nil
  2682  	c.GetPreferences()
  2683  }
  2684  
  2685  func TestCheckSuitePreferenceResults_GetRepository(tt *testing.T) {
  2686  	c := &CheckSuitePreferenceResults{}
  2687  	c.GetRepository()
  2688  	c = nil
  2689  	c.GetRepository()
  2690  }
  2691  
  2692  func TestCodeOfConduct_GetBody(tt *testing.T) {
  2693  	var zeroValue string
  2694  	c := &CodeOfConduct{Body: &zeroValue}
  2695  	c.GetBody()
  2696  	c = &CodeOfConduct{}
  2697  	c.GetBody()
  2698  	c = nil
  2699  	c.GetBody()
  2700  }
  2701  
  2702  func TestCodeOfConduct_GetKey(tt *testing.T) {
  2703  	var zeroValue string
  2704  	c := &CodeOfConduct{Key: &zeroValue}
  2705  	c.GetKey()
  2706  	c = &CodeOfConduct{}
  2707  	c.GetKey()
  2708  	c = nil
  2709  	c.GetKey()
  2710  }
  2711  
  2712  func TestCodeOfConduct_GetName(tt *testing.T) {
  2713  	var zeroValue string
  2714  	c := &CodeOfConduct{Name: &zeroValue}
  2715  	c.GetName()
  2716  	c = &CodeOfConduct{}
  2717  	c.GetName()
  2718  	c = nil
  2719  	c.GetName()
  2720  }
  2721  
  2722  func TestCodeOfConduct_GetURL(tt *testing.T) {
  2723  	var zeroValue string
  2724  	c := &CodeOfConduct{URL: &zeroValue}
  2725  	c.GetURL()
  2726  	c = &CodeOfConduct{}
  2727  	c.GetURL()
  2728  	c = nil
  2729  	c.GetURL()
  2730  }
  2731  
  2732  func TestCodeownersError_GetSuggestion(tt *testing.T) {
  2733  	var zeroValue string
  2734  	c := &CodeownersError{Suggestion: &zeroValue}
  2735  	c.GetSuggestion()
  2736  	c = &CodeownersError{}
  2737  	c.GetSuggestion()
  2738  	c = nil
  2739  	c.GetSuggestion()
  2740  }
  2741  
  2742  func TestCodeResult_GetHTMLURL(tt *testing.T) {
  2743  	var zeroValue string
  2744  	c := &CodeResult{HTMLURL: &zeroValue}
  2745  	c.GetHTMLURL()
  2746  	c = &CodeResult{}
  2747  	c.GetHTMLURL()
  2748  	c = nil
  2749  	c.GetHTMLURL()
  2750  }
  2751  
  2752  func TestCodeResult_GetName(tt *testing.T) {
  2753  	var zeroValue string
  2754  	c := &CodeResult{Name: &zeroValue}
  2755  	c.GetName()
  2756  	c = &CodeResult{}
  2757  	c.GetName()
  2758  	c = nil
  2759  	c.GetName()
  2760  }
  2761  
  2762  func TestCodeResult_GetPath(tt *testing.T) {
  2763  	var zeroValue string
  2764  	c := &CodeResult{Path: &zeroValue}
  2765  	c.GetPath()
  2766  	c = &CodeResult{}
  2767  	c.GetPath()
  2768  	c = nil
  2769  	c.GetPath()
  2770  }
  2771  
  2772  func TestCodeResult_GetRepository(tt *testing.T) {
  2773  	c := &CodeResult{}
  2774  	c.GetRepository()
  2775  	c = nil
  2776  	c.GetRepository()
  2777  }
  2778  
  2779  func TestCodeResult_GetSHA(tt *testing.T) {
  2780  	var zeroValue string
  2781  	c := &CodeResult{SHA: &zeroValue}
  2782  	c.GetSHA()
  2783  	c = &CodeResult{}
  2784  	c.GetSHA()
  2785  	c = nil
  2786  	c.GetSHA()
  2787  }
  2788  
  2789  func TestCodeScanningAlertEvent_GetAction(tt *testing.T) {
  2790  	var zeroValue string
  2791  	c := &CodeScanningAlertEvent{Action: &zeroValue}
  2792  	c.GetAction()
  2793  	c = &CodeScanningAlertEvent{}
  2794  	c.GetAction()
  2795  	c = nil
  2796  	c.GetAction()
  2797  }
  2798  
  2799  func TestCodeScanningAlertEvent_GetAlert(tt *testing.T) {
  2800  	c := &CodeScanningAlertEvent{}
  2801  	c.GetAlert()
  2802  	c = nil
  2803  	c.GetAlert()
  2804  }
  2805  
  2806  func TestCodeScanningAlertEvent_GetCommitOID(tt *testing.T) {
  2807  	var zeroValue string
  2808  	c := &CodeScanningAlertEvent{CommitOID: &zeroValue}
  2809  	c.GetCommitOID()
  2810  	c = &CodeScanningAlertEvent{}
  2811  	c.GetCommitOID()
  2812  	c = nil
  2813  	c.GetCommitOID()
  2814  }
  2815  
  2816  func TestCodeScanningAlertEvent_GetOrg(tt *testing.T) {
  2817  	c := &CodeScanningAlertEvent{}
  2818  	c.GetOrg()
  2819  	c = nil
  2820  	c.GetOrg()
  2821  }
  2822  
  2823  func TestCodeScanningAlertEvent_GetRef(tt *testing.T) {
  2824  	var zeroValue string
  2825  	c := &CodeScanningAlertEvent{Ref: &zeroValue}
  2826  	c.GetRef()
  2827  	c = &CodeScanningAlertEvent{}
  2828  	c.GetRef()
  2829  	c = nil
  2830  	c.GetRef()
  2831  }
  2832  
  2833  func TestCodeScanningAlertEvent_GetRepo(tt *testing.T) {
  2834  	c := &CodeScanningAlertEvent{}
  2835  	c.GetRepo()
  2836  	c = nil
  2837  	c.GetRepo()
  2838  }
  2839  
  2840  func TestCodeScanningAlertEvent_GetSender(tt *testing.T) {
  2841  	c := &CodeScanningAlertEvent{}
  2842  	c.GetSender()
  2843  	c = nil
  2844  	c.GetSender()
  2845  }
  2846  
  2847  func TestCodeSearchResult_GetIncompleteResults(tt *testing.T) {
  2848  	var zeroValue bool
  2849  	c := &CodeSearchResult{IncompleteResults: &zeroValue}
  2850  	c.GetIncompleteResults()
  2851  	c = &CodeSearchResult{}
  2852  	c.GetIncompleteResults()
  2853  	c = nil
  2854  	c.GetIncompleteResults()
  2855  }
  2856  
  2857  func TestCodeSearchResult_GetTotal(tt *testing.T) {
  2858  	var zeroValue int
  2859  	c := &CodeSearchResult{Total: &zeroValue}
  2860  	c.GetTotal()
  2861  	c = &CodeSearchResult{}
  2862  	c.GetTotal()
  2863  	c = nil
  2864  	c.GetTotal()
  2865  }
  2866  
  2867  func TestCollaboratorInvitation_GetCreatedAt(tt *testing.T) {
  2868  	var zeroValue Timestamp
  2869  	c := &CollaboratorInvitation{CreatedAt: &zeroValue}
  2870  	c.GetCreatedAt()
  2871  	c = &CollaboratorInvitation{}
  2872  	c.GetCreatedAt()
  2873  	c = nil
  2874  	c.GetCreatedAt()
  2875  }
  2876  
  2877  func TestCollaboratorInvitation_GetHTMLURL(tt *testing.T) {
  2878  	var zeroValue string
  2879  	c := &CollaboratorInvitation{HTMLURL: &zeroValue}
  2880  	c.GetHTMLURL()
  2881  	c = &CollaboratorInvitation{}
  2882  	c.GetHTMLURL()
  2883  	c = nil
  2884  	c.GetHTMLURL()
  2885  }
  2886  
  2887  func TestCollaboratorInvitation_GetID(tt *testing.T) {
  2888  	var zeroValue int64
  2889  	c := &CollaboratorInvitation{ID: &zeroValue}
  2890  	c.GetID()
  2891  	c = &CollaboratorInvitation{}
  2892  	c.GetID()
  2893  	c = nil
  2894  	c.GetID()
  2895  }
  2896  
  2897  func TestCollaboratorInvitation_GetInvitee(tt *testing.T) {
  2898  	c := &CollaboratorInvitation{}
  2899  	c.GetInvitee()
  2900  	c = nil
  2901  	c.GetInvitee()
  2902  }
  2903  
  2904  func TestCollaboratorInvitation_GetInviter(tt *testing.T) {
  2905  	c := &CollaboratorInvitation{}
  2906  	c.GetInviter()
  2907  	c = nil
  2908  	c.GetInviter()
  2909  }
  2910  
  2911  func TestCollaboratorInvitation_GetPermissions(tt *testing.T) {
  2912  	var zeroValue string
  2913  	c := &CollaboratorInvitation{Permissions: &zeroValue}
  2914  	c.GetPermissions()
  2915  	c = &CollaboratorInvitation{}
  2916  	c.GetPermissions()
  2917  	c = nil
  2918  	c.GetPermissions()
  2919  }
  2920  
  2921  func TestCollaboratorInvitation_GetRepo(tt *testing.T) {
  2922  	c := &CollaboratorInvitation{}
  2923  	c.GetRepo()
  2924  	c = nil
  2925  	c.GetRepo()
  2926  }
  2927  
  2928  func TestCollaboratorInvitation_GetURL(tt *testing.T) {
  2929  	var zeroValue string
  2930  	c := &CollaboratorInvitation{URL: &zeroValue}
  2931  	c.GetURL()
  2932  	c = &CollaboratorInvitation{}
  2933  	c.GetURL()
  2934  	c = nil
  2935  	c.GetURL()
  2936  }
  2937  
  2938  func TestCombinedStatus_GetCommitURL(tt *testing.T) {
  2939  	var zeroValue string
  2940  	c := &CombinedStatus{CommitURL: &zeroValue}
  2941  	c.GetCommitURL()
  2942  	c = &CombinedStatus{}
  2943  	c.GetCommitURL()
  2944  	c = nil
  2945  	c.GetCommitURL()
  2946  }
  2947  
  2948  func TestCombinedStatus_GetName(tt *testing.T) {
  2949  	var zeroValue string
  2950  	c := &CombinedStatus{Name: &zeroValue}
  2951  	c.GetName()
  2952  	c = &CombinedStatus{}
  2953  	c.GetName()
  2954  	c = nil
  2955  	c.GetName()
  2956  }
  2957  
  2958  func TestCombinedStatus_GetRepositoryURL(tt *testing.T) {
  2959  	var zeroValue string
  2960  	c := &CombinedStatus{RepositoryURL: &zeroValue}
  2961  	c.GetRepositoryURL()
  2962  	c = &CombinedStatus{}
  2963  	c.GetRepositoryURL()
  2964  	c = nil
  2965  	c.GetRepositoryURL()
  2966  }
  2967  
  2968  func TestCombinedStatus_GetSHA(tt *testing.T) {
  2969  	var zeroValue string
  2970  	c := &CombinedStatus{SHA: &zeroValue}
  2971  	c.GetSHA()
  2972  	c = &CombinedStatus{}
  2973  	c.GetSHA()
  2974  	c = nil
  2975  	c.GetSHA()
  2976  }
  2977  
  2978  func TestCombinedStatus_GetState(tt *testing.T) {
  2979  	var zeroValue string
  2980  	c := &CombinedStatus{State: &zeroValue}
  2981  	c.GetState()
  2982  	c = &CombinedStatus{}
  2983  	c.GetState()
  2984  	c = nil
  2985  	c.GetState()
  2986  }
  2987  
  2988  func TestCombinedStatus_GetTotalCount(tt *testing.T) {
  2989  	var zeroValue int
  2990  	c := &CombinedStatus{TotalCount: &zeroValue}
  2991  	c.GetTotalCount()
  2992  	c = &CombinedStatus{}
  2993  	c.GetTotalCount()
  2994  	c = nil
  2995  	c.GetTotalCount()
  2996  }
  2997  
  2998  func TestComment_GetCreatedAt(tt *testing.T) {
  2999  	var zeroValue time.Time
  3000  	c := &Comment{CreatedAt: &zeroValue}
  3001  	c.GetCreatedAt()
  3002  	c = &Comment{}
  3003  	c.GetCreatedAt()
  3004  	c = nil
  3005  	c.GetCreatedAt()
  3006  }
  3007  
  3008  func TestCommentStats_GetTotalCommitComments(tt *testing.T) {
  3009  	var zeroValue int
  3010  	c := &CommentStats{TotalCommitComments: &zeroValue}
  3011  	c.GetTotalCommitComments()
  3012  	c = &CommentStats{}
  3013  	c.GetTotalCommitComments()
  3014  	c = nil
  3015  	c.GetTotalCommitComments()
  3016  }
  3017  
  3018  func TestCommentStats_GetTotalGistComments(tt *testing.T) {
  3019  	var zeroValue int
  3020  	c := &CommentStats{TotalGistComments: &zeroValue}
  3021  	c.GetTotalGistComments()
  3022  	c = &CommentStats{}
  3023  	c.GetTotalGistComments()
  3024  	c = nil
  3025  	c.GetTotalGistComments()
  3026  }
  3027  
  3028  func TestCommentStats_GetTotalIssueComments(tt *testing.T) {
  3029  	var zeroValue int
  3030  	c := &CommentStats{TotalIssueComments: &zeroValue}
  3031  	c.GetTotalIssueComments()
  3032  	c = &CommentStats{}
  3033  	c.GetTotalIssueComments()
  3034  	c = nil
  3035  	c.GetTotalIssueComments()
  3036  }
  3037  
  3038  func TestCommentStats_GetTotalPullRequestComments(tt *testing.T) {
  3039  	var zeroValue int
  3040  	c := &CommentStats{TotalPullRequestComments: &zeroValue}
  3041  	c.GetTotalPullRequestComments()
  3042  	c = &CommentStats{}
  3043  	c.GetTotalPullRequestComments()
  3044  	c = nil
  3045  	c.GetTotalPullRequestComments()
  3046  }
  3047  
  3048  func TestCommit_GetAuthor(tt *testing.T) {
  3049  	c := &Commit{}
  3050  	c.GetAuthor()
  3051  	c = nil
  3052  	c.GetAuthor()
  3053  }
  3054  
  3055  func TestCommit_GetCommentCount(tt *testing.T) {
  3056  	var zeroValue int
  3057  	c := &Commit{CommentCount: &zeroValue}
  3058  	c.GetCommentCount()
  3059  	c = &Commit{}
  3060  	c.GetCommentCount()
  3061  	c = nil
  3062  	c.GetCommentCount()
  3063  }
  3064  
  3065  func TestCommit_GetCommitter(tt *testing.T) {
  3066  	c := &Commit{}
  3067  	c.GetCommitter()
  3068  	c = nil
  3069  	c.GetCommitter()
  3070  }
  3071  
  3072  func TestCommit_GetHTMLURL(tt *testing.T) {
  3073  	var zeroValue string
  3074  	c := &Commit{HTMLURL: &zeroValue}
  3075  	c.GetHTMLURL()
  3076  	c = &Commit{}
  3077  	c.GetHTMLURL()
  3078  	c = nil
  3079  	c.GetHTMLURL()
  3080  }
  3081  
  3082  func TestCommit_GetMessage(tt *testing.T) {
  3083  	var zeroValue string
  3084  	c := &Commit{Message: &zeroValue}
  3085  	c.GetMessage()
  3086  	c = &Commit{}
  3087  	c.GetMessage()
  3088  	c = nil
  3089  	c.GetMessage()
  3090  }
  3091  
  3092  func TestCommit_GetNodeID(tt *testing.T) {
  3093  	var zeroValue string
  3094  	c := &Commit{NodeID: &zeroValue}
  3095  	c.GetNodeID()
  3096  	c = &Commit{}
  3097  	c.GetNodeID()
  3098  	c = nil
  3099  	c.GetNodeID()
  3100  }
  3101  
  3102  func TestCommit_GetSHA(tt *testing.T) {
  3103  	var zeroValue string
  3104  	c := &Commit{SHA: &zeroValue}
  3105  	c.GetSHA()
  3106  	c = &Commit{}
  3107  	c.GetSHA()
  3108  	c = nil
  3109  	c.GetSHA()
  3110  }
  3111  
  3112  func TestCommit_GetStats(tt *testing.T) {
  3113  	c := &Commit{}
  3114  	c.GetStats()
  3115  	c = nil
  3116  	c.GetStats()
  3117  }
  3118  
  3119  func TestCommit_GetTree(tt *testing.T) {
  3120  	c := &Commit{}
  3121  	c.GetTree()
  3122  	c = nil
  3123  	c.GetTree()
  3124  }
  3125  
  3126  func TestCommit_GetURL(tt *testing.T) {
  3127  	var zeroValue string
  3128  	c := &Commit{URL: &zeroValue}
  3129  	c.GetURL()
  3130  	c = &Commit{}
  3131  	c.GetURL()
  3132  	c = nil
  3133  	c.GetURL()
  3134  }
  3135  
  3136  func TestCommit_GetVerification(tt *testing.T) {
  3137  	c := &Commit{}
  3138  	c.GetVerification()
  3139  	c = nil
  3140  	c.GetVerification()
  3141  }
  3142  
  3143  func TestCommitAuthor_GetDate(tt *testing.T) {
  3144  	var zeroValue time.Time
  3145  	c := &CommitAuthor{Date: &zeroValue}
  3146  	c.GetDate()
  3147  	c = &CommitAuthor{}
  3148  	c.GetDate()
  3149  	c = nil
  3150  	c.GetDate()
  3151  }
  3152  
  3153  func TestCommitAuthor_GetEmail(tt *testing.T) {
  3154  	var zeroValue string
  3155  	c := &CommitAuthor{Email: &zeroValue}
  3156  	c.GetEmail()
  3157  	c = &CommitAuthor{}
  3158  	c.GetEmail()
  3159  	c = nil
  3160  	c.GetEmail()
  3161  }
  3162  
  3163  func TestCommitAuthor_GetLogin(tt *testing.T) {
  3164  	var zeroValue string
  3165  	c := &CommitAuthor{Login: &zeroValue}
  3166  	c.GetLogin()
  3167  	c = &CommitAuthor{}
  3168  	c.GetLogin()
  3169  	c = nil
  3170  	c.GetLogin()
  3171  }
  3172  
  3173  func TestCommitAuthor_GetName(tt *testing.T) {
  3174  	var zeroValue string
  3175  	c := &CommitAuthor{Name: &zeroValue}
  3176  	c.GetName()
  3177  	c = &CommitAuthor{}
  3178  	c.GetName()
  3179  	c = nil
  3180  	c.GetName()
  3181  }
  3182  
  3183  func TestCommitCommentEvent_GetAction(tt *testing.T) {
  3184  	var zeroValue string
  3185  	c := &CommitCommentEvent{Action: &zeroValue}
  3186  	c.GetAction()
  3187  	c = &CommitCommentEvent{}
  3188  	c.GetAction()
  3189  	c = nil
  3190  	c.GetAction()
  3191  }
  3192  
  3193  func TestCommitCommentEvent_GetComment(tt *testing.T) {
  3194  	c := &CommitCommentEvent{}
  3195  	c.GetComment()
  3196  	c = nil
  3197  	c.GetComment()
  3198  }
  3199  
  3200  func TestCommitCommentEvent_GetInstallation(tt *testing.T) {
  3201  	c := &CommitCommentEvent{}
  3202  	c.GetInstallation()
  3203  	c = nil
  3204  	c.GetInstallation()
  3205  }
  3206  
  3207  func TestCommitCommentEvent_GetRepo(tt *testing.T) {
  3208  	c := &CommitCommentEvent{}
  3209  	c.GetRepo()
  3210  	c = nil
  3211  	c.GetRepo()
  3212  }
  3213  
  3214  func TestCommitCommentEvent_GetSender(tt *testing.T) {
  3215  	c := &CommitCommentEvent{}
  3216  	c.GetSender()
  3217  	c = nil
  3218  	c.GetSender()
  3219  }
  3220  
  3221  func TestCommitFile_GetAdditions(tt *testing.T) {
  3222  	var zeroValue int
  3223  	c := &CommitFile{Additions: &zeroValue}
  3224  	c.GetAdditions()
  3225  	c = &CommitFile{}
  3226  	c.GetAdditions()
  3227  	c = nil
  3228  	c.GetAdditions()
  3229  }
  3230  
  3231  func TestCommitFile_GetBlobURL(tt *testing.T) {
  3232  	var zeroValue string
  3233  	c := &CommitFile{BlobURL: &zeroValue}
  3234  	c.GetBlobURL()
  3235  	c = &CommitFile{}
  3236  	c.GetBlobURL()
  3237  	c = nil
  3238  	c.GetBlobURL()
  3239  }
  3240  
  3241  func TestCommitFile_GetChanges(tt *testing.T) {
  3242  	var zeroValue int
  3243  	c := &CommitFile{Changes: &zeroValue}
  3244  	c.GetChanges()
  3245  	c = &CommitFile{}
  3246  	c.GetChanges()
  3247  	c = nil
  3248  	c.GetChanges()
  3249  }
  3250  
  3251  func TestCommitFile_GetContentsURL(tt *testing.T) {
  3252  	var zeroValue string
  3253  	c := &CommitFile{ContentsURL: &zeroValue}
  3254  	c.GetContentsURL()
  3255  	c = &CommitFile{}
  3256  	c.GetContentsURL()
  3257  	c = nil
  3258  	c.GetContentsURL()
  3259  }
  3260  
  3261  func TestCommitFile_GetDeletions(tt *testing.T) {
  3262  	var zeroValue int
  3263  	c := &CommitFile{Deletions: &zeroValue}
  3264  	c.GetDeletions()
  3265  	c = &CommitFile{}
  3266  	c.GetDeletions()
  3267  	c = nil
  3268  	c.GetDeletions()
  3269  }
  3270  
  3271  func TestCommitFile_GetFilename(tt *testing.T) {
  3272  	var zeroValue string
  3273  	c := &CommitFile{Filename: &zeroValue}
  3274  	c.GetFilename()
  3275  	c = &CommitFile{}
  3276  	c.GetFilename()
  3277  	c = nil
  3278  	c.GetFilename()
  3279  }
  3280  
  3281  func TestCommitFile_GetPatch(tt *testing.T) {
  3282  	var zeroValue string
  3283  	c := &CommitFile{Patch: &zeroValue}
  3284  	c.GetPatch()
  3285  	c = &CommitFile{}
  3286  	c.GetPatch()
  3287  	c = nil
  3288  	c.GetPatch()
  3289  }
  3290  
  3291  func TestCommitFile_GetPreviousFilename(tt *testing.T) {
  3292  	var zeroValue string
  3293  	c := &CommitFile{PreviousFilename: &zeroValue}
  3294  	c.GetPreviousFilename()
  3295  	c = &CommitFile{}
  3296  	c.GetPreviousFilename()
  3297  	c = nil
  3298  	c.GetPreviousFilename()
  3299  }
  3300  
  3301  func TestCommitFile_GetRawURL(tt *testing.T) {
  3302  	var zeroValue string
  3303  	c := &CommitFile{RawURL: &zeroValue}
  3304  	c.GetRawURL()
  3305  	c = &CommitFile{}
  3306  	c.GetRawURL()
  3307  	c = nil
  3308  	c.GetRawURL()
  3309  }
  3310  
  3311  func TestCommitFile_GetSHA(tt *testing.T) {
  3312  	var zeroValue string
  3313  	c := &CommitFile{SHA: &zeroValue}
  3314  	c.GetSHA()
  3315  	c = &CommitFile{}
  3316  	c.GetSHA()
  3317  	c = nil
  3318  	c.GetSHA()
  3319  }
  3320  
  3321  func TestCommitFile_GetStatus(tt *testing.T) {
  3322  	var zeroValue string
  3323  	c := &CommitFile{Status: &zeroValue}
  3324  	c.GetStatus()
  3325  	c = &CommitFile{}
  3326  	c.GetStatus()
  3327  	c = nil
  3328  	c.GetStatus()
  3329  }
  3330  
  3331  func TestCommitResult_GetAuthor(tt *testing.T) {
  3332  	c := &CommitResult{}
  3333  	c.GetAuthor()
  3334  	c = nil
  3335  	c.GetAuthor()
  3336  }
  3337  
  3338  func TestCommitResult_GetCommentsURL(tt *testing.T) {
  3339  	var zeroValue string
  3340  	c := &CommitResult{CommentsURL: &zeroValue}
  3341  	c.GetCommentsURL()
  3342  	c = &CommitResult{}
  3343  	c.GetCommentsURL()
  3344  	c = nil
  3345  	c.GetCommentsURL()
  3346  }
  3347  
  3348  func TestCommitResult_GetCommit(tt *testing.T) {
  3349  	c := &CommitResult{}
  3350  	c.GetCommit()
  3351  	c = nil
  3352  	c.GetCommit()
  3353  }
  3354  
  3355  func TestCommitResult_GetCommitter(tt *testing.T) {
  3356  	c := &CommitResult{}
  3357  	c.GetCommitter()
  3358  	c = nil
  3359  	c.GetCommitter()
  3360  }
  3361  
  3362  func TestCommitResult_GetHTMLURL(tt *testing.T) {
  3363  	var zeroValue string
  3364  	c := &CommitResult{HTMLURL: &zeroValue}
  3365  	c.GetHTMLURL()
  3366  	c = &CommitResult{}
  3367  	c.GetHTMLURL()
  3368  	c = nil
  3369  	c.GetHTMLURL()
  3370  }
  3371  
  3372  func TestCommitResult_GetRepository(tt *testing.T) {
  3373  	c := &CommitResult{}
  3374  	c.GetRepository()
  3375  	c = nil
  3376  	c.GetRepository()
  3377  }
  3378  
  3379  func TestCommitResult_GetScore(tt *testing.T) {
  3380  	c := &CommitResult{}
  3381  	c.GetScore()
  3382  	c = nil
  3383  	c.GetScore()
  3384  }
  3385  
  3386  func TestCommitResult_GetSHA(tt *testing.T) {
  3387  	var zeroValue string
  3388  	c := &CommitResult{SHA: &zeroValue}
  3389  	c.GetSHA()
  3390  	c = &CommitResult{}
  3391  	c.GetSHA()
  3392  	c = nil
  3393  	c.GetSHA()
  3394  }
  3395  
  3396  func TestCommitResult_GetURL(tt *testing.T) {
  3397  	var zeroValue string
  3398  	c := &CommitResult{URL: &zeroValue}
  3399  	c.GetURL()
  3400  	c = &CommitResult{}
  3401  	c.GetURL()
  3402  	c = nil
  3403  	c.GetURL()
  3404  }
  3405  
  3406  func TestCommitsComparison_GetAheadBy(tt *testing.T) {
  3407  	var zeroValue int
  3408  	c := &CommitsComparison{AheadBy: &zeroValue}
  3409  	c.GetAheadBy()
  3410  	c = &CommitsComparison{}
  3411  	c.GetAheadBy()
  3412  	c = nil
  3413  	c.GetAheadBy()
  3414  }
  3415  
  3416  func TestCommitsComparison_GetBaseCommit(tt *testing.T) {
  3417  	c := &CommitsComparison{}
  3418  	c.GetBaseCommit()
  3419  	c = nil
  3420  	c.GetBaseCommit()
  3421  }
  3422  
  3423  func TestCommitsComparison_GetBehindBy(tt *testing.T) {
  3424  	var zeroValue int
  3425  	c := &CommitsComparison{BehindBy: &zeroValue}
  3426  	c.GetBehindBy()
  3427  	c = &CommitsComparison{}
  3428  	c.GetBehindBy()
  3429  	c = nil
  3430  	c.GetBehindBy()
  3431  }
  3432  
  3433  func TestCommitsComparison_GetDiffURL(tt *testing.T) {
  3434  	var zeroValue string
  3435  	c := &CommitsComparison{DiffURL: &zeroValue}
  3436  	c.GetDiffURL()
  3437  	c = &CommitsComparison{}
  3438  	c.GetDiffURL()
  3439  	c = nil
  3440  	c.GetDiffURL()
  3441  }
  3442  
  3443  func TestCommitsComparison_GetHTMLURL(tt *testing.T) {
  3444  	var zeroValue string
  3445  	c := &CommitsComparison{HTMLURL: &zeroValue}
  3446  	c.GetHTMLURL()
  3447  	c = &CommitsComparison{}
  3448  	c.GetHTMLURL()
  3449  	c = nil
  3450  	c.GetHTMLURL()
  3451  }
  3452  
  3453  func TestCommitsComparison_GetMergeBaseCommit(tt *testing.T) {
  3454  	c := &CommitsComparison{}
  3455  	c.GetMergeBaseCommit()
  3456  	c = nil
  3457  	c.GetMergeBaseCommit()
  3458  }
  3459  
  3460  func TestCommitsComparison_GetPatchURL(tt *testing.T) {
  3461  	var zeroValue string
  3462  	c := &CommitsComparison{PatchURL: &zeroValue}
  3463  	c.GetPatchURL()
  3464  	c = &CommitsComparison{}
  3465  	c.GetPatchURL()
  3466  	c = nil
  3467  	c.GetPatchURL()
  3468  }
  3469  
  3470  func TestCommitsComparison_GetPermalinkURL(tt *testing.T) {
  3471  	var zeroValue string
  3472  	c := &CommitsComparison{PermalinkURL: &zeroValue}
  3473  	c.GetPermalinkURL()
  3474  	c = &CommitsComparison{}
  3475  	c.GetPermalinkURL()
  3476  	c = nil
  3477  	c.GetPermalinkURL()
  3478  }
  3479  
  3480  func TestCommitsComparison_GetStatus(tt *testing.T) {
  3481  	var zeroValue string
  3482  	c := &CommitsComparison{Status: &zeroValue}
  3483  	c.GetStatus()
  3484  	c = &CommitsComparison{}
  3485  	c.GetStatus()
  3486  	c = nil
  3487  	c.GetStatus()
  3488  }
  3489  
  3490  func TestCommitsComparison_GetTotalCommits(tt *testing.T) {
  3491  	var zeroValue int
  3492  	c := &CommitsComparison{TotalCommits: &zeroValue}
  3493  	c.GetTotalCommits()
  3494  	c = &CommitsComparison{}
  3495  	c.GetTotalCommits()
  3496  	c = nil
  3497  	c.GetTotalCommits()
  3498  }
  3499  
  3500  func TestCommitsComparison_GetURL(tt *testing.T) {
  3501  	var zeroValue string
  3502  	c := &CommitsComparison{URL: &zeroValue}
  3503  	c.GetURL()
  3504  	c = &CommitsComparison{}
  3505  	c.GetURL()
  3506  	c = nil
  3507  	c.GetURL()
  3508  }
  3509  
  3510  func TestCommitsSearchResult_GetIncompleteResults(tt *testing.T) {
  3511  	var zeroValue bool
  3512  	c := &CommitsSearchResult{IncompleteResults: &zeroValue}
  3513  	c.GetIncompleteResults()
  3514  	c = &CommitsSearchResult{}
  3515  	c.GetIncompleteResults()
  3516  	c = nil
  3517  	c.GetIncompleteResults()
  3518  }
  3519  
  3520  func TestCommitsSearchResult_GetTotal(tt *testing.T) {
  3521  	var zeroValue int
  3522  	c := &CommitsSearchResult{Total: &zeroValue}
  3523  	c.GetTotal()
  3524  	c = &CommitsSearchResult{}
  3525  	c.GetTotal()
  3526  	c = nil
  3527  	c.GetTotal()
  3528  }
  3529  
  3530  func TestCommitStats_GetAdditions(tt *testing.T) {
  3531  	var zeroValue int
  3532  	c := &CommitStats{Additions: &zeroValue}
  3533  	c.GetAdditions()
  3534  	c = &CommitStats{}
  3535  	c.GetAdditions()
  3536  	c = nil
  3537  	c.GetAdditions()
  3538  }
  3539  
  3540  func TestCommitStats_GetDeletions(tt *testing.T) {
  3541  	var zeroValue int
  3542  	c := &CommitStats{Deletions: &zeroValue}
  3543  	c.GetDeletions()
  3544  	c = &CommitStats{}
  3545  	c.GetDeletions()
  3546  	c = nil
  3547  	c.GetDeletions()
  3548  }
  3549  
  3550  func TestCommitStats_GetTotal(tt *testing.T) {
  3551  	var zeroValue int
  3552  	c := &CommitStats{Total: &zeroValue}
  3553  	c.GetTotal()
  3554  	c = &CommitStats{}
  3555  	c.GetTotal()
  3556  	c = nil
  3557  	c.GetTotal()
  3558  }
  3559  
  3560  func TestCommunityHealthFiles_GetCodeOfConduct(tt *testing.T) {
  3561  	c := &CommunityHealthFiles{}
  3562  	c.GetCodeOfConduct()
  3563  	c = nil
  3564  	c.GetCodeOfConduct()
  3565  }
  3566  
  3567  func TestCommunityHealthFiles_GetCodeOfConductFile(tt *testing.T) {
  3568  	c := &CommunityHealthFiles{}
  3569  	c.GetCodeOfConductFile()
  3570  	c = nil
  3571  	c.GetCodeOfConductFile()
  3572  }
  3573  
  3574  func TestCommunityHealthFiles_GetContributing(tt *testing.T) {
  3575  	c := &CommunityHealthFiles{}
  3576  	c.GetContributing()
  3577  	c = nil
  3578  	c.GetContributing()
  3579  }
  3580  
  3581  func TestCommunityHealthFiles_GetIssueTemplate(tt *testing.T) {
  3582  	c := &CommunityHealthFiles{}
  3583  	c.GetIssueTemplate()
  3584  	c = nil
  3585  	c.GetIssueTemplate()
  3586  }
  3587  
  3588  func TestCommunityHealthFiles_GetLicense(tt *testing.T) {
  3589  	c := &CommunityHealthFiles{}
  3590  	c.GetLicense()
  3591  	c = nil
  3592  	c.GetLicense()
  3593  }
  3594  
  3595  func TestCommunityHealthFiles_GetPullRequestTemplate(tt *testing.T) {
  3596  	c := &CommunityHealthFiles{}
  3597  	c.GetPullRequestTemplate()
  3598  	c = nil
  3599  	c.GetPullRequestTemplate()
  3600  }
  3601  
  3602  func TestCommunityHealthFiles_GetReadme(tt *testing.T) {
  3603  	c := &CommunityHealthFiles{}
  3604  	c.GetReadme()
  3605  	c = nil
  3606  	c.GetReadme()
  3607  }
  3608  
  3609  func TestCommunityHealthMetrics_GetContentReportsEnabled(tt *testing.T) {
  3610  	var zeroValue bool
  3611  	c := &CommunityHealthMetrics{ContentReportsEnabled: &zeroValue}
  3612  	c.GetContentReportsEnabled()
  3613  	c = &CommunityHealthMetrics{}
  3614  	c.GetContentReportsEnabled()
  3615  	c = nil
  3616  	c.GetContentReportsEnabled()
  3617  }
  3618  
  3619  func TestCommunityHealthMetrics_GetDescription(tt *testing.T) {
  3620  	var zeroValue string
  3621  	c := &CommunityHealthMetrics{Description: &zeroValue}
  3622  	c.GetDescription()
  3623  	c = &CommunityHealthMetrics{}
  3624  	c.GetDescription()
  3625  	c = nil
  3626  	c.GetDescription()
  3627  }
  3628  
  3629  func TestCommunityHealthMetrics_GetDocumentation(tt *testing.T) {
  3630  	var zeroValue string
  3631  	c := &CommunityHealthMetrics{Documentation: &zeroValue}
  3632  	c.GetDocumentation()
  3633  	c = &CommunityHealthMetrics{}
  3634  	c.GetDocumentation()
  3635  	c = nil
  3636  	c.GetDocumentation()
  3637  }
  3638  
  3639  func TestCommunityHealthMetrics_GetFiles(tt *testing.T) {
  3640  	c := &CommunityHealthMetrics{}
  3641  	c.GetFiles()
  3642  	c = nil
  3643  	c.GetFiles()
  3644  }
  3645  
  3646  func TestCommunityHealthMetrics_GetHealthPercentage(tt *testing.T) {
  3647  	var zeroValue int
  3648  	c := &CommunityHealthMetrics{HealthPercentage: &zeroValue}
  3649  	c.GetHealthPercentage()
  3650  	c = &CommunityHealthMetrics{}
  3651  	c.GetHealthPercentage()
  3652  	c = nil
  3653  	c.GetHealthPercentage()
  3654  }
  3655  
  3656  func TestCommunityHealthMetrics_GetUpdatedAt(tt *testing.T) {
  3657  	var zeroValue time.Time
  3658  	c := &CommunityHealthMetrics{UpdatedAt: &zeroValue}
  3659  	c.GetUpdatedAt()
  3660  	c = &CommunityHealthMetrics{}
  3661  	c.GetUpdatedAt()
  3662  	c = nil
  3663  	c.GetUpdatedAt()
  3664  }
  3665  
  3666  func TestContentReference_GetID(tt *testing.T) {
  3667  	var zeroValue int64
  3668  	c := &ContentReference{ID: &zeroValue}
  3669  	c.GetID()
  3670  	c = &ContentReference{}
  3671  	c.GetID()
  3672  	c = nil
  3673  	c.GetID()
  3674  }
  3675  
  3676  func TestContentReference_GetNodeID(tt *testing.T) {
  3677  	var zeroValue string
  3678  	c := &ContentReference{NodeID: &zeroValue}
  3679  	c.GetNodeID()
  3680  	c = &ContentReference{}
  3681  	c.GetNodeID()
  3682  	c = nil
  3683  	c.GetNodeID()
  3684  }
  3685  
  3686  func TestContentReference_GetReference(tt *testing.T) {
  3687  	var zeroValue string
  3688  	c := &ContentReference{Reference: &zeroValue}
  3689  	c.GetReference()
  3690  	c = &ContentReference{}
  3691  	c.GetReference()
  3692  	c = nil
  3693  	c.GetReference()
  3694  }
  3695  
  3696  func TestContentReferenceEvent_GetAction(tt *testing.T) {
  3697  	var zeroValue string
  3698  	c := &ContentReferenceEvent{Action: &zeroValue}
  3699  	c.GetAction()
  3700  	c = &ContentReferenceEvent{}
  3701  	c.GetAction()
  3702  	c = nil
  3703  	c.GetAction()
  3704  }
  3705  
  3706  func TestContentReferenceEvent_GetContentReference(tt *testing.T) {
  3707  	c := &ContentReferenceEvent{}
  3708  	c.GetContentReference()
  3709  	c = nil
  3710  	c.GetContentReference()
  3711  }
  3712  
  3713  func TestContentReferenceEvent_GetInstallation(tt *testing.T) {
  3714  	c := &ContentReferenceEvent{}
  3715  	c.GetInstallation()
  3716  	c = nil
  3717  	c.GetInstallation()
  3718  }
  3719  
  3720  func TestContentReferenceEvent_GetRepo(tt *testing.T) {
  3721  	c := &ContentReferenceEvent{}
  3722  	c.GetRepo()
  3723  	c = nil
  3724  	c.GetRepo()
  3725  }
  3726  
  3727  func TestContentReferenceEvent_GetSender(tt *testing.T) {
  3728  	c := &ContentReferenceEvent{}
  3729  	c.GetSender()
  3730  	c = nil
  3731  	c.GetSender()
  3732  }
  3733  
  3734  func TestContributor_GetAvatarURL(tt *testing.T) {
  3735  	var zeroValue string
  3736  	c := &Contributor{AvatarURL: &zeroValue}
  3737  	c.GetAvatarURL()
  3738  	c = &Contributor{}
  3739  	c.GetAvatarURL()
  3740  	c = nil
  3741  	c.GetAvatarURL()
  3742  }
  3743  
  3744  func TestContributor_GetContributions(tt *testing.T) {
  3745  	var zeroValue int
  3746  	c := &Contributor{Contributions: &zeroValue}
  3747  	c.GetContributions()
  3748  	c = &Contributor{}
  3749  	c.GetContributions()
  3750  	c = nil
  3751  	c.GetContributions()
  3752  }
  3753  
  3754  func TestContributor_GetEmail(tt *testing.T) {
  3755  	var zeroValue string
  3756  	c := &Contributor{Email: &zeroValue}
  3757  	c.GetEmail()
  3758  	c = &Contributor{}
  3759  	c.GetEmail()
  3760  	c = nil
  3761  	c.GetEmail()
  3762  }
  3763  
  3764  func TestContributor_GetEventsURL(tt *testing.T) {
  3765  	var zeroValue string
  3766  	c := &Contributor{EventsURL: &zeroValue}
  3767  	c.GetEventsURL()
  3768  	c = &Contributor{}
  3769  	c.GetEventsURL()
  3770  	c = nil
  3771  	c.GetEventsURL()
  3772  }
  3773  
  3774  func TestContributor_GetFollowersURL(tt *testing.T) {
  3775  	var zeroValue string
  3776  	c := &Contributor{FollowersURL: &zeroValue}
  3777  	c.GetFollowersURL()
  3778  	c = &Contributor{}
  3779  	c.GetFollowersURL()
  3780  	c = nil
  3781  	c.GetFollowersURL()
  3782  }
  3783  
  3784  func TestContributor_GetFollowingURL(tt *testing.T) {
  3785  	var zeroValue string
  3786  	c := &Contributor{FollowingURL: &zeroValue}
  3787  	c.GetFollowingURL()
  3788  	c = &Contributor{}
  3789  	c.GetFollowingURL()
  3790  	c = nil
  3791  	c.GetFollowingURL()
  3792  }
  3793  
  3794  func TestContributor_GetGistsURL(tt *testing.T) {
  3795  	var zeroValue string
  3796  	c := &Contributor{GistsURL: &zeroValue}
  3797  	c.GetGistsURL()
  3798  	c = &Contributor{}
  3799  	c.GetGistsURL()
  3800  	c = nil
  3801  	c.GetGistsURL()
  3802  }
  3803  
  3804  func TestContributor_GetGravatarID(tt *testing.T) {
  3805  	var zeroValue string
  3806  	c := &Contributor{GravatarID: &zeroValue}
  3807  	c.GetGravatarID()
  3808  	c = &Contributor{}
  3809  	c.GetGravatarID()
  3810  	c = nil
  3811  	c.GetGravatarID()
  3812  }
  3813  
  3814  func TestContributor_GetHTMLURL(tt *testing.T) {
  3815  	var zeroValue string
  3816  	c := &Contributor{HTMLURL: &zeroValue}
  3817  	c.GetHTMLURL()
  3818  	c = &Contributor{}
  3819  	c.GetHTMLURL()
  3820  	c = nil
  3821  	c.GetHTMLURL()
  3822  }
  3823  
  3824  func TestContributor_GetID(tt *testing.T) {
  3825  	var zeroValue int64
  3826  	c := &Contributor{ID: &zeroValue}
  3827  	c.GetID()
  3828  	c = &Contributor{}
  3829  	c.GetID()
  3830  	c = nil
  3831  	c.GetID()
  3832  }
  3833  
  3834  func TestContributor_GetLogin(tt *testing.T) {
  3835  	var zeroValue string
  3836  	c := &Contributor{Login: &zeroValue}
  3837  	c.GetLogin()
  3838  	c = &Contributor{}
  3839  	c.GetLogin()
  3840  	c = nil
  3841  	c.GetLogin()
  3842  }
  3843  
  3844  func TestContributor_GetName(tt *testing.T) {
  3845  	var zeroValue string
  3846  	c := &Contributor{Name: &zeroValue}
  3847  	c.GetName()
  3848  	c = &Contributor{}
  3849  	c.GetName()
  3850  	c = nil
  3851  	c.GetName()
  3852  }
  3853  
  3854  func TestContributor_GetNodeID(tt *testing.T) {
  3855  	var zeroValue string
  3856  	c := &Contributor{NodeID: &zeroValue}
  3857  	c.GetNodeID()
  3858  	c = &Contributor{}
  3859  	c.GetNodeID()
  3860  	c = nil
  3861  	c.GetNodeID()
  3862  }
  3863  
  3864  func TestContributor_GetOrganizationsURL(tt *testing.T) {
  3865  	var zeroValue string
  3866  	c := &Contributor{OrganizationsURL: &zeroValue}
  3867  	c.GetOrganizationsURL()
  3868  	c = &Contributor{}
  3869  	c.GetOrganizationsURL()
  3870  	c = nil
  3871  	c.GetOrganizationsURL()
  3872  }
  3873  
  3874  func TestContributor_GetReceivedEventsURL(tt *testing.T) {
  3875  	var zeroValue string
  3876  	c := &Contributor{ReceivedEventsURL: &zeroValue}
  3877  	c.GetReceivedEventsURL()
  3878  	c = &Contributor{}
  3879  	c.GetReceivedEventsURL()
  3880  	c = nil
  3881  	c.GetReceivedEventsURL()
  3882  }
  3883  
  3884  func TestContributor_GetReposURL(tt *testing.T) {
  3885  	var zeroValue string
  3886  	c := &Contributor{ReposURL: &zeroValue}
  3887  	c.GetReposURL()
  3888  	c = &Contributor{}
  3889  	c.GetReposURL()
  3890  	c = nil
  3891  	c.GetReposURL()
  3892  }
  3893  
  3894  func TestContributor_GetSiteAdmin(tt *testing.T) {
  3895  	var zeroValue bool
  3896  	c := &Contributor{SiteAdmin: &zeroValue}
  3897  	c.GetSiteAdmin()
  3898  	c = &Contributor{}
  3899  	c.GetSiteAdmin()
  3900  	c = nil
  3901  	c.GetSiteAdmin()
  3902  }
  3903  
  3904  func TestContributor_GetStarredURL(tt *testing.T) {
  3905  	var zeroValue string
  3906  	c := &Contributor{StarredURL: &zeroValue}
  3907  	c.GetStarredURL()
  3908  	c = &Contributor{}
  3909  	c.GetStarredURL()
  3910  	c = nil
  3911  	c.GetStarredURL()
  3912  }
  3913  
  3914  func TestContributor_GetSubscriptionsURL(tt *testing.T) {
  3915  	var zeroValue string
  3916  	c := &Contributor{SubscriptionsURL: &zeroValue}
  3917  	c.GetSubscriptionsURL()
  3918  	c = &Contributor{}
  3919  	c.GetSubscriptionsURL()
  3920  	c = nil
  3921  	c.GetSubscriptionsURL()
  3922  }
  3923  
  3924  func TestContributor_GetType(tt *testing.T) {
  3925  	var zeroValue string
  3926  	c := &Contributor{Type: &zeroValue}
  3927  	c.GetType()
  3928  	c = &Contributor{}
  3929  	c.GetType()
  3930  	c = nil
  3931  	c.GetType()
  3932  }
  3933  
  3934  func TestContributor_GetURL(tt *testing.T) {
  3935  	var zeroValue string
  3936  	c := &Contributor{URL: &zeroValue}
  3937  	c.GetURL()
  3938  	c = &Contributor{}
  3939  	c.GetURL()
  3940  	c = nil
  3941  	c.GetURL()
  3942  }
  3943  
  3944  func TestContributorStats_GetAuthor(tt *testing.T) {
  3945  	c := &ContributorStats{}
  3946  	c.GetAuthor()
  3947  	c = nil
  3948  	c.GetAuthor()
  3949  }
  3950  
  3951  func TestContributorStats_GetTotal(tt *testing.T) {
  3952  	var zeroValue int
  3953  	c := &ContributorStats{Total: &zeroValue}
  3954  	c.GetTotal()
  3955  	c = &ContributorStats{}
  3956  	c.GetTotal()
  3957  	c = nil
  3958  	c.GetTotal()
  3959  }
  3960  
  3961  func TestCreateCheckRunOptions_GetCompletedAt(tt *testing.T) {
  3962  	var zeroValue Timestamp
  3963  	c := &CreateCheckRunOptions{CompletedAt: &zeroValue}
  3964  	c.GetCompletedAt()
  3965  	c = &CreateCheckRunOptions{}
  3966  	c.GetCompletedAt()
  3967  	c = nil
  3968  	c.GetCompletedAt()
  3969  }
  3970  
  3971  func TestCreateCheckRunOptions_GetConclusion(tt *testing.T) {
  3972  	var zeroValue string
  3973  	c := &CreateCheckRunOptions{Conclusion: &zeroValue}
  3974  	c.GetConclusion()
  3975  	c = &CreateCheckRunOptions{}
  3976  	c.GetConclusion()
  3977  	c = nil
  3978  	c.GetConclusion()
  3979  }
  3980  
  3981  func TestCreateCheckRunOptions_GetDetailsURL(tt *testing.T) {
  3982  	var zeroValue string
  3983  	c := &CreateCheckRunOptions{DetailsURL: &zeroValue}
  3984  	c.GetDetailsURL()
  3985  	c = &CreateCheckRunOptions{}
  3986  	c.GetDetailsURL()
  3987  	c = nil
  3988  	c.GetDetailsURL()
  3989  }
  3990  
  3991  func TestCreateCheckRunOptions_GetExternalID(tt *testing.T) {
  3992  	var zeroValue string
  3993  	c := &CreateCheckRunOptions{ExternalID: &zeroValue}
  3994  	c.GetExternalID()
  3995  	c = &CreateCheckRunOptions{}
  3996  	c.GetExternalID()
  3997  	c = nil
  3998  	c.GetExternalID()
  3999  }
  4000  
  4001  func TestCreateCheckRunOptions_GetOutput(tt *testing.T) {
  4002  	c := &CreateCheckRunOptions{}
  4003  	c.GetOutput()
  4004  	c = nil
  4005  	c.GetOutput()
  4006  }
  4007  
  4008  func TestCreateCheckRunOptions_GetStartedAt(tt *testing.T) {
  4009  	var zeroValue Timestamp
  4010  	c := &CreateCheckRunOptions{StartedAt: &zeroValue}
  4011  	c.GetStartedAt()
  4012  	c = &CreateCheckRunOptions{}
  4013  	c.GetStartedAt()
  4014  	c = nil
  4015  	c.GetStartedAt()
  4016  }
  4017  
  4018  func TestCreateCheckRunOptions_GetStatus(tt *testing.T) {
  4019  	var zeroValue string
  4020  	c := &CreateCheckRunOptions{Status: &zeroValue}
  4021  	c.GetStatus()
  4022  	c = &CreateCheckRunOptions{}
  4023  	c.GetStatus()
  4024  	c = nil
  4025  	c.GetStatus()
  4026  }
  4027  
  4028  func TestCreateCheckSuiteOptions_GetHeadBranch(tt *testing.T) {
  4029  	var zeroValue string
  4030  	c := &CreateCheckSuiteOptions{HeadBranch: &zeroValue}
  4031  	c.GetHeadBranch()
  4032  	c = &CreateCheckSuiteOptions{}
  4033  	c.GetHeadBranch()
  4034  	c = nil
  4035  	c.GetHeadBranch()
  4036  }
  4037  
  4038  func TestCreateEvent_GetDescription(tt *testing.T) {
  4039  	var zeroValue string
  4040  	c := &CreateEvent{Description: &zeroValue}
  4041  	c.GetDescription()
  4042  	c = &CreateEvent{}
  4043  	c.GetDescription()
  4044  	c = nil
  4045  	c.GetDescription()
  4046  }
  4047  
  4048  func TestCreateEvent_GetInstallation(tt *testing.T) {
  4049  	c := &CreateEvent{}
  4050  	c.GetInstallation()
  4051  	c = nil
  4052  	c.GetInstallation()
  4053  }
  4054  
  4055  func TestCreateEvent_GetMasterBranch(tt *testing.T) {
  4056  	var zeroValue string
  4057  	c := &CreateEvent{MasterBranch: &zeroValue}
  4058  	c.GetMasterBranch()
  4059  	c = &CreateEvent{}
  4060  	c.GetMasterBranch()
  4061  	c = nil
  4062  	c.GetMasterBranch()
  4063  }
  4064  
  4065  func TestCreateEvent_GetOrg(tt *testing.T) {
  4066  	c := &CreateEvent{}
  4067  	c.GetOrg()
  4068  	c = nil
  4069  	c.GetOrg()
  4070  }
  4071  
  4072  func TestCreateEvent_GetPusherType(tt *testing.T) {
  4073  	var zeroValue string
  4074  	c := &CreateEvent{PusherType: &zeroValue}
  4075  	c.GetPusherType()
  4076  	c = &CreateEvent{}
  4077  	c.GetPusherType()
  4078  	c = nil
  4079  	c.GetPusherType()
  4080  }
  4081  
  4082  func TestCreateEvent_GetRef(tt *testing.T) {
  4083  	var zeroValue string
  4084  	c := &CreateEvent{Ref: &zeroValue}
  4085  	c.GetRef()
  4086  	c = &CreateEvent{}
  4087  	c.GetRef()
  4088  	c = nil
  4089  	c.GetRef()
  4090  }
  4091  
  4092  func TestCreateEvent_GetRefType(tt *testing.T) {
  4093  	var zeroValue string
  4094  	c := &CreateEvent{RefType: &zeroValue}
  4095  	c.GetRefType()
  4096  	c = &CreateEvent{}
  4097  	c.GetRefType()
  4098  	c = nil
  4099  	c.GetRefType()
  4100  }
  4101  
  4102  func TestCreateEvent_GetRepo(tt *testing.T) {
  4103  	c := &CreateEvent{}
  4104  	c.GetRepo()
  4105  	c = nil
  4106  	c.GetRepo()
  4107  }
  4108  
  4109  func TestCreateEvent_GetSender(tt *testing.T) {
  4110  	c := &CreateEvent{}
  4111  	c.GetSender()
  4112  	c = nil
  4113  	c.GetSender()
  4114  }
  4115  
  4116  func TestCreateOrgInvitationOptions_GetEmail(tt *testing.T) {
  4117  	var zeroValue string
  4118  	c := &CreateOrgInvitationOptions{Email: &zeroValue}
  4119  	c.GetEmail()
  4120  	c = &CreateOrgInvitationOptions{}
  4121  	c.GetEmail()
  4122  	c = nil
  4123  	c.GetEmail()
  4124  }
  4125  
  4126  func TestCreateOrgInvitationOptions_GetInviteeID(tt *testing.T) {
  4127  	var zeroValue int64
  4128  	c := &CreateOrgInvitationOptions{InviteeID: &zeroValue}
  4129  	c.GetInviteeID()
  4130  	c = &CreateOrgInvitationOptions{}
  4131  	c.GetInviteeID()
  4132  	c = nil
  4133  	c.GetInviteeID()
  4134  }
  4135  
  4136  func TestCreateOrgInvitationOptions_GetRole(tt *testing.T) {
  4137  	var zeroValue string
  4138  	c := &CreateOrgInvitationOptions{Role: &zeroValue}
  4139  	c.GetRole()
  4140  	c = &CreateOrgInvitationOptions{}
  4141  	c.GetRole()
  4142  	c = nil
  4143  	c.GetRole()
  4144  }
  4145  
  4146  func TestCreateRunnerGroupRequest_GetAllowsPublicRepositories(tt *testing.T) {
  4147  	var zeroValue bool
  4148  	c := &CreateRunnerGroupRequest{AllowsPublicRepositories: &zeroValue}
  4149  	c.GetAllowsPublicRepositories()
  4150  	c = &CreateRunnerGroupRequest{}
  4151  	c.GetAllowsPublicRepositories()
  4152  	c = nil
  4153  	c.GetAllowsPublicRepositories()
  4154  }
  4155  
  4156  func TestCreateRunnerGroupRequest_GetName(tt *testing.T) {
  4157  	var zeroValue string
  4158  	c := &CreateRunnerGroupRequest{Name: &zeroValue}
  4159  	c.GetName()
  4160  	c = &CreateRunnerGroupRequest{}
  4161  	c.GetName()
  4162  	c = nil
  4163  	c.GetName()
  4164  }
  4165  
  4166  func TestCreateRunnerGroupRequest_GetVisibility(tt *testing.T) {
  4167  	var zeroValue string
  4168  	c := &CreateRunnerGroupRequest{Visibility: &zeroValue}
  4169  	c.GetVisibility()
  4170  	c = &CreateRunnerGroupRequest{}
  4171  	c.GetVisibility()
  4172  	c = nil
  4173  	c.GetVisibility()
  4174  }
  4175  
  4176  func TestCreateUpdateEnvironment_GetDeploymentBranchPolicy(tt *testing.T) {
  4177  	c := &CreateUpdateEnvironment{}
  4178  	c.GetDeploymentBranchPolicy()
  4179  	c = nil
  4180  	c.GetDeploymentBranchPolicy()
  4181  }
  4182  
  4183  func TestCreateUpdateEnvironment_GetWaitTimer(tt *testing.T) {
  4184  	var zeroValue int
  4185  	c := &CreateUpdateEnvironment{WaitTimer: &zeroValue}
  4186  	c.GetWaitTimer()
  4187  	c = &CreateUpdateEnvironment{}
  4188  	c.GetWaitTimer()
  4189  	c = nil
  4190  	c.GetWaitTimer()
  4191  }
  4192  
  4193  func TestCreateUserProjectOptions_GetBody(tt *testing.T) {
  4194  	var zeroValue string
  4195  	c := &CreateUserProjectOptions{Body: &zeroValue}
  4196  	c.GetBody()
  4197  	c = &CreateUserProjectOptions{}
  4198  	c.GetBody()
  4199  	c = nil
  4200  	c.GetBody()
  4201  }
  4202  
  4203  func TestCustomRepoRoles_GetID(tt *testing.T) {
  4204  	var zeroValue int64
  4205  	c := &CustomRepoRoles{ID: &zeroValue}
  4206  	c.GetID()
  4207  	c = &CustomRepoRoles{}
  4208  	c.GetID()
  4209  	c = nil
  4210  	c.GetID()
  4211  }
  4212  
  4213  func TestCustomRepoRoles_GetName(tt *testing.T) {
  4214  	var zeroValue string
  4215  	c := &CustomRepoRoles{Name: &zeroValue}
  4216  	c.GetName()
  4217  	c = &CustomRepoRoles{}
  4218  	c.GetName()
  4219  	c = nil
  4220  	c.GetName()
  4221  }
  4222  
  4223  func TestDeleteEvent_GetInstallation(tt *testing.T) {
  4224  	d := &DeleteEvent{}
  4225  	d.GetInstallation()
  4226  	d = nil
  4227  	d.GetInstallation()
  4228  }
  4229  
  4230  func TestDeleteEvent_GetPusherType(tt *testing.T) {
  4231  	var zeroValue string
  4232  	d := &DeleteEvent{PusherType: &zeroValue}
  4233  	d.GetPusherType()
  4234  	d = &DeleteEvent{}
  4235  	d.GetPusherType()
  4236  	d = nil
  4237  	d.GetPusherType()
  4238  }
  4239  
  4240  func TestDeleteEvent_GetRef(tt *testing.T) {
  4241  	var zeroValue string
  4242  	d := &DeleteEvent{Ref: &zeroValue}
  4243  	d.GetRef()
  4244  	d = &DeleteEvent{}
  4245  	d.GetRef()
  4246  	d = nil
  4247  	d.GetRef()
  4248  }
  4249  
  4250  func TestDeleteEvent_GetRefType(tt *testing.T) {
  4251  	var zeroValue string
  4252  	d := &DeleteEvent{RefType: &zeroValue}
  4253  	d.GetRefType()
  4254  	d = &DeleteEvent{}
  4255  	d.GetRefType()
  4256  	d = nil
  4257  	d.GetRefType()
  4258  }
  4259  
  4260  func TestDeleteEvent_GetRepo(tt *testing.T) {
  4261  	d := &DeleteEvent{}
  4262  	d.GetRepo()
  4263  	d = nil
  4264  	d.GetRepo()
  4265  }
  4266  
  4267  func TestDeleteEvent_GetSender(tt *testing.T) {
  4268  	d := &DeleteEvent{}
  4269  	d.GetSender()
  4270  	d = nil
  4271  	d.GetSender()
  4272  }
  4273  
  4274  func TestDeployKeyEvent_GetAction(tt *testing.T) {
  4275  	var zeroValue string
  4276  	d := &DeployKeyEvent{Action: &zeroValue}
  4277  	d.GetAction()
  4278  	d = &DeployKeyEvent{}
  4279  	d.GetAction()
  4280  	d = nil
  4281  	d.GetAction()
  4282  }
  4283  
  4284  func TestDeployKeyEvent_GetInstallation(tt *testing.T) {
  4285  	d := &DeployKeyEvent{}
  4286  	d.GetInstallation()
  4287  	d = nil
  4288  	d.GetInstallation()
  4289  }
  4290  
  4291  func TestDeployKeyEvent_GetKey(tt *testing.T) {
  4292  	d := &DeployKeyEvent{}
  4293  	d.GetKey()
  4294  	d = nil
  4295  	d.GetKey()
  4296  }
  4297  
  4298  func TestDeployKeyEvent_GetOrganization(tt *testing.T) {
  4299  	d := &DeployKeyEvent{}
  4300  	d.GetOrganization()
  4301  	d = nil
  4302  	d.GetOrganization()
  4303  }
  4304  
  4305  func TestDeployKeyEvent_GetRepo(tt *testing.T) {
  4306  	d := &DeployKeyEvent{}
  4307  	d.GetRepo()
  4308  	d = nil
  4309  	d.GetRepo()
  4310  }
  4311  
  4312  func TestDeployKeyEvent_GetSender(tt *testing.T) {
  4313  	d := &DeployKeyEvent{}
  4314  	d.GetSender()
  4315  	d = nil
  4316  	d.GetSender()
  4317  }
  4318  
  4319  func TestDeployment_GetCreatedAt(tt *testing.T) {
  4320  	var zeroValue Timestamp
  4321  	d := &Deployment{CreatedAt: &zeroValue}
  4322  	d.GetCreatedAt()
  4323  	d = &Deployment{}
  4324  	d.GetCreatedAt()
  4325  	d = nil
  4326  	d.GetCreatedAt()
  4327  }
  4328  
  4329  func TestDeployment_GetCreator(tt *testing.T) {
  4330  	d := &Deployment{}
  4331  	d.GetCreator()
  4332  	d = nil
  4333  	d.GetCreator()
  4334  }
  4335  
  4336  func TestDeployment_GetDescription(tt *testing.T) {
  4337  	var zeroValue string
  4338  	d := &Deployment{Description: &zeroValue}
  4339  	d.GetDescription()
  4340  	d = &Deployment{}
  4341  	d.GetDescription()
  4342  	d = nil
  4343  	d.GetDescription()
  4344  }
  4345  
  4346  func TestDeployment_GetEnvironment(tt *testing.T) {
  4347  	var zeroValue string
  4348  	d := &Deployment{Environment: &zeroValue}
  4349  	d.GetEnvironment()
  4350  	d = &Deployment{}
  4351  	d.GetEnvironment()
  4352  	d = nil
  4353  	d.GetEnvironment()
  4354  }
  4355  
  4356  func TestDeployment_GetID(tt *testing.T) {
  4357  	var zeroValue int64
  4358  	d := &Deployment{ID: &zeroValue}
  4359  	d.GetID()
  4360  	d = &Deployment{}
  4361  	d.GetID()
  4362  	d = nil
  4363  	d.GetID()
  4364  }
  4365  
  4366  func TestDeployment_GetNodeID(tt *testing.T) {
  4367  	var zeroValue string
  4368  	d := &Deployment{NodeID: &zeroValue}
  4369  	d.GetNodeID()
  4370  	d = &Deployment{}
  4371  	d.GetNodeID()
  4372  	d = nil
  4373  	d.GetNodeID()
  4374  }
  4375  
  4376  func TestDeployment_GetRef(tt *testing.T) {
  4377  	var zeroValue string
  4378  	d := &Deployment{Ref: &zeroValue}
  4379  	d.GetRef()
  4380  	d = &Deployment{}
  4381  	d.GetRef()
  4382  	d = nil
  4383  	d.GetRef()
  4384  }
  4385  
  4386  func TestDeployment_GetRepositoryURL(tt *testing.T) {
  4387  	var zeroValue string
  4388  	d := &Deployment{RepositoryURL: &zeroValue}
  4389  	d.GetRepositoryURL()
  4390  	d = &Deployment{}
  4391  	d.GetRepositoryURL()
  4392  	d = nil
  4393  	d.GetRepositoryURL()
  4394  }
  4395  
  4396  func TestDeployment_GetSHA(tt *testing.T) {
  4397  	var zeroValue string
  4398  	d := &Deployment{SHA: &zeroValue}
  4399  	d.GetSHA()
  4400  	d = &Deployment{}
  4401  	d.GetSHA()
  4402  	d = nil
  4403  	d.GetSHA()
  4404  }
  4405  
  4406  func TestDeployment_GetStatusesURL(tt *testing.T) {
  4407  	var zeroValue string
  4408  	d := &Deployment{StatusesURL: &zeroValue}
  4409  	d.GetStatusesURL()
  4410  	d = &Deployment{}
  4411  	d.GetStatusesURL()
  4412  	d = nil
  4413  	d.GetStatusesURL()
  4414  }
  4415  
  4416  func TestDeployment_GetTask(tt *testing.T) {
  4417  	var zeroValue string
  4418  	d := &Deployment{Task: &zeroValue}
  4419  	d.GetTask()
  4420  	d = &Deployment{}
  4421  	d.GetTask()
  4422  	d = nil
  4423  	d.GetTask()
  4424  }
  4425  
  4426  func TestDeployment_GetUpdatedAt(tt *testing.T) {
  4427  	var zeroValue Timestamp
  4428  	d := &Deployment{UpdatedAt: &zeroValue}
  4429  	d.GetUpdatedAt()
  4430  	d = &Deployment{}
  4431  	d.GetUpdatedAt()
  4432  	d = nil
  4433  	d.GetUpdatedAt()
  4434  }
  4435  
  4436  func TestDeployment_GetURL(tt *testing.T) {
  4437  	var zeroValue string
  4438  	d := &Deployment{URL: &zeroValue}
  4439  	d.GetURL()
  4440  	d = &Deployment{}
  4441  	d.GetURL()
  4442  	d = nil
  4443  	d.GetURL()
  4444  }
  4445  
  4446  func TestDeploymentEvent_GetDeployment(tt *testing.T) {
  4447  	d := &DeploymentEvent{}
  4448  	d.GetDeployment()
  4449  	d = nil
  4450  	d.GetDeployment()
  4451  }
  4452  
  4453  func TestDeploymentEvent_GetInstallation(tt *testing.T) {
  4454  	d := &DeploymentEvent{}
  4455  	d.GetInstallation()
  4456  	d = nil
  4457  	d.GetInstallation()
  4458  }
  4459  
  4460  func TestDeploymentEvent_GetRepo(tt *testing.T) {
  4461  	d := &DeploymentEvent{}
  4462  	d.GetRepo()
  4463  	d = nil
  4464  	d.GetRepo()
  4465  }
  4466  
  4467  func TestDeploymentEvent_GetSender(tt *testing.T) {
  4468  	d := &DeploymentEvent{}
  4469  	d.GetSender()
  4470  	d = nil
  4471  	d.GetSender()
  4472  }
  4473  
  4474  func TestDeploymentRequest_GetAutoMerge(tt *testing.T) {
  4475  	var zeroValue bool
  4476  	d := &DeploymentRequest{AutoMerge: &zeroValue}
  4477  	d.GetAutoMerge()
  4478  	d = &DeploymentRequest{}
  4479  	d.GetAutoMerge()
  4480  	d = nil
  4481  	d.GetAutoMerge()
  4482  }
  4483  
  4484  func TestDeploymentRequest_GetDescription(tt *testing.T) {
  4485  	var zeroValue string
  4486  	d := &DeploymentRequest{Description: &zeroValue}
  4487  	d.GetDescription()
  4488  	d = &DeploymentRequest{}
  4489  	d.GetDescription()
  4490  	d = nil
  4491  	d.GetDescription()
  4492  }
  4493  
  4494  func TestDeploymentRequest_GetEnvironment(tt *testing.T) {
  4495  	var zeroValue string
  4496  	d := &DeploymentRequest{Environment: &zeroValue}
  4497  	d.GetEnvironment()
  4498  	d = &DeploymentRequest{}
  4499  	d.GetEnvironment()
  4500  	d = nil
  4501  	d.GetEnvironment()
  4502  }
  4503  
  4504  func TestDeploymentRequest_GetProductionEnvironment(tt *testing.T) {
  4505  	var zeroValue bool
  4506  	d := &DeploymentRequest{ProductionEnvironment: &zeroValue}
  4507  	d.GetProductionEnvironment()
  4508  	d = &DeploymentRequest{}
  4509  	d.GetProductionEnvironment()
  4510  	d = nil
  4511  	d.GetProductionEnvironment()
  4512  }
  4513  
  4514  func TestDeploymentRequest_GetRef(tt *testing.T) {
  4515  	var zeroValue string
  4516  	d := &DeploymentRequest{Ref: &zeroValue}
  4517  	d.GetRef()
  4518  	d = &DeploymentRequest{}
  4519  	d.GetRef()
  4520  	d = nil
  4521  	d.GetRef()
  4522  }
  4523  
  4524  func TestDeploymentRequest_GetRequiredContexts(tt *testing.T) {
  4525  	var zeroValue []string
  4526  	d := &DeploymentRequest{RequiredContexts: &zeroValue}
  4527  	d.GetRequiredContexts()
  4528  	d = &DeploymentRequest{}
  4529  	d.GetRequiredContexts()
  4530  	d = nil
  4531  	d.GetRequiredContexts()
  4532  }
  4533  
  4534  func TestDeploymentRequest_GetTask(tt *testing.T) {
  4535  	var zeroValue string
  4536  	d := &DeploymentRequest{Task: &zeroValue}
  4537  	d.GetTask()
  4538  	d = &DeploymentRequest{}
  4539  	d.GetTask()
  4540  	d = nil
  4541  	d.GetTask()
  4542  }
  4543  
  4544  func TestDeploymentRequest_GetTransientEnvironment(tt *testing.T) {
  4545  	var zeroValue bool
  4546  	d := &DeploymentRequest{TransientEnvironment: &zeroValue}
  4547  	d.GetTransientEnvironment()
  4548  	d = &DeploymentRequest{}
  4549  	d.GetTransientEnvironment()
  4550  	d = nil
  4551  	d.GetTransientEnvironment()
  4552  }
  4553  
  4554  func TestDeploymentStatus_GetCreatedAt(tt *testing.T) {
  4555  	var zeroValue Timestamp
  4556  	d := &DeploymentStatus{CreatedAt: &zeroValue}
  4557  	d.GetCreatedAt()
  4558  	d = &DeploymentStatus{}
  4559  	d.GetCreatedAt()
  4560  	d = nil
  4561  	d.GetCreatedAt()
  4562  }
  4563  
  4564  func TestDeploymentStatus_GetCreator(tt *testing.T) {
  4565  	d := &DeploymentStatus{}
  4566  	d.GetCreator()
  4567  	d = nil
  4568  	d.GetCreator()
  4569  }
  4570  
  4571  func TestDeploymentStatus_GetDeploymentURL(tt *testing.T) {
  4572  	var zeroValue string
  4573  	d := &DeploymentStatus{DeploymentURL: &zeroValue}
  4574  	d.GetDeploymentURL()
  4575  	d = &DeploymentStatus{}
  4576  	d.GetDeploymentURL()
  4577  	d = nil
  4578  	d.GetDeploymentURL()
  4579  }
  4580  
  4581  func TestDeploymentStatus_GetDescription(tt *testing.T) {
  4582  	var zeroValue string
  4583  	d := &DeploymentStatus{Description: &zeroValue}
  4584  	d.GetDescription()
  4585  	d = &DeploymentStatus{}
  4586  	d.GetDescription()
  4587  	d = nil
  4588  	d.GetDescription()
  4589  }
  4590  
  4591  func TestDeploymentStatus_GetEnvironment(tt *testing.T) {
  4592  	var zeroValue string
  4593  	d := &DeploymentStatus{Environment: &zeroValue}
  4594  	d.GetEnvironment()
  4595  	d = &DeploymentStatus{}
  4596  	d.GetEnvironment()
  4597  	d = nil
  4598  	d.GetEnvironment()
  4599  }
  4600  
  4601  func TestDeploymentStatus_GetEnvironmentURL(tt *testing.T) {
  4602  	var zeroValue string
  4603  	d := &DeploymentStatus{EnvironmentURL: &zeroValue}
  4604  	d.GetEnvironmentURL()
  4605  	d = &DeploymentStatus{}
  4606  	d.GetEnvironmentURL()
  4607  	d = nil
  4608  	d.GetEnvironmentURL()
  4609  }
  4610  
  4611  func TestDeploymentStatus_GetID(tt *testing.T) {
  4612  	var zeroValue int64
  4613  	d := &DeploymentStatus{ID: &zeroValue}
  4614  	d.GetID()
  4615  	d = &DeploymentStatus{}
  4616  	d.GetID()
  4617  	d = nil
  4618  	d.GetID()
  4619  }
  4620  
  4621  func TestDeploymentStatus_GetLogURL(tt *testing.T) {
  4622  	var zeroValue string
  4623  	d := &DeploymentStatus{LogURL: &zeroValue}
  4624  	d.GetLogURL()
  4625  	d = &DeploymentStatus{}
  4626  	d.GetLogURL()
  4627  	d = nil
  4628  	d.GetLogURL()
  4629  }
  4630  
  4631  func TestDeploymentStatus_GetNodeID(tt *testing.T) {
  4632  	var zeroValue string
  4633  	d := &DeploymentStatus{NodeID: &zeroValue}
  4634  	d.GetNodeID()
  4635  	d = &DeploymentStatus{}
  4636  	d.GetNodeID()
  4637  	d = nil
  4638  	d.GetNodeID()
  4639  }
  4640  
  4641  func TestDeploymentStatus_GetRepositoryURL(tt *testing.T) {
  4642  	var zeroValue string
  4643  	d := &DeploymentStatus{RepositoryURL: &zeroValue}
  4644  	d.GetRepositoryURL()
  4645  	d = &DeploymentStatus{}
  4646  	d.GetRepositoryURL()
  4647  	d = nil
  4648  	d.GetRepositoryURL()
  4649  }
  4650  
  4651  func TestDeploymentStatus_GetState(tt *testing.T) {
  4652  	var zeroValue string
  4653  	d := &DeploymentStatus{State: &zeroValue}
  4654  	d.GetState()
  4655  	d = &DeploymentStatus{}
  4656  	d.GetState()
  4657  	d = nil
  4658  	d.GetState()
  4659  }
  4660  
  4661  func TestDeploymentStatus_GetTargetURL(tt *testing.T) {
  4662  	var zeroValue string
  4663  	d := &DeploymentStatus{TargetURL: &zeroValue}
  4664  	d.GetTargetURL()
  4665  	d = &DeploymentStatus{}
  4666  	d.GetTargetURL()
  4667  	d = nil
  4668  	d.GetTargetURL()
  4669  }
  4670  
  4671  func TestDeploymentStatus_GetUpdatedAt(tt *testing.T) {
  4672  	var zeroValue Timestamp
  4673  	d := &DeploymentStatus{UpdatedAt: &zeroValue}
  4674  	d.GetUpdatedAt()
  4675  	d = &DeploymentStatus{}
  4676  	d.GetUpdatedAt()
  4677  	d = nil
  4678  	d.GetUpdatedAt()
  4679  }
  4680  
  4681  func TestDeploymentStatus_GetURL(tt *testing.T) {
  4682  	var zeroValue string
  4683  	d := &DeploymentStatus{URL: &zeroValue}
  4684  	d.GetURL()
  4685  	d = &DeploymentStatus{}
  4686  	d.GetURL()
  4687  	d = nil
  4688  	d.GetURL()
  4689  }
  4690  
  4691  func TestDeploymentStatusEvent_GetDeployment(tt *testing.T) {
  4692  	d := &DeploymentStatusEvent{}
  4693  	d.GetDeployment()
  4694  	d = nil
  4695  	d.GetDeployment()
  4696  }
  4697  
  4698  func TestDeploymentStatusEvent_GetDeploymentStatus(tt *testing.T) {
  4699  	d := &DeploymentStatusEvent{}
  4700  	d.GetDeploymentStatus()
  4701  	d = nil
  4702  	d.GetDeploymentStatus()
  4703  }
  4704  
  4705  func TestDeploymentStatusEvent_GetInstallation(tt *testing.T) {
  4706  	d := &DeploymentStatusEvent{}
  4707  	d.GetInstallation()
  4708  	d = nil
  4709  	d.GetInstallation()
  4710  }
  4711  
  4712  func TestDeploymentStatusEvent_GetRepo(tt *testing.T) {
  4713  	d := &DeploymentStatusEvent{}
  4714  	d.GetRepo()
  4715  	d = nil
  4716  	d.GetRepo()
  4717  }
  4718  
  4719  func TestDeploymentStatusEvent_GetSender(tt *testing.T) {
  4720  	d := &DeploymentStatusEvent{}
  4721  	d.GetSender()
  4722  	d = nil
  4723  	d.GetSender()
  4724  }
  4725  
  4726  func TestDeploymentStatusRequest_GetAutoInactive(tt *testing.T) {
  4727  	var zeroValue bool
  4728  	d := &DeploymentStatusRequest{AutoInactive: &zeroValue}
  4729  	d.GetAutoInactive()
  4730  	d = &DeploymentStatusRequest{}
  4731  	d.GetAutoInactive()
  4732  	d = nil
  4733  	d.GetAutoInactive()
  4734  }
  4735  
  4736  func TestDeploymentStatusRequest_GetDescription(tt *testing.T) {
  4737  	var zeroValue string
  4738  	d := &DeploymentStatusRequest{Description: &zeroValue}
  4739  	d.GetDescription()
  4740  	d = &DeploymentStatusRequest{}
  4741  	d.GetDescription()
  4742  	d = nil
  4743  	d.GetDescription()
  4744  }
  4745  
  4746  func TestDeploymentStatusRequest_GetEnvironment(tt *testing.T) {
  4747  	var zeroValue string
  4748  	d := &DeploymentStatusRequest{Environment: &zeroValue}
  4749  	d.GetEnvironment()
  4750  	d = &DeploymentStatusRequest{}
  4751  	d.GetEnvironment()
  4752  	d = nil
  4753  	d.GetEnvironment()
  4754  }
  4755  
  4756  func TestDeploymentStatusRequest_GetEnvironmentURL(tt *testing.T) {
  4757  	var zeroValue string
  4758  	d := &DeploymentStatusRequest{EnvironmentURL: &zeroValue}
  4759  	d.GetEnvironmentURL()
  4760  	d = &DeploymentStatusRequest{}
  4761  	d.GetEnvironmentURL()
  4762  	d = nil
  4763  	d.GetEnvironmentURL()
  4764  }
  4765  
  4766  func TestDeploymentStatusRequest_GetLogURL(tt *testing.T) {
  4767  	var zeroValue string
  4768  	d := &DeploymentStatusRequest{LogURL: &zeroValue}
  4769  	d.GetLogURL()
  4770  	d = &DeploymentStatusRequest{}
  4771  	d.GetLogURL()
  4772  	d = nil
  4773  	d.GetLogURL()
  4774  }
  4775  
  4776  func TestDeploymentStatusRequest_GetState(tt *testing.T) {
  4777  	var zeroValue string
  4778  	d := &DeploymentStatusRequest{State: &zeroValue}
  4779  	d.GetState()
  4780  	d = &DeploymentStatusRequest{}
  4781  	d.GetState()
  4782  	d = nil
  4783  	d.GetState()
  4784  }
  4785  
  4786  func TestDiscussion_GetActiveLockReason(tt *testing.T) {
  4787  	var zeroValue string
  4788  	d := &Discussion{ActiveLockReason: &zeroValue}
  4789  	d.GetActiveLockReason()
  4790  	d = &Discussion{}
  4791  	d.GetActiveLockReason()
  4792  	d = nil
  4793  	d.GetActiveLockReason()
  4794  }
  4795  
  4796  func TestDiscussion_GetAnswerChosenAt(tt *testing.T) {
  4797  	var zeroValue Timestamp
  4798  	d := &Discussion{AnswerChosenAt: &zeroValue}
  4799  	d.GetAnswerChosenAt()
  4800  	d = &Discussion{}
  4801  	d.GetAnswerChosenAt()
  4802  	d = nil
  4803  	d.GetAnswerChosenAt()
  4804  }
  4805  
  4806  func TestDiscussion_GetAnswerChosenBy(tt *testing.T) {
  4807  	var zeroValue string
  4808  	d := &Discussion{AnswerChosenBy: &zeroValue}
  4809  	d.GetAnswerChosenBy()
  4810  	d = &Discussion{}
  4811  	d.GetAnswerChosenBy()
  4812  	d = nil
  4813  	d.GetAnswerChosenBy()
  4814  }
  4815  
  4816  func TestDiscussion_GetAnswerHTMLURL(tt *testing.T) {
  4817  	var zeroValue string
  4818  	d := &Discussion{AnswerHTMLURL: &zeroValue}
  4819  	d.GetAnswerHTMLURL()
  4820  	d = &Discussion{}
  4821  	d.GetAnswerHTMLURL()
  4822  	d = nil
  4823  	d.GetAnswerHTMLURL()
  4824  }
  4825  
  4826  func TestDiscussion_GetAuthorAssociation(tt *testing.T) {
  4827  	var zeroValue string
  4828  	d := &Discussion{AuthorAssociation: &zeroValue}
  4829  	d.GetAuthorAssociation()
  4830  	d = &Discussion{}
  4831  	d.GetAuthorAssociation()
  4832  	d = nil
  4833  	d.GetAuthorAssociation()
  4834  }
  4835  
  4836  func TestDiscussion_GetBody(tt *testing.T) {
  4837  	var zeroValue string
  4838  	d := &Discussion{Body: &zeroValue}
  4839  	d.GetBody()
  4840  	d = &Discussion{}
  4841  	d.GetBody()
  4842  	d = nil
  4843  	d.GetBody()
  4844  }
  4845  
  4846  func TestDiscussion_GetComments(tt *testing.T) {
  4847  	var zeroValue int
  4848  	d := &Discussion{Comments: &zeroValue}
  4849  	d.GetComments()
  4850  	d = &Discussion{}
  4851  	d.GetComments()
  4852  	d = nil
  4853  	d.GetComments()
  4854  }
  4855  
  4856  func TestDiscussion_GetCreatedAt(tt *testing.T) {
  4857  	var zeroValue Timestamp
  4858  	d := &Discussion{CreatedAt: &zeroValue}
  4859  	d.GetCreatedAt()
  4860  	d = &Discussion{}
  4861  	d.GetCreatedAt()
  4862  	d = nil
  4863  	d.GetCreatedAt()
  4864  }
  4865  
  4866  func TestDiscussion_GetDiscussionCategory(tt *testing.T) {
  4867  	d := &Discussion{}
  4868  	d.GetDiscussionCategory()
  4869  	d = nil
  4870  	d.GetDiscussionCategory()
  4871  }
  4872  
  4873  func TestDiscussion_GetHTMLURL(tt *testing.T) {
  4874  	var zeroValue string
  4875  	d := &Discussion{HTMLURL: &zeroValue}
  4876  	d.GetHTMLURL()
  4877  	d = &Discussion{}
  4878  	d.GetHTMLURL()
  4879  	d = nil
  4880  	d.GetHTMLURL()
  4881  }
  4882  
  4883  func TestDiscussion_GetID(tt *testing.T) {
  4884  	var zeroValue int64
  4885  	d := &Discussion{ID: &zeroValue}
  4886  	d.GetID()
  4887  	d = &Discussion{}
  4888  	d.GetID()
  4889  	d = nil
  4890  	d.GetID()
  4891  }
  4892  
  4893  func TestDiscussion_GetLocked(tt *testing.T) {
  4894  	var zeroValue bool
  4895  	d := &Discussion{Locked: &zeroValue}
  4896  	d.GetLocked()
  4897  	d = &Discussion{}
  4898  	d.GetLocked()
  4899  	d = nil
  4900  	d.GetLocked()
  4901  }
  4902  
  4903  func TestDiscussion_GetNodeID(tt *testing.T) {
  4904  	var zeroValue string
  4905  	d := &Discussion{NodeID: &zeroValue}
  4906  	d.GetNodeID()
  4907  	d = &Discussion{}
  4908  	d.GetNodeID()
  4909  	d = nil
  4910  	d.GetNodeID()
  4911  }
  4912  
  4913  func TestDiscussion_GetNumber(tt *testing.T) {
  4914  	var zeroValue int
  4915  	d := &Discussion{Number: &zeroValue}
  4916  	d.GetNumber()
  4917  	d = &Discussion{}
  4918  	d.GetNumber()
  4919  	d = nil
  4920  	d.GetNumber()
  4921  }
  4922  
  4923  func TestDiscussion_GetRepositoryURL(tt *testing.T) {
  4924  	var zeroValue string
  4925  	d := &Discussion{RepositoryURL: &zeroValue}
  4926  	d.GetRepositoryURL()
  4927  	d = &Discussion{}
  4928  	d.GetRepositoryURL()
  4929  	d = nil
  4930  	d.GetRepositoryURL()
  4931  }
  4932  
  4933  func TestDiscussion_GetState(tt *testing.T) {
  4934  	var zeroValue string
  4935  	d := &Discussion{State: &zeroValue}
  4936  	d.GetState()
  4937  	d = &Discussion{}
  4938  	d.GetState()
  4939  	d = nil
  4940  	d.GetState()
  4941  }
  4942  
  4943  func TestDiscussion_GetTitle(tt *testing.T) {
  4944  	var zeroValue string
  4945  	d := &Discussion{Title: &zeroValue}
  4946  	d.GetTitle()
  4947  	d = &Discussion{}
  4948  	d.GetTitle()
  4949  	d = nil
  4950  	d.GetTitle()
  4951  }
  4952  
  4953  func TestDiscussion_GetUpdatedAt(tt *testing.T) {
  4954  	var zeroValue Timestamp
  4955  	d := &Discussion{UpdatedAt: &zeroValue}
  4956  	d.GetUpdatedAt()
  4957  	d = &Discussion{}
  4958  	d.GetUpdatedAt()
  4959  	d = nil
  4960  	d.GetUpdatedAt()
  4961  }
  4962  
  4963  func TestDiscussion_GetUser(tt *testing.T) {
  4964  	d := &Discussion{}
  4965  	d.GetUser()
  4966  	d = nil
  4967  	d.GetUser()
  4968  }
  4969  
  4970  func TestDiscussionCategory_GetCreatedAt(tt *testing.T) {
  4971  	var zeroValue Timestamp
  4972  	d := &DiscussionCategory{CreatedAt: &zeroValue}
  4973  	d.GetCreatedAt()
  4974  	d = &DiscussionCategory{}
  4975  	d.GetCreatedAt()
  4976  	d = nil
  4977  	d.GetCreatedAt()
  4978  }
  4979  
  4980  func TestDiscussionCategory_GetDescription(tt *testing.T) {
  4981  	var zeroValue string
  4982  	d := &DiscussionCategory{Description: &zeroValue}
  4983  	d.GetDescription()
  4984  	d = &DiscussionCategory{}
  4985  	d.GetDescription()
  4986  	d = nil
  4987  	d.GetDescription()
  4988  }
  4989  
  4990  func TestDiscussionCategory_GetEmoji(tt *testing.T) {
  4991  	var zeroValue string
  4992  	d := &DiscussionCategory{Emoji: &zeroValue}
  4993  	d.GetEmoji()
  4994  	d = &DiscussionCategory{}
  4995  	d.GetEmoji()
  4996  	d = nil
  4997  	d.GetEmoji()
  4998  }
  4999  
  5000  func TestDiscussionCategory_GetID(tt *testing.T) {
  5001  	var zeroValue int64
  5002  	d := &DiscussionCategory{ID: &zeroValue}
  5003  	d.GetID()
  5004  	d = &DiscussionCategory{}
  5005  	d.GetID()
  5006  	d = nil
  5007  	d.GetID()
  5008  }
  5009  
  5010  func TestDiscussionCategory_GetIsAnswerable(tt *testing.T) {
  5011  	var zeroValue bool
  5012  	d := &DiscussionCategory{IsAnswerable: &zeroValue}
  5013  	d.GetIsAnswerable()
  5014  	d = &DiscussionCategory{}
  5015  	d.GetIsAnswerable()
  5016  	d = nil
  5017  	d.GetIsAnswerable()
  5018  }
  5019  
  5020  func TestDiscussionCategory_GetName(tt *testing.T) {
  5021  	var zeroValue string
  5022  	d := &DiscussionCategory{Name: &zeroValue}
  5023  	d.GetName()
  5024  	d = &DiscussionCategory{}
  5025  	d.GetName()
  5026  	d = nil
  5027  	d.GetName()
  5028  }
  5029  
  5030  func TestDiscussionCategory_GetNodeID(tt *testing.T) {
  5031  	var zeroValue string
  5032  	d := &DiscussionCategory{NodeID: &zeroValue}
  5033  	d.GetNodeID()
  5034  	d = &DiscussionCategory{}
  5035  	d.GetNodeID()
  5036  	d = nil
  5037  	d.GetNodeID()
  5038  }
  5039  
  5040  func TestDiscussionCategory_GetRepositoryID(tt *testing.T) {
  5041  	var zeroValue int64
  5042  	d := &DiscussionCategory{RepositoryID: &zeroValue}
  5043  	d.GetRepositoryID()
  5044  	d = &DiscussionCategory{}
  5045  	d.GetRepositoryID()
  5046  	d = nil
  5047  	d.GetRepositoryID()
  5048  }
  5049  
  5050  func TestDiscussionCategory_GetSlug(tt *testing.T) {
  5051  	var zeroValue string
  5052  	d := &DiscussionCategory{Slug: &zeroValue}
  5053  	d.GetSlug()
  5054  	d = &DiscussionCategory{}
  5055  	d.GetSlug()
  5056  	d = nil
  5057  	d.GetSlug()
  5058  }
  5059  
  5060  func TestDiscussionCategory_GetUpdatedAt(tt *testing.T) {
  5061  	var zeroValue Timestamp
  5062  	d := &DiscussionCategory{UpdatedAt: &zeroValue}
  5063  	d.GetUpdatedAt()
  5064  	d = &DiscussionCategory{}
  5065  	d.GetUpdatedAt()
  5066  	d = nil
  5067  	d.GetUpdatedAt()
  5068  }
  5069  
  5070  func TestDiscussionComment_GetAuthor(tt *testing.T) {
  5071  	d := &DiscussionComment{}
  5072  	d.GetAuthor()
  5073  	d = nil
  5074  	d.GetAuthor()
  5075  }
  5076  
  5077  func TestDiscussionComment_GetBody(tt *testing.T) {
  5078  	var zeroValue string
  5079  	d := &DiscussionComment{Body: &zeroValue}
  5080  	d.GetBody()
  5081  	d = &DiscussionComment{}
  5082  	d.GetBody()
  5083  	d = nil
  5084  	d.GetBody()
  5085  }
  5086  
  5087  func TestDiscussionComment_GetBodyHTML(tt *testing.T) {
  5088  	var zeroValue string
  5089  	d := &DiscussionComment{BodyHTML: &zeroValue}
  5090  	d.GetBodyHTML()
  5091  	d = &DiscussionComment{}
  5092  	d.GetBodyHTML()
  5093  	d = nil
  5094  	d.GetBodyHTML()
  5095  }
  5096  
  5097  func TestDiscussionComment_GetBodyVersion(tt *testing.T) {
  5098  	var zeroValue string
  5099  	d := &DiscussionComment{BodyVersion: &zeroValue}
  5100  	d.GetBodyVersion()
  5101  	d = &DiscussionComment{}
  5102  	d.GetBodyVersion()
  5103  	d = nil
  5104  	d.GetBodyVersion()
  5105  }
  5106  
  5107  func TestDiscussionComment_GetCreatedAt(tt *testing.T) {
  5108  	var zeroValue Timestamp
  5109  	d := &DiscussionComment{CreatedAt: &zeroValue}
  5110  	d.GetCreatedAt()
  5111  	d = &DiscussionComment{}
  5112  	d.GetCreatedAt()
  5113  	d = nil
  5114  	d.GetCreatedAt()
  5115  }
  5116  
  5117  func TestDiscussionComment_GetDiscussionURL(tt *testing.T) {
  5118  	var zeroValue string
  5119  	d := &DiscussionComment{DiscussionURL: &zeroValue}
  5120  	d.GetDiscussionURL()
  5121  	d = &DiscussionComment{}
  5122  	d.GetDiscussionURL()
  5123  	d = nil
  5124  	d.GetDiscussionURL()
  5125  }
  5126  
  5127  func TestDiscussionComment_GetHTMLURL(tt *testing.T) {
  5128  	var zeroValue string
  5129  	d := &DiscussionComment{HTMLURL: &zeroValue}
  5130  	d.GetHTMLURL()
  5131  	d = &DiscussionComment{}
  5132  	d.GetHTMLURL()
  5133  	d = nil
  5134  	d.GetHTMLURL()
  5135  }
  5136  
  5137  func TestDiscussionComment_GetLastEditedAt(tt *testing.T) {
  5138  	var zeroValue Timestamp
  5139  	d := &DiscussionComment{LastEditedAt: &zeroValue}
  5140  	d.GetLastEditedAt()
  5141  	d = &DiscussionComment{}
  5142  	d.GetLastEditedAt()
  5143  	d = nil
  5144  	d.GetLastEditedAt()
  5145  }
  5146  
  5147  func TestDiscussionComment_GetNodeID(tt *testing.T) {
  5148  	var zeroValue string
  5149  	d := &DiscussionComment{NodeID: &zeroValue}
  5150  	d.GetNodeID()
  5151  	d = &DiscussionComment{}
  5152  	d.GetNodeID()
  5153  	d = nil
  5154  	d.GetNodeID()
  5155  }
  5156  
  5157  func TestDiscussionComment_GetNumber(tt *testing.T) {
  5158  	var zeroValue int
  5159  	d := &DiscussionComment{Number: &zeroValue}
  5160  	d.GetNumber()
  5161  	d = &DiscussionComment{}
  5162  	d.GetNumber()
  5163  	d = nil
  5164  	d.GetNumber()
  5165  }
  5166  
  5167  func TestDiscussionComment_GetReactions(tt *testing.T) {
  5168  	d := &DiscussionComment{}
  5169  	d.GetReactions()
  5170  	d = nil
  5171  	d.GetReactions()
  5172  }
  5173  
  5174  func TestDiscussionComment_GetUpdatedAt(tt *testing.T) {
  5175  	var zeroValue Timestamp
  5176  	d := &DiscussionComment{UpdatedAt: &zeroValue}
  5177  	d.GetUpdatedAt()
  5178  	d = &DiscussionComment{}
  5179  	d.GetUpdatedAt()
  5180  	d = nil
  5181  	d.GetUpdatedAt()
  5182  }
  5183  
  5184  func TestDiscussionComment_GetURL(tt *testing.T) {
  5185  	var zeroValue string
  5186  	d := &DiscussionComment{URL: &zeroValue}
  5187  	d.GetURL()
  5188  	d = &DiscussionComment{}
  5189  	d.GetURL()
  5190  	d = nil
  5191  	d.GetURL()
  5192  }
  5193  
  5194  func TestDiscussionEvent_GetAction(tt *testing.T) {
  5195  	var zeroValue string
  5196  	d := &DiscussionEvent{Action: &zeroValue}
  5197  	d.GetAction()
  5198  	d = &DiscussionEvent{}
  5199  	d.GetAction()
  5200  	d = nil
  5201  	d.GetAction()
  5202  }
  5203  
  5204  func TestDiscussionEvent_GetDiscussion(tt *testing.T) {
  5205  	d := &DiscussionEvent{}
  5206  	d.GetDiscussion()
  5207  	d = nil
  5208  	d.GetDiscussion()
  5209  }
  5210  
  5211  func TestDiscussionEvent_GetInstallation(tt *testing.T) {
  5212  	d := &DiscussionEvent{}
  5213  	d.GetInstallation()
  5214  	d = nil
  5215  	d.GetInstallation()
  5216  }
  5217  
  5218  func TestDiscussionEvent_GetOrg(tt *testing.T) {
  5219  	d := &DiscussionEvent{}
  5220  	d.GetOrg()
  5221  	d = nil
  5222  	d.GetOrg()
  5223  }
  5224  
  5225  func TestDiscussionEvent_GetRepo(tt *testing.T) {
  5226  	d := &DiscussionEvent{}
  5227  	d.GetRepo()
  5228  	d = nil
  5229  	d.GetRepo()
  5230  }
  5231  
  5232  func TestDiscussionEvent_GetSender(tt *testing.T) {
  5233  	d := &DiscussionEvent{}
  5234  	d.GetSender()
  5235  	d = nil
  5236  	d.GetSender()
  5237  }
  5238  
  5239  func TestDismissalRestrictionsRequest_GetTeams(tt *testing.T) {
  5240  	var zeroValue []string
  5241  	d := &DismissalRestrictionsRequest{Teams: &zeroValue}
  5242  	d.GetTeams()
  5243  	d = &DismissalRestrictionsRequest{}
  5244  	d.GetTeams()
  5245  	d = nil
  5246  	d.GetTeams()
  5247  }
  5248  
  5249  func TestDismissalRestrictionsRequest_GetUsers(tt *testing.T) {
  5250  	var zeroValue []string
  5251  	d := &DismissalRestrictionsRequest{Users: &zeroValue}
  5252  	d.GetUsers()
  5253  	d = &DismissalRestrictionsRequest{}
  5254  	d.GetUsers()
  5255  	d = nil
  5256  	d.GetUsers()
  5257  }
  5258  
  5259  func TestDismissedReview_GetDismissalCommitID(tt *testing.T) {
  5260  	var zeroValue string
  5261  	d := &DismissedReview{DismissalCommitID: &zeroValue}
  5262  	d.GetDismissalCommitID()
  5263  	d = &DismissedReview{}
  5264  	d.GetDismissalCommitID()
  5265  	d = nil
  5266  	d.GetDismissalCommitID()
  5267  }
  5268  
  5269  func TestDismissedReview_GetDismissalMessage(tt *testing.T) {
  5270  	var zeroValue string
  5271  	d := &DismissedReview{DismissalMessage: &zeroValue}
  5272  	d.GetDismissalMessage()
  5273  	d = &DismissedReview{}
  5274  	d.GetDismissalMessage()
  5275  	d = nil
  5276  	d.GetDismissalMessage()
  5277  }
  5278  
  5279  func TestDismissedReview_GetReviewID(tt *testing.T) {
  5280  	var zeroValue int64
  5281  	d := &DismissedReview{ReviewID: &zeroValue}
  5282  	d.GetReviewID()
  5283  	d = &DismissedReview{}
  5284  	d.GetReviewID()
  5285  	d = nil
  5286  	d.GetReviewID()
  5287  }
  5288  
  5289  func TestDismissedReview_GetState(tt *testing.T) {
  5290  	var zeroValue string
  5291  	d := &DismissedReview{State: &zeroValue}
  5292  	d.GetState()
  5293  	d = &DismissedReview{}
  5294  	d.GetState()
  5295  	d = nil
  5296  	d.GetState()
  5297  }
  5298  
  5299  func TestDispatchRequestOptions_GetClientPayload(tt *testing.T) {
  5300  	var zeroValue json.RawMessage
  5301  	d := &DispatchRequestOptions{ClientPayload: &zeroValue}
  5302  	d.GetClientPayload()
  5303  	d = &DispatchRequestOptions{}
  5304  	d.GetClientPayload()
  5305  	d = nil
  5306  	d.GetClientPayload()
  5307  }
  5308  
  5309  func TestDraftReviewComment_GetBody(tt *testing.T) {
  5310  	var zeroValue string
  5311  	d := &DraftReviewComment{Body: &zeroValue}
  5312  	d.GetBody()
  5313  	d = &DraftReviewComment{}
  5314  	d.GetBody()
  5315  	d = nil
  5316  	d.GetBody()
  5317  }
  5318  
  5319  func TestDraftReviewComment_GetLine(tt *testing.T) {
  5320  	var zeroValue int
  5321  	d := &DraftReviewComment{Line: &zeroValue}
  5322  	d.GetLine()
  5323  	d = &DraftReviewComment{}
  5324  	d.GetLine()
  5325  	d = nil
  5326  	d.GetLine()
  5327  }
  5328  
  5329  func TestDraftReviewComment_GetPath(tt *testing.T) {
  5330  	var zeroValue string
  5331  	d := &DraftReviewComment{Path: &zeroValue}
  5332  	d.GetPath()
  5333  	d = &DraftReviewComment{}
  5334  	d.GetPath()
  5335  	d = nil
  5336  	d.GetPath()
  5337  }
  5338  
  5339  func TestDraftReviewComment_GetPosition(tt *testing.T) {
  5340  	var zeroValue int
  5341  	d := &DraftReviewComment{Position: &zeroValue}
  5342  	d.GetPosition()
  5343  	d = &DraftReviewComment{}
  5344  	d.GetPosition()
  5345  	d = nil
  5346  	d.GetPosition()
  5347  }
  5348  
  5349  func TestDraftReviewComment_GetSide(tt *testing.T) {
  5350  	var zeroValue string
  5351  	d := &DraftReviewComment{Side: &zeroValue}
  5352  	d.GetSide()
  5353  	d = &DraftReviewComment{}
  5354  	d.GetSide()
  5355  	d = nil
  5356  	d.GetSide()
  5357  }
  5358  
  5359  func TestDraftReviewComment_GetStartLine(tt *testing.T) {
  5360  	var zeroValue int
  5361  	d := &DraftReviewComment{StartLine: &zeroValue}
  5362  	d.GetStartLine()
  5363  	d = &DraftReviewComment{}
  5364  	d.GetStartLine()
  5365  	d = nil
  5366  	d.GetStartLine()
  5367  }
  5368  
  5369  func TestDraftReviewComment_GetStartSide(tt *testing.T) {
  5370  	var zeroValue string
  5371  	d := &DraftReviewComment{StartSide: &zeroValue}
  5372  	d.GetStartSide()
  5373  	d = &DraftReviewComment{}
  5374  	d.GetStartSide()
  5375  	d = nil
  5376  	d.GetStartSide()
  5377  }
  5378  
  5379  func TestEditBase_GetRef(tt *testing.T) {
  5380  	e := &EditBase{}
  5381  	e.GetRef()
  5382  	e = nil
  5383  	e.GetRef()
  5384  }
  5385  
  5386  func TestEditBase_GetSHA(tt *testing.T) {
  5387  	e := &EditBase{}
  5388  	e.GetSHA()
  5389  	e = nil
  5390  	e.GetSHA()
  5391  }
  5392  
  5393  func TestEditBody_GetFrom(tt *testing.T) {
  5394  	var zeroValue string
  5395  	e := &EditBody{From: &zeroValue}
  5396  	e.GetFrom()
  5397  	e = &EditBody{}
  5398  	e.GetFrom()
  5399  	e = nil
  5400  	e.GetFrom()
  5401  }
  5402  
  5403  func TestEditChange_GetBase(tt *testing.T) {
  5404  	e := &EditChange{}
  5405  	e.GetBase()
  5406  	e = nil
  5407  	e.GetBase()
  5408  }
  5409  
  5410  func TestEditChange_GetBody(tt *testing.T) {
  5411  	e := &EditChange{}
  5412  	e.GetBody()
  5413  	e = nil
  5414  	e.GetBody()
  5415  }
  5416  
  5417  func TestEditChange_GetRepo(tt *testing.T) {
  5418  	e := &EditChange{}
  5419  	e.GetRepo()
  5420  	e = nil
  5421  	e.GetRepo()
  5422  }
  5423  
  5424  func TestEditChange_GetTitle(tt *testing.T) {
  5425  	e := &EditChange{}
  5426  	e.GetTitle()
  5427  	e = nil
  5428  	e.GetTitle()
  5429  }
  5430  
  5431  func TestEditRef_GetFrom(tt *testing.T) {
  5432  	var zeroValue string
  5433  	e := &EditRef{From: &zeroValue}
  5434  	e.GetFrom()
  5435  	e = &EditRef{}
  5436  	e.GetFrom()
  5437  	e = nil
  5438  	e.GetFrom()
  5439  }
  5440  
  5441  func TestEditRepo_GetName(tt *testing.T) {
  5442  	e := &EditRepo{}
  5443  	e.GetName()
  5444  	e = nil
  5445  	e.GetName()
  5446  }
  5447  
  5448  func TestEditSHA_GetFrom(tt *testing.T) {
  5449  	var zeroValue string
  5450  	e := &EditSHA{From: &zeroValue}
  5451  	e.GetFrom()
  5452  	e = &EditSHA{}
  5453  	e.GetFrom()
  5454  	e = nil
  5455  	e.GetFrom()
  5456  }
  5457  
  5458  func TestEditTitle_GetFrom(tt *testing.T) {
  5459  	var zeroValue string
  5460  	e := &EditTitle{From: &zeroValue}
  5461  	e.GetFrom()
  5462  	e = &EditTitle{}
  5463  	e.GetFrom()
  5464  	e = nil
  5465  	e.GetFrom()
  5466  }
  5467  
  5468  func TestEnterprise_GetAvatarURL(tt *testing.T) {
  5469  	var zeroValue string
  5470  	e := &Enterprise{AvatarURL: &zeroValue}
  5471  	e.GetAvatarURL()
  5472  	e = &Enterprise{}
  5473  	e.GetAvatarURL()
  5474  	e = nil
  5475  	e.GetAvatarURL()
  5476  }
  5477  
  5478  func TestEnterprise_GetCreatedAt(tt *testing.T) {
  5479  	var zeroValue Timestamp
  5480  	e := &Enterprise{CreatedAt: &zeroValue}
  5481  	e.GetCreatedAt()
  5482  	e = &Enterprise{}
  5483  	e.GetCreatedAt()
  5484  	e = nil
  5485  	e.GetCreatedAt()
  5486  }
  5487  
  5488  func TestEnterprise_GetDescription(tt *testing.T) {
  5489  	var zeroValue string
  5490  	e := &Enterprise{Description: &zeroValue}
  5491  	e.GetDescription()
  5492  	e = &Enterprise{}
  5493  	e.GetDescription()
  5494  	e = nil
  5495  	e.GetDescription()
  5496  }
  5497  
  5498  func TestEnterprise_GetHTMLURL(tt *testing.T) {
  5499  	var zeroValue string
  5500  	e := &Enterprise{HTMLURL: &zeroValue}
  5501  	e.GetHTMLURL()
  5502  	e = &Enterprise{}
  5503  	e.GetHTMLURL()
  5504  	e = nil
  5505  	e.GetHTMLURL()
  5506  }
  5507  
  5508  func TestEnterprise_GetID(tt *testing.T) {
  5509  	var zeroValue int
  5510  	e := &Enterprise{ID: &zeroValue}
  5511  	e.GetID()
  5512  	e = &Enterprise{}
  5513  	e.GetID()
  5514  	e = nil
  5515  	e.GetID()
  5516  }
  5517  
  5518  func TestEnterprise_GetName(tt *testing.T) {
  5519  	var zeroValue string
  5520  	e := &Enterprise{Name: &zeroValue}
  5521  	e.GetName()
  5522  	e = &Enterprise{}
  5523  	e.GetName()
  5524  	e = nil
  5525  	e.GetName()
  5526  }
  5527  
  5528  func TestEnterprise_GetNodeID(tt *testing.T) {
  5529  	var zeroValue string
  5530  	e := &Enterprise{NodeID: &zeroValue}
  5531  	e.GetNodeID()
  5532  	e = &Enterprise{}
  5533  	e.GetNodeID()
  5534  	e = nil
  5535  	e.GetNodeID()
  5536  }
  5537  
  5538  func TestEnterprise_GetSlug(tt *testing.T) {
  5539  	var zeroValue string
  5540  	e := &Enterprise{Slug: &zeroValue}
  5541  	e.GetSlug()
  5542  	e = &Enterprise{}
  5543  	e.GetSlug()
  5544  	e = nil
  5545  	e.GetSlug()
  5546  }
  5547  
  5548  func TestEnterprise_GetUpdatedAt(tt *testing.T) {
  5549  	var zeroValue Timestamp
  5550  	e := &Enterprise{UpdatedAt: &zeroValue}
  5551  	e.GetUpdatedAt()
  5552  	e = &Enterprise{}
  5553  	e.GetUpdatedAt()
  5554  	e = nil
  5555  	e.GetUpdatedAt()
  5556  }
  5557  
  5558  func TestEnterprise_GetWebsiteURL(tt *testing.T) {
  5559  	var zeroValue string
  5560  	e := &Enterprise{WebsiteURL: &zeroValue}
  5561  	e.GetWebsiteURL()
  5562  	e = &Enterprise{}
  5563  	e.GetWebsiteURL()
  5564  	e = nil
  5565  	e.GetWebsiteURL()
  5566  }
  5567  
  5568  func TestEnvironment_GetCreatedAt(tt *testing.T) {
  5569  	var zeroValue Timestamp
  5570  	e := &Environment{CreatedAt: &zeroValue}
  5571  	e.GetCreatedAt()
  5572  	e = &Environment{}
  5573  	e.GetCreatedAt()
  5574  	e = nil
  5575  	e.GetCreatedAt()
  5576  }
  5577  
  5578  func TestEnvironment_GetDeploymentBranchPolicy(tt *testing.T) {
  5579  	e := &Environment{}
  5580  	e.GetDeploymentBranchPolicy()
  5581  	e = nil
  5582  	e.GetDeploymentBranchPolicy()
  5583  }
  5584  
  5585  func TestEnvironment_GetEnvironmentName(tt *testing.T) {
  5586  	var zeroValue string
  5587  	e := &Environment{EnvironmentName: &zeroValue}
  5588  	e.GetEnvironmentName()
  5589  	e = &Environment{}
  5590  	e.GetEnvironmentName()
  5591  	e = nil
  5592  	e.GetEnvironmentName()
  5593  }
  5594  
  5595  func TestEnvironment_GetHTMLURL(tt *testing.T) {
  5596  	var zeroValue string
  5597  	e := &Environment{HTMLURL: &zeroValue}
  5598  	e.GetHTMLURL()
  5599  	e = &Environment{}
  5600  	e.GetHTMLURL()
  5601  	e = nil
  5602  	e.GetHTMLURL()
  5603  }
  5604  
  5605  func TestEnvironment_GetID(tt *testing.T) {
  5606  	var zeroValue int64
  5607  	e := &Environment{ID: &zeroValue}
  5608  	e.GetID()
  5609  	e = &Environment{}
  5610  	e.GetID()
  5611  	e = nil
  5612  	e.GetID()
  5613  }
  5614  
  5615  func TestEnvironment_GetName(tt *testing.T) {
  5616  	var zeroValue string
  5617  	e := &Environment{Name: &zeroValue}
  5618  	e.GetName()
  5619  	e = &Environment{}
  5620  	e.GetName()
  5621  	e = nil
  5622  	e.GetName()
  5623  }
  5624  
  5625  func TestEnvironment_GetNodeID(tt *testing.T) {
  5626  	var zeroValue string
  5627  	e := &Environment{NodeID: &zeroValue}
  5628  	e.GetNodeID()
  5629  	e = &Environment{}
  5630  	e.GetNodeID()
  5631  	e = nil
  5632  	e.GetNodeID()
  5633  }
  5634  
  5635  func TestEnvironment_GetOwner(tt *testing.T) {
  5636  	var zeroValue string
  5637  	e := &Environment{Owner: &zeroValue}
  5638  	e.GetOwner()
  5639  	e = &Environment{}
  5640  	e.GetOwner()
  5641  	e = nil
  5642  	e.GetOwner()
  5643  }
  5644  
  5645  func TestEnvironment_GetRepo(tt *testing.T) {
  5646  	var zeroValue string
  5647  	e := &Environment{Repo: &zeroValue}
  5648  	e.GetRepo()
  5649  	e = &Environment{}
  5650  	e.GetRepo()
  5651  	e = nil
  5652  	e.GetRepo()
  5653  }
  5654  
  5655  func TestEnvironment_GetUpdatedAt(tt *testing.T) {
  5656  	var zeroValue Timestamp
  5657  	e := &Environment{UpdatedAt: &zeroValue}
  5658  	e.GetUpdatedAt()
  5659  	e = &Environment{}
  5660  	e.GetUpdatedAt()
  5661  	e = nil
  5662  	e.GetUpdatedAt()
  5663  }
  5664  
  5665  func TestEnvironment_GetURL(tt *testing.T) {
  5666  	var zeroValue string
  5667  	e := &Environment{URL: &zeroValue}
  5668  	e.GetURL()
  5669  	e = &Environment{}
  5670  	e.GetURL()
  5671  	e = nil
  5672  	e.GetURL()
  5673  }
  5674  
  5675  func TestEnvironment_GetWaitTimer(tt *testing.T) {
  5676  	var zeroValue int
  5677  	e := &Environment{WaitTimer: &zeroValue}
  5678  	e.GetWaitTimer()
  5679  	e = &Environment{}
  5680  	e.GetWaitTimer()
  5681  	e = nil
  5682  	e.GetWaitTimer()
  5683  }
  5684  
  5685  func TestEnvResponse_GetTotalCount(tt *testing.T) {
  5686  	var zeroValue int
  5687  	e := &EnvResponse{TotalCount: &zeroValue}
  5688  	e.GetTotalCount()
  5689  	e = &EnvResponse{}
  5690  	e.GetTotalCount()
  5691  	e = nil
  5692  	e.GetTotalCount()
  5693  }
  5694  
  5695  func TestEnvReviewers_GetID(tt *testing.T) {
  5696  	var zeroValue int64
  5697  	e := &EnvReviewers{ID: &zeroValue}
  5698  	e.GetID()
  5699  	e = &EnvReviewers{}
  5700  	e.GetID()
  5701  	e = nil
  5702  	e.GetID()
  5703  }
  5704  
  5705  func TestEnvReviewers_GetType(tt *testing.T) {
  5706  	var zeroValue string
  5707  	e := &EnvReviewers{Type: &zeroValue}
  5708  	e.GetType()
  5709  	e = &EnvReviewers{}
  5710  	e.GetType()
  5711  	e = nil
  5712  	e.GetType()
  5713  }
  5714  
  5715  func TestErrorBlock_GetCreatedAt(tt *testing.T) {
  5716  	var zeroValue Timestamp
  5717  	e := &ErrorBlock{CreatedAt: &zeroValue}
  5718  	e.GetCreatedAt()
  5719  	e = &ErrorBlock{}
  5720  	e.GetCreatedAt()
  5721  	e = nil
  5722  	e.GetCreatedAt()
  5723  }
  5724  
  5725  func TestErrorResponse_GetBlock(tt *testing.T) {
  5726  	e := &ErrorResponse{}
  5727  	e.GetBlock()
  5728  	e = nil
  5729  	e.GetBlock()
  5730  }
  5731  
  5732  func TestEvent_GetActor(tt *testing.T) {
  5733  	e := &Event{}
  5734  	e.GetActor()
  5735  	e = nil
  5736  	e.GetActor()
  5737  }
  5738  
  5739  func TestEvent_GetCreatedAt(tt *testing.T) {
  5740  	var zeroValue time.Time
  5741  	e := &Event{CreatedAt: &zeroValue}
  5742  	e.GetCreatedAt()
  5743  	e = &Event{}
  5744  	e.GetCreatedAt()
  5745  	e = nil
  5746  	e.GetCreatedAt()
  5747  }
  5748  
  5749  func TestEvent_GetID(tt *testing.T) {
  5750  	var zeroValue string
  5751  	e := &Event{ID: &zeroValue}
  5752  	e.GetID()
  5753  	e = &Event{}
  5754  	e.GetID()
  5755  	e = nil
  5756  	e.GetID()
  5757  }
  5758  
  5759  func TestEvent_GetOrg(tt *testing.T) {
  5760  	e := &Event{}
  5761  	e.GetOrg()
  5762  	e = nil
  5763  	e.GetOrg()
  5764  }
  5765  
  5766  func TestEvent_GetPublic(tt *testing.T) {
  5767  	var zeroValue bool
  5768  	e := &Event{Public: &zeroValue}
  5769  	e.GetPublic()
  5770  	e = &Event{}
  5771  	e.GetPublic()
  5772  	e = nil
  5773  	e.GetPublic()
  5774  }
  5775  
  5776  func TestEvent_GetRawPayload(tt *testing.T) {
  5777  	var zeroValue json.RawMessage
  5778  	e := &Event{RawPayload: &zeroValue}
  5779  	e.GetRawPayload()
  5780  	e = &Event{}
  5781  	e.GetRawPayload()
  5782  	e = nil
  5783  	e.GetRawPayload()
  5784  }
  5785  
  5786  func TestEvent_GetRepo(tt *testing.T) {
  5787  	e := &Event{}
  5788  	e.GetRepo()
  5789  	e = nil
  5790  	e.GetRepo()
  5791  }
  5792  
  5793  func TestEvent_GetType(tt *testing.T) {
  5794  	var zeroValue string
  5795  	e := &Event{Type: &zeroValue}
  5796  	e.GetType()
  5797  	e = &Event{}
  5798  	e.GetType()
  5799  	e = nil
  5800  	e.GetType()
  5801  }
  5802  
  5803  func TestExternalGroup_GetGroupID(tt *testing.T) {
  5804  	var zeroValue int64
  5805  	e := &ExternalGroup{GroupID: &zeroValue}
  5806  	e.GetGroupID()
  5807  	e = &ExternalGroup{}
  5808  	e.GetGroupID()
  5809  	e = nil
  5810  	e.GetGroupID()
  5811  }
  5812  
  5813  func TestExternalGroup_GetGroupName(tt *testing.T) {
  5814  	var zeroValue string
  5815  	e := &ExternalGroup{GroupName: &zeroValue}
  5816  	e.GetGroupName()
  5817  	e = &ExternalGroup{}
  5818  	e.GetGroupName()
  5819  	e = nil
  5820  	e.GetGroupName()
  5821  }
  5822  
  5823  func TestExternalGroup_GetUpdatedAt(tt *testing.T) {
  5824  	var zeroValue Timestamp
  5825  	e := &ExternalGroup{UpdatedAt: &zeroValue}
  5826  	e.GetUpdatedAt()
  5827  	e = &ExternalGroup{}
  5828  	e.GetUpdatedAt()
  5829  	e = nil
  5830  	e.GetUpdatedAt()
  5831  }
  5832  
  5833  func TestExternalGroupMember_GetMemberEmail(tt *testing.T) {
  5834  	var zeroValue string
  5835  	e := &ExternalGroupMember{MemberEmail: &zeroValue}
  5836  	e.GetMemberEmail()
  5837  	e = &ExternalGroupMember{}
  5838  	e.GetMemberEmail()
  5839  	e = nil
  5840  	e.GetMemberEmail()
  5841  }
  5842  
  5843  func TestExternalGroupMember_GetMemberID(tt *testing.T) {
  5844  	var zeroValue int64
  5845  	e := &ExternalGroupMember{MemberID: &zeroValue}
  5846  	e.GetMemberID()
  5847  	e = &ExternalGroupMember{}
  5848  	e.GetMemberID()
  5849  	e = nil
  5850  	e.GetMemberID()
  5851  }
  5852  
  5853  func TestExternalGroupMember_GetMemberLogin(tt *testing.T) {
  5854  	var zeroValue string
  5855  	e := &ExternalGroupMember{MemberLogin: &zeroValue}
  5856  	e.GetMemberLogin()
  5857  	e = &ExternalGroupMember{}
  5858  	e.GetMemberLogin()
  5859  	e = nil
  5860  	e.GetMemberLogin()
  5861  }
  5862  
  5863  func TestExternalGroupMember_GetMemberName(tt *testing.T) {
  5864  	var zeroValue string
  5865  	e := &ExternalGroupMember{MemberName: &zeroValue}
  5866  	e.GetMemberName()
  5867  	e = &ExternalGroupMember{}
  5868  	e.GetMemberName()
  5869  	e = nil
  5870  	e.GetMemberName()
  5871  }
  5872  
  5873  func TestExternalGroupTeam_GetTeamID(tt *testing.T) {
  5874  	var zeroValue int64
  5875  	e := &ExternalGroupTeam{TeamID: &zeroValue}
  5876  	e.GetTeamID()
  5877  	e = &ExternalGroupTeam{}
  5878  	e.GetTeamID()
  5879  	e = nil
  5880  	e.GetTeamID()
  5881  }
  5882  
  5883  func TestExternalGroupTeam_GetTeamName(tt *testing.T) {
  5884  	var zeroValue string
  5885  	e := &ExternalGroupTeam{TeamName: &zeroValue}
  5886  	e.GetTeamName()
  5887  	e = &ExternalGroupTeam{}
  5888  	e.GetTeamName()
  5889  	e = nil
  5890  	e.GetTeamName()
  5891  }
  5892  
  5893  func TestFeedLink_GetHRef(tt *testing.T) {
  5894  	var zeroValue string
  5895  	f := &FeedLink{HRef: &zeroValue}
  5896  	f.GetHRef()
  5897  	f = &FeedLink{}
  5898  	f.GetHRef()
  5899  	f = nil
  5900  	f.GetHRef()
  5901  }
  5902  
  5903  func TestFeedLink_GetType(tt *testing.T) {
  5904  	var zeroValue string
  5905  	f := &FeedLink{Type: &zeroValue}
  5906  	f.GetType()
  5907  	f = &FeedLink{}
  5908  	f.GetType()
  5909  	f = nil
  5910  	f.GetType()
  5911  }
  5912  
  5913  func TestFeedLinks_GetCurrentUser(tt *testing.T) {
  5914  	f := &FeedLinks{}
  5915  	f.GetCurrentUser()
  5916  	f = nil
  5917  	f.GetCurrentUser()
  5918  }
  5919  
  5920  func TestFeedLinks_GetCurrentUserActor(tt *testing.T) {
  5921  	f := &FeedLinks{}
  5922  	f.GetCurrentUserActor()
  5923  	f = nil
  5924  	f.GetCurrentUserActor()
  5925  }
  5926  
  5927  func TestFeedLinks_GetCurrentUserOrganization(tt *testing.T) {
  5928  	f := &FeedLinks{}
  5929  	f.GetCurrentUserOrganization()
  5930  	f = nil
  5931  	f.GetCurrentUserOrganization()
  5932  }
  5933  
  5934  func TestFeedLinks_GetCurrentUserPublic(tt *testing.T) {
  5935  	f := &FeedLinks{}
  5936  	f.GetCurrentUserPublic()
  5937  	f = nil
  5938  	f.GetCurrentUserPublic()
  5939  }
  5940  
  5941  func TestFeedLinks_GetTimeline(tt *testing.T) {
  5942  	f := &FeedLinks{}
  5943  	f.GetTimeline()
  5944  	f = nil
  5945  	f.GetTimeline()
  5946  }
  5947  
  5948  func TestFeedLinks_GetUser(tt *testing.T) {
  5949  	f := &FeedLinks{}
  5950  	f.GetUser()
  5951  	f = nil
  5952  	f.GetUser()
  5953  }
  5954  
  5955  func TestFeeds_GetCurrentUserActorURL(tt *testing.T) {
  5956  	var zeroValue string
  5957  	f := &Feeds{CurrentUserActorURL: &zeroValue}
  5958  	f.GetCurrentUserActorURL()
  5959  	f = &Feeds{}
  5960  	f.GetCurrentUserActorURL()
  5961  	f = nil
  5962  	f.GetCurrentUserActorURL()
  5963  }
  5964  
  5965  func TestFeeds_GetCurrentUserOrganizationURL(tt *testing.T) {
  5966  	var zeroValue string
  5967  	f := &Feeds{CurrentUserOrganizationURL: &zeroValue}
  5968  	f.GetCurrentUserOrganizationURL()
  5969  	f = &Feeds{}
  5970  	f.GetCurrentUserOrganizationURL()
  5971  	f = nil
  5972  	f.GetCurrentUserOrganizationURL()
  5973  }
  5974  
  5975  func TestFeeds_GetCurrentUserPublicURL(tt *testing.T) {
  5976  	var zeroValue string
  5977  	f := &Feeds{CurrentUserPublicURL: &zeroValue}
  5978  	f.GetCurrentUserPublicURL()
  5979  	f = &Feeds{}
  5980  	f.GetCurrentUserPublicURL()
  5981  	f = nil
  5982  	f.GetCurrentUserPublicURL()
  5983  }
  5984  
  5985  func TestFeeds_GetCurrentUserURL(tt *testing.T) {
  5986  	var zeroValue string
  5987  	f := &Feeds{CurrentUserURL: &zeroValue}
  5988  	f.GetCurrentUserURL()
  5989  	f = &Feeds{}
  5990  	f.GetCurrentUserURL()
  5991  	f = nil
  5992  	f.GetCurrentUserURL()
  5993  }
  5994  
  5995  func TestFeeds_GetLinks(tt *testing.T) {
  5996  	f := &Feeds{}
  5997  	f.GetLinks()
  5998  	f = nil
  5999  	f.GetLinks()
  6000  }
  6001  
  6002  func TestFeeds_GetTimelineURL(tt *testing.T) {
  6003  	var zeroValue string
  6004  	f := &Feeds{TimelineURL: &zeroValue}
  6005  	f.GetTimelineURL()
  6006  	f = &Feeds{}
  6007  	f.GetTimelineURL()
  6008  	f = nil
  6009  	f.GetTimelineURL()
  6010  }
  6011  
  6012  func TestFeeds_GetUserURL(tt *testing.T) {
  6013  	var zeroValue string
  6014  	f := &Feeds{UserURL: &zeroValue}
  6015  	f.GetUserURL()
  6016  	f = &Feeds{}
  6017  	f.GetUserURL()
  6018  	f = nil
  6019  	f.GetUserURL()
  6020  }
  6021  
  6022  func TestFirstPatchedVersion_GetIdentifier(tt *testing.T) {
  6023  	var zeroValue string
  6024  	f := &FirstPatchedVersion{Identifier: &zeroValue}
  6025  	f.GetIdentifier()
  6026  	f = &FirstPatchedVersion{}
  6027  	f.GetIdentifier()
  6028  	f = nil
  6029  	f.GetIdentifier()
  6030  }
  6031  
  6032  func TestForkEvent_GetForkee(tt *testing.T) {
  6033  	f := &ForkEvent{}
  6034  	f.GetForkee()
  6035  	f = nil
  6036  	f.GetForkee()
  6037  }
  6038  
  6039  func TestForkEvent_GetInstallation(tt *testing.T) {
  6040  	f := &ForkEvent{}
  6041  	f.GetInstallation()
  6042  	f = nil
  6043  	f.GetInstallation()
  6044  }
  6045  
  6046  func TestForkEvent_GetRepo(tt *testing.T) {
  6047  	f := &ForkEvent{}
  6048  	f.GetRepo()
  6049  	f = nil
  6050  	f.GetRepo()
  6051  }
  6052  
  6053  func TestForkEvent_GetSender(tt *testing.T) {
  6054  	f := &ForkEvent{}
  6055  	f.GetSender()
  6056  	f = nil
  6057  	f.GetSender()
  6058  }
  6059  
  6060  func TestGenerateNotesOptions_GetPreviousTagName(tt *testing.T) {
  6061  	var zeroValue string
  6062  	g := &GenerateNotesOptions{PreviousTagName: &zeroValue}
  6063  	g.GetPreviousTagName()
  6064  	g = &GenerateNotesOptions{}
  6065  	g.GetPreviousTagName()
  6066  	g = nil
  6067  	g.GetPreviousTagName()
  6068  }
  6069  
  6070  func TestGenerateNotesOptions_GetTargetCommitish(tt *testing.T) {
  6071  	var zeroValue string
  6072  	g := &GenerateNotesOptions{TargetCommitish: &zeroValue}
  6073  	g.GetTargetCommitish()
  6074  	g = &GenerateNotesOptions{}
  6075  	g.GetTargetCommitish()
  6076  	g = nil
  6077  	g.GetTargetCommitish()
  6078  }
  6079  
  6080  func TestGetAuditLogOptions_GetInclude(tt *testing.T) {
  6081  	var zeroValue string
  6082  	g := &GetAuditLogOptions{Include: &zeroValue}
  6083  	g.GetInclude()
  6084  	g = &GetAuditLogOptions{}
  6085  	g.GetInclude()
  6086  	g = nil
  6087  	g.GetInclude()
  6088  }
  6089  
  6090  func TestGetAuditLogOptions_GetOrder(tt *testing.T) {
  6091  	var zeroValue string
  6092  	g := &GetAuditLogOptions{Order: &zeroValue}
  6093  	g.GetOrder()
  6094  	g = &GetAuditLogOptions{}
  6095  	g.GetOrder()
  6096  	g = nil
  6097  	g.GetOrder()
  6098  }
  6099  
  6100  func TestGetAuditLogOptions_GetPhrase(tt *testing.T) {
  6101  	var zeroValue string
  6102  	g := &GetAuditLogOptions{Phrase: &zeroValue}
  6103  	g.GetPhrase()
  6104  	g = &GetAuditLogOptions{}
  6105  	g.GetPhrase()
  6106  	g = nil
  6107  	g.GetPhrase()
  6108  }
  6109  
  6110  func TestGist_GetComments(tt *testing.T) {
  6111  	var zeroValue int
  6112  	g := &Gist{Comments: &zeroValue}
  6113  	g.GetComments()
  6114  	g = &Gist{}
  6115  	g.GetComments()
  6116  	g = nil
  6117  	g.GetComments()
  6118  }
  6119  
  6120  func TestGist_GetCreatedAt(tt *testing.T) {
  6121  	var zeroValue time.Time
  6122  	g := &Gist{CreatedAt: &zeroValue}
  6123  	g.GetCreatedAt()
  6124  	g = &Gist{}
  6125  	g.GetCreatedAt()
  6126  	g = nil
  6127  	g.GetCreatedAt()
  6128  }
  6129  
  6130  func TestGist_GetDescription(tt *testing.T) {
  6131  	var zeroValue string
  6132  	g := &Gist{Description: &zeroValue}
  6133  	g.GetDescription()
  6134  	g = &Gist{}
  6135  	g.GetDescription()
  6136  	g = nil
  6137  	g.GetDescription()
  6138  }
  6139  
  6140  func TestGist_GetFiles(tt *testing.T) {
  6141  	zeroValue := map[GistFilename]GistFile{}
  6142  	g := &Gist{Files: zeroValue}
  6143  	g.GetFiles()
  6144  	g = &Gist{}
  6145  	g.GetFiles()
  6146  	g = nil
  6147  	g.GetFiles()
  6148  }
  6149  
  6150  func TestGist_GetGitPullURL(tt *testing.T) {
  6151  	var zeroValue string
  6152  	g := &Gist{GitPullURL: &zeroValue}
  6153  	g.GetGitPullURL()
  6154  	g = &Gist{}
  6155  	g.GetGitPullURL()
  6156  	g = nil
  6157  	g.GetGitPullURL()
  6158  }
  6159  
  6160  func TestGist_GetGitPushURL(tt *testing.T) {
  6161  	var zeroValue string
  6162  	g := &Gist{GitPushURL: &zeroValue}
  6163  	g.GetGitPushURL()
  6164  	g = &Gist{}
  6165  	g.GetGitPushURL()
  6166  	g = nil
  6167  	g.GetGitPushURL()
  6168  }
  6169  
  6170  func TestGist_GetHTMLURL(tt *testing.T) {
  6171  	var zeroValue string
  6172  	g := &Gist{HTMLURL: &zeroValue}
  6173  	g.GetHTMLURL()
  6174  	g = &Gist{}
  6175  	g.GetHTMLURL()
  6176  	g = nil
  6177  	g.GetHTMLURL()
  6178  }
  6179  
  6180  func TestGist_GetID(tt *testing.T) {
  6181  	var zeroValue string
  6182  	g := &Gist{ID: &zeroValue}
  6183  	g.GetID()
  6184  	g = &Gist{}
  6185  	g.GetID()
  6186  	g = nil
  6187  	g.GetID()
  6188  }
  6189  
  6190  func TestGist_GetNodeID(tt *testing.T) {
  6191  	var zeroValue string
  6192  	g := &Gist{NodeID: &zeroValue}
  6193  	g.GetNodeID()
  6194  	g = &Gist{}
  6195  	g.GetNodeID()
  6196  	g = nil
  6197  	g.GetNodeID()
  6198  }
  6199  
  6200  func TestGist_GetOwner(tt *testing.T) {
  6201  	g := &Gist{}
  6202  	g.GetOwner()
  6203  	g = nil
  6204  	g.GetOwner()
  6205  }
  6206  
  6207  func TestGist_GetPublic(tt *testing.T) {
  6208  	var zeroValue bool
  6209  	g := &Gist{Public: &zeroValue}
  6210  	g.GetPublic()
  6211  	g = &Gist{}
  6212  	g.GetPublic()
  6213  	g = nil
  6214  	g.GetPublic()
  6215  }
  6216  
  6217  func TestGist_GetUpdatedAt(tt *testing.T) {
  6218  	var zeroValue time.Time
  6219  	g := &Gist{UpdatedAt: &zeroValue}
  6220  	g.GetUpdatedAt()
  6221  	g = &Gist{}
  6222  	g.GetUpdatedAt()
  6223  	g = nil
  6224  	g.GetUpdatedAt()
  6225  }
  6226  
  6227  func TestGistComment_GetBody(tt *testing.T) {
  6228  	var zeroValue string
  6229  	g := &GistComment{Body: &zeroValue}
  6230  	g.GetBody()
  6231  	g = &GistComment{}
  6232  	g.GetBody()
  6233  	g = nil
  6234  	g.GetBody()
  6235  }
  6236  
  6237  func TestGistComment_GetCreatedAt(tt *testing.T) {
  6238  	var zeroValue time.Time
  6239  	g := &GistComment{CreatedAt: &zeroValue}
  6240  	g.GetCreatedAt()
  6241  	g = &GistComment{}
  6242  	g.GetCreatedAt()
  6243  	g = nil
  6244  	g.GetCreatedAt()
  6245  }
  6246  
  6247  func TestGistComment_GetID(tt *testing.T) {
  6248  	var zeroValue int64
  6249  	g := &GistComment{ID: &zeroValue}
  6250  	g.GetID()
  6251  	g = &GistComment{}
  6252  	g.GetID()
  6253  	g = nil
  6254  	g.GetID()
  6255  }
  6256  
  6257  func TestGistComment_GetURL(tt *testing.T) {
  6258  	var zeroValue string
  6259  	g := &GistComment{URL: &zeroValue}
  6260  	g.GetURL()
  6261  	g = &GistComment{}
  6262  	g.GetURL()
  6263  	g = nil
  6264  	g.GetURL()
  6265  }
  6266  
  6267  func TestGistComment_GetUser(tt *testing.T) {
  6268  	g := &GistComment{}
  6269  	g.GetUser()
  6270  	g = nil
  6271  	g.GetUser()
  6272  }
  6273  
  6274  func TestGistCommit_GetChangeStatus(tt *testing.T) {
  6275  	g := &GistCommit{}
  6276  	g.GetChangeStatus()
  6277  	g = nil
  6278  	g.GetChangeStatus()
  6279  }
  6280  
  6281  func TestGistCommit_GetCommittedAt(tt *testing.T) {
  6282  	var zeroValue Timestamp
  6283  	g := &GistCommit{CommittedAt: &zeroValue}
  6284  	g.GetCommittedAt()
  6285  	g = &GistCommit{}
  6286  	g.GetCommittedAt()
  6287  	g = nil
  6288  	g.GetCommittedAt()
  6289  }
  6290  
  6291  func TestGistCommit_GetNodeID(tt *testing.T) {
  6292  	var zeroValue string
  6293  	g := &GistCommit{NodeID: &zeroValue}
  6294  	g.GetNodeID()
  6295  	g = &GistCommit{}
  6296  	g.GetNodeID()
  6297  	g = nil
  6298  	g.GetNodeID()
  6299  }
  6300  
  6301  func TestGistCommit_GetURL(tt *testing.T) {
  6302  	var zeroValue string
  6303  	g := &GistCommit{URL: &zeroValue}
  6304  	g.GetURL()
  6305  	g = &GistCommit{}
  6306  	g.GetURL()
  6307  	g = nil
  6308  	g.GetURL()
  6309  }
  6310  
  6311  func TestGistCommit_GetUser(tt *testing.T) {
  6312  	g := &GistCommit{}
  6313  	g.GetUser()
  6314  	g = nil
  6315  	g.GetUser()
  6316  }
  6317  
  6318  func TestGistCommit_GetVersion(tt *testing.T) {
  6319  	var zeroValue string
  6320  	g := &GistCommit{Version: &zeroValue}
  6321  	g.GetVersion()
  6322  	g = &GistCommit{}
  6323  	g.GetVersion()
  6324  	g = nil
  6325  	g.GetVersion()
  6326  }
  6327  
  6328  func TestGistFile_GetContent(tt *testing.T) {
  6329  	var zeroValue string
  6330  	g := &GistFile{Content: &zeroValue}
  6331  	g.GetContent()
  6332  	g = &GistFile{}
  6333  	g.GetContent()
  6334  	g = nil
  6335  	g.GetContent()
  6336  }
  6337  
  6338  func TestGistFile_GetFilename(tt *testing.T) {
  6339  	var zeroValue string
  6340  	g := &GistFile{Filename: &zeroValue}
  6341  	g.GetFilename()
  6342  	g = &GistFile{}
  6343  	g.GetFilename()
  6344  	g = nil
  6345  	g.GetFilename()
  6346  }
  6347  
  6348  func TestGistFile_GetLanguage(tt *testing.T) {
  6349  	var zeroValue string
  6350  	g := &GistFile{Language: &zeroValue}
  6351  	g.GetLanguage()
  6352  	g = &GistFile{}
  6353  	g.GetLanguage()
  6354  	g = nil
  6355  	g.GetLanguage()
  6356  }
  6357  
  6358  func TestGistFile_GetRawURL(tt *testing.T) {
  6359  	var zeroValue string
  6360  	g := &GistFile{RawURL: &zeroValue}
  6361  	g.GetRawURL()
  6362  	g = &GistFile{}
  6363  	g.GetRawURL()
  6364  	g = nil
  6365  	g.GetRawURL()
  6366  }
  6367  
  6368  func TestGistFile_GetSize(tt *testing.T) {
  6369  	var zeroValue int
  6370  	g := &GistFile{Size: &zeroValue}
  6371  	g.GetSize()
  6372  	g = &GistFile{}
  6373  	g.GetSize()
  6374  	g = nil
  6375  	g.GetSize()
  6376  }
  6377  
  6378  func TestGistFile_GetType(tt *testing.T) {
  6379  	var zeroValue string
  6380  	g := &GistFile{Type: &zeroValue}
  6381  	g.GetType()
  6382  	g = &GistFile{}
  6383  	g.GetType()
  6384  	g = nil
  6385  	g.GetType()
  6386  }
  6387  
  6388  func TestGistFork_GetCreatedAt(tt *testing.T) {
  6389  	var zeroValue Timestamp
  6390  	g := &GistFork{CreatedAt: &zeroValue}
  6391  	g.GetCreatedAt()
  6392  	g = &GistFork{}
  6393  	g.GetCreatedAt()
  6394  	g = nil
  6395  	g.GetCreatedAt()
  6396  }
  6397  
  6398  func TestGistFork_GetID(tt *testing.T) {
  6399  	var zeroValue string
  6400  	g := &GistFork{ID: &zeroValue}
  6401  	g.GetID()
  6402  	g = &GistFork{}
  6403  	g.GetID()
  6404  	g = nil
  6405  	g.GetID()
  6406  }
  6407  
  6408  func TestGistFork_GetNodeID(tt *testing.T) {
  6409  	var zeroValue string
  6410  	g := &GistFork{NodeID: &zeroValue}
  6411  	g.GetNodeID()
  6412  	g = &GistFork{}
  6413  	g.GetNodeID()
  6414  	g = nil
  6415  	g.GetNodeID()
  6416  }
  6417  
  6418  func TestGistFork_GetUpdatedAt(tt *testing.T) {
  6419  	var zeroValue Timestamp
  6420  	g := &GistFork{UpdatedAt: &zeroValue}
  6421  	g.GetUpdatedAt()
  6422  	g = &GistFork{}
  6423  	g.GetUpdatedAt()
  6424  	g = nil
  6425  	g.GetUpdatedAt()
  6426  }
  6427  
  6428  func TestGistFork_GetURL(tt *testing.T) {
  6429  	var zeroValue string
  6430  	g := &GistFork{URL: &zeroValue}
  6431  	g.GetURL()
  6432  	g = &GistFork{}
  6433  	g.GetURL()
  6434  	g = nil
  6435  	g.GetURL()
  6436  }
  6437  
  6438  func TestGistFork_GetUser(tt *testing.T) {
  6439  	g := &GistFork{}
  6440  	g.GetUser()
  6441  	g = nil
  6442  	g.GetUser()
  6443  }
  6444  
  6445  func TestGistStats_GetPrivateGists(tt *testing.T) {
  6446  	var zeroValue int
  6447  	g := &GistStats{PrivateGists: &zeroValue}
  6448  	g.GetPrivateGists()
  6449  	g = &GistStats{}
  6450  	g.GetPrivateGists()
  6451  	g = nil
  6452  	g.GetPrivateGists()
  6453  }
  6454  
  6455  func TestGistStats_GetPublicGists(tt *testing.T) {
  6456  	var zeroValue int
  6457  	g := &GistStats{PublicGists: &zeroValue}
  6458  	g.GetPublicGists()
  6459  	g = &GistStats{}
  6460  	g.GetPublicGists()
  6461  	g = nil
  6462  	g.GetPublicGists()
  6463  }
  6464  
  6465  func TestGistStats_GetTotalGists(tt *testing.T) {
  6466  	var zeroValue int
  6467  	g := &GistStats{TotalGists: &zeroValue}
  6468  	g.GetTotalGists()
  6469  	g = &GistStats{}
  6470  	g.GetTotalGists()
  6471  	g = nil
  6472  	g.GetTotalGists()
  6473  }
  6474  
  6475  func TestGitHubAppAuthorizationEvent_GetAction(tt *testing.T) {
  6476  	var zeroValue string
  6477  	g := &GitHubAppAuthorizationEvent{Action: &zeroValue}
  6478  	g.GetAction()
  6479  	g = &GitHubAppAuthorizationEvent{}
  6480  	g.GetAction()
  6481  	g = nil
  6482  	g.GetAction()
  6483  }
  6484  
  6485  func TestGitHubAppAuthorizationEvent_GetInstallation(tt *testing.T) {
  6486  	g := &GitHubAppAuthorizationEvent{}
  6487  	g.GetInstallation()
  6488  	g = nil
  6489  	g.GetInstallation()
  6490  }
  6491  
  6492  func TestGitHubAppAuthorizationEvent_GetSender(tt *testing.T) {
  6493  	g := &GitHubAppAuthorizationEvent{}
  6494  	g.GetSender()
  6495  	g = nil
  6496  	g.GetSender()
  6497  }
  6498  
  6499  func TestGitignore_GetName(tt *testing.T) {
  6500  	var zeroValue string
  6501  	g := &Gitignore{Name: &zeroValue}
  6502  	g.GetName()
  6503  	g = &Gitignore{}
  6504  	g.GetName()
  6505  	g = nil
  6506  	g.GetName()
  6507  }
  6508  
  6509  func TestGitignore_GetSource(tt *testing.T) {
  6510  	var zeroValue string
  6511  	g := &Gitignore{Source: &zeroValue}
  6512  	g.GetSource()
  6513  	g = &Gitignore{}
  6514  	g.GetSource()
  6515  	g = nil
  6516  	g.GetSource()
  6517  }
  6518  
  6519  func TestGitObject_GetSHA(tt *testing.T) {
  6520  	var zeroValue string
  6521  	g := &GitObject{SHA: &zeroValue}
  6522  	g.GetSHA()
  6523  	g = &GitObject{}
  6524  	g.GetSHA()
  6525  	g = nil
  6526  	g.GetSHA()
  6527  }
  6528  
  6529  func TestGitObject_GetType(tt *testing.T) {
  6530  	var zeroValue string
  6531  	g := &GitObject{Type: &zeroValue}
  6532  	g.GetType()
  6533  	g = &GitObject{}
  6534  	g.GetType()
  6535  	g = nil
  6536  	g.GetType()
  6537  }
  6538  
  6539  func TestGitObject_GetURL(tt *testing.T) {
  6540  	var zeroValue string
  6541  	g := &GitObject{URL: &zeroValue}
  6542  	g.GetURL()
  6543  	g = &GitObject{}
  6544  	g.GetURL()
  6545  	g = nil
  6546  	g.GetURL()
  6547  }
  6548  
  6549  func TestGollumEvent_GetInstallation(tt *testing.T) {
  6550  	g := &GollumEvent{}
  6551  	g.GetInstallation()
  6552  	g = nil
  6553  	g.GetInstallation()
  6554  }
  6555  
  6556  func TestGollumEvent_GetRepo(tt *testing.T) {
  6557  	g := &GollumEvent{}
  6558  	g.GetRepo()
  6559  	g = nil
  6560  	g.GetRepo()
  6561  }
  6562  
  6563  func TestGollumEvent_GetSender(tt *testing.T) {
  6564  	g := &GollumEvent{}
  6565  	g.GetSender()
  6566  	g = nil
  6567  	g.GetSender()
  6568  }
  6569  
  6570  func TestGPGEmail_GetEmail(tt *testing.T) {
  6571  	var zeroValue string
  6572  	g := &GPGEmail{Email: &zeroValue}
  6573  	g.GetEmail()
  6574  	g = &GPGEmail{}
  6575  	g.GetEmail()
  6576  	g = nil
  6577  	g.GetEmail()
  6578  }
  6579  
  6580  func TestGPGEmail_GetVerified(tt *testing.T) {
  6581  	var zeroValue bool
  6582  	g := &GPGEmail{Verified: &zeroValue}
  6583  	g.GetVerified()
  6584  	g = &GPGEmail{}
  6585  	g.GetVerified()
  6586  	g = nil
  6587  	g.GetVerified()
  6588  }
  6589  
  6590  func TestGPGKey_GetCanCertify(tt *testing.T) {
  6591  	var zeroValue bool
  6592  	g := &GPGKey{CanCertify: &zeroValue}
  6593  	g.GetCanCertify()
  6594  	g = &GPGKey{}
  6595  	g.GetCanCertify()
  6596  	g = nil
  6597  	g.GetCanCertify()
  6598  }
  6599  
  6600  func TestGPGKey_GetCanEncryptComms(tt *testing.T) {
  6601  	var zeroValue bool
  6602  	g := &GPGKey{CanEncryptComms: &zeroValue}
  6603  	g.GetCanEncryptComms()
  6604  	g = &GPGKey{}
  6605  	g.GetCanEncryptComms()
  6606  	g = nil
  6607  	g.GetCanEncryptComms()
  6608  }
  6609  
  6610  func TestGPGKey_GetCanEncryptStorage(tt *testing.T) {
  6611  	var zeroValue bool
  6612  	g := &GPGKey{CanEncryptStorage: &zeroValue}
  6613  	g.GetCanEncryptStorage()
  6614  	g = &GPGKey{}
  6615  	g.GetCanEncryptStorage()
  6616  	g = nil
  6617  	g.GetCanEncryptStorage()
  6618  }
  6619  
  6620  func TestGPGKey_GetCanSign(tt *testing.T) {
  6621  	var zeroValue bool
  6622  	g := &GPGKey{CanSign: &zeroValue}
  6623  	g.GetCanSign()
  6624  	g = &GPGKey{}
  6625  	g.GetCanSign()
  6626  	g = nil
  6627  	g.GetCanSign()
  6628  }
  6629  
  6630  func TestGPGKey_GetCreatedAt(tt *testing.T) {
  6631  	var zeroValue time.Time
  6632  	g := &GPGKey{CreatedAt: &zeroValue}
  6633  	g.GetCreatedAt()
  6634  	g = &GPGKey{}
  6635  	g.GetCreatedAt()
  6636  	g = nil
  6637  	g.GetCreatedAt()
  6638  }
  6639  
  6640  func TestGPGKey_GetExpiresAt(tt *testing.T) {
  6641  	var zeroValue time.Time
  6642  	g := &GPGKey{ExpiresAt: &zeroValue}
  6643  	g.GetExpiresAt()
  6644  	g = &GPGKey{}
  6645  	g.GetExpiresAt()
  6646  	g = nil
  6647  	g.GetExpiresAt()
  6648  }
  6649  
  6650  func TestGPGKey_GetID(tt *testing.T) {
  6651  	var zeroValue int64
  6652  	g := &GPGKey{ID: &zeroValue}
  6653  	g.GetID()
  6654  	g = &GPGKey{}
  6655  	g.GetID()
  6656  	g = nil
  6657  	g.GetID()
  6658  }
  6659  
  6660  func TestGPGKey_GetKeyID(tt *testing.T) {
  6661  	var zeroValue string
  6662  	g := &GPGKey{KeyID: &zeroValue}
  6663  	g.GetKeyID()
  6664  	g = &GPGKey{}
  6665  	g.GetKeyID()
  6666  	g = nil
  6667  	g.GetKeyID()
  6668  }
  6669  
  6670  func TestGPGKey_GetPrimaryKeyID(tt *testing.T) {
  6671  	var zeroValue int64
  6672  	g := &GPGKey{PrimaryKeyID: &zeroValue}
  6673  	g.GetPrimaryKeyID()
  6674  	g = &GPGKey{}
  6675  	g.GetPrimaryKeyID()
  6676  	g = nil
  6677  	g.GetPrimaryKeyID()
  6678  }
  6679  
  6680  func TestGPGKey_GetPublicKey(tt *testing.T) {
  6681  	var zeroValue string
  6682  	g := &GPGKey{PublicKey: &zeroValue}
  6683  	g.GetPublicKey()
  6684  	g = &GPGKey{}
  6685  	g.GetPublicKey()
  6686  	g = nil
  6687  	g.GetPublicKey()
  6688  }
  6689  
  6690  func TestGPGKey_GetRawKey(tt *testing.T) {
  6691  	var zeroValue string
  6692  	g := &GPGKey{RawKey: &zeroValue}
  6693  	g.GetRawKey()
  6694  	g = &GPGKey{}
  6695  	g.GetRawKey()
  6696  	g = nil
  6697  	g.GetRawKey()
  6698  }
  6699  
  6700  func TestGrant_GetApp(tt *testing.T) {
  6701  	g := &Grant{}
  6702  	g.GetApp()
  6703  	g = nil
  6704  	g.GetApp()
  6705  }
  6706  
  6707  func TestGrant_GetCreatedAt(tt *testing.T) {
  6708  	var zeroValue Timestamp
  6709  	g := &Grant{CreatedAt: &zeroValue}
  6710  	g.GetCreatedAt()
  6711  	g = &Grant{}
  6712  	g.GetCreatedAt()
  6713  	g = nil
  6714  	g.GetCreatedAt()
  6715  }
  6716  
  6717  func TestGrant_GetID(tt *testing.T) {
  6718  	var zeroValue int64
  6719  	g := &Grant{ID: &zeroValue}
  6720  	g.GetID()
  6721  	g = &Grant{}
  6722  	g.GetID()
  6723  	g = nil
  6724  	g.GetID()
  6725  }
  6726  
  6727  func TestGrant_GetUpdatedAt(tt *testing.T) {
  6728  	var zeroValue Timestamp
  6729  	g := &Grant{UpdatedAt: &zeroValue}
  6730  	g.GetUpdatedAt()
  6731  	g = &Grant{}
  6732  	g.GetUpdatedAt()
  6733  	g = nil
  6734  	g.GetUpdatedAt()
  6735  }
  6736  
  6737  func TestGrant_GetURL(tt *testing.T) {
  6738  	var zeroValue string
  6739  	g := &Grant{URL: &zeroValue}
  6740  	g.GetURL()
  6741  	g = &Grant{}
  6742  	g.GetURL()
  6743  	g = nil
  6744  	g.GetURL()
  6745  }
  6746  
  6747  func TestHeadCommit_GetAuthor(tt *testing.T) {
  6748  	h := &HeadCommit{}
  6749  	h.GetAuthor()
  6750  	h = nil
  6751  	h.GetAuthor()
  6752  }
  6753  
  6754  func TestHeadCommit_GetCommitter(tt *testing.T) {
  6755  	h := &HeadCommit{}
  6756  	h.GetCommitter()
  6757  	h = nil
  6758  	h.GetCommitter()
  6759  }
  6760  
  6761  func TestHeadCommit_GetDistinct(tt *testing.T) {
  6762  	var zeroValue bool
  6763  	h := &HeadCommit{Distinct: &zeroValue}
  6764  	h.GetDistinct()
  6765  	h = &HeadCommit{}
  6766  	h.GetDistinct()
  6767  	h = nil
  6768  	h.GetDistinct()
  6769  }
  6770  
  6771  func TestHeadCommit_GetID(tt *testing.T) {
  6772  	var zeroValue string
  6773  	h := &HeadCommit{ID: &zeroValue}
  6774  	h.GetID()
  6775  	h = &HeadCommit{}
  6776  	h.GetID()
  6777  	h = nil
  6778  	h.GetID()
  6779  }
  6780  
  6781  func TestHeadCommit_GetMessage(tt *testing.T) {
  6782  	var zeroValue string
  6783  	h := &HeadCommit{Message: &zeroValue}
  6784  	h.GetMessage()
  6785  	h = &HeadCommit{}
  6786  	h.GetMessage()
  6787  	h = nil
  6788  	h.GetMessage()
  6789  }
  6790  
  6791  func TestHeadCommit_GetSHA(tt *testing.T) {
  6792  	var zeroValue string
  6793  	h := &HeadCommit{SHA: &zeroValue}
  6794  	h.GetSHA()
  6795  	h = &HeadCommit{}
  6796  	h.GetSHA()
  6797  	h = nil
  6798  	h.GetSHA()
  6799  }
  6800  
  6801  func TestHeadCommit_GetTimestamp(tt *testing.T) {
  6802  	var zeroValue Timestamp
  6803  	h := &HeadCommit{Timestamp: &zeroValue}
  6804  	h.GetTimestamp()
  6805  	h = &HeadCommit{}
  6806  	h.GetTimestamp()
  6807  	h = nil
  6808  	h.GetTimestamp()
  6809  }
  6810  
  6811  func TestHeadCommit_GetTreeID(tt *testing.T) {
  6812  	var zeroValue string
  6813  	h := &HeadCommit{TreeID: &zeroValue}
  6814  	h.GetTreeID()
  6815  	h = &HeadCommit{}
  6816  	h.GetTreeID()
  6817  	h = nil
  6818  	h.GetTreeID()
  6819  }
  6820  
  6821  func TestHeadCommit_GetURL(tt *testing.T) {
  6822  	var zeroValue string
  6823  	h := &HeadCommit{URL: &zeroValue}
  6824  	h.GetURL()
  6825  	h = &HeadCommit{}
  6826  	h.GetURL()
  6827  	h = nil
  6828  	h.GetURL()
  6829  }
  6830  
  6831  func TestHook_GetActive(tt *testing.T) {
  6832  	var zeroValue bool
  6833  	h := &Hook{Active: &zeroValue}
  6834  	h.GetActive()
  6835  	h = &Hook{}
  6836  	h.GetActive()
  6837  	h = nil
  6838  	h.GetActive()
  6839  }
  6840  
  6841  func TestHook_GetCreatedAt(tt *testing.T) {
  6842  	var zeroValue time.Time
  6843  	h := &Hook{CreatedAt: &zeroValue}
  6844  	h.GetCreatedAt()
  6845  	h = &Hook{}
  6846  	h.GetCreatedAt()
  6847  	h = nil
  6848  	h.GetCreatedAt()
  6849  }
  6850  
  6851  func TestHook_GetID(tt *testing.T) {
  6852  	var zeroValue int64
  6853  	h := &Hook{ID: &zeroValue}
  6854  	h.GetID()
  6855  	h = &Hook{}
  6856  	h.GetID()
  6857  	h = nil
  6858  	h.GetID()
  6859  }
  6860  
  6861  func TestHook_GetName(tt *testing.T) {
  6862  	var zeroValue string
  6863  	h := &Hook{Name: &zeroValue}
  6864  	h.GetName()
  6865  	h = &Hook{}
  6866  	h.GetName()
  6867  	h = nil
  6868  	h.GetName()
  6869  }
  6870  
  6871  func TestHook_GetPingURL(tt *testing.T) {
  6872  	var zeroValue string
  6873  	h := &Hook{PingURL: &zeroValue}
  6874  	h.GetPingURL()
  6875  	h = &Hook{}
  6876  	h.GetPingURL()
  6877  	h = nil
  6878  	h.GetPingURL()
  6879  }
  6880  
  6881  func TestHook_GetTestURL(tt *testing.T) {
  6882  	var zeroValue string
  6883  	h := &Hook{TestURL: &zeroValue}
  6884  	h.GetTestURL()
  6885  	h = &Hook{}
  6886  	h.GetTestURL()
  6887  	h = nil
  6888  	h.GetTestURL()
  6889  }
  6890  
  6891  func TestHook_GetType(tt *testing.T) {
  6892  	var zeroValue string
  6893  	h := &Hook{Type: &zeroValue}
  6894  	h.GetType()
  6895  	h = &Hook{}
  6896  	h.GetType()
  6897  	h = nil
  6898  	h.GetType()
  6899  }
  6900  
  6901  func TestHook_GetUpdatedAt(tt *testing.T) {
  6902  	var zeroValue time.Time
  6903  	h := &Hook{UpdatedAt: &zeroValue}
  6904  	h.GetUpdatedAt()
  6905  	h = &Hook{}
  6906  	h.GetUpdatedAt()
  6907  	h = nil
  6908  	h.GetUpdatedAt()
  6909  }
  6910  
  6911  func TestHook_GetURL(tt *testing.T) {
  6912  	var zeroValue string
  6913  	h := &Hook{URL: &zeroValue}
  6914  	h.GetURL()
  6915  	h = &Hook{}
  6916  	h.GetURL()
  6917  	h = nil
  6918  	h.GetURL()
  6919  }
  6920  
  6921  func TestHookConfig_GetContentType(tt *testing.T) {
  6922  	var zeroValue string
  6923  	h := &HookConfig{ContentType: &zeroValue}
  6924  	h.GetContentType()
  6925  	h = &HookConfig{}
  6926  	h.GetContentType()
  6927  	h = nil
  6928  	h.GetContentType()
  6929  }
  6930  
  6931  func TestHookConfig_GetInsecureSSL(tt *testing.T) {
  6932  	var zeroValue string
  6933  	h := &HookConfig{InsecureSSL: &zeroValue}
  6934  	h.GetInsecureSSL()
  6935  	h = &HookConfig{}
  6936  	h.GetInsecureSSL()
  6937  	h = nil
  6938  	h.GetInsecureSSL()
  6939  }
  6940  
  6941  func TestHookConfig_GetSecret(tt *testing.T) {
  6942  	var zeroValue string
  6943  	h := &HookConfig{Secret: &zeroValue}
  6944  	h.GetSecret()
  6945  	h = &HookConfig{}
  6946  	h.GetSecret()
  6947  	h = nil
  6948  	h.GetSecret()
  6949  }
  6950  
  6951  func TestHookConfig_GetURL(tt *testing.T) {
  6952  	var zeroValue string
  6953  	h := &HookConfig{URL: &zeroValue}
  6954  	h.GetURL()
  6955  	h = &HookConfig{}
  6956  	h.GetURL()
  6957  	h = nil
  6958  	h.GetURL()
  6959  }
  6960  
  6961  func TestHookDelivery_GetAction(tt *testing.T) {
  6962  	var zeroValue string
  6963  	h := &HookDelivery{Action: &zeroValue}
  6964  	h.GetAction()
  6965  	h = &HookDelivery{}
  6966  	h.GetAction()
  6967  	h = nil
  6968  	h.GetAction()
  6969  }
  6970  
  6971  func TestHookDelivery_GetDeliveredAt(tt *testing.T) {
  6972  	var zeroValue Timestamp
  6973  	h := &HookDelivery{DeliveredAt: &zeroValue}
  6974  	h.GetDeliveredAt()
  6975  	h = &HookDelivery{}
  6976  	h.GetDeliveredAt()
  6977  	h = nil
  6978  	h.GetDeliveredAt()
  6979  }
  6980  
  6981  func TestHookDelivery_GetDuration(tt *testing.T) {
  6982  	h := &HookDelivery{}
  6983  	h.GetDuration()
  6984  	h = nil
  6985  	h.GetDuration()
  6986  }
  6987  
  6988  func TestHookDelivery_GetEvent(tt *testing.T) {
  6989  	var zeroValue string
  6990  	h := &HookDelivery{Event: &zeroValue}
  6991  	h.GetEvent()
  6992  	h = &HookDelivery{}
  6993  	h.GetEvent()
  6994  	h = nil
  6995  	h.GetEvent()
  6996  }
  6997  
  6998  func TestHookDelivery_GetGUID(tt *testing.T) {
  6999  	var zeroValue string
  7000  	h := &HookDelivery{GUID: &zeroValue}
  7001  	h.GetGUID()
  7002  	h = &HookDelivery{}
  7003  	h.GetGUID()
  7004  	h = nil
  7005  	h.GetGUID()
  7006  }
  7007  
  7008  func TestHookDelivery_GetID(tt *testing.T) {
  7009  	var zeroValue int64
  7010  	h := &HookDelivery{ID: &zeroValue}
  7011  	h.GetID()
  7012  	h = &HookDelivery{}
  7013  	h.GetID()
  7014  	h = nil
  7015  	h.GetID()
  7016  }
  7017  
  7018  func TestHookDelivery_GetInstallationID(tt *testing.T) {
  7019  	var zeroValue int64
  7020  	h := &HookDelivery{InstallationID: &zeroValue}
  7021  	h.GetInstallationID()
  7022  	h = &HookDelivery{}
  7023  	h.GetInstallationID()
  7024  	h = nil
  7025  	h.GetInstallationID()
  7026  }
  7027  
  7028  func TestHookDelivery_GetRedelivery(tt *testing.T) {
  7029  	var zeroValue bool
  7030  	h := &HookDelivery{Redelivery: &zeroValue}
  7031  	h.GetRedelivery()
  7032  	h = &HookDelivery{}
  7033  	h.GetRedelivery()
  7034  	h = nil
  7035  	h.GetRedelivery()
  7036  }
  7037  
  7038  func TestHookDelivery_GetRepositoryID(tt *testing.T) {
  7039  	var zeroValue int64
  7040  	h := &HookDelivery{RepositoryID: &zeroValue}
  7041  	h.GetRepositoryID()
  7042  	h = &HookDelivery{}
  7043  	h.GetRepositoryID()
  7044  	h = nil
  7045  	h.GetRepositoryID()
  7046  }
  7047  
  7048  func TestHookDelivery_GetRequest(tt *testing.T) {
  7049  	h := &HookDelivery{}
  7050  	h.GetRequest()
  7051  	h = nil
  7052  	h.GetRequest()
  7053  }
  7054  
  7055  func TestHookDelivery_GetResponse(tt *testing.T) {
  7056  	h := &HookDelivery{}
  7057  	h.GetResponse()
  7058  	h = nil
  7059  	h.GetResponse()
  7060  }
  7061  
  7062  func TestHookDelivery_GetStatus(tt *testing.T) {
  7063  	var zeroValue string
  7064  	h := &HookDelivery{Status: &zeroValue}
  7065  	h.GetStatus()
  7066  	h = &HookDelivery{}
  7067  	h.GetStatus()
  7068  	h = nil
  7069  	h.GetStatus()
  7070  }
  7071  
  7072  func TestHookDelivery_GetStatusCode(tt *testing.T) {
  7073  	var zeroValue int
  7074  	h := &HookDelivery{StatusCode: &zeroValue}
  7075  	h.GetStatusCode()
  7076  	h = &HookDelivery{}
  7077  	h.GetStatusCode()
  7078  	h = nil
  7079  	h.GetStatusCode()
  7080  }
  7081  
  7082  func TestHookRequest_GetHeaders(tt *testing.T) {
  7083  	zeroValue := map[string]string{}
  7084  	h := &HookRequest{Headers: zeroValue}
  7085  	h.GetHeaders()
  7086  	h = &HookRequest{}
  7087  	h.GetHeaders()
  7088  	h = nil
  7089  	h.GetHeaders()
  7090  }
  7091  
  7092  func TestHookRequest_GetRawPayload(tt *testing.T) {
  7093  	var zeroValue json.RawMessage
  7094  	h := &HookRequest{RawPayload: &zeroValue}
  7095  	h.GetRawPayload()
  7096  	h = &HookRequest{}
  7097  	h.GetRawPayload()
  7098  	h = nil
  7099  	h.GetRawPayload()
  7100  }
  7101  
  7102  func TestHookResponse_GetHeaders(tt *testing.T) {
  7103  	zeroValue := map[string]string{}
  7104  	h := &HookResponse{Headers: zeroValue}
  7105  	h.GetHeaders()
  7106  	h = &HookResponse{}
  7107  	h.GetHeaders()
  7108  	h = nil
  7109  	h.GetHeaders()
  7110  }
  7111  
  7112  func TestHookResponse_GetRawPayload(tt *testing.T) {
  7113  	var zeroValue json.RawMessage
  7114  	h := &HookResponse{RawPayload: &zeroValue}
  7115  	h.GetRawPayload()
  7116  	h = &HookResponse{}
  7117  	h.GetRawPayload()
  7118  	h = nil
  7119  	h.GetRawPayload()
  7120  }
  7121  
  7122  func TestHookStats_GetActiveHooks(tt *testing.T) {
  7123  	var zeroValue int
  7124  	h := &HookStats{ActiveHooks: &zeroValue}
  7125  	h.GetActiveHooks()
  7126  	h = &HookStats{}
  7127  	h.GetActiveHooks()
  7128  	h = nil
  7129  	h.GetActiveHooks()
  7130  }
  7131  
  7132  func TestHookStats_GetInactiveHooks(tt *testing.T) {
  7133  	var zeroValue int
  7134  	h := &HookStats{InactiveHooks: &zeroValue}
  7135  	h.GetInactiveHooks()
  7136  	h = &HookStats{}
  7137  	h.GetInactiveHooks()
  7138  	h = nil
  7139  	h.GetInactiveHooks()
  7140  }
  7141  
  7142  func TestHookStats_GetTotalHooks(tt *testing.T) {
  7143  	var zeroValue int
  7144  	h := &HookStats{TotalHooks: &zeroValue}
  7145  	h.GetTotalHooks()
  7146  	h = &HookStats{}
  7147  	h.GetTotalHooks()
  7148  	h = nil
  7149  	h.GetTotalHooks()
  7150  }
  7151  
  7152  func TestIDPGroup_GetGroupDescription(tt *testing.T) {
  7153  	var zeroValue string
  7154  	i := &IDPGroup{GroupDescription: &zeroValue}
  7155  	i.GetGroupDescription()
  7156  	i = &IDPGroup{}
  7157  	i.GetGroupDescription()
  7158  	i = nil
  7159  	i.GetGroupDescription()
  7160  }
  7161  
  7162  func TestIDPGroup_GetGroupID(tt *testing.T) {
  7163  	var zeroValue string
  7164  	i := &IDPGroup{GroupID: &zeroValue}
  7165  	i.GetGroupID()
  7166  	i = &IDPGroup{}
  7167  	i.GetGroupID()
  7168  	i = nil
  7169  	i.GetGroupID()
  7170  }
  7171  
  7172  func TestIDPGroup_GetGroupName(tt *testing.T) {
  7173  	var zeroValue string
  7174  	i := &IDPGroup{GroupName: &zeroValue}
  7175  	i.GetGroupName()
  7176  	i = &IDPGroup{}
  7177  	i.GetGroupName()
  7178  	i = nil
  7179  	i.GetGroupName()
  7180  }
  7181  
  7182  func TestImport_GetAuthorsCount(tt *testing.T) {
  7183  	var zeroValue int
  7184  	i := &Import{AuthorsCount: &zeroValue}
  7185  	i.GetAuthorsCount()
  7186  	i = &Import{}
  7187  	i.GetAuthorsCount()
  7188  	i = nil
  7189  	i.GetAuthorsCount()
  7190  }
  7191  
  7192  func TestImport_GetAuthorsURL(tt *testing.T) {
  7193  	var zeroValue string
  7194  	i := &Import{AuthorsURL: &zeroValue}
  7195  	i.GetAuthorsURL()
  7196  	i = &Import{}
  7197  	i.GetAuthorsURL()
  7198  	i = nil
  7199  	i.GetAuthorsURL()
  7200  }
  7201  
  7202  func TestImport_GetCommitCount(tt *testing.T) {
  7203  	var zeroValue int
  7204  	i := &Import{CommitCount: &zeroValue}
  7205  	i.GetCommitCount()
  7206  	i = &Import{}
  7207  	i.GetCommitCount()
  7208  	i = nil
  7209  	i.GetCommitCount()
  7210  }
  7211  
  7212  func TestImport_GetFailedStep(tt *testing.T) {
  7213  	var zeroValue string
  7214  	i := &Import{FailedStep: &zeroValue}
  7215  	i.GetFailedStep()
  7216  	i = &Import{}
  7217  	i.GetFailedStep()
  7218  	i = nil
  7219  	i.GetFailedStep()
  7220  }
  7221  
  7222  func TestImport_GetHasLargeFiles(tt *testing.T) {
  7223  	var zeroValue bool
  7224  	i := &Import{HasLargeFiles: &zeroValue}
  7225  	i.GetHasLargeFiles()
  7226  	i = &Import{}
  7227  	i.GetHasLargeFiles()
  7228  	i = nil
  7229  	i.GetHasLargeFiles()
  7230  }
  7231  
  7232  func TestImport_GetHTMLURL(tt *testing.T) {
  7233  	var zeroValue string
  7234  	i := &Import{HTMLURL: &zeroValue}
  7235  	i.GetHTMLURL()
  7236  	i = &Import{}
  7237  	i.GetHTMLURL()
  7238  	i = nil
  7239  	i.GetHTMLURL()
  7240  }
  7241  
  7242  func TestImport_GetHumanName(tt *testing.T) {
  7243  	var zeroValue string
  7244  	i := &Import{HumanName: &zeroValue}
  7245  	i.GetHumanName()
  7246  	i = &Import{}
  7247  	i.GetHumanName()
  7248  	i = nil
  7249  	i.GetHumanName()
  7250  }
  7251  
  7252  func TestImport_GetLargeFilesCount(tt *testing.T) {
  7253  	var zeroValue int
  7254  	i := &Import{LargeFilesCount: &zeroValue}
  7255  	i.GetLargeFilesCount()
  7256  	i = &Import{}
  7257  	i.GetLargeFilesCount()
  7258  	i = nil
  7259  	i.GetLargeFilesCount()
  7260  }
  7261  
  7262  func TestImport_GetLargeFilesSize(tt *testing.T) {
  7263  	var zeroValue int
  7264  	i := &Import{LargeFilesSize: &zeroValue}
  7265  	i.GetLargeFilesSize()
  7266  	i = &Import{}
  7267  	i.GetLargeFilesSize()
  7268  	i = nil
  7269  	i.GetLargeFilesSize()
  7270  }
  7271  
  7272  func TestImport_GetMessage(tt *testing.T) {
  7273  	var zeroValue string
  7274  	i := &Import{Message: &zeroValue}
  7275  	i.GetMessage()
  7276  	i = &Import{}
  7277  	i.GetMessage()
  7278  	i = nil
  7279  	i.GetMessage()
  7280  }
  7281  
  7282  func TestImport_GetPercent(tt *testing.T) {
  7283  	var zeroValue int
  7284  	i := &Import{Percent: &zeroValue}
  7285  	i.GetPercent()
  7286  	i = &Import{}
  7287  	i.GetPercent()
  7288  	i = nil
  7289  	i.GetPercent()
  7290  }
  7291  
  7292  func TestImport_GetPushPercent(tt *testing.T) {
  7293  	var zeroValue int
  7294  	i := &Import{PushPercent: &zeroValue}
  7295  	i.GetPushPercent()
  7296  	i = &Import{}
  7297  	i.GetPushPercent()
  7298  	i = nil
  7299  	i.GetPushPercent()
  7300  }
  7301  
  7302  func TestImport_GetRepositoryURL(tt *testing.T) {
  7303  	var zeroValue string
  7304  	i := &Import{RepositoryURL: &zeroValue}
  7305  	i.GetRepositoryURL()
  7306  	i = &Import{}
  7307  	i.GetRepositoryURL()
  7308  	i = nil
  7309  	i.GetRepositoryURL()
  7310  }
  7311  
  7312  func TestImport_GetStatus(tt *testing.T) {
  7313  	var zeroValue string
  7314  	i := &Import{Status: &zeroValue}
  7315  	i.GetStatus()
  7316  	i = &Import{}
  7317  	i.GetStatus()
  7318  	i = nil
  7319  	i.GetStatus()
  7320  }
  7321  
  7322  func TestImport_GetStatusText(tt *testing.T) {
  7323  	var zeroValue string
  7324  	i := &Import{StatusText: &zeroValue}
  7325  	i.GetStatusText()
  7326  	i = &Import{}
  7327  	i.GetStatusText()
  7328  	i = nil
  7329  	i.GetStatusText()
  7330  }
  7331  
  7332  func TestImport_GetTFVCProject(tt *testing.T) {
  7333  	var zeroValue string
  7334  	i := &Import{TFVCProject: &zeroValue}
  7335  	i.GetTFVCProject()
  7336  	i = &Import{}
  7337  	i.GetTFVCProject()
  7338  	i = nil
  7339  	i.GetTFVCProject()
  7340  }
  7341  
  7342  func TestImport_GetURL(tt *testing.T) {
  7343  	var zeroValue string
  7344  	i := &Import{URL: &zeroValue}
  7345  	i.GetURL()
  7346  	i = &Import{}
  7347  	i.GetURL()
  7348  	i = nil
  7349  	i.GetURL()
  7350  }
  7351  
  7352  func TestImport_GetUseLFS(tt *testing.T) {
  7353  	var zeroValue string
  7354  	i := &Import{UseLFS: &zeroValue}
  7355  	i.GetUseLFS()
  7356  	i = &Import{}
  7357  	i.GetUseLFS()
  7358  	i = nil
  7359  	i.GetUseLFS()
  7360  }
  7361  
  7362  func TestImport_GetVCS(tt *testing.T) {
  7363  	var zeroValue string
  7364  	i := &Import{VCS: &zeroValue}
  7365  	i.GetVCS()
  7366  	i = &Import{}
  7367  	i.GetVCS()
  7368  	i = nil
  7369  	i.GetVCS()
  7370  }
  7371  
  7372  func TestImport_GetVCSPassword(tt *testing.T) {
  7373  	var zeroValue string
  7374  	i := &Import{VCSPassword: &zeroValue}
  7375  	i.GetVCSPassword()
  7376  	i = &Import{}
  7377  	i.GetVCSPassword()
  7378  	i = nil
  7379  	i.GetVCSPassword()
  7380  }
  7381  
  7382  func TestImport_GetVCSURL(tt *testing.T) {
  7383  	var zeroValue string
  7384  	i := &Import{VCSURL: &zeroValue}
  7385  	i.GetVCSURL()
  7386  	i = &Import{}
  7387  	i.GetVCSURL()
  7388  	i = nil
  7389  	i.GetVCSURL()
  7390  }
  7391  
  7392  func TestImport_GetVCSUsername(tt *testing.T) {
  7393  	var zeroValue string
  7394  	i := &Import{VCSUsername: &zeroValue}
  7395  	i.GetVCSUsername()
  7396  	i = &Import{}
  7397  	i.GetVCSUsername()
  7398  	i = nil
  7399  	i.GetVCSUsername()
  7400  }
  7401  
  7402  func TestInstallation_GetAccessTokensURL(tt *testing.T) {
  7403  	var zeroValue string
  7404  	i := &Installation{AccessTokensURL: &zeroValue}
  7405  	i.GetAccessTokensURL()
  7406  	i = &Installation{}
  7407  	i.GetAccessTokensURL()
  7408  	i = nil
  7409  	i.GetAccessTokensURL()
  7410  }
  7411  
  7412  func TestInstallation_GetAccount(tt *testing.T) {
  7413  	i := &Installation{}
  7414  	i.GetAccount()
  7415  	i = nil
  7416  	i.GetAccount()
  7417  }
  7418  
  7419  func TestInstallation_GetAppID(tt *testing.T) {
  7420  	var zeroValue int64
  7421  	i := &Installation{AppID: &zeroValue}
  7422  	i.GetAppID()
  7423  	i = &Installation{}
  7424  	i.GetAppID()
  7425  	i = nil
  7426  	i.GetAppID()
  7427  }
  7428  
  7429  func TestInstallation_GetAppSlug(tt *testing.T) {
  7430  	var zeroValue string
  7431  	i := &Installation{AppSlug: &zeroValue}
  7432  	i.GetAppSlug()
  7433  	i = &Installation{}
  7434  	i.GetAppSlug()
  7435  	i = nil
  7436  	i.GetAppSlug()
  7437  }
  7438  
  7439  func TestInstallation_GetCreatedAt(tt *testing.T) {
  7440  	var zeroValue Timestamp
  7441  	i := &Installation{CreatedAt: &zeroValue}
  7442  	i.GetCreatedAt()
  7443  	i = &Installation{}
  7444  	i.GetCreatedAt()
  7445  	i = nil
  7446  	i.GetCreatedAt()
  7447  }
  7448  
  7449  func TestInstallation_GetHasMultipleSingleFiles(tt *testing.T) {
  7450  	var zeroValue bool
  7451  	i := &Installation{HasMultipleSingleFiles: &zeroValue}
  7452  	i.GetHasMultipleSingleFiles()
  7453  	i = &Installation{}
  7454  	i.GetHasMultipleSingleFiles()
  7455  	i = nil
  7456  	i.GetHasMultipleSingleFiles()
  7457  }
  7458  
  7459  func TestInstallation_GetHTMLURL(tt *testing.T) {
  7460  	var zeroValue string
  7461  	i := &Installation{HTMLURL: &zeroValue}
  7462  	i.GetHTMLURL()
  7463  	i = &Installation{}
  7464  	i.GetHTMLURL()
  7465  	i = nil
  7466  	i.GetHTMLURL()
  7467  }
  7468  
  7469  func TestInstallation_GetID(tt *testing.T) {
  7470  	var zeroValue int64
  7471  	i := &Installation{ID: &zeroValue}
  7472  	i.GetID()
  7473  	i = &Installation{}
  7474  	i.GetID()
  7475  	i = nil
  7476  	i.GetID()
  7477  }
  7478  
  7479  func TestInstallation_GetNodeID(tt *testing.T) {
  7480  	var zeroValue string
  7481  	i := &Installation{NodeID: &zeroValue}
  7482  	i.GetNodeID()
  7483  	i = &Installation{}
  7484  	i.GetNodeID()
  7485  	i = nil
  7486  	i.GetNodeID()
  7487  }
  7488  
  7489  func TestInstallation_GetPermissions(tt *testing.T) {
  7490  	i := &Installation{}
  7491  	i.GetPermissions()
  7492  	i = nil
  7493  	i.GetPermissions()
  7494  }
  7495  
  7496  func TestInstallation_GetRepositoriesURL(tt *testing.T) {
  7497  	var zeroValue string
  7498  	i := &Installation{RepositoriesURL: &zeroValue}
  7499  	i.GetRepositoriesURL()
  7500  	i = &Installation{}
  7501  	i.GetRepositoriesURL()
  7502  	i = nil
  7503  	i.GetRepositoriesURL()
  7504  }
  7505  
  7506  func TestInstallation_GetRepositorySelection(tt *testing.T) {
  7507  	var zeroValue string
  7508  	i := &Installation{RepositorySelection: &zeroValue}
  7509  	i.GetRepositorySelection()
  7510  	i = &Installation{}
  7511  	i.GetRepositorySelection()
  7512  	i = nil
  7513  	i.GetRepositorySelection()
  7514  }
  7515  
  7516  func TestInstallation_GetSingleFileName(tt *testing.T) {
  7517  	var zeroValue string
  7518  	i := &Installation{SingleFileName: &zeroValue}
  7519  	i.GetSingleFileName()
  7520  	i = &Installation{}
  7521  	i.GetSingleFileName()
  7522  	i = nil
  7523  	i.GetSingleFileName()
  7524  }
  7525  
  7526  func TestInstallation_GetSuspendedAt(tt *testing.T) {
  7527  	var zeroValue Timestamp
  7528  	i := &Installation{SuspendedAt: &zeroValue}
  7529  	i.GetSuspendedAt()
  7530  	i = &Installation{}
  7531  	i.GetSuspendedAt()
  7532  	i = nil
  7533  	i.GetSuspendedAt()
  7534  }
  7535  
  7536  func TestInstallation_GetSuspendedBy(tt *testing.T) {
  7537  	i := &Installation{}
  7538  	i.GetSuspendedBy()
  7539  	i = nil
  7540  	i.GetSuspendedBy()
  7541  }
  7542  
  7543  func TestInstallation_GetTargetID(tt *testing.T) {
  7544  	var zeroValue int64
  7545  	i := &Installation{TargetID: &zeroValue}
  7546  	i.GetTargetID()
  7547  	i = &Installation{}
  7548  	i.GetTargetID()
  7549  	i = nil
  7550  	i.GetTargetID()
  7551  }
  7552  
  7553  func TestInstallation_GetTargetType(tt *testing.T) {
  7554  	var zeroValue string
  7555  	i := &Installation{TargetType: &zeroValue}
  7556  	i.GetTargetType()
  7557  	i = &Installation{}
  7558  	i.GetTargetType()
  7559  	i = nil
  7560  	i.GetTargetType()
  7561  }
  7562  
  7563  func TestInstallation_GetUpdatedAt(tt *testing.T) {
  7564  	var zeroValue Timestamp
  7565  	i := &Installation{UpdatedAt: &zeroValue}
  7566  	i.GetUpdatedAt()
  7567  	i = &Installation{}
  7568  	i.GetUpdatedAt()
  7569  	i = nil
  7570  	i.GetUpdatedAt()
  7571  }
  7572  
  7573  func TestInstallationEvent_GetAction(tt *testing.T) {
  7574  	var zeroValue string
  7575  	i := &InstallationEvent{Action: &zeroValue}
  7576  	i.GetAction()
  7577  	i = &InstallationEvent{}
  7578  	i.GetAction()
  7579  	i = nil
  7580  	i.GetAction()
  7581  }
  7582  
  7583  func TestInstallationEvent_GetInstallation(tt *testing.T) {
  7584  	i := &InstallationEvent{}
  7585  	i.GetInstallation()
  7586  	i = nil
  7587  	i.GetInstallation()
  7588  }
  7589  
  7590  func TestInstallationEvent_GetSender(tt *testing.T) {
  7591  	i := &InstallationEvent{}
  7592  	i.GetSender()
  7593  	i = nil
  7594  	i.GetSender()
  7595  }
  7596  
  7597  func TestInstallationPermissions_GetActions(tt *testing.T) {
  7598  	var zeroValue string
  7599  	i := &InstallationPermissions{Actions: &zeroValue}
  7600  	i.GetActions()
  7601  	i = &InstallationPermissions{}
  7602  	i.GetActions()
  7603  	i = nil
  7604  	i.GetActions()
  7605  }
  7606  
  7607  func TestInstallationPermissions_GetAdministration(tt *testing.T) {
  7608  	var zeroValue string
  7609  	i := &InstallationPermissions{Administration: &zeroValue}
  7610  	i.GetAdministration()
  7611  	i = &InstallationPermissions{}
  7612  	i.GetAdministration()
  7613  	i = nil
  7614  	i.GetAdministration()
  7615  }
  7616  
  7617  func TestInstallationPermissions_GetBlocking(tt *testing.T) {
  7618  	var zeroValue string
  7619  	i := &InstallationPermissions{Blocking: &zeroValue}
  7620  	i.GetBlocking()
  7621  	i = &InstallationPermissions{}
  7622  	i.GetBlocking()
  7623  	i = nil
  7624  	i.GetBlocking()
  7625  }
  7626  
  7627  func TestInstallationPermissions_GetChecks(tt *testing.T) {
  7628  	var zeroValue string
  7629  	i := &InstallationPermissions{Checks: &zeroValue}
  7630  	i.GetChecks()
  7631  	i = &InstallationPermissions{}
  7632  	i.GetChecks()
  7633  	i = nil
  7634  	i.GetChecks()
  7635  }
  7636  
  7637  func TestInstallationPermissions_GetContentReferences(tt *testing.T) {
  7638  	var zeroValue string
  7639  	i := &InstallationPermissions{ContentReferences: &zeroValue}
  7640  	i.GetContentReferences()
  7641  	i = &InstallationPermissions{}
  7642  	i.GetContentReferences()
  7643  	i = nil
  7644  	i.GetContentReferences()
  7645  }
  7646  
  7647  func TestInstallationPermissions_GetContents(tt *testing.T) {
  7648  	var zeroValue string
  7649  	i := &InstallationPermissions{Contents: &zeroValue}
  7650  	i.GetContents()
  7651  	i = &InstallationPermissions{}
  7652  	i.GetContents()
  7653  	i = nil
  7654  	i.GetContents()
  7655  }
  7656  
  7657  func TestInstallationPermissions_GetDeployments(tt *testing.T) {
  7658  	var zeroValue string
  7659  	i := &InstallationPermissions{Deployments: &zeroValue}
  7660  	i.GetDeployments()
  7661  	i = &InstallationPermissions{}
  7662  	i.GetDeployments()
  7663  	i = nil
  7664  	i.GetDeployments()
  7665  }
  7666  
  7667  func TestInstallationPermissions_GetEmails(tt *testing.T) {
  7668  	var zeroValue string
  7669  	i := &InstallationPermissions{Emails: &zeroValue}
  7670  	i.GetEmails()
  7671  	i = &InstallationPermissions{}
  7672  	i.GetEmails()
  7673  	i = nil
  7674  	i.GetEmails()
  7675  }
  7676  
  7677  func TestInstallationPermissions_GetEnvironments(tt *testing.T) {
  7678  	var zeroValue string
  7679  	i := &InstallationPermissions{Environments: &zeroValue}
  7680  	i.GetEnvironments()
  7681  	i = &InstallationPermissions{}
  7682  	i.GetEnvironments()
  7683  	i = nil
  7684  	i.GetEnvironments()
  7685  }
  7686  
  7687  func TestInstallationPermissions_GetFollowers(tt *testing.T) {
  7688  	var zeroValue string
  7689  	i := &InstallationPermissions{Followers: &zeroValue}
  7690  	i.GetFollowers()
  7691  	i = &InstallationPermissions{}
  7692  	i.GetFollowers()
  7693  	i = nil
  7694  	i.GetFollowers()
  7695  }
  7696  
  7697  func TestInstallationPermissions_GetIssues(tt *testing.T) {
  7698  	var zeroValue string
  7699  	i := &InstallationPermissions{Issues: &zeroValue}
  7700  	i.GetIssues()
  7701  	i = &InstallationPermissions{}
  7702  	i.GetIssues()
  7703  	i = nil
  7704  	i.GetIssues()
  7705  }
  7706  
  7707  func TestInstallationPermissions_GetMembers(tt *testing.T) {
  7708  	var zeroValue string
  7709  	i := &InstallationPermissions{Members: &zeroValue}
  7710  	i.GetMembers()
  7711  	i = &InstallationPermissions{}
  7712  	i.GetMembers()
  7713  	i = nil
  7714  	i.GetMembers()
  7715  }
  7716  
  7717  func TestInstallationPermissions_GetMetadata(tt *testing.T) {
  7718  	var zeroValue string
  7719  	i := &InstallationPermissions{Metadata: &zeroValue}
  7720  	i.GetMetadata()
  7721  	i = &InstallationPermissions{}
  7722  	i.GetMetadata()
  7723  	i = nil
  7724  	i.GetMetadata()
  7725  }
  7726  
  7727  func TestInstallationPermissions_GetOrganizationAdministration(tt *testing.T) {
  7728  	var zeroValue string
  7729  	i := &InstallationPermissions{OrganizationAdministration: &zeroValue}
  7730  	i.GetOrganizationAdministration()
  7731  	i = &InstallationPermissions{}
  7732  	i.GetOrganizationAdministration()
  7733  	i = nil
  7734  	i.GetOrganizationAdministration()
  7735  }
  7736  
  7737  func TestInstallationPermissions_GetOrganizationCustomRoles(tt *testing.T) {
  7738  	var zeroValue string
  7739  	i := &InstallationPermissions{OrganizationCustomRoles: &zeroValue}
  7740  	i.GetOrganizationCustomRoles()
  7741  	i = &InstallationPermissions{}
  7742  	i.GetOrganizationCustomRoles()
  7743  	i = nil
  7744  	i.GetOrganizationCustomRoles()
  7745  }
  7746  
  7747  func TestInstallationPermissions_GetOrganizationHooks(tt *testing.T) {
  7748  	var zeroValue string
  7749  	i := &InstallationPermissions{OrganizationHooks: &zeroValue}
  7750  	i.GetOrganizationHooks()
  7751  	i = &InstallationPermissions{}
  7752  	i.GetOrganizationHooks()
  7753  	i = nil
  7754  	i.GetOrganizationHooks()
  7755  }
  7756  
  7757  func TestInstallationPermissions_GetOrganizationPackages(tt *testing.T) {
  7758  	var zeroValue string
  7759  	i := &InstallationPermissions{OrganizationPackages: &zeroValue}
  7760  	i.GetOrganizationPackages()
  7761  	i = &InstallationPermissions{}
  7762  	i.GetOrganizationPackages()
  7763  	i = nil
  7764  	i.GetOrganizationPackages()
  7765  }
  7766  
  7767  func TestInstallationPermissions_GetOrganizationPlan(tt *testing.T) {
  7768  	var zeroValue string
  7769  	i := &InstallationPermissions{OrganizationPlan: &zeroValue}
  7770  	i.GetOrganizationPlan()
  7771  	i = &InstallationPermissions{}
  7772  	i.GetOrganizationPlan()
  7773  	i = nil
  7774  	i.GetOrganizationPlan()
  7775  }
  7776  
  7777  func TestInstallationPermissions_GetOrganizationPreReceiveHooks(tt *testing.T) {
  7778  	var zeroValue string
  7779  	i := &InstallationPermissions{OrganizationPreReceiveHooks: &zeroValue}
  7780  	i.GetOrganizationPreReceiveHooks()
  7781  	i = &InstallationPermissions{}
  7782  	i.GetOrganizationPreReceiveHooks()
  7783  	i = nil
  7784  	i.GetOrganizationPreReceiveHooks()
  7785  }
  7786  
  7787  func TestInstallationPermissions_GetOrganizationProjects(tt *testing.T) {
  7788  	var zeroValue string
  7789  	i := &InstallationPermissions{OrganizationProjects: &zeroValue}
  7790  	i.GetOrganizationProjects()
  7791  	i = &InstallationPermissions{}
  7792  	i.GetOrganizationProjects()
  7793  	i = nil
  7794  	i.GetOrganizationProjects()
  7795  }
  7796  
  7797  func TestInstallationPermissions_GetOrganizationSecrets(tt *testing.T) {
  7798  	var zeroValue string
  7799  	i := &InstallationPermissions{OrganizationSecrets: &zeroValue}
  7800  	i.GetOrganizationSecrets()
  7801  	i = &InstallationPermissions{}
  7802  	i.GetOrganizationSecrets()
  7803  	i = nil
  7804  	i.GetOrganizationSecrets()
  7805  }
  7806  
  7807  func TestInstallationPermissions_GetOrganizationSelfHostedRunners(tt *testing.T) {
  7808  	var zeroValue string
  7809  	i := &InstallationPermissions{OrganizationSelfHostedRunners: &zeroValue}
  7810  	i.GetOrganizationSelfHostedRunners()
  7811  	i = &InstallationPermissions{}
  7812  	i.GetOrganizationSelfHostedRunners()
  7813  	i = nil
  7814  	i.GetOrganizationSelfHostedRunners()
  7815  }
  7816  
  7817  func TestInstallationPermissions_GetOrganizationUserBlocking(tt *testing.T) {
  7818  	var zeroValue string
  7819  	i := &InstallationPermissions{OrganizationUserBlocking: &zeroValue}
  7820  	i.GetOrganizationUserBlocking()
  7821  	i = &InstallationPermissions{}
  7822  	i.GetOrganizationUserBlocking()
  7823  	i = nil
  7824  	i.GetOrganizationUserBlocking()
  7825  }
  7826  
  7827  func TestInstallationPermissions_GetPackages(tt *testing.T) {
  7828  	var zeroValue string
  7829  	i := &InstallationPermissions{Packages: &zeroValue}
  7830  	i.GetPackages()
  7831  	i = &InstallationPermissions{}
  7832  	i.GetPackages()
  7833  	i = nil
  7834  	i.GetPackages()
  7835  }
  7836  
  7837  func TestInstallationPermissions_GetPages(tt *testing.T) {
  7838  	var zeroValue string
  7839  	i := &InstallationPermissions{Pages: &zeroValue}
  7840  	i.GetPages()
  7841  	i = &InstallationPermissions{}
  7842  	i.GetPages()
  7843  	i = nil
  7844  	i.GetPages()
  7845  }
  7846  
  7847  func TestInstallationPermissions_GetPullRequests(tt *testing.T) {
  7848  	var zeroValue string
  7849  	i := &InstallationPermissions{PullRequests: &zeroValue}
  7850  	i.GetPullRequests()
  7851  	i = &InstallationPermissions{}
  7852  	i.GetPullRequests()
  7853  	i = nil
  7854  	i.GetPullRequests()
  7855  }
  7856  
  7857  func TestInstallationPermissions_GetRepositoryHooks(tt *testing.T) {
  7858  	var zeroValue string
  7859  	i := &InstallationPermissions{RepositoryHooks: &zeroValue}
  7860  	i.GetRepositoryHooks()
  7861  	i = &InstallationPermissions{}
  7862  	i.GetRepositoryHooks()
  7863  	i = nil
  7864  	i.GetRepositoryHooks()
  7865  }
  7866  
  7867  func TestInstallationPermissions_GetRepositoryPreReceiveHooks(tt *testing.T) {
  7868  	var zeroValue string
  7869  	i := &InstallationPermissions{RepositoryPreReceiveHooks: &zeroValue}
  7870  	i.GetRepositoryPreReceiveHooks()
  7871  	i = &InstallationPermissions{}
  7872  	i.GetRepositoryPreReceiveHooks()
  7873  	i = nil
  7874  	i.GetRepositoryPreReceiveHooks()
  7875  }
  7876  
  7877  func TestInstallationPermissions_GetRepositoryProjects(tt *testing.T) {
  7878  	var zeroValue string
  7879  	i := &InstallationPermissions{RepositoryProjects: &zeroValue}
  7880  	i.GetRepositoryProjects()
  7881  	i = &InstallationPermissions{}
  7882  	i.GetRepositoryProjects()
  7883  	i = nil
  7884  	i.GetRepositoryProjects()
  7885  }
  7886  
  7887  func TestInstallationPermissions_GetSecrets(tt *testing.T) {
  7888  	var zeroValue string
  7889  	i := &InstallationPermissions{Secrets: &zeroValue}
  7890  	i.GetSecrets()
  7891  	i = &InstallationPermissions{}
  7892  	i.GetSecrets()
  7893  	i = nil
  7894  	i.GetSecrets()
  7895  }
  7896  
  7897  func TestInstallationPermissions_GetSecretScanningAlerts(tt *testing.T) {
  7898  	var zeroValue string
  7899  	i := &InstallationPermissions{SecretScanningAlerts: &zeroValue}
  7900  	i.GetSecretScanningAlerts()
  7901  	i = &InstallationPermissions{}
  7902  	i.GetSecretScanningAlerts()
  7903  	i = nil
  7904  	i.GetSecretScanningAlerts()
  7905  }
  7906  
  7907  func TestInstallationPermissions_GetSecurityEvents(tt *testing.T) {
  7908  	var zeroValue string
  7909  	i := &InstallationPermissions{SecurityEvents: &zeroValue}
  7910  	i.GetSecurityEvents()
  7911  	i = &InstallationPermissions{}
  7912  	i.GetSecurityEvents()
  7913  	i = nil
  7914  	i.GetSecurityEvents()
  7915  }
  7916  
  7917  func TestInstallationPermissions_GetSingleFile(tt *testing.T) {
  7918  	var zeroValue string
  7919  	i := &InstallationPermissions{SingleFile: &zeroValue}
  7920  	i.GetSingleFile()
  7921  	i = &InstallationPermissions{}
  7922  	i.GetSingleFile()
  7923  	i = nil
  7924  	i.GetSingleFile()
  7925  }
  7926  
  7927  func TestInstallationPermissions_GetStatuses(tt *testing.T) {
  7928  	var zeroValue string
  7929  	i := &InstallationPermissions{Statuses: &zeroValue}
  7930  	i.GetStatuses()
  7931  	i = &InstallationPermissions{}
  7932  	i.GetStatuses()
  7933  	i = nil
  7934  	i.GetStatuses()
  7935  }
  7936  
  7937  func TestInstallationPermissions_GetTeamDiscussions(tt *testing.T) {
  7938  	var zeroValue string
  7939  	i := &InstallationPermissions{TeamDiscussions: &zeroValue}
  7940  	i.GetTeamDiscussions()
  7941  	i = &InstallationPermissions{}
  7942  	i.GetTeamDiscussions()
  7943  	i = nil
  7944  	i.GetTeamDiscussions()
  7945  }
  7946  
  7947  func TestInstallationPermissions_GetVulnerabilityAlerts(tt *testing.T) {
  7948  	var zeroValue string
  7949  	i := &InstallationPermissions{VulnerabilityAlerts: &zeroValue}
  7950  	i.GetVulnerabilityAlerts()
  7951  	i = &InstallationPermissions{}
  7952  	i.GetVulnerabilityAlerts()
  7953  	i = nil
  7954  	i.GetVulnerabilityAlerts()
  7955  }
  7956  
  7957  func TestInstallationPermissions_GetWorkflows(tt *testing.T) {
  7958  	var zeroValue string
  7959  	i := &InstallationPermissions{Workflows: &zeroValue}
  7960  	i.GetWorkflows()
  7961  	i = &InstallationPermissions{}
  7962  	i.GetWorkflows()
  7963  	i = nil
  7964  	i.GetWorkflows()
  7965  }
  7966  
  7967  func TestInstallationRepositoriesEvent_GetAction(tt *testing.T) {
  7968  	var zeroValue string
  7969  	i := &InstallationRepositoriesEvent{Action: &zeroValue}
  7970  	i.GetAction()
  7971  	i = &InstallationRepositoriesEvent{}
  7972  	i.GetAction()
  7973  	i = nil
  7974  	i.GetAction()
  7975  }
  7976  
  7977  func TestInstallationRepositoriesEvent_GetInstallation(tt *testing.T) {
  7978  	i := &InstallationRepositoriesEvent{}
  7979  	i.GetInstallation()
  7980  	i = nil
  7981  	i.GetInstallation()
  7982  }
  7983  
  7984  func TestInstallationRepositoriesEvent_GetRepositorySelection(tt *testing.T) {
  7985  	var zeroValue string
  7986  	i := &InstallationRepositoriesEvent{RepositorySelection: &zeroValue}
  7987  	i.GetRepositorySelection()
  7988  	i = &InstallationRepositoriesEvent{}
  7989  	i.GetRepositorySelection()
  7990  	i = nil
  7991  	i.GetRepositorySelection()
  7992  }
  7993  
  7994  func TestInstallationRepositoriesEvent_GetSender(tt *testing.T) {
  7995  	i := &InstallationRepositoriesEvent{}
  7996  	i.GetSender()
  7997  	i = nil
  7998  	i.GetSender()
  7999  }
  8000  
  8001  func TestInstallationToken_GetExpiresAt(tt *testing.T) {
  8002  	var zeroValue time.Time
  8003  	i := &InstallationToken{ExpiresAt: &zeroValue}
  8004  	i.GetExpiresAt()
  8005  	i = &InstallationToken{}
  8006  	i.GetExpiresAt()
  8007  	i = nil
  8008  	i.GetExpiresAt()
  8009  }
  8010  
  8011  func TestInstallationToken_GetPermissions(tt *testing.T) {
  8012  	i := &InstallationToken{}
  8013  	i.GetPermissions()
  8014  	i = nil
  8015  	i.GetPermissions()
  8016  }
  8017  
  8018  func TestInstallationToken_GetToken(tt *testing.T) {
  8019  	var zeroValue string
  8020  	i := &InstallationToken{Token: &zeroValue}
  8021  	i.GetToken()
  8022  	i = &InstallationToken{}
  8023  	i.GetToken()
  8024  	i = nil
  8025  	i.GetToken()
  8026  }
  8027  
  8028  func TestInstallationTokenOptions_GetPermissions(tt *testing.T) {
  8029  	i := &InstallationTokenOptions{}
  8030  	i.GetPermissions()
  8031  	i = nil
  8032  	i.GetPermissions()
  8033  }
  8034  
  8035  func TestInteractionRestriction_GetExpiresAt(tt *testing.T) {
  8036  	var zeroValue Timestamp
  8037  	i := &InteractionRestriction{ExpiresAt: &zeroValue}
  8038  	i.GetExpiresAt()
  8039  	i = &InteractionRestriction{}
  8040  	i.GetExpiresAt()
  8041  	i = nil
  8042  	i.GetExpiresAt()
  8043  }
  8044  
  8045  func TestInteractionRestriction_GetLimit(tt *testing.T) {
  8046  	var zeroValue string
  8047  	i := &InteractionRestriction{Limit: &zeroValue}
  8048  	i.GetLimit()
  8049  	i = &InteractionRestriction{}
  8050  	i.GetLimit()
  8051  	i = nil
  8052  	i.GetLimit()
  8053  }
  8054  
  8055  func TestInteractionRestriction_GetOrigin(tt *testing.T) {
  8056  	var zeroValue string
  8057  	i := &InteractionRestriction{Origin: &zeroValue}
  8058  	i.GetOrigin()
  8059  	i = &InteractionRestriction{}
  8060  	i.GetOrigin()
  8061  	i = nil
  8062  	i.GetOrigin()
  8063  }
  8064  
  8065  func TestInvitation_GetCreatedAt(tt *testing.T) {
  8066  	var zeroValue time.Time
  8067  	i := &Invitation{CreatedAt: &zeroValue}
  8068  	i.GetCreatedAt()
  8069  	i = &Invitation{}
  8070  	i.GetCreatedAt()
  8071  	i = nil
  8072  	i.GetCreatedAt()
  8073  }
  8074  
  8075  func TestInvitation_GetEmail(tt *testing.T) {
  8076  	var zeroValue string
  8077  	i := &Invitation{Email: &zeroValue}
  8078  	i.GetEmail()
  8079  	i = &Invitation{}
  8080  	i.GetEmail()
  8081  	i = nil
  8082  	i.GetEmail()
  8083  }
  8084  
  8085  func TestInvitation_GetFailedAt(tt *testing.T) {
  8086  	var zeroValue Timestamp
  8087  	i := &Invitation{FailedAt: &zeroValue}
  8088  	i.GetFailedAt()
  8089  	i = &Invitation{}
  8090  	i.GetFailedAt()
  8091  	i = nil
  8092  	i.GetFailedAt()
  8093  }
  8094  
  8095  func TestInvitation_GetFailedReason(tt *testing.T) {
  8096  	var zeroValue string
  8097  	i := &Invitation{FailedReason: &zeroValue}
  8098  	i.GetFailedReason()
  8099  	i = &Invitation{}
  8100  	i.GetFailedReason()
  8101  	i = nil
  8102  	i.GetFailedReason()
  8103  }
  8104  
  8105  func TestInvitation_GetID(tt *testing.T) {
  8106  	var zeroValue int64
  8107  	i := &Invitation{ID: &zeroValue}
  8108  	i.GetID()
  8109  	i = &Invitation{}
  8110  	i.GetID()
  8111  	i = nil
  8112  	i.GetID()
  8113  }
  8114  
  8115  func TestInvitation_GetInvitationTeamURL(tt *testing.T) {
  8116  	var zeroValue string
  8117  	i := &Invitation{InvitationTeamURL: &zeroValue}
  8118  	i.GetInvitationTeamURL()
  8119  	i = &Invitation{}
  8120  	i.GetInvitationTeamURL()
  8121  	i = nil
  8122  	i.GetInvitationTeamURL()
  8123  }
  8124  
  8125  func TestInvitation_GetInviter(tt *testing.T) {
  8126  	i := &Invitation{}
  8127  	i.GetInviter()
  8128  	i = nil
  8129  	i.GetInviter()
  8130  }
  8131  
  8132  func TestInvitation_GetLogin(tt *testing.T) {
  8133  	var zeroValue string
  8134  	i := &Invitation{Login: &zeroValue}
  8135  	i.GetLogin()
  8136  	i = &Invitation{}
  8137  	i.GetLogin()
  8138  	i = nil
  8139  	i.GetLogin()
  8140  }
  8141  
  8142  func TestInvitation_GetNodeID(tt *testing.T) {
  8143  	var zeroValue string
  8144  	i := &Invitation{NodeID: &zeroValue}
  8145  	i.GetNodeID()
  8146  	i = &Invitation{}
  8147  	i.GetNodeID()
  8148  	i = nil
  8149  	i.GetNodeID()
  8150  }
  8151  
  8152  func TestInvitation_GetRole(tt *testing.T) {
  8153  	var zeroValue string
  8154  	i := &Invitation{Role: &zeroValue}
  8155  	i.GetRole()
  8156  	i = &Invitation{}
  8157  	i.GetRole()
  8158  	i = nil
  8159  	i.GetRole()
  8160  }
  8161  
  8162  func TestInvitation_GetTeamCount(tt *testing.T) {
  8163  	var zeroValue int
  8164  	i := &Invitation{TeamCount: &zeroValue}
  8165  	i.GetTeamCount()
  8166  	i = &Invitation{}
  8167  	i.GetTeamCount()
  8168  	i = nil
  8169  	i.GetTeamCount()
  8170  }
  8171  
  8172  func TestIssue_GetActiveLockReason(tt *testing.T) {
  8173  	var zeroValue string
  8174  	i := &Issue{ActiveLockReason: &zeroValue}
  8175  	i.GetActiveLockReason()
  8176  	i = &Issue{}
  8177  	i.GetActiveLockReason()
  8178  	i = nil
  8179  	i.GetActiveLockReason()
  8180  }
  8181  
  8182  func TestIssue_GetAssignee(tt *testing.T) {
  8183  	i := &Issue{}
  8184  	i.GetAssignee()
  8185  	i = nil
  8186  	i.GetAssignee()
  8187  }
  8188  
  8189  func TestIssue_GetAuthorAssociation(tt *testing.T) {
  8190  	var zeroValue string
  8191  	i := &Issue{AuthorAssociation: &zeroValue}
  8192  	i.GetAuthorAssociation()
  8193  	i = &Issue{}
  8194  	i.GetAuthorAssociation()
  8195  	i = nil
  8196  	i.GetAuthorAssociation()
  8197  }
  8198  
  8199  func TestIssue_GetBody(tt *testing.T) {
  8200  	var zeroValue string
  8201  	i := &Issue{Body: &zeroValue}
  8202  	i.GetBody()
  8203  	i = &Issue{}
  8204  	i.GetBody()
  8205  	i = nil
  8206  	i.GetBody()
  8207  }
  8208  
  8209  func TestIssue_GetClosedAt(tt *testing.T) {
  8210  	var zeroValue time.Time
  8211  	i := &Issue{ClosedAt: &zeroValue}
  8212  	i.GetClosedAt()
  8213  	i = &Issue{}
  8214  	i.GetClosedAt()
  8215  	i = nil
  8216  	i.GetClosedAt()
  8217  }
  8218  
  8219  func TestIssue_GetClosedBy(tt *testing.T) {
  8220  	i := &Issue{}
  8221  	i.GetClosedBy()
  8222  	i = nil
  8223  	i.GetClosedBy()
  8224  }
  8225  
  8226  func TestIssue_GetComments(tt *testing.T) {
  8227  	var zeroValue int
  8228  	i := &Issue{Comments: &zeroValue}
  8229  	i.GetComments()
  8230  	i = &Issue{}
  8231  	i.GetComments()
  8232  	i = nil
  8233  	i.GetComments()
  8234  }
  8235  
  8236  func TestIssue_GetCommentsURL(tt *testing.T) {
  8237  	var zeroValue string
  8238  	i := &Issue{CommentsURL: &zeroValue}
  8239  	i.GetCommentsURL()
  8240  	i = &Issue{}
  8241  	i.GetCommentsURL()
  8242  	i = nil
  8243  	i.GetCommentsURL()
  8244  }
  8245  
  8246  func TestIssue_GetCreatedAt(tt *testing.T) {
  8247  	var zeroValue time.Time
  8248  	i := &Issue{CreatedAt: &zeroValue}
  8249  	i.GetCreatedAt()
  8250  	i = &Issue{}
  8251  	i.GetCreatedAt()
  8252  	i = nil
  8253  	i.GetCreatedAt()
  8254  }
  8255  
  8256  func TestIssue_GetEventsURL(tt *testing.T) {
  8257  	var zeroValue string
  8258  	i := &Issue{EventsURL: &zeroValue}
  8259  	i.GetEventsURL()
  8260  	i = &Issue{}
  8261  	i.GetEventsURL()
  8262  	i = nil
  8263  	i.GetEventsURL()
  8264  }
  8265  
  8266  func TestIssue_GetHTMLURL(tt *testing.T) {
  8267  	var zeroValue string
  8268  	i := &Issue{HTMLURL: &zeroValue}
  8269  	i.GetHTMLURL()
  8270  	i = &Issue{}
  8271  	i.GetHTMLURL()
  8272  	i = nil
  8273  	i.GetHTMLURL()
  8274  }
  8275  
  8276  func TestIssue_GetID(tt *testing.T) {
  8277  	var zeroValue int64
  8278  	i := &Issue{ID: &zeroValue}
  8279  	i.GetID()
  8280  	i = &Issue{}
  8281  	i.GetID()
  8282  	i = nil
  8283  	i.GetID()
  8284  }
  8285  
  8286  func TestIssue_GetLabelsURL(tt *testing.T) {
  8287  	var zeroValue string
  8288  	i := &Issue{LabelsURL: &zeroValue}
  8289  	i.GetLabelsURL()
  8290  	i = &Issue{}
  8291  	i.GetLabelsURL()
  8292  	i = nil
  8293  	i.GetLabelsURL()
  8294  }
  8295  
  8296  func TestIssue_GetLocked(tt *testing.T) {
  8297  	var zeroValue bool
  8298  	i := &Issue{Locked: &zeroValue}
  8299  	i.GetLocked()
  8300  	i = &Issue{}
  8301  	i.GetLocked()
  8302  	i = nil
  8303  	i.GetLocked()
  8304  }
  8305  
  8306  func TestIssue_GetMilestone(tt *testing.T) {
  8307  	i := &Issue{}
  8308  	i.GetMilestone()
  8309  	i = nil
  8310  	i.GetMilestone()
  8311  }
  8312  
  8313  func TestIssue_GetNodeID(tt *testing.T) {
  8314  	var zeroValue string
  8315  	i := &Issue{NodeID: &zeroValue}
  8316  	i.GetNodeID()
  8317  	i = &Issue{}
  8318  	i.GetNodeID()
  8319  	i = nil
  8320  	i.GetNodeID()
  8321  }
  8322  
  8323  func TestIssue_GetNumber(tt *testing.T) {
  8324  	var zeroValue int
  8325  	i := &Issue{Number: &zeroValue}
  8326  	i.GetNumber()
  8327  	i = &Issue{}
  8328  	i.GetNumber()
  8329  	i = nil
  8330  	i.GetNumber()
  8331  }
  8332  
  8333  func TestIssue_GetPullRequestLinks(tt *testing.T) {
  8334  	i := &Issue{}
  8335  	i.GetPullRequestLinks()
  8336  	i = nil
  8337  	i.GetPullRequestLinks()
  8338  }
  8339  
  8340  func TestIssue_GetReactions(tt *testing.T) {
  8341  	i := &Issue{}
  8342  	i.GetReactions()
  8343  	i = nil
  8344  	i.GetReactions()
  8345  }
  8346  
  8347  func TestIssue_GetRepository(tt *testing.T) {
  8348  	i := &Issue{}
  8349  	i.GetRepository()
  8350  	i = nil
  8351  	i.GetRepository()
  8352  }
  8353  
  8354  func TestIssue_GetRepositoryURL(tt *testing.T) {
  8355  	var zeroValue string
  8356  	i := &Issue{RepositoryURL: &zeroValue}
  8357  	i.GetRepositoryURL()
  8358  	i = &Issue{}
  8359  	i.GetRepositoryURL()
  8360  	i = nil
  8361  	i.GetRepositoryURL()
  8362  }
  8363  
  8364  func TestIssue_GetState(tt *testing.T) {
  8365  	var zeroValue string
  8366  	i := &Issue{State: &zeroValue}
  8367  	i.GetState()
  8368  	i = &Issue{}
  8369  	i.GetState()
  8370  	i = nil
  8371  	i.GetState()
  8372  }
  8373  
  8374  func TestIssue_GetTitle(tt *testing.T) {
  8375  	var zeroValue string
  8376  	i := &Issue{Title: &zeroValue}
  8377  	i.GetTitle()
  8378  	i = &Issue{}
  8379  	i.GetTitle()
  8380  	i = nil
  8381  	i.GetTitle()
  8382  }
  8383  
  8384  func TestIssue_GetUpdatedAt(tt *testing.T) {
  8385  	var zeroValue time.Time
  8386  	i := &Issue{UpdatedAt: &zeroValue}
  8387  	i.GetUpdatedAt()
  8388  	i = &Issue{}
  8389  	i.GetUpdatedAt()
  8390  	i = nil
  8391  	i.GetUpdatedAt()
  8392  }
  8393  
  8394  func TestIssue_GetURL(tt *testing.T) {
  8395  	var zeroValue string
  8396  	i := &Issue{URL: &zeroValue}
  8397  	i.GetURL()
  8398  	i = &Issue{}
  8399  	i.GetURL()
  8400  	i = nil
  8401  	i.GetURL()
  8402  }
  8403  
  8404  func TestIssue_GetUser(tt *testing.T) {
  8405  	i := &Issue{}
  8406  	i.GetUser()
  8407  	i = nil
  8408  	i.GetUser()
  8409  }
  8410  
  8411  func TestIssueComment_GetAuthorAssociation(tt *testing.T) {
  8412  	var zeroValue string
  8413  	i := &IssueComment{AuthorAssociation: &zeroValue}
  8414  	i.GetAuthorAssociation()
  8415  	i = &IssueComment{}
  8416  	i.GetAuthorAssociation()
  8417  	i = nil
  8418  	i.GetAuthorAssociation()
  8419  }
  8420  
  8421  func TestIssueComment_GetBody(tt *testing.T) {
  8422  	var zeroValue string
  8423  	i := &IssueComment{Body: &zeroValue}
  8424  	i.GetBody()
  8425  	i = &IssueComment{}
  8426  	i.GetBody()
  8427  	i = nil
  8428  	i.GetBody()
  8429  }
  8430  
  8431  func TestIssueComment_GetCreatedAt(tt *testing.T) {
  8432  	var zeroValue time.Time
  8433  	i := &IssueComment{CreatedAt: &zeroValue}
  8434  	i.GetCreatedAt()
  8435  	i = &IssueComment{}
  8436  	i.GetCreatedAt()
  8437  	i = nil
  8438  	i.GetCreatedAt()
  8439  }
  8440  
  8441  func TestIssueComment_GetHTMLURL(tt *testing.T) {
  8442  	var zeroValue string
  8443  	i := &IssueComment{HTMLURL: &zeroValue}
  8444  	i.GetHTMLURL()
  8445  	i = &IssueComment{}
  8446  	i.GetHTMLURL()
  8447  	i = nil
  8448  	i.GetHTMLURL()
  8449  }
  8450  
  8451  func TestIssueComment_GetID(tt *testing.T) {
  8452  	var zeroValue int64
  8453  	i := &IssueComment{ID: &zeroValue}
  8454  	i.GetID()
  8455  	i = &IssueComment{}
  8456  	i.GetID()
  8457  	i = nil
  8458  	i.GetID()
  8459  }
  8460  
  8461  func TestIssueComment_GetIssueURL(tt *testing.T) {
  8462  	var zeroValue string
  8463  	i := &IssueComment{IssueURL: &zeroValue}
  8464  	i.GetIssueURL()
  8465  	i = &IssueComment{}
  8466  	i.GetIssueURL()
  8467  	i = nil
  8468  	i.GetIssueURL()
  8469  }
  8470  
  8471  func TestIssueComment_GetNodeID(tt *testing.T) {
  8472  	var zeroValue string
  8473  	i := &IssueComment{NodeID: &zeroValue}
  8474  	i.GetNodeID()
  8475  	i = &IssueComment{}
  8476  	i.GetNodeID()
  8477  	i = nil
  8478  	i.GetNodeID()
  8479  }
  8480  
  8481  func TestIssueComment_GetReactions(tt *testing.T) {
  8482  	i := &IssueComment{}
  8483  	i.GetReactions()
  8484  	i = nil
  8485  	i.GetReactions()
  8486  }
  8487  
  8488  func TestIssueComment_GetUpdatedAt(tt *testing.T) {
  8489  	var zeroValue time.Time
  8490  	i := &IssueComment{UpdatedAt: &zeroValue}
  8491  	i.GetUpdatedAt()
  8492  	i = &IssueComment{}
  8493  	i.GetUpdatedAt()
  8494  	i = nil
  8495  	i.GetUpdatedAt()
  8496  }
  8497  
  8498  func TestIssueComment_GetURL(tt *testing.T) {
  8499  	var zeroValue string
  8500  	i := &IssueComment{URL: &zeroValue}
  8501  	i.GetURL()
  8502  	i = &IssueComment{}
  8503  	i.GetURL()
  8504  	i = nil
  8505  	i.GetURL()
  8506  }
  8507  
  8508  func TestIssueComment_GetUser(tt *testing.T) {
  8509  	i := &IssueComment{}
  8510  	i.GetUser()
  8511  	i = nil
  8512  	i.GetUser()
  8513  }
  8514  
  8515  func TestIssueCommentEvent_GetAction(tt *testing.T) {
  8516  	var zeroValue string
  8517  	i := &IssueCommentEvent{Action: &zeroValue}
  8518  	i.GetAction()
  8519  	i = &IssueCommentEvent{}
  8520  	i.GetAction()
  8521  	i = nil
  8522  	i.GetAction()
  8523  }
  8524  
  8525  func TestIssueCommentEvent_GetChanges(tt *testing.T) {
  8526  	i := &IssueCommentEvent{}
  8527  	i.GetChanges()
  8528  	i = nil
  8529  	i.GetChanges()
  8530  }
  8531  
  8532  func TestIssueCommentEvent_GetComment(tt *testing.T) {
  8533  	i := &IssueCommentEvent{}
  8534  	i.GetComment()
  8535  	i = nil
  8536  	i.GetComment()
  8537  }
  8538  
  8539  func TestIssueCommentEvent_GetInstallation(tt *testing.T) {
  8540  	i := &IssueCommentEvent{}
  8541  	i.GetInstallation()
  8542  	i = nil
  8543  	i.GetInstallation()
  8544  }
  8545  
  8546  func TestIssueCommentEvent_GetIssue(tt *testing.T) {
  8547  	i := &IssueCommentEvent{}
  8548  	i.GetIssue()
  8549  	i = nil
  8550  	i.GetIssue()
  8551  }
  8552  
  8553  func TestIssueCommentEvent_GetOrganization(tt *testing.T) {
  8554  	i := &IssueCommentEvent{}
  8555  	i.GetOrganization()
  8556  	i = nil
  8557  	i.GetOrganization()
  8558  }
  8559  
  8560  func TestIssueCommentEvent_GetRepo(tt *testing.T) {
  8561  	i := &IssueCommentEvent{}
  8562  	i.GetRepo()
  8563  	i = nil
  8564  	i.GetRepo()
  8565  }
  8566  
  8567  func TestIssueCommentEvent_GetSender(tt *testing.T) {
  8568  	i := &IssueCommentEvent{}
  8569  	i.GetSender()
  8570  	i = nil
  8571  	i.GetSender()
  8572  }
  8573  
  8574  func TestIssueEvent_GetActor(tt *testing.T) {
  8575  	i := &IssueEvent{}
  8576  	i.GetActor()
  8577  	i = nil
  8578  	i.GetActor()
  8579  }
  8580  
  8581  func TestIssueEvent_GetAssignee(tt *testing.T) {
  8582  	i := &IssueEvent{}
  8583  	i.GetAssignee()
  8584  	i = nil
  8585  	i.GetAssignee()
  8586  }
  8587  
  8588  func TestIssueEvent_GetAssigner(tt *testing.T) {
  8589  	i := &IssueEvent{}
  8590  	i.GetAssigner()
  8591  	i = nil
  8592  	i.GetAssigner()
  8593  }
  8594  
  8595  func TestIssueEvent_GetCommitID(tt *testing.T) {
  8596  	var zeroValue string
  8597  	i := &IssueEvent{CommitID: &zeroValue}
  8598  	i.GetCommitID()
  8599  	i = &IssueEvent{}
  8600  	i.GetCommitID()
  8601  	i = nil
  8602  	i.GetCommitID()
  8603  }
  8604  
  8605  func TestIssueEvent_GetCreatedAt(tt *testing.T) {
  8606  	var zeroValue time.Time
  8607  	i := &IssueEvent{CreatedAt: &zeroValue}
  8608  	i.GetCreatedAt()
  8609  	i = &IssueEvent{}
  8610  	i.GetCreatedAt()
  8611  	i = nil
  8612  	i.GetCreatedAt()
  8613  }
  8614  
  8615  func TestIssueEvent_GetDismissedReview(tt *testing.T) {
  8616  	i := &IssueEvent{}
  8617  	i.GetDismissedReview()
  8618  	i = nil
  8619  	i.GetDismissedReview()
  8620  }
  8621  
  8622  func TestIssueEvent_GetEvent(tt *testing.T) {
  8623  	var zeroValue string
  8624  	i := &IssueEvent{Event: &zeroValue}
  8625  	i.GetEvent()
  8626  	i = &IssueEvent{}
  8627  	i.GetEvent()
  8628  	i = nil
  8629  	i.GetEvent()
  8630  }
  8631  
  8632  func TestIssueEvent_GetID(tt *testing.T) {
  8633  	var zeroValue int64
  8634  	i := &IssueEvent{ID: &zeroValue}
  8635  	i.GetID()
  8636  	i = &IssueEvent{}
  8637  	i.GetID()
  8638  	i = nil
  8639  	i.GetID()
  8640  }
  8641  
  8642  func TestIssueEvent_GetIssue(tt *testing.T) {
  8643  	i := &IssueEvent{}
  8644  	i.GetIssue()
  8645  	i = nil
  8646  	i.GetIssue()
  8647  }
  8648  
  8649  func TestIssueEvent_GetLabel(tt *testing.T) {
  8650  	i := &IssueEvent{}
  8651  	i.GetLabel()
  8652  	i = nil
  8653  	i.GetLabel()
  8654  }
  8655  
  8656  func TestIssueEvent_GetLockReason(tt *testing.T) {
  8657  	var zeroValue string
  8658  	i := &IssueEvent{LockReason: &zeroValue}
  8659  	i.GetLockReason()
  8660  	i = &IssueEvent{}
  8661  	i.GetLockReason()
  8662  	i = nil
  8663  	i.GetLockReason()
  8664  }
  8665  
  8666  func TestIssueEvent_GetMilestone(tt *testing.T) {
  8667  	i := &IssueEvent{}
  8668  	i.GetMilestone()
  8669  	i = nil
  8670  	i.GetMilestone()
  8671  }
  8672  
  8673  func TestIssueEvent_GetProjectCard(tt *testing.T) {
  8674  	i := &IssueEvent{}
  8675  	i.GetProjectCard()
  8676  	i = nil
  8677  	i.GetProjectCard()
  8678  }
  8679  
  8680  func TestIssueEvent_GetRename(tt *testing.T) {
  8681  	i := &IssueEvent{}
  8682  	i.GetRename()
  8683  	i = nil
  8684  	i.GetRename()
  8685  }
  8686  
  8687  func TestIssueEvent_GetRequestedReviewer(tt *testing.T) {
  8688  	i := &IssueEvent{}
  8689  	i.GetRequestedReviewer()
  8690  	i = nil
  8691  	i.GetRequestedReviewer()
  8692  }
  8693  
  8694  func TestIssueEvent_GetReviewRequester(tt *testing.T) {
  8695  	i := &IssueEvent{}
  8696  	i.GetReviewRequester()
  8697  	i = nil
  8698  	i.GetReviewRequester()
  8699  }
  8700  
  8701  func TestIssueEvent_GetURL(tt *testing.T) {
  8702  	var zeroValue string
  8703  	i := &IssueEvent{URL: &zeroValue}
  8704  	i.GetURL()
  8705  	i = &IssueEvent{}
  8706  	i.GetURL()
  8707  	i = nil
  8708  	i.GetURL()
  8709  }
  8710  
  8711  func TestIssueImport_GetAssignee(tt *testing.T) {
  8712  	var zeroValue string
  8713  	i := &IssueImport{Assignee: &zeroValue}
  8714  	i.GetAssignee()
  8715  	i = &IssueImport{}
  8716  	i.GetAssignee()
  8717  	i = nil
  8718  	i.GetAssignee()
  8719  }
  8720  
  8721  func TestIssueImport_GetClosed(tt *testing.T) {
  8722  	var zeroValue bool
  8723  	i := &IssueImport{Closed: &zeroValue}
  8724  	i.GetClosed()
  8725  	i = &IssueImport{}
  8726  	i.GetClosed()
  8727  	i = nil
  8728  	i.GetClosed()
  8729  }
  8730  
  8731  func TestIssueImport_GetClosedAt(tt *testing.T) {
  8732  	var zeroValue time.Time
  8733  	i := &IssueImport{ClosedAt: &zeroValue}
  8734  	i.GetClosedAt()
  8735  	i = &IssueImport{}
  8736  	i.GetClosedAt()
  8737  	i = nil
  8738  	i.GetClosedAt()
  8739  }
  8740  
  8741  func TestIssueImport_GetCreatedAt(tt *testing.T) {
  8742  	var zeroValue time.Time
  8743  	i := &IssueImport{CreatedAt: &zeroValue}
  8744  	i.GetCreatedAt()
  8745  	i = &IssueImport{}
  8746  	i.GetCreatedAt()
  8747  	i = nil
  8748  	i.GetCreatedAt()
  8749  }
  8750  
  8751  func TestIssueImport_GetMilestone(tt *testing.T) {
  8752  	var zeroValue int
  8753  	i := &IssueImport{Milestone: &zeroValue}
  8754  	i.GetMilestone()
  8755  	i = &IssueImport{}
  8756  	i.GetMilestone()
  8757  	i = nil
  8758  	i.GetMilestone()
  8759  }
  8760  
  8761  func TestIssueImport_GetUpdatedAt(tt *testing.T) {
  8762  	var zeroValue time.Time
  8763  	i := &IssueImport{UpdatedAt: &zeroValue}
  8764  	i.GetUpdatedAt()
  8765  	i = &IssueImport{}
  8766  	i.GetUpdatedAt()
  8767  	i = nil
  8768  	i.GetUpdatedAt()
  8769  }
  8770  
  8771  func TestIssueImportError_GetCode(tt *testing.T) {
  8772  	var zeroValue string
  8773  	i := &IssueImportError{Code: &zeroValue}
  8774  	i.GetCode()
  8775  	i = &IssueImportError{}
  8776  	i.GetCode()
  8777  	i = nil
  8778  	i.GetCode()
  8779  }
  8780  
  8781  func TestIssueImportError_GetField(tt *testing.T) {
  8782  	var zeroValue string
  8783  	i := &IssueImportError{Field: &zeroValue}
  8784  	i.GetField()
  8785  	i = &IssueImportError{}
  8786  	i.GetField()
  8787  	i = nil
  8788  	i.GetField()
  8789  }
  8790  
  8791  func TestIssueImportError_GetLocation(tt *testing.T) {
  8792  	var zeroValue string
  8793  	i := &IssueImportError{Location: &zeroValue}
  8794  	i.GetLocation()
  8795  	i = &IssueImportError{}
  8796  	i.GetLocation()
  8797  	i = nil
  8798  	i.GetLocation()
  8799  }
  8800  
  8801  func TestIssueImportError_GetResource(tt *testing.T) {
  8802  	var zeroValue string
  8803  	i := &IssueImportError{Resource: &zeroValue}
  8804  	i.GetResource()
  8805  	i = &IssueImportError{}
  8806  	i.GetResource()
  8807  	i = nil
  8808  	i.GetResource()
  8809  }
  8810  
  8811  func TestIssueImportError_GetValue(tt *testing.T) {
  8812  	var zeroValue string
  8813  	i := &IssueImportError{Value: &zeroValue}
  8814  	i.GetValue()
  8815  	i = &IssueImportError{}
  8816  	i.GetValue()
  8817  	i = nil
  8818  	i.GetValue()
  8819  }
  8820  
  8821  func TestIssueImportResponse_GetCreatedAt(tt *testing.T) {
  8822  	var zeroValue time.Time
  8823  	i := &IssueImportResponse{CreatedAt: &zeroValue}
  8824  	i.GetCreatedAt()
  8825  	i = &IssueImportResponse{}
  8826  	i.GetCreatedAt()
  8827  	i = nil
  8828  	i.GetCreatedAt()
  8829  }
  8830  
  8831  func TestIssueImportResponse_GetDocumentationURL(tt *testing.T) {
  8832  	var zeroValue string
  8833  	i := &IssueImportResponse{DocumentationURL: &zeroValue}
  8834  	i.GetDocumentationURL()
  8835  	i = &IssueImportResponse{}
  8836  	i.GetDocumentationURL()
  8837  	i = nil
  8838  	i.GetDocumentationURL()
  8839  }
  8840  
  8841  func TestIssueImportResponse_GetID(tt *testing.T) {
  8842  	var zeroValue int
  8843  	i := &IssueImportResponse{ID: &zeroValue}
  8844  	i.GetID()
  8845  	i = &IssueImportResponse{}
  8846  	i.GetID()
  8847  	i = nil
  8848  	i.GetID()
  8849  }
  8850  
  8851  func TestIssueImportResponse_GetImportIssuesURL(tt *testing.T) {
  8852  	var zeroValue string
  8853  	i := &IssueImportResponse{ImportIssuesURL: &zeroValue}
  8854  	i.GetImportIssuesURL()
  8855  	i = &IssueImportResponse{}
  8856  	i.GetImportIssuesURL()
  8857  	i = nil
  8858  	i.GetImportIssuesURL()
  8859  }
  8860  
  8861  func TestIssueImportResponse_GetMessage(tt *testing.T) {
  8862  	var zeroValue string
  8863  	i := &IssueImportResponse{Message: &zeroValue}
  8864  	i.GetMessage()
  8865  	i = &IssueImportResponse{}
  8866  	i.GetMessage()
  8867  	i = nil
  8868  	i.GetMessage()
  8869  }
  8870  
  8871  func TestIssueImportResponse_GetRepositoryURL(tt *testing.T) {
  8872  	var zeroValue string
  8873  	i := &IssueImportResponse{RepositoryURL: &zeroValue}
  8874  	i.GetRepositoryURL()
  8875  	i = &IssueImportResponse{}
  8876  	i.GetRepositoryURL()
  8877  	i = nil
  8878  	i.GetRepositoryURL()
  8879  }
  8880  
  8881  func TestIssueImportResponse_GetStatus(tt *testing.T) {
  8882  	var zeroValue string
  8883  	i := &IssueImportResponse{Status: &zeroValue}
  8884  	i.GetStatus()
  8885  	i = &IssueImportResponse{}
  8886  	i.GetStatus()
  8887  	i = nil
  8888  	i.GetStatus()
  8889  }
  8890  
  8891  func TestIssueImportResponse_GetUpdatedAt(tt *testing.T) {
  8892  	var zeroValue time.Time
  8893  	i := &IssueImportResponse{UpdatedAt: &zeroValue}
  8894  	i.GetUpdatedAt()
  8895  	i = &IssueImportResponse{}
  8896  	i.GetUpdatedAt()
  8897  	i = nil
  8898  	i.GetUpdatedAt()
  8899  }
  8900  
  8901  func TestIssueImportResponse_GetURL(tt *testing.T) {
  8902  	var zeroValue string
  8903  	i := &IssueImportResponse{URL: &zeroValue}
  8904  	i.GetURL()
  8905  	i = &IssueImportResponse{}
  8906  	i.GetURL()
  8907  	i = nil
  8908  	i.GetURL()
  8909  }
  8910  
  8911  func TestIssueListCommentsOptions_GetDirection(tt *testing.T) {
  8912  	var zeroValue string
  8913  	i := &IssueListCommentsOptions{Direction: &zeroValue}
  8914  	i.GetDirection()
  8915  	i = &IssueListCommentsOptions{}
  8916  	i.GetDirection()
  8917  	i = nil
  8918  	i.GetDirection()
  8919  }
  8920  
  8921  func TestIssueListCommentsOptions_GetSince(tt *testing.T) {
  8922  	var zeroValue time.Time
  8923  	i := &IssueListCommentsOptions{Since: &zeroValue}
  8924  	i.GetSince()
  8925  	i = &IssueListCommentsOptions{}
  8926  	i.GetSince()
  8927  	i = nil
  8928  	i.GetSince()
  8929  }
  8930  
  8931  func TestIssueListCommentsOptions_GetSort(tt *testing.T) {
  8932  	var zeroValue string
  8933  	i := &IssueListCommentsOptions{Sort: &zeroValue}
  8934  	i.GetSort()
  8935  	i = &IssueListCommentsOptions{}
  8936  	i.GetSort()
  8937  	i = nil
  8938  	i.GetSort()
  8939  }
  8940  
  8941  func TestIssueRequest_GetAssignee(tt *testing.T) {
  8942  	var zeroValue string
  8943  	i := &IssueRequest{Assignee: &zeroValue}
  8944  	i.GetAssignee()
  8945  	i = &IssueRequest{}
  8946  	i.GetAssignee()
  8947  	i = nil
  8948  	i.GetAssignee()
  8949  }
  8950  
  8951  func TestIssueRequest_GetAssignees(tt *testing.T) {
  8952  	var zeroValue []string
  8953  	i := &IssueRequest{Assignees: &zeroValue}
  8954  	i.GetAssignees()
  8955  	i = &IssueRequest{}
  8956  	i.GetAssignees()
  8957  	i = nil
  8958  	i.GetAssignees()
  8959  }
  8960  
  8961  func TestIssueRequest_GetBody(tt *testing.T) {
  8962  	var zeroValue string
  8963  	i := &IssueRequest{Body: &zeroValue}
  8964  	i.GetBody()
  8965  	i = &IssueRequest{}
  8966  	i.GetBody()
  8967  	i = nil
  8968  	i.GetBody()
  8969  }
  8970  
  8971  func TestIssueRequest_GetLabels(tt *testing.T) {
  8972  	var zeroValue []string
  8973  	i := &IssueRequest{Labels: &zeroValue}
  8974  	i.GetLabels()
  8975  	i = &IssueRequest{}
  8976  	i.GetLabels()
  8977  	i = nil
  8978  	i.GetLabels()
  8979  }
  8980  
  8981  func TestIssueRequest_GetMilestone(tt *testing.T) {
  8982  	var zeroValue int
  8983  	i := &IssueRequest{Milestone: &zeroValue}
  8984  	i.GetMilestone()
  8985  	i = &IssueRequest{}
  8986  	i.GetMilestone()
  8987  	i = nil
  8988  	i.GetMilestone()
  8989  }
  8990  
  8991  func TestIssueRequest_GetState(tt *testing.T) {
  8992  	var zeroValue string
  8993  	i := &IssueRequest{State: &zeroValue}
  8994  	i.GetState()
  8995  	i = &IssueRequest{}
  8996  	i.GetState()
  8997  	i = nil
  8998  	i.GetState()
  8999  }
  9000  
  9001  func TestIssueRequest_GetStateReason(tt *testing.T) {
  9002  	var zeroValue string
  9003  	i := &IssueRequest{StateReason: &zeroValue}
  9004  	i.GetStateReason()
  9005  	i = &IssueRequest{}
  9006  	i.GetStateReason()
  9007  	i = nil
  9008  	i.GetStateReason()
  9009  }
  9010  
  9011  func TestIssueRequest_GetTitle(tt *testing.T) {
  9012  	var zeroValue string
  9013  	i := &IssueRequest{Title: &zeroValue}
  9014  	i.GetTitle()
  9015  	i = &IssueRequest{}
  9016  	i.GetTitle()
  9017  	i = nil
  9018  	i.GetTitle()
  9019  }
  9020  
  9021  func TestIssuesEvent_GetAction(tt *testing.T) {
  9022  	var zeroValue string
  9023  	i := &IssuesEvent{Action: &zeroValue}
  9024  	i.GetAction()
  9025  	i = &IssuesEvent{}
  9026  	i.GetAction()
  9027  	i = nil
  9028  	i.GetAction()
  9029  }
  9030  
  9031  func TestIssuesEvent_GetAssignee(tt *testing.T) {
  9032  	i := &IssuesEvent{}
  9033  	i.GetAssignee()
  9034  	i = nil
  9035  	i.GetAssignee()
  9036  }
  9037  
  9038  func TestIssuesEvent_GetChanges(tt *testing.T) {
  9039  	i := &IssuesEvent{}
  9040  	i.GetChanges()
  9041  	i = nil
  9042  	i.GetChanges()
  9043  }
  9044  
  9045  func TestIssuesEvent_GetInstallation(tt *testing.T) {
  9046  	i := &IssuesEvent{}
  9047  	i.GetInstallation()
  9048  	i = nil
  9049  	i.GetInstallation()
  9050  }
  9051  
  9052  func TestIssuesEvent_GetIssue(tt *testing.T) {
  9053  	i := &IssuesEvent{}
  9054  	i.GetIssue()
  9055  	i = nil
  9056  	i.GetIssue()
  9057  }
  9058  
  9059  func TestIssuesEvent_GetLabel(tt *testing.T) {
  9060  	i := &IssuesEvent{}
  9061  	i.GetLabel()
  9062  	i = nil
  9063  	i.GetLabel()
  9064  }
  9065  
  9066  func TestIssuesEvent_GetRepo(tt *testing.T) {
  9067  	i := &IssuesEvent{}
  9068  	i.GetRepo()
  9069  	i = nil
  9070  	i.GetRepo()
  9071  }
  9072  
  9073  func TestIssuesEvent_GetSender(tt *testing.T) {
  9074  	i := &IssuesEvent{}
  9075  	i.GetSender()
  9076  	i = nil
  9077  	i.GetSender()
  9078  }
  9079  
  9080  func TestIssuesSearchResult_GetIncompleteResults(tt *testing.T) {
  9081  	var zeroValue bool
  9082  	i := &IssuesSearchResult{IncompleteResults: &zeroValue}
  9083  	i.GetIncompleteResults()
  9084  	i = &IssuesSearchResult{}
  9085  	i.GetIncompleteResults()
  9086  	i = nil
  9087  	i.GetIncompleteResults()
  9088  }
  9089  
  9090  func TestIssuesSearchResult_GetTotal(tt *testing.T) {
  9091  	var zeroValue int
  9092  	i := &IssuesSearchResult{Total: &zeroValue}
  9093  	i.GetTotal()
  9094  	i = &IssuesSearchResult{}
  9095  	i.GetTotal()
  9096  	i = nil
  9097  	i.GetTotal()
  9098  }
  9099  
  9100  func TestIssueStats_GetClosedIssues(tt *testing.T) {
  9101  	var zeroValue int
  9102  	i := &IssueStats{ClosedIssues: &zeroValue}
  9103  	i.GetClosedIssues()
  9104  	i = &IssueStats{}
  9105  	i.GetClosedIssues()
  9106  	i = nil
  9107  	i.GetClosedIssues()
  9108  }
  9109  
  9110  func TestIssueStats_GetOpenIssues(tt *testing.T) {
  9111  	var zeroValue int
  9112  	i := &IssueStats{OpenIssues: &zeroValue}
  9113  	i.GetOpenIssues()
  9114  	i = &IssueStats{}
  9115  	i.GetOpenIssues()
  9116  	i = nil
  9117  	i.GetOpenIssues()
  9118  }
  9119  
  9120  func TestIssueStats_GetTotalIssues(tt *testing.T) {
  9121  	var zeroValue int
  9122  	i := &IssueStats{TotalIssues: &zeroValue}
  9123  	i.GetTotalIssues()
  9124  	i = &IssueStats{}
  9125  	i.GetTotalIssues()
  9126  	i = nil
  9127  	i.GetTotalIssues()
  9128  }
  9129  
  9130  func TestJobs_GetTotalCount(tt *testing.T) {
  9131  	var zeroValue int
  9132  	j := &Jobs{TotalCount: &zeroValue}
  9133  	j.GetTotalCount()
  9134  	j = &Jobs{}
  9135  	j.GetTotalCount()
  9136  	j = nil
  9137  	j.GetTotalCount()
  9138  }
  9139  
  9140  func TestKey_GetCreatedAt(tt *testing.T) {
  9141  	var zeroValue Timestamp
  9142  	k := &Key{CreatedAt: &zeroValue}
  9143  	k.GetCreatedAt()
  9144  	k = &Key{}
  9145  	k.GetCreatedAt()
  9146  	k = nil
  9147  	k.GetCreatedAt()
  9148  }
  9149  
  9150  func TestKey_GetID(tt *testing.T) {
  9151  	var zeroValue int64
  9152  	k := &Key{ID: &zeroValue}
  9153  	k.GetID()
  9154  	k = &Key{}
  9155  	k.GetID()
  9156  	k = nil
  9157  	k.GetID()
  9158  }
  9159  
  9160  func TestKey_GetKey(tt *testing.T) {
  9161  	var zeroValue string
  9162  	k := &Key{Key: &zeroValue}
  9163  	k.GetKey()
  9164  	k = &Key{}
  9165  	k.GetKey()
  9166  	k = nil
  9167  	k.GetKey()
  9168  }
  9169  
  9170  func TestKey_GetReadOnly(tt *testing.T) {
  9171  	var zeroValue bool
  9172  	k := &Key{ReadOnly: &zeroValue}
  9173  	k.GetReadOnly()
  9174  	k = &Key{}
  9175  	k.GetReadOnly()
  9176  	k = nil
  9177  	k.GetReadOnly()
  9178  }
  9179  
  9180  func TestKey_GetTitle(tt *testing.T) {
  9181  	var zeroValue string
  9182  	k := &Key{Title: &zeroValue}
  9183  	k.GetTitle()
  9184  	k = &Key{}
  9185  	k.GetTitle()
  9186  	k = nil
  9187  	k.GetTitle()
  9188  }
  9189  
  9190  func TestKey_GetURL(tt *testing.T) {
  9191  	var zeroValue string
  9192  	k := &Key{URL: &zeroValue}
  9193  	k.GetURL()
  9194  	k = &Key{}
  9195  	k.GetURL()
  9196  	k = nil
  9197  	k.GetURL()
  9198  }
  9199  
  9200  func TestKey_GetVerified(tt *testing.T) {
  9201  	var zeroValue bool
  9202  	k := &Key{Verified: &zeroValue}
  9203  	k.GetVerified()
  9204  	k = &Key{}
  9205  	k.GetVerified()
  9206  	k = nil
  9207  	k.GetVerified()
  9208  }
  9209  
  9210  func TestLabel_GetColor(tt *testing.T) {
  9211  	var zeroValue string
  9212  	l := &Label{Color: &zeroValue}
  9213  	l.GetColor()
  9214  	l = &Label{}
  9215  	l.GetColor()
  9216  	l = nil
  9217  	l.GetColor()
  9218  }
  9219  
  9220  func TestLabel_GetDefault(tt *testing.T) {
  9221  	var zeroValue bool
  9222  	l := &Label{Default: &zeroValue}
  9223  	l.GetDefault()
  9224  	l = &Label{}
  9225  	l.GetDefault()
  9226  	l = nil
  9227  	l.GetDefault()
  9228  }
  9229  
  9230  func TestLabel_GetDescription(tt *testing.T) {
  9231  	var zeroValue string
  9232  	l := &Label{Description: &zeroValue}
  9233  	l.GetDescription()
  9234  	l = &Label{}
  9235  	l.GetDescription()
  9236  	l = nil
  9237  	l.GetDescription()
  9238  }
  9239  
  9240  func TestLabel_GetID(tt *testing.T) {
  9241  	var zeroValue int64
  9242  	l := &Label{ID: &zeroValue}
  9243  	l.GetID()
  9244  	l = &Label{}
  9245  	l.GetID()
  9246  	l = nil
  9247  	l.GetID()
  9248  }
  9249  
  9250  func TestLabel_GetName(tt *testing.T) {
  9251  	var zeroValue string
  9252  	l := &Label{Name: &zeroValue}
  9253  	l.GetName()
  9254  	l = &Label{}
  9255  	l.GetName()
  9256  	l = nil
  9257  	l.GetName()
  9258  }
  9259  
  9260  func TestLabel_GetNodeID(tt *testing.T) {
  9261  	var zeroValue string
  9262  	l := &Label{NodeID: &zeroValue}
  9263  	l.GetNodeID()
  9264  	l = &Label{}
  9265  	l.GetNodeID()
  9266  	l = nil
  9267  	l.GetNodeID()
  9268  }
  9269  
  9270  func TestLabel_GetURL(tt *testing.T) {
  9271  	var zeroValue string
  9272  	l := &Label{URL: &zeroValue}
  9273  	l.GetURL()
  9274  	l = &Label{}
  9275  	l.GetURL()
  9276  	l = nil
  9277  	l.GetURL()
  9278  }
  9279  
  9280  func TestLabelEvent_GetAction(tt *testing.T) {
  9281  	var zeroValue string
  9282  	l := &LabelEvent{Action: &zeroValue}
  9283  	l.GetAction()
  9284  	l = &LabelEvent{}
  9285  	l.GetAction()
  9286  	l = nil
  9287  	l.GetAction()
  9288  }
  9289  
  9290  func TestLabelEvent_GetChanges(tt *testing.T) {
  9291  	l := &LabelEvent{}
  9292  	l.GetChanges()
  9293  	l = nil
  9294  	l.GetChanges()
  9295  }
  9296  
  9297  func TestLabelEvent_GetInstallation(tt *testing.T) {
  9298  	l := &LabelEvent{}
  9299  	l.GetInstallation()
  9300  	l = nil
  9301  	l.GetInstallation()
  9302  }
  9303  
  9304  func TestLabelEvent_GetLabel(tt *testing.T) {
  9305  	l := &LabelEvent{}
  9306  	l.GetLabel()
  9307  	l = nil
  9308  	l.GetLabel()
  9309  }
  9310  
  9311  func TestLabelEvent_GetOrg(tt *testing.T) {
  9312  	l := &LabelEvent{}
  9313  	l.GetOrg()
  9314  	l = nil
  9315  	l.GetOrg()
  9316  }
  9317  
  9318  func TestLabelEvent_GetRepo(tt *testing.T) {
  9319  	l := &LabelEvent{}
  9320  	l.GetRepo()
  9321  	l = nil
  9322  	l.GetRepo()
  9323  }
  9324  
  9325  func TestLabelEvent_GetSender(tt *testing.T) {
  9326  	l := &LabelEvent{}
  9327  	l.GetSender()
  9328  	l = nil
  9329  	l.GetSender()
  9330  }
  9331  
  9332  func TestLabelResult_GetColor(tt *testing.T) {
  9333  	var zeroValue string
  9334  	l := &LabelResult{Color: &zeroValue}
  9335  	l.GetColor()
  9336  	l = &LabelResult{}
  9337  	l.GetColor()
  9338  	l = nil
  9339  	l.GetColor()
  9340  }
  9341  
  9342  func TestLabelResult_GetDefault(tt *testing.T) {
  9343  	var zeroValue bool
  9344  	l := &LabelResult{Default: &zeroValue}
  9345  	l.GetDefault()
  9346  	l = &LabelResult{}
  9347  	l.GetDefault()
  9348  	l = nil
  9349  	l.GetDefault()
  9350  }
  9351  
  9352  func TestLabelResult_GetDescription(tt *testing.T) {
  9353  	var zeroValue string
  9354  	l := &LabelResult{Description: &zeroValue}
  9355  	l.GetDescription()
  9356  	l = &LabelResult{}
  9357  	l.GetDescription()
  9358  	l = nil
  9359  	l.GetDescription()
  9360  }
  9361  
  9362  func TestLabelResult_GetID(tt *testing.T) {
  9363  	var zeroValue int64
  9364  	l := &LabelResult{ID: &zeroValue}
  9365  	l.GetID()
  9366  	l = &LabelResult{}
  9367  	l.GetID()
  9368  	l = nil
  9369  	l.GetID()
  9370  }
  9371  
  9372  func TestLabelResult_GetName(tt *testing.T) {
  9373  	var zeroValue string
  9374  	l := &LabelResult{Name: &zeroValue}
  9375  	l.GetName()
  9376  	l = &LabelResult{}
  9377  	l.GetName()
  9378  	l = nil
  9379  	l.GetName()
  9380  }
  9381  
  9382  func TestLabelResult_GetScore(tt *testing.T) {
  9383  	l := &LabelResult{}
  9384  	l.GetScore()
  9385  	l = nil
  9386  	l.GetScore()
  9387  }
  9388  
  9389  func TestLabelResult_GetURL(tt *testing.T) {
  9390  	var zeroValue string
  9391  	l := &LabelResult{URL: &zeroValue}
  9392  	l.GetURL()
  9393  	l = &LabelResult{}
  9394  	l.GetURL()
  9395  	l = nil
  9396  	l.GetURL()
  9397  }
  9398  
  9399  func TestLabelsSearchResult_GetIncompleteResults(tt *testing.T) {
  9400  	var zeroValue bool
  9401  	l := &LabelsSearchResult{IncompleteResults: &zeroValue}
  9402  	l.GetIncompleteResults()
  9403  	l = &LabelsSearchResult{}
  9404  	l.GetIncompleteResults()
  9405  	l = nil
  9406  	l.GetIncompleteResults()
  9407  }
  9408  
  9409  func TestLabelsSearchResult_GetTotal(tt *testing.T) {
  9410  	var zeroValue int
  9411  	l := &LabelsSearchResult{Total: &zeroValue}
  9412  	l.GetTotal()
  9413  	l = &LabelsSearchResult{}
  9414  	l.GetTotal()
  9415  	l = nil
  9416  	l.GetTotal()
  9417  }
  9418  
  9419  func TestLargeFile_GetOID(tt *testing.T) {
  9420  	var zeroValue string
  9421  	l := &LargeFile{OID: &zeroValue}
  9422  	l.GetOID()
  9423  	l = &LargeFile{}
  9424  	l.GetOID()
  9425  	l = nil
  9426  	l.GetOID()
  9427  }
  9428  
  9429  func TestLargeFile_GetPath(tt *testing.T) {
  9430  	var zeroValue string
  9431  	l := &LargeFile{Path: &zeroValue}
  9432  	l.GetPath()
  9433  	l = &LargeFile{}
  9434  	l.GetPath()
  9435  	l = nil
  9436  	l.GetPath()
  9437  }
  9438  
  9439  func TestLargeFile_GetRefName(tt *testing.T) {
  9440  	var zeroValue string
  9441  	l := &LargeFile{RefName: &zeroValue}
  9442  	l.GetRefName()
  9443  	l = &LargeFile{}
  9444  	l.GetRefName()
  9445  	l = nil
  9446  	l.GetRefName()
  9447  }
  9448  
  9449  func TestLargeFile_GetSize(tt *testing.T) {
  9450  	var zeroValue int
  9451  	l := &LargeFile{Size: &zeroValue}
  9452  	l.GetSize()
  9453  	l = &LargeFile{}
  9454  	l.GetSize()
  9455  	l = nil
  9456  	l.GetSize()
  9457  }
  9458  
  9459  func TestLicense_GetBody(tt *testing.T) {
  9460  	var zeroValue string
  9461  	l := &License{Body: &zeroValue}
  9462  	l.GetBody()
  9463  	l = &License{}
  9464  	l.GetBody()
  9465  	l = nil
  9466  	l.GetBody()
  9467  }
  9468  
  9469  func TestLicense_GetConditions(tt *testing.T) {
  9470  	var zeroValue []string
  9471  	l := &License{Conditions: &zeroValue}
  9472  	l.GetConditions()
  9473  	l = &License{}
  9474  	l.GetConditions()
  9475  	l = nil
  9476  	l.GetConditions()
  9477  }
  9478  
  9479  func TestLicense_GetDescription(tt *testing.T) {
  9480  	var zeroValue string
  9481  	l := &License{Description: &zeroValue}
  9482  	l.GetDescription()
  9483  	l = &License{}
  9484  	l.GetDescription()
  9485  	l = nil
  9486  	l.GetDescription()
  9487  }
  9488  
  9489  func TestLicense_GetFeatured(tt *testing.T) {
  9490  	var zeroValue bool
  9491  	l := &License{Featured: &zeroValue}
  9492  	l.GetFeatured()
  9493  	l = &License{}
  9494  	l.GetFeatured()
  9495  	l = nil
  9496  	l.GetFeatured()
  9497  }
  9498  
  9499  func TestLicense_GetHTMLURL(tt *testing.T) {
  9500  	var zeroValue string
  9501  	l := &License{HTMLURL: &zeroValue}
  9502  	l.GetHTMLURL()
  9503  	l = &License{}
  9504  	l.GetHTMLURL()
  9505  	l = nil
  9506  	l.GetHTMLURL()
  9507  }
  9508  
  9509  func TestLicense_GetImplementation(tt *testing.T) {
  9510  	var zeroValue string
  9511  	l := &License{Implementation: &zeroValue}
  9512  	l.GetImplementation()
  9513  	l = &License{}
  9514  	l.GetImplementation()
  9515  	l = nil
  9516  	l.GetImplementation()
  9517  }
  9518  
  9519  func TestLicense_GetKey(tt *testing.T) {
  9520  	var zeroValue string
  9521  	l := &License{Key: &zeroValue}
  9522  	l.GetKey()
  9523  	l = &License{}
  9524  	l.GetKey()
  9525  	l = nil
  9526  	l.GetKey()
  9527  }
  9528  
  9529  func TestLicense_GetLimitations(tt *testing.T) {
  9530  	var zeroValue []string
  9531  	l := &License{Limitations: &zeroValue}
  9532  	l.GetLimitations()
  9533  	l = &License{}
  9534  	l.GetLimitations()
  9535  	l = nil
  9536  	l.GetLimitations()
  9537  }
  9538  
  9539  func TestLicense_GetName(tt *testing.T) {
  9540  	var zeroValue string
  9541  	l := &License{Name: &zeroValue}
  9542  	l.GetName()
  9543  	l = &License{}
  9544  	l.GetName()
  9545  	l = nil
  9546  	l.GetName()
  9547  }
  9548  
  9549  func TestLicense_GetPermissions(tt *testing.T) {
  9550  	var zeroValue []string
  9551  	l := &License{Permissions: &zeroValue}
  9552  	l.GetPermissions()
  9553  	l = &License{}
  9554  	l.GetPermissions()
  9555  	l = nil
  9556  	l.GetPermissions()
  9557  }
  9558  
  9559  func TestLicense_GetSPDXID(tt *testing.T) {
  9560  	var zeroValue string
  9561  	l := &License{SPDXID: &zeroValue}
  9562  	l.GetSPDXID()
  9563  	l = &License{}
  9564  	l.GetSPDXID()
  9565  	l = nil
  9566  	l.GetSPDXID()
  9567  }
  9568  
  9569  func TestLicense_GetURL(tt *testing.T) {
  9570  	var zeroValue string
  9571  	l := &License{URL: &zeroValue}
  9572  	l.GetURL()
  9573  	l = &License{}
  9574  	l.GetURL()
  9575  	l = nil
  9576  	l.GetURL()
  9577  }
  9578  
  9579  func TestListCheckRunsOptions_GetAppID(tt *testing.T) {
  9580  	var zeroValue int64
  9581  	l := &ListCheckRunsOptions{AppID: &zeroValue}
  9582  	l.GetAppID()
  9583  	l = &ListCheckRunsOptions{}
  9584  	l.GetAppID()
  9585  	l = nil
  9586  	l.GetAppID()
  9587  }
  9588  
  9589  func TestListCheckRunsOptions_GetCheckName(tt *testing.T) {
  9590  	var zeroValue string
  9591  	l := &ListCheckRunsOptions{CheckName: &zeroValue}
  9592  	l.GetCheckName()
  9593  	l = &ListCheckRunsOptions{}
  9594  	l.GetCheckName()
  9595  	l = nil
  9596  	l.GetCheckName()
  9597  }
  9598  
  9599  func TestListCheckRunsOptions_GetFilter(tt *testing.T) {
  9600  	var zeroValue string
  9601  	l := &ListCheckRunsOptions{Filter: &zeroValue}
  9602  	l.GetFilter()
  9603  	l = &ListCheckRunsOptions{}
  9604  	l.GetFilter()
  9605  	l = nil
  9606  	l.GetFilter()
  9607  }
  9608  
  9609  func TestListCheckRunsOptions_GetStatus(tt *testing.T) {
  9610  	var zeroValue string
  9611  	l := &ListCheckRunsOptions{Status: &zeroValue}
  9612  	l.GetStatus()
  9613  	l = &ListCheckRunsOptions{}
  9614  	l.GetStatus()
  9615  	l = nil
  9616  	l.GetStatus()
  9617  }
  9618  
  9619  func TestListCheckRunsResults_GetTotal(tt *testing.T) {
  9620  	var zeroValue int
  9621  	l := &ListCheckRunsResults{Total: &zeroValue}
  9622  	l.GetTotal()
  9623  	l = &ListCheckRunsResults{}
  9624  	l.GetTotal()
  9625  	l = nil
  9626  	l.GetTotal()
  9627  }
  9628  
  9629  func TestListCheckSuiteOptions_GetAppID(tt *testing.T) {
  9630  	var zeroValue int
  9631  	l := &ListCheckSuiteOptions{AppID: &zeroValue}
  9632  	l.GetAppID()
  9633  	l = &ListCheckSuiteOptions{}
  9634  	l.GetAppID()
  9635  	l = nil
  9636  	l.GetAppID()
  9637  }
  9638  
  9639  func TestListCheckSuiteOptions_GetCheckName(tt *testing.T) {
  9640  	var zeroValue string
  9641  	l := &ListCheckSuiteOptions{CheckName: &zeroValue}
  9642  	l.GetCheckName()
  9643  	l = &ListCheckSuiteOptions{}
  9644  	l.GetCheckName()
  9645  	l = nil
  9646  	l.GetCheckName()
  9647  }
  9648  
  9649  func TestListCheckSuiteResults_GetTotal(tt *testing.T) {
  9650  	var zeroValue int
  9651  	l := &ListCheckSuiteResults{Total: &zeroValue}
  9652  	l.GetTotal()
  9653  	l = &ListCheckSuiteResults{}
  9654  	l.GetTotal()
  9655  	l = nil
  9656  	l.GetTotal()
  9657  }
  9658  
  9659  func TestListCollaboratorOptions_GetAffiliation(tt *testing.T) {
  9660  	var zeroValue string
  9661  	l := &ListCollaboratorOptions{Affiliation: &zeroValue}
  9662  	l.GetAffiliation()
  9663  	l = &ListCollaboratorOptions{}
  9664  	l.GetAffiliation()
  9665  	l = nil
  9666  	l.GetAffiliation()
  9667  }
  9668  
  9669  func TestListExternalGroupsOptions_GetDisplayName(tt *testing.T) {
  9670  	var zeroValue string
  9671  	l := &ListExternalGroupsOptions{DisplayName: &zeroValue}
  9672  	l.GetDisplayName()
  9673  	l = &ListExternalGroupsOptions{}
  9674  	l.GetDisplayName()
  9675  	l = nil
  9676  	l.GetDisplayName()
  9677  }
  9678  
  9679  func TestListRepositories_GetTotalCount(tt *testing.T) {
  9680  	var zeroValue int
  9681  	l := &ListRepositories{TotalCount: &zeroValue}
  9682  	l.GetTotalCount()
  9683  	l = &ListRepositories{}
  9684  	l.GetTotalCount()
  9685  	l = nil
  9686  	l.GetTotalCount()
  9687  }
  9688  
  9689  func TestListSCIMProvisionedIdentitiesOptions_GetCount(tt *testing.T) {
  9690  	var zeroValue int
  9691  	l := &ListSCIMProvisionedIdentitiesOptions{Count: &zeroValue}
  9692  	l.GetCount()
  9693  	l = &ListSCIMProvisionedIdentitiesOptions{}
  9694  	l.GetCount()
  9695  	l = nil
  9696  	l.GetCount()
  9697  }
  9698  
  9699  func TestListSCIMProvisionedIdentitiesOptions_GetFilter(tt *testing.T) {
  9700  	var zeroValue string
  9701  	l := &ListSCIMProvisionedIdentitiesOptions{Filter: &zeroValue}
  9702  	l.GetFilter()
  9703  	l = &ListSCIMProvisionedIdentitiesOptions{}
  9704  	l.GetFilter()
  9705  	l = nil
  9706  	l.GetFilter()
  9707  }
  9708  
  9709  func TestListSCIMProvisionedIdentitiesOptions_GetStartIndex(tt *testing.T) {
  9710  	var zeroValue int
  9711  	l := &ListSCIMProvisionedIdentitiesOptions{StartIndex: &zeroValue}
  9712  	l.GetStartIndex()
  9713  	l = &ListSCIMProvisionedIdentitiesOptions{}
  9714  	l.GetStartIndex()
  9715  	l = nil
  9716  	l.GetStartIndex()
  9717  }
  9718  
  9719  func TestLocation_GetEndColumn(tt *testing.T) {
  9720  	var zeroValue int
  9721  	l := &Location{EndColumn: &zeroValue}
  9722  	l.GetEndColumn()
  9723  	l = &Location{}
  9724  	l.GetEndColumn()
  9725  	l = nil
  9726  	l.GetEndColumn()
  9727  }
  9728  
  9729  func TestLocation_GetEndLine(tt *testing.T) {
  9730  	var zeroValue int
  9731  	l := &Location{EndLine: &zeroValue}
  9732  	l.GetEndLine()
  9733  	l = &Location{}
  9734  	l.GetEndLine()
  9735  	l = nil
  9736  	l.GetEndLine()
  9737  }
  9738  
  9739  func TestLocation_GetPath(tt *testing.T) {
  9740  	var zeroValue string
  9741  	l := &Location{Path: &zeroValue}
  9742  	l.GetPath()
  9743  	l = &Location{}
  9744  	l.GetPath()
  9745  	l = nil
  9746  	l.GetPath()
  9747  }
  9748  
  9749  func TestLocation_GetStartColumn(tt *testing.T) {
  9750  	var zeroValue int
  9751  	l := &Location{StartColumn: &zeroValue}
  9752  	l.GetStartColumn()
  9753  	l = &Location{}
  9754  	l.GetStartColumn()
  9755  	l = nil
  9756  	l.GetStartColumn()
  9757  }
  9758  
  9759  func TestLocation_GetStartLine(tt *testing.T) {
  9760  	var zeroValue int
  9761  	l := &Location{StartLine: &zeroValue}
  9762  	l.GetStartLine()
  9763  	l = &Location{}
  9764  	l.GetStartLine()
  9765  	l = nil
  9766  	l.GetStartLine()
  9767  }
  9768  
  9769  func TestMarketplacePendingChange_GetEffectiveDate(tt *testing.T) {
  9770  	var zeroValue Timestamp
  9771  	m := &MarketplacePendingChange{EffectiveDate: &zeroValue}
  9772  	m.GetEffectiveDate()
  9773  	m = &MarketplacePendingChange{}
  9774  	m.GetEffectiveDate()
  9775  	m = nil
  9776  	m.GetEffectiveDate()
  9777  }
  9778  
  9779  func TestMarketplacePendingChange_GetID(tt *testing.T) {
  9780  	var zeroValue int64
  9781  	m := &MarketplacePendingChange{ID: &zeroValue}
  9782  	m.GetID()
  9783  	m = &MarketplacePendingChange{}
  9784  	m.GetID()
  9785  	m = nil
  9786  	m.GetID()
  9787  }
  9788  
  9789  func TestMarketplacePendingChange_GetPlan(tt *testing.T) {
  9790  	m := &MarketplacePendingChange{}
  9791  	m.GetPlan()
  9792  	m = nil
  9793  	m.GetPlan()
  9794  }
  9795  
  9796  func TestMarketplacePendingChange_GetUnitCount(tt *testing.T) {
  9797  	var zeroValue int
  9798  	m := &MarketplacePendingChange{UnitCount: &zeroValue}
  9799  	m.GetUnitCount()
  9800  	m = &MarketplacePendingChange{}
  9801  	m.GetUnitCount()
  9802  	m = nil
  9803  	m.GetUnitCount()
  9804  }
  9805  
  9806  func TestMarketplacePlan_GetAccountsURL(tt *testing.T) {
  9807  	var zeroValue string
  9808  	m := &MarketplacePlan{AccountsURL: &zeroValue}
  9809  	m.GetAccountsURL()
  9810  	m = &MarketplacePlan{}
  9811  	m.GetAccountsURL()
  9812  	m = nil
  9813  	m.GetAccountsURL()
  9814  }
  9815  
  9816  func TestMarketplacePlan_GetBullets(tt *testing.T) {
  9817  	var zeroValue []string
  9818  	m := &MarketplacePlan{Bullets: &zeroValue}
  9819  	m.GetBullets()
  9820  	m = &MarketplacePlan{}
  9821  	m.GetBullets()
  9822  	m = nil
  9823  	m.GetBullets()
  9824  }
  9825  
  9826  func TestMarketplacePlan_GetDescription(tt *testing.T) {
  9827  	var zeroValue string
  9828  	m := &MarketplacePlan{Description: &zeroValue}
  9829  	m.GetDescription()
  9830  	m = &MarketplacePlan{}
  9831  	m.GetDescription()
  9832  	m = nil
  9833  	m.GetDescription()
  9834  }
  9835  
  9836  func TestMarketplacePlan_GetHasFreeTrial(tt *testing.T) {
  9837  	var zeroValue bool
  9838  	m := &MarketplacePlan{HasFreeTrial: &zeroValue}
  9839  	m.GetHasFreeTrial()
  9840  	m = &MarketplacePlan{}
  9841  	m.GetHasFreeTrial()
  9842  	m = nil
  9843  	m.GetHasFreeTrial()
  9844  }
  9845  
  9846  func TestMarketplacePlan_GetID(tt *testing.T) {
  9847  	var zeroValue int64
  9848  	m := &MarketplacePlan{ID: &zeroValue}
  9849  	m.GetID()
  9850  	m = &MarketplacePlan{}
  9851  	m.GetID()
  9852  	m = nil
  9853  	m.GetID()
  9854  }
  9855  
  9856  func TestMarketplacePlan_GetMonthlyPriceInCents(tt *testing.T) {
  9857  	var zeroValue int
  9858  	m := &MarketplacePlan{MonthlyPriceInCents: &zeroValue}
  9859  	m.GetMonthlyPriceInCents()
  9860  	m = &MarketplacePlan{}
  9861  	m.GetMonthlyPriceInCents()
  9862  	m = nil
  9863  	m.GetMonthlyPriceInCents()
  9864  }
  9865  
  9866  func TestMarketplacePlan_GetName(tt *testing.T) {
  9867  	var zeroValue string
  9868  	m := &MarketplacePlan{Name: &zeroValue}
  9869  	m.GetName()
  9870  	m = &MarketplacePlan{}
  9871  	m.GetName()
  9872  	m = nil
  9873  	m.GetName()
  9874  }
  9875  
  9876  func TestMarketplacePlan_GetNumber(tt *testing.T) {
  9877  	var zeroValue int
  9878  	m := &MarketplacePlan{Number: &zeroValue}
  9879  	m.GetNumber()
  9880  	m = &MarketplacePlan{}
  9881  	m.GetNumber()
  9882  	m = nil
  9883  	m.GetNumber()
  9884  }
  9885  
  9886  func TestMarketplacePlan_GetPriceModel(tt *testing.T) {
  9887  	var zeroValue string
  9888  	m := &MarketplacePlan{PriceModel: &zeroValue}
  9889  	m.GetPriceModel()
  9890  	m = &MarketplacePlan{}
  9891  	m.GetPriceModel()
  9892  	m = nil
  9893  	m.GetPriceModel()
  9894  }
  9895  
  9896  func TestMarketplacePlan_GetState(tt *testing.T) {
  9897  	var zeroValue string
  9898  	m := &MarketplacePlan{State: &zeroValue}
  9899  	m.GetState()
  9900  	m = &MarketplacePlan{}
  9901  	m.GetState()
  9902  	m = nil
  9903  	m.GetState()
  9904  }
  9905  
  9906  func TestMarketplacePlan_GetUnitName(tt *testing.T) {
  9907  	var zeroValue string
  9908  	m := &MarketplacePlan{UnitName: &zeroValue}
  9909  	m.GetUnitName()
  9910  	m = &MarketplacePlan{}
  9911  	m.GetUnitName()
  9912  	m = nil
  9913  	m.GetUnitName()
  9914  }
  9915  
  9916  func TestMarketplacePlan_GetURL(tt *testing.T) {
  9917  	var zeroValue string
  9918  	m := &MarketplacePlan{URL: &zeroValue}
  9919  	m.GetURL()
  9920  	m = &MarketplacePlan{}
  9921  	m.GetURL()
  9922  	m = nil
  9923  	m.GetURL()
  9924  }
  9925  
  9926  func TestMarketplacePlan_GetYearlyPriceInCents(tt *testing.T) {
  9927  	var zeroValue int
  9928  	m := &MarketplacePlan{YearlyPriceInCents: &zeroValue}
  9929  	m.GetYearlyPriceInCents()
  9930  	m = &MarketplacePlan{}
  9931  	m.GetYearlyPriceInCents()
  9932  	m = nil
  9933  	m.GetYearlyPriceInCents()
  9934  }
  9935  
  9936  func TestMarketplacePlanAccount_GetID(tt *testing.T) {
  9937  	var zeroValue int64
  9938  	m := &MarketplacePlanAccount{ID: &zeroValue}
  9939  	m.GetID()
  9940  	m = &MarketplacePlanAccount{}
  9941  	m.GetID()
  9942  	m = nil
  9943  	m.GetID()
  9944  }
  9945  
  9946  func TestMarketplacePlanAccount_GetLogin(tt *testing.T) {
  9947  	var zeroValue string
  9948  	m := &MarketplacePlanAccount{Login: &zeroValue}
  9949  	m.GetLogin()
  9950  	m = &MarketplacePlanAccount{}
  9951  	m.GetLogin()
  9952  	m = nil
  9953  	m.GetLogin()
  9954  }
  9955  
  9956  func TestMarketplacePlanAccount_GetMarketplacePendingChange(tt *testing.T) {
  9957  	m := &MarketplacePlanAccount{}
  9958  	m.GetMarketplacePendingChange()
  9959  	m = nil
  9960  	m.GetMarketplacePendingChange()
  9961  }
  9962  
  9963  func TestMarketplacePlanAccount_GetMarketplacePurchase(tt *testing.T) {
  9964  	m := &MarketplacePlanAccount{}
  9965  	m.GetMarketplacePurchase()
  9966  	m = nil
  9967  	m.GetMarketplacePurchase()
  9968  }
  9969  
  9970  func TestMarketplacePlanAccount_GetOrganizationBillingEmail(tt *testing.T) {
  9971  	var zeroValue string
  9972  	m := &MarketplacePlanAccount{OrganizationBillingEmail: &zeroValue}
  9973  	m.GetOrganizationBillingEmail()
  9974  	m = &MarketplacePlanAccount{}
  9975  	m.GetOrganizationBillingEmail()
  9976  	m = nil
  9977  	m.GetOrganizationBillingEmail()
  9978  }
  9979  
  9980  func TestMarketplacePlanAccount_GetType(tt *testing.T) {
  9981  	var zeroValue string
  9982  	m := &MarketplacePlanAccount{Type: &zeroValue}
  9983  	m.GetType()
  9984  	m = &MarketplacePlanAccount{}
  9985  	m.GetType()
  9986  	m = nil
  9987  	m.GetType()
  9988  }
  9989  
  9990  func TestMarketplacePlanAccount_GetURL(tt *testing.T) {
  9991  	var zeroValue string
  9992  	m := &MarketplacePlanAccount{URL: &zeroValue}
  9993  	m.GetURL()
  9994  	m = &MarketplacePlanAccount{}
  9995  	m.GetURL()
  9996  	m = nil
  9997  	m.GetURL()
  9998  }
  9999  
 10000  func TestMarketplacePurchase_GetBillingCycle(tt *testing.T) {
 10001  	var zeroValue string
 10002  	m := &MarketplacePurchase{BillingCycle: &zeroValue}
 10003  	m.GetBillingCycle()
 10004  	m = &MarketplacePurchase{}
 10005  	m.GetBillingCycle()
 10006  	m = nil
 10007  	m.GetBillingCycle()
 10008  }
 10009  
 10010  func TestMarketplacePurchase_GetFreeTrialEndsOn(tt *testing.T) {
 10011  	var zeroValue Timestamp
 10012  	m := &MarketplacePurchase{FreeTrialEndsOn: &zeroValue}
 10013  	m.GetFreeTrialEndsOn()
 10014  	m = &MarketplacePurchase{}
 10015  	m.GetFreeTrialEndsOn()
 10016  	m = nil
 10017  	m.GetFreeTrialEndsOn()
 10018  }
 10019  
 10020  func TestMarketplacePurchase_GetNextBillingDate(tt *testing.T) {
 10021  	var zeroValue Timestamp
 10022  	m := &MarketplacePurchase{NextBillingDate: &zeroValue}
 10023  	m.GetNextBillingDate()
 10024  	m = &MarketplacePurchase{}
 10025  	m.GetNextBillingDate()
 10026  	m = nil
 10027  	m.GetNextBillingDate()
 10028  }
 10029  
 10030  func TestMarketplacePurchase_GetOnFreeTrial(tt *testing.T) {
 10031  	var zeroValue bool
 10032  	m := &MarketplacePurchase{OnFreeTrial: &zeroValue}
 10033  	m.GetOnFreeTrial()
 10034  	m = &MarketplacePurchase{}
 10035  	m.GetOnFreeTrial()
 10036  	m = nil
 10037  	m.GetOnFreeTrial()
 10038  }
 10039  
 10040  func TestMarketplacePurchase_GetPlan(tt *testing.T) {
 10041  	m := &MarketplacePurchase{}
 10042  	m.GetPlan()
 10043  	m = nil
 10044  	m.GetPlan()
 10045  }
 10046  
 10047  func TestMarketplacePurchase_GetUnitCount(tt *testing.T) {
 10048  	var zeroValue int
 10049  	m := &MarketplacePurchase{UnitCount: &zeroValue}
 10050  	m.GetUnitCount()
 10051  	m = &MarketplacePurchase{}
 10052  	m.GetUnitCount()
 10053  	m = nil
 10054  	m.GetUnitCount()
 10055  }
 10056  
 10057  func TestMarketplacePurchase_GetUpdatedAt(tt *testing.T) {
 10058  	var zeroValue Timestamp
 10059  	m := &MarketplacePurchase{UpdatedAt: &zeroValue}
 10060  	m.GetUpdatedAt()
 10061  	m = &MarketplacePurchase{}
 10062  	m.GetUpdatedAt()
 10063  	m = nil
 10064  	m.GetUpdatedAt()
 10065  }
 10066  
 10067  func TestMarketplacePurchaseEvent_GetAction(tt *testing.T) {
 10068  	var zeroValue string
 10069  	m := &MarketplacePurchaseEvent{Action: &zeroValue}
 10070  	m.GetAction()
 10071  	m = &MarketplacePurchaseEvent{}
 10072  	m.GetAction()
 10073  	m = nil
 10074  	m.GetAction()
 10075  }
 10076  
 10077  func TestMarketplacePurchaseEvent_GetEffectiveDate(tt *testing.T) {
 10078  	var zeroValue Timestamp
 10079  	m := &MarketplacePurchaseEvent{EffectiveDate: &zeroValue}
 10080  	m.GetEffectiveDate()
 10081  	m = &MarketplacePurchaseEvent{}
 10082  	m.GetEffectiveDate()
 10083  	m = nil
 10084  	m.GetEffectiveDate()
 10085  }
 10086  
 10087  func TestMarketplacePurchaseEvent_GetInstallation(tt *testing.T) {
 10088  	m := &MarketplacePurchaseEvent{}
 10089  	m.GetInstallation()
 10090  	m = nil
 10091  	m.GetInstallation()
 10092  }
 10093  
 10094  func TestMarketplacePurchaseEvent_GetMarketplacePurchase(tt *testing.T) {
 10095  	m := &MarketplacePurchaseEvent{}
 10096  	m.GetMarketplacePurchase()
 10097  	m = nil
 10098  	m.GetMarketplacePurchase()
 10099  }
 10100  
 10101  func TestMarketplacePurchaseEvent_GetPreviousMarketplacePurchase(tt *testing.T) {
 10102  	m := &MarketplacePurchaseEvent{}
 10103  	m.GetPreviousMarketplacePurchase()
 10104  	m = nil
 10105  	m.GetPreviousMarketplacePurchase()
 10106  }
 10107  
 10108  func TestMarketplacePurchaseEvent_GetSender(tt *testing.T) {
 10109  	m := &MarketplacePurchaseEvent{}
 10110  	m.GetSender()
 10111  	m = nil
 10112  	m.GetSender()
 10113  }
 10114  
 10115  func TestMatch_GetText(tt *testing.T) {
 10116  	var zeroValue string
 10117  	m := &Match{Text: &zeroValue}
 10118  	m.GetText()
 10119  	m = &Match{}
 10120  	m.GetText()
 10121  	m = nil
 10122  	m.GetText()
 10123  }
 10124  
 10125  func TestMemberEvent_GetAction(tt *testing.T) {
 10126  	var zeroValue string
 10127  	m := &MemberEvent{Action: &zeroValue}
 10128  	m.GetAction()
 10129  	m = &MemberEvent{}
 10130  	m.GetAction()
 10131  	m = nil
 10132  	m.GetAction()
 10133  }
 10134  
 10135  func TestMemberEvent_GetInstallation(tt *testing.T) {
 10136  	m := &MemberEvent{}
 10137  	m.GetInstallation()
 10138  	m = nil
 10139  	m.GetInstallation()
 10140  }
 10141  
 10142  func TestMemberEvent_GetMember(tt *testing.T) {
 10143  	m := &MemberEvent{}
 10144  	m.GetMember()
 10145  	m = nil
 10146  	m.GetMember()
 10147  }
 10148  
 10149  func TestMemberEvent_GetRepo(tt *testing.T) {
 10150  	m := &MemberEvent{}
 10151  	m.GetRepo()
 10152  	m = nil
 10153  	m.GetRepo()
 10154  }
 10155  
 10156  func TestMemberEvent_GetSender(tt *testing.T) {
 10157  	m := &MemberEvent{}
 10158  	m.GetSender()
 10159  	m = nil
 10160  	m.GetSender()
 10161  }
 10162  
 10163  func TestMembership_GetOrganization(tt *testing.T) {
 10164  	m := &Membership{}
 10165  	m.GetOrganization()
 10166  	m = nil
 10167  	m.GetOrganization()
 10168  }
 10169  
 10170  func TestMembership_GetOrganizationURL(tt *testing.T) {
 10171  	var zeroValue string
 10172  	m := &Membership{OrganizationURL: &zeroValue}
 10173  	m.GetOrganizationURL()
 10174  	m = &Membership{}
 10175  	m.GetOrganizationURL()
 10176  	m = nil
 10177  	m.GetOrganizationURL()
 10178  }
 10179  
 10180  func TestMembership_GetRole(tt *testing.T) {
 10181  	var zeroValue string
 10182  	m := &Membership{Role: &zeroValue}
 10183  	m.GetRole()
 10184  	m = &Membership{}
 10185  	m.GetRole()
 10186  	m = nil
 10187  	m.GetRole()
 10188  }
 10189  
 10190  func TestMembership_GetState(tt *testing.T) {
 10191  	var zeroValue string
 10192  	m := &Membership{State: &zeroValue}
 10193  	m.GetState()
 10194  	m = &Membership{}
 10195  	m.GetState()
 10196  	m = nil
 10197  	m.GetState()
 10198  }
 10199  
 10200  func TestMembership_GetURL(tt *testing.T) {
 10201  	var zeroValue string
 10202  	m := &Membership{URL: &zeroValue}
 10203  	m.GetURL()
 10204  	m = &Membership{}
 10205  	m.GetURL()
 10206  	m = nil
 10207  	m.GetURL()
 10208  }
 10209  
 10210  func TestMembership_GetUser(tt *testing.T) {
 10211  	m := &Membership{}
 10212  	m.GetUser()
 10213  	m = nil
 10214  	m.GetUser()
 10215  }
 10216  
 10217  func TestMembershipEvent_GetAction(tt *testing.T) {
 10218  	var zeroValue string
 10219  	m := &MembershipEvent{Action: &zeroValue}
 10220  	m.GetAction()
 10221  	m = &MembershipEvent{}
 10222  	m.GetAction()
 10223  	m = nil
 10224  	m.GetAction()
 10225  }
 10226  
 10227  func TestMembershipEvent_GetInstallation(tt *testing.T) {
 10228  	m := &MembershipEvent{}
 10229  	m.GetInstallation()
 10230  	m = nil
 10231  	m.GetInstallation()
 10232  }
 10233  
 10234  func TestMembershipEvent_GetMember(tt *testing.T) {
 10235  	m := &MembershipEvent{}
 10236  	m.GetMember()
 10237  	m = nil
 10238  	m.GetMember()
 10239  }
 10240  
 10241  func TestMembershipEvent_GetOrg(tt *testing.T) {
 10242  	m := &MembershipEvent{}
 10243  	m.GetOrg()
 10244  	m = nil
 10245  	m.GetOrg()
 10246  }
 10247  
 10248  func TestMembershipEvent_GetScope(tt *testing.T) {
 10249  	var zeroValue string
 10250  	m := &MembershipEvent{Scope: &zeroValue}
 10251  	m.GetScope()
 10252  	m = &MembershipEvent{}
 10253  	m.GetScope()
 10254  	m = nil
 10255  	m.GetScope()
 10256  }
 10257  
 10258  func TestMembershipEvent_GetSender(tt *testing.T) {
 10259  	m := &MembershipEvent{}
 10260  	m.GetSender()
 10261  	m = nil
 10262  	m.GetSender()
 10263  }
 10264  
 10265  func TestMembershipEvent_GetTeam(tt *testing.T) {
 10266  	m := &MembershipEvent{}
 10267  	m.GetTeam()
 10268  	m = nil
 10269  	m.GetTeam()
 10270  }
 10271  
 10272  func TestMessage_GetText(tt *testing.T) {
 10273  	var zeroValue string
 10274  	m := &Message{Text: &zeroValue}
 10275  	m.GetText()
 10276  	m = &Message{}
 10277  	m.GetText()
 10278  	m = nil
 10279  	m.GetText()
 10280  }
 10281  
 10282  func TestMetaEvent_GetAction(tt *testing.T) {
 10283  	var zeroValue string
 10284  	m := &MetaEvent{Action: &zeroValue}
 10285  	m.GetAction()
 10286  	m = &MetaEvent{}
 10287  	m.GetAction()
 10288  	m = nil
 10289  	m.GetAction()
 10290  }
 10291  
 10292  func TestMetaEvent_GetHook(tt *testing.T) {
 10293  	m := &MetaEvent{}
 10294  	m.GetHook()
 10295  	m = nil
 10296  	m.GetHook()
 10297  }
 10298  
 10299  func TestMetaEvent_GetHookID(tt *testing.T) {
 10300  	var zeroValue int64
 10301  	m := &MetaEvent{HookID: &zeroValue}
 10302  	m.GetHookID()
 10303  	m = &MetaEvent{}
 10304  	m.GetHookID()
 10305  	m = nil
 10306  	m.GetHookID()
 10307  }
 10308  
 10309  func TestMetaEvent_GetInstallation(tt *testing.T) {
 10310  	m := &MetaEvent{}
 10311  	m.GetInstallation()
 10312  	m = nil
 10313  	m.GetInstallation()
 10314  }
 10315  
 10316  func TestMetaEvent_GetOrg(tt *testing.T) {
 10317  	m := &MetaEvent{}
 10318  	m.GetOrg()
 10319  	m = nil
 10320  	m.GetOrg()
 10321  }
 10322  
 10323  func TestMetaEvent_GetRepo(tt *testing.T) {
 10324  	m := &MetaEvent{}
 10325  	m.GetRepo()
 10326  	m = nil
 10327  	m.GetRepo()
 10328  }
 10329  
 10330  func TestMetaEvent_GetSender(tt *testing.T) {
 10331  	m := &MetaEvent{}
 10332  	m.GetSender()
 10333  	m = nil
 10334  	m.GetSender()
 10335  }
 10336  
 10337  func TestMetric_GetHTMLURL(tt *testing.T) {
 10338  	var zeroValue string
 10339  	m := &Metric{HTMLURL: &zeroValue}
 10340  	m.GetHTMLURL()
 10341  	m = &Metric{}
 10342  	m.GetHTMLURL()
 10343  	m = nil
 10344  	m.GetHTMLURL()
 10345  }
 10346  
 10347  func TestMetric_GetKey(tt *testing.T) {
 10348  	var zeroValue string
 10349  	m := &Metric{Key: &zeroValue}
 10350  	m.GetKey()
 10351  	m = &Metric{}
 10352  	m.GetKey()
 10353  	m = nil
 10354  	m.GetKey()
 10355  }
 10356  
 10357  func TestMetric_GetName(tt *testing.T) {
 10358  	var zeroValue string
 10359  	m := &Metric{Name: &zeroValue}
 10360  	m.GetName()
 10361  	m = &Metric{}
 10362  	m.GetName()
 10363  	m = nil
 10364  	m.GetName()
 10365  }
 10366  
 10367  func TestMetric_GetNodeID(tt *testing.T) {
 10368  	var zeroValue string
 10369  	m := &Metric{NodeID: &zeroValue}
 10370  	m.GetNodeID()
 10371  	m = &Metric{}
 10372  	m.GetNodeID()
 10373  	m = nil
 10374  	m.GetNodeID()
 10375  }
 10376  
 10377  func TestMetric_GetSPDXID(tt *testing.T) {
 10378  	var zeroValue string
 10379  	m := &Metric{SPDXID: &zeroValue}
 10380  	m.GetSPDXID()
 10381  	m = &Metric{}
 10382  	m.GetSPDXID()
 10383  	m = nil
 10384  	m.GetSPDXID()
 10385  }
 10386  
 10387  func TestMetric_GetURL(tt *testing.T) {
 10388  	var zeroValue string
 10389  	m := &Metric{URL: &zeroValue}
 10390  	m.GetURL()
 10391  	m = &Metric{}
 10392  	m.GetURL()
 10393  	m = nil
 10394  	m.GetURL()
 10395  }
 10396  
 10397  func TestMigration_GetCreatedAt(tt *testing.T) {
 10398  	var zeroValue string
 10399  	m := &Migration{CreatedAt: &zeroValue}
 10400  	m.GetCreatedAt()
 10401  	m = &Migration{}
 10402  	m.GetCreatedAt()
 10403  	m = nil
 10404  	m.GetCreatedAt()
 10405  }
 10406  
 10407  func TestMigration_GetExcludeAttachments(tt *testing.T) {
 10408  	var zeroValue bool
 10409  	m := &Migration{ExcludeAttachments: &zeroValue}
 10410  	m.GetExcludeAttachments()
 10411  	m = &Migration{}
 10412  	m.GetExcludeAttachments()
 10413  	m = nil
 10414  	m.GetExcludeAttachments()
 10415  }
 10416  
 10417  func TestMigration_GetGUID(tt *testing.T) {
 10418  	var zeroValue string
 10419  	m := &Migration{GUID: &zeroValue}
 10420  	m.GetGUID()
 10421  	m = &Migration{}
 10422  	m.GetGUID()
 10423  	m = nil
 10424  	m.GetGUID()
 10425  }
 10426  
 10427  func TestMigration_GetID(tt *testing.T) {
 10428  	var zeroValue int64
 10429  	m := &Migration{ID: &zeroValue}
 10430  	m.GetID()
 10431  	m = &Migration{}
 10432  	m.GetID()
 10433  	m = nil
 10434  	m.GetID()
 10435  }
 10436  
 10437  func TestMigration_GetLockRepositories(tt *testing.T) {
 10438  	var zeroValue bool
 10439  	m := &Migration{LockRepositories: &zeroValue}
 10440  	m.GetLockRepositories()
 10441  	m = &Migration{}
 10442  	m.GetLockRepositories()
 10443  	m = nil
 10444  	m.GetLockRepositories()
 10445  }
 10446  
 10447  func TestMigration_GetState(tt *testing.T) {
 10448  	var zeroValue string
 10449  	m := &Migration{State: &zeroValue}
 10450  	m.GetState()
 10451  	m = &Migration{}
 10452  	m.GetState()
 10453  	m = nil
 10454  	m.GetState()
 10455  }
 10456  
 10457  func TestMigration_GetUpdatedAt(tt *testing.T) {
 10458  	var zeroValue string
 10459  	m := &Migration{UpdatedAt: &zeroValue}
 10460  	m.GetUpdatedAt()
 10461  	m = &Migration{}
 10462  	m.GetUpdatedAt()
 10463  	m = nil
 10464  	m.GetUpdatedAt()
 10465  }
 10466  
 10467  func TestMigration_GetURL(tt *testing.T) {
 10468  	var zeroValue string
 10469  	m := &Migration{URL: &zeroValue}
 10470  	m.GetURL()
 10471  	m = &Migration{}
 10472  	m.GetURL()
 10473  	m = nil
 10474  	m.GetURL()
 10475  }
 10476  
 10477  func TestMilestone_GetClosedAt(tt *testing.T) {
 10478  	var zeroValue time.Time
 10479  	m := &Milestone{ClosedAt: &zeroValue}
 10480  	m.GetClosedAt()
 10481  	m = &Milestone{}
 10482  	m.GetClosedAt()
 10483  	m = nil
 10484  	m.GetClosedAt()
 10485  }
 10486  
 10487  func TestMilestone_GetClosedIssues(tt *testing.T) {
 10488  	var zeroValue int
 10489  	m := &Milestone{ClosedIssues: &zeroValue}
 10490  	m.GetClosedIssues()
 10491  	m = &Milestone{}
 10492  	m.GetClosedIssues()
 10493  	m = nil
 10494  	m.GetClosedIssues()
 10495  }
 10496  
 10497  func TestMilestone_GetCreatedAt(tt *testing.T) {
 10498  	var zeroValue time.Time
 10499  	m := &Milestone{CreatedAt: &zeroValue}
 10500  	m.GetCreatedAt()
 10501  	m = &Milestone{}
 10502  	m.GetCreatedAt()
 10503  	m = nil
 10504  	m.GetCreatedAt()
 10505  }
 10506  
 10507  func TestMilestone_GetCreator(tt *testing.T) {
 10508  	m := &Milestone{}
 10509  	m.GetCreator()
 10510  	m = nil
 10511  	m.GetCreator()
 10512  }
 10513  
 10514  func TestMilestone_GetDescription(tt *testing.T) {
 10515  	var zeroValue string
 10516  	m := &Milestone{Description: &zeroValue}
 10517  	m.GetDescription()
 10518  	m = &Milestone{}
 10519  	m.GetDescription()
 10520  	m = nil
 10521  	m.GetDescription()
 10522  }
 10523  
 10524  func TestMilestone_GetDueOn(tt *testing.T) {
 10525  	var zeroValue time.Time
 10526  	m := &Milestone{DueOn: &zeroValue}
 10527  	m.GetDueOn()
 10528  	m = &Milestone{}
 10529  	m.GetDueOn()
 10530  	m = nil
 10531  	m.GetDueOn()
 10532  }
 10533  
 10534  func TestMilestone_GetHTMLURL(tt *testing.T) {
 10535  	var zeroValue string
 10536  	m := &Milestone{HTMLURL: &zeroValue}
 10537  	m.GetHTMLURL()
 10538  	m = &Milestone{}
 10539  	m.GetHTMLURL()
 10540  	m = nil
 10541  	m.GetHTMLURL()
 10542  }
 10543  
 10544  func TestMilestone_GetID(tt *testing.T) {
 10545  	var zeroValue int64
 10546  	m := &Milestone{ID: &zeroValue}
 10547  	m.GetID()
 10548  	m = &Milestone{}
 10549  	m.GetID()
 10550  	m = nil
 10551  	m.GetID()
 10552  }
 10553  
 10554  func TestMilestone_GetLabelsURL(tt *testing.T) {
 10555  	var zeroValue string
 10556  	m := &Milestone{LabelsURL: &zeroValue}
 10557  	m.GetLabelsURL()
 10558  	m = &Milestone{}
 10559  	m.GetLabelsURL()
 10560  	m = nil
 10561  	m.GetLabelsURL()
 10562  }
 10563  
 10564  func TestMilestone_GetNodeID(tt *testing.T) {
 10565  	var zeroValue string
 10566  	m := &Milestone{NodeID: &zeroValue}
 10567  	m.GetNodeID()
 10568  	m = &Milestone{}
 10569  	m.GetNodeID()
 10570  	m = nil
 10571  	m.GetNodeID()
 10572  }
 10573  
 10574  func TestMilestone_GetNumber(tt *testing.T) {
 10575  	var zeroValue int
 10576  	m := &Milestone{Number: &zeroValue}
 10577  	m.GetNumber()
 10578  	m = &Milestone{}
 10579  	m.GetNumber()
 10580  	m = nil
 10581  	m.GetNumber()
 10582  }
 10583  
 10584  func TestMilestone_GetOpenIssues(tt *testing.T) {
 10585  	var zeroValue int
 10586  	m := &Milestone{OpenIssues: &zeroValue}
 10587  	m.GetOpenIssues()
 10588  	m = &Milestone{}
 10589  	m.GetOpenIssues()
 10590  	m = nil
 10591  	m.GetOpenIssues()
 10592  }
 10593  
 10594  func TestMilestone_GetState(tt *testing.T) {
 10595  	var zeroValue string
 10596  	m := &Milestone{State: &zeroValue}
 10597  	m.GetState()
 10598  	m = &Milestone{}
 10599  	m.GetState()
 10600  	m = nil
 10601  	m.GetState()
 10602  }
 10603  
 10604  func TestMilestone_GetTitle(tt *testing.T) {
 10605  	var zeroValue string
 10606  	m := &Milestone{Title: &zeroValue}
 10607  	m.GetTitle()
 10608  	m = &Milestone{}
 10609  	m.GetTitle()
 10610  	m = nil
 10611  	m.GetTitle()
 10612  }
 10613  
 10614  func TestMilestone_GetUpdatedAt(tt *testing.T) {
 10615  	var zeroValue time.Time
 10616  	m := &Milestone{UpdatedAt: &zeroValue}
 10617  	m.GetUpdatedAt()
 10618  	m = &Milestone{}
 10619  	m.GetUpdatedAt()
 10620  	m = nil
 10621  	m.GetUpdatedAt()
 10622  }
 10623  
 10624  func TestMilestone_GetURL(tt *testing.T) {
 10625  	var zeroValue string
 10626  	m := &Milestone{URL: &zeroValue}
 10627  	m.GetURL()
 10628  	m = &Milestone{}
 10629  	m.GetURL()
 10630  	m = nil
 10631  	m.GetURL()
 10632  }
 10633  
 10634  func TestMilestoneEvent_GetAction(tt *testing.T) {
 10635  	var zeroValue string
 10636  	m := &MilestoneEvent{Action: &zeroValue}
 10637  	m.GetAction()
 10638  	m = &MilestoneEvent{}
 10639  	m.GetAction()
 10640  	m = nil
 10641  	m.GetAction()
 10642  }
 10643  
 10644  func TestMilestoneEvent_GetChanges(tt *testing.T) {
 10645  	m := &MilestoneEvent{}
 10646  	m.GetChanges()
 10647  	m = nil
 10648  	m.GetChanges()
 10649  }
 10650  
 10651  func TestMilestoneEvent_GetInstallation(tt *testing.T) {
 10652  	m := &MilestoneEvent{}
 10653  	m.GetInstallation()
 10654  	m = nil
 10655  	m.GetInstallation()
 10656  }
 10657  
 10658  func TestMilestoneEvent_GetMilestone(tt *testing.T) {
 10659  	m := &MilestoneEvent{}
 10660  	m.GetMilestone()
 10661  	m = nil
 10662  	m.GetMilestone()
 10663  }
 10664  
 10665  func TestMilestoneEvent_GetOrg(tt *testing.T) {
 10666  	m := &MilestoneEvent{}
 10667  	m.GetOrg()
 10668  	m = nil
 10669  	m.GetOrg()
 10670  }
 10671  
 10672  func TestMilestoneEvent_GetRepo(tt *testing.T) {
 10673  	m := &MilestoneEvent{}
 10674  	m.GetRepo()
 10675  	m = nil
 10676  	m.GetRepo()
 10677  }
 10678  
 10679  func TestMilestoneEvent_GetSender(tt *testing.T) {
 10680  	m := &MilestoneEvent{}
 10681  	m.GetSender()
 10682  	m = nil
 10683  	m.GetSender()
 10684  }
 10685  
 10686  func TestMilestoneStats_GetClosedMilestones(tt *testing.T) {
 10687  	var zeroValue int
 10688  	m := &MilestoneStats{ClosedMilestones: &zeroValue}
 10689  	m.GetClosedMilestones()
 10690  	m = &MilestoneStats{}
 10691  	m.GetClosedMilestones()
 10692  	m = nil
 10693  	m.GetClosedMilestones()
 10694  }
 10695  
 10696  func TestMilestoneStats_GetOpenMilestones(tt *testing.T) {
 10697  	var zeroValue int
 10698  	m := &MilestoneStats{OpenMilestones: &zeroValue}
 10699  	m.GetOpenMilestones()
 10700  	m = &MilestoneStats{}
 10701  	m.GetOpenMilestones()
 10702  	m = nil
 10703  	m.GetOpenMilestones()
 10704  }
 10705  
 10706  func TestMilestoneStats_GetTotalMilestones(tt *testing.T) {
 10707  	var zeroValue int
 10708  	m := &MilestoneStats{TotalMilestones: &zeroValue}
 10709  	m.GetTotalMilestones()
 10710  	m = &MilestoneStats{}
 10711  	m.GetTotalMilestones()
 10712  	m = nil
 10713  	m.GetTotalMilestones()
 10714  }
 10715  
 10716  func TestMostRecentInstance_GetAnalysisKey(tt *testing.T) {
 10717  	var zeroValue string
 10718  	m := &MostRecentInstance{AnalysisKey: &zeroValue}
 10719  	m.GetAnalysisKey()
 10720  	m = &MostRecentInstance{}
 10721  	m.GetAnalysisKey()
 10722  	m = nil
 10723  	m.GetAnalysisKey()
 10724  }
 10725  
 10726  func TestMostRecentInstance_GetCommitSHA(tt *testing.T) {
 10727  	var zeroValue string
 10728  	m := &MostRecentInstance{CommitSHA: &zeroValue}
 10729  	m.GetCommitSHA()
 10730  	m = &MostRecentInstance{}
 10731  	m.GetCommitSHA()
 10732  	m = nil
 10733  	m.GetCommitSHA()
 10734  }
 10735  
 10736  func TestMostRecentInstance_GetEnvironment(tt *testing.T) {
 10737  	var zeroValue string
 10738  	m := &MostRecentInstance{Environment: &zeroValue}
 10739  	m.GetEnvironment()
 10740  	m = &MostRecentInstance{}
 10741  	m.GetEnvironment()
 10742  	m = nil
 10743  	m.GetEnvironment()
 10744  }
 10745  
 10746  func TestMostRecentInstance_GetLocation(tt *testing.T) {
 10747  	m := &MostRecentInstance{}
 10748  	m.GetLocation()
 10749  	m = nil
 10750  	m.GetLocation()
 10751  }
 10752  
 10753  func TestMostRecentInstance_GetMessage(tt *testing.T) {
 10754  	m := &MostRecentInstance{}
 10755  	m.GetMessage()
 10756  	m = nil
 10757  	m.GetMessage()
 10758  }
 10759  
 10760  func TestMostRecentInstance_GetRef(tt *testing.T) {
 10761  	var zeroValue string
 10762  	m := &MostRecentInstance{Ref: &zeroValue}
 10763  	m.GetRef()
 10764  	m = &MostRecentInstance{}
 10765  	m.GetRef()
 10766  	m = nil
 10767  	m.GetRef()
 10768  }
 10769  
 10770  func TestMostRecentInstance_GetState(tt *testing.T) {
 10771  	var zeroValue string
 10772  	m := &MostRecentInstance{State: &zeroValue}
 10773  	m.GetState()
 10774  	m = &MostRecentInstance{}
 10775  	m.GetState()
 10776  	m = nil
 10777  	m.GetState()
 10778  }
 10779  
 10780  func TestNewPullRequest_GetBase(tt *testing.T) {
 10781  	var zeroValue string
 10782  	n := &NewPullRequest{Base: &zeroValue}
 10783  	n.GetBase()
 10784  	n = &NewPullRequest{}
 10785  	n.GetBase()
 10786  	n = nil
 10787  	n.GetBase()
 10788  }
 10789  
 10790  func TestNewPullRequest_GetBody(tt *testing.T) {
 10791  	var zeroValue string
 10792  	n := &NewPullRequest{Body: &zeroValue}
 10793  	n.GetBody()
 10794  	n = &NewPullRequest{}
 10795  	n.GetBody()
 10796  	n = nil
 10797  	n.GetBody()
 10798  }
 10799  
 10800  func TestNewPullRequest_GetDraft(tt *testing.T) {
 10801  	var zeroValue bool
 10802  	n := &NewPullRequest{Draft: &zeroValue}
 10803  	n.GetDraft()
 10804  	n = &NewPullRequest{}
 10805  	n.GetDraft()
 10806  	n = nil
 10807  	n.GetDraft()
 10808  }
 10809  
 10810  func TestNewPullRequest_GetHead(tt *testing.T) {
 10811  	var zeroValue string
 10812  	n := &NewPullRequest{Head: &zeroValue}
 10813  	n.GetHead()
 10814  	n = &NewPullRequest{}
 10815  	n.GetHead()
 10816  	n = nil
 10817  	n.GetHead()
 10818  }
 10819  
 10820  func TestNewPullRequest_GetIssue(tt *testing.T) {
 10821  	var zeroValue int
 10822  	n := &NewPullRequest{Issue: &zeroValue}
 10823  	n.GetIssue()
 10824  	n = &NewPullRequest{}
 10825  	n.GetIssue()
 10826  	n = nil
 10827  	n.GetIssue()
 10828  }
 10829  
 10830  func TestNewPullRequest_GetMaintainerCanModify(tt *testing.T) {
 10831  	var zeroValue bool
 10832  	n := &NewPullRequest{MaintainerCanModify: &zeroValue}
 10833  	n.GetMaintainerCanModify()
 10834  	n = &NewPullRequest{}
 10835  	n.GetMaintainerCanModify()
 10836  	n = nil
 10837  	n.GetMaintainerCanModify()
 10838  }
 10839  
 10840  func TestNewPullRequest_GetTitle(tt *testing.T) {
 10841  	var zeroValue string
 10842  	n := &NewPullRequest{Title: &zeroValue}
 10843  	n.GetTitle()
 10844  	n = &NewPullRequest{}
 10845  	n.GetTitle()
 10846  	n = nil
 10847  	n.GetTitle()
 10848  }
 10849  
 10850  func TestNewTeam_GetDescription(tt *testing.T) {
 10851  	var zeroValue string
 10852  	n := &NewTeam{Description: &zeroValue}
 10853  	n.GetDescription()
 10854  	n = &NewTeam{}
 10855  	n.GetDescription()
 10856  	n = nil
 10857  	n.GetDescription()
 10858  }
 10859  
 10860  func TestNewTeam_GetLDAPDN(tt *testing.T) {
 10861  	var zeroValue string
 10862  	n := &NewTeam{LDAPDN: &zeroValue}
 10863  	n.GetLDAPDN()
 10864  	n = &NewTeam{}
 10865  	n.GetLDAPDN()
 10866  	n = nil
 10867  	n.GetLDAPDN()
 10868  }
 10869  
 10870  func TestNewTeam_GetParentTeamID(tt *testing.T) {
 10871  	var zeroValue int64
 10872  	n := &NewTeam{ParentTeamID: &zeroValue}
 10873  	n.GetParentTeamID()
 10874  	n = &NewTeam{}
 10875  	n.GetParentTeamID()
 10876  	n = nil
 10877  	n.GetParentTeamID()
 10878  }
 10879  
 10880  func TestNewTeam_GetPermission(tt *testing.T) {
 10881  	var zeroValue string
 10882  	n := &NewTeam{Permission: &zeroValue}
 10883  	n.GetPermission()
 10884  	n = &NewTeam{}
 10885  	n.GetPermission()
 10886  	n = nil
 10887  	n.GetPermission()
 10888  }
 10889  
 10890  func TestNewTeam_GetPrivacy(tt *testing.T) {
 10891  	var zeroValue string
 10892  	n := &NewTeam{Privacy: &zeroValue}
 10893  	n.GetPrivacy()
 10894  	n = &NewTeam{}
 10895  	n.GetPrivacy()
 10896  	n = nil
 10897  	n.GetPrivacy()
 10898  }
 10899  
 10900  func TestNotification_GetID(tt *testing.T) {
 10901  	var zeroValue string
 10902  	n := &Notification{ID: &zeroValue}
 10903  	n.GetID()
 10904  	n = &Notification{}
 10905  	n.GetID()
 10906  	n = nil
 10907  	n.GetID()
 10908  }
 10909  
 10910  func TestNotification_GetLastReadAt(tt *testing.T) {
 10911  	var zeroValue time.Time
 10912  	n := &Notification{LastReadAt: &zeroValue}
 10913  	n.GetLastReadAt()
 10914  	n = &Notification{}
 10915  	n.GetLastReadAt()
 10916  	n = nil
 10917  	n.GetLastReadAt()
 10918  }
 10919  
 10920  func TestNotification_GetReason(tt *testing.T) {
 10921  	var zeroValue string
 10922  	n := &Notification{Reason: &zeroValue}
 10923  	n.GetReason()
 10924  	n = &Notification{}
 10925  	n.GetReason()
 10926  	n = nil
 10927  	n.GetReason()
 10928  }
 10929  
 10930  func TestNotification_GetRepository(tt *testing.T) {
 10931  	n := &Notification{}
 10932  	n.GetRepository()
 10933  	n = nil
 10934  	n.GetRepository()
 10935  }
 10936  
 10937  func TestNotification_GetSubject(tt *testing.T) {
 10938  	n := &Notification{}
 10939  	n.GetSubject()
 10940  	n = nil
 10941  	n.GetSubject()
 10942  }
 10943  
 10944  func TestNotification_GetUnread(tt *testing.T) {
 10945  	var zeroValue bool
 10946  	n := &Notification{Unread: &zeroValue}
 10947  	n.GetUnread()
 10948  	n = &Notification{}
 10949  	n.GetUnread()
 10950  	n = nil
 10951  	n.GetUnread()
 10952  }
 10953  
 10954  func TestNotification_GetUpdatedAt(tt *testing.T) {
 10955  	var zeroValue time.Time
 10956  	n := &Notification{UpdatedAt: &zeroValue}
 10957  	n.GetUpdatedAt()
 10958  	n = &Notification{}
 10959  	n.GetUpdatedAt()
 10960  	n = nil
 10961  	n.GetUpdatedAt()
 10962  }
 10963  
 10964  func TestNotification_GetURL(tt *testing.T) {
 10965  	var zeroValue string
 10966  	n := &Notification{URL: &zeroValue}
 10967  	n.GetURL()
 10968  	n = &Notification{}
 10969  	n.GetURL()
 10970  	n = nil
 10971  	n.GetURL()
 10972  }
 10973  
 10974  func TestNotificationSubject_GetLatestCommentURL(tt *testing.T) {
 10975  	var zeroValue string
 10976  	n := &NotificationSubject{LatestCommentURL: &zeroValue}
 10977  	n.GetLatestCommentURL()
 10978  	n = &NotificationSubject{}
 10979  	n.GetLatestCommentURL()
 10980  	n = nil
 10981  	n.GetLatestCommentURL()
 10982  }
 10983  
 10984  func TestNotificationSubject_GetTitle(tt *testing.T) {
 10985  	var zeroValue string
 10986  	n := &NotificationSubject{Title: &zeroValue}
 10987  	n.GetTitle()
 10988  	n = &NotificationSubject{}
 10989  	n.GetTitle()
 10990  	n = nil
 10991  	n.GetTitle()
 10992  }
 10993  
 10994  func TestNotificationSubject_GetType(tt *testing.T) {
 10995  	var zeroValue string
 10996  	n := &NotificationSubject{Type: &zeroValue}
 10997  	n.GetType()
 10998  	n = &NotificationSubject{}
 10999  	n.GetType()
 11000  	n = nil
 11001  	n.GetType()
 11002  }
 11003  
 11004  func TestNotificationSubject_GetURL(tt *testing.T) {
 11005  	var zeroValue string
 11006  	n := &NotificationSubject{URL: &zeroValue}
 11007  	n.GetURL()
 11008  	n = &NotificationSubject{}
 11009  	n.GetURL()
 11010  	n = nil
 11011  	n.GetURL()
 11012  }
 11013  
 11014  func TestOAuthAPP_GetClientID(tt *testing.T) {
 11015  	var zeroValue string
 11016  	o := &OAuthAPP{ClientID: &zeroValue}
 11017  	o.GetClientID()
 11018  	o = &OAuthAPP{}
 11019  	o.GetClientID()
 11020  	o = nil
 11021  	o.GetClientID()
 11022  }
 11023  
 11024  func TestOAuthAPP_GetName(tt *testing.T) {
 11025  	var zeroValue string
 11026  	o := &OAuthAPP{Name: &zeroValue}
 11027  	o.GetName()
 11028  	o = &OAuthAPP{}
 11029  	o.GetName()
 11030  	o = nil
 11031  	o.GetName()
 11032  }
 11033  
 11034  func TestOAuthAPP_GetURL(tt *testing.T) {
 11035  	var zeroValue string
 11036  	o := &OAuthAPP{URL: &zeroValue}
 11037  	o.GetURL()
 11038  	o = &OAuthAPP{}
 11039  	o.GetURL()
 11040  	o = nil
 11041  	o.GetURL()
 11042  }
 11043  
 11044  func TestOrganization_GetAdvancedSecurityEnabledForNewRepos(tt *testing.T) {
 11045  	var zeroValue bool
 11046  	o := &Organization{AdvancedSecurityEnabledForNewRepos: &zeroValue}
 11047  	o.GetAdvancedSecurityEnabledForNewRepos()
 11048  	o = &Organization{}
 11049  	o.GetAdvancedSecurityEnabledForNewRepos()
 11050  	o = nil
 11051  	o.GetAdvancedSecurityEnabledForNewRepos()
 11052  }
 11053  
 11054  func TestOrganization_GetAvatarURL(tt *testing.T) {
 11055  	var zeroValue string
 11056  	o := &Organization{AvatarURL: &zeroValue}
 11057  	o.GetAvatarURL()
 11058  	o = &Organization{}
 11059  	o.GetAvatarURL()
 11060  	o = nil
 11061  	o.GetAvatarURL()
 11062  }
 11063  
 11064  func TestOrganization_GetBillingEmail(tt *testing.T) {
 11065  	var zeroValue string
 11066  	o := &Organization{BillingEmail: &zeroValue}
 11067  	o.GetBillingEmail()
 11068  	o = &Organization{}
 11069  	o.GetBillingEmail()
 11070  	o = nil
 11071  	o.GetBillingEmail()
 11072  }
 11073  
 11074  func TestOrganization_GetBlog(tt *testing.T) {
 11075  	var zeroValue string
 11076  	o := &Organization{Blog: &zeroValue}
 11077  	o.GetBlog()
 11078  	o = &Organization{}
 11079  	o.GetBlog()
 11080  	o = nil
 11081  	o.GetBlog()
 11082  }
 11083  
 11084  func TestOrganization_GetCollaborators(tt *testing.T) {
 11085  	var zeroValue int
 11086  	o := &Organization{Collaborators: &zeroValue}
 11087  	o.GetCollaborators()
 11088  	o = &Organization{}
 11089  	o.GetCollaborators()
 11090  	o = nil
 11091  	o.GetCollaborators()
 11092  }
 11093  
 11094  func TestOrganization_GetCompany(tt *testing.T) {
 11095  	var zeroValue string
 11096  	o := &Organization{Company: &zeroValue}
 11097  	o.GetCompany()
 11098  	o = &Organization{}
 11099  	o.GetCompany()
 11100  	o = nil
 11101  	o.GetCompany()
 11102  }
 11103  
 11104  func TestOrganization_GetCreatedAt(tt *testing.T) {
 11105  	var zeroValue time.Time
 11106  	o := &Organization{CreatedAt: &zeroValue}
 11107  	o.GetCreatedAt()
 11108  	o = &Organization{}
 11109  	o.GetCreatedAt()
 11110  	o = nil
 11111  	o.GetCreatedAt()
 11112  }
 11113  
 11114  func TestOrganization_GetDefaultRepoPermission(tt *testing.T) {
 11115  	var zeroValue string
 11116  	o := &Organization{DefaultRepoPermission: &zeroValue}
 11117  	o.GetDefaultRepoPermission()
 11118  	o = &Organization{}
 11119  	o.GetDefaultRepoPermission()
 11120  	o = nil
 11121  	o.GetDefaultRepoPermission()
 11122  }
 11123  
 11124  func TestOrganization_GetDefaultRepoSettings(tt *testing.T) {
 11125  	var zeroValue string
 11126  	o := &Organization{DefaultRepoSettings: &zeroValue}
 11127  	o.GetDefaultRepoSettings()
 11128  	o = &Organization{}
 11129  	o.GetDefaultRepoSettings()
 11130  	o = nil
 11131  	o.GetDefaultRepoSettings()
 11132  }
 11133  
 11134  func TestOrganization_GetDependabotAlertsEnabledForNewRepos(tt *testing.T) {
 11135  	var zeroValue bool
 11136  	o := &Organization{DependabotAlertsEnabledForNewRepos: &zeroValue}
 11137  	o.GetDependabotAlertsEnabledForNewRepos()
 11138  	o = &Organization{}
 11139  	o.GetDependabotAlertsEnabledForNewRepos()
 11140  	o = nil
 11141  	o.GetDependabotAlertsEnabledForNewRepos()
 11142  }
 11143  
 11144  func TestOrganization_GetDependabotSecurityUpdatesEnabledForNewRepos(tt *testing.T) {
 11145  	var zeroValue bool
 11146  	o := &Organization{DependabotSecurityUpdatesEnabledForNewRepos: &zeroValue}
 11147  	o.GetDependabotSecurityUpdatesEnabledForNewRepos()
 11148  	o = &Organization{}
 11149  	o.GetDependabotSecurityUpdatesEnabledForNewRepos()
 11150  	o = nil
 11151  	o.GetDependabotSecurityUpdatesEnabledForNewRepos()
 11152  }
 11153  
 11154  func TestOrganization_GetDependencyGraphEnabledForNewRepos(tt *testing.T) {
 11155  	var zeroValue bool
 11156  	o := &Organization{DependencyGraphEnabledForNewRepos: &zeroValue}
 11157  	o.GetDependencyGraphEnabledForNewRepos()
 11158  	o = &Organization{}
 11159  	o.GetDependencyGraphEnabledForNewRepos()
 11160  	o = nil
 11161  	o.GetDependencyGraphEnabledForNewRepos()
 11162  }
 11163  
 11164  func TestOrganization_GetDescription(tt *testing.T) {
 11165  	var zeroValue string
 11166  	o := &Organization{Description: &zeroValue}
 11167  	o.GetDescription()
 11168  	o = &Organization{}
 11169  	o.GetDescription()
 11170  	o = nil
 11171  	o.GetDescription()
 11172  }
 11173  
 11174  func TestOrganization_GetDiskUsage(tt *testing.T) {
 11175  	var zeroValue int
 11176  	o := &Organization{DiskUsage: &zeroValue}
 11177  	o.GetDiskUsage()
 11178  	o = &Organization{}
 11179  	o.GetDiskUsage()
 11180  	o = nil
 11181  	o.GetDiskUsage()
 11182  }
 11183  
 11184  func TestOrganization_GetEmail(tt *testing.T) {
 11185  	var zeroValue string
 11186  	o := &Organization{Email: &zeroValue}
 11187  	o.GetEmail()
 11188  	o = &Organization{}
 11189  	o.GetEmail()
 11190  	o = nil
 11191  	o.GetEmail()
 11192  }
 11193  
 11194  func TestOrganization_GetEventsURL(tt *testing.T) {
 11195  	var zeroValue string
 11196  	o := &Organization{EventsURL: &zeroValue}
 11197  	o.GetEventsURL()
 11198  	o = &Organization{}
 11199  	o.GetEventsURL()
 11200  	o = nil
 11201  	o.GetEventsURL()
 11202  }
 11203  
 11204  func TestOrganization_GetFollowers(tt *testing.T) {
 11205  	var zeroValue int
 11206  	o := &Organization{Followers: &zeroValue}
 11207  	o.GetFollowers()
 11208  	o = &Organization{}
 11209  	o.GetFollowers()
 11210  	o = nil
 11211  	o.GetFollowers()
 11212  }
 11213  
 11214  func TestOrganization_GetFollowing(tt *testing.T) {
 11215  	var zeroValue int
 11216  	o := &Organization{Following: &zeroValue}
 11217  	o.GetFollowing()
 11218  	o = &Organization{}
 11219  	o.GetFollowing()
 11220  	o = nil
 11221  	o.GetFollowing()
 11222  }
 11223  
 11224  func TestOrganization_GetHasOrganizationProjects(tt *testing.T) {
 11225  	var zeroValue bool
 11226  	o := &Organization{HasOrganizationProjects: &zeroValue}
 11227  	o.GetHasOrganizationProjects()
 11228  	o = &Organization{}
 11229  	o.GetHasOrganizationProjects()
 11230  	o = nil
 11231  	o.GetHasOrganizationProjects()
 11232  }
 11233  
 11234  func TestOrganization_GetHasRepositoryProjects(tt *testing.T) {
 11235  	var zeroValue bool
 11236  	o := &Organization{HasRepositoryProjects: &zeroValue}
 11237  	o.GetHasRepositoryProjects()
 11238  	o = &Organization{}
 11239  	o.GetHasRepositoryProjects()
 11240  	o = nil
 11241  	o.GetHasRepositoryProjects()
 11242  }
 11243  
 11244  func TestOrganization_GetHooksURL(tt *testing.T) {
 11245  	var zeroValue string
 11246  	o := &Organization{HooksURL: &zeroValue}
 11247  	o.GetHooksURL()
 11248  	o = &Organization{}
 11249  	o.GetHooksURL()
 11250  	o = nil
 11251  	o.GetHooksURL()
 11252  }
 11253  
 11254  func TestOrganization_GetHTMLURL(tt *testing.T) {
 11255  	var zeroValue string
 11256  	o := &Organization{HTMLURL: &zeroValue}
 11257  	o.GetHTMLURL()
 11258  	o = &Organization{}
 11259  	o.GetHTMLURL()
 11260  	o = nil
 11261  	o.GetHTMLURL()
 11262  }
 11263  
 11264  func TestOrganization_GetID(tt *testing.T) {
 11265  	var zeroValue int64
 11266  	o := &Organization{ID: &zeroValue}
 11267  	o.GetID()
 11268  	o = &Organization{}
 11269  	o.GetID()
 11270  	o = nil
 11271  	o.GetID()
 11272  }
 11273  
 11274  func TestOrganization_GetIssuesURL(tt *testing.T) {
 11275  	var zeroValue string
 11276  	o := &Organization{IssuesURL: &zeroValue}
 11277  	o.GetIssuesURL()
 11278  	o = &Organization{}
 11279  	o.GetIssuesURL()
 11280  	o = nil
 11281  	o.GetIssuesURL()
 11282  }
 11283  
 11284  func TestOrganization_GetIsVerified(tt *testing.T) {
 11285  	var zeroValue bool
 11286  	o := &Organization{IsVerified: &zeroValue}
 11287  	o.GetIsVerified()
 11288  	o = &Organization{}
 11289  	o.GetIsVerified()
 11290  	o = nil
 11291  	o.GetIsVerified()
 11292  }
 11293  
 11294  func TestOrganization_GetLocation(tt *testing.T) {
 11295  	var zeroValue string
 11296  	o := &Organization{Location: &zeroValue}
 11297  	o.GetLocation()
 11298  	o = &Organization{}
 11299  	o.GetLocation()
 11300  	o = nil
 11301  	o.GetLocation()
 11302  }
 11303  
 11304  func TestOrganization_GetLogin(tt *testing.T) {
 11305  	var zeroValue string
 11306  	o := &Organization{Login: &zeroValue}
 11307  	o.GetLogin()
 11308  	o = &Organization{}
 11309  	o.GetLogin()
 11310  	o = nil
 11311  	o.GetLogin()
 11312  }
 11313  
 11314  func TestOrganization_GetMembersAllowedRepositoryCreationType(tt *testing.T) {
 11315  	var zeroValue string
 11316  	o := &Organization{MembersAllowedRepositoryCreationType: &zeroValue}
 11317  	o.GetMembersAllowedRepositoryCreationType()
 11318  	o = &Organization{}
 11319  	o.GetMembersAllowedRepositoryCreationType()
 11320  	o = nil
 11321  	o.GetMembersAllowedRepositoryCreationType()
 11322  }
 11323  
 11324  func TestOrganization_GetMembersCanCreateInternalRepos(tt *testing.T) {
 11325  	var zeroValue bool
 11326  	o := &Organization{MembersCanCreateInternalRepos: &zeroValue}
 11327  	o.GetMembersCanCreateInternalRepos()
 11328  	o = &Organization{}
 11329  	o.GetMembersCanCreateInternalRepos()
 11330  	o = nil
 11331  	o.GetMembersCanCreateInternalRepos()
 11332  }
 11333  
 11334  func TestOrganization_GetMembersCanCreatePages(tt *testing.T) {
 11335  	var zeroValue bool
 11336  	o := &Organization{MembersCanCreatePages: &zeroValue}
 11337  	o.GetMembersCanCreatePages()
 11338  	o = &Organization{}
 11339  	o.GetMembersCanCreatePages()
 11340  	o = nil
 11341  	o.GetMembersCanCreatePages()
 11342  }
 11343  
 11344  func TestOrganization_GetMembersCanCreatePrivatePages(tt *testing.T) {
 11345  	var zeroValue bool
 11346  	o := &Organization{MembersCanCreatePrivatePages: &zeroValue}
 11347  	o.GetMembersCanCreatePrivatePages()
 11348  	o = &Organization{}
 11349  	o.GetMembersCanCreatePrivatePages()
 11350  	o = nil
 11351  	o.GetMembersCanCreatePrivatePages()
 11352  }
 11353  
 11354  func TestOrganization_GetMembersCanCreatePrivateRepos(tt *testing.T) {
 11355  	var zeroValue bool
 11356  	o := &Organization{MembersCanCreatePrivateRepos: &zeroValue}
 11357  	o.GetMembersCanCreatePrivateRepos()
 11358  	o = &Organization{}
 11359  	o.GetMembersCanCreatePrivateRepos()
 11360  	o = nil
 11361  	o.GetMembersCanCreatePrivateRepos()
 11362  }
 11363  
 11364  func TestOrganization_GetMembersCanCreatePublicPages(tt *testing.T) {
 11365  	var zeroValue bool
 11366  	o := &Organization{MembersCanCreatePublicPages: &zeroValue}
 11367  	o.GetMembersCanCreatePublicPages()
 11368  	o = &Organization{}
 11369  	o.GetMembersCanCreatePublicPages()
 11370  	o = nil
 11371  	o.GetMembersCanCreatePublicPages()
 11372  }
 11373  
 11374  func TestOrganization_GetMembersCanCreatePublicRepos(tt *testing.T) {
 11375  	var zeroValue bool
 11376  	o := &Organization{MembersCanCreatePublicRepos: &zeroValue}
 11377  	o.GetMembersCanCreatePublicRepos()
 11378  	o = &Organization{}
 11379  	o.GetMembersCanCreatePublicRepos()
 11380  	o = nil
 11381  	o.GetMembersCanCreatePublicRepos()
 11382  }
 11383  
 11384  func TestOrganization_GetMembersCanCreateRepos(tt *testing.T) {
 11385  	var zeroValue bool
 11386  	o := &Organization{MembersCanCreateRepos: &zeroValue}
 11387  	o.GetMembersCanCreateRepos()
 11388  	o = &Organization{}
 11389  	o.GetMembersCanCreateRepos()
 11390  	o = nil
 11391  	o.GetMembersCanCreateRepos()
 11392  }
 11393  
 11394  func TestOrganization_GetMembersCanForkPrivateRepos(tt *testing.T) {
 11395  	var zeroValue bool
 11396  	o := &Organization{MembersCanForkPrivateRepos: &zeroValue}
 11397  	o.GetMembersCanForkPrivateRepos()
 11398  	o = &Organization{}
 11399  	o.GetMembersCanForkPrivateRepos()
 11400  	o = nil
 11401  	o.GetMembersCanForkPrivateRepos()
 11402  }
 11403  
 11404  func TestOrganization_GetMembersURL(tt *testing.T) {
 11405  	var zeroValue string
 11406  	o := &Organization{MembersURL: &zeroValue}
 11407  	o.GetMembersURL()
 11408  	o = &Organization{}
 11409  	o.GetMembersURL()
 11410  	o = nil
 11411  	o.GetMembersURL()
 11412  }
 11413  
 11414  func TestOrganization_GetName(tt *testing.T) {
 11415  	var zeroValue string
 11416  	o := &Organization{Name: &zeroValue}
 11417  	o.GetName()
 11418  	o = &Organization{}
 11419  	o.GetName()
 11420  	o = nil
 11421  	o.GetName()
 11422  }
 11423  
 11424  func TestOrganization_GetNodeID(tt *testing.T) {
 11425  	var zeroValue string
 11426  	o := &Organization{NodeID: &zeroValue}
 11427  	o.GetNodeID()
 11428  	o = &Organization{}
 11429  	o.GetNodeID()
 11430  	o = nil
 11431  	o.GetNodeID()
 11432  }
 11433  
 11434  func TestOrganization_GetOwnedPrivateRepos(tt *testing.T) {
 11435  	var zeroValue int
 11436  	o := &Organization{OwnedPrivateRepos: &zeroValue}
 11437  	o.GetOwnedPrivateRepos()
 11438  	o = &Organization{}
 11439  	o.GetOwnedPrivateRepos()
 11440  	o = nil
 11441  	o.GetOwnedPrivateRepos()
 11442  }
 11443  
 11444  func TestOrganization_GetPlan(tt *testing.T) {
 11445  	o := &Organization{}
 11446  	o.GetPlan()
 11447  	o = nil
 11448  	o.GetPlan()
 11449  }
 11450  
 11451  func TestOrganization_GetPrivateGists(tt *testing.T) {
 11452  	var zeroValue int
 11453  	o := &Organization{PrivateGists: &zeroValue}
 11454  	o.GetPrivateGists()
 11455  	o = &Organization{}
 11456  	o.GetPrivateGists()
 11457  	o = nil
 11458  	o.GetPrivateGists()
 11459  }
 11460  
 11461  func TestOrganization_GetPublicGists(tt *testing.T) {
 11462  	var zeroValue int
 11463  	o := &Organization{PublicGists: &zeroValue}
 11464  	o.GetPublicGists()
 11465  	o = &Organization{}
 11466  	o.GetPublicGists()
 11467  	o = nil
 11468  	o.GetPublicGists()
 11469  }
 11470  
 11471  func TestOrganization_GetPublicMembersURL(tt *testing.T) {
 11472  	var zeroValue string
 11473  	o := &Organization{PublicMembersURL: &zeroValue}
 11474  	o.GetPublicMembersURL()
 11475  	o = &Organization{}
 11476  	o.GetPublicMembersURL()
 11477  	o = nil
 11478  	o.GetPublicMembersURL()
 11479  }
 11480  
 11481  func TestOrganization_GetPublicRepos(tt *testing.T) {
 11482  	var zeroValue int
 11483  	o := &Organization{PublicRepos: &zeroValue}
 11484  	o.GetPublicRepos()
 11485  	o = &Organization{}
 11486  	o.GetPublicRepos()
 11487  	o = nil
 11488  	o.GetPublicRepos()
 11489  }
 11490  
 11491  func TestOrganization_GetReposURL(tt *testing.T) {
 11492  	var zeroValue string
 11493  	o := &Organization{ReposURL: &zeroValue}
 11494  	o.GetReposURL()
 11495  	o = &Organization{}
 11496  	o.GetReposURL()
 11497  	o = nil
 11498  	o.GetReposURL()
 11499  }
 11500  
 11501  func TestOrganization_GetSecretScanningEnabledForNewRepos(tt *testing.T) {
 11502  	var zeroValue bool
 11503  	o := &Organization{SecretScanningEnabledForNewRepos: &zeroValue}
 11504  	o.GetSecretScanningEnabledForNewRepos()
 11505  	o = &Organization{}
 11506  	o.GetSecretScanningEnabledForNewRepos()
 11507  	o = nil
 11508  	o.GetSecretScanningEnabledForNewRepos()
 11509  }
 11510  
 11511  func TestOrganization_GetSecretScanningPushProtectionEnabledForNewRepos(tt *testing.T) {
 11512  	var zeroValue bool
 11513  	o := &Organization{SecretScanningPushProtectionEnabledForNewRepos: &zeroValue}
 11514  	o.GetSecretScanningPushProtectionEnabledForNewRepos()
 11515  	o = &Organization{}
 11516  	o.GetSecretScanningPushProtectionEnabledForNewRepos()
 11517  	o = nil
 11518  	o.GetSecretScanningPushProtectionEnabledForNewRepos()
 11519  }
 11520  
 11521  func TestOrganization_GetTotalPrivateRepos(tt *testing.T) {
 11522  	var zeroValue int
 11523  	o := &Organization{TotalPrivateRepos: &zeroValue}
 11524  	o.GetTotalPrivateRepos()
 11525  	o = &Organization{}
 11526  	o.GetTotalPrivateRepos()
 11527  	o = nil
 11528  	o.GetTotalPrivateRepos()
 11529  }
 11530  
 11531  func TestOrganization_GetTwitterUsername(tt *testing.T) {
 11532  	var zeroValue string
 11533  	o := &Organization{TwitterUsername: &zeroValue}
 11534  	o.GetTwitterUsername()
 11535  	o = &Organization{}
 11536  	o.GetTwitterUsername()
 11537  	o = nil
 11538  	o.GetTwitterUsername()
 11539  }
 11540  
 11541  func TestOrganization_GetTwoFactorRequirementEnabled(tt *testing.T) {
 11542  	var zeroValue bool
 11543  	o := &Organization{TwoFactorRequirementEnabled: &zeroValue}
 11544  	o.GetTwoFactorRequirementEnabled()
 11545  	o = &Organization{}
 11546  	o.GetTwoFactorRequirementEnabled()
 11547  	o = nil
 11548  	o.GetTwoFactorRequirementEnabled()
 11549  }
 11550  
 11551  func TestOrganization_GetType(tt *testing.T) {
 11552  	var zeroValue string
 11553  	o := &Organization{Type: &zeroValue}
 11554  	o.GetType()
 11555  	o = &Organization{}
 11556  	o.GetType()
 11557  	o = nil
 11558  	o.GetType()
 11559  }
 11560  
 11561  func TestOrganization_GetUpdatedAt(tt *testing.T) {
 11562  	var zeroValue time.Time
 11563  	o := &Organization{UpdatedAt: &zeroValue}
 11564  	o.GetUpdatedAt()
 11565  	o = &Organization{}
 11566  	o.GetUpdatedAt()
 11567  	o = nil
 11568  	o.GetUpdatedAt()
 11569  }
 11570  
 11571  func TestOrganization_GetURL(tt *testing.T) {
 11572  	var zeroValue string
 11573  	o := &Organization{URL: &zeroValue}
 11574  	o.GetURL()
 11575  	o = &Organization{}
 11576  	o.GetURL()
 11577  	o = nil
 11578  	o.GetURL()
 11579  }
 11580  
 11581  func TestOrganization_GetWebCommitSignoffRequired(tt *testing.T) {
 11582  	var zeroValue bool
 11583  	o := &Organization{WebCommitSignoffRequired: &zeroValue}
 11584  	o.GetWebCommitSignoffRequired()
 11585  	o = &Organization{}
 11586  	o.GetWebCommitSignoffRequired()
 11587  	o = nil
 11588  	o.GetWebCommitSignoffRequired()
 11589  }
 11590  
 11591  func TestOrganizationCustomRepoRoles_GetTotalCount(tt *testing.T) {
 11592  	var zeroValue int
 11593  	o := &OrganizationCustomRepoRoles{TotalCount: &zeroValue}
 11594  	o.GetTotalCount()
 11595  	o = &OrganizationCustomRepoRoles{}
 11596  	o.GetTotalCount()
 11597  	o = nil
 11598  	o.GetTotalCount()
 11599  }
 11600  
 11601  func TestOrganizationEvent_GetAction(tt *testing.T) {
 11602  	var zeroValue string
 11603  	o := &OrganizationEvent{Action: &zeroValue}
 11604  	o.GetAction()
 11605  	o = &OrganizationEvent{}
 11606  	o.GetAction()
 11607  	o = nil
 11608  	o.GetAction()
 11609  }
 11610  
 11611  func TestOrganizationEvent_GetInstallation(tt *testing.T) {
 11612  	o := &OrganizationEvent{}
 11613  	o.GetInstallation()
 11614  	o = nil
 11615  	o.GetInstallation()
 11616  }
 11617  
 11618  func TestOrganizationEvent_GetInvitation(tt *testing.T) {
 11619  	o := &OrganizationEvent{}
 11620  	o.GetInvitation()
 11621  	o = nil
 11622  	o.GetInvitation()
 11623  }
 11624  
 11625  func TestOrganizationEvent_GetMembership(tt *testing.T) {
 11626  	o := &OrganizationEvent{}
 11627  	o.GetMembership()
 11628  	o = nil
 11629  	o.GetMembership()
 11630  }
 11631  
 11632  func TestOrganizationEvent_GetOrganization(tt *testing.T) {
 11633  	o := &OrganizationEvent{}
 11634  	o.GetOrganization()
 11635  	o = nil
 11636  	o.GetOrganization()
 11637  }
 11638  
 11639  func TestOrganizationEvent_GetSender(tt *testing.T) {
 11640  	o := &OrganizationEvent{}
 11641  	o.GetSender()
 11642  	o = nil
 11643  	o.GetSender()
 11644  }
 11645  
 11646  func TestOrganizationInstallations_GetTotalCount(tt *testing.T) {
 11647  	var zeroValue int
 11648  	o := &OrganizationInstallations{TotalCount: &zeroValue}
 11649  	o.GetTotalCount()
 11650  	o = &OrganizationInstallations{}
 11651  	o.GetTotalCount()
 11652  	o = nil
 11653  	o.GetTotalCount()
 11654  }
 11655  
 11656  func TestOrgBlockEvent_GetAction(tt *testing.T) {
 11657  	var zeroValue string
 11658  	o := &OrgBlockEvent{Action: &zeroValue}
 11659  	o.GetAction()
 11660  	o = &OrgBlockEvent{}
 11661  	o.GetAction()
 11662  	o = nil
 11663  	o.GetAction()
 11664  }
 11665  
 11666  func TestOrgBlockEvent_GetBlockedUser(tt *testing.T) {
 11667  	o := &OrgBlockEvent{}
 11668  	o.GetBlockedUser()
 11669  	o = nil
 11670  	o.GetBlockedUser()
 11671  }
 11672  
 11673  func TestOrgBlockEvent_GetInstallation(tt *testing.T) {
 11674  	o := &OrgBlockEvent{}
 11675  	o.GetInstallation()
 11676  	o = nil
 11677  	o.GetInstallation()
 11678  }
 11679  
 11680  func TestOrgBlockEvent_GetOrganization(tt *testing.T) {
 11681  	o := &OrgBlockEvent{}
 11682  	o.GetOrganization()
 11683  	o = nil
 11684  	o.GetOrganization()
 11685  }
 11686  
 11687  func TestOrgBlockEvent_GetSender(tt *testing.T) {
 11688  	o := &OrgBlockEvent{}
 11689  	o.GetSender()
 11690  	o = nil
 11691  	o.GetSender()
 11692  }
 11693  
 11694  func TestOrgStats_GetDisabledOrgs(tt *testing.T) {
 11695  	var zeroValue int
 11696  	o := &OrgStats{DisabledOrgs: &zeroValue}
 11697  	o.GetDisabledOrgs()
 11698  	o = &OrgStats{}
 11699  	o.GetDisabledOrgs()
 11700  	o = nil
 11701  	o.GetDisabledOrgs()
 11702  }
 11703  
 11704  func TestOrgStats_GetTotalOrgs(tt *testing.T) {
 11705  	var zeroValue int
 11706  	o := &OrgStats{TotalOrgs: &zeroValue}
 11707  	o.GetTotalOrgs()
 11708  	o = &OrgStats{}
 11709  	o.GetTotalOrgs()
 11710  	o = nil
 11711  	o.GetTotalOrgs()
 11712  }
 11713  
 11714  func TestOrgStats_GetTotalTeamMembers(tt *testing.T) {
 11715  	var zeroValue int
 11716  	o := &OrgStats{TotalTeamMembers: &zeroValue}
 11717  	o.GetTotalTeamMembers()
 11718  	o = &OrgStats{}
 11719  	o.GetTotalTeamMembers()
 11720  	o = nil
 11721  	o.GetTotalTeamMembers()
 11722  }
 11723  
 11724  func TestOrgStats_GetTotalTeams(tt *testing.T) {
 11725  	var zeroValue int
 11726  	o := &OrgStats{TotalTeams: &zeroValue}
 11727  	o.GetTotalTeams()
 11728  	o = &OrgStats{}
 11729  	o.GetTotalTeams()
 11730  	o = nil
 11731  	o.GetTotalTeams()
 11732  }
 11733  
 11734  func TestPackage_GetCreatedAt(tt *testing.T) {
 11735  	var zeroValue Timestamp
 11736  	p := &Package{CreatedAt: &zeroValue}
 11737  	p.GetCreatedAt()
 11738  	p = &Package{}
 11739  	p.GetCreatedAt()
 11740  	p = nil
 11741  	p.GetCreatedAt()
 11742  }
 11743  
 11744  func TestPackage_GetHTMLURL(tt *testing.T) {
 11745  	var zeroValue string
 11746  	p := &Package{HTMLURL: &zeroValue}
 11747  	p.GetHTMLURL()
 11748  	p = &Package{}
 11749  	p.GetHTMLURL()
 11750  	p = nil
 11751  	p.GetHTMLURL()
 11752  }
 11753  
 11754  func TestPackage_GetID(tt *testing.T) {
 11755  	var zeroValue int64
 11756  	p := &Package{ID: &zeroValue}
 11757  	p.GetID()
 11758  	p = &Package{}
 11759  	p.GetID()
 11760  	p = nil
 11761  	p.GetID()
 11762  }
 11763  
 11764  func TestPackage_GetName(tt *testing.T) {
 11765  	var zeroValue string
 11766  	p := &Package{Name: &zeroValue}
 11767  	p.GetName()
 11768  	p = &Package{}
 11769  	p.GetName()
 11770  	p = nil
 11771  	p.GetName()
 11772  }
 11773  
 11774  func TestPackage_GetOwner(tt *testing.T) {
 11775  	p := &Package{}
 11776  	p.GetOwner()
 11777  	p = nil
 11778  	p.GetOwner()
 11779  }
 11780  
 11781  func TestPackage_GetPackageType(tt *testing.T) {
 11782  	var zeroValue string
 11783  	p := &Package{PackageType: &zeroValue}
 11784  	p.GetPackageType()
 11785  	p = &Package{}
 11786  	p.GetPackageType()
 11787  	p = nil
 11788  	p.GetPackageType()
 11789  }
 11790  
 11791  func TestPackage_GetPackageVersion(tt *testing.T) {
 11792  	p := &Package{}
 11793  	p.GetPackageVersion()
 11794  	p = nil
 11795  	p.GetPackageVersion()
 11796  }
 11797  
 11798  func TestPackage_GetRegistry(tt *testing.T) {
 11799  	p := &Package{}
 11800  	p.GetRegistry()
 11801  	p = nil
 11802  	p.GetRegistry()
 11803  }
 11804  
 11805  func TestPackage_GetRepository(tt *testing.T) {
 11806  	p := &Package{}
 11807  	p.GetRepository()
 11808  	p = nil
 11809  	p.GetRepository()
 11810  }
 11811  
 11812  func TestPackage_GetUpdatedAt(tt *testing.T) {
 11813  	var zeroValue Timestamp
 11814  	p := &Package{UpdatedAt: &zeroValue}
 11815  	p.GetUpdatedAt()
 11816  	p = &Package{}
 11817  	p.GetUpdatedAt()
 11818  	p = nil
 11819  	p.GetUpdatedAt()
 11820  }
 11821  
 11822  func TestPackage_GetURL(tt *testing.T) {
 11823  	var zeroValue string
 11824  	p := &Package{URL: &zeroValue}
 11825  	p.GetURL()
 11826  	p = &Package{}
 11827  	p.GetURL()
 11828  	p = nil
 11829  	p.GetURL()
 11830  }
 11831  
 11832  func TestPackage_GetVersionCount(tt *testing.T) {
 11833  	var zeroValue int64
 11834  	p := &Package{VersionCount: &zeroValue}
 11835  	p.GetVersionCount()
 11836  	p = &Package{}
 11837  	p.GetVersionCount()
 11838  	p = nil
 11839  	p.GetVersionCount()
 11840  }
 11841  
 11842  func TestPackage_GetVisibility(tt *testing.T) {
 11843  	var zeroValue string
 11844  	p := &Package{Visibility: &zeroValue}
 11845  	p.GetVisibility()
 11846  	p = &Package{}
 11847  	p.GetVisibility()
 11848  	p = nil
 11849  	p.GetVisibility()
 11850  }
 11851  
 11852  func TestPackageEvent_GetAction(tt *testing.T) {
 11853  	var zeroValue string
 11854  	p := &PackageEvent{Action: &zeroValue}
 11855  	p.GetAction()
 11856  	p = &PackageEvent{}
 11857  	p.GetAction()
 11858  	p = nil
 11859  	p.GetAction()
 11860  }
 11861  
 11862  func TestPackageEvent_GetInstallation(tt *testing.T) {
 11863  	p := &PackageEvent{}
 11864  	p.GetInstallation()
 11865  	p = nil
 11866  	p.GetInstallation()
 11867  }
 11868  
 11869  func TestPackageEvent_GetOrg(tt *testing.T) {
 11870  	p := &PackageEvent{}
 11871  	p.GetOrg()
 11872  	p = nil
 11873  	p.GetOrg()
 11874  }
 11875  
 11876  func TestPackageEvent_GetPackage(tt *testing.T) {
 11877  	p := &PackageEvent{}
 11878  	p.GetPackage()
 11879  	p = nil
 11880  	p.GetPackage()
 11881  }
 11882  
 11883  func TestPackageEvent_GetRepo(tt *testing.T) {
 11884  	p := &PackageEvent{}
 11885  	p.GetRepo()
 11886  	p = nil
 11887  	p.GetRepo()
 11888  }
 11889  
 11890  func TestPackageEvent_GetSender(tt *testing.T) {
 11891  	p := &PackageEvent{}
 11892  	p.GetSender()
 11893  	p = nil
 11894  	p.GetSender()
 11895  }
 11896  
 11897  func TestPackageFile_GetAuthor(tt *testing.T) {
 11898  	p := &PackageFile{}
 11899  	p.GetAuthor()
 11900  	p = nil
 11901  	p.GetAuthor()
 11902  }
 11903  
 11904  func TestPackageFile_GetContentType(tt *testing.T) {
 11905  	var zeroValue string
 11906  	p := &PackageFile{ContentType: &zeroValue}
 11907  	p.GetContentType()
 11908  	p = &PackageFile{}
 11909  	p.GetContentType()
 11910  	p = nil
 11911  	p.GetContentType()
 11912  }
 11913  
 11914  func TestPackageFile_GetCreatedAt(tt *testing.T) {
 11915  	var zeroValue Timestamp
 11916  	p := &PackageFile{CreatedAt: &zeroValue}
 11917  	p.GetCreatedAt()
 11918  	p = &PackageFile{}
 11919  	p.GetCreatedAt()
 11920  	p = nil
 11921  	p.GetCreatedAt()
 11922  }
 11923  
 11924  func TestPackageFile_GetDownloadURL(tt *testing.T) {
 11925  	var zeroValue string
 11926  	p := &PackageFile{DownloadURL: &zeroValue}
 11927  	p.GetDownloadURL()
 11928  	p = &PackageFile{}
 11929  	p.GetDownloadURL()
 11930  	p = nil
 11931  	p.GetDownloadURL()
 11932  }
 11933  
 11934  func TestPackageFile_GetID(tt *testing.T) {
 11935  	var zeroValue int64
 11936  	p := &PackageFile{ID: &zeroValue}
 11937  	p.GetID()
 11938  	p = &PackageFile{}
 11939  	p.GetID()
 11940  	p = nil
 11941  	p.GetID()
 11942  }
 11943  
 11944  func TestPackageFile_GetMD5(tt *testing.T) {
 11945  	var zeroValue string
 11946  	p := &PackageFile{MD5: &zeroValue}
 11947  	p.GetMD5()
 11948  	p = &PackageFile{}
 11949  	p.GetMD5()
 11950  	p = nil
 11951  	p.GetMD5()
 11952  }
 11953  
 11954  func TestPackageFile_GetName(tt *testing.T) {
 11955  	var zeroValue string
 11956  	p := &PackageFile{Name: &zeroValue}
 11957  	p.GetName()
 11958  	p = &PackageFile{}
 11959  	p.GetName()
 11960  	p = nil
 11961  	p.GetName()
 11962  }
 11963  
 11964  func TestPackageFile_GetSHA1(tt *testing.T) {
 11965  	var zeroValue string
 11966  	p := &PackageFile{SHA1: &zeroValue}
 11967  	p.GetSHA1()
 11968  	p = &PackageFile{}
 11969  	p.GetSHA1()
 11970  	p = nil
 11971  	p.GetSHA1()
 11972  }
 11973  
 11974  func TestPackageFile_GetSHA256(tt *testing.T) {
 11975  	var zeroValue string
 11976  	p := &PackageFile{SHA256: &zeroValue}
 11977  	p.GetSHA256()
 11978  	p = &PackageFile{}
 11979  	p.GetSHA256()
 11980  	p = nil
 11981  	p.GetSHA256()
 11982  }
 11983  
 11984  func TestPackageFile_GetSize(tt *testing.T) {
 11985  	var zeroValue int64
 11986  	p := &PackageFile{Size: &zeroValue}
 11987  	p.GetSize()
 11988  	p = &PackageFile{}
 11989  	p.GetSize()
 11990  	p = nil
 11991  	p.GetSize()
 11992  }
 11993  
 11994  func TestPackageFile_GetState(tt *testing.T) {
 11995  	var zeroValue string
 11996  	p := &PackageFile{State: &zeroValue}
 11997  	p.GetState()
 11998  	p = &PackageFile{}
 11999  	p.GetState()
 12000  	p = nil
 12001  	p.GetState()
 12002  }
 12003  
 12004  func TestPackageFile_GetUpdatedAt(tt *testing.T) {
 12005  	var zeroValue Timestamp
 12006  	p := &PackageFile{UpdatedAt: &zeroValue}
 12007  	p.GetUpdatedAt()
 12008  	p = &PackageFile{}
 12009  	p.GetUpdatedAt()
 12010  	p = nil
 12011  	p.GetUpdatedAt()
 12012  }
 12013  
 12014  func TestPackageListOptions_GetPackageType(tt *testing.T) {
 12015  	var zeroValue string
 12016  	p := &PackageListOptions{PackageType: &zeroValue}
 12017  	p.GetPackageType()
 12018  	p = &PackageListOptions{}
 12019  	p.GetPackageType()
 12020  	p = nil
 12021  	p.GetPackageType()
 12022  }
 12023  
 12024  func TestPackageListOptions_GetState(tt *testing.T) {
 12025  	var zeroValue string
 12026  	p := &PackageListOptions{State: &zeroValue}
 12027  	p.GetState()
 12028  	p = &PackageListOptions{}
 12029  	p.GetState()
 12030  	p = nil
 12031  	p.GetState()
 12032  }
 12033  
 12034  func TestPackageListOptions_GetVisibility(tt *testing.T) {
 12035  	var zeroValue string
 12036  	p := &PackageListOptions{Visibility: &zeroValue}
 12037  	p.GetVisibility()
 12038  	p = &PackageListOptions{}
 12039  	p.GetVisibility()
 12040  	p = nil
 12041  	p.GetVisibility()
 12042  }
 12043  
 12044  func TestPackageMetadata_GetContainer(tt *testing.T) {
 12045  	p := &PackageMetadata{}
 12046  	p.GetContainer()
 12047  	p = nil
 12048  	p.GetContainer()
 12049  }
 12050  
 12051  func TestPackageMetadata_GetPackageType(tt *testing.T) {
 12052  	var zeroValue string
 12053  	p := &PackageMetadata{PackageType: &zeroValue}
 12054  	p.GetPackageType()
 12055  	p = &PackageMetadata{}
 12056  	p.GetPackageType()
 12057  	p = nil
 12058  	p.GetPackageType()
 12059  }
 12060  
 12061  func TestPackageRegistry_GetAboutURL(tt *testing.T) {
 12062  	var zeroValue string
 12063  	p := &PackageRegistry{AboutURL: &zeroValue}
 12064  	p.GetAboutURL()
 12065  	p = &PackageRegistry{}
 12066  	p.GetAboutURL()
 12067  	p = nil
 12068  	p.GetAboutURL()
 12069  }
 12070  
 12071  func TestPackageRegistry_GetName(tt *testing.T) {
 12072  	var zeroValue string
 12073  	p := &PackageRegistry{Name: &zeroValue}
 12074  	p.GetName()
 12075  	p = &PackageRegistry{}
 12076  	p.GetName()
 12077  	p = nil
 12078  	p.GetName()
 12079  }
 12080  
 12081  func TestPackageRegistry_GetType(tt *testing.T) {
 12082  	var zeroValue string
 12083  	p := &PackageRegistry{Type: &zeroValue}
 12084  	p.GetType()
 12085  	p = &PackageRegistry{}
 12086  	p.GetType()
 12087  	p = nil
 12088  	p.GetType()
 12089  }
 12090  
 12091  func TestPackageRegistry_GetURL(tt *testing.T) {
 12092  	var zeroValue string
 12093  	p := &PackageRegistry{URL: &zeroValue}
 12094  	p.GetURL()
 12095  	p = &PackageRegistry{}
 12096  	p.GetURL()
 12097  	p = nil
 12098  	p.GetURL()
 12099  }
 12100  
 12101  func TestPackageRegistry_GetVendor(tt *testing.T) {
 12102  	var zeroValue string
 12103  	p := &PackageRegistry{Vendor: &zeroValue}
 12104  	p.GetVendor()
 12105  	p = &PackageRegistry{}
 12106  	p.GetVendor()
 12107  	p = nil
 12108  	p.GetVendor()
 12109  }
 12110  
 12111  func TestPackageRelease_GetAuthor(tt *testing.T) {
 12112  	p := &PackageRelease{}
 12113  	p.GetAuthor()
 12114  	p = nil
 12115  	p.GetAuthor()
 12116  }
 12117  
 12118  func TestPackageRelease_GetCreatedAt(tt *testing.T) {
 12119  	var zeroValue Timestamp
 12120  	p := &PackageRelease{CreatedAt: &zeroValue}
 12121  	p.GetCreatedAt()
 12122  	p = &PackageRelease{}
 12123  	p.GetCreatedAt()
 12124  	p = nil
 12125  	p.GetCreatedAt()
 12126  }
 12127  
 12128  func TestPackageRelease_GetDraft(tt *testing.T) {
 12129  	var zeroValue bool
 12130  	p := &PackageRelease{Draft: &zeroValue}
 12131  	p.GetDraft()
 12132  	p = &PackageRelease{}
 12133  	p.GetDraft()
 12134  	p = nil
 12135  	p.GetDraft()
 12136  }
 12137  
 12138  func TestPackageRelease_GetHTMLURL(tt *testing.T) {
 12139  	var zeroValue string
 12140  	p := &PackageRelease{HTMLURL: &zeroValue}
 12141  	p.GetHTMLURL()
 12142  	p = &PackageRelease{}
 12143  	p.GetHTMLURL()
 12144  	p = nil
 12145  	p.GetHTMLURL()
 12146  }
 12147  
 12148  func TestPackageRelease_GetID(tt *testing.T) {
 12149  	var zeroValue int64
 12150  	p := &PackageRelease{ID: &zeroValue}
 12151  	p.GetID()
 12152  	p = &PackageRelease{}
 12153  	p.GetID()
 12154  	p = nil
 12155  	p.GetID()
 12156  }
 12157  
 12158  func TestPackageRelease_GetName(tt *testing.T) {
 12159  	var zeroValue string
 12160  	p := &PackageRelease{Name: &zeroValue}
 12161  	p.GetName()
 12162  	p = &PackageRelease{}
 12163  	p.GetName()
 12164  	p = nil
 12165  	p.GetName()
 12166  }
 12167  
 12168  func TestPackageRelease_GetPrerelease(tt *testing.T) {
 12169  	var zeroValue bool
 12170  	p := &PackageRelease{Prerelease: &zeroValue}
 12171  	p.GetPrerelease()
 12172  	p = &PackageRelease{}
 12173  	p.GetPrerelease()
 12174  	p = nil
 12175  	p.GetPrerelease()
 12176  }
 12177  
 12178  func TestPackageRelease_GetPublishedAt(tt *testing.T) {
 12179  	var zeroValue Timestamp
 12180  	p := &PackageRelease{PublishedAt: &zeroValue}
 12181  	p.GetPublishedAt()
 12182  	p = &PackageRelease{}
 12183  	p.GetPublishedAt()
 12184  	p = nil
 12185  	p.GetPublishedAt()
 12186  }
 12187  
 12188  func TestPackageRelease_GetTagName(tt *testing.T) {
 12189  	var zeroValue string
 12190  	p := &PackageRelease{TagName: &zeroValue}
 12191  	p.GetTagName()
 12192  	p = &PackageRelease{}
 12193  	p.GetTagName()
 12194  	p = nil
 12195  	p.GetTagName()
 12196  }
 12197  
 12198  func TestPackageRelease_GetTargetCommitish(tt *testing.T) {
 12199  	var zeroValue string
 12200  	p := &PackageRelease{TargetCommitish: &zeroValue}
 12201  	p.GetTargetCommitish()
 12202  	p = &PackageRelease{}
 12203  	p.GetTargetCommitish()
 12204  	p = nil
 12205  	p.GetTargetCommitish()
 12206  }
 12207  
 12208  func TestPackageRelease_GetURL(tt *testing.T) {
 12209  	var zeroValue string
 12210  	p := &PackageRelease{URL: &zeroValue}
 12211  	p.GetURL()
 12212  	p = &PackageRelease{}
 12213  	p.GetURL()
 12214  	p = nil
 12215  	p.GetURL()
 12216  }
 12217  
 12218  func TestPackageVersion_GetAuthor(tt *testing.T) {
 12219  	p := &PackageVersion{}
 12220  	p.GetAuthor()
 12221  	p = nil
 12222  	p.GetAuthor()
 12223  }
 12224  
 12225  func TestPackageVersion_GetBody(tt *testing.T) {
 12226  	var zeroValue string
 12227  	p := &PackageVersion{Body: &zeroValue}
 12228  	p.GetBody()
 12229  	p = &PackageVersion{}
 12230  	p.GetBody()
 12231  	p = nil
 12232  	p.GetBody()
 12233  }
 12234  
 12235  func TestPackageVersion_GetBodyHTML(tt *testing.T) {
 12236  	var zeroValue string
 12237  	p := &PackageVersion{BodyHTML: &zeroValue}
 12238  	p.GetBodyHTML()
 12239  	p = &PackageVersion{}
 12240  	p.GetBodyHTML()
 12241  	p = nil
 12242  	p.GetBodyHTML()
 12243  }
 12244  
 12245  func TestPackageVersion_GetCreatedAt(tt *testing.T) {
 12246  	var zeroValue Timestamp
 12247  	p := &PackageVersion{CreatedAt: &zeroValue}
 12248  	p.GetCreatedAt()
 12249  	p = &PackageVersion{}
 12250  	p.GetCreatedAt()
 12251  	p = nil
 12252  	p.GetCreatedAt()
 12253  }
 12254  
 12255  func TestPackageVersion_GetDraft(tt *testing.T) {
 12256  	var zeroValue bool
 12257  	p := &PackageVersion{Draft: &zeroValue}
 12258  	p.GetDraft()
 12259  	p = &PackageVersion{}
 12260  	p.GetDraft()
 12261  	p = nil
 12262  	p.GetDraft()
 12263  }
 12264  
 12265  func TestPackageVersion_GetHTMLURL(tt *testing.T) {
 12266  	var zeroValue string
 12267  	p := &PackageVersion{HTMLURL: &zeroValue}
 12268  	p.GetHTMLURL()
 12269  	p = &PackageVersion{}
 12270  	p.GetHTMLURL()
 12271  	p = nil
 12272  	p.GetHTMLURL()
 12273  }
 12274  
 12275  func TestPackageVersion_GetID(tt *testing.T) {
 12276  	var zeroValue int64
 12277  	p := &PackageVersion{ID: &zeroValue}
 12278  	p.GetID()
 12279  	p = &PackageVersion{}
 12280  	p.GetID()
 12281  	p = nil
 12282  	p.GetID()
 12283  }
 12284  
 12285  func TestPackageVersion_GetInstallationCommand(tt *testing.T) {
 12286  	var zeroValue string
 12287  	p := &PackageVersion{InstallationCommand: &zeroValue}
 12288  	p.GetInstallationCommand()
 12289  	p = &PackageVersion{}
 12290  	p.GetInstallationCommand()
 12291  	p = nil
 12292  	p.GetInstallationCommand()
 12293  }
 12294  
 12295  func TestPackageVersion_GetManifest(tt *testing.T) {
 12296  	var zeroValue string
 12297  	p := &PackageVersion{Manifest: &zeroValue}
 12298  	p.GetManifest()
 12299  	p = &PackageVersion{}
 12300  	p.GetManifest()
 12301  	p = nil
 12302  	p.GetManifest()
 12303  }
 12304  
 12305  func TestPackageVersion_GetMetadata(tt *testing.T) {
 12306  	p := &PackageVersion{}
 12307  	p.GetMetadata()
 12308  	p = nil
 12309  	p.GetMetadata()
 12310  }
 12311  
 12312  func TestPackageVersion_GetName(tt *testing.T) {
 12313  	var zeroValue string
 12314  	p := &PackageVersion{Name: &zeroValue}
 12315  	p.GetName()
 12316  	p = &PackageVersion{}
 12317  	p.GetName()
 12318  	p = nil
 12319  	p.GetName()
 12320  }
 12321  
 12322  func TestPackageVersion_GetPackageHTMLURL(tt *testing.T) {
 12323  	var zeroValue string
 12324  	p := &PackageVersion{PackageHTMLURL: &zeroValue}
 12325  	p.GetPackageHTMLURL()
 12326  	p = &PackageVersion{}
 12327  	p.GetPackageHTMLURL()
 12328  	p = nil
 12329  	p.GetPackageHTMLURL()
 12330  }
 12331  
 12332  func TestPackageVersion_GetPrerelease(tt *testing.T) {
 12333  	var zeroValue bool
 12334  	p := &PackageVersion{Prerelease: &zeroValue}
 12335  	p.GetPrerelease()
 12336  	p = &PackageVersion{}
 12337  	p.GetPrerelease()
 12338  	p = nil
 12339  	p.GetPrerelease()
 12340  }
 12341  
 12342  func TestPackageVersion_GetRelease(tt *testing.T) {
 12343  	p := &PackageVersion{}
 12344  	p.GetRelease()
 12345  	p = nil
 12346  	p.GetRelease()
 12347  }
 12348  
 12349  func TestPackageVersion_GetSummary(tt *testing.T) {
 12350  	var zeroValue string
 12351  	p := &PackageVersion{Summary: &zeroValue}
 12352  	p.GetSummary()
 12353  	p = &PackageVersion{}
 12354  	p.GetSummary()
 12355  	p = nil
 12356  	p.GetSummary()
 12357  }
 12358  
 12359  func TestPackageVersion_GetTagName(tt *testing.T) {
 12360  	var zeroValue string
 12361  	p := &PackageVersion{TagName: &zeroValue}
 12362  	p.GetTagName()
 12363  	p = &PackageVersion{}
 12364  	p.GetTagName()
 12365  	p = nil
 12366  	p.GetTagName()
 12367  }
 12368  
 12369  func TestPackageVersion_GetTargetCommitish(tt *testing.T) {
 12370  	var zeroValue string
 12371  	p := &PackageVersion{TargetCommitish: &zeroValue}
 12372  	p.GetTargetCommitish()
 12373  	p = &PackageVersion{}
 12374  	p.GetTargetCommitish()
 12375  	p = nil
 12376  	p.GetTargetCommitish()
 12377  }
 12378  
 12379  func TestPackageVersion_GetTargetOID(tt *testing.T) {
 12380  	var zeroValue string
 12381  	p := &PackageVersion{TargetOID: &zeroValue}
 12382  	p.GetTargetOID()
 12383  	p = &PackageVersion{}
 12384  	p.GetTargetOID()
 12385  	p = nil
 12386  	p.GetTargetOID()
 12387  }
 12388  
 12389  func TestPackageVersion_GetUpdatedAt(tt *testing.T) {
 12390  	var zeroValue Timestamp
 12391  	p := &PackageVersion{UpdatedAt: &zeroValue}
 12392  	p.GetUpdatedAt()
 12393  	p = &PackageVersion{}
 12394  	p.GetUpdatedAt()
 12395  	p = nil
 12396  	p.GetUpdatedAt()
 12397  }
 12398  
 12399  func TestPackageVersion_GetURL(tt *testing.T) {
 12400  	var zeroValue string
 12401  	p := &PackageVersion{URL: &zeroValue}
 12402  	p.GetURL()
 12403  	p = &PackageVersion{}
 12404  	p.GetURL()
 12405  	p = nil
 12406  	p.GetURL()
 12407  }
 12408  
 12409  func TestPackageVersion_GetVersion(tt *testing.T) {
 12410  	var zeroValue string
 12411  	p := &PackageVersion{Version: &zeroValue}
 12412  	p.GetVersion()
 12413  	p = &PackageVersion{}
 12414  	p.GetVersion()
 12415  	p = nil
 12416  	p.GetVersion()
 12417  }
 12418  
 12419  func TestPage_GetAction(tt *testing.T) {
 12420  	var zeroValue string
 12421  	p := &Page{Action: &zeroValue}
 12422  	p.GetAction()
 12423  	p = &Page{}
 12424  	p.GetAction()
 12425  	p = nil
 12426  	p.GetAction()
 12427  }
 12428  
 12429  func TestPage_GetHTMLURL(tt *testing.T) {
 12430  	var zeroValue string
 12431  	p := &Page{HTMLURL: &zeroValue}
 12432  	p.GetHTMLURL()
 12433  	p = &Page{}
 12434  	p.GetHTMLURL()
 12435  	p = nil
 12436  	p.GetHTMLURL()
 12437  }
 12438  
 12439  func TestPage_GetPageName(tt *testing.T) {
 12440  	var zeroValue string
 12441  	p := &Page{PageName: &zeroValue}
 12442  	p.GetPageName()
 12443  	p = &Page{}
 12444  	p.GetPageName()
 12445  	p = nil
 12446  	p.GetPageName()
 12447  }
 12448  
 12449  func TestPage_GetSHA(tt *testing.T) {
 12450  	var zeroValue string
 12451  	p := &Page{SHA: &zeroValue}
 12452  	p.GetSHA()
 12453  	p = &Page{}
 12454  	p.GetSHA()
 12455  	p = nil
 12456  	p.GetSHA()
 12457  }
 12458  
 12459  func TestPage_GetSummary(tt *testing.T) {
 12460  	var zeroValue string
 12461  	p := &Page{Summary: &zeroValue}
 12462  	p.GetSummary()
 12463  	p = &Page{}
 12464  	p.GetSummary()
 12465  	p = nil
 12466  	p.GetSummary()
 12467  }
 12468  
 12469  func TestPage_GetTitle(tt *testing.T) {
 12470  	var zeroValue string
 12471  	p := &Page{Title: &zeroValue}
 12472  	p.GetTitle()
 12473  	p = &Page{}
 12474  	p.GetTitle()
 12475  	p = nil
 12476  	p.GetTitle()
 12477  }
 12478  
 12479  func TestPageBuildEvent_GetBuild(tt *testing.T) {
 12480  	p := &PageBuildEvent{}
 12481  	p.GetBuild()
 12482  	p = nil
 12483  	p.GetBuild()
 12484  }
 12485  
 12486  func TestPageBuildEvent_GetID(tt *testing.T) {
 12487  	var zeroValue int64
 12488  	p := &PageBuildEvent{ID: &zeroValue}
 12489  	p.GetID()
 12490  	p = &PageBuildEvent{}
 12491  	p.GetID()
 12492  	p = nil
 12493  	p.GetID()
 12494  }
 12495  
 12496  func TestPageBuildEvent_GetInstallation(tt *testing.T) {
 12497  	p := &PageBuildEvent{}
 12498  	p.GetInstallation()
 12499  	p = nil
 12500  	p.GetInstallation()
 12501  }
 12502  
 12503  func TestPageBuildEvent_GetRepo(tt *testing.T) {
 12504  	p := &PageBuildEvent{}
 12505  	p.GetRepo()
 12506  	p = nil
 12507  	p.GetRepo()
 12508  }
 12509  
 12510  func TestPageBuildEvent_GetSender(tt *testing.T) {
 12511  	p := &PageBuildEvent{}
 12512  	p.GetSender()
 12513  	p = nil
 12514  	p.GetSender()
 12515  }
 12516  
 12517  func TestPages_GetCNAME(tt *testing.T) {
 12518  	var zeroValue string
 12519  	p := &Pages{CNAME: &zeroValue}
 12520  	p.GetCNAME()
 12521  	p = &Pages{}
 12522  	p.GetCNAME()
 12523  	p = nil
 12524  	p.GetCNAME()
 12525  }
 12526  
 12527  func TestPages_GetCustom404(tt *testing.T) {
 12528  	var zeroValue bool
 12529  	p := &Pages{Custom404: &zeroValue}
 12530  	p.GetCustom404()
 12531  	p = &Pages{}
 12532  	p.GetCustom404()
 12533  	p = nil
 12534  	p.GetCustom404()
 12535  }
 12536  
 12537  func TestPages_GetHTMLURL(tt *testing.T) {
 12538  	var zeroValue string
 12539  	p := &Pages{HTMLURL: &zeroValue}
 12540  	p.GetHTMLURL()
 12541  	p = &Pages{}
 12542  	p.GetHTMLURL()
 12543  	p = nil
 12544  	p.GetHTMLURL()
 12545  }
 12546  
 12547  func TestPages_GetHTTPSCertificate(tt *testing.T) {
 12548  	p := &Pages{}
 12549  	p.GetHTTPSCertificate()
 12550  	p = nil
 12551  	p.GetHTTPSCertificate()
 12552  }
 12553  
 12554  func TestPages_GetHTTPSEnforced(tt *testing.T) {
 12555  	var zeroValue bool
 12556  	p := &Pages{HTTPSEnforced: &zeroValue}
 12557  	p.GetHTTPSEnforced()
 12558  	p = &Pages{}
 12559  	p.GetHTTPSEnforced()
 12560  	p = nil
 12561  	p.GetHTTPSEnforced()
 12562  }
 12563  
 12564  func TestPages_GetPublic(tt *testing.T) {
 12565  	var zeroValue bool
 12566  	p := &Pages{Public: &zeroValue}
 12567  	p.GetPublic()
 12568  	p = &Pages{}
 12569  	p.GetPublic()
 12570  	p = nil
 12571  	p.GetPublic()
 12572  }
 12573  
 12574  func TestPages_GetSource(tt *testing.T) {
 12575  	p := &Pages{}
 12576  	p.GetSource()
 12577  	p = nil
 12578  	p.GetSource()
 12579  }
 12580  
 12581  func TestPages_GetStatus(tt *testing.T) {
 12582  	var zeroValue string
 12583  	p := &Pages{Status: &zeroValue}
 12584  	p.GetStatus()
 12585  	p = &Pages{}
 12586  	p.GetStatus()
 12587  	p = nil
 12588  	p.GetStatus()
 12589  }
 12590  
 12591  func TestPages_GetURL(tt *testing.T) {
 12592  	var zeroValue string
 12593  	p := &Pages{URL: &zeroValue}
 12594  	p.GetURL()
 12595  	p = &Pages{}
 12596  	p.GetURL()
 12597  	p = nil
 12598  	p.GetURL()
 12599  }
 12600  
 12601  func TestPagesBuild_GetCommit(tt *testing.T) {
 12602  	var zeroValue string
 12603  	p := &PagesBuild{Commit: &zeroValue}
 12604  	p.GetCommit()
 12605  	p = &PagesBuild{}
 12606  	p.GetCommit()
 12607  	p = nil
 12608  	p.GetCommit()
 12609  }
 12610  
 12611  func TestPagesBuild_GetCreatedAt(tt *testing.T) {
 12612  	var zeroValue Timestamp
 12613  	p := &PagesBuild{CreatedAt: &zeroValue}
 12614  	p.GetCreatedAt()
 12615  	p = &PagesBuild{}
 12616  	p.GetCreatedAt()
 12617  	p = nil
 12618  	p.GetCreatedAt()
 12619  }
 12620  
 12621  func TestPagesBuild_GetDuration(tt *testing.T) {
 12622  	var zeroValue int
 12623  	p := &PagesBuild{Duration: &zeroValue}
 12624  	p.GetDuration()
 12625  	p = &PagesBuild{}
 12626  	p.GetDuration()
 12627  	p = nil
 12628  	p.GetDuration()
 12629  }
 12630  
 12631  func TestPagesBuild_GetError(tt *testing.T) {
 12632  	p := &PagesBuild{}
 12633  	p.GetError()
 12634  	p = nil
 12635  	p.GetError()
 12636  }
 12637  
 12638  func TestPagesBuild_GetPusher(tt *testing.T) {
 12639  	p := &PagesBuild{}
 12640  	p.GetPusher()
 12641  	p = nil
 12642  	p.GetPusher()
 12643  }
 12644  
 12645  func TestPagesBuild_GetStatus(tt *testing.T) {
 12646  	var zeroValue string
 12647  	p := &PagesBuild{Status: &zeroValue}
 12648  	p.GetStatus()
 12649  	p = &PagesBuild{}
 12650  	p.GetStatus()
 12651  	p = nil
 12652  	p.GetStatus()
 12653  }
 12654  
 12655  func TestPagesBuild_GetUpdatedAt(tt *testing.T) {
 12656  	var zeroValue Timestamp
 12657  	p := &PagesBuild{UpdatedAt: &zeroValue}
 12658  	p.GetUpdatedAt()
 12659  	p = &PagesBuild{}
 12660  	p.GetUpdatedAt()
 12661  	p = nil
 12662  	p.GetUpdatedAt()
 12663  }
 12664  
 12665  func TestPagesBuild_GetURL(tt *testing.T) {
 12666  	var zeroValue string
 12667  	p := &PagesBuild{URL: &zeroValue}
 12668  	p.GetURL()
 12669  	p = &PagesBuild{}
 12670  	p.GetURL()
 12671  	p = nil
 12672  	p.GetURL()
 12673  }
 12674  
 12675  func TestPagesError_GetMessage(tt *testing.T) {
 12676  	var zeroValue string
 12677  	p := &PagesError{Message: &zeroValue}
 12678  	p.GetMessage()
 12679  	p = &PagesError{}
 12680  	p.GetMessage()
 12681  	p = nil
 12682  	p.GetMessage()
 12683  }
 12684  
 12685  func TestPagesHTTPSCertificate_GetDescription(tt *testing.T) {
 12686  	var zeroValue string
 12687  	p := &PagesHTTPSCertificate{Description: &zeroValue}
 12688  	p.GetDescription()
 12689  	p = &PagesHTTPSCertificate{}
 12690  	p.GetDescription()
 12691  	p = nil
 12692  	p.GetDescription()
 12693  }
 12694  
 12695  func TestPagesHTTPSCertificate_GetExpiresAt(tt *testing.T) {
 12696  	var zeroValue string
 12697  	p := &PagesHTTPSCertificate{ExpiresAt: &zeroValue}
 12698  	p.GetExpiresAt()
 12699  	p = &PagesHTTPSCertificate{}
 12700  	p.GetExpiresAt()
 12701  	p = nil
 12702  	p.GetExpiresAt()
 12703  }
 12704  
 12705  func TestPagesHTTPSCertificate_GetState(tt *testing.T) {
 12706  	var zeroValue string
 12707  	p := &PagesHTTPSCertificate{State: &zeroValue}
 12708  	p.GetState()
 12709  	p = &PagesHTTPSCertificate{}
 12710  	p.GetState()
 12711  	p = nil
 12712  	p.GetState()
 12713  }
 12714  
 12715  func TestPagesSource_GetBranch(tt *testing.T) {
 12716  	var zeroValue string
 12717  	p := &PagesSource{Branch: &zeroValue}
 12718  	p.GetBranch()
 12719  	p = &PagesSource{}
 12720  	p.GetBranch()
 12721  	p = nil
 12722  	p.GetBranch()
 12723  }
 12724  
 12725  func TestPagesSource_GetPath(tt *testing.T) {
 12726  	var zeroValue string
 12727  	p := &PagesSource{Path: &zeroValue}
 12728  	p.GetPath()
 12729  	p = &PagesSource{}
 12730  	p.GetPath()
 12731  	p = nil
 12732  	p.GetPath()
 12733  }
 12734  
 12735  func TestPageStats_GetTotalPages(tt *testing.T) {
 12736  	var zeroValue int
 12737  	p := &PageStats{TotalPages: &zeroValue}
 12738  	p.GetTotalPages()
 12739  	p = &PageStats{}
 12740  	p.GetTotalPages()
 12741  	p = nil
 12742  	p.GetTotalPages()
 12743  }
 12744  
 12745  func TestPagesUpdate_GetCNAME(tt *testing.T) {
 12746  	var zeroValue string
 12747  	p := &PagesUpdate{CNAME: &zeroValue}
 12748  	p.GetCNAME()
 12749  	p = &PagesUpdate{}
 12750  	p.GetCNAME()
 12751  	p = nil
 12752  	p.GetCNAME()
 12753  }
 12754  
 12755  func TestPagesUpdate_GetHTTPSEnforced(tt *testing.T) {
 12756  	var zeroValue bool
 12757  	p := &PagesUpdate{HTTPSEnforced: &zeroValue}
 12758  	p.GetHTTPSEnforced()
 12759  	p = &PagesUpdate{}
 12760  	p.GetHTTPSEnforced()
 12761  	p = nil
 12762  	p.GetHTTPSEnforced()
 12763  }
 12764  
 12765  func TestPagesUpdate_GetPublic(tt *testing.T) {
 12766  	var zeroValue bool
 12767  	p := &PagesUpdate{Public: &zeroValue}
 12768  	p.GetPublic()
 12769  	p = &PagesUpdate{}
 12770  	p.GetPublic()
 12771  	p = nil
 12772  	p.GetPublic()
 12773  }
 12774  
 12775  func TestPagesUpdate_GetSource(tt *testing.T) {
 12776  	p := &PagesUpdate{}
 12777  	p.GetSource()
 12778  	p = nil
 12779  	p.GetSource()
 12780  }
 12781  
 12782  func TestPingEvent_GetHook(tt *testing.T) {
 12783  	p := &PingEvent{}
 12784  	p.GetHook()
 12785  	p = nil
 12786  	p.GetHook()
 12787  }
 12788  
 12789  func TestPingEvent_GetHookID(tt *testing.T) {
 12790  	var zeroValue int64
 12791  	p := &PingEvent{HookID: &zeroValue}
 12792  	p.GetHookID()
 12793  	p = &PingEvent{}
 12794  	p.GetHookID()
 12795  	p = nil
 12796  	p.GetHookID()
 12797  }
 12798  
 12799  func TestPingEvent_GetInstallation(tt *testing.T) {
 12800  	p := &PingEvent{}
 12801  	p.GetInstallation()
 12802  	p = nil
 12803  	p.GetInstallation()
 12804  }
 12805  
 12806  func TestPingEvent_GetOrg(tt *testing.T) {
 12807  	p := &PingEvent{}
 12808  	p.GetOrg()
 12809  	p = nil
 12810  	p.GetOrg()
 12811  }
 12812  
 12813  func TestPingEvent_GetRepo(tt *testing.T) {
 12814  	p := &PingEvent{}
 12815  	p.GetRepo()
 12816  	p = nil
 12817  	p.GetRepo()
 12818  }
 12819  
 12820  func TestPingEvent_GetSender(tt *testing.T) {
 12821  	p := &PingEvent{}
 12822  	p.GetSender()
 12823  	p = nil
 12824  	p.GetSender()
 12825  }
 12826  
 12827  func TestPingEvent_GetZen(tt *testing.T) {
 12828  	var zeroValue string
 12829  	p := &PingEvent{Zen: &zeroValue}
 12830  	p.GetZen()
 12831  	p = &PingEvent{}
 12832  	p.GetZen()
 12833  	p = nil
 12834  	p.GetZen()
 12835  }
 12836  
 12837  func TestPlan_GetCollaborators(tt *testing.T) {
 12838  	var zeroValue int
 12839  	p := &Plan{Collaborators: &zeroValue}
 12840  	p.GetCollaborators()
 12841  	p = &Plan{}
 12842  	p.GetCollaborators()
 12843  	p = nil
 12844  	p.GetCollaborators()
 12845  }
 12846  
 12847  func TestPlan_GetFilledSeats(tt *testing.T) {
 12848  	var zeroValue int
 12849  	p := &Plan{FilledSeats: &zeroValue}
 12850  	p.GetFilledSeats()
 12851  	p = &Plan{}
 12852  	p.GetFilledSeats()
 12853  	p = nil
 12854  	p.GetFilledSeats()
 12855  }
 12856  
 12857  func TestPlan_GetName(tt *testing.T) {
 12858  	var zeroValue string
 12859  	p := &Plan{Name: &zeroValue}
 12860  	p.GetName()
 12861  	p = &Plan{}
 12862  	p.GetName()
 12863  	p = nil
 12864  	p.GetName()
 12865  }
 12866  
 12867  func TestPlan_GetPrivateRepos(tt *testing.T) {
 12868  	var zeroValue int
 12869  	p := &Plan{PrivateRepos: &zeroValue}
 12870  	p.GetPrivateRepos()
 12871  	p = &Plan{}
 12872  	p.GetPrivateRepos()
 12873  	p = nil
 12874  	p.GetPrivateRepos()
 12875  }
 12876  
 12877  func TestPlan_GetSeats(tt *testing.T) {
 12878  	var zeroValue int
 12879  	p := &Plan{Seats: &zeroValue}
 12880  	p.GetSeats()
 12881  	p = &Plan{}
 12882  	p.GetSeats()
 12883  	p = nil
 12884  	p.GetSeats()
 12885  }
 12886  
 12887  func TestPlan_GetSpace(tt *testing.T) {
 12888  	var zeroValue int
 12889  	p := &Plan{Space: &zeroValue}
 12890  	p.GetSpace()
 12891  	p = &Plan{}
 12892  	p.GetSpace()
 12893  	p = nil
 12894  	p.GetSpace()
 12895  }
 12896  
 12897  func TestPreReceiveHook_GetConfigURL(tt *testing.T) {
 12898  	var zeroValue string
 12899  	p := &PreReceiveHook{ConfigURL: &zeroValue}
 12900  	p.GetConfigURL()
 12901  	p = &PreReceiveHook{}
 12902  	p.GetConfigURL()
 12903  	p = nil
 12904  	p.GetConfigURL()
 12905  }
 12906  
 12907  func TestPreReceiveHook_GetEnforcement(tt *testing.T) {
 12908  	var zeroValue string
 12909  	p := &PreReceiveHook{Enforcement: &zeroValue}
 12910  	p.GetEnforcement()
 12911  	p = &PreReceiveHook{}
 12912  	p.GetEnforcement()
 12913  	p = nil
 12914  	p.GetEnforcement()
 12915  }
 12916  
 12917  func TestPreReceiveHook_GetID(tt *testing.T) {
 12918  	var zeroValue int64
 12919  	p := &PreReceiveHook{ID: &zeroValue}
 12920  	p.GetID()
 12921  	p = &PreReceiveHook{}
 12922  	p.GetID()
 12923  	p = nil
 12924  	p.GetID()
 12925  }
 12926  
 12927  func TestPreReceiveHook_GetName(tt *testing.T) {
 12928  	var zeroValue string
 12929  	p := &PreReceiveHook{Name: &zeroValue}
 12930  	p.GetName()
 12931  	p = &PreReceiveHook{}
 12932  	p.GetName()
 12933  	p = nil
 12934  	p.GetName()
 12935  }
 12936  
 12937  func TestPRLink_GetHRef(tt *testing.T) {
 12938  	var zeroValue string
 12939  	p := &PRLink{HRef: &zeroValue}
 12940  	p.GetHRef()
 12941  	p = &PRLink{}
 12942  	p.GetHRef()
 12943  	p = nil
 12944  	p.GetHRef()
 12945  }
 12946  
 12947  func TestPRLinks_GetComments(tt *testing.T) {
 12948  	p := &PRLinks{}
 12949  	p.GetComments()
 12950  	p = nil
 12951  	p.GetComments()
 12952  }
 12953  
 12954  func TestPRLinks_GetCommits(tt *testing.T) {
 12955  	p := &PRLinks{}
 12956  	p.GetCommits()
 12957  	p = nil
 12958  	p.GetCommits()
 12959  }
 12960  
 12961  func TestPRLinks_GetHTML(tt *testing.T) {
 12962  	p := &PRLinks{}
 12963  	p.GetHTML()
 12964  	p = nil
 12965  	p.GetHTML()
 12966  }
 12967  
 12968  func TestPRLinks_GetIssue(tt *testing.T) {
 12969  	p := &PRLinks{}
 12970  	p.GetIssue()
 12971  	p = nil
 12972  	p.GetIssue()
 12973  }
 12974  
 12975  func TestPRLinks_GetReviewComment(tt *testing.T) {
 12976  	p := &PRLinks{}
 12977  	p.GetReviewComment()
 12978  	p = nil
 12979  	p.GetReviewComment()
 12980  }
 12981  
 12982  func TestPRLinks_GetReviewComments(tt *testing.T) {
 12983  	p := &PRLinks{}
 12984  	p.GetReviewComments()
 12985  	p = nil
 12986  	p.GetReviewComments()
 12987  }
 12988  
 12989  func TestPRLinks_GetSelf(tt *testing.T) {
 12990  	p := &PRLinks{}
 12991  	p.GetSelf()
 12992  	p = nil
 12993  	p.GetSelf()
 12994  }
 12995  
 12996  func TestPRLinks_GetStatuses(tt *testing.T) {
 12997  	p := &PRLinks{}
 12998  	p.GetStatuses()
 12999  	p = nil
 13000  	p.GetStatuses()
 13001  }
 13002  
 13003  func TestProject_GetBody(tt *testing.T) {
 13004  	var zeroValue string
 13005  	p := &Project{Body: &zeroValue}
 13006  	p.GetBody()
 13007  	p = &Project{}
 13008  	p.GetBody()
 13009  	p = nil
 13010  	p.GetBody()
 13011  }
 13012  
 13013  func TestProject_GetColumnsURL(tt *testing.T) {
 13014  	var zeroValue string
 13015  	p := &Project{ColumnsURL: &zeroValue}
 13016  	p.GetColumnsURL()
 13017  	p = &Project{}
 13018  	p.GetColumnsURL()
 13019  	p = nil
 13020  	p.GetColumnsURL()
 13021  }
 13022  
 13023  func TestProject_GetCreatedAt(tt *testing.T) {
 13024  	var zeroValue Timestamp
 13025  	p := &Project{CreatedAt: &zeroValue}
 13026  	p.GetCreatedAt()
 13027  	p = &Project{}
 13028  	p.GetCreatedAt()
 13029  	p = nil
 13030  	p.GetCreatedAt()
 13031  }
 13032  
 13033  func TestProject_GetCreator(tt *testing.T) {
 13034  	p := &Project{}
 13035  	p.GetCreator()
 13036  	p = nil
 13037  	p.GetCreator()
 13038  }
 13039  
 13040  func TestProject_GetHTMLURL(tt *testing.T) {
 13041  	var zeroValue string
 13042  	p := &Project{HTMLURL: &zeroValue}
 13043  	p.GetHTMLURL()
 13044  	p = &Project{}
 13045  	p.GetHTMLURL()
 13046  	p = nil
 13047  	p.GetHTMLURL()
 13048  }
 13049  
 13050  func TestProject_GetID(tt *testing.T) {
 13051  	var zeroValue int64
 13052  	p := &Project{ID: &zeroValue}
 13053  	p.GetID()
 13054  	p = &Project{}
 13055  	p.GetID()
 13056  	p = nil
 13057  	p.GetID()
 13058  }
 13059  
 13060  func TestProject_GetName(tt *testing.T) {
 13061  	var zeroValue string
 13062  	p := &Project{Name: &zeroValue}
 13063  	p.GetName()
 13064  	p = &Project{}
 13065  	p.GetName()
 13066  	p = nil
 13067  	p.GetName()
 13068  }
 13069  
 13070  func TestProject_GetNodeID(tt *testing.T) {
 13071  	var zeroValue string
 13072  	p := &Project{NodeID: &zeroValue}
 13073  	p.GetNodeID()
 13074  	p = &Project{}
 13075  	p.GetNodeID()
 13076  	p = nil
 13077  	p.GetNodeID()
 13078  }
 13079  
 13080  func TestProject_GetNumber(tt *testing.T) {
 13081  	var zeroValue int
 13082  	p := &Project{Number: &zeroValue}
 13083  	p.GetNumber()
 13084  	p = &Project{}
 13085  	p.GetNumber()
 13086  	p = nil
 13087  	p.GetNumber()
 13088  }
 13089  
 13090  func TestProject_GetOrganizationPermission(tt *testing.T) {
 13091  	var zeroValue string
 13092  	p := &Project{OrganizationPermission: &zeroValue}
 13093  	p.GetOrganizationPermission()
 13094  	p = &Project{}
 13095  	p.GetOrganizationPermission()
 13096  	p = nil
 13097  	p.GetOrganizationPermission()
 13098  }
 13099  
 13100  func TestProject_GetOwnerURL(tt *testing.T) {
 13101  	var zeroValue string
 13102  	p := &Project{OwnerURL: &zeroValue}
 13103  	p.GetOwnerURL()
 13104  	p = &Project{}
 13105  	p.GetOwnerURL()
 13106  	p = nil
 13107  	p.GetOwnerURL()
 13108  }
 13109  
 13110  func TestProject_GetPrivate(tt *testing.T) {
 13111  	var zeroValue bool
 13112  	p := &Project{Private: &zeroValue}
 13113  	p.GetPrivate()
 13114  	p = &Project{}
 13115  	p.GetPrivate()
 13116  	p = nil
 13117  	p.GetPrivate()
 13118  }
 13119  
 13120  func TestProject_GetState(tt *testing.T) {
 13121  	var zeroValue string
 13122  	p := &Project{State: &zeroValue}
 13123  	p.GetState()
 13124  	p = &Project{}
 13125  	p.GetState()
 13126  	p = nil
 13127  	p.GetState()
 13128  }
 13129  
 13130  func TestProject_GetUpdatedAt(tt *testing.T) {
 13131  	var zeroValue Timestamp
 13132  	p := &Project{UpdatedAt: &zeroValue}
 13133  	p.GetUpdatedAt()
 13134  	p = &Project{}
 13135  	p.GetUpdatedAt()
 13136  	p = nil
 13137  	p.GetUpdatedAt()
 13138  }
 13139  
 13140  func TestProject_GetURL(tt *testing.T) {
 13141  	var zeroValue string
 13142  	p := &Project{URL: &zeroValue}
 13143  	p.GetURL()
 13144  	p = &Project{}
 13145  	p.GetURL()
 13146  	p = nil
 13147  	p.GetURL()
 13148  }
 13149  
 13150  func TestProjectBody_GetFrom(tt *testing.T) {
 13151  	var zeroValue string
 13152  	p := &ProjectBody{From: &zeroValue}
 13153  	p.GetFrom()
 13154  	p = &ProjectBody{}
 13155  	p.GetFrom()
 13156  	p = nil
 13157  	p.GetFrom()
 13158  }
 13159  
 13160  func TestProjectCard_GetArchived(tt *testing.T) {
 13161  	var zeroValue bool
 13162  	p := &ProjectCard{Archived: &zeroValue}
 13163  	p.GetArchived()
 13164  	p = &ProjectCard{}
 13165  	p.GetArchived()
 13166  	p = nil
 13167  	p.GetArchived()
 13168  }
 13169  
 13170  func TestProjectCard_GetColumnID(tt *testing.T) {
 13171  	var zeroValue int64
 13172  	p := &ProjectCard{ColumnID: &zeroValue}
 13173  	p.GetColumnID()
 13174  	p = &ProjectCard{}
 13175  	p.GetColumnID()
 13176  	p = nil
 13177  	p.GetColumnID()
 13178  }
 13179  
 13180  func TestProjectCard_GetColumnName(tt *testing.T) {
 13181  	var zeroValue string
 13182  	p := &ProjectCard{ColumnName: &zeroValue}
 13183  	p.GetColumnName()
 13184  	p = &ProjectCard{}
 13185  	p.GetColumnName()
 13186  	p = nil
 13187  	p.GetColumnName()
 13188  }
 13189  
 13190  func TestProjectCard_GetColumnURL(tt *testing.T) {
 13191  	var zeroValue string
 13192  	p := &ProjectCard{ColumnURL: &zeroValue}
 13193  	p.GetColumnURL()
 13194  	p = &ProjectCard{}
 13195  	p.GetColumnURL()
 13196  	p = nil
 13197  	p.GetColumnURL()
 13198  }
 13199  
 13200  func TestProjectCard_GetContentURL(tt *testing.T) {
 13201  	var zeroValue string
 13202  	p := &ProjectCard{ContentURL: &zeroValue}
 13203  	p.GetContentURL()
 13204  	p = &ProjectCard{}
 13205  	p.GetContentURL()
 13206  	p = nil
 13207  	p.GetContentURL()
 13208  }
 13209  
 13210  func TestProjectCard_GetCreatedAt(tt *testing.T) {
 13211  	var zeroValue Timestamp
 13212  	p := &ProjectCard{CreatedAt: &zeroValue}
 13213  	p.GetCreatedAt()
 13214  	p = &ProjectCard{}
 13215  	p.GetCreatedAt()
 13216  	p = nil
 13217  	p.GetCreatedAt()
 13218  }
 13219  
 13220  func TestProjectCard_GetCreator(tt *testing.T) {
 13221  	p := &ProjectCard{}
 13222  	p.GetCreator()
 13223  	p = nil
 13224  	p.GetCreator()
 13225  }
 13226  
 13227  func TestProjectCard_GetID(tt *testing.T) {
 13228  	var zeroValue int64
 13229  	p := &ProjectCard{ID: &zeroValue}
 13230  	p.GetID()
 13231  	p = &ProjectCard{}
 13232  	p.GetID()
 13233  	p = nil
 13234  	p.GetID()
 13235  }
 13236  
 13237  func TestProjectCard_GetNodeID(tt *testing.T) {
 13238  	var zeroValue string
 13239  	p := &ProjectCard{NodeID: &zeroValue}
 13240  	p.GetNodeID()
 13241  	p = &ProjectCard{}
 13242  	p.GetNodeID()
 13243  	p = nil
 13244  	p.GetNodeID()
 13245  }
 13246  
 13247  func TestProjectCard_GetNote(tt *testing.T) {
 13248  	var zeroValue string
 13249  	p := &ProjectCard{Note: &zeroValue}
 13250  	p.GetNote()
 13251  	p = &ProjectCard{}
 13252  	p.GetNote()
 13253  	p = nil
 13254  	p.GetNote()
 13255  }
 13256  
 13257  func TestProjectCard_GetPreviousColumnName(tt *testing.T) {
 13258  	var zeroValue string
 13259  	p := &ProjectCard{PreviousColumnName: &zeroValue}
 13260  	p.GetPreviousColumnName()
 13261  	p = &ProjectCard{}
 13262  	p.GetPreviousColumnName()
 13263  	p = nil
 13264  	p.GetPreviousColumnName()
 13265  }
 13266  
 13267  func TestProjectCard_GetProjectID(tt *testing.T) {
 13268  	var zeroValue int64
 13269  	p := &ProjectCard{ProjectID: &zeroValue}
 13270  	p.GetProjectID()
 13271  	p = &ProjectCard{}
 13272  	p.GetProjectID()
 13273  	p = nil
 13274  	p.GetProjectID()
 13275  }
 13276  
 13277  func TestProjectCard_GetProjectURL(tt *testing.T) {
 13278  	var zeroValue string
 13279  	p := &ProjectCard{ProjectURL: &zeroValue}
 13280  	p.GetProjectURL()
 13281  	p = &ProjectCard{}
 13282  	p.GetProjectURL()
 13283  	p = nil
 13284  	p.GetProjectURL()
 13285  }
 13286  
 13287  func TestProjectCard_GetUpdatedAt(tt *testing.T) {
 13288  	var zeroValue Timestamp
 13289  	p := &ProjectCard{UpdatedAt: &zeroValue}
 13290  	p.GetUpdatedAt()
 13291  	p = &ProjectCard{}
 13292  	p.GetUpdatedAt()
 13293  	p = nil
 13294  	p.GetUpdatedAt()
 13295  }
 13296  
 13297  func TestProjectCard_GetURL(tt *testing.T) {
 13298  	var zeroValue string
 13299  	p := &ProjectCard{URL: &zeroValue}
 13300  	p.GetURL()
 13301  	p = &ProjectCard{}
 13302  	p.GetURL()
 13303  	p = nil
 13304  	p.GetURL()
 13305  }
 13306  
 13307  func TestProjectCardChange_GetNote(tt *testing.T) {
 13308  	p := &ProjectCardChange{}
 13309  	p.GetNote()
 13310  	p = nil
 13311  	p.GetNote()
 13312  }
 13313  
 13314  func TestProjectCardEvent_GetAction(tt *testing.T) {
 13315  	var zeroValue string
 13316  	p := &ProjectCardEvent{Action: &zeroValue}
 13317  	p.GetAction()
 13318  	p = &ProjectCardEvent{}
 13319  	p.GetAction()
 13320  	p = nil
 13321  	p.GetAction()
 13322  }
 13323  
 13324  func TestProjectCardEvent_GetAfterID(tt *testing.T) {
 13325  	var zeroValue int64
 13326  	p := &ProjectCardEvent{AfterID: &zeroValue}
 13327  	p.GetAfterID()
 13328  	p = &ProjectCardEvent{}
 13329  	p.GetAfterID()
 13330  	p = nil
 13331  	p.GetAfterID()
 13332  }
 13333  
 13334  func TestProjectCardEvent_GetChanges(tt *testing.T) {
 13335  	p := &ProjectCardEvent{}
 13336  	p.GetChanges()
 13337  	p = nil
 13338  	p.GetChanges()
 13339  }
 13340  
 13341  func TestProjectCardEvent_GetInstallation(tt *testing.T) {
 13342  	p := &ProjectCardEvent{}
 13343  	p.GetInstallation()
 13344  	p = nil
 13345  	p.GetInstallation()
 13346  }
 13347  
 13348  func TestProjectCardEvent_GetOrg(tt *testing.T) {
 13349  	p := &ProjectCardEvent{}
 13350  	p.GetOrg()
 13351  	p = nil
 13352  	p.GetOrg()
 13353  }
 13354  
 13355  func TestProjectCardEvent_GetProjectCard(tt *testing.T) {
 13356  	p := &ProjectCardEvent{}
 13357  	p.GetProjectCard()
 13358  	p = nil
 13359  	p.GetProjectCard()
 13360  }
 13361  
 13362  func TestProjectCardEvent_GetRepo(tt *testing.T) {
 13363  	p := &ProjectCardEvent{}
 13364  	p.GetRepo()
 13365  	p = nil
 13366  	p.GetRepo()
 13367  }
 13368  
 13369  func TestProjectCardEvent_GetSender(tt *testing.T) {
 13370  	p := &ProjectCardEvent{}
 13371  	p.GetSender()
 13372  	p = nil
 13373  	p.GetSender()
 13374  }
 13375  
 13376  func TestProjectCardListOptions_GetArchivedState(tt *testing.T) {
 13377  	var zeroValue string
 13378  	p := &ProjectCardListOptions{ArchivedState: &zeroValue}
 13379  	p.GetArchivedState()
 13380  	p = &ProjectCardListOptions{}
 13381  	p.GetArchivedState()
 13382  	p = nil
 13383  	p.GetArchivedState()
 13384  }
 13385  
 13386  func TestProjectCardNote_GetFrom(tt *testing.T) {
 13387  	var zeroValue string
 13388  	p := &ProjectCardNote{From: &zeroValue}
 13389  	p.GetFrom()
 13390  	p = &ProjectCardNote{}
 13391  	p.GetFrom()
 13392  	p = nil
 13393  	p.GetFrom()
 13394  }
 13395  
 13396  func TestProjectCardOptions_GetArchived(tt *testing.T) {
 13397  	var zeroValue bool
 13398  	p := &ProjectCardOptions{Archived: &zeroValue}
 13399  	p.GetArchived()
 13400  	p = &ProjectCardOptions{}
 13401  	p.GetArchived()
 13402  	p = nil
 13403  	p.GetArchived()
 13404  }
 13405  
 13406  func TestProjectChange_GetBody(tt *testing.T) {
 13407  	p := &ProjectChange{}
 13408  	p.GetBody()
 13409  	p = nil
 13410  	p.GetBody()
 13411  }
 13412  
 13413  func TestProjectChange_GetName(tt *testing.T) {
 13414  	p := &ProjectChange{}
 13415  	p.GetName()
 13416  	p = nil
 13417  	p.GetName()
 13418  }
 13419  
 13420  func TestProjectCollaboratorOptions_GetPermission(tt *testing.T) {
 13421  	var zeroValue string
 13422  	p := &ProjectCollaboratorOptions{Permission: &zeroValue}
 13423  	p.GetPermission()
 13424  	p = &ProjectCollaboratorOptions{}
 13425  	p.GetPermission()
 13426  	p = nil
 13427  	p.GetPermission()
 13428  }
 13429  
 13430  func TestProjectColumn_GetCardsURL(tt *testing.T) {
 13431  	var zeroValue string
 13432  	p := &ProjectColumn{CardsURL: &zeroValue}
 13433  	p.GetCardsURL()
 13434  	p = &ProjectColumn{}
 13435  	p.GetCardsURL()
 13436  	p = nil
 13437  	p.GetCardsURL()
 13438  }
 13439  
 13440  func TestProjectColumn_GetCreatedAt(tt *testing.T) {
 13441  	var zeroValue Timestamp
 13442  	p := &ProjectColumn{CreatedAt: &zeroValue}
 13443  	p.GetCreatedAt()
 13444  	p = &ProjectColumn{}
 13445  	p.GetCreatedAt()
 13446  	p = nil
 13447  	p.GetCreatedAt()
 13448  }
 13449  
 13450  func TestProjectColumn_GetID(tt *testing.T) {
 13451  	var zeroValue int64
 13452  	p := &ProjectColumn{ID: &zeroValue}
 13453  	p.GetID()
 13454  	p = &ProjectColumn{}
 13455  	p.GetID()
 13456  	p = nil
 13457  	p.GetID()
 13458  }
 13459  
 13460  func TestProjectColumn_GetName(tt *testing.T) {
 13461  	var zeroValue string
 13462  	p := &ProjectColumn{Name: &zeroValue}
 13463  	p.GetName()
 13464  	p = &ProjectColumn{}
 13465  	p.GetName()
 13466  	p = nil
 13467  	p.GetName()
 13468  }
 13469  
 13470  func TestProjectColumn_GetNodeID(tt *testing.T) {
 13471  	var zeroValue string
 13472  	p := &ProjectColumn{NodeID: &zeroValue}
 13473  	p.GetNodeID()
 13474  	p = &ProjectColumn{}
 13475  	p.GetNodeID()
 13476  	p = nil
 13477  	p.GetNodeID()
 13478  }
 13479  
 13480  func TestProjectColumn_GetProjectURL(tt *testing.T) {
 13481  	var zeroValue string
 13482  	p := &ProjectColumn{ProjectURL: &zeroValue}
 13483  	p.GetProjectURL()
 13484  	p = &ProjectColumn{}
 13485  	p.GetProjectURL()
 13486  	p = nil
 13487  	p.GetProjectURL()
 13488  }
 13489  
 13490  func TestProjectColumn_GetUpdatedAt(tt *testing.T) {
 13491  	var zeroValue Timestamp
 13492  	p := &ProjectColumn{UpdatedAt: &zeroValue}
 13493  	p.GetUpdatedAt()
 13494  	p = &ProjectColumn{}
 13495  	p.GetUpdatedAt()
 13496  	p = nil
 13497  	p.GetUpdatedAt()
 13498  }
 13499  
 13500  func TestProjectColumn_GetURL(tt *testing.T) {
 13501  	var zeroValue string
 13502  	p := &ProjectColumn{URL: &zeroValue}
 13503  	p.GetURL()
 13504  	p = &ProjectColumn{}
 13505  	p.GetURL()
 13506  	p = nil
 13507  	p.GetURL()
 13508  }
 13509  
 13510  func TestProjectColumnChange_GetName(tt *testing.T) {
 13511  	p := &ProjectColumnChange{}
 13512  	p.GetName()
 13513  	p = nil
 13514  	p.GetName()
 13515  }
 13516  
 13517  func TestProjectColumnEvent_GetAction(tt *testing.T) {
 13518  	var zeroValue string
 13519  	p := &ProjectColumnEvent{Action: &zeroValue}
 13520  	p.GetAction()
 13521  	p = &ProjectColumnEvent{}
 13522  	p.GetAction()
 13523  	p = nil
 13524  	p.GetAction()
 13525  }
 13526  
 13527  func TestProjectColumnEvent_GetAfterID(tt *testing.T) {
 13528  	var zeroValue int64
 13529  	p := &ProjectColumnEvent{AfterID: &zeroValue}
 13530  	p.GetAfterID()
 13531  	p = &ProjectColumnEvent{}
 13532  	p.GetAfterID()
 13533  	p = nil
 13534  	p.GetAfterID()
 13535  }
 13536  
 13537  func TestProjectColumnEvent_GetChanges(tt *testing.T) {
 13538  	p := &ProjectColumnEvent{}
 13539  	p.GetChanges()
 13540  	p = nil
 13541  	p.GetChanges()
 13542  }
 13543  
 13544  func TestProjectColumnEvent_GetInstallation(tt *testing.T) {
 13545  	p := &ProjectColumnEvent{}
 13546  	p.GetInstallation()
 13547  	p = nil
 13548  	p.GetInstallation()
 13549  }
 13550  
 13551  func TestProjectColumnEvent_GetOrg(tt *testing.T) {
 13552  	p := &ProjectColumnEvent{}
 13553  	p.GetOrg()
 13554  	p = nil
 13555  	p.GetOrg()
 13556  }
 13557  
 13558  func TestProjectColumnEvent_GetProjectColumn(tt *testing.T) {
 13559  	p := &ProjectColumnEvent{}
 13560  	p.GetProjectColumn()
 13561  	p = nil
 13562  	p.GetProjectColumn()
 13563  }
 13564  
 13565  func TestProjectColumnEvent_GetRepo(tt *testing.T) {
 13566  	p := &ProjectColumnEvent{}
 13567  	p.GetRepo()
 13568  	p = nil
 13569  	p.GetRepo()
 13570  }
 13571  
 13572  func TestProjectColumnEvent_GetSender(tt *testing.T) {
 13573  	p := &ProjectColumnEvent{}
 13574  	p.GetSender()
 13575  	p = nil
 13576  	p.GetSender()
 13577  }
 13578  
 13579  func TestProjectColumnName_GetFrom(tt *testing.T) {
 13580  	var zeroValue string
 13581  	p := &ProjectColumnName{From: &zeroValue}
 13582  	p.GetFrom()
 13583  	p = &ProjectColumnName{}
 13584  	p.GetFrom()
 13585  	p = nil
 13586  	p.GetFrom()
 13587  }
 13588  
 13589  func TestProjectEvent_GetAction(tt *testing.T) {
 13590  	var zeroValue string
 13591  	p := &ProjectEvent{Action: &zeroValue}
 13592  	p.GetAction()
 13593  	p = &ProjectEvent{}
 13594  	p.GetAction()
 13595  	p = nil
 13596  	p.GetAction()
 13597  }
 13598  
 13599  func TestProjectEvent_GetChanges(tt *testing.T) {
 13600  	p := &ProjectEvent{}
 13601  	p.GetChanges()
 13602  	p = nil
 13603  	p.GetChanges()
 13604  }
 13605  
 13606  func TestProjectEvent_GetInstallation(tt *testing.T) {
 13607  	p := &ProjectEvent{}
 13608  	p.GetInstallation()
 13609  	p = nil
 13610  	p.GetInstallation()
 13611  }
 13612  
 13613  func TestProjectEvent_GetOrg(tt *testing.T) {
 13614  	p := &ProjectEvent{}
 13615  	p.GetOrg()
 13616  	p = nil
 13617  	p.GetOrg()
 13618  }
 13619  
 13620  func TestProjectEvent_GetProject(tt *testing.T) {
 13621  	p := &ProjectEvent{}
 13622  	p.GetProject()
 13623  	p = nil
 13624  	p.GetProject()
 13625  }
 13626  
 13627  func TestProjectEvent_GetRepo(tt *testing.T) {
 13628  	p := &ProjectEvent{}
 13629  	p.GetRepo()
 13630  	p = nil
 13631  	p.GetRepo()
 13632  }
 13633  
 13634  func TestProjectEvent_GetSender(tt *testing.T) {
 13635  	p := &ProjectEvent{}
 13636  	p.GetSender()
 13637  	p = nil
 13638  	p.GetSender()
 13639  }
 13640  
 13641  func TestProjectName_GetFrom(tt *testing.T) {
 13642  	var zeroValue string
 13643  	p := &ProjectName{From: &zeroValue}
 13644  	p.GetFrom()
 13645  	p = &ProjectName{}
 13646  	p.GetFrom()
 13647  	p = nil
 13648  	p.GetFrom()
 13649  }
 13650  
 13651  func TestProjectOptions_GetBody(tt *testing.T) {
 13652  	var zeroValue string
 13653  	p := &ProjectOptions{Body: &zeroValue}
 13654  	p.GetBody()
 13655  	p = &ProjectOptions{}
 13656  	p.GetBody()
 13657  	p = nil
 13658  	p.GetBody()
 13659  }
 13660  
 13661  func TestProjectOptions_GetName(tt *testing.T) {
 13662  	var zeroValue string
 13663  	p := &ProjectOptions{Name: &zeroValue}
 13664  	p.GetName()
 13665  	p = &ProjectOptions{}
 13666  	p.GetName()
 13667  	p = nil
 13668  	p.GetName()
 13669  }
 13670  
 13671  func TestProjectOptions_GetOrganizationPermission(tt *testing.T) {
 13672  	var zeroValue string
 13673  	p := &ProjectOptions{OrganizationPermission: &zeroValue}
 13674  	p.GetOrganizationPermission()
 13675  	p = &ProjectOptions{}
 13676  	p.GetOrganizationPermission()
 13677  	p = nil
 13678  	p.GetOrganizationPermission()
 13679  }
 13680  
 13681  func TestProjectOptions_GetPrivate(tt *testing.T) {
 13682  	var zeroValue bool
 13683  	p := &ProjectOptions{Private: &zeroValue}
 13684  	p.GetPrivate()
 13685  	p = &ProjectOptions{}
 13686  	p.GetPrivate()
 13687  	p = nil
 13688  	p.GetPrivate()
 13689  }
 13690  
 13691  func TestProjectOptions_GetState(tt *testing.T) {
 13692  	var zeroValue string
 13693  	p := &ProjectOptions{State: &zeroValue}
 13694  	p.GetState()
 13695  	p = &ProjectOptions{}
 13696  	p.GetState()
 13697  	p = nil
 13698  	p.GetState()
 13699  }
 13700  
 13701  func TestProjectPermissionLevel_GetPermission(tt *testing.T) {
 13702  	var zeroValue string
 13703  	p := &ProjectPermissionLevel{Permission: &zeroValue}
 13704  	p.GetPermission()
 13705  	p = &ProjectPermissionLevel{}
 13706  	p.GetPermission()
 13707  	p = nil
 13708  	p.GetPermission()
 13709  }
 13710  
 13711  func TestProjectPermissionLevel_GetUser(tt *testing.T) {
 13712  	p := &ProjectPermissionLevel{}
 13713  	p.GetUser()
 13714  	p = nil
 13715  	p.GetUser()
 13716  }
 13717  
 13718  func TestProtection_GetAllowDeletions(tt *testing.T) {
 13719  	p := &Protection{}
 13720  	p.GetAllowDeletions()
 13721  	p = nil
 13722  	p.GetAllowDeletions()
 13723  }
 13724  
 13725  func TestProtection_GetAllowForcePushes(tt *testing.T) {
 13726  	p := &Protection{}
 13727  	p.GetAllowForcePushes()
 13728  	p = nil
 13729  	p.GetAllowForcePushes()
 13730  }
 13731  
 13732  func TestProtection_GetEnforceAdmins(tt *testing.T) {
 13733  	p := &Protection{}
 13734  	p.GetEnforceAdmins()
 13735  	p = nil
 13736  	p.GetEnforceAdmins()
 13737  }
 13738  
 13739  func TestProtection_GetRequiredConversationResolution(tt *testing.T) {
 13740  	p := &Protection{}
 13741  	p.GetRequiredConversationResolution()
 13742  	p = nil
 13743  	p.GetRequiredConversationResolution()
 13744  }
 13745  
 13746  func TestProtection_GetRequiredPullRequestReviews(tt *testing.T) {
 13747  	p := &Protection{}
 13748  	p.GetRequiredPullRequestReviews()
 13749  	p = nil
 13750  	p.GetRequiredPullRequestReviews()
 13751  }
 13752  
 13753  func TestProtection_GetRequiredStatusChecks(tt *testing.T) {
 13754  	p := &Protection{}
 13755  	p.GetRequiredStatusChecks()
 13756  	p = nil
 13757  	p.GetRequiredStatusChecks()
 13758  }
 13759  
 13760  func TestProtection_GetRequireLinearHistory(tt *testing.T) {
 13761  	p := &Protection{}
 13762  	p.GetRequireLinearHistory()
 13763  	p = nil
 13764  	p.GetRequireLinearHistory()
 13765  }
 13766  
 13767  func TestProtection_GetRestrictions(tt *testing.T) {
 13768  	p := &Protection{}
 13769  	p.GetRestrictions()
 13770  	p = nil
 13771  	p.GetRestrictions()
 13772  }
 13773  
 13774  func TestProtectionChanges_GetAuthorizedActorNames(tt *testing.T) {
 13775  	p := &ProtectionChanges{}
 13776  	p.GetAuthorizedActorNames()
 13777  	p = nil
 13778  	p.GetAuthorizedActorNames()
 13779  }
 13780  
 13781  func TestProtectionChanges_GetAuthorizedActorsOnly(tt *testing.T) {
 13782  	p := &ProtectionChanges{}
 13783  	p.GetAuthorizedActorsOnly()
 13784  	p = nil
 13785  	p.GetAuthorizedActorsOnly()
 13786  }
 13787  
 13788  func TestProtectionRequest_GetAllowDeletions(tt *testing.T) {
 13789  	var zeroValue bool
 13790  	p := &ProtectionRequest{AllowDeletions: &zeroValue}
 13791  	p.GetAllowDeletions()
 13792  	p = &ProtectionRequest{}
 13793  	p.GetAllowDeletions()
 13794  	p = nil
 13795  	p.GetAllowDeletions()
 13796  }
 13797  
 13798  func TestProtectionRequest_GetAllowForcePushes(tt *testing.T) {
 13799  	var zeroValue bool
 13800  	p := &ProtectionRequest{AllowForcePushes: &zeroValue}
 13801  	p.GetAllowForcePushes()
 13802  	p = &ProtectionRequest{}
 13803  	p.GetAllowForcePushes()
 13804  	p = nil
 13805  	p.GetAllowForcePushes()
 13806  }
 13807  
 13808  func TestProtectionRequest_GetRequiredConversationResolution(tt *testing.T) {
 13809  	var zeroValue bool
 13810  	p := &ProtectionRequest{RequiredConversationResolution: &zeroValue}
 13811  	p.GetRequiredConversationResolution()
 13812  	p = &ProtectionRequest{}
 13813  	p.GetRequiredConversationResolution()
 13814  	p = nil
 13815  	p.GetRequiredConversationResolution()
 13816  }
 13817  
 13818  func TestProtectionRequest_GetRequiredPullRequestReviews(tt *testing.T) {
 13819  	p := &ProtectionRequest{}
 13820  	p.GetRequiredPullRequestReviews()
 13821  	p = nil
 13822  	p.GetRequiredPullRequestReviews()
 13823  }
 13824  
 13825  func TestProtectionRequest_GetRequiredStatusChecks(tt *testing.T) {
 13826  	p := &ProtectionRequest{}
 13827  	p.GetRequiredStatusChecks()
 13828  	p = nil
 13829  	p.GetRequiredStatusChecks()
 13830  }
 13831  
 13832  func TestProtectionRequest_GetRequireLinearHistory(tt *testing.T) {
 13833  	var zeroValue bool
 13834  	p := &ProtectionRequest{RequireLinearHistory: &zeroValue}
 13835  	p.GetRequireLinearHistory()
 13836  	p = &ProtectionRequest{}
 13837  	p.GetRequireLinearHistory()
 13838  	p = nil
 13839  	p.GetRequireLinearHistory()
 13840  }
 13841  
 13842  func TestProtectionRequest_GetRestrictions(tt *testing.T) {
 13843  	p := &ProtectionRequest{}
 13844  	p.GetRestrictions()
 13845  	p = nil
 13846  	p.GetRestrictions()
 13847  }
 13848  
 13849  func TestProtectionRule_GetID(tt *testing.T) {
 13850  	var zeroValue int64
 13851  	p := &ProtectionRule{ID: &zeroValue}
 13852  	p.GetID()
 13853  	p = &ProtectionRule{}
 13854  	p.GetID()
 13855  	p = nil
 13856  	p.GetID()
 13857  }
 13858  
 13859  func TestProtectionRule_GetNodeID(tt *testing.T) {
 13860  	var zeroValue string
 13861  	p := &ProtectionRule{NodeID: &zeroValue}
 13862  	p.GetNodeID()
 13863  	p = &ProtectionRule{}
 13864  	p.GetNodeID()
 13865  	p = nil
 13866  	p.GetNodeID()
 13867  }
 13868  
 13869  func TestProtectionRule_GetType(tt *testing.T) {
 13870  	var zeroValue string
 13871  	p := &ProtectionRule{Type: &zeroValue}
 13872  	p.GetType()
 13873  	p = &ProtectionRule{}
 13874  	p.GetType()
 13875  	p = nil
 13876  	p.GetType()
 13877  }
 13878  
 13879  func TestProtectionRule_GetWaitTimer(tt *testing.T) {
 13880  	var zeroValue int
 13881  	p := &ProtectionRule{WaitTimer: &zeroValue}
 13882  	p.GetWaitTimer()
 13883  	p = &ProtectionRule{}
 13884  	p.GetWaitTimer()
 13885  	p = nil
 13886  	p.GetWaitTimer()
 13887  }
 13888  
 13889  func TestPublicEvent_GetInstallation(tt *testing.T) {
 13890  	p := &PublicEvent{}
 13891  	p.GetInstallation()
 13892  	p = nil
 13893  	p.GetInstallation()
 13894  }
 13895  
 13896  func TestPublicEvent_GetRepo(tt *testing.T) {
 13897  	p := &PublicEvent{}
 13898  	p.GetRepo()
 13899  	p = nil
 13900  	p.GetRepo()
 13901  }
 13902  
 13903  func TestPublicEvent_GetSender(tt *testing.T) {
 13904  	p := &PublicEvent{}
 13905  	p.GetSender()
 13906  	p = nil
 13907  	p.GetSender()
 13908  }
 13909  
 13910  func TestPublicKey_GetKey(tt *testing.T) {
 13911  	var zeroValue string
 13912  	p := &PublicKey{Key: &zeroValue}
 13913  	p.GetKey()
 13914  	p = &PublicKey{}
 13915  	p.GetKey()
 13916  	p = nil
 13917  	p.GetKey()
 13918  }
 13919  
 13920  func TestPublicKey_GetKeyID(tt *testing.T) {
 13921  	var zeroValue string
 13922  	p := &PublicKey{KeyID: &zeroValue}
 13923  	p.GetKeyID()
 13924  	p = &PublicKey{}
 13925  	p.GetKeyID()
 13926  	p = nil
 13927  	p.GetKeyID()
 13928  }
 13929  
 13930  func TestPullRequest_GetActiveLockReason(tt *testing.T) {
 13931  	var zeroValue string
 13932  	p := &PullRequest{ActiveLockReason: &zeroValue}
 13933  	p.GetActiveLockReason()
 13934  	p = &PullRequest{}
 13935  	p.GetActiveLockReason()
 13936  	p = nil
 13937  	p.GetActiveLockReason()
 13938  }
 13939  
 13940  func TestPullRequest_GetAdditions(tt *testing.T) {
 13941  	var zeroValue int
 13942  	p := &PullRequest{Additions: &zeroValue}
 13943  	p.GetAdditions()
 13944  	p = &PullRequest{}
 13945  	p.GetAdditions()
 13946  	p = nil
 13947  	p.GetAdditions()
 13948  }
 13949  
 13950  func TestPullRequest_GetAssignee(tt *testing.T) {
 13951  	p := &PullRequest{}
 13952  	p.GetAssignee()
 13953  	p = nil
 13954  	p.GetAssignee()
 13955  }
 13956  
 13957  func TestPullRequest_GetAuthorAssociation(tt *testing.T) {
 13958  	var zeroValue string
 13959  	p := &PullRequest{AuthorAssociation: &zeroValue}
 13960  	p.GetAuthorAssociation()
 13961  	p = &PullRequest{}
 13962  	p.GetAuthorAssociation()
 13963  	p = nil
 13964  	p.GetAuthorAssociation()
 13965  }
 13966  
 13967  func TestPullRequest_GetAutoMerge(tt *testing.T) {
 13968  	p := &PullRequest{}
 13969  	p.GetAutoMerge()
 13970  	p = nil
 13971  	p.GetAutoMerge()
 13972  }
 13973  
 13974  func TestPullRequest_GetBase(tt *testing.T) {
 13975  	p := &PullRequest{}
 13976  	p.GetBase()
 13977  	p = nil
 13978  	p.GetBase()
 13979  }
 13980  
 13981  func TestPullRequest_GetBody(tt *testing.T) {
 13982  	var zeroValue string
 13983  	p := &PullRequest{Body: &zeroValue}
 13984  	p.GetBody()
 13985  	p = &PullRequest{}
 13986  	p.GetBody()
 13987  	p = nil
 13988  	p.GetBody()
 13989  }
 13990  
 13991  func TestPullRequest_GetChangedFiles(tt *testing.T) {
 13992  	var zeroValue int
 13993  	p := &PullRequest{ChangedFiles: &zeroValue}
 13994  	p.GetChangedFiles()
 13995  	p = &PullRequest{}
 13996  	p.GetChangedFiles()
 13997  	p = nil
 13998  	p.GetChangedFiles()
 13999  }
 14000  
 14001  func TestPullRequest_GetClosedAt(tt *testing.T) {
 14002  	var zeroValue time.Time
 14003  	p := &PullRequest{ClosedAt: &zeroValue}
 14004  	p.GetClosedAt()
 14005  	p = &PullRequest{}
 14006  	p.GetClosedAt()
 14007  	p = nil
 14008  	p.GetClosedAt()
 14009  }
 14010  
 14011  func TestPullRequest_GetComments(tt *testing.T) {
 14012  	var zeroValue int
 14013  	p := &PullRequest{Comments: &zeroValue}
 14014  	p.GetComments()
 14015  	p = &PullRequest{}
 14016  	p.GetComments()
 14017  	p = nil
 14018  	p.GetComments()
 14019  }
 14020  
 14021  func TestPullRequest_GetCommentsURL(tt *testing.T) {
 14022  	var zeroValue string
 14023  	p := &PullRequest{CommentsURL: &zeroValue}
 14024  	p.GetCommentsURL()
 14025  	p = &PullRequest{}
 14026  	p.GetCommentsURL()
 14027  	p = nil
 14028  	p.GetCommentsURL()
 14029  }
 14030  
 14031  func TestPullRequest_GetCommits(tt *testing.T) {
 14032  	var zeroValue int
 14033  	p := &PullRequest{Commits: &zeroValue}
 14034  	p.GetCommits()
 14035  	p = &PullRequest{}
 14036  	p.GetCommits()
 14037  	p = nil
 14038  	p.GetCommits()
 14039  }
 14040  
 14041  func TestPullRequest_GetCommitsURL(tt *testing.T) {
 14042  	var zeroValue string
 14043  	p := &PullRequest{CommitsURL: &zeroValue}
 14044  	p.GetCommitsURL()
 14045  	p = &PullRequest{}
 14046  	p.GetCommitsURL()
 14047  	p = nil
 14048  	p.GetCommitsURL()
 14049  }
 14050  
 14051  func TestPullRequest_GetCreatedAt(tt *testing.T) {
 14052  	var zeroValue time.Time
 14053  	p := &PullRequest{CreatedAt: &zeroValue}
 14054  	p.GetCreatedAt()
 14055  	p = &PullRequest{}
 14056  	p.GetCreatedAt()
 14057  	p = nil
 14058  	p.GetCreatedAt()
 14059  }
 14060  
 14061  func TestPullRequest_GetDeletions(tt *testing.T) {
 14062  	var zeroValue int
 14063  	p := &PullRequest{Deletions: &zeroValue}
 14064  	p.GetDeletions()
 14065  	p = &PullRequest{}
 14066  	p.GetDeletions()
 14067  	p = nil
 14068  	p.GetDeletions()
 14069  }
 14070  
 14071  func TestPullRequest_GetDiffURL(tt *testing.T) {
 14072  	var zeroValue string
 14073  	p := &PullRequest{DiffURL: &zeroValue}
 14074  	p.GetDiffURL()
 14075  	p = &PullRequest{}
 14076  	p.GetDiffURL()
 14077  	p = nil
 14078  	p.GetDiffURL()
 14079  }
 14080  
 14081  func TestPullRequest_GetDraft(tt *testing.T) {
 14082  	var zeroValue bool
 14083  	p := &PullRequest{Draft: &zeroValue}
 14084  	p.GetDraft()
 14085  	p = &PullRequest{}
 14086  	p.GetDraft()
 14087  	p = nil
 14088  	p.GetDraft()
 14089  }
 14090  
 14091  func TestPullRequest_GetHead(tt *testing.T) {
 14092  	p := &PullRequest{}
 14093  	p.GetHead()
 14094  	p = nil
 14095  	p.GetHead()
 14096  }
 14097  
 14098  func TestPullRequest_GetHTMLURL(tt *testing.T) {
 14099  	var zeroValue string
 14100  	p := &PullRequest{HTMLURL: &zeroValue}
 14101  	p.GetHTMLURL()
 14102  	p = &PullRequest{}
 14103  	p.GetHTMLURL()
 14104  	p = nil
 14105  	p.GetHTMLURL()
 14106  }
 14107  
 14108  func TestPullRequest_GetID(tt *testing.T) {
 14109  	var zeroValue int64
 14110  	p := &PullRequest{ID: &zeroValue}
 14111  	p.GetID()
 14112  	p = &PullRequest{}
 14113  	p.GetID()
 14114  	p = nil
 14115  	p.GetID()
 14116  }
 14117  
 14118  func TestPullRequest_GetIssueURL(tt *testing.T) {
 14119  	var zeroValue string
 14120  	p := &PullRequest{IssueURL: &zeroValue}
 14121  	p.GetIssueURL()
 14122  	p = &PullRequest{}
 14123  	p.GetIssueURL()
 14124  	p = nil
 14125  	p.GetIssueURL()
 14126  }
 14127  
 14128  func TestPullRequest_GetLinks(tt *testing.T) {
 14129  	p := &PullRequest{}
 14130  	p.GetLinks()
 14131  	p = nil
 14132  	p.GetLinks()
 14133  }
 14134  
 14135  func TestPullRequest_GetLocked(tt *testing.T) {
 14136  	var zeroValue bool
 14137  	p := &PullRequest{Locked: &zeroValue}
 14138  	p.GetLocked()
 14139  	p = &PullRequest{}
 14140  	p.GetLocked()
 14141  	p = nil
 14142  	p.GetLocked()
 14143  }
 14144  
 14145  func TestPullRequest_GetMaintainerCanModify(tt *testing.T) {
 14146  	var zeroValue bool
 14147  	p := &PullRequest{MaintainerCanModify: &zeroValue}
 14148  	p.GetMaintainerCanModify()
 14149  	p = &PullRequest{}
 14150  	p.GetMaintainerCanModify()
 14151  	p = nil
 14152  	p.GetMaintainerCanModify()
 14153  }
 14154  
 14155  func TestPullRequest_GetMergeable(tt *testing.T) {
 14156  	var zeroValue bool
 14157  	p := &PullRequest{Mergeable: &zeroValue}
 14158  	p.GetMergeable()
 14159  	p = &PullRequest{}
 14160  	p.GetMergeable()
 14161  	p = nil
 14162  	p.GetMergeable()
 14163  }
 14164  
 14165  func TestPullRequest_GetMergeableState(tt *testing.T) {
 14166  	var zeroValue string
 14167  	p := &PullRequest{MergeableState: &zeroValue}
 14168  	p.GetMergeableState()
 14169  	p = &PullRequest{}
 14170  	p.GetMergeableState()
 14171  	p = nil
 14172  	p.GetMergeableState()
 14173  }
 14174  
 14175  func TestPullRequest_GetMergeCommitSHA(tt *testing.T) {
 14176  	var zeroValue string
 14177  	p := &PullRequest{MergeCommitSHA: &zeroValue}
 14178  	p.GetMergeCommitSHA()
 14179  	p = &PullRequest{}
 14180  	p.GetMergeCommitSHA()
 14181  	p = nil
 14182  	p.GetMergeCommitSHA()
 14183  }
 14184  
 14185  func TestPullRequest_GetMerged(tt *testing.T) {
 14186  	var zeroValue bool
 14187  	p := &PullRequest{Merged: &zeroValue}
 14188  	p.GetMerged()
 14189  	p = &PullRequest{}
 14190  	p.GetMerged()
 14191  	p = nil
 14192  	p.GetMerged()
 14193  }
 14194  
 14195  func TestPullRequest_GetMergedAt(tt *testing.T) {
 14196  	var zeroValue time.Time
 14197  	p := &PullRequest{MergedAt: &zeroValue}
 14198  	p.GetMergedAt()
 14199  	p = &PullRequest{}
 14200  	p.GetMergedAt()
 14201  	p = nil
 14202  	p.GetMergedAt()
 14203  }
 14204  
 14205  func TestPullRequest_GetMergedBy(tt *testing.T) {
 14206  	p := &PullRequest{}
 14207  	p.GetMergedBy()
 14208  	p = nil
 14209  	p.GetMergedBy()
 14210  }
 14211  
 14212  func TestPullRequest_GetMilestone(tt *testing.T) {
 14213  	p := &PullRequest{}
 14214  	p.GetMilestone()
 14215  	p = nil
 14216  	p.GetMilestone()
 14217  }
 14218  
 14219  func TestPullRequest_GetNodeID(tt *testing.T) {
 14220  	var zeroValue string
 14221  	p := &PullRequest{NodeID: &zeroValue}
 14222  	p.GetNodeID()
 14223  	p = &PullRequest{}
 14224  	p.GetNodeID()
 14225  	p = nil
 14226  	p.GetNodeID()
 14227  }
 14228  
 14229  func TestPullRequest_GetNumber(tt *testing.T) {
 14230  	var zeroValue int
 14231  	p := &PullRequest{Number: &zeroValue}
 14232  	p.GetNumber()
 14233  	p = &PullRequest{}
 14234  	p.GetNumber()
 14235  	p = nil
 14236  	p.GetNumber()
 14237  }
 14238  
 14239  func TestPullRequest_GetPatchURL(tt *testing.T) {
 14240  	var zeroValue string
 14241  	p := &PullRequest{PatchURL: &zeroValue}
 14242  	p.GetPatchURL()
 14243  	p = &PullRequest{}
 14244  	p.GetPatchURL()
 14245  	p = nil
 14246  	p.GetPatchURL()
 14247  }
 14248  
 14249  func TestPullRequest_GetRebaseable(tt *testing.T) {
 14250  	var zeroValue bool
 14251  	p := &PullRequest{Rebaseable: &zeroValue}
 14252  	p.GetRebaseable()
 14253  	p = &PullRequest{}
 14254  	p.GetRebaseable()
 14255  	p = nil
 14256  	p.GetRebaseable()
 14257  }
 14258  
 14259  func TestPullRequest_GetReviewComments(tt *testing.T) {
 14260  	var zeroValue int
 14261  	p := &PullRequest{ReviewComments: &zeroValue}
 14262  	p.GetReviewComments()
 14263  	p = &PullRequest{}
 14264  	p.GetReviewComments()
 14265  	p = nil
 14266  	p.GetReviewComments()
 14267  }
 14268  
 14269  func TestPullRequest_GetReviewCommentsURL(tt *testing.T) {
 14270  	var zeroValue string
 14271  	p := &PullRequest{ReviewCommentsURL: &zeroValue}
 14272  	p.GetReviewCommentsURL()
 14273  	p = &PullRequest{}
 14274  	p.GetReviewCommentsURL()
 14275  	p = nil
 14276  	p.GetReviewCommentsURL()
 14277  }
 14278  
 14279  func TestPullRequest_GetReviewCommentURL(tt *testing.T) {
 14280  	var zeroValue string
 14281  	p := &PullRequest{ReviewCommentURL: &zeroValue}
 14282  	p.GetReviewCommentURL()
 14283  	p = &PullRequest{}
 14284  	p.GetReviewCommentURL()
 14285  	p = nil
 14286  	p.GetReviewCommentURL()
 14287  }
 14288  
 14289  func TestPullRequest_GetState(tt *testing.T) {
 14290  	var zeroValue string
 14291  	p := &PullRequest{State: &zeroValue}
 14292  	p.GetState()
 14293  	p = &PullRequest{}
 14294  	p.GetState()
 14295  	p = nil
 14296  	p.GetState()
 14297  }
 14298  
 14299  func TestPullRequest_GetStatusesURL(tt *testing.T) {
 14300  	var zeroValue string
 14301  	p := &PullRequest{StatusesURL: &zeroValue}
 14302  	p.GetStatusesURL()
 14303  	p = &PullRequest{}
 14304  	p.GetStatusesURL()
 14305  	p = nil
 14306  	p.GetStatusesURL()
 14307  }
 14308  
 14309  func TestPullRequest_GetTitle(tt *testing.T) {
 14310  	var zeroValue string
 14311  	p := &PullRequest{Title: &zeroValue}
 14312  	p.GetTitle()
 14313  	p = &PullRequest{}
 14314  	p.GetTitle()
 14315  	p = nil
 14316  	p.GetTitle()
 14317  }
 14318  
 14319  func TestPullRequest_GetUpdatedAt(tt *testing.T) {
 14320  	var zeroValue time.Time
 14321  	p := &PullRequest{UpdatedAt: &zeroValue}
 14322  	p.GetUpdatedAt()
 14323  	p = &PullRequest{}
 14324  	p.GetUpdatedAt()
 14325  	p = nil
 14326  	p.GetUpdatedAt()
 14327  }
 14328  
 14329  func TestPullRequest_GetURL(tt *testing.T) {
 14330  	var zeroValue string
 14331  	p := &PullRequest{URL: &zeroValue}
 14332  	p.GetURL()
 14333  	p = &PullRequest{}
 14334  	p.GetURL()
 14335  	p = nil
 14336  	p.GetURL()
 14337  }
 14338  
 14339  func TestPullRequest_GetUser(tt *testing.T) {
 14340  	p := &PullRequest{}
 14341  	p.GetUser()
 14342  	p = nil
 14343  	p.GetUser()
 14344  }
 14345  
 14346  func TestPullRequestAutoMerge_GetCommitMessage(tt *testing.T) {
 14347  	var zeroValue string
 14348  	p := &PullRequestAutoMerge{CommitMessage: &zeroValue}
 14349  	p.GetCommitMessage()
 14350  	p = &PullRequestAutoMerge{}
 14351  	p.GetCommitMessage()
 14352  	p = nil
 14353  	p.GetCommitMessage()
 14354  }
 14355  
 14356  func TestPullRequestAutoMerge_GetCommitTitle(tt *testing.T) {
 14357  	var zeroValue string
 14358  	p := &PullRequestAutoMerge{CommitTitle: &zeroValue}
 14359  	p.GetCommitTitle()
 14360  	p = &PullRequestAutoMerge{}
 14361  	p.GetCommitTitle()
 14362  	p = nil
 14363  	p.GetCommitTitle()
 14364  }
 14365  
 14366  func TestPullRequestAutoMerge_GetEnabledBy(tt *testing.T) {
 14367  	p := &PullRequestAutoMerge{}
 14368  	p.GetEnabledBy()
 14369  	p = nil
 14370  	p.GetEnabledBy()
 14371  }
 14372  
 14373  func TestPullRequestAutoMerge_GetMergeMethod(tt *testing.T) {
 14374  	var zeroValue string
 14375  	p := &PullRequestAutoMerge{MergeMethod: &zeroValue}
 14376  	p.GetMergeMethod()
 14377  	p = &PullRequestAutoMerge{}
 14378  	p.GetMergeMethod()
 14379  	p = nil
 14380  	p.GetMergeMethod()
 14381  }
 14382  
 14383  func TestPullRequestBranch_GetLabel(tt *testing.T) {
 14384  	var zeroValue string
 14385  	p := &PullRequestBranch{Label: &zeroValue}
 14386  	p.GetLabel()
 14387  	p = &PullRequestBranch{}
 14388  	p.GetLabel()
 14389  	p = nil
 14390  	p.GetLabel()
 14391  }
 14392  
 14393  func TestPullRequestBranch_GetRef(tt *testing.T) {
 14394  	var zeroValue string
 14395  	p := &PullRequestBranch{Ref: &zeroValue}
 14396  	p.GetRef()
 14397  	p = &PullRequestBranch{}
 14398  	p.GetRef()
 14399  	p = nil
 14400  	p.GetRef()
 14401  }
 14402  
 14403  func TestPullRequestBranch_GetRepo(tt *testing.T) {
 14404  	p := &PullRequestBranch{}
 14405  	p.GetRepo()
 14406  	p = nil
 14407  	p.GetRepo()
 14408  }
 14409  
 14410  func TestPullRequestBranch_GetSHA(tt *testing.T) {
 14411  	var zeroValue string
 14412  	p := &PullRequestBranch{SHA: &zeroValue}
 14413  	p.GetSHA()
 14414  	p = &PullRequestBranch{}
 14415  	p.GetSHA()
 14416  	p = nil
 14417  	p.GetSHA()
 14418  }
 14419  
 14420  func TestPullRequestBranch_GetUser(tt *testing.T) {
 14421  	p := &PullRequestBranch{}
 14422  	p.GetUser()
 14423  	p = nil
 14424  	p.GetUser()
 14425  }
 14426  
 14427  func TestPullRequestBranchUpdateOptions_GetExpectedHeadSHA(tt *testing.T) {
 14428  	var zeroValue string
 14429  	p := &PullRequestBranchUpdateOptions{ExpectedHeadSHA: &zeroValue}
 14430  	p.GetExpectedHeadSHA()
 14431  	p = &PullRequestBranchUpdateOptions{}
 14432  	p.GetExpectedHeadSHA()
 14433  	p = nil
 14434  	p.GetExpectedHeadSHA()
 14435  }
 14436  
 14437  func TestPullRequestBranchUpdateResponse_GetMessage(tt *testing.T) {
 14438  	var zeroValue string
 14439  	p := &PullRequestBranchUpdateResponse{Message: &zeroValue}
 14440  	p.GetMessage()
 14441  	p = &PullRequestBranchUpdateResponse{}
 14442  	p.GetMessage()
 14443  	p = nil
 14444  	p.GetMessage()
 14445  }
 14446  
 14447  func TestPullRequestBranchUpdateResponse_GetURL(tt *testing.T) {
 14448  	var zeroValue string
 14449  	p := &PullRequestBranchUpdateResponse{URL: &zeroValue}
 14450  	p.GetURL()
 14451  	p = &PullRequestBranchUpdateResponse{}
 14452  	p.GetURL()
 14453  	p = nil
 14454  	p.GetURL()
 14455  }
 14456  
 14457  func TestPullRequestComment_GetAuthorAssociation(tt *testing.T) {
 14458  	var zeroValue string
 14459  	p := &PullRequestComment{AuthorAssociation: &zeroValue}
 14460  	p.GetAuthorAssociation()
 14461  	p = &PullRequestComment{}
 14462  	p.GetAuthorAssociation()
 14463  	p = nil
 14464  	p.GetAuthorAssociation()
 14465  }
 14466  
 14467  func TestPullRequestComment_GetBody(tt *testing.T) {
 14468  	var zeroValue string
 14469  	p := &PullRequestComment{Body: &zeroValue}
 14470  	p.GetBody()
 14471  	p = &PullRequestComment{}
 14472  	p.GetBody()
 14473  	p = nil
 14474  	p.GetBody()
 14475  }
 14476  
 14477  func TestPullRequestComment_GetCommitID(tt *testing.T) {
 14478  	var zeroValue string
 14479  	p := &PullRequestComment{CommitID: &zeroValue}
 14480  	p.GetCommitID()
 14481  	p = &PullRequestComment{}
 14482  	p.GetCommitID()
 14483  	p = nil
 14484  	p.GetCommitID()
 14485  }
 14486  
 14487  func TestPullRequestComment_GetCreatedAt(tt *testing.T) {
 14488  	var zeroValue time.Time
 14489  	p := &PullRequestComment{CreatedAt: &zeroValue}
 14490  	p.GetCreatedAt()
 14491  	p = &PullRequestComment{}
 14492  	p.GetCreatedAt()
 14493  	p = nil
 14494  	p.GetCreatedAt()
 14495  }
 14496  
 14497  func TestPullRequestComment_GetDiffHunk(tt *testing.T) {
 14498  	var zeroValue string
 14499  	p := &PullRequestComment{DiffHunk: &zeroValue}
 14500  	p.GetDiffHunk()
 14501  	p = &PullRequestComment{}
 14502  	p.GetDiffHunk()
 14503  	p = nil
 14504  	p.GetDiffHunk()
 14505  }
 14506  
 14507  func TestPullRequestComment_GetHTMLURL(tt *testing.T) {
 14508  	var zeroValue string
 14509  	p := &PullRequestComment{HTMLURL: &zeroValue}
 14510  	p.GetHTMLURL()
 14511  	p = &PullRequestComment{}
 14512  	p.GetHTMLURL()
 14513  	p = nil
 14514  	p.GetHTMLURL()
 14515  }
 14516  
 14517  func TestPullRequestComment_GetID(tt *testing.T) {
 14518  	var zeroValue int64
 14519  	p := &PullRequestComment{ID: &zeroValue}
 14520  	p.GetID()
 14521  	p = &PullRequestComment{}
 14522  	p.GetID()
 14523  	p = nil
 14524  	p.GetID()
 14525  }
 14526  
 14527  func TestPullRequestComment_GetInReplyTo(tt *testing.T) {
 14528  	var zeroValue int64
 14529  	p := &PullRequestComment{InReplyTo: &zeroValue}
 14530  	p.GetInReplyTo()
 14531  	p = &PullRequestComment{}
 14532  	p.GetInReplyTo()
 14533  	p = nil
 14534  	p.GetInReplyTo()
 14535  }
 14536  
 14537  func TestPullRequestComment_GetLine(tt *testing.T) {
 14538  	var zeroValue int
 14539  	p := &PullRequestComment{Line: &zeroValue}
 14540  	p.GetLine()
 14541  	p = &PullRequestComment{}
 14542  	p.GetLine()
 14543  	p = nil
 14544  	p.GetLine()
 14545  }
 14546  
 14547  func TestPullRequestComment_GetNodeID(tt *testing.T) {
 14548  	var zeroValue string
 14549  	p := &PullRequestComment{NodeID: &zeroValue}
 14550  	p.GetNodeID()
 14551  	p = &PullRequestComment{}
 14552  	p.GetNodeID()
 14553  	p = nil
 14554  	p.GetNodeID()
 14555  }
 14556  
 14557  func TestPullRequestComment_GetOriginalCommitID(tt *testing.T) {
 14558  	var zeroValue string
 14559  	p := &PullRequestComment{OriginalCommitID: &zeroValue}
 14560  	p.GetOriginalCommitID()
 14561  	p = &PullRequestComment{}
 14562  	p.GetOriginalCommitID()
 14563  	p = nil
 14564  	p.GetOriginalCommitID()
 14565  }
 14566  
 14567  func TestPullRequestComment_GetOriginalLine(tt *testing.T) {
 14568  	var zeroValue int
 14569  	p := &PullRequestComment{OriginalLine: &zeroValue}
 14570  	p.GetOriginalLine()
 14571  	p = &PullRequestComment{}
 14572  	p.GetOriginalLine()
 14573  	p = nil
 14574  	p.GetOriginalLine()
 14575  }
 14576  
 14577  func TestPullRequestComment_GetOriginalPosition(tt *testing.T) {
 14578  	var zeroValue int
 14579  	p := &PullRequestComment{OriginalPosition: &zeroValue}
 14580  	p.GetOriginalPosition()
 14581  	p = &PullRequestComment{}
 14582  	p.GetOriginalPosition()
 14583  	p = nil
 14584  	p.GetOriginalPosition()
 14585  }
 14586  
 14587  func TestPullRequestComment_GetOriginalStartLine(tt *testing.T) {
 14588  	var zeroValue int
 14589  	p := &PullRequestComment{OriginalStartLine: &zeroValue}
 14590  	p.GetOriginalStartLine()
 14591  	p = &PullRequestComment{}
 14592  	p.GetOriginalStartLine()
 14593  	p = nil
 14594  	p.GetOriginalStartLine()
 14595  }
 14596  
 14597  func TestPullRequestComment_GetPath(tt *testing.T) {
 14598  	var zeroValue string
 14599  	p := &PullRequestComment{Path: &zeroValue}
 14600  	p.GetPath()
 14601  	p = &PullRequestComment{}
 14602  	p.GetPath()
 14603  	p = nil
 14604  	p.GetPath()
 14605  }
 14606  
 14607  func TestPullRequestComment_GetPosition(tt *testing.T) {
 14608  	var zeroValue int
 14609  	p := &PullRequestComment{Position: &zeroValue}
 14610  	p.GetPosition()
 14611  	p = &PullRequestComment{}
 14612  	p.GetPosition()
 14613  	p = nil
 14614  	p.GetPosition()
 14615  }
 14616  
 14617  func TestPullRequestComment_GetPullRequestReviewID(tt *testing.T) {
 14618  	var zeroValue int64
 14619  	p := &PullRequestComment{PullRequestReviewID: &zeroValue}
 14620  	p.GetPullRequestReviewID()
 14621  	p = &PullRequestComment{}
 14622  	p.GetPullRequestReviewID()
 14623  	p = nil
 14624  	p.GetPullRequestReviewID()
 14625  }
 14626  
 14627  func TestPullRequestComment_GetPullRequestURL(tt *testing.T) {
 14628  	var zeroValue string
 14629  	p := &PullRequestComment{PullRequestURL: &zeroValue}
 14630  	p.GetPullRequestURL()
 14631  	p = &PullRequestComment{}
 14632  	p.GetPullRequestURL()
 14633  	p = nil
 14634  	p.GetPullRequestURL()
 14635  }
 14636  
 14637  func TestPullRequestComment_GetReactions(tt *testing.T) {
 14638  	p := &PullRequestComment{}
 14639  	p.GetReactions()
 14640  	p = nil
 14641  	p.GetReactions()
 14642  }
 14643  
 14644  func TestPullRequestComment_GetSide(tt *testing.T) {
 14645  	var zeroValue string
 14646  	p := &PullRequestComment{Side: &zeroValue}
 14647  	p.GetSide()
 14648  	p = &PullRequestComment{}
 14649  	p.GetSide()
 14650  	p = nil
 14651  	p.GetSide()
 14652  }
 14653  
 14654  func TestPullRequestComment_GetStartLine(tt *testing.T) {
 14655  	var zeroValue int
 14656  	p := &PullRequestComment{StartLine: &zeroValue}
 14657  	p.GetStartLine()
 14658  	p = &PullRequestComment{}
 14659  	p.GetStartLine()
 14660  	p = nil
 14661  	p.GetStartLine()
 14662  }
 14663  
 14664  func TestPullRequestComment_GetStartSide(tt *testing.T) {
 14665  	var zeroValue string
 14666  	p := &PullRequestComment{StartSide: &zeroValue}
 14667  	p.GetStartSide()
 14668  	p = &PullRequestComment{}
 14669  	p.GetStartSide()
 14670  	p = nil
 14671  	p.GetStartSide()
 14672  }
 14673  
 14674  func TestPullRequestComment_GetUpdatedAt(tt *testing.T) {
 14675  	var zeroValue time.Time
 14676  	p := &PullRequestComment{UpdatedAt: &zeroValue}
 14677  	p.GetUpdatedAt()
 14678  	p = &PullRequestComment{}
 14679  	p.GetUpdatedAt()
 14680  	p = nil
 14681  	p.GetUpdatedAt()
 14682  }
 14683  
 14684  func TestPullRequestComment_GetURL(tt *testing.T) {
 14685  	var zeroValue string
 14686  	p := &PullRequestComment{URL: &zeroValue}
 14687  	p.GetURL()
 14688  	p = &PullRequestComment{}
 14689  	p.GetURL()
 14690  	p = nil
 14691  	p.GetURL()
 14692  }
 14693  
 14694  func TestPullRequestComment_GetUser(tt *testing.T) {
 14695  	p := &PullRequestComment{}
 14696  	p.GetUser()
 14697  	p = nil
 14698  	p.GetUser()
 14699  }
 14700  
 14701  func TestPullRequestEvent_GetAction(tt *testing.T) {
 14702  	var zeroValue string
 14703  	p := &PullRequestEvent{Action: &zeroValue}
 14704  	p.GetAction()
 14705  	p = &PullRequestEvent{}
 14706  	p.GetAction()
 14707  	p = nil
 14708  	p.GetAction()
 14709  }
 14710  
 14711  func TestPullRequestEvent_GetAfter(tt *testing.T) {
 14712  	var zeroValue string
 14713  	p := &PullRequestEvent{After: &zeroValue}
 14714  	p.GetAfter()
 14715  	p = &PullRequestEvent{}
 14716  	p.GetAfter()
 14717  	p = nil
 14718  	p.GetAfter()
 14719  }
 14720  
 14721  func TestPullRequestEvent_GetAssignee(tt *testing.T) {
 14722  	p := &PullRequestEvent{}
 14723  	p.GetAssignee()
 14724  	p = nil
 14725  	p.GetAssignee()
 14726  }
 14727  
 14728  func TestPullRequestEvent_GetBefore(tt *testing.T) {
 14729  	var zeroValue string
 14730  	p := &PullRequestEvent{Before: &zeroValue}
 14731  	p.GetBefore()
 14732  	p = &PullRequestEvent{}
 14733  	p.GetBefore()
 14734  	p = nil
 14735  	p.GetBefore()
 14736  }
 14737  
 14738  func TestPullRequestEvent_GetChanges(tt *testing.T) {
 14739  	p := &PullRequestEvent{}
 14740  	p.GetChanges()
 14741  	p = nil
 14742  	p.GetChanges()
 14743  }
 14744  
 14745  func TestPullRequestEvent_GetInstallation(tt *testing.T) {
 14746  	p := &PullRequestEvent{}
 14747  	p.GetInstallation()
 14748  	p = nil
 14749  	p.GetInstallation()
 14750  }
 14751  
 14752  func TestPullRequestEvent_GetLabel(tt *testing.T) {
 14753  	p := &PullRequestEvent{}
 14754  	p.GetLabel()
 14755  	p = nil
 14756  	p.GetLabel()
 14757  }
 14758  
 14759  func TestPullRequestEvent_GetNumber(tt *testing.T) {
 14760  	var zeroValue int
 14761  	p := &PullRequestEvent{Number: &zeroValue}
 14762  	p.GetNumber()
 14763  	p = &PullRequestEvent{}
 14764  	p.GetNumber()
 14765  	p = nil
 14766  	p.GetNumber()
 14767  }
 14768  
 14769  func TestPullRequestEvent_GetOrganization(tt *testing.T) {
 14770  	p := &PullRequestEvent{}
 14771  	p.GetOrganization()
 14772  	p = nil
 14773  	p.GetOrganization()
 14774  }
 14775  
 14776  func TestPullRequestEvent_GetPullRequest(tt *testing.T) {
 14777  	p := &PullRequestEvent{}
 14778  	p.GetPullRequest()
 14779  	p = nil
 14780  	p.GetPullRequest()
 14781  }
 14782  
 14783  func TestPullRequestEvent_GetRepo(tt *testing.T) {
 14784  	p := &PullRequestEvent{}
 14785  	p.GetRepo()
 14786  	p = nil
 14787  	p.GetRepo()
 14788  }
 14789  
 14790  func TestPullRequestEvent_GetRequestedReviewer(tt *testing.T) {
 14791  	p := &PullRequestEvent{}
 14792  	p.GetRequestedReviewer()
 14793  	p = nil
 14794  	p.GetRequestedReviewer()
 14795  }
 14796  
 14797  func TestPullRequestEvent_GetRequestedTeam(tt *testing.T) {
 14798  	p := &PullRequestEvent{}
 14799  	p.GetRequestedTeam()
 14800  	p = nil
 14801  	p.GetRequestedTeam()
 14802  }
 14803  
 14804  func TestPullRequestEvent_GetSender(tt *testing.T) {
 14805  	p := &PullRequestEvent{}
 14806  	p.GetSender()
 14807  	p = nil
 14808  	p.GetSender()
 14809  }
 14810  
 14811  func TestPullRequestLinks_GetDiffURL(tt *testing.T) {
 14812  	var zeroValue string
 14813  	p := &PullRequestLinks{DiffURL: &zeroValue}
 14814  	p.GetDiffURL()
 14815  	p = &PullRequestLinks{}
 14816  	p.GetDiffURL()
 14817  	p = nil
 14818  	p.GetDiffURL()
 14819  }
 14820  
 14821  func TestPullRequestLinks_GetHTMLURL(tt *testing.T) {
 14822  	var zeroValue string
 14823  	p := &PullRequestLinks{HTMLURL: &zeroValue}
 14824  	p.GetHTMLURL()
 14825  	p = &PullRequestLinks{}
 14826  	p.GetHTMLURL()
 14827  	p = nil
 14828  	p.GetHTMLURL()
 14829  }
 14830  
 14831  func TestPullRequestLinks_GetPatchURL(tt *testing.T) {
 14832  	var zeroValue string
 14833  	p := &PullRequestLinks{PatchURL: &zeroValue}
 14834  	p.GetPatchURL()
 14835  	p = &PullRequestLinks{}
 14836  	p.GetPatchURL()
 14837  	p = nil
 14838  	p.GetPatchURL()
 14839  }
 14840  
 14841  func TestPullRequestLinks_GetURL(tt *testing.T) {
 14842  	var zeroValue string
 14843  	p := &PullRequestLinks{URL: &zeroValue}
 14844  	p.GetURL()
 14845  	p = &PullRequestLinks{}
 14846  	p.GetURL()
 14847  	p = nil
 14848  	p.GetURL()
 14849  }
 14850  
 14851  func TestPullRequestMergeResult_GetMerged(tt *testing.T) {
 14852  	var zeroValue bool
 14853  	p := &PullRequestMergeResult{Merged: &zeroValue}
 14854  	p.GetMerged()
 14855  	p = &PullRequestMergeResult{}
 14856  	p.GetMerged()
 14857  	p = nil
 14858  	p.GetMerged()
 14859  }
 14860  
 14861  func TestPullRequestMergeResult_GetMessage(tt *testing.T) {
 14862  	var zeroValue string
 14863  	p := &PullRequestMergeResult{Message: &zeroValue}
 14864  	p.GetMessage()
 14865  	p = &PullRequestMergeResult{}
 14866  	p.GetMessage()
 14867  	p = nil
 14868  	p.GetMessage()
 14869  }
 14870  
 14871  func TestPullRequestMergeResult_GetSHA(tt *testing.T) {
 14872  	var zeroValue string
 14873  	p := &PullRequestMergeResult{SHA: &zeroValue}
 14874  	p.GetSHA()
 14875  	p = &PullRequestMergeResult{}
 14876  	p.GetSHA()
 14877  	p = nil
 14878  	p.GetSHA()
 14879  }
 14880  
 14881  func TestPullRequestReview_GetAuthorAssociation(tt *testing.T) {
 14882  	var zeroValue string
 14883  	p := &PullRequestReview{AuthorAssociation: &zeroValue}
 14884  	p.GetAuthorAssociation()
 14885  	p = &PullRequestReview{}
 14886  	p.GetAuthorAssociation()
 14887  	p = nil
 14888  	p.GetAuthorAssociation()
 14889  }
 14890  
 14891  func TestPullRequestReview_GetBody(tt *testing.T) {
 14892  	var zeroValue string
 14893  	p := &PullRequestReview{Body: &zeroValue}
 14894  	p.GetBody()
 14895  	p = &PullRequestReview{}
 14896  	p.GetBody()
 14897  	p = nil
 14898  	p.GetBody()
 14899  }
 14900  
 14901  func TestPullRequestReview_GetCommitID(tt *testing.T) {
 14902  	var zeroValue string
 14903  	p := &PullRequestReview{CommitID: &zeroValue}
 14904  	p.GetCommitID()
 14905  	p = &PullRequestReview{}
 14906  	p.GetCommitID()
 14907  	p = nil
 14908  	p.GetCommitID()
 14909  }
 14910  
 14911  func TestPullRequestReview_GetHTMLURL(tt *testing.T) {
 14912  	var zeroValue string
 14913  	p := &PullRequestReview{HTMLURL: &zeroValue}
 14914  	p.GetHTMLURL()
 14915  	p = &PullRequestReview{}
 14916  	p.GetHTMLURL()
 14917  	p = nil
 14918  	p.GetHTMLURL()
 14919  }
 14920  
 14921  func TestPullRequestReview_GetID(tt *testing.T) {
 14922  	var zeroValue int64
 14923  	p := &PullRequestReview{ID: &zeroValue}
 14924  	p.GetID()
 14925  	p = &PullRequestReview{}
 14926  	p.GetID()
 14927  	p = nil
 14928  	p.GetID()
 14929  }
 14930  
 14931  func TestPullRequestReview_GetNodeID(tt *testing.T) {
 14932  	var zeroValue string
 14933  	p := &PullRequestReview{NodeID: &zeroValue}
 14934  	p.GetNodeID()
 14935  	p = &PullRequestReview{}
 14936  	p.GetNodeID()
 14937  	p = nil
 14938  	p.GetNodeID()
 14939  }
 14940  
 14941  func TestPullRequestReview_GetPullRequestURL(tt *testing.T) {
 14942  	var zeroValue string
 14943  	p := &PullRequestReview{PullRequestURL: &zeroValue}
 14944  	p.GetPullRequestURL()
 14945  	p = &PullRequestReview{}
 14946  	p.GetPullRequestURL()
 14947  	p = nil
 14948  	p.GetPullRequestURL()
 14949  }
 14950  
 14951  func TestPullRequestReview_GetState(tt *testing.T) {
 14952  	var zeroValue string
 14953  	p := &PullRequestReview{State: &zeroValue}
 14954  	p.GetState()
 14955  	p = &PullRequestReview{}
 14956  	p.GetState()
 14957  	p = nil
 14958  	p.GetState()
 14959  }
 14960  
 14961  func TestPullRequestReview_GetSubmittedAt(tt *testing.T) {
 14962  	var zeroValue time.Time
 14963  	p := &PullRequestReview{SubmittedAt: &zeroValue}
 14964  	p.GetSubmittedAt()
 14965  	p = &PullRequestReview{}
 14966  	p.GetSubmittedAt()
 14967  	p = nil
 14968  	p.GetSubmittedAt()
 14969  }
 14970  
 14971  func TestPullRequestReview_GetUser(tt *testing.T) {
 14972  	p := &PullRequestReview{}
 14973  	p.GetUser()
 14974  	p = nil
 14975  	p.GetUser()
 14976  }
 14977  
 14978  func TestPullRequestReviewCommentEvent_GetAction(tt *testing.T) {
 14979  	var zeroValue string
 14980  	p := &PullRequestReviewCommentEvent{Action: &zeroValue}
 14981  	p.GetAction()
 14982  	p = &PullRequestReviewCommentEvent{}
 14983  	p.GetAction()
 14984  	p = nil
 14985  	p.GetAction()
 14986  }
 14987  
 14988  func TestPullRequestReviewCommentEvent_GetChanges(tt *testing.T) {
 14989  	p := &PullRequestReviewCommentEvent{}
 14990  	p.GetChanges()
 14991  	p = nil
 14992  	p.GetChanges()
 14993  }
 14994  
 14995  func TestPullRequestReviewCommentEvent_GetComment(tt *testing.T) {
 14996  	p := &PullRequestReviewCommentEvent{}
 14997  	p.GetComment()
 14998  	p = nil
 14999  	p.GetComment()
 15000  }
 15001  
 15002  func TestPullRequestReviewCommentEvent_GetInstallation(tt *testing.T) {
 15003  	p := &PullRequestReviewCommentEvent{}
 15004  	p.GetInstallation()
 15005  	p = nil
 15006  	p.GetInstallation()
 15007  }
 15008  
 15009  func TestPullRequestReviewCommentEvent_GetPullRequest(tt *testing.T) {
 15010  	p := &PullRequestReviewCommentEvent{}
 15011  	p.GetPullRequest()
 15012  	p = nil
 15013  	p.GetPullRequest()
 15014  }
 15015  
 15016  func TestPullRequestReviewCommentEvent_GetRepo(tt *testing.T) {
 15017  	p := &PullRequestReviewCommentEvent{}
 15018  	p.GetRepo()
 15019  	p = nil
 15020  	p.GetRepo()
 15021  }
 15022  
 15023  func TestPullRequestReviewCommentEvent_GetSender(tt *testing.T) {
 15024  	p := &PullRequestReviewCommentEvent{}
 15025  	p.GetSender()
 15026  	p = nil
 15027  	p.GetSender()
 15028  }
 15029  
 15030  func TestPullRequestReviewDismissalRequest_GetMessage(tt *testing.T) {
 15031  	var zeroValue string
 15032  	p := &PullRequestReviewDismissalRequest{Message: &zeroValue}
 15033  	p.GetMessage()
 15034  	p = &PullRequestReviewDismissalRequest{}
 15035  	p.GetMessage()
 15036  	p = nil
 15037  	p.GetMessage()
 15038  }
 15039  
 15040  func TestPullRequestReviewEvent_GetAction(tt *testing.T) {
 15041  	var zeroValue string
 15042  	p := &PullRequestReviewEvent{Action: &zeroValue}
 15043  	p.GetAction()
 15044  	p = &PullRequestReviewEvent{}
 15045  	p.GetAction()
 15046  	p = nil
 15047  	p.GetAction()
 15048  }
 15049  
 15050  func TestPullRequestReviewEvent_GetInstallation(tt *testing.T) {
 15051  	p := &PullRequestReviewEvent{}
 15052  	p.GetInstallation()
 15053  	p = nil
 15054  	p.GetInstallation()
 15055  }
 15056  
 15057  func TestPullRequestReviewEvent_GetOrganization(tt *testing.T) {
 15058  	p := &PullRequestReviewEvent{}
 15059  	p.GetOrganization()
 15060  	p = nil
 15061  	p.GetOrganization()
 15062  }
 15063  
 15064  func TestPullRequestReviewEvent_GetPullRequest(tt *testing.T) {
 15065  	p := &PullRequestReviewEvent{}
 15066  	p.GetPullRequest()
 15067  	p = nil
 15068  	p.GetPullRequest()
 15069  }
 15070  
 15071  func TestPullRequestReviewEvent_GetRepo(tt *testing.T) {
 15072  	p := &PullRequestReviewEvent{}
 15073  	p.GetRepo()
 15074  	p = nil
 15075  	p.GetRepo()
 15076  }
 15077  
 15078  func TestPullRequestReviewEvent_GetReview(tt *testing.T) {
 15079  	p := &PullRequestReviewEvent{}
 15080  	p.GetReview()
 15081  	p = nil
 15082  	p.GetReview()
 15083  }
 15084  
 15085  func TestPullRequestReviewEvent_GetSender(tt *testing.T) {
 15086  	p := &PullRequestReviewEvent{}
 15087  	p.GetSender()
 15088  	p = nil
 15089  	p.GetSender()
 15090  }
 15091  
 15092  func TestPullRequestReviewRequest_GetBody(tt *testing.T) {
 15093  	var zeroValue string
 15094  	p := &PullRequestReviewRequest{Body: &zeroValue}
 15095  	p.GetBody()
 15096  	p = &PullRequestReviewRequest{}
 15097  	p.GetBody()
 15098  	p = nil
 15099  	p.GetBody()
 15100  }
 15101  
 15102  func TestPullRequestReviewRequest_GetCommitID(tt *testing.T) {
 15103  	var zeroValue string
 15104  	p := &PullRequestReviewRequest{CommitID: &zeroValue}
 15105  	p.GetCommitID()
 15106  	p = &PullRequestReviewRequest{}
 15107  	p.GetCommitID()
 15108  	p = nil
 15109  	p.GetCommitID()
 15110  }
 15111  
 15112  func TestPullRequestReviewRequest_GetEvent(tt *testing.T) {
 15113  	var zeroValue string
 15114  	p := &PullRequestReviewRequest{Event: &zeroValue}
 15115  	p.GetEvent()
 15116  	p = &PullRequestReviewRequest{}
 15117  	p.GetEvent()
 15118  	p = nil
 15119  	p.GetEvent()
 15120  }
 15121  
 15122  func TestPullRequestReviewRequest_GetNodeID(tt *testing.T) {
 15123  	var zeroValue string
 15124  	p := &PullRequestReviewRequest{NodeID: &zeroValue}
 15125  	p.GetNodeID()
 15126  	p = &PullRequestReviewRequest{}
 15127  	p.GetNodeID()
 15128  	p = nil
 15129  	p.GetNodeID()
 15130  }
 15131  
 15132  func TestPullRequestReviewsEnforcement_GetBypassPullRequestAllowances(tt *testing.T) {
 15133  	p := &PullRequestReviewsEnforcement{}
 15134  	p.GetBypassPullRequestAllowances()
 15135  	p = nil
 15136  	p.GetBypassPullRequestAllowances()
 15137  }
 15138  
 15139  func TestPullRequestReviewsEnforcement_GetDismissalRestrictions(tt *testing.T) {
 15140  	p := &PullRequestReviewsEnforcement{}
 15141  	p.GetDismissalRestrictions()
 15142  	p = nil
 15143  	p.GetDismissalRestrictions()
 15144  }
 15145  
 15146  func TestPullRequestReviewsEnforcementRequest_GetBypassPullRequestAllowancesRequest(tt *testing.T) {
 15147  	p := &PullRequestReviewsEnforcementRequest{}
 15148  	p.GetBypassPullRequestAllowancesRequest()
 15149  	p = nil
 15150  	p.GetBypassPullRequestAllowancesRequest()
 15151  }
 15152  
 15153  func TestPullRequestReviewsEnforcementRequest_GetDismissalRestrictionsRequest(tt *testing.T) {
 15154  	p := &PullRequestReviewsEnforcementRequest{}
 15155  	p.GetDismissalRestrictionsRequest()
 15156  	p = nil
 15157  	p.GetDismissalRestrictionsRequest()
 15158  }
 15159  
 15160  func TestPullRequestReviewsEnforcementUpdate_GetBypassPullRequestAllowancesRequest(tt *testing.T) {
 15161  	p := &PullRequestReviewsEnforcementUpdate{}
 15162  	p.GetBypassPullRequestAllowancesRequest()
 15163  	p = nil
 15164  	p.GetBypassPullRequestAllowancesRequest()
 15165  }
 15166  
 15167  func TestPullRequestReviewsEnforcementUpdate_GetDismissalRestrictionsRequest(tt *testing.T) {
 15168  	p := &PullRequestReviewsEnforcementUpdate{}
 15169  	p.GetDismissalRestrictionsRequest()
 15170  	p = nil
 15171  	p.GetDismissalRestrictionsRequest()
 15172  }
 15173  
 15174  func TestPullRequestReviewsEnforcementUpdate_GetDismissStaleReviews(tt *testing.T) {
 15175  	var zeroValue bool
 15176  	p := &PullRequestReviewsEnforcementUpdate{DismissStaleReviews: &zeroValue}
 15177  	p.GetDismissStaleReviews()
 15178  	p = &PullRequestReviewsEnforcementUpdate{}
 15179  	p.GetDismissStaleReviews()
 15180  	p = nil
 15181  	p.GetDismissStaleReviews()
 15182  }
 15183  
 15184  func TestPullRequestReviewsEnforcementUpdate_GetRequireCodeOwnerReviews(tt *testing.T) {
 15185  	var zeroValue bool
 15186  	p := &PullRequestReviewsEnforcementUpdate{RequireCodeOwnerReviews: &zeroValue}
 15187  	p.GetRequireCodeOwnerReviews()
 15188  	p = &PullRequestReviewsEnforcementUpdate{}
 15189  	p.GetRequireCodeOwnerReviews()
 15190  	p = nil
 15191  	p.GetRequireCodeOwnerReviews()
 15192  }
 15193  
 15194  func TestPullRequestReviewThreadEvent_GetAction(tt *testing.T) {
 15195  	var zeroValue string
 15196  	p := &PullRequestReviewThreadEvent{Action: &zeroValue}
 15197  	p.GetAction()
 15198  	p = &PullRequestReviewThreadEvent{}
 15199  	p.GetAction()
 15200  	p = nil
 15201  	p.GetAction()
 15202  }
 15203  
 15204  func TestPullRequestReviewThreadEvent_GetInstallation(tt *testing.T) {
 15205  	p := &PullRequestReviewThreadEvent{}
 15206  	p.GetInstallation()
 15207  	p = nil
 15208  	p.GetInstallation()
 15209  }
 15210  
 15211  func TestPullRequestReviewThreadEvent_GetPullRequest(tt *testing.T) {
 15212  	p := &PullRequestReviewThreadEvent{}
 15213  	p.GetPullRequest()
 15214  	p = nil
 15215  	p.GetPullRequest()
 15216  }
 15217  
 15218  func TestPullRequestReviewThreadEvent_GetRepo(tt *testing.T) {
 15219  	p := &PullRequestReviewThreadEvent{}
 15220  	p.GetRepo()
 15221  	p = nil
 15222  	p.GetRepo()
 15223  }
 15224  
 15225  func TestPullRequestReviewThreadEvent_GetSender(tt *testing.T) {
 15226  	p := &PullRequestReviewThreadEvent{}
 15227  	p.GetSender()
 15228  	p = nil
 15229  	p.GetSender()
 15230  }
 15231  
 15232  func TestPullRequestReviewThreadEvent_GetThread(tt *testing.T) {
 15233  	p := &PullRequestReviewThreadEvent{}
 15234  	p.GetThread()
 15235  	p = nil
 15236  	p.GetThread()
 15237  }
 15238  
 15239  func TestPullRequestTargetEvent_GetAction(tt *testing.T) {
 15240  	var zeroValue string
 15241  	p := &PullRequestTargetEvent{Action: &zeroValue}
 15242  	p.GetAction()
 15243  	p = &PullRequestTargetEvent{}
 15244  	p.GetAction()
 15245  	p = nil
 15246  	p.GetAction()
 15247  }
 15248  
 15249  func TestPullRequestTargetEvent_GetAfter(tt *testing.T) {
 15250  	var zeroValue string
 15251  	p := &PullRequestTargetEvent{After: &zeroValue}
 15252  	p.GetAfter()
 15253  	p = &PullRequestTargetEvent{}
 15254  	p.GetAfter()
 15255  	p = nil
 15256  	p.GetAfter()
 15257  }
 15258  
 15259  func TestPullRequestTargetEvent_GetAssignee(tt *testing.T) {
 15260  	p := &PullRequestTargetEvent{}
 15261  	p.GetAssignee()
 15262  	p = nil
 15263  	p.GetAssignee()
 15264  }
 15265  
 15266  func TestPullRequestTargetEvent_GetBefore(tt *testing.T) {
 15267  	var zeroValue string
 15268  	p := &PullRequestTargetEvent{Before: &zeroValue}
 15269  	p.GetBefore()
 15270  	p = &PullRequestTargetEvent{}
 15271  	p.GetBefore()
 15272  	p = nil
 15273  	p.GetBefore()
 15274  }
 15275  
 15276  func TestPullRequestTargetEvent_GetChanges(tt *testing.T) {
 15277  	p := &PullRequestTargetEvent{}
 15278  	p.GetChanges()
 15279  	p = nil
 15280  	p.GetChanges()
 15281  }
 15282  
 15283  func TestPullRequestTargetEvent_GetInstallation(tt *testing.T) {
 15284  	p := &PullRequestTargetEvent{}
 15285  	p.GetInstallation()
 15286  	p = nil
 15287  	p.GetInstallation()
 15288  }
 15289  
 15290  func TestPullRequestTargetEvent_GetLabel(tt *testing.T) {
 15291  	p := &PullRequestTargetEvent{}
 15292  	p.GetLabel()
 15293  	p = nil
 15294  	p.GetLabel()
 15295  }
 15296  
 15297  func TestPullRequestTargetEvent_GetNumber(tt *testing.T) {
 15298  	var zeroValue int
 15299  	p := &PullRequestTargetEvent{Number: &zeroValue}
 15300  	p.GetNumber()
 15301  	p = &PullRequestTargetEvent{}
 15302  	p.GetNumber()
 15303  	p = nil
 15304  	p.GetNumber()
 15305  }
 15306  
 15307  func TestPullRequestTargetEvent_GetOrganization(tt *testing.T) {
 15308  	p := &PullRequestTargetEvent{}
 15309  	p.GetOrganization()
 15310  	p = nil
 15311  	p.GetOrganization()
 15312  }
 15313  
 15314  func TestPullRequestTargetEvent_GetPullRequest(tt *testing.T) {
 15315  	p := &PullRequestTargetEvent{}
 15316  	p.GetPullRequest()
 15317  	p = nil
 15318  	p.GetPullRequest()
 15319  }
 15320  
 15321  func TestPullRequestTargetEvent_GetRepo(tt *testing.T) {
 15322  	p := &PullRequestTargetEvent{}
 15323  	p.GetRepo()
 15324  	p = nil
 15325  	p.GetRepo()
 15326  }
 15327  
 15328  func TestPullRequestTargetEvent_GetRequestedReviewer(tt *testing.T) {
 15329  	p := &PullRequestTargetEvent{}
 15330  	p.GetRequestedReviewer()
 15331  	p = nil
 15332  	p.GetRequestedReviewer()
 15333  }
 15334  
 15335  func TestPullRequestTargetEvent_GetRequestedTeam(tt *testing.T) {
 15336  	p := &PullRequestTargetEvent{}
 15337  	p.GetRequestedTeam()
 15338  	p = nil
 15339  	p.GetRequestedTeam()
 15340  }
 15341  
 15342  func TestPullRequestTargetEvent_GetSender(tt *testing.T) {
 15343  	p := &PullRequestTargetEvent{}
 15344  	p.GetSender()
 15345  	p = nil
 15346  	p.GetSender()
 15347  }
 15348  
 15349  func TestPullRequestThread_GetID(tt *testing.T) {
 15350  	var zeroValue int64
 15351  	p := &PullRequestThread{ID: &zeroValue}
 15352  	p.GetID()
 15353  	p = &PullRequestThread{}
 15354  	p.GetID()
 15355  	p = nil
 15356  	p.GetID()
 15357  }
 15358  
 15359  func TestPullRequestThread_GetNodeID(tt *testing.T) {
 15360  	var zeroValue string
 15361  	p := &PullRequestThread{NodeID: &zeroValue}
 15362  	p.GetNodeID()
 15363  	p = &PullRequestThread{}
 15364  	p.GetNodeID()
 15365  	p = nil
 15366  	p.GetNodeID()
 15367  }
 15368  
 15369  func TestPullStats_GetMergablePulls(tt *testing.T) {
 15370  	var zeroValue int
 15371  	p := &PullStats{MergablePulls: &zeroValue}
 15372  	p.GetMergablePulls()
 15373  	p = &PullStats{}
 15374  	p.GetMergablePulls()
 15375  	p = nil
 15376  	p.GetMergablePulls()
 15377  }
 15378  
 15379  func TestPullStats_GetMergedPulls(tt *testing.T) {
 15380  	var zeroValue int
 15381  	p := &PullStats{MergedPulls: &zeroValue}
 15382  	p.GetMergedPulls()
 15383  	p = &PullStats{}
 15384  	p.GetMergedPulls()
 15385  	p = nil
 15386  	p.GetMergedPulls()
 15387  }
 15388  
 15389  func TestPullStats_GetTotalPulls(tt *testing.T) {
 15390  	var zeroValue int
 15391  	p := &PullStats{TotalPulls: &zeroValue}
 15392  	p.GetTotalPulls()
 15393  	p = &PullStats{}
 15394  	p.GetTotalPulls()
 15395  	p = nil
 15396  	p.GetTotalPulls()
 15397  }
 15398  
 15399  func TestPullStats_GetUnmergablePulls(tt *testing.T) {
 15400  	var zeroValue int
 15401  	p := &PullStats{UnmergablePulls: &zeroValue}
 15402  	p.GetUnmergablePulls()
 15403  	p = &PullStats{}
 15404  	p.GetUnmergablePulls()
 15405  	p = nil
 15406  	p.GetUnmergablePulls()
 15407  }
 15408  
 15409  func TestPunchCard_GetCommits(tt *testing.T) {
 15410  	var zeroValue int
 15411  	p := &PunchCard{Commits: &zeroValue}
 15412  	p.GetCommits()
 15413  	p = &PunchCard{}
 15414  	p.GetCommits()
 15415  	p = nil
 15416  	p.GetCommits()
 15417  }
 15418  
 15419  func TestPunchCard_GetDay(tt *testing.T) {
 15420  	var zeroValue int
 15421  	p := &PunchCard{Day: &zeroValue}
 15422  	p.GetDay()
 15423  	p = &PunchCard{}
 15424  	p.GetDay()
 15425  	p = nil
 15426  	p.GetDay()
 15427  }
 15428  
 15429  func TestPunchCard_GetHour(tt *testing.T) {
 15430  	var zeroValue int
 15431  	p := &PunchCard{Hour: &zeroValue}
 15432  	p.GetHour()
 15433  	p = &PunchCard{}
 15434  	p.GetHour()
 15435  	p = nil
 15436  	p.GetHour()
 15437  }
 15438  
 15439  func TestPushEvent_GetAction(tt *testing.T) {
 15440  	var zeroValue string
 15441  	p := &PushEvent{Action: &zeroValue}
 15442  	p.GetAction()
 15443  	p = &PushEvent{}
 15444  	p.GetAction()
 15445  	p = nil
 15446  	p.GetAction()
 15447  }
 15448  
 15449  func TestPushEvent_GetAfter(tt *testing.T) {
 15450  	var zeroValue string
 15451  	p := &PushEvent{After: &zeroValue}
 15452  	p.GetAfter()
 15453  	p = &PushEvent{}
 15454  	p.GetAfter()
 15455  	p = nil
 15456  	p.GetAfter()
 15457  }
 15458  
 15459  func TestPushEvent_GetBaseRef(tt *testing.T) {
 15460  	var zeroValue string
 15461  	p := &PushEvent{BaseRef: &zeroValue}
 15462  	p.GetBaseRef()
 15463  	p = &PushEvent{}
 15464  	p.GetBaseRef()
 15465  	p = nil
 15466  	p.GetBaseRef()
 15467  }
 15468  
 15469  func TestPushEvent_GetBefore(tt *testing.T) {
 15470  	var zeroValue string
 15471  	p := &PushEvent{Before: &zeroValue}
 15472  	p.GetBefore()
 15473  	p = &PushEvent{}
 15474  	p.GetBefore()
 15475  	p = nil
 15476  	p.GetBefore()
 15477  }
 15478  
 15479  func TestPushEvent_GetCompare(tt *testing.T) {
 15480  	var zeroValue string
 15481  	p := &PushEvent{Compare: &zeroValue}
 15482  	p.GetCompare()
 15483  	p = &PushEvent{}
 15484  	p.GetCompare()
 15485  	p = nil
 15486  	p.GetCompare()
 15487  }
 15488  
 15489  func TestPushEvent_GetCreated(tt *testing.T) {
 15490  	var zeroValue bool
 15491  	p := &PushEvent{Created: &zeroValue}
 15492  	p.GetCreated()
 15493  	p = &PushEvent{}
 15494  	p.GetCreated()
 15495  	p = nil
 15496  	p.GetCreated()
 15497  }
 15498  
 15499  func TestPushEvent_GetDeleted(tt *testing.T) {
 15500  	var zeroValue bool
 15501  	p := &PushEvent{Deleted: &zeroValue}
 15502  	p.GetDeleted()
 15503  	p = &PushEvent{}
 15504  	p.GetDeleted()
 15505  	p = nil
 15506  	p.GetDeleted()
 15507  }
 15508  
 15509  func TestPushEvent_GetDistinctSize(tt *testing.T) {
 15510  	var zeroValue int
 15511  	p := &PushEvent{DistinctSize: &zeroValue}
 15512  	p.GetDistinctSize()
 15513  	p = &PushEvent{}
 15514  	p.GetDistinctSize()
 15515  	p = nil
 15516  	p.GetDistinctSize()
 15517  }
 15518  
 15519  func TestPushEvent_GetForced(tt *testing.T) {
 15520  	var zeroValue bool
 15521  	p := &PushEvent{Forced: &zeroValue}
 15522  	p.GetForced()
 15523  	p = &PushEvent{}
 15524  	p.GetForced()
 15525  	p = nil
 15526  	p.GetForced()
 15527  }
 15528  
 15529  func TestPushEvent_GetHead(tt *testing.T) {
 15530  	var zeroValue string
 15531  	p := &PushEvent{Head: &zeroValue}
 15532  	p.GetHead()
 15533  	p = &PushEvent{}
 15534  	p.GetHead()
 15535  	p = nil
 15536  	p.GetHead()
 15537  }
 15538  
 15539  func TestPushEvent_GetHeadCommit(tt *testing.T) {
 15540  	p := &PushEvent{}
 15541  	p.GetHeadCommit()
 15542  	p = nil
 15543  	p.GetHeadCommit()
 15544  }
 15545  
 15546  func TestPushEvent_GetInstallation(tt *testing.T) {
 15547  	p := &PushEvent{}
 15548  	p.GetInstallation()
 15549  	p = nil
 15550  	p.GetInstallation()
 15551  }
 15552  
 15553  func TestPushEvent_GetOrganization(tt *testing.T) {
 15554  	p := &PushEvent{}
 15555  	p.GetOrganization()
 15556  	p = nil
 15557  	p.GetOrganization()
 15558  }
 15559  
 15560  func TestPushEvent_GetPusher(tt *testing.T) {
 15561  	p := &PushEvent{}
 15562  	p.GetPusher()
 15563  	p = nil
 15564  	p.GetPusher()
 15565  }
 15566  
 15567  func TestPushEvent_GetPushID(tt *testing.T) {
 15568  	var zeroValue int64
 15569  	p := &PushEvent{PushID: &zeroValue}
 15570  	p.GetPushID()
 15571  	p = &PushEvent{}
 15572  	p.GetPushID()
 15573  	p = nil
 15574  	p.GetPushID()
 15575  }
 15576  
 15577  func TestPushEvent_GetRef(tt *testing.T) {
 15578  	var zeroValue string
 15579  	p := &PushEvent{Ref: &zeroValue}
 15580  	p.GetRef()
 15581  	p = &PushEvent{}
 15582  	p.GetRef()
 15583  	p = nil
 15584  	p.GetRef()
 15585  }
 15586  
 15587  func TestPushEvent_GetRepo(tt *testing.T) {
 15588  	p := &PushEvent{}
 15589  	p.GetRepo()
 15590  	p = nil
 15591  	p.GetRepo()
 15592  }
 15593  
 15594  func TestPushEvent_GetSender(tt *testing.T) {
 15595  	p := &PushEvent{}
 15596  	p.GetSender()
 15597  	p = nil
 15598  	p.GetSender()
 15599  }
 15600  
 15601  func TestPushEvent_GetSize(tt *testing.T) {
 15602  	var zeroValue int
 15603  	p := &PushEvent{Size: &zeroValue}
 15604  	p.GetSize()
 15605  	p = &PushEvent{}
 15606  	p.GetSize()
 15607  	p = nil
 15608  	p.GetSize()
 15609  }
 15610  
 15611  func TestPushEventRepoOwner_GetEmail(tt *testing.T) {
 15612  	var zeroValue string
 15613  	p := &PushEventRepoOwner{Email: &zeroValue}
 15614  	p.GetEmail()
 15615  	p = &PushEventRepoOwner{}
 15616  	p.GetEmail()
 15617  	p = nil
 15618  	p.GetEmail()
 15619  }
 15620  
 15621  func TestPushEventRepoOwner_GetName(tt *testing.T) {
 15622  	var zeroValue string
 15623  	p := &PushEventRepoOwner{Name: &zeroValue}
 15624  	p.GetName()
 15625  	p = &PushEventRepoOwner{}
 15626  	p.GetName()
 15627  	p = nil
 15628  	p.GetName()
 15629  }
 15630  
 15631  func TestPushEventRepository_GetArchived(tt *testing.T) {
 15632  	var zeroValue bool
 15633  	p := &PushEventRepository{Archived: &zeroValue}
 15634  	p.GetArchived()
 15635  	p = &PushEventRepository{}
 15636  	p.GetArchived()
 15637  	p = nil
 15638  	p.GetArchived()
 15639  }
 15640  
 15641  func TestPushEventRepository_GetArchiveURL(tt *testing.T) {
 15642  	var zeroValue string
 15643  	p := &PushEventRepository{ArchiveURL: &zeroValue}
 15644  	p.GetArchiveURL()
 15645  	p = &PushEventRepository{}
 15646  	p.GetArchiveURL()
 15647  	p = nil
 15648  	p.GetArchiveURL()
 15649  }
 15650  
 15651  func TestPushEventRepository_GetCloneURL(tt *testing.T) {
 15652  	var zeroValue string
 15653  	p := &PushEventRepository{CloneURL: &zeroValue}
 15654  	p.GetCloneURL()
 15655  	p = &PushEventRepository{}
 15656  	p.GetCloneURL()
 15657  	p = nil
 15658  	p.GetCloneURL()
 15659  }
 15660  
 15661  func TestPushEventRepository_GetCreatedAt(tt *testing.T) {
 15662  	var zeroValue Timestamp
 15663  	p := &PushEventRepository{CreatedAt: &zeroValue}
 15664  	p.GetCreatedAt()
 15665  	p = &PushEventRepository{}
 15666  	p.GetCreatedAt()
 15667  	p = nil
 15668  	p.GetCreatedAt()
 15669  }
 15670  
 15671  func TestPushEventRepository_GetDefaultBranch(tt *testing.T) {
 15672  	var zeroValue string
 15673  	p := &PushEventRepository{DefaultBranch: &zeroValue}
 15674  	p.GetDefaultBranch()
 15675  	p = &PushEventRepository{}
 15676  	p.GetDefaultBranch()
 15677  	p = nil
 15678  	p.GetDefaultBranch()
 15679  }
 15680  
 15681  func TestPushEventRepository_GetDescription(tt *testing.T) {
 15682  	var zeroValue string
 15683  	p := &PushEventRepository{Description: &zeroValue}
 15684  	p.GetDescription()
 15685  	p = &PushEventRepository{}
 15686  	p.GetDescription()
 15687  	p = nil
 15688  	p.GetDescription()
 15689  }
 15690  
 15691  func TestPushEventRepository_GetDisabled(tt *testing.T) {
 15692  	var zeroValue bool
 15693  	p := &PushEventRepository{Disabled: &zeroValue}
 15694  	p.GetDisabled()
 15695  	p = &PushEventRepository{}
 15696  	p.GetDisabled()
 15697  	p = nil
 15698  	p.GetDisabled()
 15699  }
 15700  
 15701  func TestPushEventRepository_GetFork(tt *testing.T) {
 15702  	var zeroValue bool
 15703  	p := &PushEventRepository{Fork: &zeroValue}
 15704  	p.GetFork()
 15705  	p = &PushEventRepository{}
 15706  	p.GetFork()
 15707  	p = nil
 15708  	p.GetFork()
 15709  }
 15710  
 15711  func TestPushEventRepository_GetForksCount(tt *testing.T) {
 15712  	var zeroValue int
 15713  	p := &PushEventRepository{ForksCount: &zeroValue}
 15714  	p.GetForksCount()
 15715  	p = &PushEventRepository{}
 15716  	p.GetForksCount()
 15717  	p = nil
 15718  	p.GetForksCount()
 15719  }
 15720  
 15721  func TestPushEventRepository_GetFullName(tt *testing.T) {
 15722  	var zeroValue string
 15723  	p := &PushEventRepository{FullName: &zeroValue}
 15724  	p.GetFullName()
 15725  	p = &PushEventRepository{}
 15726  	p.GetFullName()
 15727  	p = nil
 15728  	p.GetFullName()
 15729  }
 15730  
 15731  func TestPushEventRepository_GetGitURL(tt *testing.T) {
 15732  	var zeroValue string
 15733  	p := &PushEventRepository{GitURL: &zeroValue}
 15734  	p.GetGitURL()
 15735  	p = &PushEventRepository{}
 15736  	p.GetGitURL()
 15737  	p = nil
 15738  	p.GetGitURL()
 15739  }
 15740  
 15741  func TestPushEventRepository_GetHasDownloads(tt *testing.T) {
 15742  	var zeroValue bool
 15743  	p := &PushEventRepository{HasDownloads: &zeroValue}
 15744  	p.GetHasDownloads()
 15745  	p = &PushEventRepository{}
 15746  	p.GetHasDownloads()
 15747  	p = nil
 15748  	p.GetHasDownloads()
 15749  }
 15750  
 15751  func TestPushEventRepository_GetHasIssues(tt *testing.T) {
 15752  	var zeroValue bool
 15753  	p := &PushEventRepository{HasIssues: &zeroValue}
 15754  	p.GetHasIssues()
 15755  	p = &PushEventRepository{}
 15756  	p.GetHasIssues()
 15757  	p = nil
 15758  	p.GetHasIssues()
 15759  }
 15760  
 15761  func TestPushEventRepository_GetHasPages(tt *testing.T) {
 15762  	var zeroValue bool
 15763  	p := &PushEventRepository{HasPages: &zeroValue}
 15764  	p.GetHasPages()
 15765  	p = &PushEventRepository{}
 15766  	p.GetHasPages()
 15767  	p = nil
 15768  	p.GetHasPages()
 15769  }
 15770  
 15771  func TestPushEventRepository_GetHasWiki(tt *testing.T) {
 15772  	var zeroValue bool
 15773  	p := &PushEventRepository{HasWiki: &zeroValue}
 15774  	p.GetHasWiki()
 15775  	p = &PushEventRepository{}
 15776  	p.GetHasWiki()
 15777  	p = nil
 15778  	p.GetHasWiki()
 15779  }
 15780  
 15781  func TestPushEventRepository_GetHomepage(tt *testing.T) {
 15782  	var zeroValue string
 15783  	p := &PushEventRepository{Homepage: &zeroValue}
 15784  	p.GetHomepage()
 15785  	p = &PushEventRepository{}
 15786  	p.GetHomepage()
 15787  	p = nil
 15788  	p.GetHomepage()
 15789  }
 15790  
 15791  func TestPushEventRepository_GetHTMLURL(tt *testing.T) {
 15792  	var zeroValue string
 15793  	p := &PushEventRepository{HTMLURL: &zeroValue}
 15794  	p.GetHTMLURL()
 15795  	p = &PushEventRepository{}
 15796  	p.GetHTMLURL()
 15797  	p = nil
 15798  	p.GetHTMLURL()
 15799  }
 15800  
 15801  func TestPushEventRepository_GetID(tt *testing.T) {
 15802  	var zeroValue int64
 15803  	p := &PushEventRepository{ID: &zeroValue}
 15804  	p.GetID()
 15805  	p = &PushEventRepository{}
 15806  	p.GetID()
 15807  	p = nil
 15808  	p.GetID()
 15809  }
 15810  
 15811  func TestPushEventRepository_GetLanguage(tt *testing.T) {
 15812  	var zeroValue string
 15813  	p := &PushEventRepository{Language: &zeroValue}
 15814  	p.GetLanguage()
 15815  	p = &PushEventRepository{}
 15816  	p.GetLanguage()
 15817  	p = nil
 15818  	p.GetLanguage()
 15819  }
 15820  
 15821  func TestPushEventRepository_GetMasterBranch(tt *testing.T) {
 15822  	var zeroValue string
 15823  	p := &PushEventRepository{MasterBranch: &zeroValue}
 15824  	p.GetMasterBranch()
 15825  	p = &PushEventRepository{}
 15826  	p.GetMasterBranch()
 15827  	p = nil
 15828  	p.GetMasterBranch()
 15829  }
 15830  
 15831  func TestPushEventRepository_GetName(tt *testing.T) {
 15832  	var zeroValue string
 15833  	p := &PushEventRepository{Name: &zeroValue}
 15834  	p.GetName()
 15835  	p = &PushEventRepository{}
 15836  	p.GetName()
 15837  	p = nil
 15838  	p.GetName()
 15839  }
 15840  
 15841  func TestPushEventRepository_GetNodeID(tt *testing.T) {
 15842  	var zeroValue string
 15843  	p := &PushEventRepository{NodeID: &zeroValue}
 15844  	p.GetNodeID()
 15845  	p = &PushEventRepository{}
 15846  	p.GetNodeID()
 15847  	p = nil
 15848  	p.GetNodeID()
 15849  }
 15850  
 15851  func TestPushEventRepository_GetOpenIssuesCount(tt *testing.T) {
 15852  	var zeroValue int
 15853  	p := &PushEventRepository{OpenIssuesCount: &zeroValue}
 15854  	p.GetOpenIssuesCount()
 15855  	p = &PushEventRepository{}
 15856  	p.GetOpenIssuesCount()
 15857  	p = nil
 15858  	p.GetOpenIssuesCount()
 15859  }
 15860  
 15861  func TestPushEventRepository_GetOrganization(tt *testing.T) {
 15862  	var zeroValue string
 15863  	p := &PushEventRepository{Organization: &zeroValue}
 15864  	p.GetOrganization()
 15865  	p = &PushEventRepository{}
 15866  	p.GetOrganization()
 15867  	p = nil
 15868  	p.GetOrganization()
 15869  }
 15870  
 15871  func TestPushEventRepository_GetOwner(tt *testing.T) {
 15872  	p := &PushEventRepository{}
 15873  	p.GetOwner()
 15874  	p = nil
 15875  	p.GetOwner()
 15876  }
 15877  
 15878  func TestPushEventRepository_GetPrivate(tt *testing.T) {
 15879  	var zeroValue bool
 15880  	p := &PushEventRepository{Private: &zeroValue}
 15881  	p.GetPrivate()
 15882  	p = &PushEventRepository{}
 15883  	p.GetPrivate()
 15884  	p = nil
 15885  	p.GetPrivate()
 15886  }
 15887  
 15888  func TestPushEventRepository_GetPullsURL(tt *testing.T) {
 15889  	var zeroValue string
 15890  	p := &PushEventRepository{PullsURL: &zeroValue}
 15891  	p.GetPullsURL()
 15892  	p = &PushEventRepository{}
 15893  	p.GetPullsURL()
 15894  	p = nil
 15895  	p.GetPullsURL()
 15896  }
 15897  
 15898  func TestPushEventRepository_GetPushedAt(tt *testing.T) {
 15899  	var zeroValue Timestamp
 15900  	p := &PushEventRepository{PushedAt: &zeroValue}
 15901  	p.GetPushedAt()
 15902  	p = &PushEventRepository{}
 15903  	p.GetPushedAt()
 15904  	p = nil
 15905  	p.GetPushedAt()
 15906  }
 15907  
 15908  func TestPushEventRepository_GetSize(tt *testing.T) {
 15909  	var zeroValue int
 15910  	p := &PushEventRepository{Size: &zeroValue}
 15911  	p.GetSize()
 15912  	p = &PushEventRepository{}
 15913  	p.GetSize()
 15914  	p = nil
 15915  	p.GetSize()
 15916  }
 15917  
 15918  func TestPushEventRepository_GetSSHURL(tt *testing.T) {
 15919  	var zeroValue string
 15920  	p := &PushEventRepository{SSHURL: &zeroValue}
 15921  	p.GetSSHURL()
 15922  	p = &PushEventRepository{}
 15923  	p.GetSSHURL()
 15924  	p = nil
 15925  	p.GetSSHURL()
 15926  }
 15927  
 15928  func TestPushEventRepository_GetStargazersCount(tt *testing.T) {
 15929  	var zeroValue int
 15930  	p := &PushEventRepository{StargazersCount: &zeroValue}
 15931  	p.GetStargazersCount()
 15932  	p = &PushEventRepository{}
 15933  	p.GetStargazersCount()
 15934  	p = nil
 15935  	p.GetStargazersCount()
 15936  }
 15937  
 15938  func TestPushEventRepository_GetStatusesURL(tt *testing.T) {
 15939  	var zeroValue string
 15940  	p := &PushEventRepository{StatusesURL: &zeroValue}
 15941  	p.GetStatusesURL()
 15942  	p = &PushEventRepository{}
 15943  	p.GetStatusesURL()
 15944  	p = nil
 15945  	p.GetStatusesURL()
 15946  }
 15947  
 15948  func TestPushEventRepository_GetSVNURL(tt *testing.T) {
 15949  	var zeroValue string
 15950  	p := &PushEventRepository{SVNURL: &zeroValue}
 15951  	p.GetSVNURL()
 15952  	p = &PushEventRepository{}
 15953  	p.GetSVNURL()
 15954  	p = nil
 15955  	p.GetSVNURL()
 15956  }
 15957  
 15958  func TestPushEventRepository_GetUpdatedAt(tt *testing.T) {
 15959  	var zeroValue Timestamp
 15960  	p := &PushEventRepository{UpdatedAt: &zeroValue}
 15961  	p.GetUpdatedAt()
 15962  	p = &PushEventRepository{}
 15963  	p.GetUpdatedAt()
 15964  	p = nil
 15965  	p.GetUpdatedAt()
 15966  }
 15967  
 15968  func TestPushEventRepository_GetURL(tt *testing.T) {
 15969  	var zeroValue string
 15970  	p := &PushEventRepository{URL: &zeroValue}
 15971  	p.GetURL()
 15972  	p = &PushEventRepository{}
 15973  	p.GetURL()
 15974  	p = nil
 15975  	p.GetURL()
 15976  }
 15977  
 15978  func TestPushEventRepository_GetWatchersCount(tt *testing.T) {
 15979  	var zeroValue int
 15980  	p := &PushEventRepository{WatchersCount: &zeroValue}
 15981  	p.GetWatchersCount()
 15982  	p = &PushEventRepository{}
 15983  	p.GetWatchersCount()
 15984  	p = nil
 15985  	p.GetWatchersCount()
 15986  }
 15987  
 15988  func TestRateLimits_GetActionsRunnerRegistration(tt *testing.T) {
 15989  	r := &RateLimits{}
 15990  	r.GetActionsRunnerRegistration()
 15991  	r = nil
 15992  	r.GetActionsRunnerRegistration()
 15993  }
 15994  
 15995  func TestRateLimits_GetCodeScanningUpload(tt *testing.T) {
 15996  	r := &RateLimits{}
 15997  	r.GetCodeScanningUpload()
 15998  	r = nil
 15999  	r.GetCodeScanningUpload()
 16000  }
 16001  
 16002  func TestRateLimits_GetCore(tt *testing.T) {
 16003  	r := &RateLimits{}
 16004  	r.GetCore()
 16005  	r = nil
 16006  	r.GetCore()
 16007  }
 16008  
 16009  func TestRateLimits_GetGraphQL(tt *testing.T) {
 16010  	r := &RateLimits{}
 16011  	r.GetGraphQL()
 16012  	r = nil
 16013  	r.GetGraphQL()
 16014  }
 16015  
 16016  func TestRateLimits_GetIntegrationManifest(tt *testing.T) {
 16017  	r := &RateLimits{}
 16018  	r.GetIntegrationManifest()
 16019  	r = nil
 16020  	r.GetIntegrationManifest()
 16021  }
 16022  
 16023  func TestRateLimits_GetSCIM(tt *testing.T) {
 16024  	r := &RateLimits{}
 16025  	r.GetSCIM()
 16026  	r = nil
 16027  	r.GetSCIM()
 16028  }
 16029  
 16030  func TestRateLimits_GetSearch(tt *testing.T) {
 16031  	r := &RateLimits{}
 16032  	r.GetSearch()
 16033  	r = nil
 16034  	r.GetSearch()
 16035  }
 16036  
 16037  func TestRateLimits_GetSourceImport(tt *testing.T) {
 16038  	r := &RateLimits{}
 16039  	r.GetSourceImport()
 16040  	r = nil
 16041  	r.GetSourceImport()
 16042  }
 16043  
 16044  func TestReaction_GetContent(tt *testing.T) {
 16045  	var zeroValue string
 16046  	r := &Reaction{Content: &zeroValue}
 16047  	r.GetContent()
 16048  	r = &Reaction{}
 16049  	r.GetContent()
 16050  	r = nil
 16051  	r.GetContent()
 16052  }
 16053  
 16054  func TestReaction_GetID(tt *testing.T) {
 16055  	var zeroValue int64
 16056  	r := &Reaction{ID: &zeroValue}
 16057  	r.GetID()
 16058  	r = &Reaction{}
 16059  	r.GetID()
 16060  	r = nil
 16061  	r.GetID()
 16062  }
 16063  
 16064  func TestReaction_GetNodeID(tt *testing.T) {
 16065  	var zeroValue string
 16066  	r := &Reaction{NodeID: &zeroValue}
 16067  	r.GetNodeID()
 16068  	r = &Reaction{}
 16069  	r.GetNodeID()
 16070  	r = nil
 16071  	r.GetNodeID()
 16072  }
 16073  
 16074  func TestReaction_GetUser(tt *testing.T) {
 16075  	r := &Reaction{}
 16076  	r.GetUser()
 16077  	r = nil
 16078  	r.GetUser()
 16079  }
 16080  
 16081  func TestReactions_GetConfused(tt *testing.T) {
 16082  	var zeroValue int
 16083  	r := &Reactions{Confused: &zeroValue}
 16084  	r.GetConfused()
 16085  	r = &Reactions{}
 16086  	r.GetConfused()
 16087  	r = nil
 16088  	r.GetConfused()
 16089  }
 16090  
 16091  func TestReactions_GetEyes(tt *testing.T) {
 16092  	var zeroValue int
 16093  	r := &Reactions{Eyes: &zeroValue}
 16094  	r.GetEyes()
 16095  	r = &Reactions{}
 16096  	r.GetEyes()
 16097  	r = nil
 16098  	r.GetEyes()
 16099  }
 16100  
 16101  func TestReactions_GetHeart(tt *testing.T) {
 16102  	var zeroValue int
 16103  	r := &Reactions{Heart: &zeroValue}
 16104  	r.GetHeart()
 16105  	r = &Reactions{}
 16106  	r.GetHeart()
 16107  	r = nil
 16108  	r.GetHeart()
 16109  }
 16110  
 16111  func TestReactions_GetHooray(tt *testing.T) {
 16112  	var zeroValue int
 16113  	r := &Reactions{Hooray: &zeroValue}
 16114  	r.GetHooray()
 16115  	r = &Reactions{}
 16116  	r.GetHooray()
 16117  	r = nil
 16118  	r.GetHooray()
 16119  }
 16120  
 16121  func TestReactions_GetLaugh(tt *testing.T) {
 16122  	var zeroValue int
 16123  	r := &Reactions{Laugh: &zeroValue}
 16124  	r.GetLaugh()
 16125  	r = &Reactions{}
 16126  	r.GetLaugh()
 16127  	r = nil
 16128  	r.GetLaugh()
 16129  }
 16130  
 16131  func TestReactions_GetMinusOne(tt *testing.T) {
 16132  	var zeroValue int
 16133  	r := &Reactions{MinusOne: &zeroValue}
 16134  	r.GetMinusOne()
 16135  	r = &Reactions{}
 16136  	r.GetMinusOne()
 16137  	r = nil
 16138  	r.GetMinusOne()
 16139  }
 16140  
 16141  func TestReactions_GetPlusOne(tt *testing.T) {
 16142  	var zeroValue int
 16143  	r := &Reactions{PlusOne: &zeroValue}
 16144  	r.GetPlusOne()
 16145  	r = &Reactions{}
 16146  	r.GetPlusOne()
 16147  	r = nil
 16148  	r.GetPlusOne()
 16149  }
 16150  
 16151  func TestReactions_GetRocket(tt *testing.T) {
 16152  	var zeroValue int
 16153  	r := &Reactions{Rocket: &zeroValue}
 16154  	r.GetRocket()
 16155  	r = &Reactions{}
 16156  	r.GetRocket()
 16157  	r = nil
 16158  	r.GetRocket()
 16159  }
 16160  
 16161  func TestReactions_GetTotalCount(tt *testing.T) {
 16162  	var zeroValue int
 16163  	r := &Reactions{TotalCount: &zeroValue}
 16164  	r.GetTotalCount()
 16165  	r = &Reactions{}
 16166  	r.GetTotalCount()
 16167  	r = nil
 16168  	r.GetTotalCount()
 16169  }
 16170  
 16171  func TestReactions_GetURL(tt *testing.T) {
 16172  	var zeroValue string
 16173  	r := &Reactions{URL: &zeroValue}
 16174  	r.GetURL()
 16175  	r = &Reactions{}
 16176  	r.GetURL()
 16177  	r = nil
 16178  	r.GetURL()
 16179  }
 16180  
 16181  func TestReference_GetNodeID(tt *testing.T) {
 16182  	var zeroValue string
 16183  	r := &Reference{NodeID: &zeroValue}
 16184  	r.GetNodeID()
 16185  	r = &Reference{}
 16186  	r.GetNodeID()
 16187  	r = nil
 16188  	r.GetNodeID()
 16189  }
 16190  
 16191  func TestReference_GetObject(tt *testing.T) {
 16192  	r := &Reference{}
 16193  	r.GetObject()
 16194  	r = nil
 16195  	r.GetObject()
 16196  }
 16197  
 16198  func TestReference_GetRef(tt *testing.T) {
 16199  	var zeroValue string
 16200  	r := &Reference{Ref: &zeroValue}
 16201  	r.GetRef()
 16202  	r = &Reference{}
 16203  	r.GetRef()
 16204  	r = nil
 16205  	r.GetRef()
 16206  }
 16207  
 16208  func TestReference_GetURL(tt *testing.T) {
 16209  	var zeroValue string
 16210  	r := &Reference{URL: &zeroValue}
 16211  	r.GetURL()
 16212  	r = &Reference{}
 16213  	r.GetURL()
 16214  	r = nil
 16215  	r.GetURL()
 16216  }
 16217  
 16218  func TestRegistrationToken_GetExpiresAt(tt *testing.T) {
 16219  	var zeroValue Timestamp
 16220  	r := &RegistrationToken{ExpiresAt: &zeroValue}
 16221  	r.GetExpiresAt()
 16222  	r = &RegistrationToken{}
 16223  	r.GetExpiresAt()
 16224  	r = nil
 16225  	r.GetExpiresAt()
 16226  }
 16227  
 16228  func TestRegistrationToken_GetToken(tt *testing.T) {
 16229  	var zeroValue string
 16230  	r := &RegistrationToken{Token: &zeroValue}
 16231  	r.GetToken()
 16232  	r = &RegistrationToken{}
 16233  	r.GetToken()
 16234  	r = nil
 16235  	r.GetToken()
 16236  }
 16237  
 16238  func TestReleaseAsset_GetBrowserDownloadURL(tt *testing.T) {
 16239  	var zeroValue string
 16240  	r := &ReleaseAsset{BrowserDownloadURL: &zeroValue}
 16241  	r.GetBrowserDownloadURL()
 16242  	r = &ReleaseAsset{}
 16243  	r.GetBrowserDownloadURL()
 16244  	r = nil
 16245  	r.GetBrowserDownloadURL()
 16246  }
 16247  
 16248  func TestReleaseAsset_GetContentType(tt *testing.T) {
 16249  	var zeroValue string
 16250  	r := &ReleaseAsset{ContentType: &zeroValue}
 16251  	r.GetContentType()
 16252  	r = &ReleaseAsset{}
 16253  	r.GetContentType()
 16254  	r = nil
 16255  	r.GetContentType()
 16256  }
 16257  
 16258  func TestReleaseAsset_GetCreatedAt(tt *testing.T) {
 16259  	var zeroValue Timestamp
 16260  	r := &ReleaseAsset{CreatedAt: &zeroValue}
 16261  	r.GetCreatedAt()
 16262  	r = &ReleaseAsset{}
 16263  	r.GetCreatedAt()
 16264  	r = nil
 16265  	r.GetCreatedAt()
 16266  }
 16267  
 16268  func TestReleaseAsset_GetDownloadCount(tt *testing.T) {
 16269  	var zeroValue int
 16270  	r := &ReleaseAsset{DownloadCount: &zeroValue}
 16271  	r.GetDownloadCount()
 16272  	r = &ReleaseAsset{}
 16273  	r.GetDownloadCount()
 16274  	r = nil
 16275  	r.GetDownloadCount()
 16276  }
 16277  
 16278  func TestReleaseAsset_GetID(tt *testing.T) {
 16279  	var zeroValue int64
 16280  	r := &ReleaseAsset{ID: &zeroValue}
 16281  	r.GetID()
 16282  	r = &ReleaseAsset{}
 16283  	r.GetID()
 16284  	r = nil
 16285  	r.GetID()
 16286  }
 16287  
 16288  func TestReleaseAsset_GetLabel(tt *testing.T) {
 16289  	var zeroValue string
 16290  	r := &ReleaseAsset{Label: &zeroValue}
 16291  	r.GetLabel()
 16292  	r = &ReleaseAsset{}
 16293  	r.GetLabel()
 16294  	r = nil
 16295  	r.GetLabel()
 16296  }
 16297  
 16298  func TestReleaseAsset_GetName(tt *testing.T) {
 16299  	var zeroValue string
 16300  	r := &ReleaseAsset{Name: &zeroValue}
 16301  	r.GetName()
 16302  	r = &ReleaseAsset{}
 16303  	r.GetName()
 16304  	r = nil
 16305  	r.GetName()
 16306  }
 16307  
 16308  func TestReleaseAsset_GetNodeID(tt *testing.T) {
 16309  	var zeroValue string
 16310  	r := &ReleaseAsset{NodeID: &zeroValue}
 16311  	r.GetNodeID()
 16312  	r = &ReleaseAsset{}
 16313  	r.GetNodeID()
 16314  	r = nil
 16315  	r.GetNodeID()
 16316  }
 16317  
 16318  func TestReleaseAsset_GetSize(tt *testing.T) {
 16319  	var zeroValue int
 16320  	r := &ReleaseAsset{Size: &zeroValue}
 16321  	r.GetSize()
 16322  	r = &ReleaseAsset{}
 16323  	r.GetSize()
 16324  	r = nil
 16325  	r.GetSize()
 16326  }
 16327  
 16328  func TestReleaseAsset_GetState(tt *testing.T) {
 16329  	var zeroValue string
 16330  	r := &ReleaseAsset{State: &zeroValue}
 16331  	r.GetState()
 16332  	r = &ReleaseAsset{}
 16333  	r.GetState()
 16334  	r = nil
 16335  	r.GetState()
 16336  }
 16337  
 16338  func TestReleaseAsset_GetUpdatedAt(tt *testing.T) {
 16339  	var zeroValue Timestamp
 16340  	r := &ReleaseAsset{UpdatedAt: &zeroValue}
 16341  	r.GetUpdatedAt()
 16342  	r = &ReleaseAsset{}
 16343  	r.GetUpdatedAt()
 16344  	r = nil
 16345  	r.GetUpdatedAt()
 16346  }
 16347  
 16348  func TestReleaseAsset_GetUploader(tt *testing.T) {
 16349  	r := &ReleaseAsset{}
 16350  	r.GetUploader()
 16351  	r = nil
 16352  	r.GetUploader()
 16353  }
 16354  
 16355  func TestReleaseAsset_GetURL(tt *testing.T) {
 16356  	var zeroValue string
 16357  	r := &ReleaseAsset{URL: &zeroValue}
 16358  	r.GetURL()
 16359  	r = &ReleaseAsset{}
 16360  	r.GetURL()
 16361  	r = nil
 16362  	r.GetURL()
 16363  }
 16364  
 16365  func TestReleaseEvent_GetAction(tt *testing.T) {
 16366  	var zeroValue string
 16367  	r := &ReleaseEvent{Action: &zeroValue}
 16368  	r.GetAction()
 16369  	r = &ReleaseEvent{}
 16370  	r.GetAction()
 16371  	r = nil
 16372  	r.GetAction()
 16373  }
 16374  
 16375  func TestReleaseEvent_GetInstallation(tt *testing.T) {
 16376  	r := &ReleaseEvent{}
 16377  	r.GetInstallation()
 16378  	r = nil
 16379  	r.GetInstallation()
 16380  }
 16381  
 16382  func TestReleaseEvent_GetRelease(tt *testing.T) {
 16383  	r := &ReleaseEvent{}
 16384  	r.GetRelease()
 16385  	r = nil
 16386  	r.GetRelease()
 16387  }
 16388  
 16389  func TestReleaseEvent_GetRepo(tt *testing.T) {
 16390  	r := &ReleaseEvent{}
 16391  	r.GetRepo()
 16392  	r = nil
 16393  	r.GetRepo()
 16394  }
 16395  
 16396  func TestReleaseEvent_GetSender(tt *testing.T) {
 16397  	r := &ReleaseEvent{}
 16398  	r.GetSender()
 16399  	r = nil
 16400  	r.GetSender()
 16401  }
 16402  
 16403  func TestRemoveToken_GetExpiresAt(tt *testing.T) {
 16404  	var zeroValue Timestamp
 16405  	r := &RemoveToken{ExpiresAt: &zeroValue}
 16406  	r.GetExpiresAt()
 16407  	r = &RemoveToken{}
 16408  	r.GetExpiresAt()
 16409  	r = nil
 16410  	r.GetExpiresAt()
 16411  }
 16412  
 16413  func TestRemoveToken_GetToken(tt *testing.T) {
 16414  	var zeroValue string
 16415  	r := &RemoveToken{Token: &zeroValue}
 16416  	r.GetToken()
 16417  	r = &RemoveToken{}
 16418  	r.GetToken()
 16419  	r = nil
 16420  	r.GetToken()
 16421  }
 16422  
 16423  func TestRename_GetFrom(tt *testing.T) {
 16424  	var zeroValue string
 16425  	r := &Rename{From: &zeroValue}
 16426  	r.GetFrom()
 16427  	r = &Rename{}
 16428  	r.GetFrom()
 16429  	r = nil
 16430  	r.GetFrom()
 16431  }
 16432  
 16433  func TestRename_GetTo(tt *testing.T) {
 16434  	var zeroValue string
 16435  	r := &Rename{To: &zeroValue}
 16436  	r.GetTo()
 16437  	r = &Rename{}
 16438  	r.GetTo()
 16439  	r = nil
 16440  	r.GetTo()
 16441  }
 16442  
 16443  func TestRenameOrgResponse_GetMessage(tt *testing.T) {
 16444  	var zeroValue string
 16445  	r := &RenameOrgResponse{Message: &zeroValue}
 16446  	r.GetMessage()
 16447  	r = &RenameOrgResponse{}
 16448  	r.GetMessage()
 16449  	r = nil
 16450  	r.GetMessage()
 16451  }
 16452  
 16453  func TestRenameOrgResponse_GetURL(tt *testing.T) {
 16454  	var zeroValue string
 16455  	r := &RenameOrgResponse{URL: &zeroValue}
 16456  	r.GetURL()
 16457  	r = &RenameOrgResponse{}
 16458  	r.GetURL()
 16459  	r = nil
 16460  	r.GetURL()
 16461  }
 16462  
 16463  func TestRepoMergeUpstreamRequest_GetBranch(tt *testing.T) {
 16464  	var zeroValue string
 16465  	r := &RepoMergeUpstreamRequest{Branch: &zeroValue}
 16466  	r.GetBranch()
 16467  	r = &RepoMergeUpstreamRequest{}
 16468  	r.GetBranch()
 16469  	r = nil
 16470  	r.GetBranch()
 16471  }
 16472  
 16473  func TestRepoMergeUpstreamResult_GetBaseBranch(tt *testing.T) {
 16474  	var zeroValue string
 16475  	r := &RepoMergeUpstreamResult{BaseBranch: &zeroValue}
 16476  	r.GetBaseBranch()
 16477  	r = &RepoMergeUpstreamResult{}
 16478  	r.GetBaseBranch()
 16479  	r = nil
 16480  	r.GetBaseBranch()
 16481  }
 16482  
 16483  func TestRepoMergeUpstreamResult_GetMergeType(tt *testing.T) {
 16484  	var zeroValue string
 16485  	r := &RepoMergeUpstreamResult{MergeType: &zeroValue}
 16486  	r.GetMergeType()
 16487  	r = &RepoMergeUpstreamResult{}
 16488  	r.GetMergeType()
 16489  	r = nil
 16490  	r.GetMergeType()
 16491  }
 16492  
 16493  func TestRepoMergeUpstreamResult_GetMessage(tt *testing.T) {
 16494  	var zeroValue string
 16495  	r := &RepoMergeUpstreamResult{Message: &zeroValue}
 16496  	r.GetMessage()
 16497  	r = &RepoMergeUpstreamResult{}
 16498  	r.GetMessage()
 16499  	r = nil
 16500  	r.GetMessage()
 16501  }
 16502  
 16503  func TestRepoName_GetFrom(tt *testing.T) {
 16504  	var zeroValue string
 16505  	r := &RepoName{From: &zeroValue}
 16506  	r.GetFrom()
 16507  	r = &RepoName{}
 16508  	r.GetFrom()
 16509  	r = nil
 16510  	r.GetFrom()
 16511  }
 16512  
 16513  func TestRepositoriesSearchResult_GetIncompleteResults(tt *testing.T) {
 16514  	var zeroValue bool
 16515  	r := &RepositoriesSearchResult{IncompleteResults: &zeroValue}
 16516  	r.GetIncompleteResults()
 16517  	r = &RepositoriesSearchResult{}
 16518  	r.GetIncompleteResults()
 16519  	r = nil
 16520  	r.GetIncompleteResults()
 16521  }
 16522  
 16523  func TestRepositoriesSearchResult_GetTotal(tt *testing.T) {
 16524  	var zeroValue int
 16525  	r := &RepositoriesSearchResult{Total: &zeroValue}
 16526  	r.GetTotal()
 16527  	r = &RepositoriesSearchResult{}
 16528  	r.GetTotal()
 16529  	r = nil
 16530  	r.GetTotal()
 16531  }
 16532  
 16533  func TestRepository_GetAllowAutoMerge(tt *testing.T) {
 16534  	var zeroValue bool
 16535  	r := &Repository{AllowAutoMerge: &zeroValue}
 16536  	r.GetAllowAutoMerge()
 16537  	r = &Repository{}
 16538  	r.GetAllowAutoMerge()
 16539  	r = nil
 16540  	r.GetAllowAutoMerge()
 16541  }
 16542  
 16543  func TestRepository_GetAllowForking(tt *testing.T) {
 16544  	var zeroValue bool
 16545  	r := &Repository{AllowForking: &zeroValue}
 16546  	r.GetAllowForking()
 16547  	r = &Repository{}
 16548  	r.GetAllowForking()
 16549  	r = nil
 16550  	r.GetAllowForking()
 16551  }
 16552  
 16553  func TestRepository_GetAllowMergeCommit(tt *testing.T) {
 16554  	var zeroValue bool
 16555  	r := &Repository{AllowMergeCommit: &zeroValue}
 16556  	r.GetAllowMergeCommit()
 16557  	r = &Repository{}
 16558  	r.GetAllowMergeCommit()
 16559  	r = nil
 16560  	r.GetAllowMergeCommit()
 16561  }
 16562  
 16563  func TestRepository_GetAllowRebaseMerge(tt *testing.T) {
 16564  	var zeroValue bool
 16565  	r := &Repository{AllowRebaseMerge: &zeroValue}
 16566  	r.GetAllowRebaseMerge()
 16567  	r = &Repository{}
 16568  	r.GetAllowRebaseMerge()
 16569  	r = nil
 16570  	r.GetAllowRebaseMerge()
 16571  }
 16572  
 16573  func TestRepository_GetAllowSquashMerge(tt *testing.T) {
 16574  	var zeroValue bool
 16575  	r := &Repository{AllowSquashMerge: &zeroValue}
 16576  	r.GetAllowSquashMerge()
 16577  	r = &Repository{}
 16578  	r.GetAllowSquashMerge()
 16579  	r = nil
 16580  	r.GetAllowSquashMerge()
 16581  }
 16582  
 16583  func TestRepository_GetAllowUpdateBranch(tt *testing.T) {
 16584  	var zeroValue bool
 16585  	r := &Repository{AllowUpdateBranch: &zeroValue}
 16586  	r.GetAllowUpdateBranch()
 16587  	r = &Repository{}
 16588  	r.GetAllowUpdateBranch()
 16589  	r = nil
 16590  	r.GetAllowUpdateBranch()
 16591  }
 16592  
 16593  func TestRepository_GetArchived(tt *testing.T) {
 16594  	var zeroValue bool
 16595  	r := &Repository{Archived: &zeroValue}
 16596  	r.GetArchived()
 16597  	r = &Repository{}
 16598  	r.GetArchived()
 16599  	r = nil
 16600  	r.GetArchived()
 16601  }
 16602  
 16603  func TestRepository_GetArchiveURL(tt *testing.T) {
 16604  	var zeroValue string
 16605  	r := &Repository{ArchiveURL: &zeroValue}
 16606  	r.GetArchiveURL()
 16607  	r = &Repository{}
 16608  	r.GetArchiveURL()
 16609  	r = nil
 16610  	r.GetArchiveURL()
 16611  }
 16612  
 16613  func TestRepository_GetAssigneesURL(tt *testing.T) {
 16614  	var zeroValue string
 16615  	r := &Repository{AssigneesURL: &zeroValue}
 16616  	r.GetAssigneesURL()
 16617  	r = &Repository{}
 16618  	r.GetAssigneesURL()
 16619  	r = nil
 16620  	r.GetAssigneesURL()
 16621  }
 16622  
 16623  func TestRepository_GetAutoInit(tt *testing.T) {
 16624  	var zeroValue bool
 16625  	r := &Repository{AutoInit: &zeroValue}
 16626  	r.GetAutoInit()
 16627  	r = &Repository{}
 16628  	r.GetAutoInit()
 16629  	r = nil
 16630  	r.GetAutoInit()
 16631  }
 16632  
 16633  func TestRepository_GetBlobsURL(tt *testing.T) {
 16634  	var zeroValue string
 16635  	r := &Repository{BlobsURL: &zeroValue}
 16636  	r.GetBlobsURL()
 16637  	r = &Repository{}
 16638  	r.GetBlobsURL()
 16639  	r = nil
 16640  	r.GetBlobsURL()
 16641  }
 16642  
 16643  func TestRepository_GetBranchesURL(tt *testing.T) {
 16644  	var zeroValue string
 16645  	r := &Repository{BranchesURL: &zeroValue}
 16646  	r.GetBranchesURL()
 16647  	r = &Repository{}
 16648  	r.GetBranchesURL()
 16649  	r = nil
 16650  	r.GetBranchesURL()
 16651  }
 16652  
 16653  func TestRepository_GetCloneURL(tt *testing.T) {
 16654  	var zeroValue string
 16655  	r := &Repository{CloneURL: &zeroValue}
 16656  	r.GetCloneURL()
 16657  	r = &Repository{}
 16658  	r.GetCloneURL()
 16659  	r = nil
 16660  	r.GetCloneURL()
 16661  }
 16662  
 16663  func TestRepository_GetCodeOfConduct(tt *testing.T) {
 16664  	r := &Repository{}
 16665  	r.GetCodeOfConduct()
 16666  	r = nil
 16667  	r.GetCodeOfConduct()
 16668  }
 16669  
 16670  func TestRepository_GetCollaboratorsURL(tt *testing.T) {
 16671  	var zeroValue string
 16672  	r := &Repository{CollaboratorsURL: &zeroValue}
 16673  	r.GetCollaboratorsURL()
 16674  	r = &Repository{}
 16675  	r.GetCollaboratorsURL()
 16676  	r = nil
 16677  	r.GetCollaboratorsURL()
 16678  }
 16679  
 16680  func TestRepository_GetCommentsURL(tt *testing.T) {
 16681  	var zeroValue string
 16682  	r := &Repository{CommentsURL: &zeroValue}
 16683  	r.GetCommentsURL()
 16684  	r = &Repository{}
 16685  	r.GetCommentsURL()
 16686  	r = nil
 16687  	r.GetCommentsURL()
 16688  }
 16689  
 16690  func TestRepository_GetCommitsURL(tt *testing.T) {
 16691  	var zeroValue string
 16692  	r := &Repository{CommitsURL: &zeroValue}
 16693  	r.GetCommitsURL()
 16694  	r = &Repository{}
 16695  	r.GetCommitsURL()
 16696  	r = nil
 16697  	r.GetCommitsURL()
 16698  }
 16699  
 16700  func TestRepository_GetCompareURL(tt *testing.T) {
 16701  	var zeroValue string
 16702  	r := &Repository{CompareURL: &zeroValue}
 16703  	r.GetCompareURL()
 16704  	r = &Repository{}
 16705  	r.GetCompareURL()
 16706  	r = nil
 16707  	r.GetCompareURL()
 16708  }
 16709  
 16710  func TestRepository_GetContentsURL(tt *testing.T) {
 16711  	var zeroValue string
 16712  	r := &Repository{ContentsURL: &zeroValue}
 16713  	r.GetContentsURL()
 16714  	r = &Repository{}
 16715  	r.GetContentsURL()
 16716  	r = nil
 16717  	r.GetContentsURL()
 16718  }
 16719  
 16720  func TestRepository_GetContributorsURL(tt *testing.T) {
 16721  	var zeroValue string
 16722  	r := &Repository{ContributorsURL: &zeroValue}
 16723  	r.GetContributorsURL()
 16724  	r = &Repository{}
 16725  	r.GetContributorsURL()
 16726  	r = nil
 16727  	r.GetContributorsURL()
 16728  }
 16729  
 16730  func TestRepository_GetCreatedAt(tt *testing.T) {
 16731  	var zeroValue Timestamp
 16732  	r := &Repository{CreatedAt: &zeroValue}
 16733  	r.GetCreatedAt()
 16734  	r = &Repository{}
 16735  	r.GetCreatedAt()
 16736  	r = nil
 16737  	r.GetCreatedAt()
 16738  }
 16739  
 16740  func TestRepository_GetDefaultBranch(tt *testing.T) {
 16741  	var zeroValue string
 16742  	r := &Repository{DefaultBranch: &zeroValue}
 16743  	r.GetDefaultBranch()
 16744  	r = &Repository{}
 16745  	r.GetDefaultBranch()
 16746  	r = nil
 16747  	r.GetDefaultBranch()
 16748  }
 16749  
 16750  func TestRepository_GetDeleteBranchOnMerge(tt *testing.T) {
 16751  	var zeroValue bool
 16752  	r := &Repository{DeleteBranchOnMerge: &zeroValue}
 16753  	r.GetDeleteBranchOnMerge()
 16754  	r = &Repository{}
 16755  	r.GetDeleteBranchOnMerge()
 16756  	r = nil
 16757  	r.GetDeleteBranchOnMerge()
 16758  }
 16759  
 16760  func TestRepository_GetDeploymentsURL(tt *testing.T) {
 16761  	var zeroValue string
 16762  	r := &Repository{DeploymentsURL: &zeroValue}
 16763  	r.GetDeploymentsURL()
 16764  	r = &Repository{}
 16765  	r.GetDeploymentsURL()
 16766  	r = nil
 16767  	r.GetDeploymentsURL()
 16768  }
 16769  
 16770  func TestRepository_GetDescription(tt *testing.T) {
 16771  	var zeroValue string
 16772  	r := &Repository{Description: &zeroValue}
 16773  	r.GetDescription()
 16774  	r = &Repository{}
 16775  	r.GetDescription()
 16776  	r = nil
 16777  	r.GetDescription()
 16778  }
 16779  
 16780  func TestRepository_GetDisabled(tt *testing.T) {
 16781  	var zeroValue bool
 16782  	r := &Repository{Disabled: &zeroValue}
 16783  	r.GetDisabled()
 16784  	r = &Repository{}
 16785  	r.GetDisabled()
 16786  	r = nil
 16787  	r.GetDisabled()
 16788  }
 16789  
 16790  func TestRepository_GetDownloadsURL(tt *testing.T) {
 16791  	var zeroValue string
 16792  	r := &Repository{DownloadsURL: &zeroValue}
 16793  	r.GetDownloadsURL()
 16794  	r = &Repository{}
 16795  	r.GetDownloadsURL()
 16796  	r = nil
 16797  	r.GetDownloadsURL()
 16798  }
 16799  
 16800  func TestRepository_GetEventsURL(tt *testing.T) {
 16801  	var zeroValue string
 16802  	r := &Repository{EventsURL: &zeroValue}
 16803  	r.GetEventsURL()
 16804  	r = &Repository{}
 16805  	r.GetEventsURL()
 16806  	r = nil
 16807  	r.GetEventsURL()
 16808  }
 16809  
 16810  func TestRepository_GetFork(tt *testing.T) {
 16811  	var zeroValue bool
 16812  	r := &Repository{Fork: &zeroValue}
 16813  	r.GetFork()
 16814  	r = &Repository{}
 16815  	r.GetFork()
 16816  	r = nil
 16817  	r.GetFork()
 16818  }
 16819  
 16820  func TestRepository_GetForksCount(tt *testing.T) {
 16821  	var zeroValue int
 16822  	r := &Repository{ForksCount: &zeroValue}
 16823  	r.GetForksCount()
 16824  	r = &Repository{}
 16825  	r.GetForksCount()
 16826  	r = nil
 16827  	r.GetForksCount()
 16828  }
 16829  
 16830  func TestRepository_GetForksURL(tt *testing.T) {
 16831  	var zeroValue string
 16832  	r := &Repository{ForksURL: &zeroValue}
 16833  	r.GetForksURL()
 16834  	r = &Repository{}
 16835  	r.GetForksURL()
 16836  	r = nil
 16837  	r.GetForksURL()
 16838  }
 16839  
 16840  func TestRepository_GetFullName(tt *testing.T) {
 16841  	var zeroValue string
 16842  	r := &Repository{FullName: &zeroValue}
 16843  	r.GetFullName()
 16844  	r = &Repository{}
 16845  	r.GetFullName()
 16846  	r = nil
 16847  	r.GetFullName()
 16848  }
 16849  
 16850  func TestRepository_GetGitCommitsURL(tt *testing.T) {
 16851  	var zeroValue string
 16852  	r := &Repository{GitCommitsURL: &zeroValue}
 16853  	r.GetGitCommitsURL()
 16854  	r = &Repository{}
 16855  	r.GetGitCommitsURL()
 16856  	r = nil
 16857  	r.GetGitCommitsURL()
 16858  }
 16859  
 16860  func TestRepository_GetGitignoreTemplate(tt *testing.T) {
 16861  	var zeroValue string
 16862  	r := &Repository{GitignoreTemplate: &zeroValue}
 16863  	r.GetGitignoreTemplate()
 16864  	r = &Repository{}
 16865  	r.GetGitignoreTemplate()
 16866  	r = nil
 16867  	r.GetGitignoreTemplate()
 16868  }
 16869  
 16870  func TestRepository_GetGitRefsURL(tt *testing.T) {
 16871  	var zeroValue string
 16872  	r := &Repository{GitRefsURL: &zeroValue}
 16873  	r.GetGitRefsURL()
 16874  	r = &Repository{}
 16875  	r.GetGitRefsURL()
 16876  	r = nil
 16877  	r.GetGitRefsURL()
 16878  }
 16879  
 16880  func TestRepository_GetGitTagsURL(tt *testing.T) {
 16881  	var zeroValue string
 16882  	r := &Repository{GitTagsURL: &zeroValue}
 16883  	r.GetGitTagsURL()
 16884  	r = &Repository{}
 16885  	r.GetGitTagsURL()
 16886  	r = nil
 16887  	r.GetGitTagsURL()
 16888  }
 16889  
 16890  func TestRepository_GetGitURL(tt *testing.T) {
 16891  	var zeroValue string
 16892  	r := &Repository{GitURL: &zeroValue}
 16893  	r.GetGitURL()
 16894  	r = &Repository{}
 16895  	r.GetGitURL()
 16896  	r = nil
 16897  	r.GetGitURL()
 16898  }
 16899  
 16900  func TestRepository_GetHasDownloads(tt *testing.T) {
 16901  	var zeroValue bool
 16902  	r := &Repository{HasDownloads: &zeroValue}
 16903  	r.GetHasDownloads()
 16904  	r = &Repository{}
 16905  	r.GetHasDownloads()
 16906  	r = nil
 16907  	r.GetHasDownloads()
 16908  }
 16909  
 16910  func TestRepository_GetHasIssues(tt *testing.T) {
 16911  	var zeroValue bool
 16912  	r := &Repository{HasIssues: &zeroValue}
 16913  	r.GetHasIssues()
 16914  	r = &Repository{}
 16915  	r.GetHasIssues()
 16916  	r = nil
 16917  	r.GetHasIssues()
 16918  }
 16919  
 16920  func TestRepository_GetHasPages(tt *testing.T) {
 16921  	var zeroValue bool
 16922  	r := &Repository{HasPages: &zeroValue}
 16923  	r.GetHasPages()
 16924  	r = &Repository{}
 16925  	r.GetHasPages()
 16926  	r = nil
 16927  	r.GetHasPages()
 16928  }
 16929  
 16930  func TestRepository_GetHasProjects(tt *testing.T) {
 16931  	var zeroValue bool
 16932  	r := &Repository{HasProjects: &zeroValue}
 16933  	r.GetHasProjects()
 16934  	r = &Repository{}
 16935  	r.GetHasProjects()
 16936  	r = nil
 16937  	r.GetHasProjects()
 16938  }
 16939  
 16940  func TestRepository_GetHasWiki(tt *testing.T) {
 16941  	var zeroValue bool
 16942  	r := &Repository{HasWiki: &zeroValue}
 16943  	r.GetHasWiki()
 16944  	r = &Repository{}
 16945  	r.GetHasWiki()
 16946  	r = nil
 16947  	r.GetHasWiki()
 16948  }
 16949  
 16950  func TestRepository_GetHomepage(tt *testing.T) {
 16951  	var zeroValue string
 16952  	r := &Repository{Homepage: &zeroValue}
 16953  	r.GetHomepage()
 16954  	r = &Repository{}
 16955  	r.GetHomepage()
 16956  	r = nil
 16957  	r.GetHomepage()
 16958  }
 16959  
 16960  func TestRepository_GetHooksURL(tt *testing.T) {
 16961  	var zeroValue string
 16962  	r := &Repository{HooksURL: &zeroValue}
 16963  	r.GetHooksURL()
 16964  	r = &Repository{}
 16965  	r.GetHooksURL()
 16966  	r = nil
 16967  	r.GetHooksURL()
 16968  }
 16969  
 16970  func TestRepository_GetHTMLURL(tt *testing.T) {
 16971  	var zeroValue string
 16972  	r := &Repository{HTMLURL: &zeroValue}
 16973  	r.GetHTMLURL()
 16974  	r = &Repository{}
 16975  	r.GetHTMLURL()
 16976  	r = nil
 16977  	r.GetHTMLURL()
 16978  }
 16979  
 16980  func TestRepository_GetID(tt *testing.T) {
 16981  	var zeroValue int64
 16982  	r := &Repository{ID: &zeroValue}
 16983  	r.GetID()
 16984  	r = &Repository{}
 16985  	r.GetID()
 16986  	r = nil
 16987  	r.GetID()
 16988  }
 16989  
 16990  func TestRepository_GetIssueCommentURL(tt *testing.T) {
 16991  	var zeroValue string
 16992  	r := &Repository{IssueCommentURL: &zeroValue}
 16993  	r.GetIssueCommentURL()
 16994  	r = &Repository{}
 16995  	r.GetIssueCommentURL()
 16996  	r = nil
 16997  	r.GetIssueCommentURL()
 16998  }
 16999  
 17000  func TestRepository_GetIssueEventsURL(tt *testing.T) {
 17001  	var zeroValue string
 17002  	r := &Repository{IssueEventsURL: &zeroValue}
 17003  	r.GetIssueEventsURL()
 17004  	r = &Repository{}
 17005  	r.GetIssueEventsURL()
 17006  	r = nil
 17007  	r.GetIssueEventsURL()
 17008  }
 17009  
 17010  func TestRepository_GetIssuesURL(tt *testing.T) {
 17011  	var zeroValue string
 17012  	r := &Repository{IssuesURL: &zeroValue}
 17013  	r.GetIssuesURL()
 17014  	r = &Repository{}
 17015  	r.GetIssuesURL()
 17016  	r = nil
 17017  	r.GetIssuesURL()
 17018  }
 17019  
 17020  func TestRepository_GetIsTemplate(tt *testing.T) {
 17021  	var zeroValue bool
 17022  	r := &Repository{IsTemplate: &zeroValue}
 17023  	r.GetIsTemplate()
 17024  	r = &Repository{}
 17025  	r.GetIsTemplate()
 17026  	r = nil
 17027  	r.GetIsTemplate()
 17028  }
 17029  
 17030  func TestRepository_GetKeysURL(tt *testing.T) {
 17031  	var zeroValue string
 17032  	r := &Repository{KeysURL: &zeroValue}
 17033  	r.GetKeysURL()
 17034  	r = &Repository{}
 17035  	r.GetKeysURL()
 17036  	r = nil
 17037  	r.GetKeysURL()
 17038  }
 17039  
 17040  func TestRepository_GetLabelsURL(tt *testing.T) {
 17041  	var zeroValue string
 17042  	r := &Repository{LabelsURL: &zeroValue}
 17043  	r.GetLabelsURL()
 17044  	r = &Repository{}
 17045  	r.GetLabelsURL()
 17046  	r = nil
 17047  	r.GetLabelsURL()
 17048  }
 17049  
 17050  func TestRepository_GetLanguage(tt *testing.T) {
 17051  	var zeroValue string
 17052  	r := &Repository{Language: &zeroValue}
 17053  	r.GetLanguage()
 17054  	r = &Repository{}
 17055  	r.GetLanguage()
 17056  	r = nil
 17057  	r.GetLanguage()
 17058  }
 17059  
 17060  func TestRepository_GetLanguagesURL(tt *testing.T) {
 17061  	var zeroValue string
 17062  	r := &Repository{LanguagesURL: &zeroValue}
 17063  	r.GetLanguagesURL()
 17064  	r = &Repository{}
 17065  	r.GetLanguagesURL()
 17066  	r = nil
 17067  	r.GetLanguagesURL()
 17068  }
 17069  
 17070  func TestRepository_GetLicense(tt *testing.T) {
 17071  	r := &Repository{}
 17072  	r.GetLicense()
 17073  	r = nil
 17074  	r.GetLicense()
 17075  }
 17076  
 17077  func TestRepository_GetLicenseTemplate(tt *testing.T) {
 17078  	var zeroValue string
 17079  	r := &Repository{LicenseTemplate: &zeroValue}
 17080  	r.GetLicenseTemplate()
 17081  	r = &Repository{}
 17082  	r.GetLicenseTemplate()
 17083  	r = nil
 17084  	r.GetLicenseTemplate()
 17085  }
 17086  
 17087  func TestRepository_GetMasterBranch(tt *testing.T) {
 17088  	var zeroValue string
 17089  	r := &Repository{MasterBranch: &zeroValue}
 17090  	r.GetMasterBranch()
 17091  	r = &Repository{}
 17092  	r.GetMasterBranch()
 17093  	r = nil
 17094  	r.GetMasterBranch()
 17095  }
 17096  
 17097  func TestRepository_GetMergeCommitMessage(tt *testing.T) {
 17098  	var zeroValue string
 17099  	r := &Repository{MergeCommitMessage: &zeroValue}
 17100  	r.GetMergeCommitMessage()
 17101  	r = &Repository{}
 17102  	r.GetMergeCommitMessage()
 17103  	r = nil
 17104  	r.GetMergeCommitMessage()
 17105  }
 17106  
 17107  func TestRepository_GetMergeCommitTitle(tt *testing.T) {
 17108  	var zeroValue string
 17109  	r := &Repository{MergeCommitTitle: &zeroValue}
 17110  	r.GetMergeCommitTitle()
 17111  	r = &Repository{}
 17112  	r.GetMergeCommitTitle()
 17113  	r = nil
 17114  	r.GetMergeCommitTitle()
 17115  }
 17116  
 17117  func TestRepository_GetMergesURL(tt *testing.T) {
 17118  	var zeroValue string
 17119  	r := &Repository{MergesURL: &zeroValue}
 17120  	r.GetMergesURL()
 17121  	r = &Repository{}
 17122  	r.GetMergesURL()
 17123  	r = nil
 17124  	r.GetMergesURL()
 17125  }
 17126  
 17127  func TestRepository_GetMilestonesURL(tt *testing.T) {
 17128  	var zeroValue string
 17129  	r := &Repository{MilestonesURL: &zeroValue}
 17130  	r.GetMilestonesURL()
 17131  	r = &Repository{}
 17132  	r.GetMilestonesURL()
 17133  	r = nil
 17134  	r.GetMilestonesURL()
 17135  }
 17136  
 17137  func TestRepository_GetMirrorURL(tt *testing.T) {
 17138  	var zeroValue string
 17139  	r := &Repository{MirrorURL: &zeroValue}
 17140  	r.GetMirrorURL()
 17141  	r = &Repository{}
 17142  	r.GetMirrorURL()
 17143  	r = nil
 17144  	r.GetMirrorURL()
 17145  }
 17146  
 17147  func TestRepository_GetName(tt *testing.T) {
 17148  	var zeroValue string
 17149  	r := &Repository{Name: &zeroValue}
 17150  	r.GetName()
 17151  	r = &Repository{}
 17152  	r.GetName()
 17153  	r = nil
 17154  	r.GetName()
 17155  }
 17156  
 17157  func TestRepository_GetNetworkCount(tt *testing.T) {
 17158  	var zeroValue int
 17159  	r := &Repository{NetworkCount: &zeroValue}
 17160  	r.GetNetworkCount()
 17161  	r = &Repository{}
 17162  	r.GetNetworkCount()
 17163  	r = nil
 17164  	r.GetNetworkCount()
 17165  }
 17166  
 17167  func TestRepository_GetNodeID(tt *testing.T) {
 17168  	var zeroValue string
 17169  	r := &Repository{NodeID: &zeroValue}
 17170  	r.GetNodeID()
 17171  	r = &Repository{}
 17172  	r.GetNodeID()
 17173  	r = nil
 17174  	r.GetNodeID()
 17175  }
 17176  
 17177  func TestRepository_GetNotificationsURL(tt *testing.T) {
 17178  	var zeroValue string
 17179  	r := &Repository{NotificationsURL: &zeroValue}
 17180  	r.GetNotificationsURL()
 17181  	r = &Repository{}
 17182  	r.GetNotificationsURL()
 17183  	r = nil
 17184  	r.GetNotificationsURL()
 17185  }
 17186  
 17187  func TestRepository_GetOpenIssues(tt *testing.T) {
 17188  	var zeroValue int
 17189  	r := &Repository{OpenIssues: &zeroValue}
 17190  	r.GetOpenIssues()
 17191  	r = &Repository{}
 17192  	r.GetOpenIssues()
 17193  	r = nil
 17194  	r.GetOpenIssues()
 17195  }
 17196  
 17197  func TestRepository_GetOpenIssuesCount(tt *testing.T) {
 17198  	var zeroValue int
 17199  	r := &Repository{OpenIssuesCount: &zeroValue}
 17200  	r.GetOpenIssuesCount()
 17201  	r = &Repository{}
 17202  	r.GetOpenIssuesCount()
 17203  	r = nil
 17204  	r.GetOpenIssuesCount()
 17205  }
 17206  
 17207  func TestRepository_GetOrganization(tt *testing.T) {
 17208  	r := &Repository{}
 17209  	r.GetOrganization()
 17210  	r = nil
 17211  	r.GetOrganization()
 17212  }
 17213  
 17214  func TestRepository_GetOwner(tt *testing.T) {
 17215  	r := &Repository{}
 17216  	r.GetOwner()
 17217  	r = nil
 17218  	r.GetOwner()
 17219  }
 17220  
 17221  func TestRepository_GetParent(tt *testing.T) {
 17222  	r := &Repository{}
 17223  	r.GetParent()
 17224  	r = nil
 17225  	r.GetParent()
 17226  }
 17227  
 17228  func TestRepository_GetPermissions(tt *testing.T) {
 17229  	zeroValue := map[string]bool{}
 17230  	r := &Repository{Permissions: zeroValue}
 17231  	r.GetPermissions()
 17232  	r = &Repository{}
 17233  	r.GetPermissions()
 17234  	r = nil
 17235  	r.GetPermissions()
 17236  }
 17237  
 17238  func TestRepository_GetPrivate(tt *testing.T) {
 17239  	var zeroValue bool
 17240  	r := &Repository{Private: &zeroValue}
 17241  	r.GetPrivate()
 17242  	r = &Repository{}
 17243  	r.GetPrivate()
 17244  	r = nil
 17245  	r.GetPrivate()
 17246  }
 17247  
 17248  func TestRepository_GetPullsURL(tt *testing.T) {
 17249  	var zeroValue string
 17250  	r := &Repository{PullsURL: &zeroValue}
 17251  	r.GetPullsURL()
 17252  	r = &Repository{}
 17253  	r.GetPullsURL()
 17254  	r = nil
 17255  	r.GetPullsURL()
 17256  }
 17257  
 17258  func TestRepository_GetPushedAt(tt *testing.T) {
 17259  	var zeroValue Timestamp
 17260  	r := &Repository{PushedAt: &zeroValue}
 17261  	r.GetPushedAt()
 17262  	r = &Repository{}
 17263  	r.GetPushedAt()
 17264  	r = nil
 17265  	r.GetPushedAt()
 17266  }
 17267  
 17268  func TestRepository_GetReleasesURL(tt *testing.T) {
 17269  	var zeroValue string
 17270  	r := &Repository{ReleasesURL: &zeroValue}
 17271  	r.GetReleasesURL()
 17272  	r = &Repository{}
 17273  	r.GetReleasesURL()
 17274  	r = nil
 17275  	r.GetReleasesURL()
 17276  }
 17277  
 17278  func TestRepository_GetRoleName(tt *testing.T) {
 17279  	var zeroValue string
 17280  	r := &Repository{RoleName: &zeroValue}
 17281  	r.GetRoleName()
 17282  	r = &Repository{}
 17283  	r.GetRoleName()
 17284  	r = nil
 17285  	r.GetRoleName()
 17286  }
 17287  
 17288  func TestRepository_GetSecurityAndAnalysis(tt *testing.T) {
 17289  	r := &Repository{}
 17290  	r.GetSecurityAndAnalysis()
 17291  	r = nil
 17292  	r.GetSecurityAndAnalysis()
 17293  }
 17294  
 17295  func TestRepository_GetSize(tt *testing.T) {
 17296  	var zeroValue int
 17297  	r := &Repository{Size: &zeroValue}
 17298  	r.GetSize()
 17299  	r = &Repository{}
 17300  	r.GetSize()
 17301  	r = nil
 17302  	r.GetSize()
 17303  }
 17304  
 17305  func TestRepository_GetSource(tt *testing.T) {
 17306  	r := &Repository{}
 17307  	r.GetSource()
 17308  	r = nil
 17309  	r.GetSource()
 17310  }
 17311  
 17312  func TestRepository_GetSquashMergeCommitMessage(tt *testing.T) {
 17313  	var zeroValue string
 17314  	r := &Repository{SquashMergeCommitMessage: &zeroValue}
 17315  	r.GetSquashMergeCommitMessage()
 17316  	r = &Repository{}
 17317  	r.GetSquashMergeCommitMessage()
 17318  	r = nil
 17319  	r.GetSquashMergeCommitMessage()
 17320  }
 17321  
 17322  func TestRepository_GetSquashMergeCommitTitle(tt *testing.T) {
 17323  	var zeroValue string
 17324  	r := &Repository{SquashMergeCommitTitle: &zeroValue}
 17325  	r.GetSquashMergeCommitTitle()
 17326  	r = &Repository{}
 17327  	r.GetSquashMergeCommitTitle()
 17328  	r = nil
 17329  	r.GetSquashMergeCommitTitle()
 17330  }
 17331  
 17332  func TestRepository_GetSSHURL(tt *testing.T) {
 17333  	var zeroValue string
 17334  	r := &Repository{SSHURL: &zeroValue}
 17335  	r.GetSSHURL()
 17336  	r = &Repository{}
 17337  	r.GetSSHURL()
 17338  	r = nil
 17339  	r.GetSSHURL()
 17340  }
 17341  
 17342  func TestRepository_GetStargazersCount(tt *testing.T) {
 17343  	var zeroValue int
 17344  	r := &Repository{StargazersCount: &zeroValue}
 17345  	r.GetStargazersCount()
 17346  	r = &Repository{}
 17347  	r.GetStargazersCount()
 17348  	r = nil
 17349  	r.GetStargazersCount()
 17350  }
 17351  
 17352  func TestRepository_GetStargazersURL(tt *testing.T) {
 17353  	var zeroValue string
 17354  	r := &Repository{StargazersURL: &zeroValue}
 17355  	r.GetStargazersURL()
 17356  	r = &Repository{}
 17357  	r.GetStargazersURL()
 17358  	r = nil
 17359  	r.GetStargazersURL()
 17360  }
 17361  
 17362  func TestRepository_GetStatusesURL(tt *testing.T) {
 17363  	var zeroValue string
 17364  	r := &Repository{StatusesURL: &zeroValue}
 17365  	r.GetStatusesURL()
 17366  	r = &Repository{}
 17367  	r.GetStatusesURL()
 17368  	r = nil
 17369  	r.GetStatusesURL()
 17370  }
 17371  
 17372  func TestRepository_GetSubscribersCount(tt *testing.T) {
 17373  	var zeroValue int
 17374  	r := &Repository{SubscribersCount: &zeroValue}
 17375  	r.GetSubscribersCount()
 17376  	r = &Repository{}
 17377  	r.GetSubscribersCount()
 17378  	r = nil
 17379  	r.GetSubscribersCount()
 17380  }
 17381  
 17382  func TestRepository_GetSubscribersURL(tt *testing.T) {
 17383  	var zeroValue string
 17384  	r := &Repository{SubscribersURL: &zeroValue}
 17385  	r.GetSubscribersURL()
 17386  	r = &Repository{}
 17387  	r.GetSubscribersURL()
 17388  	r = nil
 17389  	r.GetSubscribersURL()
 17390  }
 17391  
 17392  func TestRepository_GetSubscriptionURL(tt *testing.T) {
 17393  	var zeroValue string
 17394  	r := &Repository{SubscriptionURL: &zeroValue}
 17395  	r.GetSubscriptionURL()
 17396  	r = &Repository{}
 17397  	r.GetSubscriptionURL()
 17398  	r = nil
 17399  	r.GetSubscriptionURL()
 17400  }
 17401  
 17402  func TestRepository_GetSVNURL(tt *testing.T) {
 17403  	var zeroValue string
 17404  	r := &Repository{SVNURL: &zeroValue}
 17405  	r.GetSVNURL()
 17406  	r = &Repository{}
 17407  	r.GetSVNURL()
 17408  	r = nil
 17409  	r.GetSVNURL()
 17410  }
 17411  
 17412  func TestRepository_GetTagsURL(tt *testing.T) {
 17413  	var zeroValue string
 17414  	r := &Repository{TagsURL: &zeroValue}
 17415  	r.GetTagsURL()
 17416  	r = &Repository{}
 17417  	r.GetTagsURL()
 17418  	r = nil
 17419  	r.GetTagsURL()
 17420  }
 17421  
 17422  func TestRepository_GetTeamID(tt *testing.T) {
 17423  	var zeroValue int64
 17424  	r := &Repository{TeamID: &zeroValue}
 17425  	r.GetTeamID()
 17426  	r = &Repository{}
 17427  	r.GetTeamID()
 17428  	r = nil
 17429  	r.GetTeamID()
 17430  }
 17431  
 17432  func TestRepository_GetTeamsURL(tt *testing.T) {
 17433  	var zeroValue string
 17434  	r := &Repository{TeamsURL: &zeroValue}
 17435  	r.GetTeamsURL()
 17436  	r = &Repository{}
 17437  	r.GetTeamsURL()
 17438  	r = nil
 17439  	r.GetTeamsURL()
 17440  }
 17441  
 17442  func TestRepository_GetTemplateRepository(tt *testing.T) {
 17443  	r := &Repository{}
 17444  	r.GetTemplateRepository()
 17445  	r = nil
 17446  	r.GetTemplateRepository()
 17447  }
 17448  
 17449  func TestRepository_GetTreesURL(tt *testing.T) {
 17450  	var zeroValue string
 17451  	r := &Repository{TreesURL: &zeroValue}
 17452  	r.GetTreesURL()
 17453  	r = &Repository{}
 17454  	r.GetTreesURL()
 17455  	r = nil
 17456  	r.GetTreesURL()
 17457  }
 17458  
 17459  func TestRepository_GetUpdatedAt(tt *testing.T) {
 17460  	var zeroValue Timestamp
 17461  	r := &Repository{UpdatedAt: &zeroValue}
 17462  	r.GetUpdatedAt()
 17463  	r = &Repository{}
 17464  	r.GetUpdatedAt()
 17465  	r = nil
 17466  	r.GetUpdatedAt()
 17467  }
 17468  
 17469  func TestRepository_GetURL(tt *testing.T) {
 17470  	var zeroValue string
 17471  	r := &Repository{URL: &zeroValue}
 17472  	r.GetURL()
 17473  	r = &Repository{}
 17474  	r.GetURL()
 17475  	r = nil
 17476  	r.GetURL()
 17477  }
 17478  
 17479  func TestRepository_GetUseSquashPRTitleAsDefault(tt *testing.T) {
 17480  	var zeroValue bool
 17481  	r := &Repository{UseSquashPRTitleAsDefault: &zeroValue}
 17482  	r.GetUseSquashPRTitleAsDefault()
 17483  	r = &Repository{}
 17484  	r.GetUseSquashPRTitleAsDefault()
 17485  	r = nil
 17486  	r.GetUseSquashPRTitleAsDefault()
 17487  }
 17488  
 17489  func TestRepository_GetVisibility(tt *testing.T) {
 17490  	var zeroValue string
 17491  	r := &Repository{Visibility: &zeroValue}
 17492  	r.GetVisibility()
 17493  	r = &Repository{}
 17494  	r.GetVisibility()
 17495  	r = nil
 17496  	r.GetVisibility()
 17497  }
 17498  
 17499  func TestRepository_GetWatchers(tt *testing.T) {
 17500  	var zeroValue int
 17501  	r := &Repository{Watchers: &zeroValue}
 17502  	r.GetWatchers()
 17503  	r = &Repository{}
 17504  	r.GetWatchers()
 17505  	r = nil
 17506  	r.GetWatchers()
 17507  }
 17508  
 17509  func TestRepository_GetWatchersCount(tt *testing.T) {
 17510  	var zeroValue int
 17511  	r := &Repository{WatchersCount: &zeroValue}
 17512  	r.GetWatchersCount()
 17513  	r = &Repository{}
 17514  	r.GetWatchersCount()
 17515  	r = nil
 17516  	r.GetWatchersCount()
 17517  }
 17518  
 17519  func TestRepositoryActiveCommitters_GetAdvancedSecurityCommitters(tt *testing.T) {
 17520  	var zeroValue int
 17521  	r := &RepositoryActiveCommitters{AdvancedSecurityCommitters: &zeroValue}
 17522  	r.GetAdvancedSecurityCommitters()
 17523  	r = &RepositoryActiveCommitters{}
 17524  	r.GetAdvancedSecurityCommitters()
 17525  	r = nil
 17526  	r.GetAdvancedSecurityCommitters()
 17527  }
 17528  
 17529  func TestRepositoryActiveCommitters_GetName(tt *testing.T) {
 17530  	var zeroValue string
 17531  	r := &RepositoryActiveCommitters{Name: &zeroValue}
 17532  	r.GetName()
 17533  	r = &RepositoryActiveCommitters{}
 17534  	r.GetName()
 17535  	r = nil
 17536  	r.GetName()
 17537  }
 17538  
 17539  func TestRepositoryComment_GetBody(tt *testing.T) {
 17540  	var zeroValue string
 17541  	r := &RepositoryComment{Body: &zeroValue}
 17542  	r.GetBody()
 17543  	r = &RepositoryComment{}
 17544  	r.GetBody()
 17545  	r = nil
 17546  	r.GetBody()
 17547  }
 17548  
 17549  func TestRepositoryComment_GetCommitID(tt *testing.T) {
 17550  	var zeroValue string
 17551  	r := &RepositoryComment{CommitID: &zeroValue}
 17552  	r.GetCommitID()
 17553  	r = &RepositoryComment{}
 17554  	r.GetCommitID()
 17555  	r = nil
 17556  	r.GetCommitID()
 17557  }
 17558  
 17559  func TestRepositoryComment_GetCreatedAt(tt *testing.T) {
 17560  	var zeroValue time.Time
 17561  	r := &RepositoryComment{CreatedAt: &zeroValue}
 17562  	r.GetCreatedAt()
 17563  	r = &RepositoryComment{}
 17564  	r.GetCreatedAt()
 17565  	r = nil
 17566  	r.GetCreatedAt()
 17567  }
 17568  
 17569  func TestRepositoryComment_GetHTMLURL(tt *testing.T) {
 17570  	var zeroValue string
 17571  	r := &RepositoryComment{HTMLURL: &zeroValue}
 17572  	r.GetHTMLURL()
 17573  	r = &RepositoryComment{}
 17574  	r.GetHTMLURL()
 17575  	r = nil
 17576  	r.GetHTMLURL()
 17577  }
 17578  
 17579  func TestRepositoryComment_GetID(tt *testing.T) {
 17580  	var zeroValue int64
 17581  	r := &RepositoryComment{ID: &zeroValue}
 17582  	r.GetID()
 17583  	r = &RepositoryComment{}
 17584  	r.GetID()
 17585  	r = nil
 17586  	r.GetID()
 17587  }
 17588  
 17589  func TestRepositoryComment_GetNodeID(tt *testing.T) {
 17590  	var zeroValue string
 17591  	r := &RepositoryComment{NodeID: &zeroValue}
 17592  	r.GetNodeID()
 17593  	r = &RepositoryComment{}
 17594  	r.GetNodeID()
 17595  	r = nil
 17596  	r.GetNodeID()
 17597  }
 17598  
 17599  func TestRepositoryComment_GetPath(tt *testing.T) {
 17600  	var zeroValue string
 17601  	r := &RepositoryComment{Path: &zeroValue}
 17602  	r.GetPath()
 17603  	r = &RepositoryComment{}
 17604  	r.GetPath()
 17605  	r = nil
 17606  	r.GetPath()
 17607  }
 17608  
 17609  func TestRepositoryComment_GetPosition(tt *testing.T) {
 17610  	var zeroValue int
 17611  	r := &RepositoryComment{Position: &zeroValue}
 17612  	r.GetPosition()
 17613  	r = &RepositoryComment{}
 17614  	r.GetPosition()
 17615  	r = nil
 17616  	r.GetPosition()
 17617  }
 17618  
 17619  func TestRepositoryComment_GetReactions(tt *testing.T) {
 17620  	r := &RepositoryComment{}
 17621  	r.GetReactions()
 17622  	r = nil
 17623  	r.GetReactions()
 17624  }
 17625  
 17626  func TestRepositoryComment_GetUpdatedAt(tt *testing.T) {
 17627  	var zeroValue time.Time
 17628  	r := &RepositoryComment{UpdatedAt: &zeroValue}
 17629  	r.GetUpdatedAt()
 17630  	r = &RepositoryComment{}
 17631  	r.GetUpdatedAt()
 17632  	r = nil
 17633  	r.GetUpdatedAt()
 17634  }
 17635  
 17636  func TestRepositoryComment_GetURL(tt *testing.T) {
 17637  	var zeroValue string
 17638  	r := &RepositoryComment{URL: &zeroValue}
 17639  	r.GetURL()
 17640  	r = &RepositoryComment{}
 17641  	r.GetURL()
 17642  	r = nil
 17643  	r.GetURL()
 17644  }
 17645  
 17646  func TestRepositoryComment_GetUser(tt *testing.T) {
 17647  	r := &RepositoryComment{}
 17648  	r.GetUser()
 17649  	r = nil
 17650  	r.GetUser()
 17651  }
 17652  
 17653  func TestRepositoryCommit_GetAuthor(tt *testing.T) {
 17654  	r := &RepositoryCommit{}
 17655  	r.GetAuthor()
 17656  	r = nil
 17657  	r.GetAuthor()
 17658  }
 17659  
 17660  func TestRepositoryCommit_GetCommentsURL(tt *testing.T) {
 17661  	var zeroValue string
 17662  	r := &RepositoryCommit{CommentsURL: &zeroValue}
 17663  	r.GetCommentsURL()
 17664  	r = &RepositoryCommit{}
 17665  	r.GetCommentsURL()
 17666  	r = nil
 17667  	r.GetCommentsURL()
 17668  }
 17669  
 17670  func TestRepositoryCommit_GetCommit(tt *testing.T) {
 17671  	r := &RepositoryCommit{}
 17672  	r.GetCommit()
 17673  	r = nil
 17674  	r.GetCommit()
 17675  }
 17676  
 17677  func TestRepositoryCommit_GetCommitter(tt *testing.T) {
 17678  	r := &RepositoryCommit{}
 17679  	r.GetCommitter()
 17680  	r = nil
 17681  	r.GetCommitter()
 17682  }
 17683  
 17684  func TestRepositoryCommit_GetHTMLURL(tt *testing.T) {
 17685  	var zeroValue string
 17686  	r := &RepositoryCommit{HTMLURL: &zeroValue}
 17687  	r.GetHTMLURL()
 17688  	r = &RepositoryCommit{}
 17689  	r.GetHTMLURL()
 17690  	r = nil
 17691  	r.GetHTMLURL()
 17692  }
 17693  
 17694  func TestRepositoryCommit_GetNodeID(tt *testing.T) {
 17695  	var zeroValue string
 17696  	r := &RepositoryCommit{NodeID: &zeroValue}
 17697  	r.GetNodeID()
 17698  	r = &RepositoryCommit{}
 17699  	r.GetNodeID()
 17700  	r = nil
 17701  	r.GetNodeID()
 17702  }
 17703  
 17704  func TestRepositoryCommit_GetSHA(tt *testing.T) {
 17705  	var zeroValue string
 17706  	r := &RepositoryCommit{SHA: &zeroValue}
 17707  	r.GetSHA()
 17708  	r = &RepositoryCommit{}
 17709  	r.GetSHA()
 17710  	r = nil
 17711  	r.GetSHA()
 17712  }
 17713  
 17714  func TestRepositoryCommit_GetStats(tt *testing.T) {
 17715  	r := &RepositoryCommit{}
 17716  	r.GetStats()
 17717  	r = nil
 17718  	r.GetStats()
 17719  }
 17720  
 17721  func TestRepositoryCommit_GetURL(tt *testing.T) {
 17722  	var zeroValue string
 17723  	r := &RepositoryCommit{URL: &zeroValue}
 17724  	r.GetURL()
 17725  	r = &RepositoryCommit{}
 17726  	r.GetURL()
 17727  	r = nil
 17728  	r.GetURL()
 17729  }
 17730  
 17731  func TestRepositoryContent_GetDownloadURL(tt *testing.T) {
 17732  	var zeroValue string
 17733  	r := &RepositoryContent{DownloadURL: &zeroValue}
 17734  	r.GetDownloadURL()
 17735  	r = &RepositoryContent{}
 17736  	r.GetDownloadURL()
 17737  	r = nil
 17738  	r.GetDownloadURL()
 17739  }
 17740  
 17741  func TestRepositoryContent_GetEncoding(tt *testing.T) {
 17742  	var zeroValue string
 17743  	r := &RepositoryContent{Encoding: &zeroValue}
 17744  	r.GetEncoding()
 17745  	r = &RepositoryContent{}
 17746  	r.GetEncoding()
 17747  	r = nil
 17748  	r.GetEncoding()
 17749  }
 17750  
 17751  func TestRepositoryContent_GetGitURL(tt *testing.T) {
 17752  	var zeroValue string
 17753  	r := &RepositoryContent{GitURL: &zeroValue}
 17754  	r.GetGitURL()
 17755  	r = &RepositoryContent{}
 17756  	r.GetGitURL()
 17757  	r = nil
 17758  	r.GetGitURL()
 17759  }
 17760  
 17761  func TestRepositoryContent_GetHTMLURL(tt *testing.T) {
 17762  	var zeroValue string
 17763  	r := &RepositoryContent{HTMLURL: &zeroValue}
 17764  	r.GetHTMLURL()
 17765  	r = &RepositoryContent{}
 17766  	r.GetHTMLURL()
 17767  	r = nil
 17768  	r.GetHTMLURL()
 17769  }
 17770  
 17771  func TestRepositoryContent_GetName(tt *testing.T) {
 17772  	var zeroValue string
 17773  	r := &RepositoryContent{Name: &zeroValue}
 17774  	r.GetName()
 17775  	r = &RepositoryContent{}
 17776  	r.GetName()
 17777  	r = nil
 17778  	r.GetName()
 17779  }
 17780  
 17781  func TestRepositoryContent_GetPath(tt *testing.T) {
 17782  	var zeroValue string
 17783  	r := &RepositoryContent{Path: &zeroValue}
 17784  	r.GetPath()
 17785  	r = &RepositoryContent{}
 17786  	r.GetPath()
 17787  	r = nil
 17788  	r.GetPath()
 17789  }
 17790  
 17791  func TestRepositoryContent_GetSHA(tt *testing.T) {
 17792  	var zeroValue string
 17793  	r := &RepositoryContent{SHA: &zeroValue}
 17794  	r.GetSHA()
 17795  	r = &RepositoryContent{}
 17796  	r.GetSHA()
 17797  	r = nil
 17798  	r.GetSHA()
 17799  }
 17800  
 17801  func TestRepositoryContent_GetSize(tt *testing.T) {
 17802  	var zeroValue int
 17803  	r := &RepositoryContent{Size: &zeroValue}
 17804  	r.GetSize()
 17805  	r = &RepositoryContent{}
 17806  	r.GetSize()
 17807  	r = nil
 17808  	r.GetSize()
 17809  }
 17810  
 17811  func TestRepositoryContent_GetTarget(tt *testing.T) {
 17812  	var zeroValue string
 17813  	r := &RepositoryContent{Target: &zeroValue}
 17814  	r.GetTarget()
 17815  	r = &RepositoryContent{}
 17816  	r.GetTarget()
 17817  	r = nil
 17818  	r.GetTarget()
 17819  }
 17820  
 17821  func TestRepositoryContent_GetType(tt *testing.T) {
 17822  	var zeroValue string
 17823  	r := &RepositoryContent{Type: &zeroValue}
 17824  	r.GetType()
 17825  	r = &RepositoryContent{}
 17826  	r.GetType()
 17827  	r = nil
 17828  	r.GetType()
 17829  }
 17830  
 17831  func TestRepositoryContent_GetURL(tt *testing.T) {
 17832  	var zeroValue string
 17833  	r := &RepositoryContent{URL: &zeroValue}
 17834  	r.GetURL()
 17835  	r = &RepositoryContent{}
 17836  	r.GetURL()
 17837  	r = nil
 17838  	r.GetURL()
 17839  }
 17840  
 17841  func TestRepositoryContentFileOptions_GetAuthor(tt *testing.T) {
 17842  	r := &RepositoryContentFileOptions{}
 17843  	r.GetAuthor()
 17844  	r = nil
 17845  	r.GetAuthor()
 17846  }
 17847  
 17848  func TestRepositoryContentFileOptions_GetBranch(tt *testing.T) {
 17849  	var zeroValue string
 17850  	r := &RepositoryContentFileOptions{Branch: &zeroValue}
 17851  	r.GetBranch()
 17852  	r = &RepositoryContentFileOptions{}
 17853  	r.GetBranch()
 17854  	r = nil
 17855  	r.GetBranch()
 17856  }
 17857  
 17858  func TestRepositoryContentFileOptions_GetCommitter(tt *testing.T) {
 17859  	r := &RepositoryContentFileOptions{}
 17860  	r.GetCommitter()
 17861  	r = nil
 17862  	r.GetCommitter()
 17863  }
 17864  
 17865  func TestRepositoryContentFileOptions_GetMessage(tt *testing.T) {
 17866  	var zeroValue string
 17867  	r := &RepositoryContentFileOptions{Message: &zeroValue}
 17868  	r.GetMessage()
 17869  	r = &RepositoryContentFileOptions{}
 17870  	r.GetMessage()
 17871  	r = nil
 17872  	r.GetMessage()
 17873  }
 17874  
 17875  func TestRepositoryContentFileOptions_GetSHA(tt *testing.T) {
 17876  	var zeroValue string
 17877  	r := &RepositoryContentFileOptions{SHA: &zeroValue}
 17878  	r.GetSHA()
 17879  	r = &RepositoryContentFileOptions{}
 17880  	r.GetSHA()
 17881  	r = nil
 17882  	r.GetSHA()
 17883  }
 17884  
 17885  func TestRepositoryContentResponse_GetContent(tt *testing.T) {
 17886  	r := &RepositoryContentResponse{}
 17887  	r.GetContent()
 17888  	r = nil
 17889  	r.GetContent()
 17890  }
 17891  
 17892  func TestRepositoryDispatchEvent_GetAction(tt *testing.T) {
 17893  	var zeroValue string
 17894  	r := &RepositoryDispatchEvent{Action: &zeroValue}
 17895  	r.GetAction()
 17896  	r = &RepositoryDispatchEvent{}
 17897  	r.GetAction()
 17898  	r = nil
 17899  	r.GetAction()
 17900  }
 17901  
 17902  func TestRepositoryDispatchEvent_GetBranch(tt *testing.T) {
 17903  	var zeroValue string
 17904  	r := &RepositoryDispatchEvent{Branch: &zeroValue}
 17905  	r.GetBranch()
 17906  	r = &RepositoryDispatchEvent{}
 17907  	r.GetBranch()
 17908  	r = nil
 17909  	r.GetBranch()
 17910  }
 17911  
 17912  func TestRepositoryDispatchEvent_GetInstallation(tt *testing.T) {
 17913  	r := &RepositoryDispatchEvent{}
 17914  	r.GetInstallation()
 17915  	r = nil
 17916  	r.GetInstallation()
 17917  }
 17918  
 17919  func TestRepositoryDispatchEvent_GetOrg(tt *testing.T) {
 17920  	r := &RepositoryDispatchEvent{}
 17921  	r.GetOrg()
 17922  	r = nil
 17923  	r.GetOrg()
 17924  }
 17925  
 17926  func TestRepositoryDispatchEvent_GetRepo(tt *testing.T) {
 17927  	r := &RepositoryDispatchEvent{}
 17928  	r.GetRepo()
 17929  	r = nil
 17930  	r.GetRepo()
 17931  }
 17932  
 17933  func TestRepositoryDispatchEvent_GetSender(tt *testing.T) {
 17934  	r := &RepositoryDispatchEvent{}
 17935  	r.GetSender()
 17936  	r = nil
 17937  	r.GetSender()
 17938  }
 17939  
 17940  func TestRepositoryEvent_GetAction(tt *testing.T) {
 17941  	var zeroValue string
 17942  	r := &RepositoryEvent{Action: &zeroValue}
 17943  	r.GetAction()
 17944  	r = &RepositoryEvent{}
 17945  	r.GetAction()
 17946  	r = nil
 17947  	r.GetAction()
 17948  }
 17949  
 17950  func TestRepositoryEvent_GetChanges(tt *testing.T) {
 17951  	r := &RepositoryEvent{}
 17952  	r.GetChanges()
 17953  	r = nil
 17954  	r.GetChanges()
 17955  }
 17956  
 17957  func TestRepositoryEvent_GetInstallation(tt *testing.T) {
 17958  	r := &RepositoryEvent{}
 17959  	r.GetInstallation()
 17960  	r = nil
 17961  	r.GetInstallation()
 17962  }
 17963  
 17964  func TestRepositoryEvent_GetOrg(tt *testing.T) {
 17965  	r := &RepositoryEvent{}
 17966  	r.GetOrg()
 17967  	r = nil
 17968  	r.GetOrg()
 17969  }
 17970  
 17971  func TestRepositoryEvent_GetRepo(tt *testing.T) {
 17972  	r := &RepositoryEvent{}
 17973  	r.GetRepo()
 17974  	r = nil
 17975  	r.GetRepo()
 17976  }
 17977  
 17978  func TestRepositoryEvent_GetSender(tt *testing.T) {
 17979  	r := &RepositoryEvent{}
 17980  	r.GetSender()
 17981  	r = nil
 17982  	r.GetSender()
 17983  }
 17984  
 17985  func TestRepositoryImportEvent_GetOrg(tt *testing.T) {
 17986  	r := &RepositoryImportEvent{}
 17987  	r.GetOrg()
 17988  	r = nil
 17989  	r.GetOrg()
 17990  }
 17991  
 17992  func TestRepositoryImportEvent_GetRepo(tt *testing.T) {
 17993  	r := &RepositoryImportEvent{}
 17994  	r.GetRepo()
 17995  	r = nil
 17996  	r.GetRepo()
 17997  }
 17998  
 17999  func TestRepositoryImportEvent_GetSender(tt *testing.T) {
 18000  	r := &RepositoryImportEvent{}
 18001  	r.GetSender()
 18002  	r = nil
 18003  	r.GetSender()
 18004  }
 18005  
 18006  func TestRepositoryImportEvent_GetStatus(tt *testing.T) {
 18007  	var zeroValue string
 18008  	r := &RepositoryImportEvent{Status: &zeroValue}
 18009  	r.GetStatus()
 18010  	r = &RepositoryImportEvent{}
 18011  	r.GetStatus()
 18012  	r = nil
 18013  	r.GetStatus()
 18014  }
 18015  
 18016  func TestRepositoryInvitation_GetCreatedAt(tt *testing.T) {
 18017  	var zeroValue Timestamp
 18018  	r := &RepositoryInvitation{CreatedAt: &zeroValue}
 18019  	r.GetCreatedAt()
 18020  	r = &RepositoryInvitation{}
 18021  	r.GetCreatedAt()
 18022  	r = nil
 18023  	r.GetCreatedAt()
 18024  }
 18025  
 18026  func TestRepositoryInvitation_GetHTMLURL(tt *testing.T) {
 18027  	var zeroValue string
 18028  	r := &RepositoryInvitation{HTMLURL: &zeroValue}
 18029  	r.GetHTMLURL()
 18030  	r = &RepositoryInvitation{}
 18031  	r.GetHTMLURL()
 18032  	r = nil
 18033  	r.GetHTMLURL()
 18034  }
 18035  
 18036  func TestRepositoryInvitation_GetID(tt *testing.T) {
 18037  	var zeroValue int64
 18038  	r := &RepositoryInvitation{ID: &zeroValue}
 18039  	r.GetID()
 18040  	r = &RepositoryInvitation{}
 18041  	r.GetID()
 18042  	r = nil
 18043  	r.GetID()
 18044  }
 18045  
 18046  func TestRepositoryInvitation_GetInvitee(tt *testing.T) {
 18047  	r := &RepositoryInvitation{}
 18048  	r.GetInvitee()
 18049  	r = nil
 18050  	r.GetInvitee()
 18051  }
 18052  
 18053  func TestRepositoryInvitation_GetInviter(tt *testing.T) {
 18054  	r := &RepositoryInvitation{}
 18055  	r.GetInviter()
 18056  	r = nil
 18057  	r.GetInviter()
 18058  }
 18059  
 18060  func TestRepositoryInvitation_GetPermissions(tt *testing.T) {
 18061  	var zeroValue string
 18062  	r := &RepositoryInvitation{Permissions: &zeroValue}
 18063  	r.GetPermissions()
 18064  	r = &RepositoryInvitation{}
 18065  	r.GetPermissions()
 18066  	r = nil
 18067  	r.GetPermissions()
 18068  }
 18069  
 18070  func TestRepositoryInvitation_GetRepo(tt *testing.T) {
 18071  	r := &RepositoryInvitation{}
 18072  	r.GetRepo()
 18073  	r = nil
 18074  	r.GetRepo()
 18075  }
 18076  
 18077  func TestRepositoryInvitation_GetURL(tt *testing.T) {
 18078  	var zeroValue string
 18079  	r := &RepositoryInvitation{URL: &zeroValue}
 18080  	r.GetURL()
 18081  	r = &RepositoryInvitation{}
 18082  	r.GetURL()
 18083  	r = nil
 18084  	r.GetURL()
 18085  }
 18086  
 18087  func TestRepositoryLicense_GetContent(tt *testing.T) {
 18088  	var zeroValue string
 18089  	r := &RepositoryLicense{Content: &zeroValue}
 18090  	r.GetContent()
 18091  	r = &RepositoryLicense{}
 18092  	r.GetContent()
 18093  	r = nil
 18094  	r.GetContent()
 18095  }
 18096  
 18097  func TestRepositoryLicense_GetDownloadURL(tt *testing.T) {
 18098  	var zeroValue string
 18099  	r := &RepositoryLicense{DownloadURL: &zeroValue}
 18100  	r.GetDownloadURL()
 18101  	r = &RepositoryLicense{}
 18102  	r.GetDownloadURL()
 18103  	r = nil
 18104  	r.GetDownloadURL()
 18105  }
 18106  
 18107  func TestRepositoryLicense_GetEncoding(tt *testing.T) {
 18108  	var zeroValue string
 18109  	r := &RepositoryLicense{Encoding: &zeroValue}
 18110  	r.GetEncoding()
 18111  	r = &RepositoryLicense{}
 18112  	r.GetEncoding()
 18113  	r = nil
 18114  	r.GetEncoding()
 18115  }
 18116  
 18117  func TestRepositoryLicense_GetGitURL(tt *testing.T) {
 18118  	var zeroValue string
 18119  	r := &RepositoryLicense{GitURL: &zeroValue}
 18120  	r.GetGitURL()
 18121  	r = &RepositoryLicense{}
 18122  	r.GetGitURL()
 18123  	r = nil
 18124  	r.GetGitURL()
 18125  }
 18126  
 18127  func TestRepositoryLicense_GetHTMLURL(tt *testing.T) {
 18128  	var zeroValue string
 18129  	r := &RepositoryLicense{HTMLURL: &zeroValue}
 18130  	r.GetHTMLURL()
 18131  	r = &RepositoryLicense{}
 18132  	r.GetHTMLURL()
 18133  	r = nil
 18134  	r.GetHTMLURL()
 18135  }
 18136  
 18137  func TestRepositoryLicense_GetLicense(tt *testing.T) {
 18138  	r := &RepositoryLicense{}
 18139  	r.GetLicense()
 18140  	r = nil
 18141  	r.GetLicense()
 18142  }
 18143  
 18144  func TestRepositoryLicense_GetName(tt *testing.T) {
 18145  	var zeroValue string
 18146  	r := &RepositoryLicense{Name: &zeroValue}
 18147  	r.GetName()
 18148  	r = &RepositoryLicense{}
 18149  	r.GetName()
 18150  	r = nil
 18151  	r.GetName()
 18152  }
 18153  
 18154  func TestRepositoryLicense_GetPath(tt *testing.T) {
 18155  	var zeroValue string
 18156  	r := &RepositoryLicense{Path: &zeroValue}
 18157  	r.GetPath()
 18158  	r = &RepositoryLicense{}
 18159  	r.GetPath()
 18160  	r = nil
 18161  	r.GetPath()
 18162  }
 18163  
 18164  func TestRepositoryLicense_GetSHA(tt *testing.T) {
 18165  	var zeroValue string
 18166  	r := &RepositoryLicense{SHA: &zeroValue}
 18167  	r.GetSHA()
 18168  	r = &RepositoryLicense{}
 18169  	r.GetSHA()
 18170  	r = nil
 18171  	r.GetSHA()
 18172  }
 18173  
 18174  func TestRepositoryLicense_GetSize(tt *testing.T) {
 18175  	var zeroValue int
 18176  	r := &RepositoryLicense{Size: &zeroValue}
 18177  	r.GetSize()
 18178  	r = &RepositoryLicense{}
 18179  	r.GetSize()
 18180  	r = nil
 18181  	r.GetSize()
 18182  }
 18183  
 18184  func TestRepositoryLicense_GetType(tt *testing.T) {
 18185  	var zeroValue string
 18186  	r := &RepositoryLicense{Type: &zeroValue}
 18187  	r.GetType()
 18188  	r = &RepositoryLicense{}
 18189  	r.GetType()
 18190  	r = nil
 18191  	r.GetType()
 18192  }
 18193  
 18194  func TestRepositoryLicense_GetURL(tt *testing.T) {
 18195  	var zeroValue string
 18196  	r := &RepositoryLicense{URL: &zeroValue}
 18197  	r.GetURL()
 18198  	r = &RepositoryLicense{}
 18199  	r.GetURL()
 18200  	r = nil
 18201  	r.GetURL()
 18202  }
 18203  
 18204  func TestRepositoryMergeRequest_GetBase(tt *testing.T) {
 18205  	var zeroValue string
 18206  	r := &RepositoryMergeRequest{Base: &zeroValue}
 18207  	r.GetBase()
 18208  	r = &RepositoryMergeRequest{}
 18209  	r.GetBase()
 18210  	r = nil
 18211  	r.GetBase()
 18212  }
 18213  
 18214  func TestRepositoryMergeRequest_GetCommitMessage(tt *testing.T) {
 18215  	var zeroValue string
 18216  	r := &RepositoryMergeRequest{CommitMessage: &zeroValue}
 18217  	r.GetCommitMessage()
 18218  	r = &RepositoryMergeRequest{}
 18219  	r.GetCommitMessage()
 18220  	r = nil
 18221  	r.GetCommitMessage()
 18222  }
 18223  
 18224  func TestRepositoryMergeRequest_GetHead(tt *testing.T) {
 18225  	var zeroValue string
 18226  	r := &RepositoryMergeRequest{Head: &zeroValue}
 18227  	r.GetHead()
 18228  	r = &RepositoryMergeRequest{}
 18229  	r.GetHead()
 18230  	r = nil
 18231  	r.GetHead()
 18232  }
 18233  
 18234  func TestRepositoryPermissionLevel_GetPermission(tt *testing.T) {
 18235  	var zeroValue string
 18236  	r := &RepositoryPermissionLevel{Permission: &zeroValue}
 18237  	r.GetPermission()
 18238  	r = &RepositoryPermissionLevel{}
 18239  	r.GetPermission()
 18240  	r = nil
 18241  	r.GetPermission()
 18242  }
 18243  
 18244  func TestRepositoryPermissionLevel_GetUser(tt *testing.T) {
 18245  	r := &RepositoryPermissionLevel{}
 18246  	r.GetUser()
 18247  	r = nil
 18248  	r.GetUser()
 18249  }
 18250  
 18251  func TestRepositoryRelease_GetAssetsURL(tt *testing.T) {
 18252  	var zeroValue string
 18253  	r := &RepositoryRelease{AssetsURL: &zeroValue}
 18254  	r.GetAssetsURL()
 18255  	r = &RepositoryRelease{}
 18256  	r.GetAssetsURL()
 18257  	r = nil
 18258  	r.GetAssetsURL()
 18259  }
 18260  
 18261  func TestRepositoryRelease_GetAuthor(tt *testing.T) {
 18262  	r := &RepositoryRelease{}
 18263  	r.GetAuthor()
 18264  	r = nil
 18265  	r.GetAuthor()
 18266  }
 18267  
 18268  func TestRepositoryRelease_GetBody(tt *testing.T) {
 18269  	var zeroValue string
 18270  	r := &RepositoryRelease{Body: &zeroValue}
 18271  	r.GetBody()
 18272  	r = &RepositoryRelease{}
 18273  	r.GetBody()
 18274  	r = nil
 18275  	r.GetBody()
 18276  }
 18277  
 18278  func TestRepositoryRelease_GetCreatedAt(tt *testing.T) {
 18279  	var zeroValue Timestamp
 18280  	r := &RepositoryRelease{CreatedAt: &zeroValue}
 18281  	r.GetCreatedAt()
 18282  	r = &RepositoryRelease{}
 18283  	r.GetCreatedAt()
 18284  	r = nil
 18285  	r.GetCreatedAt()
 18286  }
 18287  
 18288  func TestRepositoryRelease_GetDiscussionCategoryName(tt *testing.T) {
 18289  	var zeroValue string
 18290  	r := &RepositoryRelease{DiscussionCategoryName: &zeroValue}
 18291  	r.GetDiscussionCategoryName()
 18292  	r = &RepositoryRelease{}
 18293  	r.GetDiscussionCategoryName()
 18294  	r = nil
 18295  	r.GetDiscussionCategoryName()
 18296  }
 18297  
 18298  func TestRepositoryRelease_GetDraft(tt *testing.T) {
 18299  	var zeroValue bool
 18300  	r := &RepositoryRelease{Draft: &zeroValue}
 18301  	r.GetDraft()
 18302  	r = &RepositoryRelease{}
 18303  	r.GetDraft()
 18304  	r = nil
 18305  	r.GetDraft()
 18306  }
 18307  
 18308  func TestRepositoryRelease_GetGenerateReleaseNotes(tt *testing.T) {
 18309  	var zeroValue bool
 18310  	r := &RepositoryRelease{GenerateReleaseNotes: &zeroValue}
 18311  	r.GetGenerateReleaseNotes()
 18312  	r = &RepositoryRelease{}
 18313  	r.GetGenerateReleaseNotes()
 18314  	r = nil
 18315  	r.GetGenerateReleaseNotes()
 18316  }
 18317  
 18318  func TestRepositoryRelease_GetHTMLURL(tt *testing.T) {
 18319  	var zeroValue string
 18320  	r := &RepositoryRelease{HTMLURL: &zeroValue}
 18321  	r.GetHTMLURL()
 18322  	r = &RepositoryRelease{}
 18323  	r.GetHTMLURL()
 18324  	r = nil
 18325  	r.GetHTMLURL()
 18326  }
 18327  
 18328  func TestRepositoryRelease_GetID(tt *testing.T) {
 18329  	var zeroValue int64
 18330  	r := &RepositoryRelease{ID: &zeroValue}
 18331  	r.GetID()
 18332  	r = &RepositoryRelease{}
 18333  	r.GetID()
 18334  	r = nil
 18335  	r.GetID()
 18336  }
 18337  
 18338  func TestRepositoryRelease_GetName(tt *testing.T) {
 18339  	var zeroValue string
 18340  	r := &RepositoryRelease{Name: &zeroValue}
 18341  	r.GetName()
 18342  	r = &RepositoryRelease{}
 18343  	r.GetName()
 18344  	r = nil
 18345  	r.GetName()
 18346  }
 18347  
 18348  func TestRepositoryRelease_GetNodeID(tt *testing.T) {
 18349  	var zeroValue string
 18350  	r := &RepositoryRelease{NodeID: &zeroValue}
 18351  	r.GetNodeID()
 18352  	r = &RepositoryRelease{}
 18353  	r.GetNodeID()
 18354  	r = nil
 18355  	r.GetNodeID()
 18356  }
 18357  
 18358  func TestRepositoryRelease_GetPrerelease(tt *testing.T) {
 18359  	var zeroValue bool
 18360  	r := &RepositoryRelease{Prerelease: &zeroValue}
 18361  	r.GetPrerelease()
 18362  	r = &RepositoryRelease{}
 18363  	r.GetPrerelease()
 18364  	r = nil
 18365  	r.GetPrerelease()
 18366  }
 18367  
 18368  func TestRepositoryRelease_GetPublishedAt(tt *testing.T) {
 18369  	var zeroValue Timestamp
 18370  	r := &RepositoryRelease{PublishedAt: &zeroValue}
 18371  	r.GetPublishedAt()
 18372  	r = &RepositoryRelease{}
 18373  	r.GetPublishedAt()
 18374  	r = nil
 18375  	r.GetPublishedAt()
 18376  }
 18377  
 18378  func TestRepositoryRelease_GetTagName(tt *testing.T) {
 18379  	var zeroValue string
 18380  	r := &RepositoryRelease{TagName: &zeroValue}
 18381  	r.GetTagName()
 18382  	r = &RepositoryRelease{}
 18383  	r.GetTagName()
 18384  	r = nil
 18385  	r.GetTagName()
 18386  }
 18387  
 18388  func TestRepositoryRelease_GetTarballURL(tt *testing.T) {
 18389  	var zeroValue string
 18390  	r := &RepositoryRelease{TarballURL: &zeroValue}
 18391  	r.GetTarballURL()
 18392  	r = &RepositoryRelease{}
 18393  	r.GetTarballURL()
 18394  	r = nil
 18395  	r.GetTarballURL()
 18396  }
 18397  
 18398  func TestRepositoryRelease_GetTargetCommitish(tt *testing.T) {
 18399  	var zeroValue string
 18400  	r := &RepositoryRelease{TargetCommitish: &zeroValue}
 18401  	r.GetTargetCommitish()
 18402  	r = &RepositoryRelease{}
 18403  	r.GetTargetCommitish()
 18404  	r = nil
 18405  	r.GetTargetCommitish()
 18406  }
 18407  
 18408  func TestRepositoryRelease_GetUploadURL(tt *testing.T) {
 18409  	var zeroValue string
 18410  	r := &RepositoryRelease{UploadURL: &zeroValue}
 18411  	r.GetUploadURL()
 18412  	r = &RepositoryRelease{}
 18413  	r.GetUploadURL()
 18414  	r = nil
 18415  	r.GetUploadURL()
 18416  }
 18417  
 18418  func TestRepositoryRelease_GetURL(tt *testing.T) {
 18419  	var zeroValue string
 18420  	r := &RepositoryRelease{URL: &zeroValue}
 18421  	r.GetURL()
 18422  	r = &RepositoryRelease{}
 18423  	r.GetURL()
 18424  	r = nil
 18425  	r.GetURL()
 18426  }
 18427  
 18428  func TestRepositoryRelease_GetZipballURL(tt *testing.T) {
 18429  	var zeroValue string
 18430  	r := &RepositoryRelease{ZipballURL: &zeroValue}
 18431  	r.GetZipballURL()
 18432  	r = &RepositoryRelease{}
 18433  	r.GetZipballURL()
 18434  	r = nil
 18435  	r.GetZipballURL()
 18436  }
 18437  
 18438  func TestRepositoryTag_GetCommit(tt *testing.T) {
 18439  	r := &RepositoryTag{}
 18440  	r.GetCommit()
 18441  	r = nil
 18442  	r.GetCommit()
 18443  }
 18444  
 18445  func TestRepositoryTag_GetName(tt *testing.T) {
 18446  	var zeroValue string
 18447  	r := &RepositoryTag{Name: &zeroValue}
 18448  	r.GetName()
 18449  	r = &RepositoryTag{}
 18450  	r.GetName()
 18451  	r = nil
 18452  	r.GetName()
 18453  }
 18454  
 18455  func TestRepositoryTag_GetTarballURL(tt *testing.T) {
 18456  	var zeroValue string
 18457  	r := &RepositoryTag{TarballURL: &zeroValue}
 18458  	r.GetTarballURL()
 18459  	r = &RepositoryTag{}
 18460  	r.GetTarballURL()
 18461  	r = nil
 18462  	r.GetTarballURL()
 18463  }
 18464  
 18465  func TestRepositoryTag_GetZipballURL(tt *testing.T) {
 18466  	var zeroValue string
 18467  	r := &RepositoryTag{ZipballURL: &zeroValue}
 18468  	r.GetZipballURL()
 18469  	r = &RepositoryTag{}
 18470  	r.GetZipballURL()
 18471  	r = nil
 18472  	r.GetZipballURL()
 18473  }
 18474  
 18475  func TestRepositoryVulnerabilityAlert_GetAffectedPackageName(tt *testing.T) {
 18476  	var zeroValue string
 18477  	r := &RepositoryVulnerabilityAlert{AffectedPackageName: &zeroValue}
 18478  	r.GetAffectedPackageName()
 18479  	r = &RepositoryVulnerabilityAlert{}
 18480  	r.GetAffectedPackageName()
 18481  	r = nil
 18482  	r.GetAffectedPackageName()
 18483  }
 18484  
 18485  func TestRepositoryVulnerabilityAlert_GetAffectedRange(tt *testing.T) {
 18486  	var zeroValue string
 18487  	r := &RepositoryVulnerabilityAlert{AffectedRange: &zeroValue}
 18488  	r.GetAffectedRange()
 18489  	r = &RepositoryVulnerabilityAlert{}
 18490  	r.GetAffectedRange()
 18491  	r = nil
 18492  	r.GetAffectedRange()
 18493  }
 18494  
 18495  func TestRepositoryVulnerabilityAlert_GetCreatedAt(tt *testing.T) {
 18496  	var zeroValue Timestamp
 18497  	r := &RepositoryVulnerabilityAlert{CreatedAt: &zeroValue}
 18498  	r.GetCreatedAt()
 18499  	r = &RepositoryVulnerabilityAlert{}
 18500  	r.GetCreatedAt()
 18501  	r = nil
 18502  	r.GetCreatedAt()
 18503  }
 18504  
 18505  func TestRepositoryVulnerabilityAlert_GetDismissedAt(tt *testing.T) {
 18506  	var zeroValue Timestamp
 18507  	r := &RepositoryVulnerabilityAlert{DismissedAt: &zeroValue}
 18508  	r.GetDismissedAt()
 18509  	r = &RepositoryVulnerabilityAlert{}
 18510  	r.GetDismissedAt()
 18511  	r = nil
 18512  	r.GetDismissedAt()
 18513  }
 18514  
 18515  func TestRepositoryVulnerabilityAlert_GetDismisser(tt *testing.T) {
 18516  	r := &RepositoryVulnerabilityAlert{}
 18517  	r.GetDismisser()
 18518  	r = nil
 18519  	r.GetDismisser()
 18520  }
 18521  
 18522  func TestRepositoryVulnerabilityAlert_GetDismissReason(tt *testing.T) {
 18523  	var zeroValue string
 18524  	r := &RepositoryVulnerabilityAlert{DismissReason: &zeroValue}
 18525  	r.GetDismissReason()
 18526  	r = &RepositoryVulnerabilityAlert{}
 18527  	r.GetDismissReason()
 18528  	r = nil
 18529  	r.GetDismissReason()
 18530  }
 18531  
 18532  func TestRepositoryVulnerabilityAlert_GetExternalIdentifier(tt *testing.T) {
 18533  	var zeroValue string
 18534  	r := &RepositoryVulnerabilityAlert{ExternalIdentifier: &zeroValue}
 18535  	r.GetExternalIdentifier()
 18536  	r = &RepositoryVulnerabilityAlert{}
 18537  	r.GetExternalIdentifier()
 18538  	r = nil
 18539  	r.GetExternalIdentifier()
 18540  }
 18541  
 18542  func TestRepositoryVulnerabilityAlert_GetExternalReference(tt *testing.T) {
 18543  	var zeroValue string
 18544  	r := &RepositoryVulnerabilityAlert{ExternalReference: &zeroValue}
 18545  	r.GetExternalReference()
 18546  	r = &RepositoryVulnerabilityAlert{}
 18547  	r.GetExternalReference()
 18548  	r = nil
 18549  	r.GetExternalReference()
 18550  }
 18551  
 18552  func TestRepositoryVulnerabilityAlert_GetFixedIn(tt *testing.T) {
 18553  	var zeroValue string
 18554  	r := &RepositoryVulnerabilityAlert{FixedIn: &zeroValue}
 18555  	r.GetFixedIn()
 18556  	r = &RepositoryVulnerabilityAlert{}
 18557  	r.GetFixedIn()
 18558  	r = nil
 18559  	r.GetFixedIn()
 18560  }
 18561  
 18562  func TestRepositoryVulnerabilityAlert_GetGitHubSecurityAdvisoryID(tt *testing.T) {
 18563  	var zeroValue string
 18564  	r := &RepositoryVulnerabilityAlert{GitHubSecurityAdvisoryID: &zeroValue}
 18565  	r.GetGitHubSecurityAdvisoryID()
 18566  	r = &RepositoryVulnerabilityAlert{}
 18567  	r.GetGitHubSecurityAdvisoryID()
 18568  	r = nil
 18569  	r.GetGitHubSecurityAdvisoryID()
 18570  }
 18571  
 18572  func TestRepositoryVulnerabilityAlert_GetID(tt *testing.T) {
 18573  	var zeroValue int64
 18574  	r := &RepositoryVulnerabilityAlert{ID: &zeroValue}
 18575  	r.GetID()
 18576  	r = &RepositoryVulnerabilityAlert{}
 18577  	r.GetID()
 18578  	r = nil
 18579  	r.GetID()
 18580  }
 18581  
 18582  func TestRepositoryVulnerabilityAlert_GetSeverity(tt *testing.T) {
 18583  	var zeroValue string
 18584  	r := &RepositoryVulnerabilityAlert{Severity: &zeroValue}
 18585  	r.GetSeverity()
 18586  	r = &RepositoryVulnerabilityAlert{}
 18587  	r.GetSeverity()
 18588  	r = nil
 18589  	r.GetSeverity()
 18590  }
 18591  
 18592  func TestRepositoryVulnerabilityAlertEvent_GetAction(tt *testing.T) {
 18593  	var zeroValue string
 18594  	r := &RepositoryVulnerabilityAlertEvent{Action: &zeroValue}
 18595  	r.GetAction()
 18596  	r = &RepositoryVulnerabilityAlertEvent{}
 18597  	r.GetAction()
 18598  	r = nil
 18599  	r.GetAction()
 18600  }
 18601  
 18602  func TestRepositoryVulnerabilityAlertEvent_GetAlert(tt *testing.T) {
 18603  	r := &RepositoryVulnerabilityAlertEvent{}
 18604  	r.GetAlert()
 18605  	r = nil
 18606  	r.GetAlert()
 18607  }
 18608  
 18609  func TestRepositoryVulnerabilityAlertEvent_GetInstallation(tt *testing.T) {
 18610  	r := &RepositoryVulnerabilityAlertEvent{}
 18611  	r.GetInstallation()
 18612  	r = nil
 18613  	r.GetInstallation()
 18614  }
 18615  
 18616  func TestRepositoryVulnerabilityAlertEvent_GetRepository(tt *testing.T) {
 18617  	r := &RepositoryVulnerabilityAlertEvent{}
 18618  	r.GetRepository()
 18619  	r = nil
 18620  	r.GetRepository()
 18621  }
 18622  
 18623  func TestRepositoryVulnerabilityAlertEvent_GetSender(tt *testing.T) {
 18624  	r := &RepositoryVulnerabilityAlertEvent{}
 18625  	r.GetSender()
 18626  	r = nil
 18627  	r.GetSender()
 18628  }
 18629  
 18630  func TestRepoStats_GetForkRepos(tt *testing.T) {
 18631  	var zeroValue int
 18632  	r := &RepoStats{ForkRepos: &zeroValue}
 18633  	r.GetForkRepos()
 18634  	r = &RepoStats{}
 18635  	r.GetForkRepos()
 18636  	r = nil
 18637  	r.GetForkRepos()
 18638  }
 18639  
 18640  func TestRepoStats_GetOrgRepos(tt *testing.T) {
 18641  	var zeroValue int
 18642  	r := &RepoStats{OrgRepos: &zeroValue}
 18643  	r.GetOrgRepos()
 18644  	r = &RepoStats{}
 18645  	r.GetOrgRepos()
 18646  	r = nil
 18647  	r.GetOrgRepos()
 18648  }
 18649  
 18650  func TestRepoStats_GetRootRepos(tt *testing.T) {
 18651  	var zeroValue int
 18652  	r := &RepoStats{RootRepos: &zeroValue}
 18653  	r.GetRootRepos()
 18654  	r = &RepoStats{}
 18655  	r.GetRootRepos()
 18656  	r = nil
 18657  	r.GetRootRepos()
 18658  }
 18659  
 18660  func TestRepoStats_GetTotalPushes(tt *testing.T) {
 18661  	var zeroValue int
 18662  	r := &RepoStats{TotalPushes: &zeroValue}
 18663  	r.GetTotalPushes()
 18664  	r = &RepoStats{}
 18665  	r.GetTotalPushes()
 18666  	r = nil
 18667  	r.GetTotalPushes()
 18668  }
 18669  
 18670  func TestRepoStats_GetTotalRepos(tt *testing.T) {
 18671  	var zeroValue int
 18672  	r := &RepoStats{TotalRepos: &zeroValue}
 18673  	r.GetTotalRepos()
 18674  	r = &RepoStats{}
 18675  	r.GetTotalRepos()
 18676  	r = nil
 18677  	r.GetTotalRepos()
 18678  }
 18679  
 18680  func TestRepoStats_GetTotalWikis(tt *testing.T) {
 18681  	var zeroValue int
 18682  	r := &RepoStats{TotalWikis: &zeroValue}
 18683  	r.GetTotalWikis()
 18684  	r = &RepoStats{}
 18685  	r.GetTotalWikis()
 18686  	r = nil
 18687  	r.GetTotalWikis()
 18688  }
 18689  
 18690  func TestRepoStatus_GetAvatarURL(tt *testing.T) {
 18691  	var zeroValue string
 18692  	r := &RepoStatus{AvatarURL: &zeroValue}
 18693  	r.GetAvatarURL()
 18694  	r = &RepoStatus{}
 18695  	r.GetAvatarURL()
 18696  	r = nil
 18697  	r.GetAvatarURL()
 18698  }
 18699  
 18700  func TestRepoStatus_GetContext(tt *testing.T) {
 18701  	var zeroValue string
 18702  	r := &RepoStatus{Context: &zeroValue}
 18703  	r.GetContext()
 18704  	r = &RepoStatus{}
 18705  	r.GetContext()
 18706  	r = nil
 18707  	r.GetContext()
 18708  }
 18709  
 18710  func TestRepoStatus_GetCreatedAt(tt *testing.T) {
 18711  	var zeroValue time.Time
 18712  	r := &RepoStatus{CreatedAt: &zeroValue}
 18713  	r.GetCreatedAt()
 18714  	r = &RepoStatus{}
 18715  	r.GetCreatedAt()
 18716  	r = nil
 18717  	r.GetCreatedAt()
 18718  }
 18719  
 18720  func TestRepoStatus_GetCreator(tt *testing.T) {
 18721  	r := &RepoStatus{}
 18722  	r.GetCreator()
 18723  	r = nil
 18724  	r.GetCreator()
 18725  }
 18726  
 18727  func TestRepoStatus_GetDescription(tt *testing.T) {
 18728  	var zeroValue string
 18729  	r := &RepoStatus{Description: &zeroValue}
 18730  	r.GetDescription()
 18731  	r = &RepoStatus{}
 18732  	r.GetDescription()
 18733  	r = nil
 18734  	r.GetDescription()
 18735  }
 18736  
 18737  func TestRepoStatus_GetID(tt *testing.T) {
 18738  	var zeroValue int64
 18739  	r := &RepoStatus{ID: &zeroValue}
 18740  	r.GetID()
 18741  	r = &RepoStatus{}
 18742  	r.GetID()
 18743  	r = nil
 18744  	r.GetID()
 18745  }
 18746  
 18747  func TestRepoStatus_GetNodeID(tt *testing.T) {
 18748  	var zeroValue string
 18749  	r := &RepoStatus{NodeID: &zeroValue}
 18750  	r.GetNodeID()
 18751  	r = &RepoStatus{}
 18752  	r.GetNodeID()
 18753  	r = nil
 18754  	r.GetNodeID()
 18755  }
 18756  
 18757  func TestRepoStatus_GetState(tt *testing.T) {
 18758  	var zeroValue string
 18759  	r := &RepoStatus{State: &zeroValue}
 18760  	r.GetState()
 18761  	r = &RepoStatus{}
 18762  	r.GetState()
 18763  	r = nil
 18764  	r.GetState()
 18765  }
 18766  
 18767  func TestRepoStatus_GetTargetURL(tt *testing.T) {
 18768  	var zeroValue string
 18769  	r := &RepoStatus{TargetURL: &zeroValue}
 18770  	r.GetTargetURL()
 18771  	r = &RepoStatus{}
 18772  	r.GetTargetURL()
 18773  	r = nil
 18774  	r.GetTargetURL()
 18775  }
 18776  
 18777  func TestRepoStatus_GetUpdatedAt(tt *testing.T) {
 18778  	var zeroValue time.Time
 18779  	r := &RepoStatus{UpdatedAt: &zeroValue}
 18780  	r.GetUpdatedAt()
 18781  	r = &RepoStatus{}
 18782  	r.GetUpdatedAt()
 18783  	r = nil
 18784  	r.GetUpdatedAt()
 18785  }
 18786  
 18787  func TestRepoStatus_GetURL(tt *testing.T) {
 18788  	var zeroValue string
 18789  	r := &RepoStatus{URL: &zeroValue}
 18790  	r.GetURL()
 18791  	r = &RepoStatus{}
 18792  	r.GetURL()
 18793  	r = nil
 18794  	r.GetURL()
 18795  }
 18796  
 18797  func TestRequiredReviewer_GetType(tt *testing.T) {
 18798  	var zeroValue string
 18799  	r := &RequiredReviewer{Type: &zeroValue}
 18800  	r.GetType()
 18801  	r = &RequiredReviewer{}
 18802  	r.GetType()
 18803  	r = nil
 18804  	r.GetType()
 18805  }
 18806  
 18807  func TestRequiredStatusCheck_GetAppID(tt *testing.T) {
 18808  	var zeroValue int64
 18809  	r := &RequiredStatusCheck{AppID: &zeroValue}
 18810  	r.GetAppID()
 18811  	r = &RequiredStatusCheck{}
 18812  	r.GetAppID()
 18813  	r = nil
 18814  	r.GetAppID()
 18815  }
 18816  
 18817  func TestRequiredStatusChecksRequest_GetStrict(tt *testing.T) {
 18818  	var zeroValue bool
 18819  	r := &RequiredStatusChecksRequest{Strict: &zeroValue}
 18820  	r.GetStrict()
 18821  	r = &RequiredStatusChecksRequest{}
 18822  	r.GetStrict()
 18823  	r = nil
 18824  	r.GetStrict()
 18825  }
 18826  
 18827  func TestReviewersRequest_GetNodeID(tt *testing.T) {
 18828  	var zeroValue string
 18829  	r := &ReviewersRequest{NodeID: &zeroValue}
 18830  	r.GetNodeID()
 18831  	r = &ReviewersRequest{}
 18832  	r.GetNodeID()
 18833  	r = nil
 18834  	r.GetNodeID()
 18835  }
 18836  
 18837  func TestRule_GetDescription(tt *testing.T) {
 18838  	var zeroValue string
 18839  	r := &Rule{Description: &zeroValue}
 18840  	r.GetDescription()
 18841  	r = &Rule{}
 18842  	r.GetDescription()
 18843  	r = nil
 18844  	r.GetDescription()
 18845  }
 18846  
 18847  func TestRule_GetFullDescription(tt *testing.T) {
 18848  	var zeroValue string
 18849  	r := &Rule{FullDescription: &zeroValue}
 18850  	r.GetFullDescription()
 18851  	r = &Rule{}
 18852  	r.GetFullDescription()
 18853  	r = nil
 18854  	r.GetFullDescription()
 18855  }
 18856  
 18857  func TestRule_GetHelp(tt *testing.T) {
 18858  	var zeroValue string
 18859  	r := &Rule{Help: &zeroValue}
 18860  	r.GetHelp()
 18861  	r = &Rule{}
 18862  	r.GetHelp()
 18863  	r = nil
 18864  	r.GetHelp()
 18865  }
 18866  
 18867  func TestRule_GetID(tt *testing.T) {
 18868  	var zeroValue string
 18869  	r := &Rule{ID: &zeroValue}
 18870  	r.GetID()
 18871  	r = &Rule{}
 18872  	r.GetID()
 18873  	r = nil
 18874  	r.GetID()
 18875  }
 18876  
 18877  func TestRule_GetName(tt *testing.T) {
 18878  	var zeroValue string
 18879  	r := &Rule{Name: &zeroValue}
 18880  	r.GetName()
 18881  	r = &Rule{}
 18882  	r.GetName()
 18883  	r = nil
 18884  	r.GetName()
 18885  }
 18886  
 18887  func TestRule_GetSecuritySeverityLevel(tt *testing.T) {
 18888  	var zeroValue string
 18889  	r := &Rule{SecuritySeverityLevel: &zeroValue}
 18890  	r.GetSecuritySeverityLevel()
 18891  	r = &Rule{}
 18892  	r.GetSecuritySeverityLevel()
 18893  	r = nil
 18894  	r.GetSecuritySeverityLevel()
 18895  }
 18896  
 18897  func TestRule_GetSeverity(tt *testing.T) {
 18898  	var zeroValue string
 18899  	r := &Rule{Severity: &zeroValue}
 18900  	r.GetSeverity()
 18901  	r = &Rule{}
 18902  	r.GetSeverity()
 18903  	r = nil
 18904  	r.GetSeverity()
 18905  }
 18906  
 18907  func TestRunner_GetBusy(tt *testing.T) {
 18908  	var zeroValue bool
 18909  	r := &Runner{Busy: &zeroValue}
 18910  	r.GetBusy()
 18911  	r = &Runner{}
 18912  	r.GetBusy()
 18913  	r = nil
 18914  	r.GetBusy()
 18915  }
 18916  
 18917  func TestRunner_GetID(tt *testing.T) {
 18918  	var zeroValue int64
 18919  	r := &Runner{ID: &zeroValue}
 18920  	r.GetID()
 18921  	r = &Runner{}
 18922  	r.GetID()
 18923  	r = nil
 18924  	r.GetID()
 18925  }
 18926  
 18927  func TestRunner_GetName(tt *testing.T) {
 18928  	var zeroValue string
 18929  	r := &Runner{Name: &zeroValue}
 18930  	r.GetName()
 18931  	r = &Runner{}
 18932  	r.GetName()
 18933  	r = nil
 18934  	r.GetName()
 18935  }
 18936  
 18937  func TestRunner_GetOS(tt *testing.T) {
 18938  	var zeroValue string
 18939  	r := &Runner{OS: &zeroValue}
 18940  	r.GetOS()
 18941  	r = &Runner{}
 18942  	r.GetOS()
 18943  	r = nil
 18944  	r.GetOS()
 18945  }
 18946  
 18947  func TestRunner_GetStatus(tt *testing.T) {
 18948  	var zeroValue string
 18949  	r := &Runner{Status: &zeroValue}
 18950  	r.GetStatus()
 18951  	r = &Runner{}
 18952  	r.GetStatus()
 18953  	r = nil
 18954  	r.GetStatus()
 18955  }
 18956  
 18957  func TestRunnerApplicationDownload_GetArchitecture(tt *testing.T) {
 18958  	var zeroValue string
 18959  	r := &RunnerApplicationDownload{Architecture: &zeroValue}
 18960  	r.GetArchitecture()
 18961  	r = &RunnerApplicationDownload{}
 18962  	r.GetArchitecture()
 18963  	r = nil
 18964  	r.GetArchitecture()
 18965  }
 18966  
 18967  func TestRunnerApplicationDownload_GetDownloadURL(tt *testing.T) {
 18968  	var zeroValue string
 18969  	r := &RunnerApplicationDownload{DownloadURL: &zeroValue}
 18970  	r.GetDownloadURL()
 18971  	r = &RunnerApplicationDownload{}
 18972  	r.GetDownloadURL()
 18973  	r = nil
 18974  	r.GetDownloadURL()
 18975  }
 18976  
 18977  func TestRunnerApplicationDownload_GetFilename(tt *testing.T) {
 18978  	var zeroValue string
 18979  	r := &RunnerApplicationDownload{Filename: &zeroValue}
 18980  	r.GetFilename()
 18981  	r = &RunnerApplicationDownload{}
 18982  	r.GetFilename()
 18983  	r = nil
 18984  	r.GetFilename()
 18985  }
 18986  
 18987  func TestRunnerApplicationDownload_GetOS(tt *testing.T) {
 18988  	var zeroValue string
 18989  	r := &RunnerApplicationDownload{OS: &zeroValue}
 18990  	r.GetOS()
 18991  	r = &RunnerApplicationDownload{}
 18992  	r.GetOS()
 18993  	r = nil
 18994  	r.GetOS()
 18995  }
 18996  
 18997  func TestRunnerApplicationDownload_GetSHA256Checksum(tt *testing.T) {
 18998  	var zeroValue string
 18999  	r := &RunnerApplicationDownload{SHA256Checksum: &zeroValue}
 19000  	r.GetSHA256Checksum()
 19001  	r = &RunnerApplicationDownload{}
 19002  	r.GetSHA256Checksum()
 19003  	r = nil
 19004  	r.GetSHA256Checksum()
 19005  }
 19006  
 19007  func TestRunnerApplicationDownload_GetTempDownloadToken(tt *testing.T) {
 19008  	var zeroValue string
 19009  	r := &RunnerApplicationDownload{TempDownloadToken: &zeroValue}
 19010  	r.GetTempDownloadToken()
 19011  	r = &RunnerApplicationDownload{}
 19012  	r.GetTempDownloadToken()
 19013  	r = nil
 19014  	r.GetTempDownloadToken()
 19015  }
 19016  
 19017  func TestRunnerGroup_GetAllowsPublicRepositories(tt *testing.T) {
 19018  	var zeroValue bool
 19019  	r := &RunnerGroup{AllowsPublicRepositories: &zeroValue}
 19020  	r.GetAllowsPublicRepositories()
 19021  	r = &RunnerGroup{}
 19022  	r.GetAllowsPublicRepositories()
 19023  	r = nil
 19024  	r.GetAllowsPublicRepositories()
 19025  }
 19026  
 19027  func TestRunnerGroup_GetDefault(tt *testing.T) {
 19028  	var zeroValue bool
 19029  	r := &RunnerGroup{Default: &zeroValue}
 19030  	r.GetDefault()
 19031  	r = &RunnerGroup{}
 19032  	r.GetDefault()
 19033  	r = nil
 19034  	r.GetDefault()
 19035  }
 19036  
 19037  func TestRunnerGroup_GetID(tt *testing.T) {
 19038  	var zeroValue int64
 19039  	r := &RunnerGroup{ID: &zeroValue}
 19040  	r.GetID()
 19041  	r = &RunnerGroup{}
 19042  	r.GetID()
 19043  	r = nil
 19044  	r.GetID()
 19045  }
 19046  
 19047  func TestRunnerGroup_GetInherited(tt *testing.T) {
 19048  	var zeroValue bool
 19049  	r := &RunnerGroup{Inherited: &zeroValue}
 19050  	r.GetInherited()
 19051  	r = &RunnerGroup{}
 19052  	r.GetInherited()
 19053  	r = nil
 19054  	r.GetInherited()
 19055  }
 19056  
 19057  func TestRunnerGroup_GetName(tt *testing.T) {
 19058  	var zeroValue string
 19059  	r := &RunnerGroup{Name: &zeroValue}
 19060  	r.GetName()
 19061  	r = &RunnerGroup{}
 19062  	r.GetName()
 19063  	r = nil
 19064  	r.GetName()
 19065  }
 19066  
 19067  func TestRunnerGroup_GetRunnersURL(tt *testing.T) {
 19068  	var zeroValue string
 19069  	r := &RunnerGroup{RunnersURL: &zeroValue}
 19070  	r.GetRunnersURL()
 19071  	r = &RunnerGroup{}
 19072  	r.GetRunnersURL()
 19073  	r = nil
 19074  	r.GetRunnersURL()
 19075  }
 19076  
 19077  func TestRunnerGroup_GetSelectedRepositoriesURL(tt *testing.T) {
 19078  	var zeroValue string
 19079  	r := &RunnerGroup{SelectedRepositoriesURL: &zeroValue}
 19080  	r.GetSelectedRepositoriesURL()
 19081  	r = &RunnerGroup{}
 19082  	r.GetSelectedRepositoriesURL()
 19083  	r = nil
 19084  	r.GetSelectedRepositoriesURL()
 19085  }
 19086  
 19087  func TestRunnerGroup_GetVisibility(tt *testing.T) {
 19088  	var zeroValue string
 19089  	r := &RunnerGroup{Visibility: &zeroValue}
 19090  	r.GetVisibility()
 19091  	r = &RunnerGroup{}
 19092  	r.GetVisibility()
 19093  	r = nil
 19094  	r.GetVisibility()
 19095  }
 19096  
 19097  func TestRunnerLabels_GetID(tt *testing.T) {
 19098  	var zeroValue int64
 19099  	r := &RunnerLabels{ID: &zeroValue}
 19100  	r.GetID()
 19101  	r = &RunnerLabels{}
 19102  	r.GetID()
 19103  	r = nil
 19104  	r.GetID()
 19105  }
 19106  
 19107  func TestRunnerLabels_GetName(tt *testing.T) {
 19108  	var zeroValue string
 19109  	r := &RunnerLabels{Name: &zeroValue}
 19110  	r.GetName()
 19111  	r = &RunnerLabels{}
 19112  	r.GetName()
 19113  	r = nil
 19114  	r.GetName()
 19115  }
 19116  
 19117  func TestRunnerLabels_GetType(tt *testing.T) {
 19118  	var zeroValue string
 19119  	r := &RunnerLabels{Type: &zeroValue}
 19120  	r.GetType()
 19121  	r = &RunnerLabels{}
 19122  	r.GetType()
 19123  	r = nil
 19124  	r.GetType()
 19125  }
 19126  
 19127  func TestSarifAnalysis_GetCheckoutURI(tt *testing.T) {
 19128  	var zeroValue string
 19129  	s := &SarifAnalysis{CheckoutURI: &zeroValue}
 19130  	s.GetCheckoutURI()
 19131  	s = &SarifAnalysis{}
 19132  	s.GetCheckoutURI()
 19133  	s = nil
 19134  	s.GetCheckoutURI()
 19135  }
 19136  
 19137  func TestSarifAnalysis_GetCommitSHA(tt *testing.T) {
 19138  	var zeroValue string
 19139  	s := &SarifAnalysis{CommitSHA: &zeroValue}
 19140  	s.GetCommitSHA()
 19141  	s = &SarifAnalysis{}
 19142  	s.GetCommitSHA()
 19143  	s = nil
 19144  	s.GetCommitSHA()
 19145  }
 19146  
 19147  func TestSarifAnalysis_GetRef(tt *testing.T) {
 19148  	var zeroValue string
 19149  	s := &SarifAnalysis{Ref: &zeroValue}
 19150  	s.GetRef()
 19151  	s = &SarifAnalysis{}
 19152  	s.GetRef()
 19153  	s = nil
 19154  	s.GetRef()
 19155  }
 19156  
 19157  func TestSarifAnalysis_GetSarif(tt *testing.T) {
 19158  	var zeroValue string
 19159  	s := &SarifAnalysis{Sarif: &zeroValue}
 19160  	s.GetSarif()
 19161  	s = &SarifAnalysis{}
 19162  	s.GetSarif()
 19163  	s = nil
 19164  	s.GetSarif()
 19165  }
 19166  
 19167  func TestSarifAnalysis_GetStartedAt(tt *testing.T) {
 19168  	var zeroValue Timestamp
 19169  	s := &SarifAnalysis{StartedAt: &zeroValue}
 19170  	s.GetStartedAt()
 19171  	s = &SarifAnalysis{}
 19172  	s.GetStartedAt()
 19173  	s = nil
 19174  	s.GetStartedAt()
 19175  }
 19176  
 19177  func TestSarifAnalysis_GetToolName(tt *testing.T) {
 19178  	var zeroValue string
 19179  	s := &SarifAnalysis{ToolName: &zeroValue}
 19180  	s.GetToolName()
 19181  	s = &SarifAnalysis{}
 19182  	s.GetToolName()
 19183  	s = nil
 19184  	s.GetToolName()
 19185  }
 19186  
 19187  func TestSarifID_GetID(tt *testing.T) {
 19188  	var zeroValue string
 19189  	s := &SarifID{ID: &zeroValue}
 19190  	s.GetID()
 19191  	s = &SarifID{}
 19192  	s.GetID()
 19193  	s = nil
 19194  	s.GetID()
 19195  }
 19196  
 19197  func TestSarifID_GetURL(tt *testing.T) {
 19198  	var zeroValue string
 19199  	s := &SarifID{URL: &zeroValue}
 19200  	s.GetURL()
 19201  	s = &SarifID{}
 19202  	s.GetURL()
 19203  	s = nil
 19204  	s.GetURL()
 19205  }
 19206  
 19207  func TestScanningAnalysis_GetAnalysisKey(tt *testing.T) {
 19208  	var zeroValue string
 19209  	s := &ScanningAnalysis{AnalysisKey: &zeroValue}
 19210  	s.GetAnalysisKey()
 19211  	s = &ScanningAnalysis{}
 19212  	s.GetAnalysisKey()
 19213  	s = nil
 19214  	s.GetAnalysisKey()
 19215  }
 19216  
 19217  func TestScanningAnalysis_GetCategory(tt *testing.T) {
 19218  	var zeroValue string
 19219  	s := &ScanningAnalysis{Category: &zeroValue}
 19220  	s.GetCategory()
 19221  	s = &ScanningAnalysis{}
 19222  	s.GetCategory()
 19223  	s = nil
 19224  	s.GetCategory()
 19225  }
 19226  
 19227  func TestScanningAnalysis_GetCommitSHA(tt *testing.T) {
 19228  	var zeroValue string
 19229  	s := &ScanningAnalysis{CommitSHA: &zeroValue}
 19230  	s.GetCommitSHA()
 19231  	s = &ScanningAnalysis{}
 19232  	s.GetCommitSHA()
 19233  	s = nil
 19234  	s.GetCommitSHA()
 19235  }
 19236  
 19237  func TestScanningAnalysis_GetCreatedAt(tt *testing.T) {
 19238  	var zeroValue Timestamp
 19239  	s := &ScanningAnalysis{CreatedAt: &zeroValue}
 19240  	s.GetCreatedAt()
 19241  	s = &ScanningAnalysis{}
 19242  	s.GetCreatedAt()
 19243  	s = nil
 19244  	s.GetCreatedAt()
 19245  }
 19246  
 19247  func TestScanningAnalysis_GetDeletable(tt *testing.T) {
 19248  	var zeroValue bool
 19249  	s := &ScanningAnalysis{Deletable: &zeroValue}
 19250  	s.GetDeletable()
 19251  	s = &ScanningAnalysis{}
 19252  	s.GetDeletable()
 19253  	s = nil
 19254  	s.GetDeletable()
 19255  }
 19256  
 19257  func TestScanningAnalysis_GetEnvironment(tt *testing.T) {
 19258  	var zeroValue string
 19259  	s := &ScanningAnalysis{Environment: &zeroValue}
 19260  	s.GetEnvironment()
 19261  	s = &ScanningAnalysis{}
 19262  	s.GetEnvironment()
 19263  	s = nil
 19264  	s.GetEnvironment()
 19265  }
 19266  
 19267  func TestScanningAnalysis_GetError(tt *testing.T) {
 19268  	var zeroValue string
 19269  	s := &ScanningAnalysis{Error: &zeroValue}
 19270  	s.GetError()
 19271  	s = &ScanningAnalysis{}
 19272  	s.GetError()
 19273  	s = nil
 19274  	s.GetError()
 19275  }
 19276  
 19277  func TestScanningAnalysis_GetID(tt *testing.T) {
 19278  	var zeroValue int64
 19279  	s := &ScanningAnalysis{ID: &zeroValue}
 19280  	s.GetID()
 19281  	s = &ScanningAnalysis{}
 19282  	s.GetID()
 19283  	s = nil
 19284  	s.GetID()
 19285  }
 19286  
 19287  func TestScanningAnalysis_GetRef(tt *testing.T) {
 19288  	var zeroValue string
 19289  	s := &ScanningAnalysis{Ref: &zeroValue}
 19290  	s.GetRef()
 19291  	s = &ScanningAnalysis{}
 19292  	s.GetRef()
 19293  	s = nil
 19294  	s.GetRef()
 19295  }
 19296  
 19297  func TestScanningAnalysis_GetResultsCount(tt *testing.T) {
 19298  	var zeroValue int
 19299  	s := &ScanningAnalysis{ResultsCount: &zeroValue}
 19300  	s.GetResultsCount()
 19301  	s = &ScanningAnalysis{}
 19302  	s.GetResultsCount()
 19303  	s = nil
 19304  	s.GetResultsCount()
 19305  }
 19306  
 19307  func TestScanningAnalysis_GetRulesCount(tt *testing.T) {
 19308  	var zeroValue int
 19309  	s := &ScanningAnalysis{RulesCount: &zeroValue}
 19310  	s.GetRulesCount()
 19311  	s = &ScanningAnalysis{}
 19312  	s.GetRulesCount()
 19313  	s = nil
 19314  	s.GetRulesCount()
 19315  }
 19316  
 19317  func TestScanningAnalysis_GetSarifID(tt *testing.T) {
 19318  	var zeroValue string
 19319  	s := &ScanningAnalysis{SarifID: &zeroValue}
 19320  	s.GetSarifID()
 19321  	s = &ScanningAnalysis{}
 19322  	s.GetSarifID()
 19323  	s = nil
 19324  	s.GetSarifID()
 19325  }
 19326  
 19327  func TestScanningAnalysis_GetTool(tt *testing.T) {
 19328  	s := &ScanningAnalysis{}
 19329  	s.GetTool()
 19330  	s = nil
 19331  	s.GetTool()
 19332  }
 19333  
 19334  func TestScanningAnalysis_GetURL(tt *testing.T) {
 19335  	var zeroValue string
 19336  	s := &ScanningAnalysis{URL: &zeroValue}
 19337  	s.GetURL()
 19338  	s = &ScanningAnalysis{}
 19339  	s.GetURL()
 19340  	s = nil
 19341  	s.GetURL()
 19342  }
 19343  
 19344  func TestScanningAnalysis_GetWarning(tt *testing.T) {
 19345  	var zeroValue string
 19346  	s := &ScanningAnalysis{Warning: &zeroValue}
 19347  	s.GetWarning()
 19348  	s = &ScanningAnalysis{}
 19349  	s.GetWarning()
 19350  	s = nil
 19351  	s.GetWarning()
 19352  }
 19353  
 19354  func TestSCIMUserAttributes_GetActive(tt *testing.T) {
 19355  	var zeroValue bool
 19356  	s := &SCIMUserAttributes{Active: &zeroValue}
 19357  	s.GetActive()
 19358  	s = &SCIMUserAttributes{}
 19359  	s.GetActive()
 19360  	s = nil
 19361  	s.GetActive()
 19362  }
 19363  
 19364  func TestSCIMUserAttributes_GetDisplayName(tt *testing.T) {
 19365  	var zeroValue string
 19366  	s := &SCIMUserAttributes{DisplayName: &zeroValue}
 19367  	s.GetDisplayName()
 19368  	s = &SCIMUserAttributes{}
 19369  	s.GetDisplayName()
 19370  	s = nil
 19371  	s.GetDisplayName()
 19372  }
 19373  
 19374  func TestSCIMUserAttributes_GetExternalID(tt *testing.T) {
 19375  	var zeroValue string
 19376  	s := &SCIMUserAttributes{ExternalID: &zeroValue}
 19377  	s.GetExternalID()
 19378  	s = &SCIMUserAttributes{}
 19379  	s.GetExternalID()
 19380  	s = nil
 19381  	s.GetExternalID()
 19382  }
 19383  
 19384  func TestSCIMUserEmail_GetPrimary(tt *testing.T) {
 19385  	var zeroValue bool
 19386  	s := &SCIMUserEmail{Primary: &zeroValue}
 19387  	s.GetPrimary()
 19388  	s = &SCIMUserEmail{}
 19389  	s.GetPrimary()
 19390  	s = nil
 19391  	s.GetPrimary()
 19392  }
 19393  
 19394  func TestSCIMUserEmail_GetType(tt *testing.T) {
 19395  	var zeroValue string
 19396  	s := &SCIMUserEmail{Type: &zeroValue}
 19397  	s.GetType()
 19398  	s = &SCIMUserEmail{}
 19399  	s.GetType()
 19400  	s = nil
 19401  	s.GetType()
 19402  }
 19403  
 19404  func TestSCIMUserName_GetFormatted(tt *testing.T) {
 19405  	var zeroValue string
 19406  	s := &SCIMUserName{Formatted: &zeroValue}
 19407  	s.GetFormatted()
 19408  	s = &SCIMUserName{}
 19409  	s.GetFormatted()
 19410  	s = nil
 19411  	s.GetFormatted()
 19412  }
 19413  
 19414  func TestSecretScanning_GetStatus(tt *testing.T) {
 19415  	var zeroValue string
 19416  	s := &SecretScanning{Status: &zeroValue}
 19417  	s.GetStatus()
 19418  	s = &SecretScanning{}
 19419  	s.GetStatus()
 19420  	s = nil
 19421  	s.GetStatus()
 19422  }
 19423  
 19424  func TestSecretScanningAlert_GetCreatedAt(tt *testing.T) {
 19425  	var zeroValue Timestamp
 19426  	s := &SecretScanningAlert{CreatedAt: &zeroValue}
 19427  	s.GetCreatedAt()
 19428  	s = &SecretScanningAlert{}
 19429  	s.GetCreatedAt()
 19430  	s = nil
 19431  	s.GetCreatedAt()
 19432  }
 19433  
 19434  func TestSecretScanningAlert_GetHTMLURL(tt *testing.T) {
 19435  	var zeroValue string
 19436  	s := &SecretScanningAlert{HTMLURL: &zeroValue}
 19437  	s.GetHTMLURL()
 19438  	s = &SecretScanningAlert{}
 19439  	s.GetHTMLURL()
 19440  	s = nil
 19441  	s.GetHTMLURL()
 19442  }
 19443  
 19444  func TestSecretScanningAlert_GetLocationsURL(tt *testing.T) {
 19445  	var zeroValue string
 19446  	s := &SecretScanningAlert{LocationsURL: &zeroValue}
 19447  	s.GetLocationsURL()
 19448  	s = &SecretScanningAlert{}
 19449  	s.GetLocationsURL()
 19450  	s = nil
 19451  	s.GetLocationsURL()
 19452  }
 19453  
 19454  func TestSecretScanningAlert_GetNumber(tt *testing.T) {
 19455  	var zeroValue int
 19456  	s := &SecretScanningAlert{Number: &zeroValue}
 19457  	s.GetNumber()
 19458  	s = &SecretScanningAlert{}
 19459  	s.GetNumber()
 19460  	s = nil
 19461  	s.GetNumber()
 19462  }
 19463  
 19464  func TestSecretScanningAlert_GetResolution(tt *testing.T) {
 19465  	var zeroValue string
 19466  	s := &SecretScanningAlert{Resolution: &zeroValue}
 19467  	s.GetResolution()
 19468  	s = &SecretScanningAlert{}
 19469  	s.GetResolution()
 19470  	s = nil
 19471  	s.GetResolution()
 19472  }
 19473  
 19474  func TestSecretScanningAlert_GetResolvedAt(tt *testing.T) {
 19475  	var zeroValue Timestamp
 19476  	s := &SecretScanningAlert{ResolvedAt: &zeroValue}
 19477  	s.GetResolvedAt()
 19478  	s = &SecretScanningAlert{}
 19479  	s.GetResolvedAt()
 19480  	s = nil
 19481  	s.GetResolvedAt()
 19482  }
 19483  
 19484  func TestSecretScanningAlert_GetResolvedBy(tt *testing.T) {
 19485  	s := &SecretScanningAlert{}
 19486  	s.GetResolvedBy()
 19487  	s = nil
 19488  	s.GetResolvedBy()
 19489  }
 19490  
 19491  func TestSecretScanningAlert_GetSecret(tt *testing.T) {
 19492  	var zeroValue string
 19493  	s := &SecretScanningAlert{Secret: &zeroValue}
 19494  	s.GetSecret()
 19495  	s = &SecretScanningAlert{}
 19496  	s.GetSecret()
 19497  	s = nil
 19498  	s.GetSecret()
 19499  }
 19500  
 19501  func TestSecretScanningAlert_GetSecretType(tt *testing.T) {
 19502  	var zeroValue string
 19503  	s := &SecretScanningAlert{SecretType: &zeroValue}
 19504  	s.GetSecretType()
 19505  	s = &SecretScanningAlert{}
 19506  	s.GetSecretType()
 19507  	s = nil
 19508  	s.GetSecretType()
 19509  }
 19510  
 19511  func TestSecretScanningAlert_GetState(tt *testing.T) {
 19512  	var zeroValue string
 19513  	s := &SecretScanningAlert{State: &zeroValue}
 19514  	s.GetState()
 19515  	s = &SecretScanningAlert{}
 19516  	s.GetState()
 19517  	s = nil
 19518  	s.GetState()
 19519  }
 19520  
 19521  func TestSecretScanningAlert_GetURL(tt *testing.T) {
 19522  	var zeroValue string
 19523  	s := &SecretScanningAlert{URL: &zeroValue}
 19524  	s.GetURL()
 19525  	s = &SecretScanningAlert{}
 19526  	s.GetURL()
 19527  	s = nil
 19528  	s.GetURL()
 19529  }
 19530  
 19531  func TestSecretScanningAlertEvent_GetAction(tt *testing.T) {
 19532  	var zeroValue string
 19533  	s := &SecretScanningAlertEvent{Action: &zeroValue}
 19534  	s.GetAction()
 19535  	s = &SecretScanningAlertEvent{}
 19536  	s.GetAction()
 19537  	s = nil
 19538  	s.GetAction()
 19539  }
 19540  
 19541  func TestSecretScanningAlertEvent_GetAlert(tt *testing.T) {
 19542  	s := &SecretScanningAlertEvent{}
 19543  	s.GetAlert()
 19544  	s = nil
 19545  	s.GetAlert()
 19546  }
 19547  
 19548  func TestSecretScanningAlertEvent_GetEnterprise(tt *testing.T) {
 19549  	s := &SecretScanningAlertEvent{}
 19550  	s.GetEnterprise()
 19551  	s = nil
 19552  	s.GetEnterprise()
 19553  }
 19554  
 19555  func TestSecretScanningAlertEvent_GetInstallation(tt *testing.T) {
 19556  	s := &SecretScanningAlertEvent{}
 19557  	s.GetInstallation()
 19558  	s = nil
 19559  	s.GetInstallation()
 19560  }
 19561  
 19562  func TestSecretScanningAlertEvent_GetOrganization(tt *testing.T) {
 19563  	s := &SecretScanningAlertEvent{}
 19564  	s.GetOrganization()
 19565  	s = nil
 19566  	s.GetOrganization()
 19567  }
 19568  
 19569  func TestSecretScanningAlertEvent_GetRepo(tt *testing.T) {
 19570  	s := &SecretScanningAlertEvent{}
 19571  	s.GetRepo()
 19572  	s = nil
 19573  	s.GetRepo()
 19574  }
 19575  
 19576  func TestSecretScanningAlertEvent_GetSender(tt *testing.T) {
 19577  	s := &SecretScanningAlertEvent{}
 19578  	s.GetSender()
 19579  	s = nil
 19580  	s.GetSender()
 19581  }
 19582  
 19583  func TestSecretScanningAlertLocation_GetDetails(tt *testing.T) {
 19584  	s := &SecretScanningAlertLocation{}
 19585  	s.GetDetails()
 19586  	s = nil
 19587  	s.GetDetails()
 19588  }
 19589  
 19590  func TestSecretScanningAlertLocation_GetType(tt *testing.T) {
 19591  	var zeroValue string
 19592  	s := &SecretScanningAlertLocation{Type: &zeroValue}
 19593  	s.GetType()
 19594  	s = &SecretScanningAlertLocation{}
 19595  	s.GetType()
 19596  	s = nil
 19597  	s.GetType()
 19598  }
 19599  
 19600  func TestSecretScanningAlertLocationDetails_GetBlobSHA(tt *testing.T) {
 19601  	var zeroValue string
 19602  	s := &SecretScanningAlertLocationDetails{BlobSHA: &zeroValue}
 19603  	s.GetBlobSHA()
 19604  	s = &SecretScanningAlertLocationDetails{}
 19605  	s.GetBlobSHA()
 19606  	s = nil
 19607  	s.GetBlobSHA()
 19608  }
 19609  
 19610  func TestSecretScanningAlertLocationDetails_GetBlobURL(tt *testing.T) {
 19611  	var zeroValue string
 19612  	s := &SecretScanningAlertLocationDetails{BlobURL: &zeroValue}
 19613  	s.GetBlobURL()
 19614  	s = &SecretScanningAlertLocationDetails{}
 19615  	s.GetBlobURL()
 19616  	s = nil
 19617  	s.GetBlobURL()
 19618  }
 19619  
 19620  func TestSecretScanningAlertLocationDetails_GetCommitSHA(tt *testing.T) {
 19621  	var zeroValue string
 19622  	s := &SecretScanningAlertLocationDetails{CommitSHA: &zeroValue}
 19623  	s.GetCommitSHA()
 19624  	s = &SecretScanningAlertLocationDetails{}
 19625  	s.GetCommitSHA()
 19626  	s = nil
 19627  	s.GetCommitSHA()
 19628  }
 19629  
 19630  func TestSecretScanningAlertLocationDetails_GetCommitURL(tt *testing.T) {
 19631  	var zeroValue string
 19632  	s := &SecretScanningAlertLocationDetails{CommitURL: &zeroValue}
 19633  	s.GetCommitURL()
 19634  	s = &SecretScanningAlertLocationDetails{}
 19635  	s.GetCommitURL()
 19636  	s = nil
 19637  	s.GetCommitURL()
 19638  }
 19639  
 19640  func TestSecretScanningAlertLocationDetails_GetEndColumn(tt *testing.T) {
 19641  	var zeroValue int
 19642  	s := &SecretScanningAlertLocationDetails{EndColumn: &zeroValue}
 19643  	s.GetEndColumn()
 19644  	s = &SecretScanningAlertLocationDetails{}
 19645  	s.GetEndColumn()
 19646  	s = nil
 19647  	s.GetEndColumn()
 19648  }
 19649  
 19650  func TestSecretScanningAlertLocationDetails_GetEndLine(tt *testing.T) {
 19651  	var zeroValue int
 19652  	s := &SecretScanningAlertLocationDetails{EndLine: &zeroValue}
 19653  	s.GetEndLine()
 19654  	s = &SecretScanningAlertLocationDetails{}
 19655  	s.GetEndLine()
 19656  	s = nil
 19657  	s.GetEndLine()
 19658  }
 19659  
 19660  func TestSecretScanningAlertLocationDetails_GetPath(tt *testing.T) {
 19661  	var zeroValue string
 19662  	s := &SecretScanningAlertLocationDetails{Path: &zeroValue}
 19663  	s.GetPath()
 19664  	s = &SecretScanningAlertLocationDetails{}
 19665  	s.GetPath()
 19666  	s = nil
 19667  	s.GetPath()
 19668  }
 19669  
 19670  func TestSecretScanningAlertLocationDetails_GetStartColumn(tt *testing.T) {
 19671  	var zeroValue int
 19672  	s := &SecretScanningAlertLocationDetails{StartColumn: &zeroValue}
 19673  	s.GetStartColumn()
 19674  	s = &SecretScanningAlertLocationDetails{}
 19675  	s.GetStartColumn()
 19676  	s = nil
 19677  	s.GetStartColumn()
 19678  }
 19679  
 19680  func TestSecretScanningAlertLocationDetails_GetStartline(tt *testing.T) {
 19681  	var zeroValue int
 19682  	s := &SecretScanningAlertLocationDetails{Startline: &zeroValue}
 19683  	s.GetStartline()
 19684  	s = &SecretScanningAlertLocationDetails{}
 19685  	s.GetStartline()
 19686  	s = nil
 19687  	s.GetStartline()
 19688  }
 19689  
 19690  func TestSecretScanningAlertUpdateOptions_GetResolution(tt *testing.T) {
 19691  	var zeroValue string
 19692  	s := &SecretScanningAlertUpdateOptions{Resolution: &zeroValue}
 19693  	s.GetResolution()
 19694  	s = &SecretScanningAlertUpdateOptions{}
 19695  	s.GetResolution()
 19696  	s = nil
 19697  	s.GetResolution()
 19698  }
 19699  
 19700  func TestSecretScanningAlertUpdateOptions_GetSecretType(tt *testing.T) {
 19701  	var zeroValue string
 19702  	s := &SecretScanningAlertUpdateOptions{SecretType: &zeroValue}
 19703  	s.GetSecretType()
 19704  	s = &SecretScanningAlertUpdateOptions{}
 19705  	s.GetSecretType()
 19706  	s = nil
 19707  	s.GetSecretType()
 19708  }
 19709  
 19710  func TestSecretScanningAlertUpdateOptions_GetState(tt *testing.T) {
 19711  	var zeroValue string
 19712  	s := &SecretScanningAlertUpdateOptions{State: &zeroValue}
 19713  	s.GetState()
 19714  	s = &SecretScanningAlertUpdateOptions{}
 19715  	s.GetState()
 19716  	s = nil
 19717  	s.GetState()
 19718  }
 19719  
 19720  func TestSecurityAdvisory_GetDescription(tt *testing.T) {
 19721  	var zeroValue string
 19722  	s := &SecurityAdvisory{Description: &zeroValue}
 19723  	s.GetDescription()
 19724  	s = &SecurityAdvisory{}
 19725  	s.GetDescription()
 19726  	s = nil
 19727  	s.GetDescription()
 19728  }
 19729  
 19730  func TestSecurityAdvisory_GetGHSAID(tt *testing.T) {
 19731  	var zeroValue string
 19732  	s := &SecurityAdvisory{GHSAID: &zeroValue}
 19733  	s.GetGHSAID()
 19734  	s = &SecurityAdvisory{}
 19735  	s.GetGHSAID()
 19736  	s = nil
 19737  	s.GetGHSAID()
 19738  }
 19739  
 19740  func TestSecurityAdvisory_GetPublishedAt(tt *testing.T) {
 19741  	var zeroValue Timestamp
 19742  	s := &SecurityAdvisory{PublishedAt: &zeroValue}
 19743  	s.GetPublishedAt()
 19744  	s = &SecurityAdvisory{}
 19745  	s.GetPublishedAt()
 19746  	s = nil
 19747  	s.GetPublishedAt()
 19748  }
 19749  
 19750  func TestSecurityAdvisory_GetSeverity(tt *testing.T) {
 19751  	var zeroValue string
 19752  	s := &SecurityAdvisory{Severity: &zeroValue}
 19753  	s.GetSeverity()
 19754  	s = &SecurityAdvisory{}
 19755  	s.GetSeverity()
 19756  	s = nil
 19757  	s.GetSeverity()
 19758  }
 19759  
 19760  func TestSecurityAdvisory_GetSummary(tt *testing.T) {
 19761  	var zeroValue string
 19762  	s := &SecurityAdvisory{Summary: &zeroValue}
 19763  	s.GetSummary()
 19764  	s = &SecurityAdvisory{}
 19765  	s.GetSummary()
 19766  	s = nil
 19767  	s.GetSummary()
 19768  }
 19769  
 19770  func TestSecurityAdvisory_GetUpdatedAt(tt *testing.T) {
 19771  	var zeroValue Timestamp
 19772  	s := &SecurityAdvisory{UpdatedAt: &zeroValue}
 19773  	s.GetUpdatedAt()
 19774  	s = &SecurityAdvisory{}
 19775  	s.GetUpdatedAt()
 19776  	s = nil
 19777  	s.GetUpdatedAt()
 19778  }
 19779  
 19780  func TestSecurityAdvisory_GetWithdrawnAt(tt *testing.T) {
 19781  	var zeroValue Timestamp
 19782  	s := &SecurityAdvisory{WithdrawnAt: &zeroValue}
 19783  	s.GetWithdrawnAt()
 19784  	s = &SecurityAdvisory{}
 19785  	s.GetWithdrawnAt()
 19786  	s = nil
 19787  	s.GetWithdrawnAt()
 19788  }
 19789  
 19790  func TestSecurityAdvisoryEvent_GetAction(tt *testing.T) {
 19791  	var zeroValue string
 19792  	s := &SecurityAdvisoryEvent{Action: &zeroValue}
 19793  	s.GetAction()
 19794  	s = &SecurityAdvisoryEvent{}
 19795  	s.GetAction()
 19796  	s = nil
 19797  	s.GetAction()
 19798  }
 19799  
 19800  func TestSecurityAdvisoryEvent_GetSecurityAdvisory(tt *testing.T) {
 19801  	s := &SecurityAdvisoryEvent{}
 19802  	s.GetSecurityAdvisory()
 19803  	s = nil
 19804  	s.GetSecurityAdvisory()
 19805  }
 19806  
 19807  func TestSecurityAndAnalysis_GetAdvancedSecurity(tt *testing.T) {
 19808  	s := &SecurityAndAnalysis{}
 19809  	s.GetAdvancedSecurity()
 19810  	s = nil
 19811  	s.GetAdvancedSecurity()
 19812  }
 19813  
 19814  func TestSecurityAndAnalysis_GetSecretScanning(tt *testing.T) {
 19815  	s := &SecurityAndAnalysis{}
 19816  	s.GetSecretScanning()
 19817  	s = nil
 19818  	s.GetSecretScanning()
 19819  }
 19820  
 19821  func TestSelectedReposList_GetTotalCount(tt *testing.T) {
 19822  	var zeroValue int
 19823  	s := &SelectedReposList{TotalCount: &zeroValue}
 19824  	s.GetTotalCount()
 19825  	s = &SelectedReposList{}
 19826  	s.GetTotalCount()
 19827  	s = nil
 19828  	s.GetTotalCount()
 19829  }
 19830  
 19831  func TestServiceHook_GetName(tt *testing.T) {
 19832  	var zeroValue string
 19833  	s := &ServiceHook{Name: &zeroValue}
 19834  	s.GetName()
 19835  	s = &ServiceHook{}
 19836  	s.GetName()
 19837  	s = nil
 19838  	s.GetName()
 19839  }
 19840  
 19841  func TestSignaturesProtectedBranch_GetEnabled(tt *testing.T) {
 19842  	var zeroValue bool
 19843  	s := &SignaturesProtectedBranch{Enabled: &zeroValue}
 19844  	s.GetEnabled()
 19845  	s = &SignaturesProtectedBranch{}
 19846  	s.GetEnabled()
 19847  	s = nil
 19848  	s.GetEnabled()
 19849  }
 19850  
 19851  func TestSignaturesProtectedBranch_GetURL(tt *testing.T) {
 19852  	var zeroValue string
 19853  	s := &SignaturesProtectedBranch{URL: &zeroValue}
 19854  	s.GetURL()
 19855  	s = &SignaturesProtectedBranch{}
 19856  	s.GetURL()
 19857  	s = nil
 19858  	s.GetURL()
 19859  }
 19860  
 19861  func TestSignatureVerification_GetPayload(tt *testing.T) {
 19862  	var zeroValue string
 19863  	s := &SignatureVerification{Payload: &zeroValue}
 19864  	s.GetPayload()
 19865  	s = &SignatureVerification{}
 19866  	s.GetPayload()
 19867  	s = nil
 19868  	s.GetPayload()
 19869  }
 19870  
 19871  func TestSignatureVerification_GetReason(tt *testing.T) {
 19872  	var zeroValue string
 19873  	s := &SignatureVerification{Reason: &zeroValue}
 19874  	s.GetReason()
 19875  	s = &SignatureVerification{}
 19876  	s.GetReason()
 19877  	s = nil
 19878  	s.GetReason()
 19879  }
 19880  
 19881  func TestSignatureVerification_GetSignature(tt *testing.T) {
 19882  	var zeroValue string
 19883  	s := &SignatureVerification{Signature: &zeroValue}
 19884  	s.GetSignature()
 19885  	s = &SignatureVerification{}
 19886  	s.GetSignature()
 19887  	s = nil
 19888  	s.GetSignature()
 19889  }
 19890  
 19891  func TestSignatureVerification_GetVerified(tt *testing.T) {
 19892  	var zeroValue bool
 19893  	s := &SignatureVerification{Verified: &zeroValue}
 19894  	s.GetVerified()
 19895  	s = &SignatureVerification{}
 19896  	s.GetVerified()
 19897  	s = nil
 19898  	s.GetVerified()
 19899  }
 19900  
 19901  func TestSource_GetActor(tt *testing.T) {
 19902  	s := &Source{}
 19903  	s.GetActor()
 19904  	s = nil
 19905  	s.GetActor()
 19906  }
 19907  
 19908  func TestSource_GetID(tt *testing.T) {
 19909  	var zeroValue int64
 19910  	s := &Source{ID: &zeroValue}
 19911  	s.GetID()
 19912  	s = &Source{}
 19913  	s.GetID()
 19914  	s = nil
 19915  	s.GetID()
 19916  }
 19917  
 19918  func TestSource_GetIssue(tt *testing.T) {
 19919  	s := &Source{}
 19920  	s.GetIssue()
 19921  	s = nil
 19922  	s.GetIssue()
 19923  }
 19924  
 19925  func TestSource_GetType(tt *testing.T) {
 19926  	var zeroValue string
 19927  	s := &Source{Type: &zeroValue}
 19928  	s.GetType()
 19929  	s = &Source{}
 19930  	s.GetType()
 19931  	s = nil
 19932  	s.GetType()
 19933  }
 19934  
 19935  func TestSource_GetURL(tt *testing.T) {
 19936  	var zeroValue string
 19937  	s := &Source{URL: &zeroValue}
 19938  	s.GetURL()
 19939  	s = &Source{}
 19940  	s.GetURL()
 19941  	s = nil
 19942  	s.GetURL()
 19943  }
 19944  
 19945  func TestSourceImportAuthor_GetEmail(tt *testing.T) {
 19946  	var zeroValue string
 19947  	s := &SourceImportAuthor{Email: &zeroValue}
 19948  	s.GetEmail()
 19949  	s = &SourceImportAuthor{}
 19950  	s.GetEmail()
 19951  	s = nil
 19952  	s.GetEmail()
 19953  }
 19954  
 19955  func TestSourceImportAuthor_GetID(tt *testing.T) {
 19956  	var zeroValue int64
 19957  	s := &SourceImportAuthor{ID: &zeroValue}
 19958  	s.GetID()
 19959  	s = &SourceImportAuthor{}
 19960  	s.GetID()
 19961  	s = nil
 19962  	s.GetID()
 19963  }
 19964  
 19965  func TestSourceImportAuthor_GetImportURL(tt *testing.T) {
 19966  	var zeroValue string
 19967  	s := &SourceImportAuthor{ImportURL: &zeroValue}
 19968  	s.GetImportURL()
 19969  	s = &SourceImportAuthor{}
 19970  	s.GetImportURL()
 19971  	s = nil
 19972  	s.GetImportURL()
 19973  }
 19974  
 19975  func TestSourceImportAuthor_GetName(tt *testing.T) {
 19976  	var zeroValue string
 19977  	s := &SourceImportAuthor{Name: &zeroValue}
 19978  	s.GetName()
 19979  	s = &SourceImportAuthor{}
 19980  	s.GetName()
 19981  	s = nil
 19982  	s.GetName()
 19983  }
 19984  
 19985  func TestSourceImportAuthor_GetRemoteID(tt *testing.T) {
 19986  	var zeroValue string
 19987  	s := &SourceImportAuthor{RemoteID: &zeroValue}
 19988  	s.GetRemoteID()
 19989  	s = &SourceImportAuthor{}
 19990  	s.GetRemoteID()
 19991  	s = nil
 19992  	s.GetRemoteID()
 19993  }
 19994  
 19995  func TestSourceImportAuthor_GetRemoteName(tt *testing.T) {
 19996  	var zeroValue string
 19997  	s := &SourceImportAuthor{RemoteName: &zeroValue}
 19998  	s.GetRemoteName()
 19999  	s = &SourceImportAuthor{}
 20000  	s.GetRemoteName()
 20001  	s = nil
 20002  	s.GetRemoteName()
 20003  }
 20004  
 20005  func TestSourceImportAuthor_GetURL(tt *testing.T) {
 20006  	var zeroValue string
 20007  	s := &SourceImportAuthor{URL: &zeroValue}
 20008  	s.GetURL()
 20009  	s = &SourceImportAuthor{}
 20010  	s.GetURL()
 20011  	s = nil
 20012  	s.GetURL()
 20013  }
 20014  
 20015  func TestStarEvent_GetAction(tt *testing.T) {
 20016  	var zeroValue string
 20017  	s := &StarEvent{Action: &zeroValue}
 20018  	s.GetAction()
 20019  	s = &StarEvent{}
 20020  	s.GetAction()
 20021  	s = nil
 20022  	s.GetAction()
 20023  }
 20024  
 20025  func TestStarEvent_GetInstallation(tt *testing.T) {
 20026  	s := &StarEvent{}
 20027  	s.GetInstallation()
 20028  	s = nil
 20029  	s.GetInstallation()
 20030  }
 20031  
 20032  func TestStarEvent_GetOrg(tt *testing.T) {
 20033  	s := &StarEvent{}
 20034  	s.GetOrg()
 20035  	s = nil
 20036  	s.GetOrg()
 20037  }
 20038  
 20039  func TestStarEvent_GetRepo(tt *testing.T) {
 20040  	s := &StarEvent{}
 20041  	s.GetRepo()
 20042  	s = nil
 20043  	s.GetRepo()
 20044  }
 20045  
 20046  func TestStarEvent_GetSender(tt *testing.T) {
 20047  	s := &StarEvent{}
 20048  	s.GetSender()
 20049  	s = nil
 20050  	s.GetSender()
 20051  }
 20052  
 20053  func TestStarEvent_GetStarredAt(tt *testing.T) {
 20054  	var zeroValue Timestamp
 20055  	s := &StarEvent{StarredAt: &zeroValue}
 20056  	s.GetStarredAt()
 20057  	s = &StarEvent{}
 20058  	s.GetStarredAt()
 20059  	s = nil
 20060  	s.GetStarredAt()
 20061  }
 20062  
 20063  func TestStargazer_GetStarredAt(tt *testing.T) {
 20064  	var zeroValue Timestamp
 20065  	s := &Stargazer{StarredAt: &zeroValue}
 20066  	s.GetStarredAt()
 20067  	s = &Stargazer{}
 20068  	s.GetStarredAt()
 20069  	s = nil
 20070  	s.GetStarredAt()
 20071  }
 20072  
 20073  func TestStargazer_GetUser(tt *testing.T) {
 20074  	s := &Stargazer{}
 20075  	s.GetUser()
 20076  	s = nil
 20077  	s.GetUser()
 20078  }
 20079  
 20080  func TestStarredRepository_GetRepository(tt *testing.T) {
 20081  	s := &StarredRepository{}
 20082  	s.GetRepository()
 20083  	s = nil
 20084  	s.GetRepository()
 20085  }
 20086  
 20087  func TestStarredRepository_GetStarredAt(tt *testing.T) {
 20088  	var zeroValue Timestamp
 20089  	s := &StarredRepository{StarredAt: &zeroValue}
 20090  	s.GetStarredAt()
 20091  	s = &StarredRepository{}
 20092  	s.GetStarredAt()
 20093  	s = nil
 20094  	s.GetStarredAt()
 20095  }
 20096  
 20097  func TestStatusEvent_GetCommit(tt *testing.T) {
 20098  	s := &StatusEvent{}
 20099  	s.GetCommit()
 20100  	s = nil
 20101  	s.GetCommit()
 20102  }
 20103  
 20104  func TestStatusEvent_GetContext(tt *testing.T) {
 20105  	var zeroValue string
 20106  	s := &StatusEvent{Context: &zeroValue}
 20107  	s.GetContext()
 20108  	s = &StatusEvent{}
 20109  	s.GetContext()
 20110  	s = nil
 20111  	s.GetContext()
 20112  }
 20113  
 20114  func TestStatusEvent_GetCreatedAt(tt *testing.T) {
 20115  	var zeroValue Timestamp
 20116  	s := &StatusEvent{CreatedAt: &zeroValue}
 20117  	s.GetCreatedAt()
 20118  	s = &StatusEvent{}
 20119  	s.GetCreatedAt()
 20120  	s = nil
 20121  	s.GetCreatedAt()
 20122  }
 20123  
 20124  func TestStatusEvent_GetDescription(tt *testing.T) {
 20125  	var zeroValue string
 20126  	s := &StatusEvent{Description: &zeroValue}
 20127  	s.GetDescription()
 20128  	s = &StatusEvent{}
 20129  	s.GetDescription()
 20130  	s = nil
 20131  	s.GetDescription()
 20132  }
 20133  
 20134  func TestStatusEvent_GetID(tt *testing.T) {
 20135  	var zeroValue int64
 20136  	s := &StatusEvent{ID: &zeroValue}
 20137  	s.GetID()
 20138  	s = &StatusEvent{}
 20139  	s.GetID()
 20140  	s = nil
 20141  	s.GetID()
 20142  }
 20143  
 20144  func TestStatusEvent_GetInstallation(tt *testing.T) {
 20145  	s := &StatusEvent{}
 20146  	s.GetInstallation()
 20147  	s = nil
 20148  	s.GetInstallation()
 20149  }
 20150  
 20151  func TestStatusEvent_GetName(tt *testing.T) {
 20152  	var zeroValue string
 20153  	s := &StatusEvent{Name: &zeroValue}
 20154  	s.GetName()
 20155  	s = &StatusEvent{}
 20156  	s.GetName()
 20157  	s = nil
 20158  	s.GetName()
 20159  }
 20160  
 20161  func TestStatusEvent_GetRepo(tt *testing.T) {
 20162  	s := &StatusEvent{}
 20163  	s.GetRepo()
 20164  	s = nil
 20165  	s.GetRepo()
 20166  }
 20167  
 20168  func TestStatusEvent_GetSender(tt *testing.T) {
 20169  	s := &StatusEvent{}
 20170  	s.GetSender()
 20171  	s = nil
 20172  	s.GetSender()
 20173  }
 20174  
 20175  func TestStatusEvent_GetSHA(tt *testing.T) {
 20176  	var zeroValue string
 20177  	s := &StatusEvent{SHA: &zeroValue}
 20178  	s.GetSHA()
 20179  	s = &StatusEvent{}
 20180  	s.GetSHA()
 20181  	s = nil
 20182  	s.GetSHA()
 20183  }
 20184  
 20185  func TestStatusEvent_GetState(tt *testing.T) {
 20186  	var zeroValue string
 20187  	s := &StatusEvent{State: &zeroValue}
 20188  	s.GetState()
 20189  	s = &StatusEvent{}
 20190  	s.GetState()
 20191  	s = nil
 20192  	s.GetState()
 20193  }
 20194  
 20195  func TestStatusEvent_GetTargetURL(tt *testing.T) {
 20196  	var zeroValue string
 20197  	s := &StatusEvent{TargetURL: &zeroValue}
 20198  	s.GetTargetURL()
 20199  	s = &StatusEvent{}
 20200  	s.GetTargetURL()
 20201  	s = nil
 20202  	s.GetTargetURL()
 20203  }
 20204  
 20205  func TestStatusEvent_GetUpdatedAt(tt *testing.T) {
 20206  	var zeroValue Timestamp
 20207  	s := &StatusEvent{UpdatedAt: &zeroValue}
 20208  	s.GetUpdatedAt()
 20209  	s = &StatusEvent{}
 20210  	s.GetUpdatedAt()
 20211  	s = nil
 20212  	s.GetUpdatedAt()
 20213  }
 20214  
 20215  func TestSubscription_GetCreatedAt(tt *testing.T) {
 20216  	var zeroValue Timestamp
 20217  	s := &Subscription{CreatedAt: &zeroValue}
 20218  	s.GetCreatedAt()
 20219  	s = &Subscription{}
 20220  	s.GetCreatedAt()
 20221  	s = nil
 20222  	s.GetCreatedAt()
 20223  }
 20224  
 20225  func TestSubscription_GetIgnored(tt *testing.T) {
 20226  	var zeroValue bool
 20227  	s := &Subscription{Ignored: &zeroValue}
 20228  	s.GetIgnored()
 20229  	s = &Subscription{}
 20230  	s.GetIgnored()
 20231  	s = nil
 20232  	s.GetIgnored()
 20233  }
 20234  
 20235  func TestSubscription_GetReason(tt *testing.T) {
 20236  	var zeroValue string
 20237  	s := &Subscription{Reason: &zeroValue}
 20238  	s.GetReason()
 20239  	s = &Subscription{}
 20240  	s.GetReason()
 20241  	s = nil
 20242  	s.GetReason()
 20243  }
 20244  
 20245  func TestSubscription_GetRepositoryURL(tt *testing.T) {
 20246  	var zeroValue string
 20247  	s := &Subscription{RepositoryURL: &zeroValue}
 20248  	s.GetRepositoryURL()
 20249  	s = &Subscription{}
 20250  	s.GetRepositoryURL()
 20251  	s = nil
 20252  	s.GetRepositoryURL()
 20253  }
 20254  
 20255  func TestSubscription_GetSubscribed(tt *testing.T) {
 20256  	var zeroValue bool
 20257  	s := &Subscription{Subscribed: &zeroValue}
 20258  	s.GetSubscribed()
 20259  	s = &Subscription{}
 20260  	s.GetSubscribed()
 20261  	s = nil
 20262  	s.GetSubscribed()
 20263  }
 20264  
 20265  func TestSubscription_GetThreadURL(tt *testing.T) {
 20266  	var zeroValue string
 20267  	s := &Subscription{ThreadURL: &zeroValue}
 20268  	s.GetThreadURL()
 20269  	s = &Subscription{}
 20270  	s.GetThreadURL()
 20271  	s = nil
 20272  	s.GetThreadURL()
 20273  }
 20274  
 20275  func TestSubscription_GetURL(tt *testing.T) {
 20276  	var zeroValue string
 20277  	s := &Subscription{URL: &zeroValue}
 20278  	s.GetURL()
 20279  	s = &Subscription{}
 20280  	s.GetURL()
 20281  	s = nil
 20282  	s.GetURL()
 20283  }
 20284  
 20285  func TestTag_GetMessage(tt *testing.T) {
 20286  	var zeroValue string
 20287  	t := &Tag{Message: &zeroValue}
 20288  	t.GetMessage()
 20289  	t = &Tag{}
 20290  	t.GetMessage()
 20291  	t = nil
 20292  	t.GetMessage()
 20293  }
 20294  
 20295  func TestTag_GetNodeID(tt *testing.T) {
 20296  	var zeroValue string
 20297  	t := &Tag{NodeID: &zeroValue}
 20298  	t.GetNodeID()
 20299  	t = &Tag{}
 20300  	t.GetNodeID()
 20301  	t = nil
 20302  	t.GetNodeID()
 20303  }
 20304  
 20305  func TestTag_GetObject(tt *testing.T) {
 20306  	t := &Tag{}
 20307  	t.GetObject()
 20308  	t = nil
 20309  	t.GetObject()
 20310  }
 20311  
 20312  func TestTag_GetSHA(tt *testing.T) {
 20313  	var zeroValue string
 20314  	t := &Tag{SHA: &zeroValue}
 20315  	t.GetSHA()
 20316  	t = &Tag{}
 20317  	t.GetSHA()
 20318  	t = nil
 20319  	t.GetSHA()
 20320  }
 20321  
 20322  func TestTag_GetTag(tt *testing.T) {
 20323  	var zeroValue string
 20324  	t := &Tag{Tag: &zeroValue}
 20325  	t.GetTag()
 20326  	t = &Tag{}
 20327  	t.GetTag()
 20328  	t = nil
 20329  	t.GetTag()
 20330  }
 20331  
 20332  func TestTag_GetTagger(tt *testing.T) {
 20333  	t := &Tag{}
 20334  	t.GetTagger()
 20335  	t = nil
 20336  	t.GetTagger()
 20337  }
 20338  
 20339  func TestTag_GetURL(tt *testing.T) {
 20340  	var zeroValue string
 20341  	t := &Tag{URL: &zeroValue}
 20342  	t.GetURL()
 20343  	t = &Tag{}
 20344  	t.GetURL()
 20345  	t = nil
 20346  	t.GetURL()
 20347  }
 20348  
 20349  func TestTag_GetVerification(tt *testing.T) {
 20350  	t := &Tag{}
 20351  	t.GetVerification()
 20352  	t = nil
 20353  	t.GetVerification()
 20354  }
 20355  
 20356  func TestTagProtection_GetID(tt *testing.T) {
 20357  	var zeroValue int64
 20358  	t := &TagProtection{ID: &zeroValue}
 20359  	t.GetID()
 20360  	t = &TagProtection{}
 20361  	t.GetID()
 20362  	t = nil
 20363  	t.GetID()
 20364  }
 20365  
 20366  func TestTagProtection_GetPattern(tt *testing.T) {
 20367  	var zeroValue string
 20368  	t := &TagProtection{Pattern: &zeroValue}
 20369  	t.GetPattern()
 20370  	t = &TagProtection{}
 20371  	t.GetPattern()
 20372  	t = nil
 20373  	t.GetPattern()
 20374  }
 20375  
 20376  func TestTaskStep_GetCompletedAt(tt *testing.T) {
 20377  	var zeroValue Timestamp
 20378  	t := &TaskStep{CompletedAt: &zeroValue}
 20379  	t.GetCompletedAt()
 20380  	t = &TaskStep{}
 20381  	t.GetCompletedAt()
 20382  	t = nil
 20383  	t.GetCompletedAt()
 20384  }
 20385  
 20386  func TestTaskStep_GetConclusion(tt *testing.T) {
 20387  	var zeroValue string
 20388  	t := &TaskStep{Conclusion: &zeroValue}
 20389  	t.GetConclusion()
 20390  	t = &TaskStep{}
 20391  	t.GetConclusion()
 20392  	t = nil
 20393  	t.GetConclusion()
 20394  }
 20395  
 20396  func TestTaskStep_GetName(tt *testing.T) {
 20397  	var zeroValue string
 20398  	t := &TaskStep{Name: &zeroValue}
 20399  	t.GetName()
 20400  	t = &TaskStep{}
 20401  	t.GetName()
 20402  	t = nil
 20403  	t.GetName()
 20404  }
 20405  
 20406  func TestTaskStep_GetNumber(tt *testing.T) {
 20407  	var zeroValue int64
 20408  	t := &TaskStep{Number: &zeroValue}
 20409  	t.GetNumber()
 20410  	t = &TaskStep{}
 20411  	t.GetNumber()
 20412  	t = nil
 20413  	t.GetNumber()
 20414  }
 20415  
 20416  func TestTaskStep_GetStartedAt(tt *testing.T) {
 20417  	var zeroValue Timestamp
 20418  	t := &TaskStep{StartedAt: &zeroValue}
 20419  	t.GetStartedAt()
 20420  	t = &TaskStep{}
 20421  	t.GetStartedAt()
 20422  	t = nil
 20423  	t.GetStartedAt()
 20424  }
 20425  
 20426  func TestTaskStep_GetStatus(tt *testing.T) {
 20427  	var zeroValue string
 20428  	t := &TaskStep{Status: &zeroValue}
 20429  	t.GetStatus()
 20430  	t = &TaskStep{}
 20431  	t.GetStatus()
 20432  	t = nil
 20433  	t.GetStatus()
 20434  }
 20435  
 20436  func TestTeam_GetDescription(tt *testing.T) {
 20437  	var zeroValue string
 20438  	t := &Team{Description: &zeroValue}
 20439  	t.GetDescription()
 20440  	t = &Team{}
 20441  	t.GetDescription()
 20442  	t = nil
 20443  	t.GetDescription()
 20444  }
 20445  
 20446  func TestTeam_GetHTMLURL(tt *testing.T) {
 20447  	var zeroValue string
 20448  	t := &Team{HTMLURL: &zeroValue}
 20449  	t.GetHTMLURL()
 20450  	t = &Team{}
 20451  	t.GetHTMLURL()
 20452  	t = nil
 20453  	t.GetHTMLURL()
 20454  }
 20455  
 20456  func TestTeam_GetID(tt *testing.T) {
 20457  	var zeroValue int64
 20458  	t := &Team{ID: &zeroValue}
 20459  	t.GetID()
 20460  	t = &Team{}
 20461  	t.GetID()
 20462  	t = nil
 20463  	t.GetID()
 20464  }
 20465  
 20466  func TestTeam_GetLDAPDN(tt *testing.T) {
 20467  	var zeroValue string
 20468  	t := &Team{LDAPDN: &zeroValue}
 20469  	t.GetLDAPDN()
 20470  	t = &Team{}
 20471  	t.GetLDAPDN()
 20472  	t = nil
 20473  	t.GetLDAPDN()
 20474  }
 20475  
 20476  func TestTeam_GetMembersCount(tt *testing.T) {
 20477  	var zeroValue int
 20478  	t := &Team{MembersCount: &zeroValue}
 20479  	t.GetMembersCount()
 20480  	t = &Team{}
 20481  	t.GetMembersCount()
 20482  	t = nil
 20483  	t.GetMembersCount()
 20484  }
 20485  
 20486  func TestTeam_GetMembersURL(tt *testing.T) {
 20487  	var zeroValue string
 20488  	t := &Team{MembersURL: &zeroValue}
 20489  	t.GetMembersURL()
 20490  	t = &Team{}
 20491  	t.GetMembersURL()
 20492  	t = nil
 20493  	t.GetMembersURL()
 20494  }
 20495  
 20496  func TestTeam_GetName(tt *testing.T) {
 20497  	var zeroValue string
 20498  	t := &Team{Name: &zeroValue}
 20499  	t.GetName()
 20500  	t = &Team{}
 20501  	t.GetName()
 20502  	t = nil
 20503  	t.GetName()
 20504  }
 20505  
 20506  func TestTeam_GetNodeID(tt *testing.T) {
 20507  	var zeroValue string
 20508  	t := &Team{NodeID: &zeroValue}
 20509  	t.GetNodeID()
 20510  	t = &Team{}
 20511  	t.GetNodeID()
 20512  	t = nil
 20513  	t.GetNodeID()
 20514  }
 20515  
 20516  func TestTeam_GetOrganization(tt *testing.T) {
 20517  	t := &Team{}
 20518  	t.GetOrganization()
 20519  	t = nil
 20520  	t.GetOrganization()
 20521  }
 20522  
 20523  func TestTeam_GetParent(tt *testing.T) {
 20524  	t := &Team{}
 20525  	t.GetParent()
 20526  	t = nil
 20527  	t.GetParent()
 20528  }
 20529  
 20530  func TestTeam_GetPermission(tt *testing.T) {
 20531  	var zeroValue string
 20532  	t := &Team{Permission: &zeroValue}
 20533  	t.GetPermission()
 20534  	t = &Team{}
 20535  	t.GetPermission()
 20536  	t = nil
 20537  	t.GetPermission()
 20538  }
 20539  
 20540  func TestTeam_GetPermissions(tt *testing.T) {
 20541  	zeroValue := map[string]bool{}
 20542  	t := &Team{Permissions: zeroValue}
 20543  	t.GetPermissions()
 20544  	t = &Team{}
 20545  	t.GetPermissions()
 20546  	t = nil
 20547  	t.GetPermissions()
 20548  }
 20549  
 20550  func TestTeam_GetPrivacy(tt *testing.T) {
 20551  	var zeroValue string
 20552  	t := &Team{Privacy: &zeroValue}
 20553  	t.GetPrivacy()
 20554  	t = &Team{}
 20555  	t.GetPrivacy()
 20556  	t = nil
 20557  	t.GetPrivacy()
 20558  }
 20559  
 20560  func TestTeam_GetReposCount(tt *testing.T) {
 20561  	var zeroValue int
 20562  	t := &Team{ReposCount: &zeroValue}
 20563  	t.GetReposCount()
 20564  	t = &Team{}
 20565  	t.GetReposCount()
 20566  	t = nil
 20567  	t.GetReposCount()
 20568  }
 20569  
 20570  func TestTeam_GetRepositoriesURL(tt *testing.T) {
 20571  	var zeroValue string
 20572  	t := &Team{RepositoriesURL: &zeroValue}
 20573  	t.GetRepositoriesURL()
 20574  	t = &Team{}
 20575  	t.GetRepositoriesURL()
 20576  	t = nil
 20577  	t.GetRepositoriesURL()
 20578  }
 20579  
 20580  func TestTeam_GetSlug(tt *testing.T) {
 20581  	var zeroValue string
 20582  	t := &Team{Slug: &zeroValue}
 20583  	t.GetSlug()
 20584  	t = &Team{}
 20585  	t.GetSlug()
 20586  	t = nil
 20587  	t.GetSlug()
 20588  }
 20589  
 20590  func TestTeam_GetURL(tt *testing.T) {
 20591  	var zeroValue string
 20592  	t := &Team{URL: &zeroValue}
 20593  	t.GetURL()
 20594  	t = &Team{}
 20595  	t.GetURL()
 20596  	t = nil
 20597  	t.GetURL()
 20598  }
 20599  
 20600  func TestTeamAddEvent_GetInstallation(tt *testing.T) {
 20601  	t := &TeamAddEvent{}
 20602  	t.GetInstallation()
 20603  	t = nil
 20604  	t.GetInstallation()
 20605  }
 20606  
 20607  func TestTeamAddEvent_GetOrg(tt *testing.T) {
 20608  	t := &TeamAddEvent{}
 20609  	t.GetOrg()
 20610  	t = nil
 20611  	t.GetOrg()
 20612  }
 20613  
 20614  func TestTeamAddEvent_GetRepo(tt *testing.T) {
 20615  	t := &TeamAddEvent{}
 20616  	t.GetRepo()
 20617  	t = nil
 20618  	t.GetRepo()
 20619  }
 20620  
 20621  func TestTeamAddEvent_GetSender(tt *testing.T) {
 20622  	t := &TeamAddEvent{}
 20623  	t.GetSender()
 20624  	t = nil
 20625  	t.GetSender()
 20626  }
 20627  
 20628  func TestTeamAddEvent_GetTeam(tt *testing.T) {
 20629  	t := &TeamAddEvent{}
 20630  	t.GetTeam()
 20631  	t = nil
 20632  	t.GetTeam()
 20633  }
 20634  
 20635  func TestTeamChange_GetDescription(tt *testing.T) {
 20636  	t := &TeamChange{}
 20637  	t.GetDescription()
 20638  	t = nil
 20639  	t.GetDescription()
 20640  }
 20641  
 20642  func TestTeamChange_GetName(tt *testing.T) {
 20643  	t := &TeamChange{}
 20644  	t.GetName()
 20645  	t = nil
 20646  	t.GetName()
 20647  }
 20648  
 20649  func TestTeamChange_GetPrivacy(tt *testing.T) {
 20650  	t := &TeamChange{}
 20651  	t.GetPrivacy()
 20652  	t = nil
 20653  	t.GetPrivacy()
 20654  }
 20655  
 20656  func TestTeamChange_GetRepository(tt *testing.T) {
 20657  	t := &TeamChange{}
 20658  	t.GetRepository()
 20659  	t = nil
 20660  	t.GetRepository()
 20661  }
 20662  
 20663  func TestTeamDescription_GetFrom(tt *testing.T) {
 20664  	var zeroValue string
 20665  	t := &TeamDescription{From: &zeroValue}
 20666  	t.GetFrom()
 20667  	t = &TeamDescription{}
 20668  	t.GetFrom()
 20669  	t = nil
 20670  	t.GetFrom()
 20671  }
 20672  
 20673  func TestTeamDiscussion_GetAuthor(tt *testing.T) {
 20674  	t := &TeamDiscussion{}
 20675  	t.GetAuthor()
 20676  	t = nil
 20677  	t.GetAuthor()
 20678  }
 20679  
 20680  func TestTeamDiscussion_GetBody(tt *testing.T) {
 20681  	var zeroValue string
 20682  	t := &TeamDiscussion{Body: &zeroValue}
 20683  	t.GetBody()
 20684  	t = &TeamDiscussion{}
 20685  	t.GetBody()
 20686  	t = nil
 20687  	t.GetBody()
 20688  }
 20689  
 20690  func TestTeamDiscussion_GetBodyHTML(tt *testing.T) {
 20691  	var zeroValue string
 20692  	t := &TeamDiscussion{BodyHTML: &zeroValue}
 20693  	t.GetBodyHTML()
 20694  	t = &TeamDiscussion{}
 20695  	t.GetBodyHTML()
 20696  	t = nil
 20697  	t.GetBodyHTML()
 20698  }
 20699  
 20700  func TestTeamDiscussion_GetBodyVersion(tt *testing.T) {
 20701  	var zeroValue string
 20702  	t := &TeamDiscussion{BodyVersion: &zeroValue}
 20703  	t.GetBodyVersion()
 20704  	t = &TeamDiscussion{}
 20705  	t.GetBodyVersion()
 20706  	t = nil
 20707  	t.GetBodyVersion()
 20708  }
 20709  
 20710  func TestTeamDiscussion_GetCommentsCount(tt *testing.T) {
 20711  	var zeroValue int
 20712  	t := &TeamDiscussion{CommentsCount: &zeroValue}
 20713  	t.GetCommentsCount()
 20714  	t = &TeamDiscussion{}
 20715  	t.GetCommentsCount()
 20716  	t = nil
 20717  	t.GetCommentsCount()
 20718  }
 20719  
 20720  func TestTeamDiscussion_GetCommentsURL(tt *testing.T) {
 20721  	var zeroValue string
 20722  	t := &TeamDiscussion{CommentsURL: &zeroValue}
 20723  	t.GetCommentsURL()
 20724  	t = &TeamDiscussion{}
 20725  	t.GetCommentsURL()
 20726  	t = nil
 20727  	t.GetCommentsURL()
 20728  }
 20729  
 20730  func TestTeamDiscussion_GetCreatedAt(tt *testing.T) {
 20731  	var zeroValue Timestamp
 20732  	t := &TeamDiscussion{CreatedAt: &zeroValue}
 20733  	t.GetCreatedAt()
 20734  	t = &TeamDiscussion{}
 20735  	t.GetCreatedAt()
 20736  	t = nil
 20737  	t.GetCreatedAt()
 20738  }
 20739  
 20740  func TestTeamDiscussion_GetHTMLURL(tt *testing.T) {
 20741  	var zeroValue string
 20742  	t := &TeamDiscussion{HTMLURL: &zeroValue}
 20743  	t.GetHTMLURL()
 20744  	t = &TeamDiscussion{}
 20745  	t.GetHTMLURL()
 20746  	t = nil
 20747  	t.GetHTMLURL()
 20748  }
 20749  
 20750  func TestTeamDiscussion_GetLastEditedAt(tt *testing.T) {
 20751  	var zeroValue Timestamp
 20752  	t := &TeamDiscussion{LastEditedAt: &zeroValue}
 20753  	t.GetLastEditedAt()
 20754  	t = &TeamDiscussion{}
 20755  	t.GetLastEditedAt()
 20756  	t = nil
 20757  	t.GetLastEditedAt()
 20758  }
 20759  
 20760  func TestTeamDiscussion_GetNodeID(tt *testing.T) {
 20761  	var zeroValue string
 20762  	t := &TeamDiscussion{NodeID: &zeroValue}
 20763  	t.GetNodeID()
 20764  	t = &TeamDiscussion{}
 20765  	t.GetNodeID()
 20766  	t = nil
 20767  	t.GetNodeID()
 20768  }
 20769  
 20770  func TestTeamDiscussion_GetNumber(tt *testing.T) {
 20771  	var zeroValue int
 20772  	t := &TeamDiscussion{Number: &zeroValue}
 20773  	t.GetNumber()
 20774  	t = &TeamDiscussion{}
 20775  	t.GetNumber()
 20776  	t = nil
 20777  	t.GetNumber()
 20778  }
 20779  
 20780  func TestTeamDiscussion_GetPinned(tt *testing.T) {
 20781  	var zeroValue bool
 20782  	t := &TeamDiscussion{Pinned: &zeroValue}
 20783  	t.GetPinned()
 20784  	t = &TeamDiscussion{}
 20785  	t.GetPinned()
 20786  	t = nil
 20787  	t.GetPinned()
 20788  }
 20789  
 20790  func TestTeamDiscussion_GetPrivate(tt *testing.T) {
 20791  	var zeroValue bool
 20792  	t := &TeamDiscussion{Private: &zeroValue}
 20793  	t.GetPrivate()
 20794  	t = &TeamDiscussion{}
 20795  	t.GetPrivate()
 20796  	t = nil
 20797  	t.GetPrivate()
 20798  }
 20799  
 20800  func TestTeamDiscussion_GetReactions(tt *testing.T) {
 20801  	t := &TeamDiscussion{}
 20802  	t.GetReactions()
 20803  	t = nil
 20804  	t.GetReactions()
 20805  }
 20806  
 20807  func TestTeamDiscussion_GetTeamURL(tt *testing.T) {
 20808  	var zeroValue string
 20809  	t := &TeamDiscussion{TeamURL: &zeroValue}
 20810  	t.GetTeamURL()
 20811  	t = &TeamDiscussion{}
 20812  	t.GetTeamURL()
 20813  	t = nil
 20814  	t.GetTeamURL()
 20815  }
 20816  
 20817  func TestTeamDiscussion_GetTitle(tt *testing.T) {
 20818  	var zeroValue string
 20819  	t := &TeamDiscussion{Title: &zeroValue}
 20820  	t.GetTitle()
 20821  	t = &TeamDiscussion{}
 20822  	t.GetTitle()
 20823  	t = nil
 20824  	t.GetTitle()
 20825  }
 20826  
 20827  func TestTeamDiscussion_GetUpdatedAt(tt *testing.T) {
 20828  	var zeroValue Timestamp
 20829  	t := &TeamDiscussion{UpdatedAt: &zeroValue}
 20830  	t.GetUpdatedAt()
 20831  	t = &TeamDiscussion{}
 20832  	t.GetUpdatedAt()
 20833  	t = nil
 20834  	t.GetUpdatedAt()
 20835  }
 20836  
 20837  func TestTeamDiscussion_GetURL(tt *testing.T) {
 20838  	var zeroValue string
 20839  	t := &TeamDiscussion{URL: &zeroValue}
 20840  	t.GetURL()
 20841  	t = &TeamDiscussion{}
 20842  	t.GetURL()
 20843  	t = nil
 20844  	t.GetURL()
 20845  }
 20846  
 20847  func TestTeamEvent_GetAction(tt *testing.T) {
 20848  	var zeroValue string
 20849  	t := &TeamEvent{Action: &zeroValue}
 20850  	t.GetAction()
 20851  	t = &TeamEvent{}
 20852  	t.GetAction()
 20853  	t = nil
 20854  	t.GetAction()
 20855  }
 20856  
 20857  func TestTeamEvent_GetChanges(tt *testing.T) {
 20858  	t := &TeamEvent{}
 20859  	t.GetChanges()
 20860  	t = nil
 20861  	t.GetChanges()
 20862  }
 20863  
 20864  func TestTeamEvent_GetInstallation(tt *testing.T) {
 20865  	t := &TeamEvent{}
 20866  	t.GetInstallation()
 20867  	t = nil
 20868  	t.GetInstallation()
 20869  }
 20870  
 20871  func TestTeamEvent_GetOrg(tt *testing.T) {
 20872  	t := &TeamEvent{}
 20873  	t.GetOrg()
 20874  	t = nil
 20875  	t.GetOrg()
 20876  }
 20877  
 20878  func TestTeamEvent_GetRepo(tt *testing.T) {
 20879  	t := &TeamEvent{}
 20880  	t.GetRepo()
 20881  	t = nil
 20882  	t.GetRepo()
 20883  }
 20884  
 20885  func TestTeamEvent_GetSender(tt *testing.T) {
 20886  	t := &TeamEvent{}
 20887  	t.GetSender()
 20888  	t = nil
 20889  	t.GetSender()
 20890  }
 20891  
 20892  func TestTeamEvent_GetTeam(tt *testing.T) {
 20893  	t := &TeamEvent{}
 20894  	t.GetTeam()
 20895  	t = nil
 20896  	t.GetTeam()
 20897  }
 20898  
 20899  func TestTeamLDAPMapping_GetDescription(tt *testing.T) {
 20900  	var zeroValue string
 20901  	t := &TeamLDAPMapping{Description: &zeroValue}
 20902  	t.GetDescription()
 20903  	t = &TeamLDAPMapping{}
 20904  	t.GetDescription()
 20905  	t = nil
 20906  	t.GetDescription()
 20907  }
 20908  
 20909  func TestTeamLDAPMapping_GetID(tt *testing.T) {
 20910  	var zeroValue int64
 20911  	t := &TeamLDAPMapping{ID: &zeroValue}
 20912  	t.GetID()
 20913  	t = &TeamLDAPMapping{}
 20914  	t.GetID()
 20915  	t = nil
 20916  	t.GetID()
 20917  }
 20918  
 20919  func TestTeamLDAPMapping_GetLDAPDN(tt *testing.T) {
 20920  	var zeroValue string
 20921  	t := &TeamLDAPMapping{LDAPDN: &zeroValue}
 20922  	t.GetLDAPDN()
 20923  	t = &TeamLDAPMapping{}
 20924  	t.GetLDAPDN()
 20925  	t = nil
 20926  	t.GetLDAPDN()
 20927  }
 20928  
 20929  func TestTeamLDAPMapping_GetMembersURL(tt *testing.T) {
 20930  	var zeroValue string
 20931  	t := &TeamLDAPMapping{MembersURL: &zeroValue}
 20932  	t.GetMembersURL()
 20933  	t = &TeamLDAPMapping{}
 20934  	t.GetMembersURL()
 20935  	t = nil
 20936  	t.GetMembersURL()
 20937  }
 20938  
 20939  func TestTeamLDAPMapping_GetName(tt *testing.T) {
 20940  	var zeroValue string
 20941  	t := &TeamLDAPMapping{Name: &zeroValue}
 20942  	t.GetName()
 20943  	t = &TeamLDAPMapping{}
 20944  	t.GetName()
 20945  	t = nil
 20946  	t.GetName()
 20947  }
 20948  
 20949  func TestTeamLDAPMapping_GetPermission(tt *testing.T) {
 20950  	var zeroValue string
 20951  	t := &TeamLDAPMapping{Permission: &zeroValue}
 20952  	t.GetPermission()
 20953  	t = &TeamLDAPMapping{}
 20954  	t.GetPermission()
 20955  	t = nil
 20956  	t.GetPermission()
 20957  }
 20958  
 20959  func TestTeamLDAPMapping_GetPrivacy(tt *testing.T) {
 20960  	var zeroValue string
 20961  	t := &TeamLDAPMapping{Privacy: &zeroValue}
 20962  	t.GetPrivacy()
 20963  	t = &TeamLDAPMapping{}
 20964  	t.GetPrivacy()
 20965  	t = nil
 20966  	t.GetPrivacy()
 20967  }
 20968  
 20969  func TestTeamLDAPMapping_GetRepositoriesURL(tt *testing.T) {
 20970  	var zeroValue string
 20971  	t := &TeamLDAPMapping{RepositoriesURL: &zeroValue}
 20972  	t.GetRepositoriesURL()
 20973  	t = &TeamLDAPMapping{}
 20974  	t.GetRepositoriesURL()
 20975  	t = nil
 20976  	t.GetRepositoriesURL()
 20977  }
 20978  
 20979  func TestTeamLDAPMapping_GetSlug(tt *testing.T) {
 20980  	var zeroValue string
 20981  	t := &TeamLDAPMapping{Slug: &zeroValue}
 20982  	t.GetSlug()
 20983  	t = &TeamLDAPMapping{}
 20984  	t.GetSlug()
 20985  	t = nil
 20986  	t.GetSlug()
 20987  }
 20988  
 20989  func TestTeamLDAPMapping_GetURL(tt *testing.T) {
 20990  	var zeroValue string
 20991  	t := &TeamLDAPMapping{URL: &zeroValue}
 20992  	t.GetURL()
 20993  	t = &TeamLDAPMapping{}
 20994  	t.GetURL()
 20995  	t = nil
 20996  	t.GetURL()
 20997  }
 20998  
 20999  func TestTeamName_GetFrom(tt *testing.T) {
 21000  	var zeroValue string
 21001  	t := &TeamName{From: &zeroValue}
 21002  	t.GetFrom()
 21003  	t = &TeamName{}
 21004  	t.GetFrom()
 21005  	t = nil
 21006  	t.GetFrom()
 21007  }
 21008  
 21009  func TestTeamPermissions_GetFrom(tt *testing.T) {
 21010  	t := &TeamPermissions{}
 21011  	t.GetFrom()
 21012  	t = nil
 21013  	t.GetFrom()
 21014  }
 21015  
 21016  func TestTeamPermissionsFrom_GetAdmin(tt *testing.T) {
 21017  	var zeroValue bool
 21018  	t := &TeamPermissionsFrom{Admin: &zeroValue}
 21019  	t.GetAdmin()
 21020  	t = &TeamPermissionsFrom{}
 21021  	t.GetAdmin()
 21022  	t = nil
 21023  	t.GetAdmin()
 21024  }
 21025  
 21026  func TestTeamPermissionsFrom_GetPull(tt *testing.T) {
 21027  	var zeroValue bool
 21028  	t := &TeamPermissionsFrom{Pull: &zeroValue}
 21029  	t.GetPull()
 21030  	t = &TeamPermissionsFrom{}
 21031  	t.GetPull()
 21032  	t = nil
 21033  	t.GetPull()
 21034  }
 21035  
 21036  func TestTeamPermissionsFrom_GetPush(tt *testing.T) {
 21037  	var zeroValue bool
 21038  	t := &TeamPermissionsFrom{Push: &zeroValue}
 21039  	t.GetPush()
 21040  	t = &TeamPermissionsFrom{}
 21041  	t.GetPush()
 21042  	t = nil
 21043  	t.GetPush()
 21044  }
 21045  
 21046  func TestTeamPrivacy_GetFrom(tt *testing.T) {
 21047  	var zeroValue string
 21048  	t := &TeamPrivacy{From: &zeroValue}
 21049  	t.GetFrom()
 21050  	t = &TeamPrivacy{}
 21051  	t.GetFrom()
 21052  	t = nil
 21053  	t.GetFrom()
 21054  }
 21055  
 21056  func TestTeamProjectOptions_GetPermission(tt *testing.T) {
 21057  	var zeroValue string
 21058  	t := &TeamProjectOptions{Permission: &zeroValue}
 21059  	t.GetPermission()
 21060  	t = &TeamProjectOptions{}
 21061  	t.GetPermission()
 21062  	t = nil
 21063  	t.GetPermission()
 21064  }
 21065  
 21066  func TestTeamRepository_GetPermissions(tt *testing.T) {
 21067  	t := &TeamRepository{}
 21068  	t.GetPermissions()
 21069  	t = nil
 21070  	t.GetPermissions()
 21071  }
 21072  
 21073  func TestTemplateRepoRequest_GetDescription(tt *testing.T) {
 21074  	var zeroValue string
 21075  	t := &TemplateRepoRequest{Description: &zeroValue}
 21076  	t.GetDescription()
 21077  	t = &TemplateRepoRequest{}
 21078  	t.GetDescription()
 21079  	t = nil
 21080  	t.GetDescription()
 21081  }
 21082  
 21083  func TestTemplateRepoRequest_GetIncludeAllBranches(tt *testing.T) {
 21084  	var zeroValue bool
 21085  	t := &TemplateRepoRequest{IncludeAllBranches: &zeroValue}
 21086  	t.GetIncludeAllBranches()
 21087  	t = &TemplateRepoRequest{}
 21088  	t.GetIncludeAllBranches()
 21089  	t = nil
 21090  	t.GetIncludeAllBranches()
 21091  }
 21092  
 21093  func TestTemplateRepoRequest_GetName(tt *testing.T) {
 21094  	var zeroValue string
 21095  	t := &TemplateRepoRequest{Name: &zeroValue}
 21096  	t.GetName()
 21097  	t = &TemplateRepoRequest{}
 21098  	t.GetName()
 21099  	t = nil
 21100  	t.GetName()
 21101  }
 21102  
 21103  func TestTemplateRepoRequest_GetOwner(tt *testing.T) {
 21104  	var zeroValue string
 21105  	t := &TemplateRepoRequest{Owner: &zeroValue}
 21106  	t.GetOwner()
 21107  	t = &TemplateRepoRequest{}
 21108  	t.GetOwner()
 21109  	t = nil
 21110  	t.GetOwner()
 21111  }
 21112  
 21113  func TestTemplateRepoRequest_GetPrivate(tt *testing.T) {
 21114  	var zeroValue bool
 21115  	t := &TemplateRepoRequest{Private: &zeroValue}
 21116  	t.GetPrivate()
 21117  	t = &TemplateRepoRequest{}
 21118  	t.GetPrivate()
 21119  	t = nil
 21120  	t.GetPrivate()
 21121  }
 21122  
 21123  func TestTextMatch_GetFragment(tt *testing.T) {
 21124  	var zeroValue string
 21125  	t := &TextMatch{Fragment: &zeroValue}
 21126  	t.GetFragment()
 21127  	t = &TextMatch{}
 21128  	t.GetFragment()
 21129  	t = nil
 21130  	t.GetFragment()
 21131  }
 21132  
 21133  func TestTextMatch_GetObjectType(tt *testing.T) {
 21134  	var zeroValue string
 21135  	t := &TextMatch{ObjectType: &zeroValue}
 21136  	t.GetObjectType()
 21137  	t = &TextMatch{}
 21138  	t.GetObjectType()
 21139  	t = nil
 21140  	t.GetObjectType()
 21141  }
 21142  
 21143  func TestTextMatch_GetObjectURL(tt *testing.T) {
 21144  	var zeroValue string
 21145  	t := &TextMatch{ObjectURL: &zeroValue}
 21146  	t.GetObjectURL()
 21147  	t = &TextMatch{}
 21148  	t.GetObjectURL()
 21149  	t = nil
 21150  	t.GetObjectURL()
 21151  }
 21152  
 21153  func TestTextMatch_GetProperty(tt *testing.T) {
 21154  	var zeroValue string
 21155  	t := &TextMatch{Property: &zeroValue}
 21156  	t.GetProperty()
 21157  	t = &TextMatch{}
 21158  	t.GetProperty()
 21159  	t = nil
 21160  	t.GetProperty()
 21161  }
 21162  
 21163  func TestTimeline_GetActor(tt *testing.T) {
 21164  	t := &Timeline{}
 21165  	t.GetActor()
 21166  	t = nil
 21167  	t.GetActor()
 21168  }
 21169  
 21170  func TestTimeline_GetAssignee(tt *testing.T) {
 21171  	t := &Timeline{}
 21172  	t.GetAssignee()
 21173  	t = nil
 21174  	t.GetAssignee()
 21175  }
 21176  
 21177  func TestTimeline_GetAssigner(tt *testing.T) {
 21178  	t := &Timeline{}
 21179  	t.GetAssigner()
 21180  	t = nil
 21181  	t.GetAssigner()
 21182  }
 21183  
 21184  func TestTimeline_GetAuthor(tt *testing.T) {
 21185  	t := &Timeline{}
 21186  	t.GetAuthor()
 21187  	t = nil
 21188  	t.GetAuthor()
 21189  }
 21190  
 21191  func TestTimeline_GetBody(tt *testing.T) {
 21192  	var zeroValue string
 21193  	t := &Timeline{Body: &zeroValue}
 21194  	t.GetBody()
 21195  	t = &Timeline{}
 21196  	t.GetBody()
 21197  	t = nil
 21198  	t.GetBody()
 21199  }
 21200  
 21201  func TestTimeline_GetCommitID(tt *testing.T) {
 21202  	var zeroValue string
 21203  	t := &Timeline{CommitID: &zeroValue}
 21204  	t.GetCommitID()
 21205  	t = &Timeline{}
 21206  	t.GetCommitID()
 21207  	t = nil
 21208  	t.GetCommitID()
 21209  }
 21210  
 21211  func TestTimeline_GetCommitter(tt *testing.T) {
 21212  	t := &Timeline{}
 21213  	t.GetCommitter()
 21214  	t = nil
 21215  	t.GetCommitter()
 21216  }
 21217  
 21218  func TestTimeline_GetCommitURL(tt *testing.T) {
 21219  	var zeroValue string
 21220  	t := &Timeline{CommitURL: &zeroValue}
 21221  	t.GetCommitURL()
 21222  	t = &Timeline{}
 21223  	t.GetCommitURL()
 21224  	t = nil
 21225  	t.GetCommitURL()
 21226  }
 21227  
 21228  func TestTimeline_GetCreatedAt(tt *testing.T) {
 21229  	var zeroValue time.Time
 21230  	t := &Timeline{CreatedAt: &zeroValue}
 21231  	t.GetCreatedAt()
 21232  	t = &Timeline{}
 21233  	t.GetCreatedAt()
 21234  	t = nil
 21235  	t.GetCreatedAt()
 21236  }
 21237  
 21238  func TestTimeline_GetEvent(tt *testing.T) {
 21239  	var zeroValue string
 21240  	t := &Timeline{Event: &zeroValue}
 21241  	t.GetEvent()
 21242  	t = &Timeline{}
 21243  	t.GetEvent()
 21244  	t = nil
 21245  	t.GetEvent()
 21246  }
 21247  
 21248  func TestTimeline_GetID(tt *testing.T) {
 21249  	var zeroValue int64
 21250  	t := &Timeline{ID: &zeroValue}
 21251  	t.GetID()
 21252  	t = &Timeline{}
 21253  	t.GetID()
 21254  	t = nil
 21255  	t.GetID()
 21256  }
 21257  
 21258  func TestTimeline_GetLabel(tt *testing.T) {
 21259  	t := &Timeline{}
 21260  	t.GetLabel()
 21261  	t = nil
 21262  	t.GetLabel()
 21263  }
 21264  
 21265  func TestTimeline_GetMessage(tt *testing.T) {
 21266  	var zeroValue string
 21267  	t := &Timeline{Message: &zeroValue}
 21268  	t.GetMessage()
 21269  	t = &Timeline{}
 21270  	t.GetMessage()
 21271  	t = nil
 21272  	t.GetMessage()
 21273  }
 21274  
 21275  func TestTimeline_GetMilestone(tt *testing.T) {
 21276  	t := &Timeline{}
 21277  	t.GetMilestone()
 21278  	t = nil
 21279  	t.GetMilestone()
 21280  }
 21281  
 21282  func TestTimeline_GetProjectCard(tt *testing.T) {
 21283  	t := &Timeline{}
 21284  	t.GetProjectCard()
 21285  	t = nil
 21286  	t.GetProjectCard()
 21287  }
 21288  
 21289  func TestTimeline_GetRename(tt *testing.T) {
 21290  	t := &Timeline{}
 21291  	t.GetRename()
 21292  	t = nil
 21293  	t.GetRename()
 21294  }
 21295  
 21296  func TestTimeline_GetRequester(tt *testing.T) {
 21297  	t := &Timeline{}
 21298  	t.GetRequester()
 21299  	t = nil
 21300  	t.GetRequester()
 21301  }
 21302  
 21303  func TestTimeline_GetReviewer(tt *testing.T) {
 21304  	t := &Timeline{}
 21305  	t.GetReviewer()
 21306  	t = nil
 21307  	t.GetReviewer()
 21308  }
 21309  
 21310  func TestTimeline_GetSHA(tt *testing.T) {
 21311  	var zeroValue string
 21312  	t := &Timeline{SHA: &zeroValue}
 21313  	t.GetSHA()
 21314  	t = &Timeline{}
 21315  	t.GetSHA()
 21316  	t = nil
 21317  	t.GetSHA()
 21318  }
 21319  
 21320  func TestTimeline_GetSource(tt *testing.T) {
 21321  	t := &Timeline{}
 21322  	t.GetSource()
 21323  	t = nil
 21324  	t.GetSource()
 21325  }
 21326  
 21327  func TestTimeline_GetState(tt *testing.T) {
 21328  	var zeroValue string
 21329  	t := &Timeline{State: &zeroValue}
 21330  	t.GetState()
 21331  	t = &Timeline{}
 21332  	t.GetState()
 21333  	t = nil
 21334  	t.GetState()
 21335  }
 21336  
 21337  func TestTimeline_GetSubmittedAt(tt *testing.T) {
 21338  	var zeroValue time.Time
 21339  	t := &Timeline{SubmittedAt: &zeroValue}
 21340  	t.GetSubmittedAt()
 21341  	t = &Timeline{}
 21342  	t.GetSubmittedAt()
 21343  	t = nil
 21344  	t.GetSubmittedAt()
 21345  }
 21346  
 21347  func TestTimeline_GetURL(tt *testing.T) {
 21348  	var zeroValue string
 21349  	t := &Timeline{URL: &zeroValue}
 21350  	t.GetURL()
 21351  	t = &Timeline{}
 21352  	t.GetURL()
 21353  	t = nil
 21354  	t.GetURL()
 21355  }
 21356  
 21357  func TestTimeline_GetUser(tt *testing.T) {
 21358  	t := &Timeline{}
 21359  	t.GetUser()
 21360  	t = nil
 21361  	t.GetUser()
 21362  }
 21363  
 21364  func TestTool_GetGUID(tt *testing.T) {
 21365  	var zeroValue string
 21366  	t := &Tool{GUID: &zeroValue}
 21367  	t.GetGUID()
 21368  	t = &Tool{}
 21369  	t.GetGUID()
 21370  	t = nil
 21371  	t.GetGUID()
 21372  }
 21373  
 21374  func TestTool_GetName(tt *testing.T) {
 21375  	var zeroValue string
 21376  	t := &Tool{Name: &zeroValue}
 21377  	t.GetName()
 21378  	t = &Tool{}
 21379  	t.GetName()
 21380  	t = nil
 21381  	t.GetName()
 21382  }
 21383  
 21384  func TestTool_GetVersion(tt *testing.T) {
 21385  	var zeroValue string
 21386  	t := &Tool{Version: &zeroValue}
 21387  	t.GetVersion()
 21388  	t = &Tool{}
 21389  	t.GetVersion()
 21390  	t = nil
 21391  	t.GetVersion()
 21392  }
 21393  
 21394  func TestTopicResult_GetCreatedAt(tt *testing.T) {
 21395  	var zeroValue Timestamp
 21396  	t := &TopicResult{CreatedAt: &zeroValue}
 21397  	t.GetCreatedAt()
 21398  	t = &TopicResult{}
 21399  	t.GetCreatedAt()
 21400  	t = nil
 21401  	t.GetCreatedAt()
 21402  }
 21403  
 21404  func TestTopicResult_GetCreatedBy(tt *testing.T) {
 21405  	var zeroValue string
 21406  	t := &TopicResult{CreatedBy: &zeroValue}
 21407  	t.GetCreatedBy()
 21408  	t = &TopicResult{}
 21409  	t.GetCreatedBy()
 21410  	t = nil
 21411  	t.GetCreatedBy()
 21412  }
 21413  
 21414  func TestTopicResult_GetCurated(tt *testing.T) {
 21415  	var zeroValue bool
 21416  	t := &TopicResult{Curated: &zeroValue}
 21417  	t.GetCurated()
 21418  	t = &TopicResult{}
 21419  	t.GetCurated()
 21420  	t = nil
 21421  	t.GetCurated()
 21422  }
 21423  
 21424  func TestTopicResult_GetDescription(tt *testing.T) {
 21425  	var zeroValue string
 21426  	t := &TopicResult{Description: &zeroValue}
 21427  	t.GetDescription()
 21428  	t = &TopicResult{}
 21429  	t.GetDescription()
 21430  	t = nil
 21431  	t.GetDescription()
 21432  }
 21433  
 21434  func TestTopicResult_GetDisplayName(tt *testing.T) {
 21435  	var zeroValue string
 21436  	t := &TopicResult{DisplayName: &zeroValue}
 21437  	t.GetDisplayName()
 21438  	t = &TopicResult{}
 21439  	t.GetDisplayName()
 21440  	t = nil
 21441  	t.GetDisplayName()
 21442  }
 21443  
 21444  func TestTopicResult_GetFeatured(tt *testing.T) {
 21445  	var zeroValue bool
 21446  	t := &TopicResult{Featured: &zeroValue}
 21447  	t.GetFeatured()
 21448  	t = &TopicResult{}
 21449  	t.GetFeatured()
 21450  	t = nil
 21451  	t.GetFeatured()
 21452  }
 21453  
 21454  func TestTopicResult_GetName(tt *testing.T) {
 21455  	var zeroValue string
 21456  	t := &TopicResult{Name: &zeroValue}
 21457  	t.GetName()
 21458  	t = &TopicResult{}
 21459  	t.GetName()
 21460  	t = nil
 21461  	t.GetName()
 21462  }
 21463  
 21464  func TestTopicResult_GetScore(tt *testing.T) {
 21465  	t := &TopicResult{}
 21466  	t.GetScore()
 21467  	t = nil
 21468  	t.GetScore()
 21469  }
 21470  
 21471  func TestTopicResult_GetShortDescription(tt *testing.T) {
 21472  	var zeroValue string
 21473  	t := &TopicResult{ShortDescription: &zeroValue}
 21474  	t.GetShortDescription()
 21475  	t = &TopicResult{}
 21476  	t.GetShortDescription()
 21477  	t = nil
 21478  	t.GetShortDescription()
 21479  }
 21480  
 21481  func TestTopicResult_GetUpdatedAt(tt *testing.T) {
 21482  	var zeroValue string
 21483  	t := &TopicResult{UpdatedAt: &zeroValue}
 21484  	t.GetUpdatedAt()
 21485  	t = &TopicResult{}
 21486  	t.GetUpdatedAt()
 21487  	t = nil
 21488  	t.GetUpdatedAt()
 21489  }
 21490  
 21491  func TestTopicsSearchResult_GetIncompleteResults(tt *testing.T) {
 21492  	var zeroValue bool
 21493  	t := &TopicsSearchResult{IncompleteResults: &zeroValue}
 21494  	t.GetIncompleteResults()
 21495  	t = &TopicsSearchResult{}
 21496  	t.GetIncompleteResults()
 21497  	t = nil
 21498  	t.GetIncompleteResults()
 21499  }
 21500  
 21501  func TestTopicsSearchResult_GetTotal(tt *testing.T) {
 21502  	var zeroValue int
 21503  	t := &TopicsSearchResult{Total: &zeroValue}
 21504  	t.GetTotal()
 21505  	t = &TopicsSearchResult{}
 21506  	t.GetTotal()
 21507  	t = nil
 21508  	t.GetTotal()
 21509  }
 21510  
 21511  func TestTrafficClones_GetCount(tt *testing.T) {
 21512  	var zeroValue int
 21513  	t := &TrafficClones{Count: &zeroValue}
 21514  	t.GetCount()
 21515  	t = &TrafficClones{}
 21516  	t.GetCount()
 21517  	t = nil
 21518  	t.GetCount()
 21519  }
 21520  
 21521  func TestTrafficClones_GetUniques(tt *testing.T) {
 21522  	var zeroValue int
 21523  	t := &TrafficClones{Uniques: &zeroValue}
 21524  	t.GetUniques()
 21525  	t = &TrafficClones{}
 21526  	t.GetUniques()
 21527  	t = nil
 21528  	t.GetUniques()
 21529  }
 21530  
 21531  func TestTrafficData_GetCount(tt *testing.T) {
 21532  	var zeroValue int
 21533  	t := &TrafficData{Count: &zeroValue}
 21534  	t.GetCount()
 21535  	t = &TrafficData{}
 21536  	t.GetCount()
 21537  	t = nil
 21538  	t.GetCount()
 21539  }
 21540  
 21541  func TestTrafficData_GetTimestamp(tt *testing.T) {
 21542  	var zeroValue Timestamp
 21543  	t := &TrafficData{Timestamp: &zeroValue}
 21544  	t.GetTimestamp()
 21545  	t = &TrafficData{}
 21546  	t.GetTimestamp()
 21547  	t = nil
 21548  	t.GetTimestamp()
 21549  }
 21550  
 21551  func TestTrafficData_GetUniques(tt *testing.T) {
 21552  	var zeroValue int
 21553  	t := &TrafficData{Uniques: &zeroValue}
 21554  	t.GetUniques()
 21555  	t = &TrafficData{}
 21556  	t.GetUniques()
 21557  	t = nil
 21558  	t.GetUniques()
 21559  }
 21560  
 21561  func TestTrafficPath_GetCount(tt *testing.T) {
 21562  	var zeroValue int
 21563  	t := &TrafficPath{Count: &zeroValue}
 21564  	t.GetCount()
 21565  	t = &TrafficPath{}
 21566  	t.GetCount()
 21567  	t = nil
 21568  	t.GetCount()
 21569  }
 21570  
 21571  func TestTrafficPath_GetPath(tt *testing.T) {
 21572  	var zeroValue string
 21573  	t := &TrafficPath{Path: &zeroValue}
 21574  	t.GetPath()
 21575  	t = &TrafficPath{}
 21576  	t.GetPath()
 21577  	t = nil
 21578  	t.GetPath()
 21579  }
 21580  
 21581  func TestTrafficPath_GetTitle(tt *testing.T) {
 21582  	var zeroValue string
 21583  	t := &TrafficPath{Title: &zeroValue}
 21584  	t.GetTitle()
 21585  	t = &TrafficPath{}
 21586  	t.GetTitle()
 21587  	t = nil
 21588  	t.GetTitle()
 21589  }
 21590  
 21591  func TestTrafficPath_GetUniques(tt *testing.T) {
 21592  	var zeroValue int
 21593  	t := &TrafficPath{Uniques: &zeroValue}
 21594  	t.GetUniques()
 21595  	t = &TrafficPath{}
 21596  	t.GetUniques()
 21597  	t = nil
 21598  	t.GetUniques()
 21599  }
 21600  
 21601  func TestTrafficReferrer_GetCount(tt *testing.T) {
 21602  	var zeroValue int
 21603  	t := &TrafficReferrer{Count: &zeroValue}
 21604  	t.GetCount()
 21605  	t = &TrafficReferrer{}
 21606  	t.GetCount()
 21607  	t = nil
 21608  	t.GetCount()
 21609  }
 21610  
 21611  func TestTrafficReferrer_GetReferrer(tt *testing.T) {
 21612  	var zeroValue string
 21613  	t := &TrafficReferrer{Referrer: &zeroValue}
 21614  	t.GetReferrer()
 21615  	t = &TrafficReferrer{}
 21616  	t.GetReferrer()
 21617  	t = nil
 21618  	t.GetReferrer()
 21619  }
 21620  
 21621  func TestTrafficReferrer_GetUniques(tt *testing.T) {
 21622  	var zeroValue int
 21623  	t := &TrafficReferrer{Uniques: &zeroValue}
 21624  	t.GetUniques()
 21625  	t = &TrafficReferrer{}
 21626  	t.GetUniques()
 21627  	t = nil
 21628  	t.GetUniques()
 21629  }
 21630  
 21631  func TestTrafficViews_GetCount(tt *testing.T) {
 21632  	var zeroValue int
 21633  	t := &TrafficViews{Count: &zeroValue}
 21634  	t.GetCount()
 21635  	t = &TrafficViews{}
 21636  	t.GetCount()
 21637  	t = nil
 21638  	t.GetCount()
 21639  }
 21640  
 21641  func TestTrafficViews_GetUniques(tt *testing.T) {
 21642  	var zeroValue int
 21643  	t := &TrafficViews{Uniques: &zeroValue}
 21644  	t.GetUniques()
 21645  	t = &TrafficViews{}
 21646  	t.GetUniques()
 21647  	t = nil
 21648  	t.GetUniques()
 21649  }
 21650  
 21651  func TestTree_GetSHA(tt *testing.T) {
 21652  	var zeroValue string
 21653  	t := &Tree{SHA: &zeroValue}
 21654  	t.GetSHA()
 21655  	t = &Tree{}
 21656  	t.GetSHA()
 21657  	t = nil
 21658  	t.GetSHA()
 21659  }
 21660  
 21661  func TestTree_GetTruncated(tt *testing.T) {
 21662  	var zeroValue bool
 21663  	t := &Tree{Truncated: &zeroValue}
 21664  	t.GetTruncated()
 21665  	t = &Tree{}
 21666  	t.GetTruncated()
 21667  	t = nil
 21668  	t.GetTruncated()
 21669  }
 21670  
 21671  func TestTreeEntry_GetContent(tt *testing.T) {
 21672  	var zeroValue string
 21673  	t := &TreeEntry{Content: &zeroValue}
 21674  	t.GetContent()
 21675  	t = &TreeEntry{}
 21676  	t.GetContent()
 21677  	t = nil
 21678  	t.GetContent()
 21679  }
 21680  
 21681  func TestTreeEntry_GetMode(tt *testing.T) {
 21682  	var zeroValue string
 21683  	t := &TreeEntry{Mode: &zeroValue}
 21684  	t.GetMode()
 21685  	t = &TreeEntry{}
 21686  	t.GetMode()
 21687  	t = nil
 21688  	t.GetMode()
 21689  }
 21690  
 21691  func TestTreeEntry_GetPath(tt *testing.T) {
 21692  	var zeroValue string
 21693  	t := &TreeEntry{Path: &zeroValue}
 21694  	t.GetPath()
 21695  	t = &TreeEntry{}
 21696  	t.GetPath()
 21697  	t = nil
 21698  	t.GetPath()
 21699  }
 21700  
 21701  func TestTreeEntry_GetSHA(tt *testing.T) {
 21702  	var zeroValue string
 21703  	t := &TreeEntry{SHA: &zeroValue}
 21704  	t.GetSHA()
 21705  	t = &TreeEntry{}
 21706  	t.GetSHA()
 21707  	t = nil
 21708  	t.GetSHA()
 21709  }
 21710  
 21711  func TestTreeEntry_GetSize(tt *testing.T) {
 21712  	var zeroValue int
 21713  	t := &TreeEntry{Size: &zeroValue}
 21714  	t.GetSize()
 21715  	t = &TreeEntry{}
 21716  	t.GetSize()
 21717  	t = nil
 21718  	t.GetSize()
 21719  }
 21720  
 21721  func TestTreeEntry_GetType(tt *testing.T) {
 21722  	var zeroValue string
 21723  	t := &TreeEntry{Type: &zeroValue}
 21724  	t.GetType()
 21725  	t = &TreeEntry{}
 21726  	t.GetType()
 21727  	t = nil
 21728  	t.GetType()
 21729  }
 21730  
 21731  func TestTreeEntry_GetURL(tt *testing.T) {
 21732  	var zeroValue string
 21733  	t := &TreeEntry{URL: &zeroValue}
 21734  	t.GetURL()
 21735  	t = &TreeEntry{}
 21736  	t.GetURL()
 21737  	t = nil
 21738  	t.GetURL()
 21739  }
 21740  
 21741  func TestUpdateAttributeForSCIMUserOperations_GetPath(tt *testing.T) {
 21742  	var zeroValue string
 21743  	u := &UpdateAttributeForSCIMUserOperations{Path: &zeroValue}
 21744  	u.GetPath()
 21745  	u = &UpdateAttributeForSCIMUserOperations{}
 21746  	u.GetPath()
 21747  	u = nil
 21748  	u.GetPath()
 21749  }
 21750  
 21751  func TestUpdateCheckRunOptions_GetCompletedAt(tt *testing.T) {
 21752  	var zeroValue Timestamp
 21753  	u := &UpdateCheckRunOptions{CompletedAt: &zeroValue}
 21754  	u.GetCompletedAt()
 21755  	u = &UpdateCheckRunOptions{}
 21756  	u.GetCompletedAt()
 21757  	u = nil
 21758  	u.GetCompletedAt()
 21759  }
 21760  
 21761  func TestUpdateCheckRunOptions_GetConclusion(tt *testing.T) {
 21762  	var zeroValue string
 21763  	u := &UpdateCheckRunOptions{Conclusion: &zeroValue}
 21764  	u.GetConclusion()
 21765  	u = &UpdateCheckRunOptions{}
 21766  	u.GetConclusion()
 21767  	u = nil
 21768  	u.GetConclusion()
 21769  }
 21770  
 21771  func TestUpdateCheckRunOptions_GetDetailsURL(tt *testing.T) {
 21772  	var zeroValue string
 21773  	u := &UpdateCheckRunOptions{DetailsURL: &zeroValue}
 21774  	u.GetDetailsURL()
 21775  	u = &UpdateCheckRunOptions{}
 21776  	u.GetDetailsURL()
 21777  	u = nil
 21778  	u.GetDetailsURL()
 21779  }
 21780  
 21781  func TestUpdateCheckRunOptions_GetExternalID(tt *testing.T) {
 21782  	var zeroValue string
 21783  	u := &UpdateCheckRunOptions{ExternalID: &zeroValue}
 21784  	u.GetExternalID()
 21785  	u = &UpdateCheckRunOptions{}
 21786  	u.GetExternalID()
 21787  	u = nil
 21788  	u.GetExternalID()
 21789  }
 21790  
 21791  func TestUpdateCheckRunOptions_GetOutput(tt *testing.T) {
 21792  	u := &UpdateCheckRunOptions{}
 21793  	u.GetOutput()
 21794  	u = nil
 21795  	u.GetOutput()
 21796  }
 21797  
 21798  func TestUpdateCheckRunOptions_GetStatus(tt *testing.T) {
 21799  	var zeroValue string
 21800  	u := &UpdateCheckRunOptions{Status: &zeroValue}
 21801  	u.GetStatus()
 21802  	u = &UpdateCheckRunOptions{}
 21803  	u.GetStatus()
 21804  	u = nil
 21805  	u.GetStatus()
 21806  }
 21807  
 21808  func TestUpdateRunnerGroupRequest_GetAllowsPublicRepositories(tt *testing.T) {
 21809  	var zeroValue bool
 21810  	u := &UpdateRunnerGroupRequest{AllowsPublicRepositories: &zeroValue}
 21811  	u.GetAllowsPublicRepositories()
 21812  	u = &UpdateRunnerGroupRequest{}
 21813  	u.GetAllowsPublicRepositories()
 21814  	u = nil
 21815  	u.GetAllowsPublicRepositories()
 21816  }
 21817  
 21818  func TestUpdateRunnerGroupRequest_GetName(tt *testing.T) {
 21819  	var zeroValue string
 21820  	u := &UpdateRunnerGroupRequest{Name: &zeroValue}
 21821  	u.GetName()
 21822  	u = &UpdateRunnerGroupRequest{}
 21823  	u.GetName()
 21824  	u = nil
 21825  	u.GetName()
 21826  }
 21827  
 21828  func TestUpdateRunnerGroupRequest_GetVisibility(tt *testing.T) {
 21829  	var zeroValue string
 21830  	u := &UpdateRunnerGroupRequest{Visibility: &zeroValue}
 21831  	u.GetVisibility()
 21832  	u = &UpdateRunnerGroupRequest{}
 21833  	u.GetVisibility()
 21834  	u = nil
 21835  	u.GetVisibility()
 21836  }
 21837  
 21838  func TestUser_GetAvatarURL(tt *testing.T) {
 21839  	var zeroValue string
 21840  	u := &User{AvatarURL: &zeroValue}
 21841  	u.GetAvatarURL()
 21842  	u = &User{}
 21843  	u.GetAvatarURL()
 21844  	u = nil
 21845  	u.GetAvatarURL()
 21846  }
 21847  
 21848  func TestUser_GetBio(tt *testing.T) {
 21849  	var zeroValue string
 21850  	u := &User{Bio: &zeroValue}
 21851  	u.GetBio()
 21852  	u = &User{}
 21853  	u.GetBio()
 21854  	u = nil
 21855  	u.GetBio()
 21856  }
 21857  
 21858  func TestUser_GetBlog(tt *testing.T) {
 21859  	var zeroValue string
 21860  	u := &User{Blog: &zeroValue}
 21861  	u.GetBlog()
 21862  	u = &User{}
 21863  	u.GetBlog()
 21864  	u = nil
 21865  	u.GetBlog()
 21866  }
 21867  
 21868  func TestUser_GetCollaborators(tt *testing.T) {
 21869  	var zeroValue int
 21870  	u := &User{Collaborators: &zeroValue}
 21871  	u.GetCollaborators()
 21872  	u = &User{}
 21873  	u.GetCollaborators()
 21874  	u = nil
 21875  	u.GetCollaborators()
 21876  }
 21877  
 21878  func TestUser_GetCompany(tt *testing.T) {
 21879  	var zeroValue string
 21880  	u := &User{Company: &zeroValue}
 21881  	u.GetCompany()
 21882  	u = &User{}
 21883  	u.GetCompany()
 21884  	u = nil
 21885  	u.GetCompany()
 21886  }
 21887  
 21888  func TestUser_GetCreatedAt(tt *testing.T) {
 21889  	var zeroValue Timestamp
 21890  	u := &User{CreatedAt: &zeroValue}
 21891  	u.GetCreatedAt()
 21892  	u = &User{}
 21893  	u.GetCreatedAt()
 21894  	u = nil
 21895  	u.GetCreatedAt()
 21896  }
 21897  
 21898  func TestUser_GetDiskUsage(tt *testing.T) {
 21899  	var zeroValue int
 21900  	u := &User{DiskUsage: &zeroValue}
 21901  	u.GetDiskUsage()
 21902  	u = &User{}
 21903  	u.GetDiskUsage()
 21904  	u = nil
 21905  	u.GetDiskUsage()
 21906  }
 21907  
 21908  func TestUser_GetEmail(tt *testing.T) {
 21909  	var zeroValue string
 21910  	u := &User{Email: &zeroValue}
 21911  	u.GetEmail()
 21912  	u = &User{}
 21913  	u.GetEmail()
 21914  	u = nil
 21915  	u.GetEmail()
 21916  }
 21917  
 21918  func TestUser_GetEventsURL(tt *testing.T) {
 21919  	var zeroValue string
 21920  	u := &User{EventsURL: &zeroValue}
 21921  	u.GetEventsURL()
 21922  	u = &User{}
 21923  	u.GetEventsURL()
 21924  	u = nil
 21925  	u.GetEventsURL()
 21926  }
 21927  
 21928  func TestUser_GetFollowers(tt *testing.T) {
 21929  	var zeroValue int
 21930  	u := &User{Followers: &zeroValue}
 21931  	u.GetFollowers()
 21932  	u = &User{}
 21933  	u.GetFollowers()
 21934  	u = nil
 21935  	u.GetFollowers()
 21936  }
 21937  
 21938  func TestUser_GetFollowersURL(tt *testing.T) {
 21939  	var zeroValue string
 21940  	u := &User{FollowersURL: &zeroValue}
 21941  	u.GetFollowersURL()
 21942  	u = &User{}
 21943  	u.GetFollowersURL()
 21944  	u = nil
 21945  	u.GetFollowersURL()
 21946  }
 21947  
 21948  func TestUser_GetFollowing(tt *testing.T) {
 21949  	var zeroValue int
 21950  	u := &User{Following: &zeroValue}
 21951  	u.GetFollowing()
 21952  	u = &User{}
 21953  	u.GetFollowing()
 21954  	u = nil
 21955  	u.GetFollowing()
 21956  }
 21957  
 21958  func TestUser_GetFollowingURL(tt *testing.T) {
 21959  	var zeroValue string
 21960  	u := &User{FollowingURL: &zeroValue}
 21961  	u.GetFollowingURL()
 21962  	u = &User{}
 21963  	u.GetFollowingURL()
 21964  	u = nil
 21965  	u.GetFollowingURL()
 21966  }
 21967  
 21968  func TestUser_GetGistsURL(tt *testing.T) {
 21969  	var zeroValue string
 21970  	u := &User{GistsURL: &zeroValue}
 21971  	u.GetGistsURL()
 21972  	u = &User{}
 21973  	u.GetGistsURL()
 21974  	u = nil
 21975  	u.GetGistsURL()
 21976  }
 21977  
 21978  func TestUser_GetGravatarID(tt *testing.T) {
 21979  	var zeroValue string
 21980  	u := &User{GravatarID: &zeroValue}
 21981  	u.GetGravatarID()
 21982  	u = &User{}
 21983  	u.GetGravatarID()
 21984  	u = nil
 21985  	u.GetGravatarID()
 21986  }
 21987  
 21988  func TestUser_GetHireable(tt *testing.T) {
 21989  	var zeroValue bool
 21990  	u := &User{Hireable: &zeroValue}
 21991  	u.GetHireable()
 21992  	u = &User{}
 21993  	u.GetHireable()
 21994  	u = nil
 21995  	u.GetHireable()
 21996  }
 21997  
 21998  func TestUser_GetHTMLURL(tt *testing.T) {
 21999  	var zeroValue string
 22000  	u := &User{HTMLURL: &zeroValue}
 22001  	u.GetHTMLURL()
 22002  	u = &User{}
 22003  	u.GetHTMLURL()
 22004  	u = nil
 22005  	u.GetHTMLURL()
 22006  }
 22007  
 22008  func TestUser_GetID(tt *testing.T) {
 22009  	var zeroValue int64
 22010  	u := &User{ID: &zeroValue}
 22011  	u.GetID()
 22012  	u = &User{}
 22013  	u.GetID()
 22014  	u = nil
 22015  	u.GetID()
 22016  }
 22017  
 22018  func TestUser_GetLdapDn(tt *testing.T) {
 22019  	var zeroValue string
 22020  	u := &User{LdapDn: &zeroValue}
 22021  	u.GetLdapDn()
 22022  	u = &User{}
 22023  	u.GetLdapDn()
 22024  	u = nil
 22025  	u.GetLdapDn()
 22026  }
 22027  
 22028  func TestUser_GetLocation(tt *testing.T) {
 22029  	var zeroValue string
 22030  	u := &User{Location: &zeroValue}
 22031  	u.GetLocation()
 22032  	u = &User{}
 22033  	u.GetLocation()
 22034  	u = nil
 22035  	u.GetLocation()
 22036  }
 22037  
 22038  func TestUser_GetLogin(tt *testing.T) {
 22039  	var zeroValue string
 22040  	u := &User{Login: &zeroValue}
 22041  	u.GetLogin()
 22042  	u = &User{}
 22043  	u.GetLogin()
 22044  	u = nil
 22045  	u.GetLogin()
 22046  }
 22047  
 22048  func TestUser_GetName(tt *testing.T) {
 22049  	var zeroValue string
 22050  	u := &User{Name: &zeroValue}
 22051  	u.GetName()
 22052  	u = &User{}
 22053  	u.GetName()
 22054  	u = nil
 22055  	u.GetName()
 22056  }
 22057  
 22058  func TestUser_GetNodeID(tt *testing.T) {
 22059  	var zeroValue string
 22060  	u := &User{NodeID: &zeroValue}
 22061  	u.GetNodeID()
 22062  	u = &User{}
 22063  	u.GetNodeID()
 22064  	u = nil
 22065  	u.GetNodeID()
 22066  }
 22067  
 22068  func TestUser_GetOrganizationsURL(tt *testing.T) {
 22069  	var zeroValue string
 22070  	u := &User{OrganizationsURL: &zeroValue}
 22071  	u.GetOrganizationsURL()
 22072  	u = &User{}
 22073  	u.GetOrganizationsURL()
 22074  	u = nil
 22075  	u.GetOrganizationsURL()
 22076  }
 22077  
 22078  func TestUser_GetOwnedPrivateRepos(tt *testing.T) {
 22079  	var zeroValue int
 22080  	u := &User{OwnedPrivateRepos: &zeroValue}
 22081  	u.GetOwnedPrivateRepos()
 22082  	u = &User{}
 22083  	u.GetOwnedPrivateRepos()
 22084  	u = nil
 22085  	u.GetOwnedPrivateRepos()
 22086  }
 22087  
 22088  func TestUser_GetPermissions(tt *testing.T) {
 22089  	zeroValue := map[string]bool{}
 22090  	u := &User{Permissions: zeroValue}
 22091  	u.GetPermissions()
 22092  	u = &User{}
 22093  	u.GetPermissions()
 22094  	u = nil
 22095  	u.GetPermissions()
 22096  }
 22097  
 22098  func TestUser_GetPlan(tt *testing.T) {
 22099  	u := &User{}
 22100  	u.GetPlan()
 22101  	u = nil
 22102  	u.GetPlan()
 22103  }
 22104  
 22105  func TestUser_GetPrivateGists(tt *testing.T) {
 22106  	var zeroValue int
 22107  	u := &User{PrivateGists: &zeroValue}
 22108  	u.GetPrivateGists()
 22109  	u = &User{}
 22110  	u.GetPrivateGists()
 22111  	u = nil
 22112  	u.GetPrivateGists()
 22113  }
 22114  
 22115  func TestUser_GetPublicGists(tt *testing.T) {
 22116  	var zeroValue int
 22117  	u := &User{PublicGists: &zeroValue}
 22118  	u.GetPublicGists()
 22119  	u = &User{}
 22120  	u.GetPublicGists()
 22121  	u = nil
 22122  	u.GetPublicGists()
 22123  }
 22124  
 22125  func TestUser_GetPublicRepos(tt *testing.T) {
 22126  	var zeroValue int
 22127  	u := &User{PublicRepos: &zeroValue}
 22128  	u.GetPublicRepos()
 22129  	u = &User{}
 22130  	u.GetPublicRepos()
 22131  	u = nil
 22132  	u.GetPublicRepos()
 22133  }
 22134  
 22135  func TestUser_GetReceivedEventsURL(tt *testing.T) {
 22136  	var zeroValue string
 22137  	u := &User{ReceivedEventsURL: &zeroValue}
 22138  	u.GetReceivedEventsURL()
 22139  	u = &User{}
 22140  	u.GetReceivedEventsURL()
 22141  	u = nil
 22142  	u.GetReceivedEventsURL()
 22143  }
 22144  
 22145  func TestUser_GetReposURL(tt *testing.T) {
 22146  	var zeroValue string
 22147  	u := &User{ReposURL: &zeroValue}
 22148  	u.GetReposURL()
 22149  	u = &User{}
 22150  	u.GetReposURL()
 22151  	u = nil
 22152  	u.GetReposURL()
 22153  }
 22154  
 22155  func TestUser_GetRoleName(tt *testing.T) {
 22156  	var zeroValue string
 22157  	u := &User{RoleName: &zeroValue}
 22158  	u.GetRoleName()
 22159  	u = &User{}
 22160  	u.GetRoleName()
 22161  	u = nil
 22162  	u.GetRoleName()
 22163  }
 22164  
 22165  func TestUser_GetSiteAdmin(tt *testing.T) {
 22166  	var zeroValue bool
 22167  	u := &User{SiteAdmin: &zeroValue}
 22168  	u.GetSiteAdmin()
 22169  	u = &User{}
 22170  	u.GetSiteAdmin()
 22171  	u = nil
 22172  	u.GetSiteAdmin()
 22173  }
 22174  
 22175  func TestUser_GetStarredURL(tt *testing.T) {
 22176  	var zeroValue string
 22177  	u := &User{StarredURL: &zeroValue}
 22178  	u.GetStarredURL()
 22179  	u = &User{}
 22180  	u.GetStarredURL()
 22181  	u = nil
 22182  	u.GetStarredURL()
 22183  }
 22184  
 22185  func TestUser_GetSubscriptionsURL(tt *testing.T) {
 22186  	var zeroValue string
 22187  	u := &User{SubscriptionsURL: &zeroValue}
 22188  	u.GetSubscriptionsURL()
 22189  	u = &User{}
 22190  	u.GetSubscriptionsURL()
 22191  	u = nil
 22192  	u.GetSubscriptionsURL()
 22193  }
 22194  
 22195  func TestUser_GetSuspendedAt(tt *testing.T) {
 22196  	var zeroValue Timestamp
 22197  	u := &User{SuspendedAt: &zeroValue}
 22198  	u.GetSuspendedAt()
 22199  	u = &User{}
 22200  	u.GetSuspendedAt()
 22201  	u = nil
 22202  	u.GetSuspendedAt()
 22203  }
 22204  
 22205  func TestUser_GetTotalPrivateRepos(tt *testing.T) {
 22206  	var zeroValue int
 22207  	u := &User{TotalPrivateRepos: &zeroValue}
 22208  	u.GetTotalPrivateRepos()
 22209  	u = &User{}
 22210  	u.GetTotalPrivateRepos()
 22211  	u = nil
 22212  	u.GetTotalPrivateRepos()
 22213  }
 22214  
 22215  func TestUser_GetTwitterUsername(tt *testing.T) {
 22216  	var zeroValue string
 22217  	u := &User{TwitterUsername: &zeroValue}
 22218  	u.GetTwitterUsername()
 22219  	u = &User{}
 22220  	u.GetTwitterUsername()
 22221  	u = nil
 22222  	u.GetTwitterUsername()
 22223  }
 22224  
 22225  func TestUser_GetTwoFactorAuthentication(tt *testing.T) {
 22226  	var zeroValue bool
 22227  	u := &User{TwoFactorAuthentication: &zeroValue}
 22228  	u.GetTwoFactorAuthentication()
 22229  	u = &User{}
 22230  	u.GetTwoFactorAuthentication()
 22231  	u = nil
 22232  	u.GetTwoFactorAuthentication()
 22233  }
 22234  
 22235  func TestUser_GetType(tt *testing.T) {
 22236  	var zeroValue string
 22237  	u := &User{Type: &zeroValue}
 22238  	u.GetType()
 22239  	u = &User{}
 22240  	u.GetType()
 22241  	u = nil
 22242  	u.GetType()
 22243  }
 22244  
 22245  func TestUser_GetUpdatedAt(tt *testing.T) {
 22246  	var zeroValue Timestamp
 22247  	u := &User{UpdatedAt: &zeroValue}
 22248  	u.GetUpdatedAt()
 22249  	u = &User{}
 22250  	u.GetUpdatedAt()
 22251  	u = nil
 22252  	u.GetUpdatedAt()
 22253  }
 22254  
 22255  func TestUser_GetURL(tt *testing.T) {
 22256  	var zeroValue string
 22257  	u := &User{URL: &zeroValue}
 22258  	u.GetURL()
 22259  	u = &User{}
 22260  	u.GetURL()
 22261  	u = nil
 22262  	u.GetURL()
 22263  }
 22264  
 22265  func TestUserAuthorization_GetApp(tt *testing.T) {
 22266  	u := &UserAuthorization{}
 22267  	u.GetApp()
 22268  	u = nil
 22269  	u.GetApp()
 22270  }
 22271  
 22272  func TestUserAuthorization_GetCreatedAt(tt *testing.T) {
 22273  	var zeroValue Timestamp
 22274  	u := &UserAuthorization{CreatedAt: &zeroValue}
 22275  	u.GetCreatedAt()
 22276  	u = &UserAuthorization{}
 22277  	u.GetCreatedAt()
 22278  	u = nil
 22279  	u.GetCreatedAt()
 22280  }
 22281  
 22282  func TestUserAuthorization_GetFingerprint(tt *testing.T) {
 22283  	var zeroValue string
 22284  	u := &UserAuthorization{Fingerprint: &zeroValue}
 22285  	u.GetFingerprint()
 22286  	u = &UserAuthorization{}
 22287  	u.GetFingerprint()
 22288  	u = nil
 22289  	u.GetFingerprint()
 22290  }
 22291  
 22292  func TestUserAuthorization_GetHashedToken(tt *testing.T) {
 22293  	var zeroValue string
 22294  	u := &UserAuthorization{HashedToken: &zeroValue}
 22295  	u.GetHashedToken()
 22296  	u = &UserAuthorization{}
 22297  	u.GetHashedToken()
 22298  	u = nil
 22299  	u.GetHashedToken()
 22300  }
 22301  
 22302  func TestUserAuthorization_GetID(tt *testing.T) {
 22303  	var zeroValue int64
 22304  	u := &UserAuthorization{ID: &zeroValue}
 22305  	u.GetID()
 22306  	u = &UserAuthorization{}
 22307  	u.GetID()
 22308  	u = nil
 22309  	u.GetID()
 22310  }
 22311  
 22312  func TestUserAuthorization_GetNote(tt *testing.T) {
 22313  	var zeroValue string
 22314  	u := &UserAuthorization{Note: &zeroValue}
 22315  	u.GetNote()
 22316  	u = &UserAuthorization{}
 22317  	u.GetNote()
 22318  	u = nil
 22319  	u.GetNote()
 22320  }
 22321  
 22322  func TestUserAuthorization_GetNoteURL(tt *testing.T) {
 22323  	var zeroValue string
 22324  	u := &UserAuthorization{NoteURL: &zeroValue}
 22325  	u.GetNoteURL()
 22326  	u = &UserAuthorization{}
 22327  	u.GetNoteURL()
 22328  	u = nil
 22329  	u.GetNoteURL()
 22330  }
 22331  
 22332  func TestUserAuthorization_GetToken(tt *testing.T) {
 22333  	var zeroValue string
 22334  	u := &UserAuthorization{Token: &zeroValue}
 22335  	u.GetToken()
 22336  	u = &UserAuthorization{}
 22337  	u.GetToken()
 22338  	u = nil
 22339  	u.GetToken()
 22340  }
 22341  
 22342  func TestUserAuthorization_GetTokenLastEight(tt *testing.T) {
 22343  	var zeroValue string
 22344  	u := &UserAuthorization{TokenLastEight: &zeroValue}
 22345  	u.GetTokenLastEight()
 22346  	u = &UserAuthorization{}
 22347  	u.GetTokenLastEight()
 22348  	u = nil
 22349  	u.GetTokenLastEight()
 22350  }
 22351  
 22352  func TestUserAuthorization_GetUpdatedAt(tt *testing.T) {
 22353  	var zeroValue Timestamp
 22354  	u := &UserAuthorization{UpdatedAt: &zeroValue}
 22355  	u.GetUpdatedAt()
 22356  	u = &UserAuthorization{}
 22357  	u.GetUpdatedAt()
 22358  	u = nil
 22359  	u.GetUpdatedAt()
 22360  }
 22361  
 22362  func TestUserAuthorization_GetURL(tt *testing.T) {
 22363  	var zeroValue string
 22364  	u := &UserAuthorization{URL: &zeroValue}
 22365  	u.GetURL()
 22366  	u = &UserAuthorization{}
 22367  	u.GetURL()
 22368  	u = nil
 22369  	u.GetURL()
 22370  }
 22371  
 22372  func TestUserContext_GetMessage(tt *testing.T) {
 22373  	var zeroValue string
 22374  	u := &UserContext{Message: &zeroValue}
 22375  	u.GetMessage()
 22376  	u = &UserContext{}
 22377  	u.GetMessage()
 22378  	u = nil
 22379  	u.GetMessage()
 22380  }
 22381  
 22382  func TestUserContext_GetOcticon(tt *testing.T) {
 22383  	var zeroValue string
 22384  	u := &UserContext{Octicon: &zeroValue}
 22385  	u.GetOcticon()
 22386  	u = &UserContext{}
 22387  	u.GetOcticon()
 22388  	u = nil
 22389  	u.GetOcticon()
 22390  }
 22391  
 22392  func TestUserEmail_GetEmail(tt *testing.T) {
 22393  	var zeroValue string
 22394  	u := &UserEmail{Email: &zeroValue}
 22395  	u.GetEmail()
 22396  	u = &UserEmail{}
 22397  	u.GetEmail()
 22398  	u = nil
 22399  	u.GetEmail()
 22400  }
 22401  
 22402  func TestUserEmail_GetPrimary(tt *testing.T) {
 22403  	var zeroValue bool
 22404  	u := &UserEmail{Primary: &zeroValue}
 22405  	u.GetPrimary()
 22406  	u = &UserEmail{}
 22407  	u.GetPrimary()
 22408  	u = nil
 22409  	u.GetPrimary()
 22410  }
 22411  
 22412  func TestUserEmail_GetVerified(tt *testing.T) {
 22413  	var zeroValue bool
 22414  	u := &UserEmail{Verified: &zeroValue}
 22415  	u.GetVerified()
 22416  	u = &UserEmail{}
 22417  	u.GetVerified()
 22418  	u = nil
 22419  	u.GetVerified()
 22420  }
 22421  
 22422  func TestUserEmail_GetVisibility(tt *testing.T) {
 22423  	var zeroValue string
 22424  	u := &UserEmail{Visibility: &zeroValue}
 22425  	u.GetVisibility()
 22426  	u = &UserEmail{}
 22427  	u.GetVisibility()
 22428  	u = nil
 22429  	u.GetVisibility()
 22430  }
 22431  
 22432  func TestUserEvent_GetAction(tt *testing.T) {
 22433  	var zeroValue string
 22434  	u := &UserEvent{Action: &zeroValue}
 22435  	u.GetAction()
 22436  	u = &UserEvent{}
 22437  	u.GetAction()
 22438  	u = nil
 22439  	u.GetAction()
 22440  }
 22441  
 22442  func TestUserEvent_GetEnterprise(tt *testing.T) {
 22443  	u := &UserEvent{}
 22444  	u.GetEnterprise()
 22445  	u = nil
 22446  	u.GetEnterprise()
 22447  }
 22448  
 22449  func TestUserEvent_GetInstallation(tt *testing.T) {
 22450  	u := &UserEvent{}
 22451  	u.GetInstallation()
 22452  	u = nil
 22453  	u.GetInstallation()
 22454  }
 22455  
 22456  func TestUserEvent_GetSender(tt *testing.T) {
 22457  	u := &UserEvent{}
 22458  	u.GetSender()
 22459  	u = nil
 22460  	u.GetSender()
 22461  }
 22462  
 22463  func TestUserEvent_GetUser(tt *testing.T) {
 22464  	u := &UserEvent{}
 22465  	u.GetUser()
 22466  	u = nil
 22467  	u.GetUser()
 22468  }
 22469  
 22470  func TestUserLDAPMapping_GetAvatarURL(tt *testing.T) {
 22471  	var zeroValue string
 22472  	u := &UserLDAPMapping{AvatarURL: &zeroValue}
 22473  	u.GetAvatarURL()
 22474  	u = &UserLDAPMapping{}
 22475  	u.GetAvatarURL()
 22476  	u = nil
 22477  	u.GetAvatarURL()
 22478  }
 22479  
 22480  func TestUserLDAPMapping_GetEventsURL(tt *testing.T) {
 22481  	var zeroValue string
 22482  	u := &UserLDAPMapping{EventsURL: &zeroValue}
 22483  	u.GetEventsURL()
 22484  	u = &UserLDAPMapping{}
 22485  	u.GetEventsURL()
 22486  	u = nil
 22487  	u.GetEventsURL()
 22488  }
 22489  
 22490  func TestUserLDAPMapping_GetFollowersURL(tt *testing.T) {
 22491  	var zeroValue string
 22492  	u := &UserLDAPMapping{FollowersURL: &zeroValue}
 22493  	u.GetFollowersURL()
 22494  	u = &UserLDAPMapping{}
 22495  	u.GetFollowersURL()
 22496  	u = nil
 22497  	u.GetFollowersURL()
 22498  }
 22499  
 22500  func TestUserLDAPMapping_GetFollowingURL(tt *testing.T) {
 22501  	var zeroValue string
 22502  	u := &UserLDAPMapping{FollowingURL: &zeroValue}
 22503  	u.GetFollowingURL()
 22504  	u = &UserLDAPMapping{}
 22505  	u.GetFollowingURL()
 22506  	u = nil
 22507  	u.GetFollowingURL()
 22508  }
 22509  
 22510  func TestUserLDAPMapping_GetGistsURL(tt *testing.T) {
 22511  	var zeroValue string
 22512  	u := &UserLDAPMapping{GistsURL: &zeroValue}
 22513  	u.GetGistsURL()
 22514  	u = &UserLDAPMapping{}
 22515  	u.GetGistsURL()
 22516  	u = nil
 22517  	u.GetGistsURL()
 22518  }
 22519  
 22520  func TestUserLDAPMapping_GetGravatarID(tt *testing.T) {
 22521  	var zeroValue string
 22522  	u := &UserLDAPMapping{GravatarID: &zeroValue}
 22523  	u.GetGravatarID()
 22524  	u = &UserLDAPMapping{}
 22525  	u.GetGravatarID()
 22526  	u = nil
 22527  	u.GetGravatarID()
 22528  }
 22529  
 22530  func TestUserLDAPMapping_GetID(tt *testing.T) {
 22531  	var zeroValue int64
 22532  	u := &UserLDAPMapping{ID: &zeroValue}
 22533  	u.GetID()
 22534  	u = &UserLDAPMapping{}
 22535  	u.GetID()
 22536  	u = nil
 22537  	u.GetID()
 22538  }
 22539  
 22540  func TestUserLDAPMapping_GetLDAPDN(tt *testing.T) {
 22541  	var zeroValue string
 22542  	u := &UserLDAPMapping{LDAPDN: &zeroValue}
 22543  	u.GetLDAPDN()
 22544  	u = &UserLDAPMapping{}
 22545  	u.GetLDAPDN()
 22546  	u = nil
 22547  	u.GetLDAPDN()
 22548  }
 22549  
 22550  func TestUserLDAPMapping_GetLogin(tt *testing.T) {
 22551  	var zeroValue string
 22552  	u := &UserLDAPMapping{Login: &zeroValue}
 22553  	u.GetLogin()
 22554  	u = &UserLDAPMapping{}
 22555  	u.GetLogin()
 22556  	u = nil
 22557  	u.GetLogin()
 22558  }
 22559  
 22560  func TestUserLDAPMapping_GetOrganizationsURL(tt *testing.T) {
 22561  	var zeroValue string
 22562  	u := &UserLDAPMapping{OrganizationsURL: &zeroValue}
 22563  	u.GetOrganizationsURL()
 22564  	u = &UserLDAPMapping{}
 22565  	u.GetOrganizationsURL()
 22566  	u = nil
 22567  	u.GetOrganizationsURL()
 22568  }
 22569  
 22570  func TestUserLDAPMapping_GetReceivedEventsURL(tt *testing.T) {
 22571  	var zeroValue string
 22572  	u := &UserLDAPMapping{ReceivedEventsURL: &zeroValue}
 22573  	u.GetReceivedEventsURL()
 22574  	u = &UserLDAPMapping{}
 22575  	u.GetReceivedEventsURL()
 22576  	u = nil
 22577  	u.GetReceivedEventsURL()
 22578  }
 22579  
 22580  func TestUserLDAPMapping_GetReposURL(tt *testing.T) {
 22581  	var zeroValue string
 22582  	u := &UserLDAPMapping{ReposURL: &zeroValue}
 22583  	u.GetReposURL()
 22584  	u = &UserLDAPMapping{}
 22585  	u.GetReposURL()
 22586  	u = nil
 22587  	u.GetReposURL()
 22588  }
 22589  
 22590  func TestUserLDAPMapping_GetSiteAdmin(tt *testing.T) {
 22591  	var zeroValue bool
 22592  	u := &UserLDAPMapping{SiteAdmin: &zeroValue}
 22593  	u.GetSiteAdmin()
 22594  	u = &UserLDAPMapping{}
 22595  	u.GetSiteAdmin()
 22596  	u = nil
 22597  	u.GetSiteAdmin()
 22598  }
 22599  
 22600  func TestUserLDAPMapping_GetStarredURL(tt *testing.T) {
 22601  	var zeroValue string
 22602  	u := &UserLDAPMapping{StarredURL: &zeroValue}
 22603  	u.GetStarredURL()
 22604  	u = &UserLDAPMapping{}
 22605  	u.GetStarredURL()
 22606  	u = nil
 22607  	u.GetStarredURL()
 22608  }
 22609  
 22610  func TestUserLDAPMapping_GetSubscriptionsURL(tt *testing.T) {
 22611  	var zeroValue string
 22612  	u := &UserLDAPMapping{SubscriptionsURL: &zeroValue}
 22613  	u.GetSubscriptionsURL()
 22614  	u = &UserLDAPMapping{}
 22615  	u.GetSubscriptionsURL()
 22616  	u = nil
 22617  	u.GetSubscriptionsURL()
 22618  }
 22619  
 22620  func TestUserLDAPMapping_GetType(tt *testing.T) {
 22621  	var zeroValue string
 22622  	u := &UserLDAPMapping{Type: &zeroValue}
 22623  	u.GetType()
 22624  	u = &UserLDAPMapping{}
 22625  	u.GetType()
 22626  	u = nil
 22627  	u.GetType()
 22628  }
 22629  
 22630  func TestUserLDAPMapping_GetURL(tt *testing.T) {
 22631  	var zeroValue string
 22632  	u := &UserLDAPMapping{URL: &zeroValue}
 22633  	u.GetURL()
 22634  	u = &UserLDAPMapping{}
 22635  	u.GetURL()
 22636  	u = nil
 22637  	u.GetURL()
 22638  }
 22639  
 22640  func TestUserMigration_GetCreatedAt(tt *testing.T) {
 22641  	var zeroValue string
 22642  	u := &UserMigration{CreatedAt: &zeroValue}
 22643  	u.GetCreatedAt()
 22644  	u = &UserMigration{}
 22645  	u.GetCreatedAt()
 22646  	u = nil
 22647  	u.GetCreatedAt()
 22648  }
 22649  
 22650  func TestUserMigration_GetExcludeAttachments(tt *testing.T) {
 22651  	var zeroValue bool
 22652  	u := &UserMigration{ExcludeAttachments: &zeroValue}
 22653  	u.GetExcludeAttachments()
 22654  	u = &UserMigration{}
 22655  	u.GetExcludeAttachments()
 22656  	u = nil
 22657  	u.GetExcludeAttachments()
 22658  }
 22659  
 22660  func TestUserMigration_GetGUID(tt *testing.T) {
 22661  	var zeroValue string
 22662  	u := &UserMigration{GUID: &zeroValue}
 22663  	u.GetGUID()
 22664  	u = &UserMigration{}
 22665  	u.GetGUID()
 22666  	u = nil
 22667  	u.GetGUID()
 22668  }
 22669  
 22670  func TestUserMigration_GetID(tt *testing.T) {
 22671  	var zeroValue int64
 22672  	u := &UserMigration{ID: &zeroValue}
 22673  	u.GetID()
 22674  	u = &UserMigration{}
 22675  	u.GetID()
 22676  	u = nil
 22677  	u.GetID()
 22678  }
 22679  
 22680  func TestUserMigration_GetLockRepositories(tt *testing.T) {
 22681  	var zeroValue bool
 22682  	u := &UserMigration{LockRepositories: &zeroValue}
 22683  	u.GetLockRepositories()
 22684  	u = &UserMigration{}
 22685  	u.GetLockRepositories()
 22686  	u = nil
 22687  	u.GetLockRepositories()
 22688  }
 22689  
 22690  func TestUserMigration_GetState(tt *testing.T) {
 22691  	var zeroValue string
 22692  	u := &UserMigration{State: &zeroValue}
 22693  	u.GetState()
 22694  	u = &UserMigration{}
 22695  	u.GetState()
 22696  	u = nil
 22697  	u.GetState()
 22698  }
 22699  
 22700  func TestUserMigration_GetUpdatedAt(tt *testing.T) {
 22701  	var zeroValue string
 22702  	u := &UserMigration{UpdatedAt: &zeroValue}
 22703  	u.GetUpdatedAt()
 22704  	u = &UserMigration{}
 22705  	u.GetUpdatedAt()
 22706  	u = nil
 22707  	u.GetUpdatedAt()
 22708  }
 22709  
 22710  func TestUserMigration_GetURL(tt *testing.T) {
 22711  	var zeroValue string
 22712  	u := &UserMigration{URL: &zeroValue}
 22713  	u.GetURL()
 22714  	u = &UserMigration{}
 22715  	u.GetURL()
 22716  	u = nil
 22717  	u.GetURL()
 22718  }
 22719  
 22720  func TestUsersSearchResult_GetIncompleteResults(tt *testing.T) {
 22721  	var zeroValue bool
 22722  	u := &UsersSearchResult{IncompleteResults: &zeroValue}
 22723  	u.GetIncompleteResults()
 22724  	u = &UsersSearchResult{}
 22725  	u.GetIncompleteResults()
 22726  	u = nil
 22727  	u.GetIncompleteResults()
 22728  }
 22729  
 22730  func TestUsersSearchResult_GetTotal(tt *testing.T) {
 22731  	var zeroValue int
 22732  	u := &UsersSearchResult{Total: &zeroValue}
 22733  	u.GetTotal()
 22734  	u = &UsersSearchResult{}
 22735  	u.GetTotal()
 22736  	u = nil
 22737  	u.GetTotal()
 22738  }
 22739  
 22740  func TestUserStats_GetAdminUsers(tt *testing.T) {
 22741  	var zeroValue int
 22742  	u := &UserStats{AdminUsers: &zeroValue}
 22743  	u.GetAdminUsers()
 22744  	u = &UserStats{}
 22745  	u.GetAdminUsers()
 22746  	u = nil
 22747  	u.GetAdminUsers()
 22748  }
 22749  
 22750  func TestUserStats_GetSuspendedUsers(tt *testing.T) {
 22751  	var zeroValue int
 22752  	u := &UserStats{SuspendedUsers: &zeroValue}
 22753  	u.GetSuspendedUsers()
 22754  	u = &UserStats{}
 22755  	u.GetSuspendedUsers()
 22756  	u = nil
 22757  	u.GetSuspendedUsers()
 22758  }
 22759  
 22760  func TestUserStats_GetTotalUsers(tt *testing.T) {
 22761  	var zeroValue int
 22762  	u := &UserStats{TotalUsers: &zeroValue}
 22763  	u.GetTotalUsers()
 22764  	u = &UserStats{}
 22765  	u.GetTotalUsers()
 22766  	u = nil
 22767  	u.GetTotalUsers()
 22768  }
 22769  
 22770  func TestUserSuspendOptions_GetReason(tt *testing.T) {
 22771  	var zeroValue string
 22772  	u := &UserSuspendOptions{Reason: &zeroValue}
 22773  	u.GetReason()
 22774  	u = &UserSuspendOptions{}
 22775  	u.GetReason()
 22776  	u = nil
 22777  	u.GetReason()
 22778  }
 22779  
 22780  func TestVulnerabilityPackage_GetEcosystem(tt *testing.T) {
 22781  	var zeroValue string
 22782  	v := &VulnerabilityPackage{Ecosystem: &zeroValue}
 22783  	v.GetEcosystem()
 22784  	v = &VulnerabilityPackage{}
 22785  	v.GetEcosystem()
 22786  	v = nil
 22787  	v.GetEcosystem()
 22788  }
 22789  
 22790  func TestVulnerabilityPackage_GetName(tt *testing.T) {
 22791  	var zeroValue string
 22792  	v := &VulnerabilityPackage{Name: &zeroValue}
 22793  	v.GetName()
 22794  	v = &VulnerabilityPackage{}
 22795  	v.GetName()
 22796  	v = nil
 22797  	v.GetName()
 22798  }
 22799  
 22800  func TestWatchEvent_GetAction(tt *testing.T) {
 22801  	var zeroValue string
 22802  	w := &WatchEvent{Action: &zeroValue}
 22803  	w.GetAction()
 22804  	w = &WatchEvent{}
 22805  	w.GetAction()
 22806  	w = nil
 22807  	w.GetAction()
 22808  }
 22809  
 22810  func TestWatchEvent_GetInstallation(tt *testing.T) {
 22811  	w := &WatchEvent{}
 22812  	w.GetInstallation()
 22813  	w = nil
 22814  	w.GetInstallation()
 22815  }
 22816  
 22817  func TestWatchEvent_GetRepo(tt *testing.T) {
 22818  	w := &WatchEvent{}
 22819  	w.GetRepo()
 22820  	w = nil
 22821  	w.GetRepo()
 22822  }
 22823  
 22824  func TestWatchEvent_GetSender(tt *testing.T) {
 22825  	w := &WatchEvent{}
 22826  	w.GetSender()
 22827  	w = nil
 22828  	w.GetSender()
 22829  }
 22830  
 22831  func TestWeeklyCommitActivity_GetTotal(tt *testing.T) {
 22832  	var zeroValue int
 22833  	w := &WeeklyCommitActivity{Total: &zeroValue}
 22834  	w.GetTotal()
 22835  	w = &WeeklyCommitActivity{}
 22836  	w.GetTotal()
 22837  	w = nil
 22838  	w.GetTotal()
 22839  }
 22840  
 22841  func TestWeeklyCommitActivity_GetWeek(tt *testing.T) {
 22842  	var zeroValue Timestamp
 22843  	w := &WeeklyCommitActivity{Week: &zeroValue}
 22844  	w.GetWeek()
 22845  	w = &WeeklyCommitActivity{}
 22846  	w.GetWeek()
 22847  	w = nil
 22848  	w.GetWeek()
 22849  }
 22850  
 22851  func TestWeeklyStats_GetAdditions(tt *testing.T) {
 22852  	var zeroValue int
 22853  	w := &WeeklyStats{Additions: &zeroValue}
 22854  	w.GetAdditions()
 22855  	w = &WeeklyStats{}
 22856  	w.GetAdditions()
 22857  	w = nil
 22858  	w.GetAdditions()
 22859  }
 22860  
 22861  func TestWeeklyStats_GetCommits(tt *testing.T) {
 22862  	var zeroValue int
 22863  	w := &WeeklyStats{Commits: &zeroValue}
 22864  	w.GetCommits()
 22865  	w = &WeeklyStats{}
 22866  	w.GetCommits()
 22867  	w = nil
 22868  	w.GetCommits()
 22869  }
 22870  
 22871  func TestWeeklyStats_GetDeletions(tt *testing.T) {
 22872  	var zeroValue int
 22873  	w := &WeeklyStats{Deletions: &zeroValue}
 22874  	w.GetDeletions()
 22875  	w = &WeeklyStats{}
 22876  	w.GetDeletions()
 22877  	w = nil
 22878  	w.GetDeletions()
 22879  }
 22880  
 22881  func TestWeeklyStats_GetWeek(tt *testing.T) {
 22882  	var zeroValue Timestamp
 22883  	w := &WeeklyStats{Week: &zeroValue}
 22884  	w.GetWeek()
 22885  	w = &WeeklyStats{}
 22886  	w.GetWeek()
 22887  	w = nil
 22888  	w.GetWeek()
 22889  }
 22890  
 22891  func TestWorkflow_GetBadgeURL(tt *testing.T) {
 22892  	var zeroValue string
 22893  	w := &Workflow{BadgeURL: &zeroValue}
 22894  	w.GetBadgeURL()
 22895  	w = &Workflow{}
 22896  	w.GetBadgeURL()
 22897  	w = nil
 22898  	w.GetBadgeURL()
 22899  }
 22900  
 22901  func TestWorkflow_GetCreatedAt(tt *testing.T) {
 22902  	var zeroValue Timestamp
 22903  	w := &Workflow{CreatedAt: &zeroValue}
 22904  	w.GetCreatedAt()
 22905  	w = &Workflow{}
 22906  	w.GetCreatedAt()
 22907  	w = nil
 22908  	w.GetCreatedAt()
 22909  }
 22910  
 22911  func TestWorkflow_GetHTMLURL(tt *testing.T) {
 22912  	var zeroValue string
 22913  	w := &Workflow{HTMLURL: &zeroValue}
 22914  	w.GetHTMLURL()
 22915  	w = &Workflow{}
 22916  	w.GetHTMLURL()
 22917  	w = nil
 22918  	w.GetHTMLURL()
 22919  }
 22920  
 22921  func TestWorkflow_GetID(tt *testing.T) {
 22922  	var zeroValue int64
 22923  	w := &Workflow{ID: &zeroValue}
 22924  	w.GetID()
 22925  	w = &Workflow{}
 22926  	w.GetID()
 22927  	w = nil
 22928  	w.GetID()
 22929  }
 22930  
 22931  func TestWorkflow_GetName(tt *testing.T) {
 22932  	var zeroValue string
 22933  	w := &Workflow{Name: &zeroValue}
 22934  	w.GetName()
 22935  	w = &Workflow{}
 22936  	w.GetName()
 22937  	w = nil
 22938  	w.GetName()
 22939  }
 22940  
 22941  func TestWorkflow_GetNodeID(tt *testing.T) {
 22942  	var zeroValue string
 22943  	w := &Workflow{NodeID: &zeroValue}
 22944  	w.GetNodeID()
 22945  	w = &Workflow{}
 22946  	w.GetNodeID()
 22947  	w = nil
 22948  	w.GetNodeID()
 22949  }
 22950  
 22951  func TestWorkflow_GetPath(tt *testing.T) {
 22952  	var zeroValue string
 22953  	w := &Workflow{Path: &zeroValue}
 22954  	w.GetPath()
 22955  	w = &Workflow{}
 22956  	w.GetPath()
 22957  	w = nil
 22958  	w.GetPath()
 22959  }
 22960  
 22961  func TestWorkflow_GetState(tt *testing.T) {
 22962  	var zeroValue string
 22963  	w := &Workflow{State: &zeroValue}
 22964  	w.GetState()
 22965  	w = &Workflow{}
 22966  	w.GetState()
 22967  	w = nil
 22968  	w.GetState()
 22969  }
 22970  
 22971  func TestWorkflow_GetUpdatedAt(tt *testing.T) {
 22972  	var zeroValue Timestamp
 22973  	w := &Workflow{UpdatedAt: &zeroValue}
 22974  	w.GetUpdatedAt()
 22975  	w = &Workflow{}
 22976  	w.GetUpdatedAt()
 22977  	w = nil
 22978  	w.GetUpdatedAt()
 22979  }
 22980  
 22981  func TestWorkflow_GetURL(tt *testing.T) {
 22982  	var zeroValue string
 22983  	w := &Workflow{URL: &zeroValue}
 22984  	w.GetURL()
 22985  	w = &Workflow{}
 22986  	w.GetURL()
 22987  	w = nil
 22988  	w.GetURL()
 22989  }
 22990  
 22991  func TestWorkflowBill_GetTotalMS(tt *testing.T) {
 22992  	var zeroValue int64
 22993  	w := &WorkflowBill{TotalMS: &zeroValue}
 22994  	w.GetTotalMS()
 22995  	w = &WorkflowBill{}
 22996  	w.GetTotalMS()
 22997  	w = nil
 22998  	w.GetTotalMS()
 22999  }
 23000  
 23001  func TestWorkflowDispatchEvent_GetInstallation(tt *testing.T) {
 23002  	w := &WorkflowDispatchEvent{}
 23003  	w.GetInstallation()
 23004  	w = nil
 23005  	w.GetInstallation()
 23006  }
 23007  
 23008  func TestWorkflowDispatchEvent_GetOrg(tt *testing.T) {
 23009  	w := &WorkflowDispatchEvent{}
 23010  	w.GetOrg()
 23011  	w = nil
 23012  	w.GetOrg()
 23013  }
 23014  
 23015  func TestWorkflowDispatchEvent_GetRef(tt *testing.T) {
 23016  	var zeroValue string
 23017  	w := &WorkflowDispatchEvent{Ref: &zeroValue}
 23018  	w.GetRef()
 23019  	w = &WorkflowDispatchEvent{}
 23020  	w.GetRef()
 23021  	w = nil
 23022  	w.GetRef()
 23023  }
 23024  
 23025  func TestWorkflowDispatchEvent_GetRepo(tt *testing.T) {
 23026  	w := &WorkflowDispatchEvent{}
 23027  	w.GetRepo()
 23028  	w = nil
 23029  	w.GetRepo()
 23030  }
 23031  
 23032  func TestWorkflowDispatchEvent_GetSender(tt *testing.T) {
 23033  	w := &WorkflowDispatchEvent{}
 23034  	w.GetSender()
 23035  	w = nil
 23036  	w.GetSender()
 23037  }
 23038  
 23039  func TestWorkflowDispatchEvent_GetWorkflow(tt *testing.T) {
 23040  	var zeroValue string
 23041  	w := &WorkflowDispatchEvent{Workflow: &zeroValue}
 23042  	w.GetWorkflow()
 23043  	w = &WorkflowDispatchEvent{}
 23044  	w.GetWorkflow()
 23045  	w = nil
 23046  	w.GetWorkflow()
 23047  }
 23048  
 23049  func TestWorkflowEnvironment_GetMacOS(tt *testing.T) {
 23050  	w := &WorkflowEnvironment{}
 23051  	w.GetMacOS()
 23052  	w = nil
 23053  	w.GetMacOS()
 23054  }
 23055  
 23056  func TestWorkflowEnvironment_GetUbuntu(tt *testing.T) {
 23057  	w := &WorkflowEnvironment{}
 23058  	w.GetUbuntu()
 23059  	w = nil
 23060  	w.GetUbuntu()
 23061  }
 23062  
 23063  func TestWorkflowEnvironment_GetWindows(tt *testing.T) {
 23064  	w := &WorkflowEnvironment{}
 23065  	w.GetWindows()
 23066  	w = nil
 23067  	w.GetWindows()
 23068  }
 23069  
 23070  func TestWorkflowJob_GetCheckRunURL(tt *testing.T) {
 23071  	var zeroValue string
 23072  	w := &WorkflowJob{CheckRunURL: &zeroValue}
 23073  	w.GetCheckRunURL()
 23074  	w = &WorkflowJob{}
 23075  	w.GetCheckRunURL()
 23076  	w = nil
 23077  	w.GetCheckRunURL()
 23078  }
 23079  
 23080  func TestWorkflowJob_GetCompletedAt(tt *testing.T) {
 23081  	var zeroValue Timestamp
 23082  	w := &WorkflowJob{CompletedAt: &zeroValue}
 23083  	w.GetCompletedAt()
 23084  	w = &WorkflowJob{}
 23085  	w.GetCompletedAt()
 23086  	w = nil
 23087  	w.GetCompletedAt()
 23088  }
 23089  
 23090  func TestWorkflowJob_GetConclusion(tt *testing.T) {
 23091  	var zeroValue string
 23092  	w := &WorkflowJob{Conclusion: &zeroValue}
 23093  	w.GetConclusion()
 23094  	w = &WorkflowJob{}
 23095  	w.GetConclusion()
 23096  	w = nil
 23097  	w.GetConclusion()
 23098  }
 23099  
 23100  func TestWorkflowJob_GetHeadSHA(tt *testing.T) {
 23101  	var zeroValue string
 23102  	w := &WorkflowJob{HeadSHA: &zeroValue}
 23103  	w.GetHeadSHA()
 23104  	w = &WorkflowJob{}
 23105  	w.GetHeadSHA()
 23106  	w = nil
 23107  	w.GetHeadSHA()
 23108  }
 23109  
 23110  func TestWorkflowJob_GetHTMLURL(tt *testing.T) {
 23111  	var zeroValue string
 23112  	w := &WorkflowJob{HTMLURL: &zeroValue}
 23113  	w.GetHTMLURL()
 23114  	w = &WorkflowJob{}
 23115  	w.GetHTMLURL()
 23116  	w = nil
 23117  	w.GetHTMLURL()
 23118  }
 23119  
 23120  func TestWorkflowJob_GetID(tt *testing.T) {
 23121  	var zeroValue int64
 23122  	w := &WorkflowJob{ID: &zeroValue}
 23123  	w.GetID()
 23124  	w = &WorkflowJob{}
 23125  	w.GetID()
 23126  	w = nil
 23127  	w.GetID()
 23128  }
 23129  
 23130  func TestWorkflowJob_GetName(tt *testing.T) {
 23131  	var zeroValue string
 23132  	w := &WorkflowJob{Name: &zeroValue}
 23133  	w.GetName()
 23134  	w = &WorkflowJob{}
 23135  	w.GetName()
 23136  	w = nil
 23137  	w.GetName()
 23138  }
 23139  
 23140  func TestWorkflowJob_GetNodeID(tt *testing.T) {
 23141  	var zeroValue string
 23142  	w := &WorkflowJob{NodeID: &zeroValue}
 23143  	w.GetNodeID()
 23144  	w = &WorkflowJob{}
 23145  	w.GetNodeID()
 23146  	w = nil
 23147  	w.GetNodeID()
 23148  }
 23149  
 23150  func TestWorkflowJob_GetRunID(tt *testing.T) {
 23151  	var zeroValue int64
 23152  	w := &WorkflowJob{RunID: &zeroValue}
 23153  	w.GetRunID()
 23154  	w = &WorkflowJob{}
 23155  	w.GetRunID()
 23156  	w = nil
 23157  	w.GetRunID()
 23158  }
 23159  
 23160  func TestWorkflowJob_GetRunnerGroupID(tt *testing.T) {
 23161  	var zeroValue int64
 23162  	w := &WorkflowJob{RunnerGroupID: &zeroValue}
 23163  	w.GetRunnerGroupID()
 23164  	w = &WorkflowJob{}
 23165  	w.GetRunnerGroupID()
 23166  	w = nil
 23167  	w.GetRunnerGroupID()
 23168  }
 23169  
 23170  func TestWorkflowJob_GetRunnerGroupName(tt *testing.T) {
 23171  	var zeroValue string
 23172  	w := &WorkflowJob{RunnerGroupName: &zeroValue}
 23173  	w.GetRunnerGroupName()
 23174  	w = &WorkflowJob{}
 23175  	w.GetRunnerGroupName()
 23176  	w = nil
 23177  	w.GetRunnerGroupName()
 23178  }
 23179  
 23180  func TestWorkflowJob_GetRunnerID(tt *testing.T) {
 23181  	var zeroValue int64
 23182  	w := &WorkflowJob{RunnerID: &zeroValue}
 23183  	w.GetRunnerID()
 23184  	w = &WorkflowJob{}
 23185  	w.GetRunnerID()
 23186  	w = nil
 23187  	w.GetRunnerID()
 23188  }
 23189  
 23190  func TestWorkflowJob_GetRunnerName(tt *testing.T) {
 23191  	var zeroValue string
 23192  	w := &WorkflowJob{RunnerName: &zeroValue}
 23193  	w.GetRunnerName()
 23194  	w = &WorkflowJob{}
 23195  	w.GetRunnerName()
 23196  	w = nil
 23197  	w.GetRunnerName()
 23198  }
 23199  
 23200  func TestWorkflowJob_GetRunURL(tt *testing.T) {
 23201  	var zeroValue string
 23202  	w := &WorkflowJob{RunURL: &zeroValue}
 23203  	w.GetRunURL()
 23204  	w = &WorkflowJob{}
 23205  	w.GetRunURL()
 23206  	w = nil
 23207  	w.GetRunURL()
 23208  }
 23209  
 23210  func TestWorkflowJob_GetStartedAt(tt *testing.T) {
 23211  	var zeroValue Timestamp
 23212  	w := &WorkflowJob{StartedAt: &zeroValue}
 23213  	w.GetStartedAt()
 23214  	w = &WorkflowJob{}
 23215  	w.GetStartedAt()
 23216  	w = nil
 23217  	w.GetStartedAt()
 23218  }
 23219  
 23220  func TestWorkflowJob_GetStatus(tt *testing.T) {
 23221  	var zeroValue string
 23222  	w := &WorkflowJob{Status: &zeroValue}
 23223  	w.GetStatus()
 23224  	w = &WorkflowJob{}
 23225  	w.GetStatus()
 23226  	w = nil
 23227  	w.GetStatus()
 23228  }
 23229  
 23230  func TestWorkflowJob_GetURL(tt *testing.T) {
 23231  	var zeroValue string
 23232  	w := &WorkflowJob{URL: &zeroValue}
 23233  	w.GetURL()
 23234  	w = &WorkflowJob{}
 23235  	w.GetURL()
 23236  	w = nil
 23237  	w.GetURL()
 23238  }
 23239  
 23240  func TestWorkflowJobEvent_GetAction(tt *testing.T) {
 23241  	var zeroValue string
 23242  	w := &WorkflowJobEvent{Action: &zeroValue}
 23243  	w.GetAction()
 23244  	w = &WorkflowJobEvent{}
 23245  	w.GetAction()
 23246  	w = nil
 23247  	w.GetAction()
 23248  }
 23249  
 23250  func TestWorkflowJobEvent_GetInstallation(tt *testing.T) {
 23251  	w := &WorkflowJobEvent{}
 23252  	w.GetInstallation()
 23253  	w = nil
 23254  	w.GetInstallation()
 23255  }
 23256  
 23257  func TestWorkflowJobEvent_GetOrg(tt *testing.T) {
 23258  	w := &WorkflowJobEvent{}
 23259  	w.GetOrg()
 23260  	w = nil
 23261  	w.GetOrg()
 23262  }
 23263  
 23264  func TestWorkflowJobEvent_GetRepo(tt *testing.T) {
 23265  	w := &WorkflowJobEvent{}
 23266  	w.GetRepo()
 23267  	w = nil
 23268  	w.GetRepo()
 23269  }
 23270  
 23271  func TestWorkflowJobEvent_GetSender(tt *testing.T) {
 23272  	w := &WorkflowJobEvent{}
 23273  	w.GetSender()
 23274  	w = nil
 23275  	w.GetSender()
 23276  }
 23277  
 23278  func TestWorkflowJobEvent_GetWorkflowJob(tt *testing.T) {
 23279  	w := &WorkflowJobEvent{}
 23280  	w.GetWorkflowJob()
 23281  	w = nil
 23282  	w.GetWorkflowJob()
 23283  }
 23284  
 23285  func TestWorkflowRun_GetActor(tt *testing.T) {
 23286  	w := &WorkflowRun{}
 23287  	w.GetActor()
 23288  	w = nil
 23289  	w.GetActor()
 23290  }
 23291  
 23292  func TestWorkflowRun_GetArtifactsURL(tt *testing.T) {
 23293  	var zeroValue string
 23294  	w := &WorkflowRun{ArtifactsURL: &zeroValue}
 23295  	w.GetArtifactsURL()
 23296  	w = &WorkflowRun{}
 23297  	w.GetArtifactsURL()
 23298  	w = nil
 23299  	w.GetArtifactsURL()
 23300  }
 23301  
 23302  func TestWorkflowRun_GetCancelURL(tt *testing.T) {
 23303  	var zeroValue string
 23304  	w := &WorkflowRun{CancelURL: &zeroValue}
 23305  	w.GetCancelURL()
 23306  	w = &WorkflowRun{}
 23307  	w.GetCancelURL()
 23308  	w = nil
 23309  	w.GetCancelURL()
 23310  }
 23311  
 23312  func TestWorkflowRun_GetCheckSuiteID(tt *testing.T) {
 23313  	var zeroValue int64
 23314  	w := &WorkflowRun{CheckSuiteID: &zeroValue}
 23315  	w.GetCheckSuiteID()
 23316  	w = &WorkflowRun{}
 23317  	w.GetCheckSuiteID()
 23318  	w = nil
 23319  	w.GetCheckSuiteID()
 23320  }
 23321  
 23322  func TestWorkflowRun_GetCheckSuiteNodeID(tt *testing.T) {
 23323  	var zeroValue string
 23324  	w := &WorkflowRun{CheckSuiteNodeID: &zeroValue}
 23325  	w.GetCheckSuiteNodeID()
 23326  	w = &WorkflowRun{}
 23327  	w.GetCheckSuiteNodeID()
 23328  	w = nil
 23329  	w.GetCheckSuiteNodeID()
 23330  }
 23331  
 23332  func TestWorkflowRun_GetCheckSuiteURL(tt *testing.T) {
 23333  	var zeroValue string
 23334  	w := &WorkflowRun{CheckSuiteURL: &zeroValue}
 23335  	w.GetCheckSuiteURL()
 23336  	w = &WorkflowRun{}
 23337  	w.GetCheckSuiteURL()
 23338  	w = nil
 23339  	w.GetCheckSuiteURL()
 23340  }
 23341  
 23342  func TestWorkflowRun_GetConclusion(tt *testing.T) {
 23343  	var zeroValue string
 23344  	w := &WorkflowRun{Conclusion: &zeroValue}
 23345  	w.GetConclusion()
 23346  	w = &WorkflowRun{}
 23347  	w.GetConclusion()
 23348  	w = nil
 23349  	w.GetConclusion()
 23350  }
 23351  
 23352  func TestWorkflowRun_GetCreatedAt(tt *testing.T) {
 23353  	var zeroValue Timestamp
 23354  	w := &WorkflowRun{CreatedAt: &zeroValue}
 23355  	w.GetCreatedAt()
 23356  	w = &WorkflowRun{}
 23357  	w.GetCreatedAt()
 23358  	w = nil
 23359  	w.GetCreatedAt()
 23360  }
 23361  
 23362  func TestWorkflowRun_GetEvent(tt *testing.T) {
 23363  	var zeroValue string
 23364  	w := &WorkflowRun{Event: &zeroValue}
 23365  	w.GetEvent()
 23366  	w = &WorkflowRun{}
 23367  	w.GetEvent()
 23368  	w = nil
 23369  	w.GetEvent()
 23370  }
 23371  
 23372  func TestWorkflowRun_GetHeadBranch(tt *testing.T) {
 23373  	var zeroValue string
 23374  	w := &WorkflowRun{HeadBranch: &zeroValue}
 23375  	w.GetHeadBranch()
 23376  	w = &WorkflowRun{}
 23377  	w.GetHeadBranch()
 23378  	w = nil
 23379  	w.GetHeadBranch()
 23380  }
 23381  
 23382  func TestWorkflowRun_GetHeadCommit(tt *testing.T) {
 23383  	w := &WorkflowRun{}
 23384  	w.GetHeadCommit()
 23385  	w = nil
 23386  	w.GetHeadCommit()
 23387  }
 23388  
 23389  func TestWorkflowRun_GetHeadRepository(tt *testing.T) {
 23390  	w := &WorkflowRun{}
 23391  	w.GetHeadRepository()
 23392  	w = nil
 23393  	w.GetHeadRepository()
 23394  }
 23395  
 23396  func TestWorkflowRun_GetHeadSHA(tt *testing.T) {
 23397  	var zeroValue string
 23398  	w := &WorkflowRun{HeadSHA: &zeroValue}
 23399  	w.GetHeadSHA()
 23400  	w = &WorkflowRun{}
 23401  	w.GetHeadSHA()
 23402  	w = nil
 23403  	w.GetHeadSHA()
 23404  }
 23405  
 23406  func TestWorkflowRun_GetHTMLURL(tt *testing.T) {
 23407  	var zeroValue string
 23408  	w := &WorkflowRun{HTMLURL: &zeroValue}
 23409  	w.GetHTMLURL()
 23410  	w = &WorkflowRun{}
 23411  	w.GetHTMLURL()
 23412  	w = nil
 23413  	w.GetHTMLURL()
 23414  }
 23415  
 23416  func TestWorkflowRun_GetID(tt *testing.T) {
 23417  	var zeroValue int64
 23418  	w := &WorkflowRun{ID: &zeroValue}
 23419  	w.GetID()
 23420  	w = &WorkflowRun{}
 23421  	w.GetID()
 23422  	w = nil
 23423  	w.GetID()
 23424  }
 23425  
 23426  func TestWorkflowRun_GetJobsURL(tt *testing.T) {
 23427  	var zeroValue string
 23428  	w := &WorkflowRun{JobsURL: &zeroValue}
 23429  	w.GetJobsURL()
 23430  	w = &WorkflowRun{}
 23431  	w.GetJobsURL()
 23432  	w = nil
 23433  	w.GetJobsURL()
 23434  }
 23435  
 23436  func TestWorkflowRun_GetLogsURL(tt *testing.T) {
 23437  	var zeroValue string
 23438  	w := &WorkflowRun{LogsURL: &zeroValue}
 23439  	w.GetLogsURL()
 23440  	w = &WorkflowRun{}
 23441  	w.GetLogsURL()
 23442  	w = nil
 23443  	w.GetLogsURL()
 23444  }
 23445  
 23446  func TestWorkflowRun_GetName(tt *testing.T) {
 23447  	var zeroValue string
 23448  	w := &WorkflowRun{Name: &zeroValue}
 23449  	w.GetName()
 23450  	w = &WorkflowRun{}
 23451  	w.GetName()
 23452  	w = nil
 23453  	w.GetName()
 23454  }
 23455  
 23456  func TestWorkflowRun_GetNodeID(tt *testing.T) {
 23457  	var zeroValue string
 23458  	w := &WorkflowRun{NodeID: &zeroValue}
 23459  	w.GetNodeID()
 23460  	w = &WorkflowRun{}
 23461  	w.GetNodeID()
 23462  	w = nil
 23463  	w.GetNodeID()
 23464  }
 23465  
 23466  func TestWorkflowRun_GetPreviousAttemptURL(tt *testing.T) {
 23467  	var zeroValue string
 23468  	w := &WorkflowRun{PreviousAttemptURL: &zeroValue}
 23469  	w.GetPreviousAttemptURL()
 23470  	w = &WorkflowRun{}
 23471  	w.GetPreviousAttemptURL()
 23472  	w = nil
 23473  	w.GetPreviousAttemptURL()
 23474  }
 23475  
 23476  func TestWorkflowRun_GetRepository(tt *testing.T) {
 23477  	w := &WorkflowRun{}
 23478  	w.GetRepository()
 23479  	w = nil
 23480  	w.GetRepository()
 23481  }
 23482  
 23483  func TestWorkflowRun_GetRerunURL(tt *testing.T) {
 23484  	var zeroValue string
 23485  	w := &WorkflowRun{RerunURL: &zeroValue}
 23486  	w.GetRerunURL()
 23487  	w = &WorkflowRun{}
 23488  	w.GetRerunURL()
 23489  	w = nil
 23490  	w.GetRerunURL()
 23491  }
 23492  
 23493  func TestWorkflowRun_GetRunAttempt(tt *testing.T) {
 23494  	var zeroValue int
 23495  	w := &WorkflowRun{RunAttempt: &zeroValue}
 23496  	w.GetRunAttempt()
 23497  	w = &WorkflowRun{}
 23498  	w.GetRunAttempt()
 23499  	w = nil
 23500  	w.GetRunAttempt()
 23501  }
 23502  
 23503  func TestWorkflowRun_GetRunNumber(tt *testing.T) {
 23504  	var zeroValue int
 23505  	w := &WorkflowRun{RunNumber: &zeroValue}
 23506  	w.GetRunNumber()
 23507  	w = &WorkflowRun{}
 23508  	w.GetRunNumber()
 23509  	w = nil
 23510  	w.GetRunNumber()
 23511  }
 23512  
 23513  func TestWorkflowRun_GetRunStartedAt(tt *testing.T) {
 23514  	var zeroValue Timestamp
 23515  	w := &WorkflowRun{RunStartedAt: &zeroValue}
 23516  	w.GetRunStartedAt()
 23517  	w = &WorkflowRun{}
 23518  	w.GetRunStartedAt()
 23519  	w = nil
 23520  	w.GetRunStartedAt()
 23521  }
 23522  
 23523  func TestWorkflowRun_GetStatus(tt *testing.T) {
 23524  	var zeroValue string
 23525  	w := &WorkflowRun{Status: &zeroValue}
 23526  	w.GetStatus()
 23527  	w = &WorkflowRun{}
 23528  	w.GetStatus()
 23529  	w = nil
 23530  	w.GetStatus()
 23531  }
 23532  
 23533  func TestWorkflowRun_GetUpdatedAt(tt *testing.T) {
 23534  	var zeroValue Timestamp
 23535  	w := &WorkflowRun{UpdatedAt: &zeroValue}
 23536  	w.GetUpdatedAt()
 23537  	w = &WorkflowRun{}
 23538  	w.GetUpdatedAt()
 23539  	w = nil
 23540  	w.GetUpdatedAt()
 23541  }
 23542  
 23543  func TestWorkflowRun_GetURL(tt *testing.T) {
 23544  	var zeroValue string
 23545  	w := &WorkflowRun{URL: &zeroValue}
 23546  	w.GetURL()
 23547  	w = &WorkflowRun{}
 23548  	w.GetURL()
 23549  	w = nil
 23550  	w.GetURL()
 23551  }
 23552  
 23553  func TestWorkflowRun_GetWorkflowID(tt *testing.T) {
 23554  	var zeroValue int64
 23555  	w := &WorkflowRun{WorkflowID: &zeroValue}
 23556  	w.GetWorkflowID()
 23557  	w = &WorkflowRun{}
 23558  	w.GetWorkflowID()
 23559  	w = nil
 23560  	w.GetWorkflowID()
 23561  }
 23562  
 23563  func TestWorkflowRun_GetWorkflowURL(tt *testing.T) {
 23564  	var zeroValue string
 23565  	w := &WorkflowRun{WorkflowURL: &zeroValue}
 23566  	w.GetWorkflowURL()
 23567  	w = &WorkflowRun{}
 23568  	w.GetWorkflowURL()
 23569  	w = nil
 23570  	w.GetWorkflowURL()
 23571  }
 23572  
 23573  func TestWorkflowRunAttemptOptions_GetExcludePullRequests(tt *testing.T) {
 23574  	var zeroValue bool
 23575  	w := &WorkflowRunAttemptOptions{ExcludePullRequests: &zeroValue}
 23576  	w.GetExcludePullRequests()
 23577  	w = &WorkflowRunAttemptOptions{}
 23578  	w.GetExcludePullRequests()
 23579  	w = nil
 23580  	w.GetExcludePullRequests()
 23581  }
 23582  
 23583  func TestWorkflowRunBill_GetJobs(tt *testing.T) {
 23584  	var zeroValue int
 23585  	w := &WorkflowRunBill{Jobs: &zeroValue}
 23586  	w.GetJobs()
 23587  	w = &WorkflowRunBill{}
 23588  	w.GetJobs()
 23589  	w = nil
 23590  	w.GetJobs()
 23591  }
 23592  
 23593  func TestWorkflowRunBill_GetTotalMS(tt *testing.T) {
 23594  	var zeroValue int64
 23595  	w := &WorkflowRunBill{TotalMS: &zeroValue}
 23596  	w.GetTotalMS()
 23597  	w = &WorkflowRunBill{}
 23598  	w.GetTotalMS()
 23599  	w = nil
 23600  	w.GetTotalMS()
 23601  }
 23602  
 23603  func TestWorkflowRunEnvironment_GetMacOS(tt *testing.T) {
 23604  	w := &WorkflowRunEnvironment{}
 23605  	w.GetMacOS()
 23606  	w = nil
 23607  	w.GetMacOS()
 23608  }
 23609  
 23610  func TestWorkflowRunEnvironment_GetUbuntu(tt *testing.T) {
 23611  	w := &WorkflowRunEnvironment{}
 23612  	w.GetUbuntu()
 23613  	w = nil
 23614  	w.GetUbuntu()
 23615  }
 23616  
 23617  func TestWorkflowRunEnvironment_GetWindows(tt *testing.T) {
 23618  	w := &WorkflowRunEnvironment{}
 23619  	w.GetWindows()
 23620  	w = nil
 23621  	w.GetWindows()
 23622  }
 23623  
 23624  func TestWorkflowRunEvent_GetAction(tt *testing.T) {
 23625  	var zeroValue string
 23626  	w := &WorkflowRunEvent{Action: &zeroValue}
 23627  	w.GetAction()
 23628  	w = &WorkflowRunEvent{}
 23629  	w.GetAction()
 23630  	w = nil
 23631  	w.GetAction()
 23632  }
 23633  
 23634  func TestWorkflowRunEvent_GetInstallation(tt *testing.T) {
 23635  	w := &WorkflowRunEvent{}
 23636  	w.GetInstallation()
 23637  	w = nil
 23638  	w.GetInstallation()
 23639  }
 23640  
 23641  func TestWorkflowRunEvent_GetOrg(tt *testing.T) {
 23642  	w := &WorkflowRunEvent{}
 23643  	w.GetOrg()
 23644  	w = nil
 23645  	w.GetOrg()
 23646  }
 23647  
 23648  func TestWorkflowRunEvent_GetRepo(tt *testing.T) {
 23649  	w := &WorkflowRunEvent{}
 23650  	w.GetRepo()
 23651  	w = nil
 23652  	w.GetRepo()
 23653  }
 23654  
 23655  func TestWorkflowRunEvent_GetSender(tt *testing.T) {
 23656  	w := &WorkflowRunEvent{}
 23657  	w.GetSender()
 23658  	w = nil
 23659  	w.GetSender()
 23660  }
 23661  
 23662  func TestWorkflowRunEvent_GetWorkflow(tt *testing.T) {
 23663  	w := &WorkflowRunEvent{}
 23664  	w.GetWorkflow()
 23665  	w = nil
 23666  	w.GetWorkflow()
 23667  }
 23668  
 23669  func TestWorkflowRunEvent_GetWorkflowRun(tt *testing.T) {
 23670  	w := &WorkflowRunEvent{}
 23671  	w.GetWorkflowRun()
 23672  	w = nil
 23673  	w.GetWorkflowRun()
 23674  }
 23675  
 23676  func TestWorkflowRunJobRun_GetDurationMS(tt *testing.T) {
 23677  	var zeroValue int64
 23678  	w := &WorkflowRunJobRun{DurationMS: &zeroValue}
 23679  	w.GetDurationMS()
 23680  	w = &WorkflowRunJobRun{}
 23681  	w.GetDurationMS()
 23682  	w = nil
 23683  	w.GetDurationMS()
 23684  }
 23685  
 23686  func TestWorkflowRunJobRun_GetJobID(tt *testing.T) {
 23687  	var zeroValue int
 23688  	w := &WorkflowRunJobRun{JobID: &zeroValue}
 23689  	w.GetJobID()
 23690  	w = &WorkflowRunJobRun{}
 23691  	w.GetJobID()
 23692  	w = nil
 23693  	w.GetJobID()
 23694  }
 23695  
 23696  func TestWorkflowRuns_GetTotalCount(tt *testing.T) {
 23697  	var zeroValue int
 23698  	w := &WorkflowRuns{TotalCount: &zeroValue}
 23699  	w.GetTotalCount()
 23700  	w = &WorkflowRuns{}
 23701  	w.GetTotalCount()
 23702  	w = nil
 23703  	w.GetTotalCount()
 23704  }
 23705  
 23706  func TestWorkflowRunUsage_GetBillable(tt *testing.T) {
 23707  	w := &WorkflowRunUsage{}
 23708  	w.GetBillable()
 23709  	w = nil
 23710  	w.GetBillable()
 23711  }
 23712  
 23713  func TestWorkflowRunUsage_GetRunDurationMS(tt *testing.T) {
 23714  	var zeroValue int64
 23715  	w := &WorkflowRunUsage{RunDurationMS: &zeroValue}
 23716  	w.GetRunDurationMS()
 23717  	w = &WorkflowRunUsage{}
 23718  	w.GetRunDurationMS()
 23719  	w = nil
 23720  	w.GetRunDurationMS()
 23721  }
 23722  
 23723  func TestWorkflows_GetTotalCount(tt *testing.T) {
 23724  	var zeroValue int
 23725  	w := &Workflows{TotalCount: &zeroValue}
 23726  	w.GetTotalCount()
 23727  	w = &Workflows{}
 23728  	w.GetTotalCount()
 23729  	w = nil
 23730  	w.GetTotalCount()
 23731  }
 23732  
 23733  func TestWorkflowUsage_GetBillable(tt *testing.T) {
 23734  	w := &WorkflowUsage{}
 23735  	w.GetBillable()
 23736  	w = nil
 23737  	w.GetBillable()
 23738  }
 23739  

View as plain text