▽

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

Documentation: github.com/google/go-github/v45/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_GetRunnerGroupID(tt *testing.T) {
  1220  	var zeroValue int64
  1221  	a := &AuditEntry{RunnerGroupID: &zeroValue}
  1222  	a.GetRunnerGroupID()
  1223  	a = &AuditEntry{}
  1224  	a.GetRunnerGroupID()
  1225  	a = nil
  1226  	a.GetRunnerGroupID()
  1227  }
  1228  
  1229  func TestAuditEntry_GetRunnerGroupName(tt *testing.T) {
  1230  	var zeroValue string
  1231  	a := &AuditEntry{RunnerGroupName: &zeroValue}
  1232  	a.GetRunnerGroupName()
  1233  	a = &AuditEntry{}
  1234  	a.GetRunnerGroupName()
  1235  	a = nil
  1236  	a.GetRunnerGroupName()
  1237  }
  1238  
  1239  func TestAuditEntry_GetRunnerID(tt *testing.T) {
  1240  	var zeroValue int64
  1241  	a := &AuditEntry{RunnerID: &zeroValue}
  1242  	a.GetRunnerID()
  1243  	a = &AuditEntry{}
  1244  	a.GetRunnerID()
  1245  	a = nil
  1246  	a.GetRunnerID()
  1247  }
  1248  
  1249  func TestAuditEntry_GetRunnerName(tt *testing.T) {
  1250  	var zeroValue string
  1251  	a := &AuditEntry{RunnerName: &zeroValue}
  1252  	a.GetRunnerName()
  1253  	a = &AuditEntry{}
  1254  	a.GetRunnerName()
  1255  	a = nil
  1256  	a.GetRunnerName()
  1257  }
  1258  
  1259  func TestAuditEntry_GetSourceVersion(tt *testing.T) {
  1260  	var zeroValue string
  1261  	a := &AuditEntry{SourceVersion: &zeroValue}
  1262  	a.GetSourceVersion()
  1263  	a = &AuditEntry{}
  1264  	a.GetSourceVersion()
  1265  	a = nil
  1266  	a.GetSourceVersion()
  1267  }
  1268  
  1269  func TestAuditEntry_GetStartedAt(tt *testing.T) {
  1270  	var zeroValue Timestamp
  1271  	a := &AuditEntry{StartedAt: &zeroValue}
  1272  	a.GetStartedAt()
  1273  	a = &AuditEntry{}
  1274  	a.GetStartedAt()
  1275  	a = nil
  1276  	a.GetStartedAt()
  1277  }
  1278  
  1279  func TestAuditEntry_GetTargetLogin(tt *testing.T) {
  1280  	var zeroValue string
  1281  	a := &AuditEntry{TargetLogin: &zeroValue}
  1282  	a.GetTargetLogin()
  1283  	a = &AuditEntry{}
  1284  	a.GetTargetLogin()
  1285  	a = nil
  1286  	a.GetTargetLogin()
  1287  }
  1288  
  1289  func TestAuditEntry_GetTargetVersion(tt *testing.T) {
  1290  	var zeroValue string
  1291  	a := &AuditEntry{TargetVersion: &zeroValue}
  1292  	a.GetTargetVersion()
  1293  	a = &AuditEntry{}
  1294  	a.GetTargetVersion()
  1295  	a = nil
  1296  	a.GetTargetVersion()
  1297  }
  1298  
  1299  func TestAuditEntry_GetTeam(tt *testing.T) {
  1300  	var zeroValue string
  1301  	a := &AuditEntry{Team: &zeroValue}
  1302  	a.GetTeam()
  1303  	a = &AuditEntry{}
  1304  	a.GetTeam()
  1305  	a = nil
  1306  	a.GetTeam()
  1307  }
  1308  
  1309  func TestAuditEntry_GetTimestamp(tt *testing.T) {
  1310  	var zeroValue Timestamp
  1311  	a := &AuditEntry{Timestamp: &zeroValue}
  1312  	a.GetTimestamp()
  1313  	a = &AuditEntry{}
  1314  	a.GetTimestamp()
  1315  	a = nil
  1316  	a.GetTimestamp()
  1317  }
  1318  
  1319  func TestAuditEntry_GetTransportProtocol(tt *testing.T) {
  1320  	var zeroValue int
  1321  	a := &AuditEntry{TransportProtocol: &zeroValue}
  1322  	a.GetTransportProtocol()
  1323  	a = &AuditEntry{}
  1324  	a.GetTransportProtocol()
  1325  	a = nil
  1326  	a.GetTransportProtocol()
  1327  }
  1328  
  1329  func TestAuditEntry_GetTransportProtocolName(tt *testing.T) {
  1330  	var zeroValue string
  1331  	a := &AuditEntry{TransportProtocolName: &zeroValue}
  1332  	a.GetTransportProtocolName()
  1333  	a = &AuditEntry{}
  1334  	a.GetTransportProtocolName()
  1335  	a = nil
  1336  	a.GetTransportProtocolName()
  1337  }
  1338  
  1339  func TestAuditEntry_GetTriggerID(tt *testing.T) {
  1340  	var zeroValue int64
  1341  	a := &AuditEntry{TriggerID: &zeroValue}
  1342  	a.GetTriggerID()
  1343  	a = &AuditEntry{}
  1344  	a.GetTriggerID()
  1345  	a = nil
  1346  	a.GetTriggerID()
  1347  }
  1348  
  1349  func TestAuditEntry_GetUser(tt *testing.T) {
  1350  	var zeroValue string
  1351  	a := &AuditEntry{User: &zeroValue}
  1352  	a.GetUser()
  1353  	a = &AuditEntry{}
  1354  	a.GetUser()
  1355  	a = nil
  1356  	a.GetUser()
  1357  }
  1358  
  1359  func TestAuditEntry_GetVisibility(tt *testing.T) {
  1360  	var zeroValue string
  1361  	a := &AuditEntry{Visibility: &zeroValue}
  1362  	a.GetVisibility()
  1363  	a = &AuditEntry{}
  1364  	a.GetVisibility()
  1365  	a = nil
  1366  	a.GetVisibility()
  1367  }
  1368  
  1369  func TestAuditEntry_GetWorkflowID(tt *testing.T) {
  1370  	var zeroValue int64
  1371  	a := &AuditEntry{WorkflowID: &zeroValue}
  1372  	a.GetWorkflowID()
  1373  	a = &AuditEntry{}
  1374  	a.GetWorkflowID()
  1375  	a = nil
  1376  	a.GetWorkflowID()
  1377  }
  1378  
  1379  func TestAuditEntry_GetWorkflowRunID(tt *testing.T) {
  1380  	var zeroValue int64
  1381  	a := &AuditEntry{WorkflowRunID: &zeroValue}
  1382  	a.GetWorkflowRunID()
  1383  	a = &AuditEntry{}
  1384  	a.GetWorkflowRunID()
  1385  	a = nil
  1386  	a.GetWorkflowRunID()
  1387  }
  1388  
  1389  func TestAuthorization_GetApp(tt *testing.T) {
  1390  	a := &Authorization{}
  1391  	a.GetApp()
  1392  	a = nil
  1393  	a.GetApp()
  1394  }
  1395  
  1396  func TestAuthorization_GetCreatedAt(tt *testing.T) {
  1397  	var zeroValue Timestamp
  1398  	a := &Authorization{CreatedAt: &zeroValue}
  1399  	a.GetCreatedAt()
  1400  	a = &Authorization{}
  1401  	a.GetCreatedAt()
  1402  	a = nil
  1403  	a.GetCreatedAt()
  1404  }
  1405  
  1406  func TestAuthorization_GetFingerprint(tt *testing.T) {
  1407  	var zeroValue string
  1408  	a := &Authorization{Fingerprint: &zeroValue}
  1409  	a.GetFingerprint()
  1410  	a = &Authorization{}
  1411  	a.GetFingerprint()
  1412  	a = nil
  1413  	a.GetFingerprint()
  1414  }
  1415  
  1416  func TestAuthorization_GetHashedToken(tt *testing.T) {
  1417  	var zeroValue string
  1418  	a := &Authorization{HashedToken: &zeroValue}
  1419  	a.GetHashedToken()
  1420  	a = &Authorization{}
  1421  	a.GetHashedToken()
  1422  	a = nil
  1423  	a.GetHashedToken()
  1424  }
  1425  
  1426  func TestAuthorization_GetID(tt *testing.T) {
  1427  	var zeroValue int64
  1428  	a := &Authorization{ID: &zeroValue}
  1429  	a.GetID()
  1430  	a = &Authorization{}
  1431  	a.GetID()
  1432  	a = nil
  1433  	a.GetID()
  1434  }
  1435  
  1436  func TestAuthorization_GetNote(tt *testing.T) {
  1437  	var zeroValue string
  1438  	a := &Authorization{Note: &zeroValue}
  1439  	a.GetNote()
  1440  	a = &Authorization{}
  1441  	a.GetNote()
  1442  	a = nil
  1443  	a.GetNote()
  1444  }
  1445  
  1446  func TestAuthorization_GetNoteURL(tt *testing.T) {
  1447  	var zeroValue string
  1448  	a := &Authorization{NoteURL: &zeroValue}
  1449  	a.GetNoteURL()
  1450  	a = &Authorization{}
  1451  	a.GetNoteURL()
  1452  	a = nil
  1453  	a.GetNoteURL()
  1454  }
  1455  
  1456  func TestAuthorization_GetToken(tt *testing.T) {
  1457  	var zeroValue string
  1458  	a := &Authorization{Token: &zeroValue}
  1459  	a.GetToken()
  1460  	a = &Authorization{}
  1461  	a.GetToken()
  1462  	a = nil
  1463  	a.GetToken()
  1464  }
  1465  
  1466  func TestAuthorization_GetTokenLastEight(tt *testing.T) {
  1467  	var zeroValue string
  1468  	a := &Authorization{TokenLastEight: &zeroValue}
  1469  	a.GetTokenLastEight()
  1470  	a = &Authorization{}
  1471  	a.GetTokenLastEight()
  1472  	a = nil
  1473  	a.GetTokenLastEight()
  1474  }
  1475  
  1476  func TestAuthorization_GetUpdatedAt(tt *testing.T) {
  1477  	var zeroValue Timestamp
  1478  	a := &Authorization{UpdatedAt: &zeroValue}
  1479  	a.GetUpdatedAt()
  1480  	a = &Authorization{}
  1481  	a.GetUpdatedAt()
  1482  	a = nil
  1483  	a.GetUpdatedAt()
  1484  }
  1485  
  1486  func TestAuthorization_GetURL(tt *testing.T) {
  1487  	var zeroValue string
  1488  	a := &Authorization{URL: &zeroValue}
  1489  	a.GetURL()
  1490  	a = &Authorization{}
  1491  	a.GetURL()
  1492  	a = nil
  1493  	a.GetURL()
  1494  }
  1495  
  1496  func TestAuthorization_GetUser(tt *testing.T) {
  1497  	a := &Authorization{}
  1498  	a.GetUser()
  1499  	a = nil
  1500  	a.GetUser()
  1501  }
  1502  
  1503  func TestAuthorizationApp_GetClientID(tt *testing.T) {
  1504  	var zeroValue string
  1505  	a := &AuthorizationApp{ClientID: &zeroValue}
  1506  	a.GetClientID()
  1507  	a = &AuthorizationApp{}
  1508  	a.GetClientID()
  1509  	a = nil
  1510  	a.GetClientID()
  1511  }
  1512  
  1513  func TestAuthorizationApp_GetName(tt *testing.T) {
  1514  	var zeroValue string
  1515  	a := &AuthorizationApp{Name: &zeroValue}
  1516  	a.GetName()
  1517  	a = &AuthorizationApp{}
  1518  	a.GetName()
  1519  	a = nil
  1520  	a.GetName()
  1521  }
  1522  
  1523  func TestAuthorizationApp_GetURL(tt *testing.T) {
  1524  	var zeroValue string
  1525  	a := &AuthorizationApp{URL: &zeroValue}
  1526  	a.GetURL()
  1527  	a = &AuthorizationApp{}
  1528  	a.GetURL()
  1529  	a = nil
  1530  	a.GetURL()
  1531  }
  1532  
  1533  func TestAuthorizationRequest_GetClientID(tt *testing.T) {
  1534  	var zeroValue string
  1535  	a := &AuthorizationRequest{ClientID: &zeroValue}
  1536  	a.GetClientID()
  1537  	a = &AuthorizationRequest{}
  1538  	a.GetClientID()
  1539  	a = nil
  1540  	a.GetClientID()
  1541  }
  1542  
  1543  func TestAuthorizationRequest_GetClientSecret(tt *testing.T) {
  1544  	var zeroValue string
  1545  	a := &AuthorizationRequest{ClientSecret: &zeroValue}
  1546  	a.GetClientSecret()
  1547  	a = &AuthorizationRequest{}
  1548  	a.GetClientSecret()
  1549  	a = nil
  1550  	a.GetClientSecret()
  1551  }
  1552  
  1553  func TestAuthorizationRequest_GetFingerprint(tt *testing.T) {
  1554  	var zeroValue string
  1555  	a := &AuthorizationRequest{Fingerprint: &zeroValue}
  1556  	a.GetFingerprint()
  1557  	a = &AuthorizationRequest{}
  1558  	a.GetFingerprint()
  1559  	a = nil
  1560  	a.GetFingerprint()
  1561  }
  1562  
  1563  func TestAuthorizationRequest_GetNote(tt *testing.T) {
  1564  	var zeroValue string
  1565  	a := &AuthorizationRequest{Note: &zeroValue}
  1566  	a.GetNote()
  1567  	a = &AuthorizationRequest{}
  1568  	a.GetNote()
  1569  	a = nil
  1570  	a.GetNote()
  1571  }
  1572  
  1573  func TestAuthorizationRequest_GetNoteURL(tt *testing.T) {
  1574  	var zeroValue string
  1575  	a := &AuthorizationRequest{NoteURL: &zeroValue}
  1576  	a.GetNoteURL()
  1577  	a = &AuthorizationRequest{}
  1578  	a.GetNoteURL()
  1579  	a = nil
  1580  	a.GetNoteURL()
  1581  }
  1582  
  1583  func TestAuthorizationUpdateRequest_GetFingerprint(tt *testing.T) {
  1584  	var zeroValue string
  1585  	a := &AuthorizationUpdateRequest{Fingerprint: &zeroValue}
  1586  	a.GetFingerprint()
  1587  	a = &AuthorizationUpdateRequest{}
  1588  	a.GetFingerprint()
  1589  	a = nil
  1590  	a.GetFingerprint()
  1591  }
  1592  
  1593  func TestAuthorizationUpdateRequest_GetNote(tt *testing.T) {
  1594  	var zeroValue string
  1595  	a := &AuthorizationUpdateRequest{Note: &zeroValue}
  1596  	a.GetNote()
  1597  	a = &AuthorizationUpdateRequest{}
  1598  	a.GetNote()
  1599  	a = nil
  1600  	a.GetNote()
  1601  }
  1602  
  1603  func TestAuthorizationUpdateRequest_GetNoteURL(tt *testing.T) {
  1604  	var zeroValue string
  1605  	a := &AuthorizationUpdateRequest{NoteURL: &zeroValue}
  1606  	a.GetNoteURL()
  1607  	a = &AuthorizationUpdateRequest{}
  1608  	a.GetNoteURL()
  1609  	a = nil
  1610  	a.GetNoteURL()
  1611  }
  1612  
  1613  func TestAuthorizedActorsOnly_GetFrom(tt *testing.T) {
  1614  	var zeroValue bool
  1615  	a := &AuthorizedActorsOnly{From: &zeroValue}
  1616  	a.GetFrom()
  1617  	a = &AuthorizedActorsOnly{}
  1618  	a.GetFrom()
  1619  	a = nil
  1620  	a.GetFrom()
  1621  }
  1622  
  1623  func TestAutolink_GetID(tt *testing.T) {
  1624  	var zeroValue int64
  1625  	a := &Autolink{ID: &zeroValue}
  1626  	a.GetID()
  1627  	a = &Autolink{}
  1628  	a.GetID()
  1629  	a = nil
  1630  	a.GetID()
  1631  }
  1632  
  1633  func TestAutolink_GetKeyPrefix(tt *testing.T) {
  1634  	var zeroValue string
  1635  	a := &Autolink{KeyPrefix: &zeroValue}
  1636  	a.GetKeyPrefix()
  1637  	a = &Autolink{}
  1638  	a.GetKeyPrefix()
  1639  	a = nil
  1640  	a.GetKeyPrefix()
  1641  }
  1642  
  1643  func TestAutolink_GetURLTemplate(tt *testing.T) {
  1644  	var zeroValue string
  1645  	a := &Autolink{URLTemplate: &zeroValue}
  1646  	a.GetURLTemplate()
  1647  	a = &Autolink{}
  1648  	a.GetURLTemplate()
  1649  	a = nil
  1650  	a.GetURLTemplate()
  1651  }
  1652  
  1653  func TestAutolinkOptions_GetKeyPrefix(tt *testing.T) {
  1654  	var zeroValue string
  1655  	a := &AutolinkOptions{KeyPrefix: &zeroValue}
  1656  	a.GetKeyPrefix()
  1657  	a = &AutolinkOptions{}
  1658  	a.GetKeyPrefix()
  1659  	a = nil
  1660  	a.GetKeyPrefix()
  1661  }
  1662  
  1663  func TestAutolinkOptions_GetURLTemplate(tt *testing.T) {
  1664  	var zeroValue string
  1665  	a := &AutolinkOptions{URLTemplate: &zeroValue}
  1666  	a.GetURLTemplate()
  1667  	a = &AutolinkOptions{}
  1668  	a.GetURLTemplate()
  1669  	a = nil
  1670  	a.GetURLTemplate()
  1671  }
  1672  
  1673  func TestAutoTriggerCheck_GetAppID(tt *testing.T) {
  1674  	var zeroValue int64
  1675  	a := &AutoTriggerCheck{AppID: &zeroValue}
  1676  	a.GetAppID()
  1677  	a = &AutoTriggerCheck{}
  1678  	a.GetAppID()
  1679  	a = nil
  1680  	a.GetAppID()
  1681  }
  1682  
  1683  func TestAutoTriggerCheck_GetSetting(tt *testing.T) {
  1684  	var zeroValue bool
  1685  	a := &AutoTriggerCheck{Setting: &zeroValue}
  1686  	a.GetSetting()
  1687  	a = &AutoTriggerCheck{}
  1688  	a.GetSetting()
  1689  	a = nil
  1690  	a.GetSetting()
  1691  }
  1692  
  1693  func TestBlob_GetContent(tt *testing.T) {
  1694  	var zeroValue string
  1695  	b := &Blob{Content: &zeroValue}
  1696  	b.GetContent()
  1697  	b = &Blob{}
  1698  	b.GetContent()
  1699  	b = nil
  1700  	b.GetContent()
  1701  }
  1702  
  1703  func TestBlob_GetEncoding(tt *testing.T) {
  1704  	var zeroValue string
  1705  	b := &Blob{Encoding: &zeroValue}
  1706  	b.GetEncoding()
  1707  	b = &Blob{}
  1708  	b.GetEncoding()
  1709  	b = nil
  1710  	b.GetEncoding()
  1711  }
  1712  
  1713  func TestBlob_GetNodeID(tt *testing.T) {
  1714  	var zeroValue string
  1715  	b := &Blob{NodeID: &zeroValue}
  1716  	b.GetNodeID()
  1717  	b = &Blob{}
  1718  	b.GetNodeID()
  1719  	b = nil
  1720  	b.GetNodeID()
  1721  }
  1722  
  1723  func TestBlob_GetSHA(tt *testing.T) {
  1724  	var zeroValue string
  1725  	b := &Blob{SHA: &zeroValue}
  1726  	b.GetSHA()
  1727  	b = &Blob{}
  1728  	b.GetSHA()
  1729  	b = nil
  1730  	b.GetSHA()
  1731  }
  1732  
  1733  func TestBlob_GetSize(tt *testing.T) {
  1734  	var zeroValue int
  1735  	b := &Blob{Size: &zeroValue}
  1736  	b.GetSize()
  1737  	b = &Blob{}
  1738  	b.GetSize()
  1739  	b = nil
  1740  	b.GetSize()
  1741  }
  1742  
  1743  func TestBlob_GetURL(tt *testing.T) {
  1744  	var zeroValue string
  1745  	b := &Blob{URL: &zeroValue}
  1746  	b.GetURL()
  1747  	b = &Blob{}
  1748  	b.GetURL()
  1749  	b = nil
  1750  	b.GetURL()
  1751  }
  1752  
  1753  func TestBranch_GetCommit(tt *testing.T) {
  1754  	b := &Branch{}
  1755  	b.GetCommit()
  1756  	b = nil
  1757  	b.GetCommit()
  1758  }
  1759  
  1760  func TestBranch_GetName(tt *testing.T) {
  1761  	var zeroValue string
  1762  	b := &Branch{Name: &zeroValue}
  1763  	b.GetName()
  1764  	b = &Branch{}
  1765  	b.GetName()
  1766  	b = nil
  1767  	b.GetName()
  1768  }
  1769  
  1770  func TestBranch_GetProtected(tt *testing.T) {
  1771  	var zeroValue bool
  1772  	b := &Branch{Protected: &zeroValue}
  1773  	b.GetProtected()
  1774  	b = &Branch{}
  1775  	b.GetProtected()
  1776  	b = nil
  1777  	b.GetProtected()
  1778  }
  1779  
  1780  func TestBranchCommit_GetCommit(tt *testing.T) {
  1781  	b := &BranchCommit{}
  1782  	b.GetCommit()
  1783  	b = nil
  1784  	b.GetCommit()
  1785  }
  1786  
  1787  func TestBranchCommit_GetName(tt *testing.T) {
  1788  	var zeroValue string
  1789  	b := &BranchCommit{Name: &zeroValue}
  1790  	b.GetName()
  1791  	b = &BranchCommit{}
  1792  	b.GetName()
  1793  	b = nil
  1794  	b.GetName()
  1795  }
  1796  
  1797  func TestBranchCommit_GetProtected(tt *testing.T) {
  1798  	var zeroValue bool
  1799  	b := &BranchCommit{Protected: &zeroValue}
  1800  	b.GetProtected()
  1801  	b = &BranchCommit{}
  1802  	b.GetProtected()
  1803  	b = nil
  1804  	b.GetProtected()
  1805  }
  1806  
  1807  func TestBranchListOptions_GetProtected(tt *testing.T) {
  1808  	var zeroValue bool
  1809  	b := &BranchListOptions{Protected: &zeroValue}
  1810  	b.GetProtected()
  1811  	b = &BranchListOptions{}
  1812  	b.GetProtected()
  1813  	b = nil
  1814  	b.GetProtected()
  1815  }
  1816  
  1817  func TestBranchPolicy_GetCustomBranchPolicies(tt *testing.T) {
  1818  	var zeroValue bool
  1819  	b := &BranchPolicy{CustomBranchPolicies: &zeroValue}
  1820  	b.GetCustomBranchPolicies()
  1821  	b = &BranchPolicy{}
  1822  	b.GetCustomBranchPolicies()
  1823  	b = nil
  1824  	b.GetCustomBranchPolicies()
  1825  }
  1826  
  1827  func TestBranchPolicy_GetProtectedBranches(tt *testing.T) {
  1828  	var zeroValue bool
  1829  	b := &BranchPolicy{ProtectedBranches: &zeroValue}
  1830  	b.GetProtectedBranches()
  1831  	b = &BranchPolicy{}
  1832  	b.GetProtectedBranches()
  1833  	b = nil
  1834  	b.GetProtectedBranches()
  1835  }
  1836  
  1837  func TestBranchProtectionRule_GetAdminEnforced(tt *testing.T) {
  1838  	var zeroValue bool
  1839  	b := &BranchProtectionRule{AdminEnforced: &zeroValue}
  1840  	b.GetAdminEnforced()
  1841  	b = &BranchProtectionRule{}
  1842  	b.GetAdminEnforced()
  1843  	b = nil
  1844  	b.GetAdminEnforced()
  1845  }
  1846  
  1847  func TestBranchProtectionRule_GetAllowDeletionsEnforcementLevel(tt *testing.T) {
  1848  	var zeroValue string
  1849  	b := &BranchProtectionRule{AllowDeletionsEnforcementLevel: &zeroValue}
  1850  	b.GetAllowDeletionsEnforcementLevel()
  1851  	b = &BranchProtectionRule{}
  1852  	b.GetAllowDeletionsEnforcementLevel()
  1853  	b = nil
  1854  	b.GetAllowDeletionsEnforcementLevel()
  1855  }
  1856  
  1857  func TestBranchProtectionRule_GetAllowForcePushesEnforcementLevel(tt *testing.T) {
  1858  	var zeroValue string
  1859  	b := &BranchProtectionRule{AllowForcePushesEnforcementLevel: &zeroValue}
  1860  	b.GetAllowForcePushesEnforcementLevel()
  1861  	b = &BranchProtectionRule{}
  1862  	b.GetAllowForcePushesEnforcementLevel()
  1863  	b = nil
  1864  	b.GetAllowForcePushesEnforcementLevel()
  1865  }
  1866  
  1867  func TestBranchProtectionRule_GetAuthorizedActorsOnly(tt *testing.T) {
  1868  	var zeroValue bool
  1869  	b := &BranchProtectionRule{AuthorizedActorsOnly: &zeroValue}
  1870  	b.GetAuthorizedActorsOnly()
  1871  	b = &BranchProtectionRule{}
  1872  	b.GetAuthorizedActorsOnly()
  1873  	b = nil
  1874  	b.GetAuthorizedActorsOnly()
  1875  }
  1876  
  1877  func TestBranchProtectionRule_GetAuthorizedDismissalActorsOnly(tt *testing.T) {
  1878  	var zeroValue bool
  1879  	b := &BranchProtectionRule{AuthorizedDismissalActorsOnly: &zeroValue}
  1880  	b.GetAuthorizedDismissalActorsOnly()
  1881  	b = &BranchProtectionRule{}
  1882  	b.GetAuthorizedDismissalActorsOnly()
  1883  	b = nil
  1884  	b.GetAuthorizedDismissalActorsOnly()
  1885  }
  1886  
  1887  func TestBranchProtectionRule_GetCreatedAt(tt *testing.T) {
  1888  	var zeroValue Timestamp
  1889  	b := &BranchProtectionRule{CreatedAt: &zeroValue}
  1890  	b.GetCreatedAt()
  1891  	b = &BranchProtectionRule{}
  1892  	b.GetCreatedAt()
  1893  	b = nil
  1894  	b.GetCreatedAt()
  1895  }
  1896  
  1897  func TestBranchProtectionRule_GetDismissStaleReviewsOnPush(tt *testing.T) {
  1898  	var zeroValue bool
  1899  	b := &BranchProtectionRule{DismissStaleReviewsOnPush: &zeroValue}
  1900  	b.GetDismissStaleReviewsOnPush()
  1901  	b = &BranchProtectionRule{}
  1902  	b.GetDismissStaleReviewsOnPush()
  1903  	b = nil
  1904  	b.GetDismissStaleReviewsOnPush()
  1905  }
  1906  
  1907  func TestBranchProtectionRule_GetID(tt *testing.T) {
  1908  	var zeroValue int64
  1909  	b := &BranchProtectionRule{ID: &zeroValue}
  1910  	b.GetID()
  1911  	b = &BranchProtectionRule{}
  1912  	b.GetID()
  1913  	b = nil
  1914  	b.GetID()
  1915  }
  1916  
  1917  func TestBranchProtectionRule_GetIgnoreApprovalsFromContributors(tt *testing.T) {
  1918  	var zeroValue bool
  1919  	b := &BranchProtectionRule{IgnoreApprovalsFromContributors: &zeroValue}
  1920  	b.GetIgnoreApprovalsFromContributors()
  1921  	b = &BranchProtectionRule{}
  1922  	b.GetIgnoreApprovalsFromContributors()
  1923  	b = nil
  1924  	b.GetIgnoreApprovalsFromContributors()
  1925  }
  1926  
  1927  func TestBranchProtectionRule_GetLinearHistoryRequirementEnforcementLevel(tt *testing.T) {
  1928  	var zeroValue string
  1929  	b := &BranchProtectionRule{LinearHistoryRequirementEnforcementLevel: &zeroValue}
  1930  	b.GetLinearHistoryRequirementEnforcementLevel()
  1931  	b = &BranchProtectionRule{}
  1932  	b.GetLinearHistoryRequirementEnforcementLevel()
  1933  	b = nil
  1934  	b.GetLinearHistoryRequirementEnforcementLevel()
  1935  }
  1936  
  1937  func TestBranchProtectionRule_GetMergeQueueEnforcementLevel(tt *testing.T) {
  1938  	var zeroValue string
  1939  	b := &BranchProtectionRule{MergeQueueEnforcementLevel: &zeroValue}
  1940  	b.GetMergeQueueEnforcementLevel()
  1941  	b = &BranchProtectionRule{}
  1942  	b.GetMergeQueueEnforcementLevel()
  1943  	b = nil
  1944  	b.GetMergeQueueEnforcementLevel()
  1945  }
  1946  
  1947  func TestBranchProtectionRule_GetName(tt *testing.T) {
  1948  	var zeroValue string
  1949  	b := &BranchProtectionRule{Name: &zeroValue}
  1950  	b.GetName()
  1951  	b = &BranchProtectionRule{}
  1952  	b.GetName()
  1953  	b = nil
  1954  	b.GetName()
  1955  }
  1956  
  1957  func TestBranchProtectionRule_GetPullRequestReviewsEnforcementLevel(tt *testing.T) {
  1958  	var zeroValue string
  1959  	b := &BranchProtectionRule{PullRequestReviewsEnforcementLevel: &zeroValue}
  1960  	b.GetPullRequestReviewsEnforcementLevel()
  1961  	b = &BranchProtectionRule{}
  1962  	b.GetPullRequestReviewsEnforcementLevel()
  1963  	b = nil
  1964  	b.GetPullRequestReviewsEnforcementLevel()
  1965  }
  1966  
  1967  func TestBranchProtectionRule_GetRepositoryID(tt *testing.T) {
  1968  	var zeroValue int64
  1969  	b := &BranchProtectionRule{RepositoryID: &zeroValue}
  1970  	b.GetRepositoryID()
  1971  	b = &BranchProtectionRule{}
  1972  	b.GetRepositoryID()
  1973  	b = nil
  1974  	b.GetRepositoryID()
  1975  }
  1976  
  1977  func TestBranchProtectionRule_GetRequireCodeOwnerReview(tt *testing.T) {
  1978  	var zeroValue bool
  1979  	b := &BranchProtectionRule{RequireCodeOwnerReview: &zeroValue}
  1980  	b.GetRequireCodeOwnerReview()
  1981  	b = &BranchProtectionRule{}
  1982  	b.GetRequireCodeOwnerReview()
  1983  	b = nil
  1984  	b.GetRequireCodeOwnerReview()
  1985  }
  1986  
  1987  func TestBranchProtectionRule_GetRequiredApprovingReviewCount(tt *testing.T) {
  1988  	var zeroValue int
  1989  	b := &BranchProtectionRule{RequiredApprovingReviewCount: &zeroValue}
  1990  	b.GetRequiredApprovingReviewCount()
  1991  	b = &BranchProtectionRule{}
  1992  	b.GetRequiredApprovingReviewCount()
  1993  	b = nil
  1994  	b.GetRequiredApprovingReviewCount()
  1995  }
  1996  
  1997  func TestBranchProtectionRule_GetRequiredConversationResolutionLevel(tt *testing.T) {
  1998  	var zeroValue string
  1999  	b := &BranchProtectionRule{RequiredConversationResolutionLevel: &zeroValue}
  2000  	b.GetRequiredConversationResolutionLevel()
  2001  	b = &BranchProtectionRule{}
  2002  	b.GetRequiredConversationResolutionLevel()
  2003  	b = nil
  2004  	b.GetRequiredConversationResolutionLevel()
  2005  }
  2006  
  2007  func TestBranchProtectionRule_GetRequiredDeploymentsEnforcementLevel(tt *testing.T) {
  2008  	var zeroValue string
  2009  	b := &BranchProtectionRule{RequiredDeploymentsEnforcementLevel: &zeroValue}
  2010  	b.GetRequiredDeploymentsEnforcementLevel()
  2011  	b = &BranchProtectionRule{}
  2012  	b.GetRequiredDeploymentsEnforcementLevel()
  2013  	b = nil
  2014  	b.GetRequiredDeploymentsEnforcementLevel()
  2015  }
  2016  
  2017  func TestBranchProtectionRule_GetRequiredStatusChecksEnforcementLevel(tt *testing.T) {
  2018  	var zeroValue string
  2019  	b := &BranchProtectionRule{RequiredStatusChecksEnforcementLevel: &zeroValue}
  2020  	b.GetRequiredStatusChecksEnforcementLevel()
  2021  	b = &BranchProtectionRule{}
  2022  	b.GetRequiredStatusChecksEnforcementLevel()
  2023  	b = nil
  2024  	b.GetRequiredStatusChecksEnforcementLevel()
  2025  }
  2026  
  2027  func TestBranchProtectionRule_GetSignatureRequirementEnforcementLevel(tt *testing.T) {
  2028  	var zeroValue string
  2029  	b := &BranchProtectionRule{SignatureRequirementEnforcementLevel: &zeroValue}
  2030  	b.GetSignatureRequirementEnforcementLevel()
  2031  	b = &BranchProtectionRule{}
  2032  	b.GetSignatureRequirementEnforcementLevel()
  2033  	b = nil
  2034  	b.GetSignatureRequirementEnforcementLevel()
  2035  }
  2036  
  2037  func TestBranchProtectionRule_GetStrictRequiredStatusChecksPolicy(tt *testing.T) {
  2038  	var zeroValue bool
  2039  	b := &BranchProtectionRule{StrictRequiredStatusChecksPolicy: &zeroValue}
  2040  	b.GetStrictRequiredStatusChecksPolicy()
  2041  	b = &BranchProtectionRule{}
  2042  	b.GetStrictRequiredStatusChecksPolicy()
  2043  	b = nil
  2044  	b.GetStrictRequiredStatusChecksPolicy()
  2045  }
  2046  
  2047  func TestBranchProtectionRule_GetUpdatedAt(tt *testing.T) {
  2048  	var zeroValue Timestamp
  2049  	b := &BranchProtectionRule{UpdatedAt: &zeroValue}
  2050  	b.GetUpdatedAt()
  2051  	b = &BranchProtectionRule{}
  2052  	b.GetUpdatedAt()
  2053  	b = nil
  2054  	b.GetUpdatedAt()
  2055  }
  2056  
  2057  func TestBranchProtectionRuleEvent_GetAction(tt *testing.T) {
  2058  	var zeroValue string
  2059  	b := &BranchProtectionRuleEvent{Action: &zeroValue}
  2060  	b.GetAction()
  2061  	b = &BranchProtectionRuleEvent{}
  2062  	b.GetAction()
  2063  	b = nil
  2064  	b.GetAction()
  2065  }
  2066  
  2067  func TestBranchProtectionRuleEvent_GetChanges(tt *testing.T) {
  2068  	b := &BranchProtectionRuleEvent{}
  2069  	b.GetChanges()
  2070  	b = nil
  2071  	b.GetChanges()
  2072  }
  2073  
  2074  func TestBranchProtectionRuleEvent_GetInstallation(tt *testing.T) {
  2075  	b := &BranchProtectionRuleEvent{}
  2076  	b.GetInstallation()
  2077  	b = nil
  2078  	b.GetInstallation()
  2079  }
  2080  
  2081  func TestBranchProtectionRuleEvent_GetOrg(tt *testing.T) {
  2082  	b := &BranchProtectionRuleEvent{}
  2083  	b.GetOrg()
  2084  	b = nil
  2085  	b.GetOrg()
  2086  }
  2087  
  2088  func TestBranchProtectionRuleEvent_GetRepo(tt *testing.T) {
  2089  	b := &BranchProtectionRuleEvent{}
  2090  	b.GetRepo()
  2091  	b = nil
  2092  	b.GetRepo()
  2093  }
  2094  
  2095  func TestBranchProtectionRuleEvent_GetRule(tt *testing.T) {
  2096  	b := &BranchProtectionRuleEvent{}
  2097  	b.GetRule()
  2098  	b = nil
  2099  	b.GetRule()
  2100  }
  2101  
  2102  func TestBranchProtectionRuleEvent_GetSender(tt *testing.T) {
  2103  	b := &BranchProtectionRuleEvent{}
  2104  	b.GetSender()
  2105  	b = nil
  2106  	b.GetSender()
  2107  }
  2108  
  2109  func TestCheckRun_GetApp(tt *testing.T) {
  2110  	c := &CheckRun{}
  2111  	c.GetApp()
  2112  	c = nil
  2113  	c.GetApp()
  2114  }
  2115  
  2116  func TestCheckRun_GetCheckSuite(tt *testing.T) {
  2117  	c := &CheckRun{}
  2118  	c.GetCheckSuite()
  2119  	c = nil
  2120  	c.GetCheckSuite()
  2121  }
  2122  
  2123  func TestCheckRun_GetCompletedAt(tt *testing.T) {
  2124  	var zeroValue Timestamp
  2125  	c := &CheckRun{CompletedAt: &zeroValue}
  2126  	c.GetCompletedAt()
  2127  	c = &CheckRun{}
  2128  	c.GetCompletedAt()
  2129  	c = nil
  2130  	c.GetCompletedAt()
  2131  }
  2132  
  2133  func TestCheckRun_GetConclusion(tt *testing.T) {
  2134  	var zeroValue string
  2135  	c := &CheckRun{Conclusion: &zeroValue}
  2136  	c.GetConclusion()
  2137  	c = &CheckRun{}
  2138  	c.GetConclusion()
  2139  	c = nil
  2140  	c.GetConclusion()
  2141  }
  2142  
  2143  func TestCheckRun_GetDetailsURL(tt *testing.T) {
  2144  	var zeroValue string
  2145  	c := &CheckRun{DetailsURL: &zeroValue}
  2146  	c.GetDetailsURL()
  2147  	c = &CheckRun{}
  2148  	c.GetDetailsURL()
  2149  	c = nil
  2150  	c.GetDetailsURL()
  2151  }
  2152  
  2153  func TestCheckRun_GetExternalID(tt *testing.T) {
  2154  	var zeroValue string
  2155  	c := &CheckRun{ExternalID: &zeroValue}
  2156  	c.GetExternalID()
  2157  	c = &CheckRun{}
  2158  	c.GetExternalID()
  2159  	c = nil
  2160  	c.GetExternalID()
  2161  }
  2162  
  2163  func TestCheckRun_GetHeadSHA(tt *testing.T) {
  2164  	var zeroValue string
  2165  	c := &CheckRun{HeadSHA: &zeroValue}
  2166  	c.GetHeadSHA()
  2167  	c = &CheckRun{}
  2168  	c.GetHeadSHA()
  2169  	c = nil
  2170  	c.GetHeadSHA()
  2171  }
  2172  
  2173  func TestCheckRun_GetHTMLURL(tt *testing.T) {
  2174  	var zeroValue string
  2175  	c := &CheckRun{HTMLURL: &zeroValue}
  2176  	c.GetHTMLURL()
  2177  	c = &CheckRun{}
  2178  	c.GetHTMLURL()
  2179  	c = nil
  2180  	c.GetHTMLURL()
  2181  }
  2182  
  2183  func TestCheckRun_GetID(tt *testing.T) {
  2184  	var zeroValue int64
  2185  	c := &CheckRun{ID: &zeroValue}
  2186  	c.GetID()
  2187  	c = &CheckRun{}
  2188  	c.GetID()
  2189  	c = nil
  2190  	c.GetID()
  2191  }
  2192  
  2193  func TestCheckRun_GetName(tt *testing.T) {
  2194  	var zeroValue string
  2195  	c := &CheckRun{Name: &zeroValue}
  2196  	c.GetName()
  2197  	c = &CheckRun{}
  2198  	c.GetName()
  2199  	c = nil
  2200  	c.GetName()
  2201  }
  2202  
  2203  func TestCheckRun_GetNodeID(tt *testing.T) {
  2204  	var zeroValue string
  2205  	c := &CheckRun{NodeID: &zeroValue}
  2206  	c.GetNodeID()
  2207  	c = &CheckRun{}
  2208  	c.GetNodeID()
  2209  	c = nil
  2210  	c.GetNodeID()
  2211  }
  2212  
  2213  func TestCheckRun_GetOutput(tt *testing.T) {
  2214  	c := &CheckRun{}
  2215  	c.GetOutput()
  2216  	c = nil
  2217  	c.GetOutput()
  2218  }
  2219  
  2220  func TestCheckRun_GetStartedAt(tt *testing.T) {
  2221  	var zeroValue Timestamp
  2222  	c := &CheckRun{StartedAt: &zeroValue}
  2223  	c.GetStartedAt()
  2224  	c = &CheckRun{}
  2225  	c.GetStartedAt()
  2226  	c = nil
  2227  	c.GetStartedAt()
  2228  }
  2229  
  2230  func TestCheckRun_GetStatus(tt *testing.T) {
  2231  	var zeroValue string
  2232  	c := &CheckRun{Status: &zeroValue}
  2233  	c.GetStatus()
  2234  	c = &CheckRun{}
  2235  	c.GetStatus()
  2236  	c = nil
  2237  	c.GetStatus()
  2238  }
  2239  
  2240  func TestCheckRun_GetURL(tt *testing.T) {
  2241  	var zeroValue string
  2242  	c := &CheckRun{URL: &zeroValue}
  2243  	c.GetURL()
  2244  	c = &CheckRun{}
  2245  	c.GetURL()
  2246  	c = nil
  2247  	c.GetURL()
  2248  }
  2249  
  2250  func TestCheckRunAnnotation_GetAnnotationLevel(tt *testing.T) {
  2251  	var zeroValue string
  2252  	c := &CheckRunAnnotation{AnnotationLevel: &zeroValue}
  2253  	c.GetAnnotationLevel()
  2254  	c = &CheckRunAnnotation{}
  2255  	c.GetAnnotationLevel()
  2256  	c = nil
  2257  	c.GetAnnotationLevel()
  2258  }
  2259  
  2260  func TestCheckRunAnnotation_GetEndColumn(tt *testing.T) {
  2261  	var zeroValue int
  2262  	c := &CheckRunAnnotation{EndColumn: &zeroValue}
  2263  	c.GetEndColumn()
  2264  	c = &CheckRunAnnotation{}
  2265  	c.GetEndColumn()
  2266  	c = nil
  2267  	c.GetEndColumn()
  2268  }
  2269  
  2270  func TestCheckRunAnnotation_GetEndLine(tt *testing.T) {
  2271  	var zeroValue int
  2272  	c := &CheckRunAnnotation{EndLine: &zeroValue}
  2273  	c.GetEndLine()
  2274  	c = &CheckRunAnnotation{}
  2275  	c.GetEndLine()
  2276  	c = nil
  2277  	c.GetEndLine()
  2278  }
  2279  
  2280  func TestCheckRunAnnotation_GetMessage(tt *testing.T) {
  2281  	var zeroValue string
  2282  	c := &CheckRunAnnotation{Message: &zeroValue}
  2283  	c.GetMessage()
  2284  	c = &CheckRunAnnotation{}
  2285  	c.GetMessage()
  2286  	c = nil
  2287  	c.GetMessage()
  2288  }
  2289  
  2290  func TestCheckRunAnnotation_GetPath(tt *testing.T) {
  2291  	var zeroValue string
  2292  	c := &CheckRunAnnotation{Path: &zeroValue}
  2293  	c.GetPath()
  2294  	c = &CheckRunAnnotation{}
  2295  	c.GetPath()
  2296  	c = nil
  2297  	c.GetPath()
  2298  }
  2299  
  2300  func TestCheckRunAnnotation_GetRawDetails(tt *testing.T) {
  2301  	var zeroValue string
  2302  	c := &CheckRunAnnotation{RawDetails: &zeroValue}
  2303  	c.GetRawDetails()
  2304  	c = &CheckRunAnnotation{}
  2305  	c.GetRawDetails()
  2306  	c = nil
  2307  	c.GetRawDetails()
  2308  }
  2309  
  2310  func TestCheckRunAnnotation_GetStartColumn(tt *testing.T) {
  2311  	var zeroValue int
  2312  	c := &CheckRunAnnotation{StartColumn: &zeroValue}
  2313  	c.GetStartColumn()
  2314  	c = &CheckRunAnnotation{}
  2315  	c.GetStartColumn()
  2316  	c = nil
  2317  	c.GetStartColumn()
  2318  }
  2319  
  2320  func TestCheckRunAnnotation_GetStartLine(tt *testing.T) {
  2321  	var zeroValue int
  2322  	c := &CheckRunAnnotation{StartLine: &zeroValue}
  2323  	c.GetStartLine()
  2324  	c = &CheckRunAnnotation{}
  2325  	c.GetStartLine()
  2326  	c = nil
  2327  	c.GetStartLine()
  2328  }
  2329  
  2330  func TestCheckRunAnnotation_GetTitle(tt *testing.T) {
  2331  	var zeroValue string
  2332  	c := &CheckRunAnnotation{Title: &zeroValue}
  2333  	c.GetTitle()
  2334  	c = &CheckRunAnnotation{}
  2335  	c.GetTitle()
  2336  	c = nil
  2337  	c.GetTitle()
  2338  }
  2339  
  2340  func TestCheckRunEvent_GetAction(tt *testing.T) {
  2341  	var zeroValue string
  2342  	c := &CheckRunEvent{Action: &zeroValue}
  2343  	c.GetAction()
  2344  	c = &CheckRunEvent{}
  2345  	c.GetAction()
  2346  	c = nil
  2347  	c.GetAction()
  2348  }
  2349  
  2350  func TestCheckRunEvent_GetCheckRun(tt *testing.T) {
  2351  	c := &CheckRunEvent{}
  2352  	c.GetCheckRun()
  2353  	c = nil
  2354  	c.GetCheckRun()
  2355  }
  2356  
  2357  func TestCheckRunEvent_GetInstallation(tt *testing.T) {
  2358  	c := &CheckRunEvent{}
  2359  	c.GetInstallation()
  2360  	c = nil
  2361  	c.GetInstallation()
  2362  }
  2363  
  2364  func TestCheckRunEvent_GetOrg(tt *testing.T) {
  2365  	c := &CheckRunEvent{}
  2366  	c.GetOrg()
  2367  	c = nil
  2368  	c.GetOrg()
  2369  }
  2370  
  2371  func TestCheckRunEvent_GetRepo(tt *testing.T) {
  2372  	c := &CheckRunEvent{}
  2373  	c.GetRepo()
  2374  	c = nil
  2375  	c.GetRepo()
  2376  }
  2377  
  2378  func TestCheckRunEvent_GetRequestedAction(tt *testing.T) {
  2379  	c := &CheckRunEvent{}
  2380  	c.GetRequestedAction()
  2381  	c = nil
  2382  	c.GetRequestedAction()
  2383  }
  2384  
  2385  func TestCheckRunEvent_GetSender(tt *testing.T) {
  2386  	c := &CheckRunEvent{}
  2387  	c.GetSender()
  2388  	c = nil
  2389  	c.GetSender()
  2390  }
  2391  
  2392  func TestCheckRunImage_GetAlt(tt *testing.T) {
  2393  	var zeroValue string
  2394  	c := &CheckRunImage{Alt: &zeroValue}
  2395  	c.GetAlt()
  2396  	c = &CheckRunImage{}
  2397  	c.GetAlt()
  2398  	c = nil
  2399  	c.GetAlt()
  2400  }
  2401  
  2402  func TestCheckRunImage_GetCaption(tt *testing.T) {
  2403  	var zeroValue string
  2404  	c := &CheckRunImage{Caption: &zeroValue}
  2405  	c.GetCaption()
  2406  	c = &CheckRunImage{}
  2407  	c.GetCaption()
  2408  	c = nil
  2409  	c.GetCaption()
  2410  }
  2411  
  2412  func TestCheckRunImage_GetImageURL(tt *testing.T) {
  2413  	var zeroValue string
  2414  	c := &CheckRunImage{ImageURL: &zeroValue}
  2415  	c.GetImageURL()
  2416  	c = &CheckRunImage{}
  2417  	c.GetImageURL()
  2418  	c = nil
  2419  	c.GetImageURL()
  2420  }
  2421  
  2422  func TestCheckRunOutput_GetAnnotationsCount(tt *testing.T) {
  2423  	var zeroValue int
  2424  	c := &CheckRunOutput{AnnotationsCount: &zeroValue}
  2425  	c.GetAnnotationsCount()
  2426  	c = &CheckRunOutput{}
  2427  	c.GetAnnotationsCount()
  2428  	c = nil
  2429  	c.GetAnnotationsCount()
  2430  }
  2431  
  2432  func TestCheckRunOutput_GetAnnotationsURL(tt *testing.T) {
  2433  	var zeroValue string
  2434  	c := &CheckRunOutput{AnnotationsURL: &zeroValue}
  2435  	c.GetAnnotationsURL()
  2436  	c = &CheckRunOutput{}
  2437  	c.GetAnnotationsURL()
  2438  	c = nil
  2439  	c.GetAnnotationsURL()
  2440  }
  2441  
  2442  func TestCheckRunOutput_GetSummary(tt *testing.T) {
  2443  	var zeroValue string
  2444  	c := &CheckRunOutput{Summary: &zeroValue}
  2445  	c.GetSummary()
  2446  	c = &CheckRunOutput{}
  2447  	c.GetSummary()
  2448  	c = nil
  2449  	c.GetSummary()
  2450  }
  2451  
  2452  func TestCheckRunOutput_GetText(tt *testing.T) {
  2453  	var zeroValue string
  2454  	c := &CheckRunOutput{Text: &zeroValue}
  2455  	c.GetText()
  2456  	c = &CheckRunOutput{}
  2457  	c.GetText()
  2458  	c = nil
  2459  	c.GetText()
  2460  }
  2461  
  2462  func TestCheckRunOutput_GetTitle(tt *testing.T) {
  2463  	var zeroValue string
  2464  	c := &CheckRunOutput{Title: &zeroValue}
  2465  	c.GetTitle()
  2466  	c = &CheckRunOutput{}
  2467  	c.GetTitle()
  2468  	c = nil
  2469  	c.GetTitle()
  2470  }
  2471  
  2472  func TestCheckSuite_GetAfterSHA(tt *testing.T) {
  2473  	var zeroValue string
  2474  	c := &CheckSuite{AfterSHA: &zeroValue}
  2475  	c.GetAfterSHA()
  2476  	c = &CheckSuite{}
  2477  	c.GetAfterSHA()
  2478  	c = nil
  2479  	c.GetAfterSHA()
  2480  }
  2481  
  2482  func TestCheckSuite_GetApp(tt *testing.T) {
  2483  	c := &CheckSuite{}
  2484  	c.GetApp()
  2485  	c = nil
  2486  	c.GetApp()
  2487  }
  2488  
  2489  func TestCheckSuite_GetBeforeSHA(tt *testing.T) {
  2490  	var zeroValue string
  2491  	c := &CheckSuite{BeforeSHA: &zeroValue}
  2492  	c.GetBeforeSHA()
  2493  	c = &CheckSuite{}
  2494  	c.GetBeforeSHA()
  2495  	c = nil
  2496  	c.GetBeforeSHA()
  2497  }
  2498  
  2499  func TestCheckSuite_GetConclusion(tt *testing.T) {
  2500  	var zeroValue string
  2501  	c := &CheckSuite{Conclusion: &zeroValue}
  2502  	c.GetConclusion()
  2503  	c = &CheckSuite{}
  2504  	c.GetConclusion()
  2505  	c = nil
  2506  	c.GetConclusion()
  2507  }
  2508  
  2509  func TestCheckSuite_GetCreatedAt(tt *testing.T) {
  2510  	var zeroValue Timestamp
  2511  	c := &CheckSuite{CreatedAt: &zeroValue}
  2512  	c.GetCreatedAt()
  2513  	c = &CheckSuite{}
  2514  	c.GetCreatedAt()
  2515  	c = nil
  2516  	c.GetCreatedAt()
  2517  }
  2518  
  2519  func TestCheckSuite_GetHeadBranch(tt *testing.T) {
  2520  	var zeroValue string
  2521  	c := &CheckSuite{HeadBranch: &zeroValue}
  2522  	c.GetHeadBranch()
  2523  	c = &CheckSuite{}
  2524  	c.GetHeadBranch()
  2525  	c = nil
  2526  	c.GetHeadBranch()
  2527  }
  2528  
  2529  func TestCheckSuite_GetHeadCommit(tt *testing.T) {
  2530  	c := &CheckSuite{}
  2531  	c.GetHeadCommit()
  2532  	c = nil
  2533  	c.GetHeadCommit()
  2534  }
  2535  
  2536  func TestCheckSuite_GetHeadSHA(tt *testing.T) {
  2537  	var zeroValue string
  2538  	c := &CheckSuite{HeadSHA: &zeroValue}
  2539  	c.GetHeadSHA()
  2540  	c = &CheckSuite{}
  2541  	c.GetHeadSHA()
  2542  	c = nil
  2543  	c.GetHeadSHA()
  2544  }
  2545  
  2546  func TestCheckSuite_GetID(tt *testing.T) {
  2547  	var zeroValue int64
  2548  	c := &CheckSuite{ID: &zeroValue}
  2549  	c.GetID()
  2550  	c = &CheckSuite{}
  2551  	c.GetID()
  2552  	c = nil
  2553  	c.GetID()
  2554  }
  2555  
  2556  func TestCheckSuite_GetNodeID(tt *testing.T) {
  2557  	var zeroValue string
  2558  	c := &CheckSuite{NodeID: &zeroValue}
  2559  	c.GetNodeID()
  2560  	c = &CheckSuite{}
  2561  	c.GetNodeID()
  2562  	c = nil
  2563  	c.GetNodeID()
  2564  }
  2565  
  2566  func TestCheckSuite_GetRepository(tt *testing.T) {
  2567  	c := &CheckSuite{}
  2568  	c.GetRepository()
  2569  	c = nil
  2570  	c.GetRepository()
  2571  }
  2572  
  2573  func TestCheckSuite_GetStatus(tt *testing.T) {
  2574  	var zeroValue string
  2575  	c := &CheckSuite{Status: &zeroValue}
  2576  	c.GetStatus()
  2577  	c = &CheckSuite{}
  2578  	c.GetStatus()
  2579  	c = nil
  2580  	c.GetStatus()
  2581  }
  2582  
  2583  func TestCheckSuite_GetUpdatedAt(tt *testing.T) {
  2584  	var zeroValue Timestamp
  2585  	c := &CheckSuite{UpdatedAt: &zeroValue}
  2586  	c.GetUpdatedAt()
  2587  	c = &CheckSuite{}
  2588  	c.GetUpdatedAt()
  2589  	c = nil
  2590  	c.GetUpdatedAt()
  2591  }
  2592  
  2593  func TestCheckSuite_GetURL(tt *testing.T) {
  2594  	var zeroValue string
  2595  	c := &CheckSuite{URL: &zeroValue}
  2596  	c.GetURL()
  2597  	c = &CheckSuite{}
  2598  	c.GetURL()
  2599  	c = nil
  2600  	c.GetURL()
  2601  }
  2602  
  2603  func TestCheckSuiteEvent_GetAction(tt *testing.T) {
  2604  	var zeroValue string
  2605  	c := &CheckSuiteEvent{Action: &zeroValue}
  2606  	c.GetAction()
  2607  	c = &CheckSuiteEvent{}
  2608  	c.GetAction()
  2609  	c = nil
  2610  	c.GetAction()
  2611  }
  2612  
  2613  func TestCheckSuiteEvent_GetCheckSuite(tt *testing.T) {
  2614  	c := &CheckSuiteEvent{}
  2615  	c.GetCheckSuite()
  2616  	c = nil
  2617  	c.GetCheckSuite()
  2618  }
  2619  
  2620  func TestCheckSuiteEvent_GetInstallation(tt *testing.T) {
  2621  	c := &CheckSuiteEvent{}
  2622  	c.GetInstallation()
  2623  	c = nil
  2624  	c.GetInstallation()
  2625  }
  2626  
  2627  func TestCheckSuiteEvent_GetOrg(tt *testing.T) {
  2628  	c := &CheckSuiteEvent{}
  2629  	c.GetOrg()
  2630  	c = nil
  2631  	c.GetOrg()
  2632  }
  2633  
  2634  func TestCheckSuiteEvent_GetRepo(tt *testing.T) {
  2635  	c := &CheckSuiteEvent{}
  2636  	c.GetRepo()
  2637  	c = nil
  2638  	c.GetRepo()
  2639  }
  2640  
  2641  func TestCheckSuiteEvent_GetSender(tt *testing.T) {
  2642  	c := &CheckSuiteEvent{}
  2643  	c.GetSender()
  2644  	c = nil
  2645  	c.GetSender()
  2646  }
  2647  
  2648  func TestCheckSuitePreferenceResults_GetPreferences(tt *testing.T) {
  2649  	c := &CheckSuitePreferenceResults{}
  2650  	c.GetPreferences()
  2651  	c = nil
  2652  	c.GetPreferences()
  2653  }
  2654  
  2655  func TestCheckSuitePreferenceResults_GetRepository(tt *testing.T) {
  2656  	c := &CheckSuitePreferenceResults{}
  2657  	c.GetRepository()
  2658  	c = nil
  2659  	c.GetRepository()
  2660  }
  2661  
  2662  func TestCodeOfConduct_GetBody(tt *testing.T) {
  2663  	var zeroValue string
  2664  	c := &CodeOfConduct{Body: &zeroValue}
  2665  	c.GetBody()
  2666  	c = &CodeOfConduct{}
  2667  	c.GetBody()
  2668  	c = nil
  2669  	c.GetBody()
  2670  }
  2671  
  2672  func TestCodeOfConduct_GetKey(tt *testing.T) {
  2673  	var zeroValue string
  2674  	c := &CodeOfConduct{Key: &zeroValue}
  2675  	c.GetKey()
  2676  	c = &CodeOfConduct{}
  2677  	c.GetKey()
  2678  	c = nil
  2679  	c.GetKey()
  2680  }
  2681  
  2682  func TestCodeOfConduct_GetName(tt *testing.T) {
  2683  	var zeroValue string
  2684  	c := &CodeOfConduct{Name: &zeroValue}
  2685  	c.GetName()
  2686  	c = &CodeOfConduct{}
  2687  	c.GetName()
  2688  	c = nil
  2689  	c.GetName()
  2690  }
  2691  
  2692  func TestCodeOfConduct_GetURL(tt *testing.T) {
  2693  	var zeroValue string
  2694  	c := &CodeOfConduct{URL: &zeroValue}
  2695  	c.GetURL()
  2696  	c = &CodeOfConduct{}
  2697  	c.GetURL()
  2698  	c = nil
  2699  	c.GetURL()
  2700  }
  2701  
  2702  func TestCodeResult_GetHTMLURL(tt *testing.T) {
  2703  	var zeroValue string
  2704  	c := &CodeResult{HTMLURL: &zeroValue}
  2705  	c.GetHTMLURL()
  2706  	c = &CodeResult{}
  2707  	c.GetHTMLURL()
  2708  	c = nil
  2709  	c.GetHTMLURL()
  2710  }
  2711  
  2712  func TestCodeResult_GetName(tt *testing.T) {
  2713  	var zeroValue string
  2714  	c := &CodeResult{Name: &zeroValue}
  2715  	c.GetName()
  2716  	c = &CodeResult{}
  2717  	c.GetName()
  2718  	c = nil
  2719  	c.GetName()
  2720  }
  2721  
  2722  func TestCodeResult_GetPath(tt *testing.T) {
  2723  	var zeroValue string
  2724  	c := &CodeResult{Path: &zeroValue}
  2725  	c.GetPath()
  2726  	c = &CodeResult{}
  2727  	c.GetPath()
  2728  	c = nil
  2729  	c.GetPath()
  2730  }
  2731  
  2732  func TestCodeResult_GetRepository(tt *testing.T) {
  2733  	c := &CodeResult{}
  2734  	c.GetRepository()
  2735  	c = nil
  2736  	c.GetRepository()
  2737  }
  2738  
  2739  func TestCodeResult_GetSHA(tt *testing.T) {
  2740  	var zeroValue string
  2741  	c := &CodeResult{SHA: &zeroValue}
  2742  	c.GetSHA()
  2743  	c = &CodeResult{}
  2744  	c.GetSHA()
  2745  	c = nil
  2746  	c.GetSHA()
  2747  }
  2748  
  2749  func TestCodeScanningAlertEvent_GetAction(tt *testing.T) {
  2750  	var zeroValue string
  2751  	c := &CodeScanningAlertEvent{Action: &zeroValue}
  2752  	c.GetAction()
  2753  	c = &CodeScanningAlertEvent{}
  2754  	c.GetAction()
  2755  	c = nil
  2756  	c.GetAction()
  2757  }
  2758  
  2759  func TestCodeScanningAlertEvent_GetAlert(tt *testing.T) {
  2760  	c := &CodeScanningAlertEvent{}
  2761  	c.GetAlert()
  2762  	c = nil
  2763  	c.GetAlert()
  2764  }
  2765  
  2766  func TestCodeScanningAlertEvent_GetCommitOID(tt *testing.T) {
  2767  	var zeroValue string
  2768  	c := &CodeScanningAlertEvent{CommitOID: &zeroValue}
  2769  	c.GetCommitOID()
  2770  	c = &CodeScanningAlertEvent{}
  2771  	c.GetCommitOID()
  2772  	c = nil
  2773  	c.GetCommitOID()
  2774  }
  2775  
  2776  func TestCodeScanningAlertEvent_GetOrg(tt *testing.T) {
  2777  	c := &CodeScanningAlertEvent{}
  2778  	c.GetOrg()
  2779  	c = nil
  2780  	c.GetOrg()
  2781  }
  2782  
  2783  func TestCodeScanningAlertEvent_GetRef(tt *testing.T) {
  2784  	var zeroValue string
  2785  	c := &CodeScanningAlertEvent{Ref: &zeroValue}
  2786  	c.GetRef()
  2787  	c = &CodeScanningAlertEvent{}
  2788  	c.GetRef()
  2789  	c = nil
  2790  	c.GetRef()
  2791  }
  2792  
  2793  func TestCodeScanningAlertEvent_GetRepo(tt *testing.T) {
  2794  	c := &CodeScanningAlertEvent{}
  2795  	c.GetRepo()
  2796  	c = nil
  2797  	c.GetRepo()
  2798  }
  2799  
  2800  func TestCodeScanningAlertEvent_GetSender(tt *testing.T) {
  2801  	c := &CodeScanningAlertEvent{}
  2802  	c.GetSender()
  2803  	c = nil
  2804  	c.GetSender()
  2805  }
  2806  
  2807  func TestCodeSearchResult_GetIncompleteResults(tt *testing.T) {
  2808  	var zeroValue bool
  2809  	c := &CodeSearchResult{IncompleteResults: &zeroValue}
  2810  	c.GetIncompleteResults()
  2811  	c = &CodeSearchResult{}
  2812  	c.GetIncompleteResults()
  2813  	c = nil
  2814  	c.GetIncompleteResults()
  2815  }
  2816  
  2817  func TestCodeSearchResult_GetTotal(tt *testing.T) {
  2818  	var zeroValue int
  2819  	c := &CodeSearchResult{Total: &zeroValue}
  2820  	c.GetTotal()
  2821  	c = &CodeSearchResult{}
  2822  	c.GetTotal()
  2823  	c = nil
  2824  	c.GetTotal()
  2825  }
  2826  
  2827  func TestCollaboratorInvitation_GetCreatedAt(tt *testing.T) {
  2828  	var zeroValue Timestamp
  2829  	c := &CollaboratorInvitation{CreatedAt: &zeroValue}
  2830  	c.GetCreatedAt()
  2831  	c = &CollaboratorInvitation{}
  2832  	c.GetCreatedAt()
  2833  	c = nil
  2834  	c.GetCreatedAt()
  2835  }
  2836  
  2837  func TestCollaboratorInvitation_GetHTMLURL(tt *testing.T) {
  2838  	var zeroValue string
  2839  	c := &CollaboratorInvitation{HTMLURL: &zeroValue}
  2840  	c.GetHTMLURL()
  2841  	c = &CollaboratorInvitation{}
  2842  	c.GetHTMLURL()
  2843  	c = nil
  2844  	c.GetHTMLURL()
  2845  }
  2846  
  2847  func TestCollaboratorInvitation_GetID(tt *testing.T) {
  2848  	var zeroValue int64
  2849  	c := &CollaboratorInvitation{ID: &zeroValue}
  2850  	c.GetID()
  2851  	c = &CollaboratorInvitation{}
  2852  	c.GetID()
  2853  	c = nil
  2854  	c.GetID()
  2855  }
  2856  
  2857  func TestCollaboratorInvitation_GetInvitee(tt *testing.T) {
  2858  	c := &CollaboratorInvitation{}
  2859  	c.GetInvitee()
  2860  	c = nil
  2861  	c.GetInvitee()
  2862  }
  2863  
  2864  func TestCollaboratorInvitation_GetInviter(tt *testing.T) {
  2865  	c := &CollaboratorInvitation{}
  2866  	c.GetInviter()
  2867  	c = nil
  2868  	c.GetInviter()
  2869  }
  2870  
  2871  func TestCollaboratorInvitation_GetPermissions(tt *testing.T) {
  2872  	var zeroValue string
  2873  	c := &CollaboratorInvitation{Permissions: &zeroValue}
  2874  	c.GetPermissions()
  2875  	c = &CollaboratorInvitation{}
  2876  	c.GetPermissions()
  2877  	c = nil
  2878  	c.GetPermissions()
  2879  }
  2880  
  2881  func TestCollaboratorInvitation_GetRepo(tt *testing.T) {
  2882  	c := &CollaboratorInvitation{}
  2883  	c.GetRepo()
  2884  	c = nil
  2885  	c.GetRepo()
  2886  }
  2887  
  2888  func TestCollaboratorInvitation_GetURL(tt *testing.T) {
  2889  	var zeroValue string
  2890  	c := &CollaboratorInvitation{URL: &zeroValue}
  2891  	c.GetURL()
  2892  	c = &CollaboratorInvitation{}
  2893  	c.GetURL()
  2894  	c = nil
  2895  	c.GetURL()
  2896  }
  2897  
  2898  func TestCombinedStatus_GetCommitURL(tt *testing.T) {
  2899  	var zeroValue string
  2900  	c := &CombinedStatus{CommitURL: &zeroValue}
  2901  	c.GetCommitURL()
  2902  	c = &CombinedStatus{}
  2903  	c.GetCommitURL()
  2904  	c = nil
  2905  	c.GetCommitURL()
  2906  }
  2907  
  2908  func TestCombinedStatus_GetName(tt *testing.T) {
  2909  	var zeroValue string
  2910  	c := &CombinedStatus{Name: &zeroValue}
  2911  	c.GetName()
  2912  	c = &CombinedStatus{}
  2913  	c.GetName()
  2914  	c = nil
  2915  	c.GetName()
  2916  }
  2917  
  2918  func TestCombinedStatus_GetRepositoryURL(tt *testing.T) {
  2919  	var zeroValue string
  2920  	c := &CombinedStatus{RepositoryURL: &zeroValue}
  2921  	c.GetRepositoryURL()
  2922  	c = &CombinedStatus{}
  2923  	c.GetRepositoryURL()
  2924  	c = nil
  2925  	c.GetRepositoryURL()
  2926  }
  2927  
  2928  func TestCombinedStatus_GetSHA(tt *testing.T) {
  2929  	var zeroValue string
  2930  	c := &CombinedStatus{SHA: &zeroValue}
  2931  	c.GetSHA()
  2932  	c = &CombinedStatus{}
  2933  	c.GetSHA()
  2934  	c = nil
  2935  	c.GetSHA()
  2936  }
  2937  
  2938  func TestCombinedStatus_GetState(tt *testing.T) {
  2939  	var zeroValue string
  2940  	c := &CombinedStatus{State: &zeroValue}
  2941  	c.GetState()
  2942  	c = &CombinedStatus{}
  2943  	c.GetState()
  2944  	c = nil
  2945  	c.GetState()
  2946  }
  2947  
  2948  func TestCombinedStatus_GetTotalCount(tt *testing.T) {
  2949  	var zeroValue int
  2950  	c := &CombinedStatus{TotalCount: &zeroValue}
  2951  	c.GetTotalCount()
  2952  	c = &CombinedStatus{}
  2953  	c.GetTotalCount()
  2954  	c = nil
  2955  	c.GetTotalCount()
  2956  }
  2957  
  2958  func TestComment_GetCreatedAt(tt *testing.T) {
  2959  	var zeroValue time.Time
  2960  	c := &Comment{CreatedAt: &zeroValue}
  2961  	c.GetCreatedAt()
  2962  	c = &Comment{}
  2963  	c.GetCreatedAt()
  2964  	c = nil
  2965  	c.GetCreatedAt()
  2966  }
  2967  
  2968  func TestCommentStats_GetTotalCommitComments(tt *testing.T) {
  2969  	var zeroValue int
  2970  	c := &CommentStats{TotalCommitComments: &zeroValue}
  2971  	c.GetTotalCommitComments()
  2972  	c = &CommentStats{}
  2973  	c.GetTotalCommitComments()
  2974  	c = nil
  2975  	c.GetTotalCommitComments()
  2976  }
  2977  
  2978  func TestCommentStats_GetTotalGistComments(tt *testing.T) {
  2979  	var zeroValue int
  2980  	c := &CommentStats{TotalGistComments: &zeroValue}
  2981  	c.GetTotalGistComments()
  2982  	c = &CommentStats{}
  2983  	c.GetTotalGistComments()
  2984  	c = nil
  2985  	c.GetTotalGistComments()
  2986  }
  2987  
  2988  func TestCommentStats_GetTotalIssueComments(tt *testing.T) {
  2989  	var zeroValue int
  2990  	c := &CommentStats{TotalIssueComments: &zeroValue}
  2991  	c.GetTotalIssueComments()
  2992  	c = &CommentStats{}
  2993  	c.GetTotalIssueComments()
  2994  	c = nil
  2995  	c.GetTotalIssueComments()
  2996  }
  2997  
  2998  func TestCommentStats_GetTotalPullRequestComments(tt *testing.T) {
  2999  	var zeroValue int
  3000  	c := &CommentStats{TotalPullRequestComments: &zeroValue}
  3001  	c.GetTotalPullRequestComments()
  3002  	c = &CommentStats{}
  3003  	c.GetTotalPullRequestComments()
  3004  	c = nil
  3005  	c.GetTotalPullRequestComments()
  3006  }
  3007  
  3008  func TestCommit_GetAuthor(tt *testing.T) {
  3009  	c := &Commit{}
  3010  	c.GetAuthor()
  3011  	c = nil
  3012  	c.GetAuthor()
  3013  }
  3014  
  3015  func TestCommit_GetCommentCount(tt *testing.T) {
  3016  	var zeroValue int
  3017  	c := &Commit{CommentCount: &zeroValue}
  3018  	c.GetCommentCount()
  3019  	c = &Commit{}
  3020  	c.GetCommentCount()
  3021  	c = nil
  3022  	c.GetCommentCount()
  3023  }
  3024  
  3025  func TestCommit_GetCommitter(tt *testing.T) {
  3026  	c := &Commit{}
  3027  	c.GetCommitter()
  3028  	c = nil
  3029  	c.GetCommitter()
  3030  }
  3031  
  3032  func TestCommit_GetHTMLURL(tt *testing.T) {
  3033  	var zeroValue string
  3034  	c := &Commit{HTMLURL: &zeroValue}
  3035  	c.GetHTMLURL()
  3036  	c = &Commit{}
  3037  	c.GetHTMLURL()
  3038  	c = nil
  3039  	c.GetHTMLURL()
  3040  }
  3041  
  3042  func TestCommit_GetMessage(tt *testing.T) {
  3043  	var zeroValue string
  3044  	c := &Commit{Message: &zeroValue}
  3045  	c.GetMessage()
  3046  	c = &Commit{}
  3047  	c.GetMessage()
  3048  	c = nil
  3049  	c.GetMessage()
  3050  }
  3051  
  3052  func TestCommit_GetNodeID(tt *testing.T) {
  3053  	var zeroValue string
  3054  	c := &Commit{NodeID: &zeroValue}
  3055  	c.GetNodeID()
  3056  	c = &Commit{}
  3057  	c.GetNodeID()
  3058  	c = nil
  3059  	c.GetNodeID()
  3060  }
  3061  
  3062  func TestCommit_GetSHA(tt *testing.T) {
  3063  	var zeroValue string
  3064  	c := &Commit{SHA: &zeroValue}
  3065  	c.GetSHA()
  3066  	c = &Commit{}
  3067  	c.GetSHA()
  3068  	c = nil
  3069  	c.GetSHA()
  3070  }
  3071  
  3072  func TestCommit_GetStats(tt *testing.T) {
  3073  	c := &Commit{}
  3074  	c.GetStats()
  3075  	c = nil
  3076  	c.GetStats()
  3077  }
  3078  
  3079  func TestCommit_GetTree(tt *testing.T) {
  3080  	c := &Commit{}
  3081  	c.GetTree()
  3082  	c = nil
  3083  	c.GetTree()
  3084  }
  3085  
  3086  func TestCommit_GetURL(tt *testing.T) {
  3087  	var zeroValue string
  3088  	c := &Commit{URL: &zeroValue}
  3089  	c.GetURL()
  3090  	c = &Commit{}
  3091  	c.GetURL()
  3092  	c = nil
  3093  	c.GetURL()
  3094  }
  3095  
  3096  func TestCommit_GetVerification(tt *testing.T) {
  3097  	c := &Commit{}
  3098  	c.GetVerification()
  3099  	c = nil
  3100  	c.GetVerification()
  3101  }
  3102  
  3103  func TestCommitAuthor_GetDate(tt *testing.T) {
  3104  	var zeroValue time.Time
  3105  	c := &CommitAuthor{Date: &zeroValue}
  3106  	c.GetDate()
  3107  	c = &CommitAuthor{}
  3108  	c.GetDate()
  3109  	c = nil
  3110  	c.GetDate()
  3111  }
  3112  
  3113  func TestCommitAuthor_GetEmail(tt *testing.T) {
  3114  	var zeroValue string
  3115  	c := &CommitAuthor{Email: &zeroValue}
  3116  	c.GetEmail()
  3117  	c = &CommitAuthor{}
  3118  	c.GetEmail()
  3119  	c = nil
  3120  	c.GetEmail()
  3121  }
  3122  
  3123  func TestCommitAuthor_GetLogin(tt *testing.T) {
  3124  	var zeroValue string
  3125  	c := &CommitAuthor{Login: &zeroValue}
  3126  	c.GetLogin()
  3127  	c = &CommitAuthor{}
  3128  	c.GetLogin()
  3129  	c = nil
  3130  	c.GetLogin()
  3131  }
  3132  
  3133  func TestCommitAuthor_GetName(tt *testing.T) {
  3134  	var zeroValue string
  3135  	c := &CommitAuthor{Name: &zeroValue}
  3136  	c.GetName()
  3137  	c = &CommitAuthor{}
  3138  	c.GetName()
  3139  	c = nil
  3140  	c.GetName()
  3141  }
  3142  
  3143  func TestCommitCommentEvent_GetAction(tt *testing.T) {
  3144  	var zeroValue string
  3145  	c := &CommitCommentEvent{Action: &zeroValue}
  3146  	c.GetAction()
  3147  	c = &CommitCommentEvent{}
  3148  	c.GetAction()
  3149  	c = nil
  3150  	c.GetAction()
  3151  }
  3152  
  3153  func TestCommitCommentEvent_GetComment(tt *testing.T) {
  3154  	c := &CommitCommentEvent{}
  3155  	c.GetComment()
  3156  	c = nil
  3157  	c.GetComment()
  3158  }
  3159  
  3160  func TestCommitCommentEvent_GetInstallation(tt *testing.T) {
  3161  	c := &CommitCommentEvent{}
  3162  	c.GetInstallation()
  3163  	c = nil
  3164  	c.GetInstallation()
  3165  }
  3166  
  3167  func TestCommitCommentEvent_GetRepo(tt *testing.T) {
  3168  	c := &CommitCommentEvent{}
  3169  	c.GetRepo()
  3170  	c = nil
  3171  	c.GetRepo()
  3172  }
  3173  
  3174  func TestCommitCommentEvent_GetSender(tt *testing.T) {
  3175  	c := &CommitCommentEvent{}
  3176  	c.GetSender()
  3177  	c = nil
  3178  	c.GetSender()
  3179  }
  3180  
  3181  func TestCommitFile_GetAdditions(tt *testing.T) {
  3182  	var zeroValue int
  3183  	c := &CommitFile{Additions: &zeroValue}
  3184  	c.GetAdditions()
  3185  	c = &CommitFile{}
  3186  	c.GetAdditions()
  3187  	c = nil
  3188  	c.GetAdditions()
  3189  }
  3190  
  3191  func TestCommitFile_GetBlobURL(tt *testing.T) {
  3192  	var zeroValue string
  3193  	c := &CommitFile{BlobURL: &zeroValue}
  3194  	c.GetBlobURL()
  3195  	c = &CommitFile{}
  3196  	c.GetBlobURL()
  3197  	c = nil
  3198  	c.GetBlobURL()
  3199  }
  3200  
  3201  func TestCommitFile_GetChanges(tt *testing.T) {
  3202  	var zeroValue int
  3203  	c := &CommitFile{Changes: &zeroValue}
  3204  	c.GetChanges()
  3205  	c = &CommitFile{}
  3206  	c.GetChanges()
  3207  	c = nil
  3208  	c.GetChanges()
  3209  }
  3210  
  3211  func TestCommitFile_GetContentsURL(tt *testing.T) {
  3212  	var zeroValue string
  3213  	c := &CommitFile{ContentsURL: &zeroValue}
  3214  	c.GetContentsURL()
  3215  	c = &CommitFile{}
  3216  	c.GetContentsURL()
  3217  	c = nil
  3218  	c.GetContentsURL()
  3219  }
  3220  
  3221  func TestCommitFile_GetDeletions(tt *testing.T) {
  3222  	var zeroValue int
  3223  	c := &CommitFile{Deletions: &zeroValue}
  3224  	c.GetDeletions()
  3225  	c = &CommitFile{}
  3226  	c.GetDeletions()
  3227  	c = nil
  3228  	c.GetDeletions()
  3229  }
  3230  
  3231  func TestCommitFile_GetFilename(tt *testing.T) {
  3232  	var zeroValue string
  3233  	c := &CommitFile{Filename: &zeroValue}
  3234  	c.GetFilename()
  3235  	c = &CommitFile{}
  3236  	c.GetFilename()
  3237  	c = nil
  3238  	c.GetFilename()
  3239  }
  3240  
  3241  func TestCommitFile_GetPatch(tt *testing.T) {
  3242  	var zeroValue string
  3243  	c := &CommitFile{Patch: &zeroValue}
  3244  	c.GetPatch()
  3245  	c = &CommitFile{}
  3246  	c.GetPatch()
  3247  	c = nil
  3248  	c.GetPatch()
  3249  }
  3250  
  3251  func TestCommitFile_GetPreviousFilename(tt *testing.T) {
  3252  	var zeroValue string
  3253  	c := &CommitFile{PreviousFilename: &zeroValue}
  3254  	c.GetPreviousFilename()
  3255  	c = &CommitFile{}
  3256  	c.GetPreviousFilename()
  3257  	c = nil
  3258  	c.GetPreviousFilename()
  3259  }
  3260  
  3261  func TestCommitFile_GetRawURL(tt *testing.T) {
  3262  	var zeroValue string
  3263  	c := &CommitFile{RawURL: &zeroValue}
  3264  	c.GetRawURL()
  3265  	c = &CommitFile{}
  3266  	c.GetRawURL()
  3267  	c = nil
  3268  	c.GetRawURL()
  3269  }
  3270  
  3271  func TestCommitFile_GetSHA(tt *testing.T) {
  3272  	var zeroValue string
  3273  	c := &CommitFile{SHA: &zeroValue}
  3274  	c.GetSHA()
  3275  	c = &CommitFile{}
  3276  	c.GetSHA()
  3277  	c = nil
  3278  	c.GetSHA()
  3279  }
  3280  
  3281  func TestCommitFile_GetStatus(tt *testing.T) {
  3282  	var zeroValue string
  3283  	c := &CommitFile{Status: &zeroValue}
  3284  	c.GetStatus()
  3285  	c = &CommitFile{}
  3286  	c.GetStatus()
  3287  	c = nil
  3288  	c.GetStatus()
  3289  }
  3290  
  3291  func TestCommitResult_GetAuthor(tt *testing.T) {
  3292  	c := &CommitResult{}
  3293  	c.GetAuthor()
  3294  	c = nil
  3295  	c.GetAuthor()
  3296  }
  3297  
  3298  func TestCommitResult_GetCommentsURL(tt *testing.T) {
  3299  	var zeroValue string
  3300  	c := &CommitResult{CommentsURL: &zeroValue}
  3301  	c.GetCommentsURL()
  3302  	c = &CommitResult{}
  3303  	c.GetCommentsURL()
  3304  	c = nil
  3305  	c.GetCommentsURL()
  3306  }
  3307  
  3308  func TestCommitResult_GetCommit(tt *testing.T) {
  3309  	c := &CommitResult{}
  3310  	c.GetCommit()
  3311  	c = nil
  3312  	c.GetCommit()
  3313  }
  3314  
  3315  func TestCommitResult_GetCommitter(tt *testing.T) {
  3316  	c := &CommitResult{}
  3317  	c.GetCommitter()
  3318  	c = nil
  3319  	c.GetCommitter()
  3320  }
  3321  
  3322  func TestCommitResult_GetHTMLURL(tt *testing.T) {
  3323  	var zeroValue string
  3324  	c := &CommitResult{HTMLURL: &zeroValue}
  3325  	c.GetHTMLURL()
  3326  	c = &CommitResult{}
  3327  	c.GetHTMLURL()
  3328  	c = nil
  3329  	c.GetHTMLURL()
  3330  }
  3331  
  3332  func TestCommitResult_GetRepository(tt *testing.T) {
  3333  	c := &CommitResult{}
  3334  	c.GetRepository()
  3335  	c = nil
  3336  	c.GetRepository()
  3337  }
  3338  
  3339  func TestCommitResult_GetScore(tt *testing.T) {
  3340  	c := &CommitResult{}
  3341  	c.GetScore()
  3342  	c = nil
  3343  	c.GetScore()
  3344  }
  3345  
  3346  func TestCommitResult_GetSHA(tt *testing.T) {
  3347  	var zeroValue string
  3348  	c := &CommitResult{SHA: &zeroValue}
  3349  	c.GetSHA()
  3350  	c = &CommitResult{}
  3351  	c.GetSHA()
  3352  	c = nil
  3353  	c.GetSHA()
  3354  }
  3355  
  3356  func TestCommitResult_GetURL(tt *testing.T) {
  3357  	var zeroValue string
  3358  	c := &CommitResult{URL: &zeroValue}
  3359  	c.GetURL()
  3360  	c = &CommitResult{}
  3361  	c.GetURL()
  3362  	c = nil
  3363  	c.GetURL()
  3364  }
  3365  
  3366  func TestCommitsComparison_GetAheadBy(tt *testing.T) {
  3367  	var zeroValue int
  3368  	c := &CommitsComparison{AheadBy: &zeroValue}
  3369  	c.GetAheadBy()
  3370  	c = &CommitsComparison{}
  3371  	c.GetAheadBy()
  3372  	c = nil
  3373  	c.GetAheadBy()
  3374  }
  3375  
  3376  func TestCommitsComparison_GetBaseCommit(tt *testing.T) {
  3377  	c := &CommitsComparison{}
  3378  	c.GetBaseCommit()
  3379  	c = nil
  3380  	c.GetBaseCommit()
  3381  }
  3382  
  3383  func TestCommitsComparison_GetBehindBy(tt *testing.T) {
  3384  	var zeroValue int
  3385  	c := &CommitsComparison{BehindBy: &zeroValue}
  3386  	c.GetBehindBy()
  3387  	c = &CommitsComparison{}
  3388  	c.GetBehindBy()
  3389  	c = nil
  3390  	c.GetBehindBy()
  3391  }
  3392  
  3393  func TestCommitsComparison_GetDiffURL(tt *testing.T) {
  3394  	var zeroValue string
  3395  	c := &CommitsComparison{DiffURL: &zeroValue}
  3396  	c.GetDiffURL()
  3397  	c = &CommitsComparison{}
  3398  	c.GetDiffURL()
  3399  	c = nil
  3400  	c.GetDiffURL()
  3401  }
  3402  
  3403  func TestCommitsComparison_GetHTMLURL(tt *testing.T) {
  3404  	var zeroValue string
  3405  	c := &CommitsComparison{HTMLURL: &zeroValue}
  3406  	c.GetHTMLURL()
  3407  	c = &CommitsComparison{}
  3408  	c.GetHTMLURL()
  3409  	c = nil
  3410  	c.GetHTMLURL()
  3411  }
  3412  
  3413  func TestCommitsComparison_GetMergeBaseCommit(tt *testing.T) {
  3414  	c := &CommitsComparison{}
  3415  	c.GetMergeBaseCommit()
  3416  	c = nil
  3417  	c.GetMergeBaseCommit()
  3418  }
  3419  
  3420  func TestCommitsComparison_GetPatchURL(tt *testing.T) {
  3421  	var zeroValue string
  3422  	c := &CommitsComparison{PatchURL: &zeroValue}
  3423  	c.GetPatchURL()
  3424  	c = &CommitsComparison{}
  3425  	c.GetPatchURL()
  3426  	c = nil
  3427  	c.GetPatchURL()
  3428  }
  3429  
  3430  func TestCommitsComparison_GetPermalinkURL(tt *testing.T) {
  3431  	var zeroValue string
  3432  	c := &CommitsComparison{PermalinkURL: &zeroValue}
  3433  	c.GetPermalinkURL()
  3434  	c = &CommitsComparison{}
  3435  	c.GetPermalinkURL()
  3436  	c = nil
  3437  	c.GetPermalinkURL()
  3438  }
  3439  
  3440  func TestCommitsComparison_GetStatus(tt *testing.T) {
  3441  	var zeroValue string
  3442  	c := &CommitsComparison{Status: &zeroValue}
  3443  	c.GetStatus()
  3444  	c = &CommitsComparison{}
  3445  	c.GetStatus()
  3446  	c = nil
  3447  	c.GetStatus()
  3448  }
  3449  
  3450  func TestCommitsComparison_GetTotalCommits(tt *testing.T) {
  3451  	var zeroValue int
  3452  	c := &CommitsComparison{TotalCommits: &zeroValue}
  3453  	c.GetTotalCommits()
  3454  	c = &CommitsComparison{}
  3455  	c.GetTotalCommits()
  3456  	c = nil
  3457  	c.GetTotalCommits()
  3458  }
  3459  
  3460  func TestCommitsComparison_GetURL(tt *testing.T) {
  3461  	var zeroValue string
  3462  	c := &CommitsComparison{URL: &zeroValue}
  3463  	c.GetURL()
  3464  	c = &CommitsComparison{}
  3465  	c.GetURL()
  3466  	c = nil
  3467  	c.GetURL()
  3468  }
  3469  
  3470  func TestCommitsSearchResult_GetIncompleteResults(tt *testing.T) {
  3471  	var zeroValue bool
  3472  	c := &CommitsSearchResult{IncompleteResults: &zeroValue}
  3473  	c.GetIncompleteResults()
  3474  	c = &CommitsSearchResult{}
  3475  	c.GetIncompleteResults()
  3476  	c = nil
  3477  	c.GetIncompleteResults()
  3478  }
  3479  
  3480  func TestCommitsSearchResult_GetTotal(tt *testing.T) {
  3481  	var zeroValue int
  3482  	c := &CommitsSearchResult{Total: &zeroValue}
  3483  	c.GetTotal()
  3484  	c = &CommitsSearchResult{}
  3485  	c.GetTotal()
  3486  	c = nil
  3487  	c.GetTotal()
  3488  }
  3489  
  3490  func TestCommitStats_GetAdditions(tt *testing.T) {
  3491  	var zeroValue int
  3492  	c := &CommitStats{Additions: &zeroValue}
  3493  	c.GetAdditions()
  3494  	c = &CommitStats{}
  3495  	c.GetAdditions()
  3496  	c = nil
  3497  	c.GetAdditions()
  3498  }
  3499  
  3500  func TestCommitStats_GetDeletions(tt *testing.T) {
  3501  	var zeroValue int
  3502  	c := &CommitStats{Deletions: &zeroValue}
  3503  	c.GetDeletions()
  3504  	c = &CommitStats{}
  3505  	c.GetDeletions()
  3506  	c = nil
  3507  	c.GetDeletions()
  3508  }
  3509  
  3510  func TestCommitStats_GetTotal(tt *testing.T) {
  3511  	var zeroValue int
  3512  	c := &CommitStats{Total: &zeroValue}
  3513  	c.GetTotal()
  3514  	c = &CommitStats{}
  3515  	c.GetTotal()
  3516  	c = nil
  3517  	c.GetTotal()
  3518  }
  3519  
  3520  func TestCommunityHealthFiles_GetCodeOfConduct(tt *testing.T) {
  3521  	c := &CommunityHealthFiles{}
  3522  	c.GetCodeOfConduct()
  3523  	c = nil
  3524  	c.GetCodeOfConduct()
  3525  }
  3526  
  3527  func TestCommunityHealthFiles_GetCodeOfConductFile(tt *testing.T) {
  3528  	c := &CommunityHealthFiles{}
  3529  	c.GetCodeOfConductFile()
  3530  	c = nil
  3531  	c.GetCodeOfConductFile()
  3532  }
  3533  
  3534  func TestCommunityHealthFiles_GetContributing(tt *testing.T) {
  3535  	c := &CommunityHealthFiles{}
  3536  	c.GetContributing()
  3537  	c = nil
  3538  	c.GetContributing()
  3539  }
  3540  
  3541  func TestCommunityHealthFiles_GetIssueTemplate(tt *testing.T) {
  3542  	c := &CommunityHealthFiles{}
  3543  	c.GetIssueTemplate()
  3544  	c = nil
  3545  	c.GetIssueTemplate()
  3546  }
  3547  
  3548  func TestCommunityHealthFiles_GetLicense(tt *testing.T) {
  3549  	c := &CommunityHealthFiles{}
  3550  	c.GetLicense()
  3551  	c = nil
  3552  	c.GetLicense()
  3553  }
  3554  
  3555  func TestCommunityHealthFiles_GetPullRequestTemplate(tt *testing.T) {
  3556  	c := &CommunityHealthFiles{}
  3557  	c.GetPullRequestTemplate()
  3558  	c = nil
  3559  	c.GetPullRequestTemplate()
  3560  }
  3561  
  3562  func TestCommunityHealthFiles_GetReadme(tt *testing.T) {
  3563  	c := &CommunityHealthFiles{}
  3564  	c.GetReadme()
  3565  	c = nil
  3566  	c.GetReadme()
  3567  }
  3568  
  3569  func TestCommunityHealthMetrics_GetContentReportsEnabled(tt *testing.T) {
  3570  	var zeroValue bool
  3571  	c := &CommunityHealthMetrics{ContentReportsEnabled: &zeroValue}
  3572  	c.GetContentReportsEnabled()
  3573  	c = &CommunityHealthMetrics{}
  3574  	c.GetContentReportsEnabled()
  3575  	c = nil
  3576  	c.GetContentReportsEnabled()
  3577  }
  3578  
  3579  func TestCommunityHealthMetrics_GetDescription(tt *testing.T) {
  3580  	var zeroValue string
  3581  	c := &CommunityHealthMetrics{Description: &zeroValue}
  3582  	c.GetDescription()
  3583  	c = &CommunityHealthMetrics{}
  3584  	c.GetDescription()
  3585  	c = nil
  3586  	c.GetDescription()
  3587  }
  3588  
  3589  func TestCommunityHealthMetrics_GetDocumentation(tt *testing.T) {
  3590  	var zeroValue string
  3591  	c := &CommunityHealthMetrics{Documentation: &zeroValue}
  3592  	c.GetDocumentation()
  3593  	c = &CommunityHealthMetrics{}
  3594  	c.GetDocumentation()
  3595  	c = nil
  3596  	c.GetDocumentation()
  3597  }
  3598  
  3599  func TestCommunityHealthMetrics_GetFiles(tt *testing.T) {
  3600  	c := &CommunityHealthMetrics{}
  3601  	c.GetFiles()
  3602  	c = nil
  3603  	c.GetFiles()
  3604  }
  3605  
  3606  func TestCommunityHealthMetrics_GetHealthPercentage(tt *testing.T) {
  3607  	var zeroValue int
  3608  	c := &CommunityHealthMetrics{HealthPercentage: &zeroValue}
  3609  	c.GetHealthPercentage()
  3610  	c = &CommunityHealthMetrics{}
  3611  	c.GetHealthPercentage()
  3612  	c = nil
  3613  	c.GetHealthPercentage()
  3614  }
  3615  
  3616  func TestCommunityHealthMetrics_GetUpdatedAt(tt *testing.T) {
  3617  	var zeroValue time.Time
  3618  	c := &CommunityHealthMetrics{UpdatedAt: &zeroValue}
  3619  	c.GetUpdatedAt()
  3620  	c = &CommunityHealthMetrics{}
  3621  	c.GetUpdatedAt()
  3622  	c = nil
  3623  	c.GetUpdatedAt()
  3624  }
  3625  
  3626  func TestContentReference_GetID(tt *testing.T) {
  3627  	var zeroValue int64
  3628  	c := &ContentReference{ID: &zeroValue}
  3629  	c.GetID()
  3630  	c = &ContentReference{}
  3631  	c.GetID()
  3632  	c = nil
  3633  	c.GetID()
  3634  }
  3635  
  3636  func TestContentReference_GetNodeID(tt *testing.T) {
  3637  	var zeroValue string
  3638  	c := &ContentReference{NodeID: &zeroValue}
  3639  	c.GetNodeID()
  3640  	c = &ContentReference{}
  3641  	c.GetNodeID()
  3642  	c = nil
  3643  	c.GetNodeID()
  3644  }
  3645  
  3646  func TestContentReference_GetReference(tt *testing.T) {
  3647  	var zeroValue string
  3648  	c := &ContentReference{Reference: &zeroValue}
  3649  	c.GetReference()
  3650  	c = &ContentReference{}
  3651  	c.GetReference()
  3652  	c = nil
  3653  	c.GetReference()
  3654  }
  3655  
  3656  func TestContentReferenceEvent_GetAction(tt *testing.T) {
  3657  	var zeroValue string
  3658  	c := &ContentReferenceEvent{Action: &zeroValue}
  3659  	c.GetAction()
  3660  	c = &ContentReferenceEvent{}
  3661  	c.GetAction()
  3662  	c = nil
  3663  	c.GetAction()
  3664  }
  3665  
  3666  func TestContentReferenceEvent_GetContentReference(tt *testing.T) {
  3667  	c := &ContentReferenceEvent{}
  3668  	c.GetContentReference()
  3669  	c = nil
  3670  	c.GetContentReference()
  3671  }
  3672  
  3673  func TestContentReferenceEvent_GetInstallation(tt *testing.T) {
  3674  	c := &ContentReferenceEvent{}
  3675  	c.GetInstallation()
  3676  	c = nil
  3677  	c.GetInstallation()
  3678  }
  3679  
  3680  func TestContentReferenceEvent_GetRepo(tt *testing.T) {
  3681  	c := &ContentReferenceEvent{}
  3682  	c.GetRepo()
  3683  	c = nil
  3684  	c.GetRepo()
  3685  }
  3686  
  3687  func TestContentReferenceEvent_GetSender(tt *testing.T) {
  3688  	c := &ContentReferenceEvent{}
  3689  	c.GetSender()
  3690  	c = nil
  3691  	c.GetSender()
  3692  }
  3693  
  3694  func TestContributor_GetAvatarURL(tt *testing.T) {
  3695  	var zeroValue string
  3696  	c := &Contributor{AvatarURL: &zeroValue}
  3697  	c.GetAvatarURL()
  3698  	c = &Contributor{}
  3699  	c.GetAvatarURL()
  3700  	c = nil
  3701  	c.GetAvatarURL()
  3702  }
  3703  
  3704  func TestContributor_GetContributions(tt *testing.T) {
  3705  	var zeroValue int
  3706  	c := &Contributor{Contributions: &zeroValue}
  3707  	c.GetContributions()
  3708  	c = &Contributor{}
  3709  	c.GetContributions()
  3710  	c = nil
  3711  	c.GetContributions()
  3712  }
  3713  
  3714  func TestContributor_GetEmail(tt *testing.T) {
  3715  	var zeroValue string
  3716  	c := &Contributor{Email: &zeroValue}
  3717  	c.GetEmail()
  3718  	c = &Contributor{}
  3719  	c.GetEmail()
  3720  	c = nil
  3721  	c.GetEmail()
  3722  }
  3723  
  3724  func TestContributor_GetEventsURL(tt *testing.T) {
  3725  	var zeroValue string
  3726  	c := &Contributor{EventsURL: &zeroValue}
  3727  	c.GetEventsURL()
  3728  	c = &Contributor{}
  3729  	c.GetEventsURL()
  3730  	c = nil
  3731  	c.GetEventsURL()
  3732  }
  3733  
  3734  func TestContributor_GetFollowersURL(tt *testing.T) {
  3735  	var zeroValue string
  3736  	c := &Contributor{FollowersURL: &zeroValue}
  3737  	c.GetFollowersURL()
  3738  	c = &Contributor{}
  3739  	c.GetFollowersURL()
  3740  	c = nil
  3741  	c.GetFollowersURL()
  3742  }
  3743  
  3744  func TestContributor_GetFollowingURL(tt *testing.T) {
  3745  	var zeroValue string
  3746  	c := &Contributor{FollowingURL: &zeroValue}
  3747  	c.GetFollowingURL()
  3748  	c = &Contributor{}
  3749  	c.GetFollowingURL()
  3750  	c = nil
  3751  	c.GetFollowingURL()
  3752  }
  3753  
  3754  func TestContributor_GetGistsURL(tt *testing.T) {
  3755  	var zeroValue string
  3756  	c := &Contributor{GistsURL: &zeroValue}
  3757  	c.GetGistsURL()
  3758  	c = &Contributor{}
  3759  	c.GetGistsURL()
  3760  	c = nil
  3761  	c.GetGistsURL()
  3762  }
  3763  
  3764  func TestContributor_GetGravatarID(tt *testing.T) {
  3765  	var zeroValue string
  3766  	c := &Contributor{GravatarID: &zeroValue}
  3767  	c.GetGravatarID()
  3768  	c = &Contributor{}
  3769  	c.GetGravatarID()
  3770  	c = nil
  3771  	c.GetGravatarID()
  3772  }
  3773  
  3774  func TestContributor_GetHTMLURL(tt *testing.T) {
  3775  	var zeroValue string
  3776  	c := &Contributor{HTMLURL: &zeroValue}
  3777  	c.GetHTMLURL()
  3778  	c = &Contributor{}
  3779  	c.GetHTMLURL()
  3780  	c = nil
  3781  	c.GetHTMLURL()
  3782  }
  3783  
  3784  func TestContributor_GetID(tt *testing.T) {
  3785  	var zeroValue int64
  3786  	c := &Contributor{ID: &zeroValue}
  3787  	c.GetID()
  3788  	c = &Contributor{}
  3789  	c.GetID()
  3790  	c = nil
  3791  	c.GetID()
  3792  }
  3793  
  3794  func TestContributor_GetLogin(tt *testing.T) {
  3795  	var zeroValue string
  3796  	c := &Contributor{Login: &zeroValue}
  3797  	c.GetLogin()
  3798  	c = &Contributor{}
  3799  	c.GetLogin()
  3800  	c = nil
  3801  	c.GetLogin()
  3802  }
  3803  
  3804  func TestContributor_GetName(tt *testing.T) {
  3805  	var zeroValue string
  3806  	c := &Contributor{Name: &zeroValue}
  3807  	c.GetName()
  3808  	c = &Contributor{}
  3809  	c.GetName()
  3810  	c = nil
  3811  	c.GetName()
  3812  }
  3813  
  3814  func TestContributor_GetNodeID(tt *testing.T) {
  3815  	var zeroValue string
  3816  	c := &Contributor{NodeID: &zeroValue}
  3817  	c.GetNodeID()
  3818  	c = &Contributor{}
  3819  	c.GetNodeID()
  3820  	c = nil
  3821  	c.GetNodeID()
  3822  }
  3823  
  3824  func TestContributor_GetOrganizationsURL(tt *testing.T) {
  3825  	var zeroValue string
  3826  	c := &Contributor{OrganizationsURL: &zeroValue}
  3827  	c.GetOrganizationsURL()
  3828  	c = &Contributor{}
  3829  	c.GetOrganizationsURL()
  3830  	c = nil
  3831  	c.GetOrganizationsURL()
  3832  }
  3833  
  3834  func TestContributor_GetReceivedEventsURL(tt *testing.T) {
  3835  	var zeroValue string
  3836  	c := &Contributor{ReceivedEventsURL: &zeroValue}
  3837  	c.GetReceivedEventsURL()
  3838  	c = &Contributor{}
  3839  	c.GetReceivedEventsURL()
  3840  	c = nil
  3841  	c.GetReceivedEventsURL()
  3842  }
  3843  
  3844  func TestContributor_GetReposURL(tt *testing.T) {
  3845  	var zeroValue string
  3846  	c := &Contributor{ReposURL: &zeroValue}
  3847  	c.GetReposURL()
  3848  	c = &Contributor{}
  3849  	c.GetReposURL()
  3850  	c = nil
  3851  	c.GetReposURL()
  3852  }
  3853  
  3854  func TestContributor_GetSiteAdmin(tt *testing.T) {
  3855  	var zeroValue bool
  3856  	c := &Contributor{SiteAdmin: &zeroValue}
  3857  	c.GetSiteAdmin()
  3858  	c = &Contributor{}
  3859  	c.GetSiteAdmin()
  3860  	c = nil
  3861  	c.GetSiteAdmin()
  3862  }
  3863  
  3864  func TestContributor_GetStarredURL(tt *testing.T) {
  3865  	var zeroValue string
  3866  	c := &Contributor{StarredURL: &zeroValue}
  3867  	c.GetStarredURL()
  3868  	c = &Contributor{}
  3869  	c.GetStarredURL()
  3870  	c = nil
  3871  	c.GetStarredURL()
  3872  }
  3873  
  3874  func TestContributor_GetSubscriptionsURL(tt *testing.T) {
  3875  	var zeroValue string
  3876  	c := &Contributor{SubscriptionsURL: &zeroValue}
  3877  	c.GetSubscriptionsURL()
  3878  	c = &Contributor{}
  3879  	c.GetSubscriptionsURL()
  3880  	c = nil
  3881  	c.GetSubscriptionsURL()
  3882  }
  3883  
  3884  func TestContributor_GetType(tt *testing.T) {
  3885  	var zeroValue string
  3886  	c := &Contributor{Type: &zeroValue}
  3887  	c.GetType()
  3888  	c = &Contributor{}
  3889  	c.GetType()
  3890  	c = nil
  3891  	c.GetType()
  3892  }
  3893  
  3894  func TestContributor_GetURL(tt *testing.T) {
  3895  	var zeroValue string
  3896  	c := &Contributor{URL: &zeroValue}
  3897  	c.GetURL()
  3898  	c = &Contributor{}
  3899  	c.GetURL()
  3900  	c = nil
  3901  	c.GetURL()
  3902  }
  3903  
  3904  func TestContributorStats_GetAuthor(tt *testing.T) {
  3905  	c := &ContributorStats{}
  3906  	c.GetAuthor()
  3907  	c = nil
  3908  	c.GetAuthor()
  3909  }
  3910  
  3911  func TestContributorStats_GetTotal(tt *testing.T) {
  3912  	var zeroValue int
  3913  	c := &ContributorStats{Total: &zeroValue}
  3914  	c.GetTotal()
  3915  	c = &ContributorStats{}
  3916  	c.GetTotal()
  3917  	c = nil
  3918  	c.GetTotal()
  3919  }
  3920  
  3921  func TestCreateCheckRunOptions_GetCompletedAt(tt *testing.T) {
  3922  	var zeroValue Timestamp
  3923  	c := &CreateCheckRunOptions{CompletedAt: &zeroValue}
  3924  	c.GetCompletedAt()
  3925  	c = &CreateCheckRunOptions{}
  3926  	c.GetCompletedAt()
  3927  	c = nil
  3928  	c.GetCompletedAt()
  3929  }
  3930  
  3931  func TestCreateCheckRunOptions_GetConclusion(tt *testing.T) {
  3932  	var zeroValue string
  3933  	c := &CreateCheckRunOptions{Conclusion: &zeroValue}
  3934  	c.GetConclusion()
  3935  	c = &CreateCheckRunOptions{}
  3936  	c.GetConclusion()
  3937  	c = nil
  3938  	c.GetConclusion()
  3939  }
  3940  
  3941  func TestCreateCheckRunOptions_GetDetailsURL(tt *testing.T) {
  3942  	var zeroValue string
  3943  	c := &CreateCheckRunOptions{DetailsURL: &zeroValue}
  3944  	c.GetDetailsURL()
  3945  	c = &CreateCheckRunOptions{}
  3946  	c.GetDetailsURL()
  3947  	c = nil
  3948  	c.GetDetailsURL()
  3949  }
  3950  
  3951  func TestCreateCheckRunOptions_GetExternalID(tt *testing.T) {
  3952  	var zeroValue string
  3953  	c := &CreateCheckRunOptions{ExternalID: &zeroValue}
  3954  	c.GetExternalID()
  3955  	c = &CreateCheckRunOptions{}
  3956  	c.GetExternalID()
  3957  	c = nil
  3958  	c.GetExternalID()
  3959  }
  3960  
  3961  func TestCreateCheckRunOptions_GetOutput(tt *testing.T) {
  3962  	c := &CreateCheckRunOptions{}
  3963  	c.GetOutput()
  3964  	c = nil
  3965  	c.GetOutput()
  3966  }
  3967  
  3968  func TestCreateCheckRunOptions_GetStartedAt(tt *testing.T) {
  3969  	var zeroValue Timestamp
  3970  	c := &CreateCheckRunOptions{StartedAt: &zeroValue}
  3971  	c.GetStartedAt()
  3972  	c = &CreateCheckRunOptions{}
  3973  	c.GetStartedAt()
  3974  	c = nil
  3975  	c.GetStartedAt()
  3976  }
  3977  
  3978  func TestCreateCheckRunOptions_GetStatus(tt *testing.T) {
  3979  	var zeroValue string
  3980  	c := &CreateCheckRunOptions{Status: &zeroValue}
  3981  	c.GetStatus()
  3982  	c = &CreateCheckRunOptions{}
  3983  	c.GetStatus()
  3984  	c = nil
  3985  	c.GetStatus()
  3986  }
  3987  
  3988  func TestCreateCheckSuiteOptions_GetHeadBranch(tt *testing.T) {
  3989  	var zeroValue string
  3990  	c := &CreateCheckSuiteOptions{HeadBranch: &zeroValue}
  3991  	c.GetHeadBranch()
  3992  	c = &CreateCheckSuiteOptions{}
  3993  	c.GetHeadBranch()
  3994  	c = nil
  3995  	c.GetHeadBranch()
  3996  }
  3997  
  3998  func TestCreateEvent_GetDescription(tt *testing.T) {
  3999  	var zeroValue string
  4000  	c := &CreateEvent{Description: &zeroValue}
  4001  	c.GetDescription()
  4002  	c = &CreateEvent{}
  4003  	c.GetDescription()
  4004  	c = nil
  4005  	c.GetDescription()
  4006  }
  4007  
  4008  func TestCreateEvent_GetInstallation(tt *testing.T) {
  4009  	c := &CreateEvent{}
  4010  	c.GetInstallation()
  4011  	c = nil
  4012  	c.GetInstallation()
  4013  }
  4014  
  4015  func TestCreateEvent_GetMasterBranch(tt *testing.T) {
  4016  	var zeroValue string
  4017  	c := &CreateEvent{MasterBranch: &zeroValue}
  4018  	c.GetMasterBranch()
  4019  	c = &CreateEvent{}
  4020  	c.GetMasterBranch()
  4021  	c = nil
  4022  	c.GetMasterBranch()
  4023  }
  4024  
  4025  func TestCreateEvent_GetOrg(tt *testing.T) {
  4026  	c := &CreateEvent{}
  4027  	c.GetOrg()
  4028  	c = nil
  4029  	c.GetOrg()
  4030  }
  4031  
  4032  func TestCreateEvent_GetPusherType(tt *testing.T) {
  4033  	var zeroValue string
  4034  	c := &CreateEvent{PusherType: &zeroValue}
  4035  	c.GetPusherType()
  4036  	c = &CreateEvent{}
  4037  	c.GetPusherType()
  4038  	c = nil
  4039  	c.GetPusherType()
  4040  }
  4041  
  4042  func TestCreateEvent_GetRef(tt *testing.T) {
  4043  	var zeroValue string
  4044  	c := &CreateEvent{Ref: &zeroValue}
  4045  	c.GetRef()
  4046  	c = &CreateEvent{}
  4047  	c.GetRef()
  4048  	c = nil
  4049  	c.GetRef()
  4050  }
  4051  
  4052  func TestCreateEvent_GetRefType(tt *testing.T) {
  4053  	var zeroValue string
  4054  	c := &CreateEvent{RefType: &zeroValue}
  4055  	c.GetRefType()
  4056  	c = &CreateEvent{}
  4057  	c.GetRefType()
  4058  	c = nil
  4059  	c.GetRefType()
  4060  }
  4061  
  4062  func TestCreateEvent_GetRepo(tt *testing.T) {
  4063  	c := &CreateEvent{}
  4064  	c.GetRepo()
  4065  	c = nil
  4066  	c.GetRepo()
  4067  }
  4068  
  4069  func TestCreateEvent_GetSender(tt *testing.T) {
  4070  	c := &CreateEvent{}
  4071  	c.GetSender()
  4072  	c = nil
  4073  	c.GetSender()
  4074  }
  4075  
  4076  func TestCreateOrgInvitationOptions_GetEmail(tt *testing.T) {
  4077  	var zeroValue string
  4078  	c := &CreateOrgInvitationOptions{Email: &zeroValue}
  4079  	c.GetEmail()
  4080  	c = &CreateOrgInvitationOptions{}
  4081  	c.GetEmail()
  4082  	c = nil
  4083  	c.GetEmail()
  4084  }
  4085  
  4086  func TestCreateOrgInvitationOptions_GetInviteeID(tt *testing.T) {
  4087  	var zeroValue int64
  4088  	c := &CreateOrgInvitationOptions{InviteeID: &zeroValue}
  4089  	c.GetInviteeID()
  4090  	c = &CreateOrgInvitationOptions{}
  4091  	c.GetInviteeID()
  4092  	c = nil
  4093  	c.GetInviteeID()
  4094  }
  4095  
  4096  func TestCreateOrgInvitationOptions_GetRole(tt *testing.T) {
  4097  	var zeroValue string
  4098  	c := &CreateOrgInvitationOptions{Role: &zeroValue}
  4099  	c.GetRole()
  4100  	c = &CreateOrgInvitationOptions{}
  4101  	c.GetRole()
  4102  	c = nil
  4103  	c.GetRole()
  4104  }
  4105  
  4106  func TestCreateRunnerGroupRequest_GetAllowsPublicRepositories(tt *testing.T) {
  4107  	var zeroValue bool
  4108  	c := &CreateRunnerGroupRequest{AllowsPublicRepositories: &zeroValue}
  4109  	c.GetAllowsPublicRepositories()
  4110  	c = &CreateRunnerGroupRequest{}
  4111  	c.GetAllowsPublicRepositories()
  4112  	c = nil
  4113  	c.GetAllowsPublicRepositories()
  4114  }
  4115  
  4116  func TestCreateRunnerGroupRequest_GetName(tt *testing.T) {
  4117  	var zeroValue string
  4118  	c := &CreateRunnerGroupRequest{Name: &zeroValue}
  4119  	c.GetName()
  4120  	c = &CreateRunnerGroupRequest{}
  4121  	c.GetName()
  4122  	c = nil
  4123  	c.GetName()
  4124  }
  4125  
  4126  func TestCreateRunnerGroupRequest_GetVisibility(tt *testing.T) {
  4127  	var zeroValue string
  4128  	c := &CreateRunnerGroupRequest{Visibility: &zeroValue}
  4129  	c.GetVisibility()
  4130  	c = &CreateRunnerGroupRequest{}
  4131  	c.GetVisibility()
  4132  	c = nil
  4133  	c.GetVisibility()
  4134  }
  4135  
  4136  func TestCreateUpdateEnvironment_GetDeploymentBranchPolicy(tt *testing.T) {
  4137  	c := &CreateUpdateEnvironment{}
  4138  	c.GetDeploymentBranchPolicy()
  4139  	c = nil
  4140  	c.GetDeploymentBranchPolicy()
  4141  }
  4142  
  4143  func TestCreateUpdateEnvironment_GetWaitTimer(tt *testing.T) {
  4144  	var zeroValue int
  4145  	c := &CreateUpdateEnvironment{WaitTimer: &zeroValue}
  4146  	c.GetWaitTimer()
  4147  	c = &CreateUpdateEnvironment{}
  4148  	c.GetWaitTimer()
  4149  	c = nil
  4150  	c.GetWaitTimer()
  4151  }
  4152  
  4153  func TestCreateUserProjectOptions_GetBody(tt *testing.T) {
  4154  	var zeroValue string
  4155  	c := &CreateUserProjectOptions{Body: &zeroValue}
  4156  	c.GetBody()
  4157  	c = &CreateUserProjectOptions{}
  4158  	c.GetBody()
  4159  	c = nil
  4160  	c.GetBody()
  4161  }
  4162  
  4163  func TestCustomRepoRoles_GetID(tt *testing.T) {
  4164  	var zeroValue int64
  4165  	c := &CustomRepoRoles{ID: &zeroValue}
  4166  	c.GetID()
  4167  	c = &CustomRepoRoles{}
  4168  	c.GetID()
  4169  	c = nil
  4170  	c.GetID()
  4171  }
  4172  
  4173  func TestCustomRepoRoles_GetName(tt *testing.T) {
  4174  	var zeroValue string
  4175  	c := &CustomRepoRoles{Name: &zeroValue}
  4176  	c.GetName()
  4177  	c = &CustomRepoRoles{}
  4178  	c.GetName()
  4179  	c = nil
  4180  	c.GetName()
  4181  }
  4182  
  4183  func TestDeleteEvent_GetInstallation(tt *testing.T) {
  4184  	d := &DeleteEvent{}
  4185  	d.GetInstallation()
  4186  	d = nil
  4187  	d.GetInstallation()
  4188  }
  4189  
  4190  func TestDeleteEvent_GetPusherType(tt *testing.T) {
  4191  	var zeroValue string
  4192  	d := &DeleteEvent{PusherType: &zeroValue}
  4193  	d.GetPusherType()
  4194  	d = &DeleteEvent{}
  4195  	d.GetPusherType()
  4196  	d = nil
  4197  	d.GetPusherType()
  4198  }
  4199  
  4200  func TestDeleteEvent_GetRef(tt *testing.T) {
  4201  	var zeroValue string
  4202  	d := &DeleteEvent{Ref: &zeroValue}
  4203  	d.GetRef()
  4204  	d = &DeleteEvent{}
  4205  	d.GetRef()
  4206  	d = nil
  4207  	d.GetRef()
  4208  }
  4209  
  4210  func TestDeleteEvent_GetRefType(tt *testing.T) {
  4211  	var zeroValue string
  4212  	d := &DeleteEvent{RefType: &zeroValue}
  4213  	d.GetRefType()
  4214  	d = &DeleteEvent{}
  4215  	d.GetRefType()
  4216  	d = nil
  4217  	d.GetRefType()
  4218  }
  4219  
  4220  func TestDeleteEvent_GetRepo(tt *testing.T) {
  4221  	d := &DeleteEvent{}
  4222  	d.GetRepo()
  4223  	d = nil
  4224  	d.GetRepo()
  4225  }
  4226  
  4227  func TestDeleteEvent_GetSender(tt *testing.T) {
  4228  	d := &DeleteEvent{}
  4229  	d.GetSender()
  4230  	d = nil
  4231  	d.GetSender()
  4232  }
  4233  
  4234  func TestDeployKeyEvent_GetAction(tt *testing.T) {
  4235  	var zeroValue string
  4236  	d := &DeployKeyEvent{Action: &zeroValue}
  4237  	d.GetAction()
  4238  	d = &DeployKeyEvent{}
  4239  	d.GetAction()
  4240  	d = nil
  4241  	d.GetAction()
  4242  }
  4243  
  4244  func TestDeployKeyEvent_GetInstallation(tt *testing.T) {
  4245  	d := &DeployKeyEvent{}
  4246  	d.GetInstallation()
  4247  	d = nil
  4248  	d.GetInstallation()
  4249  }
  4250  
  4251  func TestDeployKeyEvent_GetKey(tt *testing.T) {
  4252  	d := &DeployKeyEvent{}
  4253  	d.GetKey()
  4254  	d = nil
  4255  	d.GetKey()
  4256  }
  4257  
  4258  func TestDeployKeyEvent_GetOrganization(tt *testing.T) {
  4259  	d := &DeployKeyEvent{}
  4260  	d.GetOrganization()
  4261  	d = nil
  4262  	d.GetOrganization()
  4263  }
  4264  
  4265  func TestDeployKeyEvent_GetRepo(tt *testing.T) {
  4266  	d := &DeployKeyEvent{}
  4267  	d.GetRepo()
  4268  	d = nil
  4269  	d.GetRepo()
  4270  }
  4271  
  4272  func TestDeployKeyEvent_GetSender(tt *testing.T) {
  4273  	d := &DeployKeyEvent{}
  4274  	d.GetSender()
  4275  	d = nil
  4276  	d.GetSender()
  4277  }
  4278  
  4279  func TestDeployment_GetCreatedAt(tt *testing.T) {
  4280  	var zeroValue Timestamp
  4281  	d := &Deployment{CreatedAt: &zeroValue}
  4282  	d.GetCreatedAt()
  4283  	d = &Deployment{}
  4284  	d.GetCreatedAt()
  4285  	d = nil
  4286  	d.GetCreatedAt()
  4287  }
  4288  
  4289  func TestDeployment_GetCreator(tt *testing.T) {
  4290  	d := &Deployment{}
  4291  	d.GetCreator()
  4292  	d = nil
  4293  	d.GetCreator()
  4294  }
  4295  
  4296  func TestDeployment_GetDescription(tt *testing.T) {
  4297  	var zeroValue string
  4298  	d := &Deployment{Description: &zeroValue}
  4299  	d.GetDescription()
  4300  	d = &Deployment{}
  4301  	d.GetDescription()
  4302  	d = nil
  4303  	d.GetDescription()
  4304  }
  4305  
  4306  func TestDeployment_GetEnvironment(tt *testing.T) {
  4307  	var zeroValue string
  4308  	d := &Deployment{Environment: &zeroValue}
  4309  	d.GetEnvironment()
  4310  	d = &Deployment{}
  4311  	d.GetEnvironment()
  4312  	d = nil
  4313  	d.GetEnvironment()
  4314  }
  4315  
  4316  func TestDeployment_GetID(tt *testing.T) {
  4317  	var zeroValue int64
  4318  	d := &Deployment{ID: &zeroValue}
  4319  	d.GetID()
  4320  	d = &Deployment{}
  4321  	d.GetID()
  4322  	d = nil
  4323  	d.GetID()
  4324  }
  4325  
  4326  func TestDeployment_GetNodeID(tt *testing.T) {
  4327  	var zeroValue string
  4328  	d := &Deployment{NodeID: &zeroValue}
  4329  	d.GetNodeID()
  4330  	d = &Deployment{}
  4331  	d.GetNodeID()
  4332  	d = nil
  4333  	d.GetNodeID()
  4334  }
  4335  
  4336  func TestDeployment_GetRef(tt *testing.T) {
  4337  	var zeroValue string
  4338  	d := &Deployment{Ref: &zeroValue}
  4339  	d.GetRef()
  4340  	d = &Deployment{}
  4341  	d.GetRef()
  4342  	d = nil
  4343  	d.GetRef()
  4344  }
  4345  
  4346  func TestDeployment_GetRepositoryURL(tt *testing.T) {
  4347  	var zeroValue string
  4348  	d := &Deployment{RepositoryURL: &zeroValue}
  4349  	d.GetRepositoryURL()
  4350  	d = &Deployment{}
  4351  	d.GetRepositoryURL()
  4352  	d = nil
  4353  	d.GetRepositoryURL()
  4354  }
  4355  
  4356  func TestDeployment_GetSHA(tt *testing.T) {
  4357  	var zeroValue string
  4358  	d := &Deployment{SHA: &zeroValue}
  4359  	d.GetSHA()
  4360  	d = &Deployment{}
  4361  	d.GetSHA()
  4362  	d = nil
  4363  	d.GetSHA()
  4364  }
  4365  
  4366  func TestDeployment_GetStatusesURL(tt *testing.T) {
  4367  	var zeroValue string
  4368  	d := &Deployment{StatusesURL: &zeroValue}
  4369  	d.GetStatusesURL()
  4370  	d = &Deployment{}
  4371  	d.GetStatusesURL()
  4372  	d = nil
  4373  	d.GetStatusesURL()
  4374  }
  4375  
  4376  func TestDeployment_GetTask(tt *testing.T) {
  4377  	var zeroValue string
  4378  	d := &Deployment{Task: &zeroValue}
  4379  	d.GetTask()
  4380  	d = &Deployment{}
  4381  	d.GetTask()
  4382  	d = nil
  4383  	d.GetTask()
  4384  }
  4385  
  4386  func TestDeployment_GetUpdatedAt(tt *testing.T) {
  4387  	var zeroValue Timestamp
  4388  	d := &Deployment{UpdatedAt: &zeroValue}
  4389  	d.GetUpdatedAt()
  4390  	d = &Deployment{}
  4391  	d.GetUpdatedAt()
  4392  	d = nil
  4393  	d.GetUpdatedAt()
  4394  }
  4395  
  4396  func TestDeployment_GetURL(tt *testing.T) {
  4397  	var zeroValue string
  4398  	d := &Deployment{URL: &zeroValue}
  4399  	d.GetURL()
  4400  	d = &Deployment{}
  4401  	d.GetURL()
  4402  	d = nil
  4403  	d.GetURL()
  4404  }
  4405  
  4406  func TestDeploymentEvent_GetDeployment(tt *testing.T) {
  4407  	d := &DeploymentEvent{}
  4408  	d.GetDeployment()
  4409  	d = nil
  4410  	d.GetDeployment()
  4411  }
  4412  
  4413  func TestDeploymentEvent_GetInstallation(tt *testing.T) {
  4414  	d := &DeploymentEvent{}
  4415  	d.GetInstallation()
  4416  	d = nil
  4417  	d.GetInstallation()
  4418  }
  4419  
  4420  func TestDeploymentEvent_GetRepo(tt *testing.T) {
  4421  	d := &DeploymentEvent{}
  4422  	d.GetRepo()
  4423  	d = nil
  4424  	d.GetRepo()
  4425  }
  4426  
  4427  func TestDeploymentEvent_GetSender(tt *testing.T) {
  4428  	d := &DeploymentEvent{}
  4429  	d.GetSender()
  4430  	d = nil
  4431  	d.GetSender()
  4432  }
  4433  
  4434  func TestDeploymentRequest_GetAutoMerge(tt *testing.T) {
  4435  	var zeroValue bool
  4436  	d := &DeploymentRequest{AutoMerge: &zeroValue}
  4437  	d.GetAutoMerge()
  4438  	d = &DeploymentRequest{}
  4439  	d.GetAutoMerge()
  4440  	d = nil
  4441  	d.GetAutoMerge()
  4442  }
  4443  
  4444  func TestDeploymentRequest_GetDescription(tt *testing.T) {
  4445  	var zeroValue string
  4446  	d := &DeploymentRequest{Description: &zeroValue}
  4447  	d.GetDescription()
  4448  	d = &DeploymentRequest{}
  4449  	d.GetDescription()
  4450  	d = nil
  4451  	d.GetDescription()
  4452  }
  4453  
  4454  func TestDeploymentRequest_GetEnvironment(tt *testing.T) {
  4455  	var zeroValue string
  4456  	d := &DeploymentRequest{Environment: &zeroValue}
  4457  	d.GetEnvironment()
  4458  	d = &DeploymentRequest{}
  4459  	d.GetEnvironment()
  4460  	d = nil
  4461  	d.GetEnvironment()
  4462  }
  4463  
  4464  func TestDeploymentRequest_GetProductionEnvironment(tt *testing.T) {
  4465  	var zeroValue bool
  4466  	d := &DeploymentRequest{ProductionEnvironment: &zeroValue}
  4467  	d.GetProductionEnvironment()
  4468  	d = &DeploymentRequest{}
  4469  	d.GetProductionEnvironment()
  4470  	d = nil
  4471  	d.GetProductionEnvironment()
  4472  }
  4473  
  4474  func TestDeploymentRequest_GetRef(tt *testing.T) {
  4475  	var zeroValue string
  4476  	d := &DeploymentRequest{Ref: &zeroValue}
  4477  	d.GetRef()
  4478  	d = &DeploymentRequest{}
  4479  	d.GetRef()
  4480  	d = nil
  4481  	d.GetRef()
  4482  }
  4483  
  4484  func TestDeploymentRequest_GetRequiredContexts(tt *testing.T) {
  4485  	var zeroValue []string
  4486  	d := &DeploymentRequest{RequiredContexts: &zeroValue}
  4487  	d.GetRequiredContexts()
  4488  	d = &DeploymentRequest{}
  4489  	d.GetRequiredContexts()
  4490  	d = nil
  4491  	d.GetRequiredContexts()
  4492  }
  4493  
  4494  func TestDeploymentRequest_GetTask(tt *testing.T) {
  4495  	var zeroValue string
  4496  	d := &DeploymentRequest{Task: &zeroValue}
  4497  	d.GetTask()
  4498  	d = &DeploymentRequest{}
  4499  	d.GetTask()
  4500  	d = nil
  4501  	d.GetTask()
  4502  }
  4503  
  4504  func TestDeploymentRequest_GetTransientEnvironment(tt *testing.T) {
  4505  	var zeroValue bool
  4506  	d := &DeploymentRequest{TransientEnvironment: &zeroValue}
  4507  	d.GetTransientEnvironment()
  4508  	d = &DeploymentRequest{}
  4509  	d.GetTransientEnvironment()
  4510  	d = nil
  4511  	d.GetTransientEnvironment()
  4512  }
  4513  
  4514  func TestDeploymentStatus_GetCreatedAt(tt *testing.T) {
  4515  	var zeroValue Timestamp
  4516  	d := &DeploymentStatus{CreatedAt: &zeroValue}
  4517  	d.GetCreatedAt()
  4518  	d = &DeploymentStatus{}
  4519  	d.GetCreatedAt()
  4520  	d = nil
  4521  	d.GetCreatedAt()
  4522  }
  4523  
  4524  func TestDeploymentStatus_GetCreator(tt *testing.T) {
  4525  	d := &DeploymentStatus{}
  4526  	d.GetCreator()
  4527  	d = nil
  4528  	d.GetCreator()
  4529  }
  4530  
  4531  func TestDeploymentStatus_GetDeploymentURL(tt *testing.T) {
  4532  	var zeroValue string
  4533  	d := &DeploymentStatus{DeploymentURL: &zeroValue}
  4534  	d.GetDeploymentURL()
  4535  	d = &DeploymentStatus{}
  4536  	d.GetDeploymentURL()
  4537  	d = nil
  4538  	d.GetDeploymentURL()
  4539  }
  4540  
  4541  func TestDeploymentStatus_GetDescription(tt *testing.T) {
  4542  	var zeroValue string
  4543  	d := &DeploymentStatus{Description: &zeroValue}
  4544  	d.GetDescription()
  4545  	d = &DeploymentStatus{}
  4546  	d.GetDescription()
  4547  	d = nil
  4548  	d.GetDescription()
  4549  }
  4550  
  4551  func TestDeploymentStatus_GetEnvironment(tt *testing.T) {
  4552  	var zeroValue string
  4553  	d := &DeploymentStatus{Environment: &zeroValue}
  4554  	d.GetEnvironment()
  4555  	d = &DeploymentStatus{}
  4556  	d.GetEnvironment()
  4557  	d = nil
  4558  	d.GetEnvironment()
  4559  }
  4560  
  4561  func TestDeploymentStatus_GetEnvironmentURL(tt *testing.T) {
  4562  	var zeroValue string
  4563  	d := &DeploymentStatus{EnvironmentURL: &zeroValue}
  4564  	d.GetEnvironmentURL()
  4565  	d = &DeploymentStatus{}
  4566  	d.GetEnvironmentURL()
  4567  	d = nil
  4568  	d.GetEnvironmentURL()
  4569  }
  4570  
  4571  func TestDeploymentStatus_GetID(tt *testing.T) {
  4572  	var zeroValue int64
  4573  	d := &DeploymentStatus{ID: &zeroValue}
  4574  	d.GetID()
  4575  	d = &DeploymentStatus{}
  4576  	d.GetID()
  4577  	d = nil
  4578  	d.GetID()
  4579  }
  4580  
  4581  func TestDeploymentStatus_GetLogURL(tt *testing.T) {
  4582  	var zeroValue string
  4583  	d := &DeploymentStatus{LogURL: &zeroValue}
  4584  	d.GetLogURL()
  4585  	d = &DeploymentStatus{}
  4586  	d.GetLogURL()
  4587  	d = nil
  4588  	d.GetLogURL()
  4589  }
  4590  
  4591  func TestDeploymentStatus_GetNodeID(tt *testing.T) {
  4592  	var zeroValue string
  4593  	d := &DeploymentStatus{NodeID: &zeroValue}
  4594  	d.GetNodeID()
  4595  	d = &DeploymentStatus{}
  4596  	d.GetNodeID()
  4597  	d = nil
  4598  	d.GetNodeID()
  4599  }
  4600  
  4601  func TestDeploymentStatus_GetRepositoryURL(tt *testing.T) {
  4602  	var zeroValue string
  4603  	d := &DeploymentStatus{RepositoryURL: &zeroValue}
  4604  	d.GetRepositoryURL()
  4605  	d = &DeploymentStatus{}
  4606  	d.GetRepositoryURL()
  4607  	d = nil
  4608  	d.GetRepositoryURL()
  4609  }
  4610  
  4611  func TestDeploymentStatus_GetState(tt *testing.T) {
  4612  	var zeroValue string
  4613  	d := &DeploymentStatus{State: &zeroValue}
  4614  	d.GetState()
  4615  	d = &DeploymentStatus{}
  4616  	d.GetState()
  4617  	d = nil
  4618  	d.GetState()
  4619  }
  4620  
  4621  func TestDeploymentStatus_GetTargetURL(tt *testing.T) {
  4622  	var zeroValue string
  4623  	d := &DeploymentStatus{TargetURL: &zeroValue}
  4624  	d.GetTargetURL()
  4625  	d = &DeploymentStatus{}
  4626  	d.GetTargetURL()
  4627  	d = nil
  4628  	d.GetTargetURL()
  4629  }
  4630  
  4631  func TestDeploymentStatus_GetUpdatedAt(tt *testing.T) {
  4632  	var zeroValue Timestamp
  4633  	d := &DeploymentStatus{UpdatedAt: &zeroValue}
  4634  	d.GetUpdatedAt()
  4635  	d = &DeploymentStatus{}
  4636  	d.GetUpdatedAt()
  4637  	d = nil
  4638  	d.GetUpdatedAt()
  4639  }
  4640  
  4641  func TestDeploymentStatus_GetURL(tt *testing.T) {
  4642  	var zeroValue string
  4643  	d := &DeploymentStatus{URL: &zeroValue}
  4644  	d.GetURL()
  4645  	d = &DeploymentStatus{}
  4646  	d.GetURL()
  4647  	d = nil
  4648  	d.GetURL()
  4649  }
  4650  
  4651  func TestDeploymentStatusEvent_GetDeployment(tt *testing.T) {
  4652  	d := &DeploymentStatusEvent{}
  4653  	d.GetDeployment()
  4654  	d = nil
  4655  	d.GetDeployment()
  4656  }
  4657  
  4658  func TestDeploymentStatusEvent_GetDeploymentStatus(tt *testing.T) {
  4659  	d := &DeploymentStatusEvent{}
  4660  	d.GetDeploymentStatus()
  4661  	d = nil
  4662  	d.GetDeploymentStatus()
  4663  }
  4664  
  4665  func TestDeploymentStatusEvent_GetInstallation(tt *testing.T) {
  4666  	d := &DeploymentStatusEvent{}
  4667  	d.GetInstallation()
  4668  	d = nil
  4669  	d.GetInstallation()
  4670  }
  4671  
  4672  func TestDeploymentStatusEvent_GetRepo(tt *testing.T) {
  4673  	d := &DeploymentStatusEvent{}
  4674  	d.GetRepo()
  4675  	d = nil
  4676  	d.GetRepo()
  4677  }
  4678  
  4679  func TestDeploymentStatusEvent_GetSender(tt *testing.T) {
  4680  	d := &DeploymentStatusEvent{}
  4681  	d.GetSender()
  4682  	d = nil
  4683  	d.GetSender()
  4684  }
  4685  
  4686  func TestDeploymentStatusRequest_GetAutoInactive(tt *testing.T) {
  4687  	var zeroValue bool
  4688  	d := &DeploymentStatusRequest{AutoInactive: &zeroValue}
  4689  	d.GetAutoInactive()
  4690  	d = &DeploymentStatusRequest{}
  4691  	d.GetAutoInactive()
  4692  	d = nil
  4693  	d.GetAutoInactive()
  4694  }
  4695  
  4696  func TestDeploymentStatusRequest_GetDescription(tt *testing.T) {
  4697  	var zeroValue string
  4698  	d := &DeploymentStatusRequest{Description: &zeroValue}
  4699  	d.GetDescription()
  4700  	d = &DeploymentStatusRequest{}
  4701  	d.GetDescription()
  4702  	d = nil
  4703  	d.GetDescription()
  4704  }
  4705  
  4706  func TestDeploymentStatusRequest_GetEnvironment(tt *testing.T) {
  4707  	var zeroValue string
  4708  	d := &DeploymentStatusRequest{Environment: &zeroValue}
  4709  	d.GetEnvironment()
  4710  	d = &DeploymentStatusRequest{}
  4711  	d.GetEnvironment()
  4712  	d = nil
  4713  	d.GetEnvironment()
  4714  }
  4715  
  4716  func TestDeploymentStatusRequest_GetEnvironmentURL(tt *testing.T) {
  4717  	var zeroValue string
  4718  	d := &DeploymentStatusRequest{EnvironmentURL: &zeroValue}
  4719  	d.GetEnvironmentURL()
  4720  	d = &DeploymentStatusRequest{}
  4721  	d.GetEnvironmentURL()
  4722  	d = nil
  4723  	d.GetEnvironmentURL()
  4724  }
  4725  
  4726  func TestDeploymentStatusRequest_GetLogURL(tt *testing.T) {
  4727  	var zeroValue string
  4728  	d := &DeploymentStatusRequest{LogURL: &zeroValue}
  4729  	d.GetLogURL()
  4730  	d = &DeploymentStatusRequest{}
  4731  	d.GetLogURL()
  4732  	d = nil
  4733  	d.GetLogURL()
  4734  }
  4735  
  4736  func TestDeploymentStatusRequest_GetState(tt *testing.T) {
  4737  	var zeroValue string
  4738  	d := &DeploymentStatusRequest{State: &zeroValue}
  4739  	d.GetState()
  4740  	d = &DeploymentStatusRequest{}
  4741  	d.GetState()
  4742  	d = nil
  4743  	d.GetState()
  4744  }
  4745  
  4746  func TestDiscussion_GetActiveLockReason(tt *testing.T) {
  4747  	var zeroValue string
  4748  	d := &Discussion{ActiveLockReason: &zeroValue}
  4749  	d.GetActiveLockReason()
  4750  	d = &Discussion{}
  4751  	d.GetActiveLockReason()
  4752  	d = nil
  4753  	d.GetActiveLockReason()
  4754  }
  4755  
  4756  func TestDiscussion_GetAnswerChosenAt(tt *testing.T) {
  4757  	var zeroValue Timestamp
  4758  	d := &Discussion{AnswerChosenAt: &zeroValue}
  4759  	d.GetAnswerChosenAt()
  4760  	d = &Discussion{}
  4761  	d.GetAnswerChosenAt()
  4762  	d = nil
  4763  	d.GetAnswerChosenAt()
  4764  }
  4765  
  4766  func TestDiscussion_GetAnswerChosenBy(tt *testing.T) {
  4767  	var zeroValue string
  4768  	d := &Discussion{AnswerChosenBy: &zeroValue}
  4769  	d.GetAnswerChosenBy()
  4770  	d = &Discussion{}
  4771  	d.GetAnswerChosenBy()
  4772  	d = nil
  4773  	d.GetAnswerChosenBy()
  4774  }
  4775  
  4776  func TestDiscussion_GetAnswerHTMLURL(tt *testing.T) {
  4777  	var zeroValue string
  4778  	d := &Discussion{AnswerHTMLURL: &zeroValue}
  4779  	d.GetAnswerHTMLURL()
  4780  	d = &Discussion{}
  4781  	d.GetAnswerHTMLURL()
  4782  	d = nil
  4783  	d.GetAnswerHTMLURL()
  4784  }
  4785  
  4786  func TestDiscussion_GetAuthorAssociation(tt *testing.T) {
  4787  	var zeroValue string
  4788  	d := &Discussion{AuthorAssociation: &zeroValue}
  4789  	d.GetAuthorAssociation()
  4790  	d = &Discussion{}
  4791  	d.GetAuthorAssociation()
  4792  	d = nil
  4793  	d.GetAuthorAssociation()
  4794  }
  4795  
  4796  func TestDiscussion_GetBody(tt *testing.T) {
  4797  	var zeroValue string
  4798  	d := &Discussion{Body: &zeroValue}
  4799  	d.GetBody()
  4800  	d = &Discussion{}
  4801  	d.GetBody()
  4802  	d = nil
  4803  	d.GetBody()
  4804  }
  4805  
  4806  func TestDiscussion_GetComments(tt *testing.T) {
  4807  	var zeroValue int
  4808  	d := &Discussion{Comments: &zeroValue}
  4809  	d.GetComments()
  4810  	d = &Discussion{}
  4811  	d.GetComments()
  4812  	d = nil
  4813  	d.GetComments()
  4814  }
  4815  
  4816  func TestDiscussion_GetCreatedAt(tt *testing.T) {
  4817  	var zeroValue Timestamp
  4818  	d := &Discussion{CreatedAt: &zeroValue}
  4819  	d.GetCreatedAt()
  4820  	d = &Discussion{}
  4821  	d.GetCreatedAt()
  4822  	d = nil
  4823  	d.GetCreatedAt()
  4824  }
  4825  
  4826  func TestDiscussion_GetDiscussionCategory(tt *testing.T) {
  4827  	d := &Discussion{}
  4828  	d.GetDiscussionCategory()
  4829  	d = nil
  4830  	d.GetDiscussionCategory()
  4831  }
  4832  
  4833  func TestDiscussion_GetHTMLURL(tt *testing.T) {
  4834  	var zeroValue string
  4835  	d := &Discussion{HTMLURL: &zeroValue}
  4836  	d.GetHTMLURL()
  4837  	d = &Discussion{}
  4838  	d.GetHTMLURL()
  4839  	d = nil
  4840  	d.GetHTMLURL()
  4841  }
  4842  
  4843  func TestDiscussion_GetID(tt *testing.T) {
  4844  	var zeroValue int64
  4845  	d := &Discussion{ID: &zeroValue}
  4846  	d.GetID()
  4847  	d = &Discussion{}
  4848  	d.GetID()
  4849  	d = nil
  4850  	d.GetID()
  4851  }
  4852  
  4853  func TestDiscussion_GetLocked(tt *testing.T) {
  4854  	var zeroValue bool
  4855  	d := &Discussion{Locked: &zeroValue}
  4856  	d.GetLocked()
  4857  	d = &Discussion{}
  4858  	d.GetLocked()
  4859  	d = nil
  4860  	d.GetLocked()
  4861  }
  4862  
  4863  func TestDiscussion_GetNodeID(tt *testing.T) {
  4864  	var zeroValue string
  4865  	d := &Discussion{NodeID: &zeroValue}
  4866  	d.GetNodeID()
  4867  	d = &Discussion{}
  4868  	d.GetNodeID()
  4869  	d = nil
  4870  	d.GetNodeID()
  4871  }
  4872  
  4873  func TestDiscussion_GetNumber(tt *testing.T) {
  4874  	var zeroValue int
  4875  	d := &Discussion{Number: &zeroValue}
  4876  	d.GetNumber()
  4877  	d = &Discussion{}
  4878  	d.GetNumber()
  4879  	d = nil
  4880  	d.GetNumber()
  4881  }
  4882  
  4883  func TestDiscussion_GetRepositoryURL(tt *testing.T) {
  4884  	var zeroValue string
  4885  	d := &Discussion{RepositoryURL: &zeroValue}
  4886  	d.GetRepositoryURL()
  4887  	d = &Discussion{}
  4888  	d.GetRepositoryURL()
  4889  	d = nil
  4890  	d.GetRepositoryURL()
  4891  }
  4892  
  4893  func TestDiscussion_GetState(tt *testing.T) {
  4894  	var zeroValue string
  4895  	d := &Discussion{State: &zeroValue}
  4896  	d.GetState()
  4897  	d = &Discussion{}
  4898  	d.GetState()
  4899  	d = nil
  4900  	d.GetState()
  4901  }
  4902  
  4903  func TestDiscussion_GetTitle(tt *testing.T) {
  4904  	var zeroValue string
  4905  	d := &Discussion{Title: &zeroValue}
  4906  	d.GetTitle()
  4907  	d = &Discussion{}
  4908  	d.GetTitle()
  4909  	d = nil
  4910  	d.GetTitle()
  4911  }
  4912  
  4913  func TestDiscussion_GetUpdatedAt(tt *testing.T) {
  4914  	var zeroValue Timestamp
  4915  	d := &Discussion{UpdatedAt: &zeroValue}
  4916  	d.GetUpdatedAt()
  4917  	d = &Discussion{}
  4918  	d.GetUpdatedAt()
  4919  	d = nil
  4920  	d.GetUpdatedAt()
  4921  }
  4922  
  4923  func TestDiscussion_GetUser(tt *testing.T) {
  4924  	d := &Discussion{}
  4925  	d.GetUser()
  4926  	d = nil
  4927  	d.GetUser()
  4928  }
  4929  
  4930  func TestDiscussionCategory_GetCreatedAt(tt *testing.T) {
  4931  	var zeroValue Timestamp
  4932  	d := &DiscussionCategory{CreatedAt: &zeroValue}
  4933  	d.GetCreatedAt()
  4934  	d = &DiscussionCategory{}
  4935  	d.GetCreatedAt()
  4936  	d = nil
  4937  	d.GetCreatedAt()
  4938  }
  4939  
  4940  func TestDiscussionCategory_GetDescription(tt *testing.T) {
  4941  	var zeroValue string
  4942  	d := &DiscussionCategory{Description: &zeroValue}
  4943  	d.GetDescription()
  4944  	d = &DiscussionCategory{}
  4945  	d.GetDescription()
  4946  	d = nil
  4947  	d.GetDescription()
  4948  }
  4949  
  4950  func TestDiscussionCategory_GetEmoji(tt *testing.T) {
  4951  	var zeroValue string
  4952  	d := &DiscussionCategory{Emoji: &zeroValue}
  4953  	d.GetEmoji()
  4954  	d = &DiscussionCategory{}
  4955  	d.GetEmoji()
  4956  	d = nil
  4957  	d.GetEmoji()
  4958  }
  4959  
  4960  func TestDiscussionCategory_GetID(tt *testing.T) {
  4961  	var zeroValue int64
  4962  	d := &DiscussionCategory{ID: &zeroValue}
  4963  	d.GetID()
  4964  	d = &DiscussionCategory{}
  4965  	d.GetID()
  4966  	d = nil
  4967  	d.GetID()
  4968  }
  4969  
  4970  func TestDiscussionCategory_GetIsAnswerable(tt *testing.T) {
  4971  	var zeroValue bool
  4972  	d := &DiscussionCategory{IsAnswerable: &zeroValue}
  4973  	d.GetIsAnswerable()
  4974  	d = &DiscussionCategory{}
  4975  	d.GetIsAnswerable()
  4976  	d = nil
  4977  	d.GetIsAnswerable()
  4978  }
  4979  
  4980  func TestDiscussionCategory_GetName(tt *testing.T) {
  4981  	var zeroValue string
  4982  	d := &DiscussionCategory{Name: &zeroValue}
  4983  	d.GetName()
  4984  	d = &DiscussionCategory{}
  4985  	d.GetName()
  4986  	d = nil
  4987  	d.GetName()
  4988  }
  4989  
  4990  func TestDiscussionCategory_GetNodeID(tt *testing.T) {
  4991  	var zeroValue string
  4992  	d := &DiscussionCategory{NodeID: &zeroValue}
  4993  	d.GetNodeID()
  4994  	d = &DiscussionCategory{}
  4995  	d.GetNodeID()
  4996  	d = nil
  4997  	d.GetNodeID()
  4998  }
  4999  
  5000  func TestDiscussionCategory_GetRepositoryID(tt *testing.T) {
  5001  	var zeroValue int64
  5002  	d := &DiscussionCategory{RepositoryID: &zeroValue}
  5003  	d.GetRepositoryID()
  5004  	d = &DiscussionCategory{}
  5005  	d.GetRepositoryID()
  5006  	d = nil
  5007  	d.GetRepositoryID()
  5008  }
  5009  
  5010  func TestDiscussionCategory_GetSlug(tt *testing.T) {
  5011  	var zeroValue string
  5012  	d := &DiscussionCategory{Slug: &zeroValue}
  5013  	d.GetSlug()
  5014  	d = &DiscussionCategory{}
  5015  	d.GetSlug()
  5016  	d = nil
  5017  	d.GetSlug()
  5018  }
  5019  
  5020  func TestDiscussionCategory_GetUpdatedAt(tt *testing.T) {
  5021  	var zeroValue Timestamp
  5022  	d := &DiscussionCategory{UpdatedAt: &zeroValue}
  5023  	d.GetUpdatedAt()
  5024  	d = &DiscussionCategory{}
  5025  	d.GetUpdatedAt()
  5026  	d = nil
  5027  	d.GetUpdatedAt()
  5028  }
  5029  
  5030  func TestDiscussionComment_GetAuthor(tt *testing.T) {
  5031  	d := &DiscussionComment{}
  5032  	d.GetAuthor()
  5033  	d = nil
  5034  	d.GetAuthor()
  5035  }
  5036  
  5037  func TestDiscussionComment_GetBody(tt *testing.T) {
  5038  	var zeroValue string
  5039  	d := &DiscussionComment{Body: &zeroValue}
  5040  	d.GetBody()
  5041  	d = &DiscussionComment{}
  5042  	d.GetBody()
  5043  	d = nil
  5044  	d.GetBody()
  5045  }
  5046  
  5047  func TestDiscussionComment_GetBodyHTML(tt *testing.T) {
  5048  	var zeroValue string
  5049  	d := &DiscussionComment{BodyHTML: &zeroValue}
  5050  	d.GetBodyHTML()
  5051  	d = &DiscussionComment{}
  5052  	d.GetBodyHTML()
  5053  	d = nil
  5054  	d.GetBodyHTML()
  5055  }
  5056  
  5057  func TestDiscussionComment_GetBodyVersion(tt *testing.T) {
  5058  	var zeroValue string
  5059  	d := &DiscussionComment{BodyVersion: &zeroValue}
  5060  	d.GetBodyVersion()
  5061  	d = &DiscussionComment{}
  5062  	d.GetBodyVersion()
  5063  	d = nil
  5064  	d.GetBodyVersion()
  5065  }
  5066  
  5067  func TestDiscussionComment_GetCreatedAt(tt *testing.T) {
  5068  	var zeroValue Timestamp
  5069  	d := &DiscussionComment{CreatedAt: &zeroValue}
  5070  	d.GetCreatedAt()
  5071  	d = &DiscussionComment{}
  5072  	d.GetCreatedAt()
  5073  	d = nil
  5074  	d.GetCreatedAt()
  5075  }
  5076  
  5077  func TestDiscussionComment_GetDiscussionURL(tt *testing.T) {
  5078  	var zeroValue string
  5079  	d := &DiscussionComment{DiscussionURL: &zeroValue}
  5080  	d.GetDiscussionURL()
  5081  	d = &DiscussionComment{}
  5082  	d.GetDiscussionURL()
  5083  	d = nil
  5084  	d.GetDiscussionURL()
  5085  }
  5086  
  5087  func TestDiscussionComment_GetHTMLURL(tt *testing.T) {
  5088  	var zeroValue string
  5089  	d := &DiscussionComment{HTMLURL: &zeroValue}
  5090  	d.GetHTMLURL()
  5091  	d = &DiscussionComment{}
  5092  	d.GetHTMLURL()
  5093  	d = nil
  5094  	d.GetHTMLURL()
  5095  }
  5096  
  5097  func TestDiscussionComment_GetLastEditedAt(tt *testing.T) {
  5098  	var zeroValue Timestamp
  5099  	d := &DiscussionComment{LastEditedAt: &zeroValue}
  5100  	d.GetLastEditedAt()
  5101  	d = &DiscussionComment{}
  5102  	d.GetLastEditedAt()
  5103  	d = nil
  5104  	d.GetLastEditedAt()
  5105  }
  5106  
  5107  func TestDiscussionComment_GetNodeID(tt *testing.T) {
  5108  	var zeroValue string
  5109  	d := &DiscussionComment{NodeID: &zeroValue}
  5110  	d.GetNodeID()
  5111  	d = &DiscussionComment{}
  5112  	d.GetNodeID()
  5113  	d = nil
  5114  	d.GetNodeID()
  5115  }
  5116  
  5117  func TestDiscussionComment_GetNumber(tt *testing.T) {
  5118  	var zeroValue int
  5119  	d := &DiscussionComment{Number: &zeroValue}
  5120  	d.GetNumber()
  5121  	d = &DiscussionComment{}
  5122  	d.GetNumber()
  5123  	d = nil
  5124  	d.GetNumber()
  5125  }
  5126  
  5127  func TestDiscussionComment_GetReactions(tt *testing.T) {
  5128  	d := &DiscussionComment{}
  5129  	d.GetReactions()
  5130  	d = nil
  5131  	d.GetReactions()
  5132  }
  5133  
  5134  func TestDiscussionComment_GetUpdatedAt(tt *testing.T) {
  5135  	var zeroValue Timestamp
  5136  	d := &DiscussionComment{UpdatedAt: &zeroValue}
  5137  	d.GetUpdatedAt()
  5138  	d = &DiscussionComment{}
  5139  	d.GetUpdatedAt()
  5140  	d = nil
  5141  	d.GetUpdatedAt()
  5142  }
  5143  
  5144  func TestDiscussionComment_GetURL(tt *testing.T) {
  5145  	var zeroValue string
  5146  	d := &DiscussionComment{URL: &zeroValue}
  5147  	d.GetURL()
  5148  	d = &DiscussionComment{}
  5149  	d.GetURL()
  5150  	d = nil
  5151  	d.GetURL()
  5152  }
  5153  
  5154  func TestDiscussionEvent_GetAction(tt *testing.T) {
  5155  	var zeroValue string
  5156  	d := &DiscussionEvent{Action: &zeroValue}
  5157  	d.GetAction()
  5158  	d = &DiscussionEvent{}
  5159  	d.GetAction()
  5160  	d = nil
  5161  	d.GetAction()
  5162  }
  5163  
  5164  func TestDiscussionEvent_GetDiscussion(tt *testing.T) {
  5165  	d := &DiscussionEvent{}
  5166  	d.GetDiscussion()
  5167  	d = nil
  5168  	d.GetDiscussion()
  5169  }
  5170  
  5171  func TestDiscussionEvent_GetInstallation(tt *testing.T) {
  5172  	d := &DiscussionEvent{}
  5173  	d.GetInstallation()
  5174  	d = nil
  5175  	d.GetInstallation()
  5176  }
  5177  
  5178  func TestDiscussionEvent_GetOrg(tt *testing.T) {
  5179  	d := &DiscussionEvent{}
  5180  	d.GetOrg()
  5181  	d = nil
  5182  	d.GetOrg()
  5183  }
  5184  
  5185  func TestDiscussionEvent_GetRepo(tt *testing.T) {
  5186  	d := &DiscussionEvent{}
  5187  	d.GetRepo()
  5188  	d = nil
  5189  	d.GetRepo()
  5190  }
  5191  
  5192  func TestDiscussionEvent_GetSender(tt *testing.T) {
  5193  	d := &DiscussionEvent{}
  5194  	d.GetSender()
  5195  	d = nil
  5196  	d.GetSender()
  5197  }
  5198  
  5199  func TestDismissalRestrictionsRequest_GetTeams(tt *testing.T) {
  5200  	var zeroValue []string
  5201  	d := &DismissalRestrictionsRequest{Teams: &zeroValue}
  5202  	d.GetTeams()
  5203  	d = &DismissalRestrictionsRequest{}
  5204  	d.GetTeams()
  5205  	d = nil
  5206  	d.GetTeams()
  5207  }
  5208  
  5209  func TestDismissalRestrictionsRequest_GetUsers(tt *testing.T) {
  5210  	var zeroValue []string
  5211  	d := &DismissalRestrictionsRequest{Users: &zeroValue}
  5212  	d.GetUsers()
  5213  	d = &DismissalRestrictionsRequest{}
  5214  	d.GetUsers()
  5215  	d = nil
  5216  	d.GetUsers()
  5217  }
  5218  
  5219  func TestDismissedReview_GetDismissalCommitID(tt *testing.T) {
  5220  	var zeroValue string
  5221  	d := &DismissedReview{DismissalCommitID: &zeroValue}
  5222  	d.GetDismissalCommitID()
  5223  	d = &DismissedReview{}
  5224  	d.GetDismissalCommitID()
  5225  	d = nil
  5226  	d.GetDismissalCommitID()
  5227  }
  5228  
  5229  func TestDismissedReview_GetDismissalMessage(tt *testing.T) {
  5230  	var zeroValue string
  5231  	d := &DismissedReview{DismissalMessage: &zeroValue}
  5232  	d.GetDismissalMessage()
  5233  	d = &DismissedReview{}
  5234  	d.GetDismissalMessage()
  5235  	d = nil
  5236  	d.GetDismissalMessage()
  5237  }
  5238  
  5239  func TestDismissedReview_GetReviewID(tt *testing.T) {
  5240  	var zeroValue int64
  5241  	d := &DismissedReview{ReviewID: &zeroValue}
  5242  	d.GetReviewID()
  5243  	d = &DismissedReview{}
  5244  	d.GetReviewID()
  5245  	d = nil
  5246  	d.GetReviewID()
  5247  }
  5248  
  5249  func TestDismissedReview_GetState(tt *testing.T) {
  5250  	var zeroValue string
  5251  	d := &DismissedReview{State: &zeroValue}
  5252  	d.GetState()
  5253  	d = &DismissedReview{}
  5254  	d.GetState()
  5255  	d = nil
  5256  	d.GetState()
  5257  }
  5258  
  5259  func TestDispatchRequestOptions_GetClientPayload(tt *testing.T) {
  5260  	var zeroValue json.RawMessage
  5261  	d := &DispatchRequestOptions{ClientPayload: &zeroValue}
  5262  	d.GetClientPayload()
  5263  	d = &DispatchRequestOptions{}
  5264  	d.GetClientPayload()
  5265  	d = nil
  5266  	d.GetClientPayload()
  5267  }
  5268  
  5269  func TestDraftReviewComment_GetBody(tt *testing.T) {
  5270  	var zeroValue string
  5271  	d := &DraftReviewComment{Body: &zeroValue}
  5272  	d.GetBody()
  5273  	d = &DraftReviewComment{}
  5274  	d.GetBody()
  5275  	d = nil
  5276  	d.GetBody()
  5277  }
  5278  
  5279  func TestDraftReviewComment_GetLine(tt *testing.T) {
  5280  	var zeroValue int
  5281  	d := &DraftReviewComment{Line: &zeroValue}
  5282  	d.GetLine()
  5283  	d = &DraftReviewComment{}
  5284  	d.GetLine()
  5285  	d = nil
  5286  	d.GetLine()
  5287  }
  5288  
  5289  func TestDraftReviewComment_GetPath(tt *testing.T) {
  5290  	var zeroValue string
  5291  	d := &DraftReviewComment{Path: &zeroValue}
  5292  	d.GetPath()
  5293  	d = &DraftReviewComment{}
  5294  	d.GetPath()
  5295  	d = nil
  5296  	d.GetPath()
  5297  }
  5298  
  5299  func TestDraftReviewComment_GetPosition(tt *testing.T) {
  5300  	var zeroValue int
  5301  	d := &DraftReviewComment{Position: &zeroValue}
  5302  	d.GetPosition()
  5303  	d = &DraftReviewComment{}
  5304  	d.GetPosition()
  5305  	d = nil
  5306  	d.GetPosition()
  5307  }
  5308  
  5309  func TestDraftReviewComment_GetSide(tt *testing.T) {
  5310  	var zeroValue string
  5311  	d := &DraftReviewComment{Side: &zeroValue}
  5312  	d.GetSide()
  5313  	d = &DraftReviewComment{}
  5314  	d.GetSide()
  5315  	d = nil
  5316  	d.GetSide()
  5317  }
  5318  
  5319  func TestDraftReviewComment_GetStartLine(tt *testing.T) {
  5320  	var zeroValue int
  5321  	d := &DraftReviewComment{StartLine: &zeroValue}
  5322  	d.GetStartLine()
  5323  	d = &DraftReviewComment{}
  5324  	d.GetStartLine()
  5325  	d = nil
  5326  	d.GetStartLine()
  5327  }
  5328  
  5329  func TestDraftReviewComment_GetStartSide(tt *testing.T) {
  5330  	var zeroValue string
  5331  	d := &DraftReviewComment{StartSide: &zeroValue}
  5332  	d.GetStartSide()
  5333  	d = &DraftReviewComment{}
  5334  	d.GetStartSide()
  5335  	d = nil
  5336  	d.GetStartSide()
  5337  }
  5338  
  5339  func TestEditBase_GetRef(tt *testing.T) {
  5340  	e := &EditBase{}
  5341  	e.GetRef()
  5342  	e = nil
  5343  	e.GetRef()
  5344  }
  5345  
  5346  func TestEditBase_GetSHA(tt *testing.T) {
  5347  	e := &EditBase{}
  5348  	e.GetSHA()
  5349  	e = nil
  5350  	e.GetSHA()
  5351  }
  5352  
  5353  func TestEditBody_GetFrom(tt *testing.T) {
  5354  	var zeroValue string
  5355  	e := &EditBody{From: &zeroValue}
  5356  	e.GetFrom()
  5357  	e = &EditBody{}
  5358  	e.GetFrom()
  5359  	e = nil
  5360  	e.GetFrom()
  5361  }
  5362  
  5363  func TestEditChange_GetBase(tt *testing.T) {
  5364  	e := &EditChange{}
  5365  	e.GetBase()
  5366  	e = nil
  5367  	e.GetBase()
  5368  }
  5369  
  5370  func TestEditChange_GetBody(tt *testing.T) {
  5371  	e := &EditChange{}
  5372  	e.GetBody()
  5373  	e = nil
  5374  	e.GetBody()
  5375  }
  5376  
  5377  func TestEditChange_GetRepo(tt *testing.T) {
  5378  	e := &EditChange{}
  5379  	e.GetRepo()
  5380  	e = nil
  5381  	e.GetRepo()
  5382  }
  5383  
  5384  func TestEditChange_GetTitle(tt *testing.T) {
  5385  	e := &EditChange{}
  5386  	e.GetTitle()
  5387  	e = nil
  5388  	e.GetTitle()
  5389  }
  5390  
  5391  func TestEditRef_GetFrom(tt *testing.T) {
  5392  	var zeroValue string
  5393  	e := &EditRef{From: &zeroValue}
  5394  	e.GetFrom()
  5395  	e = &EditRef{}
  5396  	e.GetFrom()
  5397  	e = nil
  5398  	e.GetFrom()
  5399  }
  5400  
  5401  func TestEditRepo_GetName(tt *testing.T) {
  5402  	e := &EditRepo{}
  5403  	e.GetName()
  5404  	e = nil
  5405  	e.GetName()
  5406  }
  5407  
  5408  func TestEditSHA_GetFrom(tt *testing.T) {
  5409  	var zeroValue string
  5410  	e := &EditSHA{From: &zeroValue}
  5411  	e.GetFrom()
  5412  	e = &EditSHA{}
  5413  	e.GetFrom()
  5414  	e = nil
  5415  	e.GetFrom()
  5416  }
  5417  
  5418  func TestEditTitle_GetFrom(tt *testing.T) {
  5419  	var zeroValue string
  5420  	e := &EditTitle{From: &zeroValue}
  5421  	e.GetFrom()
  5422  	e = &EditTitle{}
  5423  	e.GetFrom()
  5424  	e = nil
  5425  	e.GetFrom()
  5426  }
  5427  
  5428  func TestEnterprise_GetAvatarURL(tt *testing.T) {
  5429  	var zeroValue string
  5430  	e := &Enterprise{AvatarURL: &zeroValue}
  5431  	e.GetAvatarURL()
  5432  	e = &Enterprise{}
  5433  	e.GetAvatarURL()
  5434  	e = nil
  5435  	e.GetAvatarURL()
  5436  }
  5437  
  5438  func TestEnterprise_GetCreatedAt(tt *testing.T) {
  5439  	var zeroValue Timestamp
  5440  	e := &Enterprise{CreatedAt: &zeroValue}
  5441  	e.GetCreatedAt()
  5442  	e = &Enterprise{}
  5443  	e.GetCreatedAt()
  5444  	e = nil
  5445  	e.GetCreatedAt()
  5446  }
  5447  
  5448  func TestEnterprise_GetDescription(tt *testing.T) {
  5449  	var zeroValue string
  5450  	e := &Enterprise{Description: &zeroValue}
  5451  	e.GetDescription()
  5452  	e = &Enterprise{}
  5453  	e.GetDescription()
  5454  	e = nil
  5455  	e.GetDescription()
  5456  }
  5457  
  5458  func TestEnterprise_GetHTMLURL(tt *testing.T) {
  5459  	var zeroValue string
  5460  	e := &Enterprise{HTMLURL: &zeroValue}
  5461  	e.GetHTMLURL()
  5462  	e = &Enterprise{}
  5463  	e.GetHTMLURL()
  5464  	e = nil
  5465  	e.GetHTMLURL()
  5466  }
  5467  
  5468  func TestEnterprise_GetID(tt *testing.T) {
  5469  	var zeroValue int
  5470  	e := &Enterprise{ID: &zeroValue}
  5471  	e.GetID()
  5472  	e = &Enterprise{}
  5473  	e.GetID()
  5474  	e = nil
  5475  	e.GetID()
  5476  }
  5477  
  5478  func TestEnterprise_GetName(tt *testing.T) {
  5479  	var zeroValue string
  5480  	e := &Enterprise{Name: &zeroValue}
  5481  	e.GetName()
  5482  	e = &Enterprise{}
  5483  	e.GetName()
  5484  	e = nil
  5485  	e.GetName()
  5486  }
  5487  
  5488  func TestEnterprise_GetNodeID(tt *testing.T) {
  5489  	var zeroValue string
  5490  	e := &Enterprise{NodeID: &zeroValue}
  5491  	e.GetNodeID()
  5492  	e = &Enterprise{}
  5493  	e.GetNodeID()
  5494  	e = nil
  5495  	e.GetNodeID()
  5496  }
  5497  
  5498  func TestEnterprise_GetSlug(tt *testing.T) {
  5499  	var zeroValue string
  5500  	e := &Enterprise{Slug: &zeroValue}
  5501  	e.GetSlug()
  5502  	e = &Enterprise{}
  5503  	e.GetSlug()
  5504  	e = nil
  5505  	e.GetSlug()
  5506  }
  5507  
  5508  func TestEnterprise_GetUpdatedAt(tt *testing.T) {
  5509  	var zeroValue Timestamp
  5510  	e := &Enterprise{UpdatedAt: &zeroValue}
  5511  	e.GetUpdatedAt()
  5512  	e = &Enterprise{}
  5513  	e.GetUpdatedAt()
  5514  	e = nil
  5515  	e.GetUpdatedAt()
  5516  }
  5517  
  5518  func TestEnterprise_GetWebsiteURL(tt *testing.T) {
  5519  	var zeroValue string
  5520  	e := &Enterprise{WebsiteURL: &zeroValue}
  5521  	e.GetWebsiteURL()
  5522  	e = &Enterprise{}
  5523  	e.GetWebsiteURL()
  5524  	e = nil
  5525  	e.GetWebsiteURL()
  5526  }
  5527  
  5528  func TestEnvironment_GetCreatedAt(tt *testing.T) {
  5529  	var zeroValue Timestamp
  5530  	e := &Environment{CreatedAt: &zeroValue}
  5531  	e.GetCreatedAt()
  5532  	e = &Environment{}
  5533  	e.GetCreatedAt()
  5534  	e = nil
  5535  	e.GetCreatedAt()
  5536  }
  5537  
  5538  func TestEnvironment_GetDeploymentBranchPolicy(tt *testing.T) {
  5539  	e := &Environment{}
  5540  	e.GetDeploymentBranchPolicy()
  5541  	e = nil
  5542  	e.GetDeploymentBranchPolicy()
  5543  }
  5544  
  5545  func TestEnvironment_GetEnvironmentName(tt *testing.T) {
  5546  	var zeroValue string
  5547  	e := &Environment{EnvironmentName: &zeroValue}
  5548  	e.GetEnvironmentName()
  5549  	e = &Environment{}
  5550  	e.GetEnvironmentName()
  5551  	e = nil
  5552  	e.GetEnvironmentName()
  5553  }
  5554  
  5555  func TestEnvironment_GetHTMLURL(tt *testing.T) {
  5556  	var zeroValue string
  5557  	e := &Environment{HTMLURL: &zeroValue}
  5558  	e.GetHTMLURL()
  5559  	e = &Environment{}
  5560  	e.GetHTMLURL()
  5561  	e = nil
  5562  	e.GetHTMLURL()
  5563  }
  5564  
  5565  func TestEnvironment_GetID(tt *testing.T) {
  5566  	var zeroValue int64
  5567  	e := &Environment{ID: &zeroValue}
  5568  	e.GetID()
  5569  	e = &Environment{}
  5570  	e.GetID()
  5571  	e = nil
  5572  	e.GetID()
  5573  }
  5574  
  5575  func TestEnvironment_GetName(tt *testing.T) {
  5576  	var zeroValue string
  5577  	e := &Environment{Name: &zeroValue}
  5578  	e.GetName()
  5579  	e = &Environment{}
  5580  	e.GetName()
  5581  	e = nil
  5582  	e.GetName()
  5583  }
  5584  
  5585  func TestEnvironment_GetNodeID(tt *testing.T) {
  5586  	var zeroValue string
  5587  	e := &Environment{NodeID: &zeroValue}
  5588  	e.GetNodeID()
  5589  	e = &Environment{}
  5590  	e.GetNodeID()
  5591  	e = nil
  5592  	e.GetNodeID()
  5593  }
  5594  
  5595  func TestEnvironment_GetOwner(tt *testing.T) {
  5596  	var zeroValue string
  5597  	e := &Environment{Owner: &zeroValue}
  5598  	e.GetOwner()
  5599  	e = &Environment{}
  5600  	e.GetOwner()
  5601  	e = nil
  5602  	e.GetOwner()
  5603  }
  5604  
  5605  func TestEnvironment_GetRepo(tt *testing.T) {
  5606  	var zeroValue string
  5607  	e := &Environment{Repo: &zeroValue}
  5608  	e.GetRepo()
  5609  	e = &Environment{}
  5610  	e.GetRepo()
  5611  	e = nil
  5612  	e.GetRepo()
  5613  }
  5614  
  5615  func TestEnvironment_GetUpdatedAt(tt *testing.T) {
  5616  	var zeroValue Timestamp
  5617  	e := &Environment{UpdatedAt: &zeroValue}
  5618  	e.GetUpdatedAt()
  5619  	e = &Environment{}
  5620  	e.GetUpdatedAt()
  5621  	e = nil
  5622  	e.GetUpdatedAt()
  5623  }
  5624  
  5625  func TestEnvironment_GetURL(tt *testing.T) {
  5626  	var zeroValue string
  5627  	e := &Environment{URL: &zeroValue}
  5628  	e.GetURL()
  5629  	e = &Environment{}
  5630  	e.GetURL()
  5631  	e = nil
  5632  	e.GetURL()
  5633  }
  5634  
  5635  func TestEnvironment_GetWaitTimer(tt *testing.T) {
  5636  	var zeroValue int
  5637  	e := &Environment{WaitTimer: &zeroValue}
  5638  	e.GetWaitTimer()
  5639  	e = &Environment{}
  5640  	e.GetWaitTimer()
  5641  	e = nil
  5642  	e.GetWaitTimer()
  5643  }
  5644  
  5645  func TestEnvResponse_GetTotalCount(tt *testing.T) {
  5646  	var zeroValue int
  5647  	e := &EnvResponse{TotalCount: &zeroValue}
  5648  	e.GetTotalCount()
  5649  	e = &EnvResponse{}
  5650  	e.GetTotalCount()
  5651  	e = nil
  5652  	e.GetTotalCount()
  5653  }
  5654  
  5655  func TestEnvReviewers_GetID(tt *testing.T) {
  5656  	var zeroValue int64
  5657  	e := &EnvReviewers{ID: &zeroValue}
  5658  	e.GetID()
  5659  	e = &EnvReviewers{}
  5660  	e.GetID()
  5661  	e = nil
  5662  	e.GetID()
  5663  }
  5664  
  5665  func TestEnvReviewers_GetType(tt *testing.T) {
  5666  	var zeroValue string
  5667  	e := &EnvReviewers{Type: &zeroValue}
  5668  	e.GetType()
  5669  	e = &EnvReviewers{}
  5670  	e.GetType()
  5671  	e = nil
  5672  	e.GetType()
  5673  }
  5674  
  5675  func TestErrorBlock_GetCreatedAt(tt *testing.T) {
  5676  	var zeroValue Timestamp
  5677  	e := &ErrorBlock{CreatedAt: &zeroValue}
  5678  	e.GetCreatedAt()
  5679  	e = &ErrorBlock{}
  5680  	e.GetCreatedAt()
  5681  	e = nil
  5682  	e.GetCreatedAt()
  5683  }
  5684  
  5685  func TestErrorResponse_GetBlock(tt *testing.T) {
  5686  	e := &ErrorResponse{}
  5687  	e.GetBlock()
  5688  	e = nil
  5689  	e.GetBlock()
  5690  }
  5691  
  5692  func TestEvent_GetActor(tt *testing.T) {
  5693  	e := &Event{}
  5694  	e.GetActor()
  5695  	e = nil
  5696  	e.GetActor()
  5697  }
  5698  
  5699  func TestEvent_GetCreatedAt(tt *testing.T) {
  5700  	var zeroValue time.Time
  5701  	e := &Event{CreatedAt: &zeroValue}
  5702  	e.GetCreatedAt()
  5703  	e = &Event{}
  5704  	e.GetCreatedAt()
  5705  	e = nil
  5706  	e.GetCreatedAt()
  5707  }
  5708  
  5709  func TestEvent_GetID(tt *testing.T) {
  5710  	var zeroValue string
  5711  	e := &Event{ID: &zeroValue}
  5712  	e.GetID()
  5713  	e = &Event{}
  5714  	e.GetID()
  5715  	e = nil
  5716  	e.GetID()
  5717  }
  5718  
  5719  func TestEvent_GetOrg(tt *testing.T) {
  5720  	e := &Event{}
  5721  	e.GetOrg()
  5722  	e = nil
  5723  	e.GetOrg()
  5724  }
  5725  
  5726  func TestEvent_GetPublic(tt *testing.T) {
  5727  	var zeroValue bool
  5728  	e := &Event{Public: &zeroValue}
  5729  	e.GetPublic()
  5730  	e = &Event{}
  5731  	e.GetPublic()
  5732  	e = nil
  5733  	e.GetPublic()
  5734  }
  5735  
  5736  func TestEvent_GetRawPayload(tt *testing.T) {
  5737  	var zeroValue json.RawMessage
  5738  	e := &Event{RawPayload: &zeroValue}
  5739  	e.GetRawPayload()
  5740  	e = &Event{}
  5741  	e.GetRawPayload()
  5742  	e = nil
  5743  	e.GetRawPayload()
  5744  }
  5745  
  5746  func TestEvent_GetRepo(tt *testing.T) {
  5747  	e := &Event{}
  5748  	e.GetRepo()
  5749  	e = nil
  5750  	e.GetRepo()
  5751  }
  5752  
  5753  func TestEvent_GetType(tt *testing.T) {
  5754  	var zeroValue string
  5755  	e := &Event{Type: &zeroValue}
  5756  	e.GetType()
  5757  	e = &Event{}
  5758  	e.GetType()
  5759  	e = nil
  5760  	e.GetType()
  5761  }
  5762  
  5763  func TestExternalGroup_GetGroupID(tt *testing.T) {
  5764  	var zeroValue int64
  5765  	e := &ExternalGroup{GroupID: &zeroValue}
  5766  	e.GetGroupID()
  5767  	e = &ExternalGroup{}
  5768  	e.GetGroupID()
  5769  	e = nil
  5770  	e.GetGroupID()
  5771  }
  5772  
  5773  func TestExternalGroup_GetGroupName(tt *testing.T) {
  5774  	var zeroValue string
  5775  	e := &ExternalGroup{GroupName: &zeroValue}
  5776  	e.GetGroupName()
  5777  	e = &ExternalGroup{}
  5778  	e.GetGroupName()
  5779  	e = nil
  5780  	e.GetGroupName()
  5781  }
  5782  
  5783  func TestExternalGroup_GetUpdatedAt(tt *testing.T) {
  5784  	var zeroValue Timestamp
  5785  	e := &ExternalGroup{UpdatedAt: &zeroValue}
  5786  	e.GetUpdatedAt()
  5787  	e = &ExternalGroup{}
  5788  	e.GetUpdatedAt()
  5789  	e = nil
  5790  	e.GetUpdatedAt()
  5791  }
  5792  
  5793  func TestExternalGroupMember_GetMemberEmail(tt *testing.T) {
  5794  	var zeroValue string
  5795  	e := &ExternalGroupMember{MemberEmail: &zeroValue}
  5796  	e.GetMemberEmail()
  5797  	e = &ExternalGroupMember{}
  5798  	e.GetMemberEmail()
  5799  	e = nil
  5800  	e.GetMemberEmail()
  5801  }
  5802  
  5803  func TestExternalGroupMember_GetMemberID(tt *testing.T) {
  5804  	var zeroValue int64
  5805  	e := &ExternalGroupMember{MemberID: &zeroValue}
  5806  	e.GetMemberID()
  5807  	e = &ExternalGroupMember{}
  5808  	e.GetMemberID()
  5809  	e = nil
  5810  	e.GetMemberID()
  5811  }
  5812  
  5813  func TestExternalGroupMember_GetMemberLogin(tt *testing.T) {
  5814  	var zeroValue string
  5815  	e := &ExternalGroupMember{MemberLogin: &zeroValue}
  5816  	e.GetMemberLogin()
  5817  	e = &ExternalGroupMember{}
  5818  	e.GetMemberLogin()
  5819  	e = nil
  5820  	e.GetMemberLogin()
  5821  }
  5822  
  5823  func TestExternalGroupMember_GetMemberName(tt *testing.T) {
  5824  	var zeroValue string
  5825  	e := &ExternalGroupMember{MemberName: &zeroValue}
  5826  	e.GetMemberName()
  5827  	e = &ExternalGroupMember{}
  5828  	e.GetMemberName()
  5829  	e = nil
  5830  	e.GetMemberName()
  5831  }
  5832  
  5833  func TestExternalGroupTeam_GetTeamID(tt *testing.T) {
  5834  	var zeroValue int64
  5835  	e := &ExternalGroupTeam{TeamID: &zeroValue}
  5836  	e.GetTeamID()
  5837  	e = &ExternalGroupTeam{}
  5838  	e.GetTeamID()
  5839  	e = nil
  5840  	e.GetTeamID()
  5841  }
  5842  
  5843  func TestExternalGroupTeam_GetTeamName(tt *testing.T) {
  5844  	var zeroValue string
  5845  	e := &ExternalGroupTeam{TeamName: &zeroValue}
  5846  	e.GetTeamName()
  5847  	e = &ExternalGroupTeam{}
  5848  	e.GetTeamName()
  5849  	e = nil
  5850  	e.GetTeamName()
  5851  }
  5852  
  5853  func TestFeedLink_GetHRef(tt *testing.T) {
  5854  	var zeroValue string
  5855  	f := &FeedLink{HRef: &zeroValue}
  5856  	f.GetHRef()
  5857  	f = &FeedLink{}
  5858  	f.GetHRef()
  5859  	f = nil
  5860  	f.GetHRef()
  5861  }
  5862  
  5863  func TestFeedLink_GetType(tt *testing.T) {
  5864  	var zeroValue string
  5865  	f := &FeedLink{Type: &zeroValue}
  5866  	f.GetType()
  5867  	f = &FeedLink{}
  5868  	f.GetType()
  5869  	f = nil
  5870  	f.GetType()
  5871  }
  5872  
  5873  func TestFeedLinks_GetCurrentUser(tt *testing.T) {
  5874  	f := &FeedLinks{}
  5875  	f.GetCurrentUser()
  5876  	f = nil
  5877  	f.GetCurrentUser()
  5878  }
  5879  
  5880  func TestFeedLinks_GetCurrentUserActor(tt *testing.T) {
  5881  	f := &FeedLinks{}
  5882  	f.GetCurrentUserActor()
  5883  	f = nil
  5884  	f.GetCurrentUserActor()
  5885  }
  5886  
  5887  func TestFeedLinks_GetCurrentUserOrganization(tt *testing.T) {
  5888  	f := &FeedLinks{}
  5889  	f.GetCurrentUserOrganization()
  5890  	f = nil
  5891  	f.GetCurrentUserOrganization()
  5892  }
  5893  
  5894  func TestFeedLinks_GetCurrentUserPublic(tt *testing.T) {
  5895  	f := &FeedLinks{}
  5896  	f.GetCurrentUserPublic()
  5897  	f = nil
  5898  	f.GetCurrentUserPublic()
  5899  }
  5900  
  5901  func TestFeedLinks_GetTimeline(tt *testing.T) {
  5902  	f := &FeedLinks{}
  5903  	f.GetTimeline()
  5904  	f = nil
  5905  	f.GetTimeline()
  5906  }
  5907  
  5908  func TestFeedLinks_GetUser(tt *testing.T) {
  5909  	f := &FeedLinks{}
  5910  	f.GetUser()
  5911  	f = nil
  5912  	f.GetUser()
  5913  }
  5914  
  5915  func TestFeeds_GetCurrentUserActorURL(tt *testing.T) {
  5916  	var zeroValue string
  5917  	f := &Feeds{CurrentUserActorURL: &zeroValue}
  5918  	f.GetCurrentUserActorURL()
  5919  	f = &Feeds{}
  5920  	f.GetCurrentUserActorURL()
  5921  	f = nil
  5922  	f.GetCurrentUserActorURL()
  5923  }
  5924  
  5925  func TestFeeds_GetCurrentUserOrganizationURL(tt *testing.T) {
  5926  	var zeroValue string
  5927  	f := &Feeds{CurrentUserOrganizationURL: &zeroValue}
  5928  	f.GetCurrentUserOrganizationURL()
  5929  	f = &Feeds{}
  5930  	f.GetCurrentUserOrganizationURL()
  5931  	f = nil
  5932  	f.GetCurrentUserOrganizationURL()
  5933  }
  5934  
  5935  func TestFeeds_GetCurrentUserPublicURL(tt *testing.T) {
  5936  	var zeroValue string
  5937  	f := &Feeds{CurrentUserPublicURL: &zeroValue}
  5938  	f.GetCurrentUserPublicURL()
  5939  	f = &Feeds{}
  5940  	f.GetCurrentUserPublicURL()
  5941  	f = nil
  5942  	f.GetCurrentUserPublicURL()
  5943  }
  5944  
  5945  func TestFeeds_GetCurrentUserURL(tt *testing.T) {
  5946  	var zeroValue string
  5947  	f := &Feeds{CurrentUserURL: &zeroValue}
  5948  	f.GetCurrentUserURL()
  5949  	f = &Feeds{}
  5950  	f.GetCurrentUserURL()
  5951  	f = nil
  5952  	f.GetCurrentUserURL()
  5953  }
  5954  
  5955  func TestFeeds_GetLinks(tt *testing.T) {
  5956  	f := &Feeds{}
  5957  	f.GetLinks()
  5958  	f = nil
  5959  	f.GetLinks()
  5960  }
  5961  
  5962  func TestFeeds_GetTimelineURL(tt *testing.T) {
  5963  	var zeroValue string
  5964  	f := &Feeds{TimelineURL: &zeroValue}
  5965  	f.GetTimelineURL()
  5966  	f = &Feeds{}
  5967  	f.GetTimelineURL()
  5968  	f = nil
  5969  	f.GetTimelineURL()
  5970  }
  5971  
  5972  func TestFeeds_GetUserURL(tt *testing.T) {
  5973  	var zeroValue string
  5974  	f := &Feeds{UserURL: &zeroValue}
  5975  	f.GetUserURL()
  5976  	f = &Feeds{}
  5977  	f.GetUserURL()
  5978  	f = nil
  5979  	f.GetUserURL()
  5980  }
  5981  
  5982  func TestFirstPatchedVersion_GetIdentifier(tt *testing.T) {
  5983  	var zeroValue string
  5984  	f := &FirstPatchedVersion{Identifier: &zeroValue}
  5985  	f.GetIdentifier()
  5986  	f = &FirstPatchedVersion{}
  5987  	f.GetIdentifier()
  5988  	f = nil
  5989  	f.GetIdentifier()
  5990  }
  5991  
  5992  func TestForkEvent_GetForkee(tt *testing.T) {
  5993  	f := &ForkEvent{}
  5994  	f.GetForkee()
  5995  	f = nil
  5996  	f.GetForkee()
  5997  }
  5998  
  5999  func TestForkEvent_GetInstallation(tt *testing.T) {
  6000  	f := &ForkEvent{}
  6001  	f.GetInstallation()
  6002  	f = nil
  6003  	f.GetInstallation()
  6004  }
  6005  
  6006  func TestForkEvent_GetRepo(tt *testing.T) {
  6007  	f := &ForkEvent{}
  6008  	f.GetRepo()
  6009  	f = nil
  6010  	f.GetRepo()
  6011  }
  6012  
  6013  func TestForkEvent_GetSender(tt *testing.T) {
  6014  	f := &ForkEvent{}
  6015  	f.GetSender()
  6016  	f = nil
  6017  	f.GetSender()
  6018  }
  6019  
  6020  func TestGenerateNotesOptions_GetPreviousTagName(tt *testing.T) {
  6021  	var zeroValue string
  6022  	g := &GenerateNotesOptions{PreviousTagName: &zeroValue}
  6023  	g.GetPreviousTagName()
  6024  	g = &GenerateNotesOptions{}
  6025  	g.GetPreviousTagName()
  6026  	g = nil
  6027  	g.GetPreviousTagName()
  6028  }
  6029  
  6030  func TestGenerateNotesOptions_GetTargetCommitish(tt *testing.T) {
  6031  	var zeroValue string
  6032  	g := &GenerateNotesOptions{TargetCommitish: &zeroValue}
  6033  	g.GetTargetCommitish()
  6034  	g = &GenerateNotesOptions{}
  6035  	g.GetTargetCommitish()
  6036  	g = nil
  6037  	g.GetTargetCommitish()
  6038  }
  6039  
  6040  func TestGetAuditLogOptions_GetInclude(tt *testing.T) {
  6041  	var zeroValue string
  6042  	g := &GetAuditLogOptions{Include: &zeroValue}
  6043  	g.GetInclude()
  6044  	g = &GetAuditLogOptions{}
  6045  	g.GetInclude()
  6046  	g = nil
  6047  	g.GetInclude()
  6048  }
  6049  
  6050  func TestGetAuditLogOptions_GetOrder(tt *testing.T) {
  6051  	var zeroValue string
  6052  	g := &GetAuditLogOptions{Order: &zeroValue}
  6053  	g.GetOrder()
  6054  	g = &GetAuditLogOptions{}
  6055  	g.GetOrder()
  6056  	g = nil
  6057  	g.GetOrder()
  6058  }
  6059  
  6060  func TestGetAuditLogOptions_GetPhrase(tt *testing.T) {
  6061  	var zeroValue string
  6062  	g := &GetAuditLogOptions{Phrase: &zeroValue}
  6063  	g.GetPhrase()
  6064  	g = &GetAuditLogOptions{}
  6065  	g.GetPhrase()
  6066  	g = nil
  6067  	g.GetPhrase()
  6068  }
  6069  
  6070  func TestGist_GetComments(tt *testing.T) {
  6071  	var zeroValue int
  6072  	g := &Gist{Comments: &zeroValue}
  6073  	g.GetComments()
  6074  	g = &Gist{}
  6075  	g.GetComments()
  6076  	g = nil
  6077  	g.GetComments()
  6078  }
  6079  
  6080  func TestGist_GetCreatedAt(tt *testing.T) {
  6081  	var zeroValue time.Time
  6082  	g := &Gist{CreatedAt: &zeroValue}
  6083  	g.GetCreatedAt()
  6084  	g = &Gist{}
  6085  	g.GetCreatedAt()
  6086  	g = nil
  6087  	g.GetCreatedAt()
  6088  }
  6089  
  6090  func TestGist_GetDescription(tt *testing.T) {
  6091  	var zeroValue string
  6092  	g := &Gist{Description: &zeroValue}
  6093  	g.GetDescription()
  6094  	g = &Gist{}
  6095  	g.GetDescription()
  6096  	g = nil
  6097  	g.GetDescription()
  6098  }
  6099  
  6100  func TestGist_GetFiles(tt *testing.T) {
  6101  	zeroValue := map[GistFilename]GistFile{}
  6102  	g := &Gist{Files: zeroValue}
  6103  	g.GetFiles()
  6104  	g = &Gist{}
  6105  	g.GetFiles()
  6106  	g = nil
  6107  	g.GetFiles()
  6108  }
  6109  
  6110  func TestGist_GetGitPullURL(tt *testing.T) {
  6111  	var zeroValue string
  6112  	g := &Gist{GitPullURL: &zeroValue}
  6113  	g.GetGitPullURL()
  6114  	g = &Gist{}
  6115  	g.GetGitPullURL()
  6116  	g = nil
  6117  	g.GetGitPullURL()
  6118  }
  6119  
  6120  func TestGist_GetGitPushURL(tt *testing.T) {
  6121  	var zeroValue string
  6122  	g := &Gist{GitPushURL: &zeroValue}
  6123  	g.GetGitPushURL()
  6124  	g = &Gist{}
  6125  	g.GetGitPushURL()
  6126  	g = nil
  6127  	g.GetGitPushURL()
  6128  }
  6129  
  6130  func TestGist_GetHTMLURL(tt *testing.T) {
  6131  	var zeroValue string
  6132  	g := &Gist{HTMLURL: &zeroValue}
  6133  	g.GetHTMLURL()
  6134  	g = &Gist{}
  6135  	g.GetHTMLURL()
  6136  	g = nil
  6137  	g.GetHTMLURL()
  6138  }
  6139  
  6140  func TestGist_GetID(tt *testing.T) {
  6141  	var zeroValue string
  6142  	g := &Gist{ID: &zeroValue}
  6143  	g.GetID()
  6144  	g = &Gist{}
  6145  	g.GetID()
  6146  	g = nil
  6147  	g.GetID()
  6148  }
  6149  
  6150  func TestGist_GetNodeID(tt *testing.T) {
  6151  	var zeroValue string
  6152  	g := &Gist{NodeID: &zeroValue}
  6153  	g.GetNodeID()
  6154  	g = &Gist{}
  6155  	g.GetNodeID()
  6156  	g = nil
  6157  	g.GetNodeID()
  6158  }
  6159  
  6160  func TestGist_GetOwner(tt *testing.T) {
  6161  	g := &Gist{}
  6162  	g.GetOwner()
  6163  	g = nil
  6164  	g.GetOwner()
  6165  }
  6166  
  6167  func TestGist_GetPublic(tt *testing.T) {
  6168  	var zeroValue bool
  6169  	g := &Gist{Public: &zeroValue}
  6170  	g.GetPublic()
  6171  	g = &Gist{}
  6172  	g.GetPublic()
  6173  	g = nil
  6174  	g.GetPublic()
  6175  }
  6176  
  6177  func TestGist_GetUpdatedAt(tt *testing.T) {
  6178  	var zeroValue time.Time
  6179  	g := &Gist{UpdatedAt: &zeroValue}
  6180  	g.GetUpdatedAt()
  6181  	g = &Gist{}
  6182  	g.GetUpdatedAt()
  6183  	g = nil
  6184  	g.GetUpdatedAt()
  6185  }
  6186  
  6187  func TestGistComment_GetBody(tt *testing.T) {
  6188  	var zeroValue string
  6189  	g := &GistComment{Body: &zeroValue}
  6190  	g.GetBody()
  6191  	g = &GistComment{}
  6192  	g.GetBody()
  6193  	g = nil
  6194  	g.GetBody()
  6195  }
  6196  
  6197  func TestGistComment_GetCreatedAt(tt *testing.T) {
  6198  	var zeroValue time.Time
  6199  	g := &GistComment{CreatedAt: &zeroValue}
  6200  	g.GetCreatedAt()
  6201  	g = &GistComment{}
  6202  	g.GetCreatedAt()
  6203  	g = nil
  6204  	g.GetCreatedAt()
  6205  }
  6206  
  6207  func TestGistComment_GetID(tt *testing.T) {
  6208  	var zeroValue int64
  6209  	g := &GistComment{ID: &zeroValue}
  6210  	g.GetID()
  6211  	g = &GistComment{}
  6212  	g.GetID()
  6213  	g = nil
  6214  	g.GetID()
  6215  }
  6216  
  6217  func TestGistComment_GetURL(tt *testing.T) {
  6218  	var zeroValue string
  6219  	g := &GistComment{URL: &zeroValue}
  6220  	g.GetURL()
  6221  	g = &GistComment{}
  6222  	g.GetURL()
  6223  	g = nil
  6224  	g.GetURL()
  6225  }
  6226  
  6227  func TestGistComment_GetUser(tt *testing.T) {
  6228  	g := &GistComment{}
  6229  	g.GetUser()
  6230  	g = nil
  6231  	g.GetUser()
  6232  }
  6233  
  6234  func TestGistCommit_GetChangeStatus(tt *testing.T) {
  6235  	g := &GistCommit{}
  6236  	g.GetChangeStatus()
  6237  	g = nil
  6238  	g.GetChangeStatus()
  6239  }
  6240  
  6241  func TestGistCommit_GetCommittedAt(tt *testing.T) {
  6242  	var zeroValue Timestamp
  6243  	g := &GistCommit{CommittedAt: &zeroValue}
  6244  	g.GetCommittedAt()
  6245  	g = &GistCommit{}
  6246  	g.GetCommittedAt()
  6247  	g = nil
  6248  	g.GetCommittedAt()
  6249  }
  6250  
  6251  func TestGistCommit_GetNodeID(tt *testing.T) {
  6252  	var zeroValue string
  6253  	g := &GistCommit{NodeID: &zeroValue}
  6254  	g.GetNodeID()
  6255  	g = &GistCommit{}
  6256  	g.GetNodeID()
  6257  	g = nil
  6258  	g.GetNodeID()
  6259  }
  6260  
  6261  func TestGistCommit_GetURL(tt *testing.T) {
  6262  	var zeroValue string
  6263  	g := &GistCommit{URL: &zeroValue}
  6264  	g.GetURL()
  6265  	g = &GistCommit{}
  6266  	g.GetURL()
  6267  	g = nil
  6268  	g.GetURL()
  6269  }
  6270  
  6271  func TestGistCommit_GetUser(tt *testing.T) {
  6272  	g := &GistCommit{}
  6273  	g.GetUser()
  6274  	g = nil
  6275  	g.GetUser()
  6276  }
  6277  
  6278  func TestGistCommit_GetVersion(tt *testing.T) {
  6279  	var zeroValue string
  6280  	g := &GistCommit{Version: &zeroValue}
  6281  	g.GetVersion()
  6282  	g = &GistCommit{}
  6283  	g.GetVersion()
  6284  	g = nil
  6285  	g.GetVersion()
  6286  }
  6287  
  6288  func TestGistFile_GetContent(tt *testing.T) {
  6289  	var zeroValue string
  6290  	g := &GistFile{Content: &zeroValue}
  6291  	g.GetContent()
  6292  	g = &GistFile{}
  6293  	g.GetContent()
  6294  	g = nil
  6295  	g.GetContent()
  6296  }
  6297  
  6298  func TestGistFile_GetFilename(tt *testing.T) {
  6299  	var zeroValue string
  6300  	g := &GistFile{Filename: &zeroValue}
  6301  	g.GetFilename()
  6302  	g = &GistFile{}
  6303  	g.GetFilename()
  6304  	g = nil
  6305  	g.GetFilename()
  6306  }
  6307  
  6308  func TestGistFile_GetLanguage(tt *testing.T) {
  6309  	var zeroValue string
  6310  	g := &GistFile{Language: &zeroValue}
  6311  	g.GetLanguage()
  6312  	g = &GistFile{}
  6313  	g.GetLanguage()
  6314  	g = nil
  6315  	g.GetLanguage()
  6316  }
  6317  
  6318  func TestGistFile_GetRawURL(tt *testing.T) {
  6319  	var zeroValue string
  6320  	g := &GistFile{RawURL: &zeroValue}
  6321  	g.GetRawURL()
  6322  	g = &GistFile{}
  6323  	g.GetRawURL()
  6324  	g = nil
  6325  	g.GetRawURL()
  6326  }
  6327  
  6328  func TestGistFile_GetSize(tt *testing.T) {
  6329  	var zeroValue int
  6330  	g := &GistFile{Size: &zeroValue}
  6331  	g.GetSize()
  6332  	g = &GistFile{}
  6333  	g.GetSize()
  6334  	g = nil
  6335  	g.GetSize()
  6336  }
  6337  
  6338  func TestGistFile_GetType(tt *testing.T) {
  6339  	var zeroValue string
  6340  	g := &GistFile{Type: &zeroValue}
  6341  	g.GetType()
  6342  	g = &GistFile{}
  6343  	g.GetType()
  6344  	g = nil
  6345  	g.GetType()
  6346  }
  6347  
  6348  func TestGistFork_GetCreatedAt(tt *testing.T) {
  6349  	var zeroValue Timestamp
  6350  	g := &GistFork{CreatedAt: &zeroValue}
  6351  	g.GetCreatedAt()
  6352  	g = &GistFork{}
  6353  	g.GetCreatedAt()
  6354  	g = nil
  6355  	g.GetCreatedAt()
  6356  }
  6357  
  6358  func TestGistFork_GetID(tt *testing.T) {
  6359  	var zeroValue string
  6360  	g := &GistFork{ID: &zeroValue}
  6361  	g.GetID()
  6362  	g = &GistFork{}
  6363  	g.GetID()
  6364  	g = nil
  6365  	g.GetID()
  6366  }
  6367  
  6368  func TestGistFork_GetNodeID(tt *testing.T) {
  6369  	var zeroValue string
  6370  	g := &GistFork{NodeID: &zeroValue}
  6371  	g.GetNodeID()
  6372  	g = &GistFork{}
  6373  	g.GetNodeID()
  6374  	g = nil
  6375  	g.GetNodeID()
  6376  }
  6377  
  6378  func TestGistFork_GetUpdatedAt(tt *testing.T) {
  6379  	var zeroValue Timestamp
  6380  	g := &GistFork{UpdatedAt: &zeroValue}
  6381  	g.GetUpdatedAt()
  6382  	g = &GistFork{}
  6383  	g.GetUpdatedAt()
  6384  	g = nil
  6385  	g.GetUpdatedAt()
  6386  }
  6387  
  6388  func TestGistFork_GetURL(tt *testing.T) {
  6389  	var zeroValue string
  6390  	g := &GistFork{URL: &zeroValue}
  6391  	g.GetURL()
  6392  	g = &GistFork{}
  6393  	g.GetURL()
  6394  	g = nil
  6395  	g.GetURL()
  6396  }
  6397  
  6398  func TestGistFork_GetUser(tt *testing.T) {
  6399  	g := &GistFork{}
  6400  	g.GetUser()
  6401  	g = nil
  6402  	g.GetUser()
  6403  }
  6404  
  6405  func TestGistStats_GetPrivateGists(tt *testing.T) {
  6406  	var zeroValue int
  6407  	g := &GistStats{PrivateGists: &zeroValue}
  6408  	g.GetPrivateGists()
  6409  	g = &GistStats{}
  6410  	g.GetPrivateGists()
  6411  	g = nil
  6412  	g.GetPrivateGists()
  6413  }
  6414  
  6415  func TestGistStats_GetPublicGists(tt *testing.T) {
  6416  	var zeroValue int
  6417  	g := &GistStats{PublicGists: &zeroValue}
  6418  	g.GetPublicGists()
  6419  	g = &GistStats{}
  6420  	g.GetPublicGists()
  6421  	g = nil
  6422  	g.GetPublicGists()
  6423  }
  6424  
  6425  func TestGistStats_GetTotalGists(tt *testing.T) {
  6426  	var zeroValue int
  6427  	g := &GistStats{TotalGists: &zeroValue}
  6428  	g.GetTotalGists()
  6429  	g = &GistStats{}
  6430  	g.GetTotalGists()
  6431  	g = nil
  6432  	g.GetTotalGists()
  6433  }
  6434  
  6435  func TestGitHubAppAuthorizationEvent_GetAction(tt *testing.T) {
  6436  	var zeroValue string
  6437  	g := &GitHubAppAuthorizationEvent{Action: &zeroValue}
  6438  	g.GetAction()
  6439  	g = &GitHubAppAuthorizationEvent{}
  6440  	g.GetAction()
  6441  	g = nil
  6442  	g.GetAction()
  6443  }
  6444  
  6445  func TestGitHubAppAuthorizationEvent_GetInstallation(tt *testing.T) {
  6446  	g := &GitHubAppAuthorizationEvent{}
  6447  	g.GetInstallation()
  6448  	g = nil
  6449  	g.GetInstallation()
  6450  }
  6451  
  6452  func TestGitHubAppAuthorizationEvent_GetSender(tt *testing.T) {
  6453  	g := &GitHubAppAuthorizationEvent{}
  6454  	g.GetSender()
  6455  	g = nil
  6456  	g.GetSender()
  6457  }
  6458  
  6459  func TestGitignore_GetName(tt *testing.T) {
  6460  	var zeroValue string
  6461  	g := &Gitignore{Name: &zeroValue}
  6462  	g.GetName()
  6463  	g = &Gitignore{}
  6464  	g.GetName()
  6465  	g = nil
  6466  	g.GetName()
  6467  }
  6468  
  6469  func TestGitignore_GetSource(tt *testing.T) {
  6470  	var zeroValue string
  6471  	g := &Gitignore{Source: &zeroValue}
  6472  	g.GetSource()
  6473  	g = &Gitignore{}
  6474  	g.GetSource()
  6475  	g = nil
  6476  	g.GetSource()
  6477  }
  6478  
  6479  func TestGitObject_GetSHA(tt *testing.T) {
  6480  	var zeroValue string
  6481  	g := &GitObject{SHA: &zeroValue}
  6482  	g.GetSHA()
  6483  	g = &GitObject{}
  6484  	g.GetSHA()
  6485  	g = nil
  6486  	g.GetSHA()
  6487  }
  6488  
  6489  func TestGitObject_GetType(tt *testing.T) {
  6490  	var zeroValue string
  6491  	g := &GitObject{Type: &zeroValue}
  6492  	g.GetType()
  6493  	g = &GitObject{}
  6494  	g.GetType()
  6495  	g = nil
  6496  	g.GetType()
  6497  }
  6498  
  6499  func TestGitObject_GetURL(tt *testing.T) {
  6500  	var zeroValue string
  6501  	g := &GitObject{URL: &zeroValue}
  6502  	g.GetURL()
  6503  	g = &GitObject{}
  6504  	g.GetURL()
  6505  	g = nil
  6506  	g.GetURL()
  6507  }
  6508  
  6509  func TestGollumEvent_GetInstallation(tt *testing.T) {
  6510  	g := &GollumEvent{}
  6511  	g.GetInstallation()
  6512  	g = nil
  6513  	g.GetInstallation()
  6514  }
  6515  
  6516  func TestGollumEvent_GetRepo(tt *testing.T) {
  6517  	g := &GollumEvent{}
  6518  	g.GetRepo()
  6519  	g = nil
  6520  	g.GetRepo()
  6521  }
  6522  
  6523  func TestGollumEvent_GetSender(tt *testing.T) {
  6524  	g := &GollumEvent{}
  6525  	g.GetSender()
  6526  	g = nil
  6527  	g.GetSender()
  6528  }
  6529  
  6530  func TestGPGEmail_GetEmail(tt *testing.T) {
  6531  	var zeroValue string
  6532  	g := &GPGEmail{Email: &zeroValue}
  6533  	g.GetEmail()
  6534  	g = &GPGEmail{}
  6535  	g.GetEmail()
  6536  	g = nil
  6537  	g.GetEmail()
  6538  }
  6539  
  6540  func TestGPGEmail_GetVerified(tt *testing.T) {
  6541  	var zeroValue bool
  6542  	g := &GPGEmail{Verified: &zeroValue}
  6543  	g.GetVerified()
  6544  	g = &GPGEmail{}
  6545  	g.GetVerified()
  6546  	g = nil
  6547  	g.GetVerified()
  6548  }
  6549  
  6550  func TestGPGKey_GetCanCertify(tt *testing.T) {
  6551  	var zeroValue bool
  6552  	g := &GPGKey{CanCertify: &zeroValue}
  6553  	g.GetCanCertify()
  6554  	g = &GPGKey{}
  6555  	g.GetCanCertify()
  6556  	g = nil
  6557  	g.GetCanCertify()
  6558  }
  6559  
  6560  func TestGPGKey_GetCanEncryptComms(tt *testing.T) {
  6561  	var zeroValue bool
  6562  	g := &GPGKey{CanEncryptComms: &zeroValue}
  6563  	g.GetCanEncryptComms()
  6564  	g = &GPGKey{}
  6565  	g.GetCanEncryptComms()
  6566  	g = nil
  6567  	g.GetCanEncryptComms()
  6568  }
  6569  
  6570  func TestGPGKey_GetCanEncryptStorage(tt *testing.T) {
  6571  	var zeroValue bool
  6572  	g := &GPGKey{CanEncryptStorage: &zeroValue}
  6573  	g.GetCanEncryptStorage()
  6574  	g = &GPGKey{}
  6575  	g.GetCanEncryptStorage()
  6576  	g = nil
  6577  	g.GetCanEncryptStorage()
  6578  }
  6579  
  6580  func TestGPGKey_GetCanSign(tt *testing.T) {
  6581  	var zeroValue bool
  6582  	g := &GPGKey{CanSign: &zeroValue}
  6583  	g.GetCanSign()
  6584  	g = &GPGKey{}
  6585  	g.GetCanSign()
  6586  	g = nil
  6587  	g.GetCanSign()
  6588  }
  6589  
  6590  func TestGPGKey_GetCreatedAt(tt *testing.T) {
  6591  	var zeroValue time.Time
  6592  	g := &GPGKey{CreatedAt: &zeroValue}
  6593  	g.GetCreatedAt()
  6594  	g = &GPGKey{}
  6595  	g.GetCreatedAt()
  6596  	g = nil
  6597  	g.GetCreatedAt()
  6598  }
  6599  
  6600  func TestGPGKey_GetExpiresAt(tt *testing.T) {
  6601  	var zeroValue time.Time
  6602  	g := &GPGKey{ExpiresAt: &zeroValue}
  6603  	g.GetExpiresAt()
  6604  	g = &GPGKey{}
  6605  	g.GetExpiresAt()
  6606  	g = nil
  6607  	g.GetExpiresAt()
  6608  }
  6609  
  6610  func TestGPGKey_GetID(tt *testing.T) {
  6611  	var zeroValue int64
  6612  	g := &GPGKey{ID: &zeroValue}
  6613  	g.GetID()
  6614  	g = &GPGKey{}
  6615  	g.GetID()
  6616  	g = nil
  6617  	g.GetID()
  6618  }
  6619  
  6620  func TestGPGKey_GetKeyID(tt *testing.T) {
  6621  	var zeroValue string
  6622  	g := &GPGKey{KeyID: &zeroValue}
  6623  	g.GetKeyID()
  6624  	g = &GPGKey{}
  6625  	g.GetKeyID()
  6626  	g = nil
  6627  	g.GetKeyID()
  6628  }
  6629  
  6630  func TestGPGKey_GetPrimaryKeyID(tt *testing.T) {
  6631  	var zeroValue int64
  6632  	g := &GPGKey{PrimaryKeyID: &zeroValue}
  6633  	g.GetPrimaryKeyID()
  6634  	g = &GPGKey{}
  6635  	g.GetPrimaryKeyID()
  6636  	g = nil
  6637  	g.GetPrimaryKeyID()
  6638  }
  6639  
  6640  func TestGPGKey_GetPublicKey(tt *testing.T) {
  6641  	var zeroValue string
  6642  	g := &GPGKey{PublicKey: &zeroValue}
  6643  	g.GetPublicKey()
  6644  	g = &GPGKey{}
  6645  	g.GetPublicKey()
  6646  	g = nil
  6647  	g.GetPublicKey()
  6648  }
  6649  
  6650  func TestGPGKey_GetRawKey(tt *testing.T) {
  6651  	var zeroValue string
  6652  	g := &GPGKey{RawKey: &zeroValue}
  6653  	g.GetRawKey()
  6654  	g = &GPGKey{}
  6655  	g.GetRawKey()
  6656  	g = nil
  6657  	g.GetRawKey()
  6658  }
  6659  
  6660  func TestGrant_GetApp(tt *testing.T) {
  6661  	g := &Grant{}
  6662  	g.GetApp()
  6663  	g = nil
  6664  	g.GetApp()
  6665  }
  6666  
  6667  func TestGrant_GetCreatedAt(tt *testing.T) {
  6668  	var zeroValue Timestamp
  6669  	g := &Grant{CreatedAt: &zeroValue}
  6670  	g.GetCreatedAt()
  6671  	g = &Grant{}
  6672  	g.GetCreatedAt()
  6673  	g = nil
  6674  	g.GetCreatedAt()
  6675  }
  6676  
  6677  func TestGrant_GetID(tt *testing.T) {
  6678  	var zeroValue int64
  6679  	g := &Grant{ID: &zeroValue}
  6680  	g.GetID()
  6681  	g = &Grant{}
  6682  	g.GetID()
  6683  	g = nil
  6684  	g.GetID()
  6685  }
  6686  
  6687  func TestGrant_GetUpdatedAt(tt *testing.T) {
  6688  	var zeroValue Timestamp
  6689  	g := &Grant{UpdatedAt: &zeroValue}
  6690  	g.GetUpdatedAt()
  6691  	g = &Grant{}
  6692  	g.GetUpdatedAt()
  6693  	g = nil
  6694  	g.GetUpdatedAt()
  6695  }
  6696  
  6697  func TestGrant_GetURL(tt *testing.T) {
  6698  	var zeroValue string
  6699  	g := &Grant{URL: &zeroValue}
  6700  	g.GetURL()
  6701  	g = &Grant{}
  6702  	g.GetURL()
  6703  	g = nil
  6704  	g.GetURL()
  6705  }
  6706  
  6707  func TestHeadCommit_GetAuthor(tt *testing.T) {
  6708  	h := &HeadCommit{}
  6709  	h.GetAuthor()
  6710  	h = nil
  6711  	h.GetAuthor()
  6712  }
  6713  
  6714  func TestHeadCommit_GetCommitter(tt *testing.T) {
  6715  	h := &HeadCommit{}
  6716  	h.GetCommitter()
  6717  	h = nil
  6718  	h.GetCommitter()
  6719  }
  6720  
  6721  func TestHeadCommit_GetDistinct(tt *testing.T) {
  6722  	var zeroValue bool
  6723  	h := &HeadCommit{Distinct: &zeroValue}
  6724  	h.GetDistinct()
  6725  	h = &HeadCommit{}
  6726  	h.GetDistinct()
  6727  	h = nil
  6728  	h.GetDistinct()
  6729  }
  6730  
  6731  func TestHeadCommit_GetID(tt *testing.T) {
  6732  	var zeroValue string
  6733  	h := &HeadCommit{ID: &zeroValue}
  6734  	h.GetID()
  6735  	h = &HeadCommit{}
  6736  	h.GetID()
  6737  	h = nil
  6738  	h.GetID()
  6739  }
  6740  
  6741  func TestHeadCommit_GetMessage(tt *testing.T) {
  6742  	var zeroValue string
  6743  	h := &HeadCommit{Message: &zeroValue}
  6744  	h.GetMessage()
  6745  	h = &HeadCommit{}
  6746  	h.GetMessage()
  6747  	h = nil
  6748  	h.GetMessage()
  6749  }
  6750  
  6751  func TestHeadCommit_GetSHA(tt *testing.T) {
  6752  	var zeroValue string
  6753  	h := &HeadCommit{SHA: &zeroValue}
  6754  	h.GetSHA()
  6755  	h = &HeadCommit{}
  6756  	h.GetSHA()
  6757  	h = nil
  6758  	h.GetSHA()
  6759  }
  6760  
  6761  func TestHeadCommit_GetTimestamp(tt *testing.T) {
  6762  	var zeroValue Timestamp
  6763  	h := &HeadCommit{Timestamp: &zeroValue}
  6764  	h.GetTimestamp()
  6765  	h = &HeadCommit{}
  6766  	h.GetTimestamp()
  6767  	h = nil
  6768  	h.GetTimestamp()
  6769  }
  6770  
  6771  func TestHeadCommit_GetTreeID(tt *testing.T) {
  6772  	var zeroValue string
  6773  	h := &HeadCommit{TreeID: &zeroValue}
  6774  	h.GetTreeID()
  6775  	h = &HeadCommit{}
  6776  	h.GetTreeID()
  6777  	h = nil
  6778  	h.GetTreeID()
  6779  }
  6780  
  6781  func TestHeadCommit_GetURL(tt *testing.T) {
  6782  	var zeroValue string
  6783  	h := &HeadCommit{URL: &zeroValue}
  6784  	h.GetURL()
  6785  	h = &HeadCommit{}
  6786  	h.GetURL()
  6787  	h = nil
  6788  	h.GetURL()
  6789  }
  6790  
  6791  func TestHook_GetActive(tt *testing.T) {
  6792  	var zeroValue bool
  6793  	h := &Hook{Active: &zeroValue}
  6794  	h.GetActive()
  6795  	h = &Hook{}
  6796  	h.GetActive()
  6797  	h = nil
  6798  	h.GetActive()
  6799  }
  6800  
  6801  func TestHook_GetCreatedAt(tt *testing.T) {
  6802  	var zeroValue time.Time
  6803  	h := &Hook{CreatedAt: &zeroValue}
  6804  	h.GetCreatedAt()
  6805  	h = &Hook{}
  6806  	h.GetCreatedAt()
  6807  	h = nil
  6808  	h.GetCreatedAt()
  6809  }
  6810  
  6811  func TestHook_GetID(tt *testing.T) {
  6812  	var zeroValue int64
  6813  	h := &Hook{ID: &zeroValue}
  6814  	h.GetID()
  6815  	h = &Hook{}
  6816  	h.GetID()
  6817  	h = nil
  6818  	h.GetID()
  6819  }
  6820  
  6821  func TestHook_GetName(tt *testing.T) {
  6822  	var zeroValue string
  6823  	h := &Hook{Name: &zeroValue}
  6824  	h.GetName()
  6825  	h = &Hook{}
  6826  	h.GetName()
  6827  	h = nil
  6828  	h.GetName()
  6829  }
  6830  
  6831  func TestHook_GetPingURL(tt *testing.T) {
  6832  	var zeroValue string
  6833  	h := &Hook{PingURL: &zeroValue}
  6834  	h.GetPingURL()
  6835  	h = &Hook{}
  6836  	h.GetPingURL()
  6837  	h = nil
  6838  	h.GetPingURL()
  6839  }
  6840  
  6841  func TestHook_GetTestURL(tt *testing.T) {
  6842  	var zeroValue string
  6843  	h := &Hook{TestURL: &zeroValue}
  6844  	h.GetTestURL()
  6845  	h = &Hook{}
  6846  	h.GetTestURL()
  6847  	h = nil
  6848  	h.GetTestURL()
  6849  }
  6850  
  6851  func TestHook_GetType(tt *testing.T) {
  6852  	var zeroValue string
  6853  	h := &Hook{Type: &zeroValue}
  6854  	h.GetType()
  6855  	h = &Hook{}
  6856  	h.GetType()
  6857  	h = nil
  6858  	h.GetType()
  6859  }
  6860  
  6861  func TestHook_GetUpdatedAt(tt *testing.T) {
  6862  	var zeroValue time.Time
  6863  	h := &Hook{UpdatedAt: &zeroValue}
  6864  	h.GetUpdatedAt()
  6865  	h = &Hook{}
  6866  	h.GetUpdatedAt()
  6867  	h = nil
  6868  	h.GetUpdatedAt()
  6869  }
  6870  
  6871  func TestHook_GetURL(tt *testing.T) {
  6872  	var zeroValue string
  6873  	h := &Hook{URL: &zeroValue}
  6874  	h.GetURL()
  6875  	h = &Hook{}
  6876  	h.GetURL()
  6877  	h = nil
  6878  	h.GetURL()
  6879  }
  6880  
  6881  func TestHookConfig_GetContentType(tt *testing.T) {
  6882  	var zeroValue string
  6883  	h := &HookConfig{ContentType: &zeroValue}
  6884  	h.GetContentType()
  6885  	h = &HookConfig{}
  6886  	h.GetContentType()
  6887  	h = nil
  6888  	h.GetContentType()
  6889  }
  6890  
  6891  func TestHookConfig_GetInsecureSSL(tt *testing.T) {
  6892  	var zeroValue string
  6893  	h := &HookConfig{InsecureSSL: &zeroValue}
  6894  	h.GetInsecureSSL()
  6895  	h = &HookConfig{}
  6896  	h.GetInsecureSSL()
  6897  	h = nil
  6898  	h.GetInsecureSSL()
  6899  }
  6900  
  6901  func TestHookConfig_GetSecret(tt *testing.T) {
  6902  	var zeroValue string
  6903  	h := &HookConfig{Secret: &zeroValue}
  6904  	h.GetSecret()
  6905  	h = &HookConfig{}
  6906  	h.GetSecret()
  6907  	h = nil
  6908  	h.GetSecret()
  6909  }
  6910  
  6911  func TestHookConfig_GetURL(tt *testing.T) {
  6912  	var zeroValue string
  6913  	h := &HookConfig{URL: &zeroValue}
  6914  	h.GetURL()
  6915  	h = &HookConfig{}
  6916  	h.GetURL()
  6917  	h = nil
  6918  	h.GetURL()
  6919  }
  6920  
  6921  func TestHookDelivery_GetAction(tt *testing.T) {
  6922  	var zeroValue string
  6923  	h := &HookDelivery{Action: &zeroValue}
  6924  	h.GetAction()
  6925  	h = &HookDelivery{}
  6926  	h.GetAction()
  6927  	h = nil
  6928  	h.GetAction()
  6929  }
  6930  
  6931  func TestHookDelivery_GetDeliveredAt(tt *testing.T) {
  6932  	var zeroValue Timestamp
  6933  	h := &HookDelivery{DeliveredAt: &zeroValue}
  6934  	h.GetDeliveredAt()
  6935  	h = &HookDelivery{}
  6936  	h.GetDeliveredAt()
  6937  	h = nil
  6938  	h.GetDeliveredAt()
  6939  }
  6940  
  6941  func TestHookDelivery_GetDuration(tt *testing.T) {
  6942  	h := &HookDelivery{}
  6943  	h.GetDuration()
  6944  	h = nil
  6945  	h.GetDuration()
  6946  }
  6947  
  6948  func TestHookDelivery_GetEvent(tt *testing.T) {
  6949  	var zeroValue string
  6950  	h := &HookDelivery{Event: &zeroValue}
  6951  	h.GetEvent()
  6952  	h = &HookDelivery{}
  6953  	h.GetEvent()
  6954  	h = nil
  6955  	h.GetEvent()
  6956  }
  6957  
  6958  func TestHookDelivery_GetGUID(tt *testing.T) {
  6959  	var zeroValue string
  6960  	h := &HookDelivery{GUID: &zeroValue}
  6961  	h.GetGUID()
  6962  	h = &HookDelivery{}
  6963  	h.GetGUID()
  6964  	h = nil
  6965  	h.GetGUID()
  6966  }
  6967  
  6968  func TestHookDelivery_GetID(tt *testing.T) {
  6969  	var zeroValue int64
  6970  	h := &HookDelivery{ID: &zeroValue}
  6971  	h.GetID()
  6972  	h = &HookDelivery{}
  6973  	h.GetID()
  6974  	h = nil
  6975  	h.GetID()
  6976  }
  6977  
  6978  func TestHookDelivery_GetInstallationID(tt *testing.T) {
  6979  	var zeroValue int64
  6980  	h := &HookDelivery{InstallationID: &zeroValue}
  6981  	h.GetInstallationID()
  6982  	h = &HookDelivery{}
  6983  	h.GetInstallationID()
  6984  	h = nil
  6985  	h.GetInstallationID()
  6986  }
  6987  
  6988  func TestHookDelivery_GetRedelivery(tt *testing.T) {
  6989  	var zeroValue bool
  6990  	h := &HookDelivery{Redelivery: &zeroValue}
  6991  	h.GetRedelivery()
  6992  	h = &HookDelivery{}
  6993  	h.GetRedelivery()
  6994  	h = nil
  6995  	h.GetRedelivery()
  6996  }
  6997  
  6998  func TestHookDelivery_GetRepositoryID(tt *testing.T) {
  6999  	var zeroValue int64
  7000  	h := &HookDelivery{RepositoryID: &zeroValue}
  7001  	h.GetRepositoryID()
  7002  	h = &HookDelivery{}
  7003  	h.GetRepositoryID()
  7004  	h = nil
  7005  	h.GetRepositoryID()
  7006  }
  7007  
  7008  func TestHookDelivery_GetRequest(tt *testing.T) {
  7009  	h := &HookDelivery{}
  7010  	h.GetRequest()
  7011  	h = nil
  7012  	h.GetRequest()
  7013  }
  7014  
  7015  func TestHookDelivery_GetResponse(tt *testing.T) {
  7016  	h := &HookDelivery{}
  7017  	h.GetResponse()
  7018  	h = nil
  7019  	h.GetResponse()
  7020  }
  7021  
  7022  func TestHookDelivery_GetStatus(tt *testing.T) {
  7023  	var zeroValue string
  7024  	h := &HookDelivery{Status: &zeroValue}
  7025  	h.GetStatus()
  7026  	h = &HookDelivery{}
  7027  	h.GetStatus()
  7028  	h = nil
  7029  	h.GetStatus()
  7030  }
  7031  
  7032  func TestHookDelivery_GetStatusCode(tt *testing.T) {
  7033  	var zeroValue int
  7034  	h := &HookDelivery{StatusCode: &zeroValue}
  7035  	h.GetStatusCode()
  7036  	h = &HookDelivery{}
  7037  	h.GetStatusCode()
  7038  	h = nil
  7039  	h.GetStatusCode()
  7040  }
  7041  
  7042  func TestHookRequest_GetHeaders(tt *testing.T) {
  7043  	zeroValue := map[string]string{}
  7044  	h := &HookRequest{Headers: zeroValue}
  7045  	h.GetHeaders()
  7046  	h = &HookRequest{}
  7047  	h.GetHeaders()
  7048  	h = nil
  7049  	h.GetHeaders()
  7050  }
  7051  
  7052  func TestHookRequest_GetRawPayload(tt *testing.T) {
  7053  	var zeroValue json.RawMessage
  7054  	h := &HookRequest{RawPayload: &zeroValue}
  7055  	h.GetRawPayload()
  7056  	h = &HookRequest{}
  7057  	h.GetRawPayload()
  7058  	h = nil
  7059  	h.GetRawPayload()
  7060  }
  7061  
  7062  func TestHookResponse_GetHeaders(tt *testing.T) {
  7063  	zeroValue := map[string]string{}
  7064  	h := &HookResponse{Headers: zeroValue}
  7065  	h.GetHeaders()
  7066  	h = &HookResponse{}
  7067  	h.GetHeaders()
  7068  	h = nil
  7069  	h.GetHeaders()
  7070  }
  7071  
  7072  func TestHookResponse_GetRawPayload(tt *testing.T) {
  7073  	var zeroValue json.RawMessage
  7074  	h := &HookResponse{RawPayload: &zeroValue}
  7075  	h.GetRawPayload()
  7076  	h = &HookResponse{}
  7077  	h.GetRawPayload()
  7078  	h = nil
  7079  	h.GetRawPayload()
  7080  }
  7081  
  7082  func TestHookStats_GetActiveHooks(tt *testing.T) {
  7083  	var zeroValue int
  7084  	h := &HookStats{ActiveHooks: &zeroValue}
  7085  	h.GetActiveHooks()
  7086  	h = &HookStats{}
  7087  	h.GetActiveHooks()
  7088  	h = nil
  7089  	h.GetActiveHooks()
  7090  }
  7091  
  7092  func TestHookStats_GetInactiveHooks(tt *testing.T) {
  7093  	var zeroValue int
  7094  	h := &HookStats{InactiveHooks: &zeroValue}
  7095  	h.GetInactiveHooks()
  7096  	h = &HookStats{}
  7097  	h.GetInactiveHooks()
  7098  	h = nil
  7099  	h.GetInactiveHooks()
  7100  }
  7101  
  7102  func TestHookStats_GetTotalHooks(tt *testing.T) {
  7103  	var zeroValue int
  7104  	h := &HookStats{TotalHooks: &zeroValue}
  7105  	h.GetTotalHooks()
  7106  	h = &HookStats{}
  7107  	h.GetTotalHooks()
  7108  	h = nil
  7109  	h.GetTotalHooks()
  7110  }
  7111  
  7112  func TestIDPGroup_GetGroupDescription(tt *testing.T) {
  7113  	var zeroValue string
  7114  	i := &IDPGroup{GroupDescription: &zeroValue}
  7115  	i.GetGroupDescription()
  7116  	i = &IDPGroup{}
  7117  	i.GetGroupDescription()
  7118  	i = nil
  7119  	i.GetGroupDescription()
  7120  }
  7121  
  7122  func TestIDPGroup_GetGroupID(tt *testing.T) {
  7123  	var zeroValue string
  7124  	i := &IDPGroup{GroupID: &zeroValue}
  7125  	i.GetGroupID()
  7126  	i = &IDPGroup{}
  7127  	i.GetGroupID()
  7128  	i = nil
  7129  	i.GetGroupID()
  7130  }
  7131  
  7132  func TestIDPGroup_GetGroupName(tt *testing.T) {
  7133  	var zeroValue string
  7134  	i := &IDPGroup{GroupName: &zeroValue}
  7135  	i.GetGroupName()
  7136  	i = &IDPGroup{}
  7137  	i.GetGroupName()
  7138  	i = nil
  7139  	i.GetGroupName()
  7140  }
  7141  
  7142  func TestImport_GetAuthorsCount(tt *testing.T) {
  7143  	var zeroValue int
  7144  	i := &Import{AuthorsCount: &zeroValue}
  7145  	i.GetAuthorsCount()
  7146  	i = &Import{}
  7147  	i.GetAuthorsCount()
  7148  	i = nil
  7149  	i.GetAuthorsCount()
  7150  }
  7151  
  7152  func TestImport_GetAuthorsURL(tt *testing.T) {
  7153  	var zeroValue string
  7154  	i := &Import{AuthorsURL: &zeroValue}
  7155  	i.GetAuthorsURL()
  7156  	i = &Import{}
  7157  	i.GetAuthorsURL()
  7158  	i = nil
  7159  	i.GetAuthorsURL()
  7160  }
  7161  
  7162  func TestImport_GetCommitCount(tt *testing.T) {
  7163  	var zeroValue int
  7164  	i := &Import{CommitCount: &zeroValue}
  7165  	i.GetCommitCount()
  7166  	i = &Import{}
  7167  	i.GetCommitCount()
  7168  	i = nil
  7169  	i.GetCommitCount()
  7170  }
  7171  
  7172  func TestImport_GetFailedStep(tt *testing.T) {
  7173  	var zeroValue string
  7174  	i := &Import{FailedStep: &zeroValue}
  7175  	i.GetFailedStep()
  7176  	i = &Import{}
  7177  	i.GetFailedStep()
  7178  	i = nil
  7179  	i.GetFailedStep()
  7180  }
  7181  
  7182  func TestImport_GetHasLargeFiles(tt *testing.T) {
  7183  	var zeroValue bool
  7184  	i := &Import{HasLargeFiles: &zeroValue}
  7185  	i.GetHasLargeFiles()
  7186  	i = &Import{}
  7187  	i.GetHasLargeFiles()
  7188  	i = nil
  7189  	i.GetHasLargeFiles()
  7190  }
  7191  
  7192  func TestImport_GetHTMLURL(tt *testing.T) {
  7193  	var zeroValue string
  7194  	i := &Import{HTMLURL: &zeroValue}
  7195  	i.GetHTMLURL()
  7196  	i = &Import{}
  7197  	i.GetHTMLURL()
  7198  	i = nil
  7199  	i.GetHTMLURL()
  7200  }
  7201  
  7202  func TestImport_GetHumanName(tt *testing.T) {
  7203  	var zeroValue string
  7204  	i := &Import{HumanName: &zeroValue}
  7205  	i.GetHumanName()
  7206  	i = &Import{}
  7207  	i.GetHumanName()
  7208  	i = nil
  7209  	i.GetHumanName()
  7210  }
  7211  
  7212  func TestImport_GetLargeFilesCount(tt *testing.T) {
  7213  	var zeroValue int
  7214  	i := &Import{LargeFilesCount: &zeroValue}
  7215  	i.GetLargeFilesCount()
  7216  	i = &Import{}
  7217  	i.GetLargeFilesCount()
  7218  	i = nil
  7219  	i.GetLargeFilesCount()
  7220  }
  7221  
  7222  func TestImport_GetLargeFilesSize(tt *testing.T) {
  7223  	var zeroValue int
  7224  	i := &Import{LargeFilesSize: &zeroValue}
  7225  	i.GetLargeFilesSize()
  7226  	i = &Import{}
  7227  	i.GetLargeFilesSize()
  7228  	i = nil
  7229  	i.GetLargeFilesSize()
  7230  }
  7231  
  7232  func TestImport_GetMessage(tt *testing.T) {
  7233  	var zeroValue string
  7234  	i := &Import{Message: &zeroValue}
  7235  	i.GetMessage()
  7236  	i = &Import{}
  7237  	i.GetMessage()
  7238  	i = nil
  7239  	i.GetMessage()
  7240  }
  7241  
  7242  func TestImport_GetPercent(tt *testing.T) {
  7243  	var zeroValue int
  7244  	i := &Import{Percent: &zeroValue}
  7245  	i.GetPercent()
  7246  	i = &Import{}
  7247  	i.GetPercent()
  7248  	i = nil
  7249  	i.GetPercent()
  7250  }
  7251  
  7252  func TestImport_GetPushPercent(tt *testing.T) {
  7253  	var zeroValue int
  7254  	i := &Import{PushPercent: &zeroValue}
  7255  	i.GetPushPercent()
  7256  	i = &Import{}
  7257  	i.GetPushPercent()
  7258  	i = nil
  7259  	i.GetPushPercent()
  7260  }
  7261  
  7262  func TestImport_GetRepositoryURL(tt *testing.T) {
  7263  	var zeroValue string
  7264  	i := &Import{RepositoryURL: &zeroValue}
  7265  	i.GetRepositoryURL()
  7266  	i = &Import{}
  7267  	i.GetRepositoryURL()
  7268  	i = nil
  7269  	i.GetRepositoryURL()
  7270  }
  7271  
  7272  func TestImport_GetStatus(tt *testing.T) {
  7273  	var zeroValue string
  7274  	i := &Import{Status: &zeroValue}
  7275  	i.GetStatus()
  7276  	i = &Import{}
  7277  	i.GetStatus()
  7278  	i = nil
  7279  	i.GetStatus()
  7280  }
  7281  
  7282  func TestImport_GetStatusText(tt *testing.T) {
  7283  	var zeroValue string
  7284  	i := &Import{StatusText: &zeroValue}
  7285  	i.GetStatusText()
  7286  	i = &Import{}
  7287  	i.GetStatusText()
  7288  	i = nil
  7289  	i.GetStatusText()
  7290  }
  7291  
  7292  func TestImport_GetTFVCProject(tt *testing.T) {
  7293  	var zeroValue string
  7294  	i := &Import{TFVCProject: &zeroValue}
  7295  	i.GetTFVCProject()
  7296  	i = &Import{}
  7297  	i.GetTFVCProject()
  7298  	i = nil
  7299  	i.GetTFVCProject()
  7300  }
  7301  
  7302  func TestImport_GetURL(tt *testing.T) {
  7303  	var zeroValue string
  7304  	i := &Import{URL: &zeroValue}
  7305  	i.GetURL()
  7306  	i = &Import{}
  7307  	i.GetURL()
  7308  	i = nil
  7309  	i.GetURL()
  7310  }
  7311  
  7312  func TestImport_GetUseLFS(tt *testing.T) {
  7313  	var zeroValue string
  7314  	i := &Import{UseLFS: &zeroValue}
  7315  	i.GetUseLFS()
  7316  	i = &Import{}
  7317  	i.GetUseLFS()
  7318  	i = nil
  7319  	i.GetUseLFS()
  7320  }
  7321  
  7322  func TestImport_GetVCS(tt *testing.T) {
  7323  	var zeroValue string
  7324  	i := &Import{VCS: &zeroValue}
  7325  	i.GetVCS()
  7326  	i = &Import{}
  7327  	i.GetVCS()
  7328  	i = nil
  7329  	i.GetVCS()
  7330  }
  7331  
  7332  func TestImport_GetVCSPassword(tt *testing.T) {
  7333  	var zeroValue string
  7334  	i := &Import{VCSPassword: &zeroValue}
  7335  	i.GetVCSPassword()
  7336  	i = &Import{}
  7337  	i.GetVCSPassword()
  7338  	i = nil
  7339  	i.GetVCSPassword()
  7340  }
  7341  
  7342  func TestImport_GetVCSURL(tt *testing.T) {
  7343  	var zeroValue string
  7344  	i := &Import{VCSURL: &zeroValue}
  7345  	i.GetVCSURL()
  7346  	i = &Import{}
  7347  	i.GetVCSURL()
  7348  	i = nil
  7349  	i.GetVCSURL()
  7350  }
  7351  
  7352  func TestImport_GetVCSUsername(tt *testing.T) {
  7353  	var zeroValue string
  7354  	i := &Import{VCSUsername: &zeroValue}
  7355  	i.GetVCSUsername()
  7356  	i = &Import{}
  7357  	i.GetVCSUsername()
  7358  	i = nil
  7359  	i.GetVCSUsername()
  7360  }
  7361  
  7362  func TestInstallation_GetAccessTokensURL(tt *testing.T) {
  7363  	var zeroValue string
  7364  	i := &Installation{AccessTokensURL: &zeroValue}
  7365  	i.GetAccessTokensURL()
  7366  	i = &Installation{}
  7367  	i.GetAccessTokensURL()
  7368  	i = nil
  7369  	i.GetAccessTokensURL()
  7370  }
  7371  
  7372  func TestInstallation_GetAccount(tt *testing.T) {
  7373  	i := &Installation{}
  7374  	i.GetAccount()
  7375  	i = nil
  7376  	i.GetAccount()
  7377  }
  7378  
  7379  func TestInstallation_GetAppID(tt *testing.T) {
  7380  	var zeroValue int64
  7381  	i := &Installation{AppID: &zeroValue}
  7382  	i.GetAppID()
  7383  	i = &Installation{}
  7384  	i.GetAppID()
  7385  	i = nil
  7386  	i.GetAppID()
  7387  }
  7388  
  7389  func TestInstallation_GetAppSlug(tt *testing.T) {
  7390  	var zeroValue string
  7391  	i := &Installation{AppSlug: &zeroValue}
  7392  	i.GetAppSlug()
  7393  	i = &Installation{}
  7394  	i.GetAppSlug()
  7395  	i = nil
  7396  	i.GetAppSlug()
  7397  }
  7398  
  7399  func TestInstallation_GetCreatedAt(tt *testing.T) {
  7400  	var zeroValue Timestamp
  7401  	i := &Installation{CreatedAt: &zeroValue}
  7402  	i.GetCreatedAt()
  7403  	i = &Installation{}
  7404  	i.GetCreatedAt()
  7405  	i = nil
  7406  	i.GetCreatedAt()
  7407  }
  7408  
  7409  func TestInstallation_GetHasMultipleSingleFiles(tt *testing.T) {
  7410  	var zeroValue bool
  7411  	i := &Installation{HasMultipleSingleFiles: &zeroValue}
  7412  	i.GetHasMultipleSingleFiles()
  7413  	i = &Installation{}
  7414  	i.GetHasMultipleSingleFiles()
  7415  	i = nil
  7416  	i.GetHasMultipleSingleFiles()
  7417  }
  7418  
  7419  func TestInstallation_GetHTMLURL(tt *testing.T) {
  7420  	var zeroValue string
  7421  	i := &Installation{HTMLURL: &zeroValue}
  7422  	i.GetHTMLURL()
  7423  	i = &Installation{}
  7424  	i.GetHTMLURL()
  7425  	i = nil
  7426  	i.GetHTMLURL()
  7427  }
  7428  
  7429  func TestInstallation_GetID(tt *testing.T) {
  7430  	var zeroValue int64
  7431  	i := &Installation{ID: &zeroValue}
  7432  	i.GetID()
  7433  	i = &Installation{}
  7434  	i.GetID()
  7435  	i = nil
  7436  	i.GetID()
  7437  }
  7438  
  7439  func TestInstallation_GetNodeID(tt *testing.T) {
  7440  	var zeroValue string
  7441  	i := &Installation{NodeID: &zeroValue}
  7442  	i.GetNodeID()
  7443  	i = &Installation{}
  7444  	i.GetNodeID()
  7445  	i = nil
  7446  	i.GetNodeID()
  7447  }
  7448  
  7449  func TestInstallation_GetPermissions(tt *testing.T) {
  7450  	i := &Installation{}
  7451  	i.GetPermissions()
  7452  	i = nil
  7453  	i.GetPermissions()
  7454  }
  7455  
  7456  func TestInstallation_GetRepositoriesURL(tt *testing.T) {
  7457  	var zeroValue string
  7458  	i := &Installation{RepositoriesURL: &zeroValue}
  7459  	i.GetRepositoriesURL()
  7460  	i = &Installation{}
  7461  	i.GetRepositoriesURL()
  7462  	i = nil
  7463  	i.GetRepositoriesURL()
  7464  }
  7465  
  7466  func TestInstallation_GetRepositorySelection(tt *testing.T) {
  7467  	var zeroValue string
  7468  	i := &Installation{RepositorySelection: &zeroValue}
  7469  	i.GetRepositorySelection()
  7470  	i = &Installation{}
  7471  	i.GetRepositorySelection()
  7472  	i = nil
  7473  	i.GetRepositorySelection()
  7474  }
  7475  
  7476  func TestInstallation_GetSingleFileName(tt *testing.T) {
  7477  	var zeroValue string
  7478  	i := &Installation{SingleFileName: &zeroValue}
  7479  	i.GetSingleFileName()
  7480  	i = &Installation{}
  7481  	i.GetSingleFileName()
  7482  	i = nil
  7483  	i.GetSingleFileName()
  7484  }
  7485  
  7486  func TestInstallation_GetSuspendedAt(tt *testing.T) {
  7487  	var zeroValue Timestamp
  7488  	i := &Installation{SuspendedAt: &zeroValue}
  7489  	i.GetSuspendedAt()
  7490  	i = &Installation{}
  7491  	i.GetSuspendedAt()
  7492  	i = nil
  7493  	i.GetSuspendedAt()
  7494  }
  7495  
  7496  func TestInstallation_GetSuspendedBy(tt *testing.T) {
  7497  	i := &Installation{}
  7498  	i.GetSuspendedBy()
  7499  	i = nil
  7500  	i.GetSuspendedBy()
  7501  }
  7502  
  7503  func TestInstallation_GetTargetID(tt *testing.T) {
  7504  	var zeroValue int64
  7505  	i := &Installation{TargetID: &zeroValue}
  7506  	i.GetTargetID()
  7507  	i = &Installation{}
  7508  	i.GetTargetID()
  7509  	i = nil
  7510  	i.GetTargetID()
  7511  }
  7512  
  7513  func TestInstallation_GetTargetType(tt *testing.T) {
  7514  	var zeroValue string
  7515  	i := &Installation{TargetType: &zeroValue}
  7516  	i.GetTargetType()
  7517  	i = &Installation{}
  7518  	i.GetTargetType()
  7519  	i = nil
  7520  	i.GetTargetType()
  7521  }
  7522  
  7523  func TestInstallation_GetUpdatedAt(tt *testing.T) {
  7524  	var zeroValue Timestamp
  7525  	i := &Installation{UpdatedAt: &zeroValue}
  7526  	i.GetUpdatedAt()
  7527  	i = &Installation{}
  7528  	i.GetUpdatedAt()
  7529  	i = nil
  7530  	i.GetUpdatedAt()
  7531  }
  7532  
  7533  func TestInstallationEvent_GetAction(tt *testing.T) {
  7534  	var zeroValue string
  7535  	i := &InstallationEvent{Action: &zeroValue}
  7536  	i.GetAction()
  7537  	i = &InstallationEvent{}
  7538  	i.GetAction()
  7539  	i = nil
  7540  	i.GetAction()
  7541  }
  7542  
  7543  func TestInstallationEvent_GetInstallation(tt *testing.T) {
  7544  	i := &InstallationEvent{}
  7545  	i.GetInstallation()
  7546  	i = nil
  7547  	i.GetInstallation()
  7548  }
  7549  
  7550  func TestInstallationEvent_GetSender(tt *testing.T) {
  7551  	i := &InstallationEvent{}
  7552  	i.GetSender()
  7553  	i = nil
  7554  	i.GetSender()
  7555  }
  7556  
  7557  func TestInstallationPermissions_GetActions(tt *testing.T) {
  7558  	var zeroValue string
  7559  	i := &InstallationPermissions{Actions: &zeroValue}
  7560  	i.GetActions()
  7561  	i = &InstallationPermissions{}
  7562  	i.GetActions()
  7563  	i = nil
  7564  	i.GetActions()
  7565  }
  7566  
  7567  func TestInstallationPermissions_GetAdministration(tt *testing.T) {
  7568  	var zeroValue string
  7569  	i := &InstallationPermissions{Administration: &zeroValue}
  7570  	i.GetAdministration()
  7571  	i = &InstallationPermissions{}
  7572  	i.GetAdministration()
  7573  	i = nil
  7574  	i.GetAdministration()
  7575  }
  7576  
  7577  func TestInstallationPermissions_GetBlocking(tt *testing.T) {
  7578  	var zeroValue string
  7579  	i := &InstallationPermissions{Blocking: &zeroValue}
  7580  	i.GetBlocking()
  7581  	i = &InstallationPermissions{}
  7582  	i.GetBlocking()
  7583  	i = nil
  7584  	i.GetBlocking()
  7585  }
  7586  
  7587  func TestInstallationPermissions_GetChecks(tt *testing.T) {
  7588  	var zeroValue string
  7589  	i := &InstallationPermissions{Checks: &zeroValue}
  7590  	i.GetChecks()
  7591  	i = &InstallationPermissions{}
  7592  	i.GetChecks()
  7593  	i = nil
  7594  	i.GetChecks()
  7595  }
  7596  
  7597  func TestInstallationPermissions_GetContentReferences(tt *testing.T) {
  7598  	var zeroValue string
  7599  	i := &InstallationPermissions{ContentReferences: &zeroValue}
  7600  	i.GetContentReferences()
  7601  	i = &InstallationPermissions{}
  7602  	i.GetContentReferences()
  7603  	i = nil
  7604  	i.GetContentReferences()
  7605  }
  7606  
  7607  func TestInstallationPermissions_GetContents(tt *testing.T) {
  7608  	var zeroValue string
  7609  	i := &InstallationPermissions{Contents: &zeroValue}
  7610  	i.GetContents()
  7611  	i = &InstallationPermissions{}
  7612  	i.GetContents()
  7613  	i = nil
  7614  	i.GetContents()
  7615  }
  7616  
  7617  func TestInstallationPermissions_GetDeployments(tt *testing.T) {
  7618  	var zeroValue string
  7619  	i := &InstallationPermissions{Deployments: &zeroValue}
  7620  	i.GetDeployments()
  7621  	i = &InstallationPermissions{}
  7622  	i.GetDeployments()
  7623  	i = nil
  7624  	i.GetDeployments()
  7625  }
  7626  
  7627  func TestInstallationPermissions_GetEmails(tt *testing.T) {
  7628  	var zeroValue string
  7629  	i := &InstallationPermissions{Emails: &zeroValue}
  7630  	i.GetEmails()
  7631  	i = &InstallationPermissions{}
  7632  	i.GetEmails()
  7633  	i = nil
  7634  	i.GetEmails()
  7635  }
  7636  
  7637  func TestInstallationPermissions_GetEnvironments(tt *testing.T) {
  7638  	var zeroValue string
  7639  	i := &InstallationPermissions{Environments: &zeroValue}
  7640  	i.GetEnvironments()
  7641  	i = &InstallationPermissions{}
  7642  	i.GetEnvironments()
  7643  	i = nil
  7644  	i.GetEnvironments()
  7645  }
  7646  
  7647  func TestInstallationPermissions_GetFollowers(tt *testing.T) {
  7648  	var zeroValue string
  7649  	i := &InstallationPermissions{Followers: &zeroValue}
  7650  	i.GetFollowers()
  7651  	i = &InstallationPermissions{}
  7652  	i.GetFollowers()
  7653  	i = nil
  7654  	i.GetFollowers()
  7655  }
  7656  
  7657  func TestInstallationPermissions_GetIssues(tt *testing.T) {
  7658  	var zeroValue string
  7659  	i := &InstallationPermissions{Issues: &zeroValue}
  7660  	i.GetIssues()
  7661  	i = &InstallationPermissions{}
  7662  	i.GetIssues()
  7663  	i = nil
  7664  	i.GetIssues()
  7665  }
  7666  
  7667  func TestInstallationPermissions_GetMembers(tt *testing.T) {
  7668  	var zeroValue string
  7669  	i := &InstallationPermissions{Members: &zeroValue}
  7670  	i.GetMembers()
  7671  	i = &InstallationPermissions{}
  7672  	i.GetMembers()
  7673  	i = nil
  7674  	i.GetMembers()
  7675  }
  7676  
  7677  func TestInstallationPermissions_GetMetadata(tt *testing.T) {
  7678  	var zeroValue string
  7679  	i := &InstallationPermissions{Metadata: &zeroValue}
  7680  	i.GetMetadata()
  7681  	i = &InstallationPermissions{}
  7682  	i.GetMetadata()
  7683  	i = nil
  7684  	i.GetMetadata()
  7685  }
  7686  
  7687  func TestInstallationPermissions_GetOrganizationAdministration(tt *testing.T) {
  7688  	var zeroValue string
  7689  	i := &InstallationPermissions{OrganizationAdministration: &zeroValue}
  7690  	i.GetOrganizationAdministration()
  7691  	i = &InstallationPermissions{}
  7692  	i.GetOrganizationAdministration()
  7693  	i = nil
  7694  	i.GetOrganizationAdministration()
  7695  }
  7696  
  7697  func TestInstallationPermissions_GetOrganizationHooks(tt *testing.T) {
  7698  	var zeroValue string
  7699  	i := &InstallationPermissions{OrganizationHooks: &zeroValue}
  7700  	i.GetOrganizationHooks()
  7701  	i = &InstallationPermissions{}
  7702  	i.GetOrganizationHooks()
  7703  	i = nil
  7704  	i.GetOrganizationHooks()
  7705  }
  7706  
  7707  func TestInstallationPermissions_GetOrganizationPlan(tt *testing.T) {
  7708  	var zeroValue string
  7709  	i := &InstallationPermissions{OrganizationPlan: &zeroValue}
  7710  	i.GetOrganizationPlan()
  7711  	i = &InstallationPermissions{}
  7712  	i.GetOrganizationPlan()
  7713  	i = nil
  7714  	i.GetOrganizationPlan()
  7715  }
  7716  
  7717  func TestInstallationPermissions_GetOrganizationPreReceiveHooks(tt *testing.T) {
  7718  	var zeroValue string
  7719  	i := &InstallationPermissions{OrganizationPreReceiveHooks: &zeroValue}
  7720  	i.GetOrganizationPreReceiveHooks()
  7721  	i = &InstallationPermissions{}
  7722  	i.GetOrganizationPreReceiveHooks()
  7723  	i = nil
  7724  	i.GetOrganizationPreReceiveHooks()
  7725  }
  7726  
  7727  func TestInstallationPermissions_GetOrganizationProjects(tt *testing.T) {
  7728  	var zeroValue string
  7729  	i := &InstallationPermissions{OrganizationProjects: &zeroValue}
  7730  	i.GetOrganizationProjects()
  7731  	i = &InstallationPermissions{}
  7732  	i.GetOrganizationProjects()
  7733  	i = nil
  7734  	i.GetOrganizationProjects()
  7735  }
  7736  
  7737  func TestInstallationPermissions_GetOrganizationSecrets(tt *testing.T) {
  7738  	var zeroValue string
  7739  	i := &InstallationPermissions{OrganizationSecrets: &zeroValue}
  7740  	i.GetOrganizationSecrets()
  7741  	i = &InstallationPermissions{}
  7742  	i.GetOrganizationSecrets()
  7743  	i = nil
  7744  	i.GetOrganizationSecrets()
  7745  }
  7746  
  7747  func TestInstallationPermissions_GetOrganizationSelfHostedRunners(tt *testing.T) {
  7748  	var zeroValue string
  7749  	i := &InstallationPermissions{OrganizationSelfHostedRunners: &zeroValue}
  7750  	i.GetOrganizationSelfHostedRunners()
  7751  	i = &InstallationPermissions{}
  7752  	i.GetOrganizationSelfHostedRunners()
  7753  	i = nil
  7754  	i.GetOrganizationSelfHostedRunners()
  7755  }
  7756  
  7757  func TestInstallationPermissions_GetOrganizationUserBlocking(tt *testing.T) {
  7758  	var zeroValue string
  7759  	i := &InstallationPermissions{OrganizationUserBlocking: &zeroValue}
  7760  	i.GetOrganizationUserBlocking()
  7761  	i = &InstallationPermissions{}
  7762  	i.GetOrganizationUserBlocking()
  7763  	i = nil
  7764  	i.GetOrganizationUserBlocking()
  7765  }
  7766  
  7767  func TestInstallationPermissions_GetPackages(tt *testing.T) {
  7768  	var zeroValue string
  7769  	i := &InstallationPermissions{Packages: &zeroValue}
  7770  	i.GetPackages()
  7771  	i = &InstallationPermissions{}
  7772  	i.GetPackages()
  7773  	i = nil
  7774  	i.GetPackages()
  7775  }
  7776  
  7777  func TestInstallationPermissions_GetPages(tt *testing.T) {
  7778  	var zeroValue string
  7779  	i := &InstallationPermissions{Pages: &zeroValue}
  7780  	i.GetPages()
  7781  	i = &InstallationPermissions{}
  7782  	i.GetPages()
  7783  	i = nil
  7784  	i.GetPages()
  7785  }
  7786  
  7787  func TestInstallationPermissions_GetPullRequests(tt *testing.T) {
  7788  	var zeroValue string
  7789  	i := &InstallationPermissions{PullRequests: &zeroValue}
  7790  	i.GetPullRequests()
  7791  	i = &InstallationPermissions{}
  7792  	i.GetPullRequests()
  7793  	i = nil
  7794  	i.GetPullRequests()
  7795  }
  7796  
  7797  func TestInstallationPermissions_GetRepositoryHooks(tt *testing.T) {
  7798  	var zeroValue string
  7799  	i := &InstallationPermissions{RepositoryHooks: &zeroValue}
  7800  	i.GetRepositoryHooks()
  7801  	i = &InstallationPermissions{}
  7802  	i.GetRepositoryHooks()
  7803  	i = nil
  7804  	i.GetRepositoryHooks()
  7805  }
  7806  
  7807  func TestInstallationPermissions_GetRepositoryPreReceiveHooks(tt *testing.T) {
  7808  	var zeroValue string
  7809  	i := &InstallationPermissions{RepositoryPreReceiveHooks: &zeroValue}
  7810  	i.GetRepositoryPreReceiveHooks()
  7811  	i = &InstallationPermissions{}
  7812  	i.GetRepositoryPreReceiveHooks()
  7813  	i = nil
  7814  	i.GetRepositoryPreReceiveHooks()
  7815  }
  7816  
  7817  func TestInstallationPermissions_GetRepositoryProjects(tt *testing.T) {
  7818  	var zeroValue string
  7819  	i := &InstallationPermissions{RepositoryProjects: &zeroValue}
  7820  	i.GetRepositoryProjects()
  7821  	i = &InstallationPermissions{}
  7822  	i.GetRepositoryProjects()
  7823  	i = nil
  7824  	i.GetRepositoryProjects()
  7825  }
  7826  
  7827  func TestInstallationPermissions_GetSecrets(tt *testing.T) {
  7828  	var zeroValue string
  7829  	i := &InstallationPermissions{Secrets: &zeroValue}
  7830  	i.GetSecrets()
  7831  	i = &InstallationPermissions{}
  7832  	i.GetSecrets()
  7833  	i = nil
  7834  	i.GetSecrets()
  7835  }
  7836  
  7837  func TestInstallationPermissions_GetSecretScanningAlerts(tt *testing.T) {
  7838  	var zeroValue string
  7839  	i := &InstallationPermissions{SecretScanningAlerts: &zeroValue}
  7840  	i.GetSecretScanningAlerts()
  7841  	i = &InstallationPermissions{}
  7842  	i.GetSecretScanningAlerts()
  7843  	i = nil
  7844  	i.GetSecretScanningAlerts()
  7845  }
  7846  
  7847  func TestInstallationPermissions_GetSecurityEvents(tt *testing.T) {
  7848  	var zeroValue string
  7849  	i := &InstallationPermissions{SecurityEvents: &zeroValue}
  7850  	i.GetSecurityEvents()
  7851  	i = &InstallationPermissions{}
  7852  	i.GetSecurityEvents()
  7853  	i = nil
  7854  	i.GetSecurityEvents()
  7855  }
  7856  
  7857  func TestInstallationPermissions_GetSingleFile(tt *testing.T) {
  7858  	var zeroValue string
  7859  	i := &InstallationPermissions{SingleFile: &zeroValue}
  7860  	i.GetSingleFile()
  7861  	i = &InstallationPermissions{}
  7862  	i.GetSingleFile()
  7863  	i = nil
  7864  	i.GetSingleFile()
  7865  }
  7866  
  7867  func TestInstallationPermissions_GetStatuses(tt *testing.T) {
  7868  	var zeroValue string
  7869  	i := &InstallationPermissions{Statuses: &zeroValue}
  7870  	i.GetStatuses()
  7871  	i = &InstallationPermissions{}
  7872  	i.GetStatuses()
  7873  	i = nil
  7874  	i.GetStatuses()
  7875  }
  7876  
  7877  func TestInstallationPermissions_GetTeamDiscussions(tt *testing.T) {
  7878  	var zeroValue string
  7879  	i := &InstallationPermissions{TeamDiscussions: &zeroValue}
  7880  	i.GetTeamDiscussions()
  7881  	i = &InstallationPermissions{}
  7882  	i.GetTeamDiscussions()
  7883  	i = nil
  7884  	i.GetTeamDiscussions()
  7885  }
  7886  
  7887  func TestInstallationPermissions_GetVulnerabilityAlerts(tt *testing.T) {
  7888  	var zeroValue string
  7889  	i := &InstallationPermissions{VulnerabilityAlerts: &zeroValue}
  7890  	i.GetVulnerabilityAlerts()
  7891  	i = &InstallationPermissions{}
  7892  	i.GetVulnerabilityAlerts()
  7893  	i = nil
  7894  	i.GetVulnerabilityAlerts()
  7895  }
  7896  
  7897  func TestInstallationPermissions_GetWorkflows(tt *testing.T) {
  7898  	var zeroValue string
  7899  	i := &InstallationPermissions{Workflows: &zeroValue}
  7900  	i.GetWorkflows()
  7901  	i = &InstallationPermissions{}
  7902  	i.GetWorkflows()
  7903  	i = nil
  7904  	i.GetWorkflows()
  7905  }
  7906  
  7907  func TestInstallationRepositoriesEvent_GetAction(tt *testing.T) {
  7908  	var zeroValue string
  7909  	i := &InstallationRepositoriesEvent{Action: &zeroValue}
  7910  	i.GetAction()
  7911  	i = &InstallationRepositoriesEvent{}
  7912  	i.GetAction()
  7913  	i = nil
  7914  	i.GetAction()
  7915  }
  7916  
  7917  func TestInstallationRepositoriesEvent_GetInstallation(tt *testing.T) {
  7918  	i := &InstallationRepositoriesEvent{}
  7919  	i.GetInstallation()
  7920  	i = nil
  7921  	i.GetInstallation()
  7922  }
  7923  
  7924  func TestInstallationRepositoriesEvent_GetRepositorySelection(tt *testing.T) {
  7925  	var zeroValue string
  7926  	i := &InstallationRepositoriesEvent{RepositorySelection: &zeroValue}
  7927  	i.GetRepositorySelection()
  7928  	i = &InstallationRepositoriesEvent{}
  7929  	i.GetRepositorySelection()
  7930  	i = nil
  7931  	i.GetRepositorySelection()
  7932  }
  7933  
  7934  func TestInstallationRepositoriesEvent_GetSender(tt *testing.T) {
  7935  	i := &InstallationRepositoriesEvent{}
  7936  	i.GetSender()
  7937  	i = nil
  7938  	i.GetSender()
  7939  }
  7940  
  7941  func TestInstallationToken_GetExpiresAt(tt *testing.T) {
  7942  	var zeroValue time.Time
  7943  	i := &InstallationToken{ExpiresAt: &zeroValue}
  7944  	i.GetExpiresAt()
  7945  	i = &InstallationToken{}
  7946  	i.GetExpiresAt()
  7947  	i = nil
  7948  	i.GetExpiresAt()
  7949  }
  7950  
  7951  func TestInstallationToken_GetPermissions(tt *testing.T) {
  7952  	i := &InstallationToken{}
  7953  	i.GetPermissions()
  7954  	i = nil
  7955  	i.GetPermissions()
  7956  }
  7957  
  7958  func TestInstallationToken_GetToken(tt *testing.T) {
  7959  	var zeroValue string
  7960  	i := &InstallationToken{Token: &zeroValue}
  7961  	i.GetToken()
  7962  	i = &InstallationToken{}
  7963  	i.GetToken()
  7964  	i = nil
  7965  	i.GetToken()
  7966  }
  7967  
  7968  func TestInstallationTokenOptions_GetPermissions(tt *testing.T) {
  7969  	i := &InstallationTokenOptions{}
  7970  	i.GetPermissions()
  7971  	i = nil
  7972  	i.GetPermissions()
  7973  }
  7974  
  7975  func TestInteractionRestriction_GetExpiresAt(tt *testing.T) {
  7976  	var zeroValue Timestamp
  7977  	i := &InteractionRestriction{ExpiresAt: &zeroValue}
  7978  	i.GetExpiresAt()
  7979  	i = &InteractionRestriction{}
  7980  	i.GetExpiresAt()
  7981  	i = nil
  7982  	i.GetExpiresAt()
  7983  }
  7984  
  7985  func TestInteractionRestriction_GetLimit(tt *testing.T) {
  7986  	var zeroValue string
  7987  	i := &InteractionRestriction{Limit: &zeroValue}
  7988  	i.GetLimit()
  7989  	i = &InteractionRestriction{}
  7990  	i.GetLimit()
  7991  	i = nil
  7992  	i.GetLimit()
  7993  }
  7994  
  7995  func TestInteractionRestriction_GetOrigin(tt *testing.T) {
  7996  	var zeroValue string
  7997  	i := &InteractionRestriction{Origin: &zeroValue}
  7998  	i.GetOrigin()
  7999  	i = &InteractionRestriction{}
  8000  	i.GetOrigin()
  8001  	i = nil
  8002  	i.GetOrigin()
  8003  }
  8004  
  8005  func TestInvitation_GetCreatedAt(tt *testing.T) {
  8006  	var zeroValue time.Time
  8007  	i := &Invitation{CreatedAt: &zeroValue}
  8008  	i.GetCreatedAt()
  8009  	i = &Invitation{}
  8010  	i.GetCreatedAt()
  8011  	i = nil
  8012  	i.GetCreatedAt()
  8013  }
  8014  
  8015  func TestInvitation_GetEmail(tt *testing.T) {
  8016  	var zeroValue string
  8017  	i := &Invitation{Email: &zeroValue}
  8018  	i.GetEmail()
  8019  	i = &Invitation{}
  8020  	i.GetEmail()
  8021  	i = nil
  8022  	i.GetEmail()
  8023  }
  8024  
  8025  func TestInvitation_GetFailedAt(tt *testing.T) {
  8026  	var zeroValue Timestamp
  8027  	i := &Invitation{FailedAt: &zeroValue}
  8028  	i.GetFailedAt()
  8029  	i = &Invitation{}
  8030  	i.GetFailedAt()
  8031  	i = nil
  8032  	i.GetFailedAt()
  8033  }
  8034  
  8035  func TestInvitation_GetFailedReason(tt *testing.T) {
  8036  	var zeroValue string
  8037  	i := &Invitation{FailedReason: &zeroValue}
  8038  	i.GetFailedReason()
  8039  	i = &Invitation{}
  8040  	i.GetFailedReason()
  8041  	i = nil
  8042  	i.GetFailedReason()
  8043  }
  8044  
  8045  func TestInvitation_GetID(tt *testing.T) {
  8046  	var zeroValue int64
  8047  	i := &Invitation{ID: &zeroValue}
  8048  	i.GetID()
  8049  	i = &Invitation{}
  8050  	i.GetID()
  8051  	i = nil
  8052  	i.GetID()
  8053  }
  8054  
  8055  func TestInvitation_GetInvitationTeamURL(tt *testing.T) {
  8056  	var zeroValue string
  8057  	i := &Invitation{InvitationTeamURL: &zeroValue}
  8058  	i.GetInvitationTeamURL()
  8059  	i = &Invitation{}
  8060  	i.GetInvitationTeamURL()
  8061  	i = nil
  8062  	i.GetInvitationTeamURL()
  8063  }
  8064  
  8065  func TestInvitation_GetInviter(tt *testing.T) {
  8066  	i := &Invitation{}
  8067  	i.GetInviter()
  8068  	i = nil
  8069  	i.GetInviter()
  8070  }
  8071  
  8072  func TestInvitation_GetLogin(tt *testing.T) {
  8073  	var zeroValue string
  8074  	i := &Invitation{Login: &zeroValue}
  8075  	i.GetLogin()
  8076  	i = &Invitation{}
  8077  	i.GetLogin()
  8078  	i = nil
  8079  	i.GetLogin()
  8080  }
  8081  
  8082  func TestInvitation_GetNodeID(tt *testing.T) {
  8083  	var zeroValue string
  8084  	i := &Invitation{NodeID: &zeroValue}
  8085  	i.GetNodeID()
  8086  	i = &Invitation{}
  8087  	i.GetNodeID()
  8088  	i = nil
  8089  	i.GetNodeID()
  8090  }
  8091  
  8092  func TestInvitation_GetRole(tt *testing.T) {
  8093  	var zeroValue string
  8094  	i := &Invitation{Role: &zeroValue}
  8095  	i.GetRole()
  8096  	i = &Invitation{}
  8097  	i.GetRole()
  8098  	i = nil
  8099  	i.GetRole()
  8100  }
  8101  
  8102  func TestInvitation_GetTeamCount(tt *testing.T) {
  8103  	var zeroValue int
  8104  	i := &Invitation{TeamCount: &zeroValue}
  8105  	i.GetTeamCount()
  8106  	i = &Invitation{}
  8107  	i.GetTeamCount()
  8108  	i = nil
  8109  	i.GetTeamCount()
  8110  }
  8111  
  8112  func TestIssue_GetActiveLockReason(tt *testing.T) {
  8113  	var zeroValue string
  8114  	i := &Issue{ActiveLockReason: &zeroValue}
  8115  	i.GetActiveLockReason()
  8116  	i = &Issue{}
  8117  	i.GetActiveLockReason()
  8118  	i = nil
  8119  	i.GetActiveLockReason()
  8120  }
  8121  
  8122  func TestIssue_GetAssignee(tt *testing.T) {
  8123  	i := &Issue{}
  8124  	i.GetAssignee()
  8125  	i = nil
  8126  	i.GetAssignee()
  8127  }
  8128  
  8129  func TestIssue_GetAuthorAssociation(tt *testing.T) {
  8130  	var zeroValue string
  8131  	i := &Issue{AuthorAssociation: &zeroValue}
  8132  	i.GetAuthorAssociation()
  8133  	i = &Issue{}
  8134  	i.GetAuthorAssociation()
  8135  	i = nil
  8136  	i.GetAuthorAssociation()
  8137  }
  8138  
  8139  func TestIssue_GetBody(tt *testing.T) {
  8140  	var zeroValue string
  8141  	i := &Issue{Body: &zeroValue}
  8142  	i.GetBody()
  8143  	i = &Issue{}
  8144  	i.GetBody()
  8145  	i = nil
  8146  	i.GetBody()
  8147  }
  8148  
  8149  func TestIssue_GetClosedAt(tt *testing.T) {
  8150  	var zeroValue time.Time
  8151  	i := &Issue{ClosedAt: &zeroValue}
  8152  	i.GetClosedAt()
  8153  	i = &Issue{}
  8154  	i.GetClosedAt()
  8155  	i = nil
  8156  	i.GetClosedAt()
  8157  }
  8158  
  8159  func TestIssue_GetClosedBy(tt *testing.T) {
  8160  	i := &Issue{}
  8161  	i.GetClosedBy()
  8162  	i = nil
  8163  	i.GetClosedBy()
  8164  }
  8165  
  8166  func TestIssue_GetComments(tt *testing.T) {
  8167  	var zeroValue int
  8168  	i := &Issue{Comments: &zeroValue}
  8169  	i.GetComments()
  8170  	i = &Issue{}
  8171  	i.GetComments()
  8172  	i = nil
  8173  	i.GetComments()
  8174  }
  8175  
  8176  func TestIssue_GetCommentsURL(tt *testing.T) {
  8177  	var zeroValue string
  8178  	i := &Issue{CommentsURL: &zeroValue}
  8179  	i.GetCommentsURL()
  8180  	i = &Issue{}
  8181  	i.GetCommentsURL()
  8182  	i = nil
  8183  	i.GetCommentsURL()
  8184  }
  8185  
  8186  func TestIssue_GetCreatedAt(tt *testing.T) {
  8187  	var zeroValue time.Time
  8188  	i := &Issue{CreatedAt: &zeroValue}
  8189  	i.GetCreatedAt()
  8190  	i = &Issue{}
  8191  	i.GetCreatedAt()
  8192  	i = nil
  8193  	i.GetCreatedAt()
  8194  }
  8195  
  8196  func TestIssue_GetEventsURL(tt *testing.T) {
  8197  	var zeroValue string
  8198  	i := &Issue{EventsURL: &zeroValue}
  8199  	i.GetEventsURL()
  8200  	i = &Issue{}
  8201  	i.GetEventsURL()
  8202  	i = nil
  8203  	i.GetEventsURL()
  8204  }
  8205  
  8206  func TestIssue_GetHTMLURL(tt *testing.T) {
  8207  	var zeroValue string
  8208  	i := &Issue{HTMLURL: &zeroValue}
  8209  	i.GetHTMLURL()
  8210  	i = &Issue{}
  8211  	i.GetHTMLURL()
  8212  	i = nil
  8213  	i.GetHTMLURL()
  8214  }
  8215  
  8216  func TestIssue_GetID(tt *testing.T) {
  8217  	var zeroValue int64
  8218  	i := &Issue{ID: &zeroValue}
  8219  	i.GetID()
  8220  	i = &Issue{}
  8221  	i.GetID()
  8222  	i = nil
  8223  	i.GetID()
  8224  }
  8225  
  8226  func TestIssue_GetLabelsURL(tt *testing.T) {
  8227  	var zeroValue string
  8228  	i := &Issue{LabelsURL: &zeroValue}
  8229  	i.GetLabelsURL()
  8230  	i = &Issue{}
  8231  	i.GetLabelsURL()
  8232  	i = nil
  8233  	i.GetLabelsURL()
  8234  }
  8235  
  8236  func TestIssue_GetLocked(tt *testing.T) {
  8237  	var zeroValue bool
  8238  	i := &Issue{Locked: &zeroValue}
  8239  	i.GetLocked()
  8240  	i = &Issue{}
  8241  	i.GetLocked()
  8242  	i = nil
  8243  	i.GetLocked()
  8244  }
  8245  
  8246  func TestIssue_GetMilestone(tt *testing.T) {
  8247  	i := &Issue{}
  8248  	i.GetMilestone()
  8249  	i = nil
  8250  	i.GetMilestone()
  8251  }
  8252  
  8253  func TestIssue_GetNodeID(tt *testing.T) {
  8254  	var zeroValue string
  8255  	i := &Issue{NodeID: &zeroValue}
  8256  	i.GetNodeID()
  8257  	i = &Issue{}
  8258  	i.GetNodeID()
  8259  	i = nil
  8260  	i.GetNodeID()
  8261  }
  8262  
  8263  func TestIssue_GetNumber(tt *testing.T) {
  8264  	var zeroValue int
  8265  	i := &Issue{Number: &zeroValue}
  8266  	i.GetNumber()
  8267  	i = &Issue{}
  8268  	i.GetNumber()
  8269  	i = nil
  8270  	i.GetNumber()
  8271  }
  8272  
  8273  func TestIssue_GetPullRequestLinks(tt *testing.T) {
  8274  	i := &Issue{}
  8275  	i.GetPullRequestLinks()
  8276  	i = nil
  8277  	i.GetPullRequestLinks()
  8278  }
  8279  
  8280  func TestIssue_GetReactions(tt *testing.T) {
  8281  	i := &Issue{}
  8282  	i.GetReactions()
  8283  	i = nil
  8284  	i.GetReactions()
  8285  }
  8286  
  8287  func TestIssue_GetRepository(tt *testing.T) {
  8288  	i := &Issue{}
  8289  	i.GetRepository()
  8290  	i = nil
  8291  	i.GetRepository()
  8292  }
  8293  
  8294  func TestIssue_GetRepositoryURL(tt *testing.T) {
  8295  	var zeroValue string
  8296  	i := &Issue{RepositoryURL: &zeroValue}
  8297  	i.GetRepositoryURL()
  8298  	i = &Issue{}
  8299  	i.GetRepositoryURL()
  8300  	i = nil
  8301  	i.GetRepositoryURL()
  8302  }
  8303  
  8304  func TestIssue_GetState(tt *testing.T) {
  8305  	var zeroValue string
  8306  	i := &Issue{State: &zeroValue}
  8307  	i.GetState()
  8308  	i = &Issue{}
  8309  	i.GetState()
  8310  	i = nil
  8311  	i.GetState()
  8312  }
  8313  
  8314  func TestIssue_GetTitle(tt *testing.T) {
  8315  	var zeroValue string
  8316  	i := &Issue{Title: &zeroValue}
  8317  	i.GetTitle()
  8318  	i = &Issue{}
  8319  	i.GetTitle()
  8320  	i = nil
  8321  	i.GetTitle()
  8322  }
  8323  
  8324  func TestIssue_GetUpdatedAt(tt *testing.T) {
  8325  	var zeroValue time.Time
  8326  	i := &Issue{UpdatedAt: &zeroValue}
  8327  	i.GetUpdatedAt()
  8328  	i = &Issue{}
  8329  	i.GetUpdatedAt()
  8330  	i = nil
  8331  	i.GetUpdatedAt()
  8332  }
  8333  
  8334  func TestIssue_GetURL(tt *testing.T) {
  8335  	var zeroValue string
  8336  	i := &Issue{URL: &zeroValue}
  8337  	i.GetURL()
  8338  	i = &Issue{}
  8339  	i.GetURL()
  8340  	i = nil
  8341  	i.GetURL()
  8342  }
  8343  
  8344  func TestIssue_GetUser(tt *testing.T) {
  8345  	i := &Issue{}
  8346  	i.GetUser()
  8347  	i = nil
  8348  	i.GetUser()
  8349  }
  8350  
  8351  func TestIssueComment_GetAuthorAssociation(tt *testing.T) {
  8352  	var zeroValue string
  8353  	i := &IssueComment{AuthorAssociation: &zeroValue}
  8354  	i.GetAuthorAssociation()
  8355  	i = &IssueComment{}
  8356  	i.GetAuthorAssociation()
  8357  	i = nil
  8358  	i.GetAuthorAssociation()
  8359  }
  8360  
  8361  func TestIssueComment_GetBody(tt *testing.T) {
  8362  	var zeroValue string
  8363  	i := &IssueComment{Body: &zeroValue}
  8364  	i.GetBody()
  8365  	i = &IssueComment{}
  8366  	i.GetBody()
  8367  	i = nil
  8368  	i.GetBody()
  8369  }
  8370  
  8371  func TestIssueComment_GetCreatedAt(tt *testing.T) {
  8372  	var zeroValue time.Time
  8373  	i := &IssueComment{CreatedAt: &zeroValue}
  8374  	i.GetCreatedAt()
  8375  	i = &IssueComment{}
  8376  	i.GetCreatedAt()
  8377  	i = nil
  8378  	i.GetCreatedAt()
  8379  }
  8380  
  8381  func TestIssueComment_GetHTMLURL(tt *testing.T) {
  8382  	var zeroValue string
  8383  	i := &IssueComment{HTMLURL: &zeroValue}
  8384  	i.GetHTMLURL()
  8385  	i = &IssueComment{}
  8386  	i.GetHTMLURL()
  8387  	i = nil
  8388  	i.GetHTMLURL()
  8389  }
  8390  
  8391  func TestIssueComment_GetID(tt *testing.T) {
  8392  	var zeroValue int64
  8393  	i := &IssueComment{ID: &zeroValue}
  8394  	i.GetID()
  8395  	i = &IssueComment{}
  8396  	i.GetID()
  8397  	i = nil
  8398  	i.GetID()
  8399  }
  8400  
  8401  func TestIssueComment_GetIssueURL(tt *testing.T) {
  8402  	var zeroValue string
  8403  	i := &IssueComment{IssueURL: &zeroValue}
  8404  	i.GetIssueURL()
  8405  	i = &IssueComment{}
  8406  	i.GetIssueURL()
  8407  	i = nil
  8408  	i.GetIssueURL()
  8409  }
  8410  
  8411  func TestIssueComment_GetNodeID(tt *testing.T) {
  8412  	var zeroValue string
  8413  	i := &IssueComment{NodeID: &zeroValue}
  8414  	i.GetNodeID()
  8415  	i = &IssueComment{}
  8416  	i.GetNodeID()
  8417  	i = nil
  8418  	i.GetNodeID()
  8419  }
  8420  
  8421  func TestIssueComment_GetReactions(tt *testing.T) {
  8422  	i := &IssueComment{}
  8423  	i.GetReactions()
  8424  	i = nil
  8425  	i.GetReactions()
  8426  }
  8427  
  8428  func TestIssueComment_GetUpdatedAt(tt *testing.T) {
  8429  	var zeroValue time.Time
  8430  	i := &IssueComment{UpdatedAt: &zeroValue}
  8431  	i.GetUpdatedAt()
  8432  	i = &IssueComment{}
  8433  	i.GetUpdatedAt()
  8434  	i = nil
  8435  	i.GetUpdatedAt()
  8436  }
  8437  
  8438  func TestIssueComment_GetURL(tt *testing.T) {
  8439  	var zeroValue string
  8440  	i := &IssueComment{URL: &zeroValue}
  8441  	i.GetURL()
  8442  	i = &IssueComment{}
  8443  	i.GetURL()
  8444  	i = nil
  8445  	i.GetURL()
  8446  }
  8447  
  8448  func TestIssueComment_GetUser(tt *testing.T) {
  8449  	i := &IssueComment{}
  8450  	i.GetUser()
  8451  	i = nil
  8452  	i.GetUser()
  8453  }
  8454  
  8455  func TestIssueCommentEvent_GetAction(tt *testing.T) {
  8456  	var zeroValue string
  8457  	i := &IssueCommentEvent{Action: &zeroValue}
  8458  	i.GetAction()
  8459  	i = &IssueCommentEvent{}
  8460  	i.GetAction()
  8461  	i = nil
  8462  	i.GetAction()
  8463  }
  8464  
  8465  func TestIssueCommentEvent_GetChanges(tt *testing.T) {
  8466  	i := &IssueCommentEvent{}
  8467  	i.GetChanges()
  8468  	i = nil
  8469  	i.GetChanges()
  8470  }
  8471  
  8472  func TestIssueCommentEvent_GetComment(tt *testing.T) {
  8473  	i := &IssueCommentEvent{}
  8474  	i.GetComment()
  8475  	i = nil
  8476  	i.GetComment()
  8477  }
  8478  
  8479  func TestIssueCommentEvent_GetInstallation(tt *testing.T) {
  8480  	i := &IssueCommentEvent{}
  8481  	i.GetInstallation()
  8482  	i = nil
  8483  	i.GetInstallation()
  8484  }
  8485  
  8486  func TestIssueCommentEvent_GetIssue(tt *testing.T) {
  8487  	i := &IssueCommentEvent{}
  8488  	i.GetIssue()
  8489  	i = nil
  8490  	i.GetIssue()
  8491  }
  8492  
  8493  func TestIssueCommentEvent_GetOrganization(tt *testing.T) {
  8494  	i := &IssueCommentEvent{}
  8495  	i.GetOrganization()
  8496  	i = nil
  8497  	i.GetOrganization()
  8498  }
  8499  
  8500  func TestIssueCommentEvent_GetRepo(tt *testing.T) {
  8501  	i := &IssueCommentEvent{}
  8502  	i.GetRepo()
  8503  	i = nil
  8504  	i.GetRepo()
  8505  }
  8506  
  8507  func TestIssueCommentEvent_GetSender(tt *testing.T) {
  8508  	i := &IssueCommentEvent{}
  8509  	i.GetSender()
  8510  	i = nil
  8511  	i.GetSender()
  8512  }
  8513  
  8514  func TestIssueEvent_GetActor(tt *testing.T) {
  8515  	i := &IssueEvent{}
  8516  	i.GetActor()
  8517  	i = nil
  8518  	i.GetActor()
  8519  }
  8520  
  8521  func TestIssueEvent_GetAssignee(tt *testing.T) {
  8522  	i := &IssueEvent{}
  8523  	i.GetAssignee()
  8524  	i = nil
  8525  	i.GetAssignee()
  8526  }
  8527  
  8528  func TestIssueEvent_GetAssigner(tt *testing.T) {
  8529  	i := &IssueEvent{}
  8530  	i.GetAssigner()
  8531  	i = nil
  8532  	i.GetAssigner()
  8533  }
  8534  
  8535  func TestIssueEvent_GetCommitID(tt *testing.T) {
  8536  	var zeroValue string
  8537  	i := &IssueEvent{CommitID: &zeroValue}
  8538  	i.GetCommitID()
  8539  	i = &IssueEvent{}
  8540  	i.GetCommitID()
  8541  	i = nil
  8542  	i.GetCommitID()
  8543  }
  8544  
  8545  func TestIssueEvent_GetCreatedAt(tt *testing.T) {
  8546  	var zeroValue time.Time
  8547  	i := &IssueEvent{CreatedAt: &zeroValue}
  8548  	i.GetCreatedAt()
  8549  	i = &IssueEvent{}
  8550  	i.GetCreatedAt()
  8551  	i = nil
  8552  	i.GetCreatedAt()
  8553  }
  8554  
  8555  func TestIssueEvent_GetDismissedReview(tt *testing.T) {
  8556  	i := &IssueEvent{}
  8557  	i.GetDismissedReview()
  8558  	i = nil
  8559  	i.GetDismissedReview()
  8560  }
  8561  
  8562  func TestIssueEvent_GetEvent(tt *testing.T) {
  8563  	var zeroValue string
  8564  	i := &IssueEvent{Event: &zeroValue}
  8565  	i.GetEvent()
  8566  	i = &IssueEvent{}
  8567  	i.GetEvent()
  8568  	i = nil
  8569  	i.GetEvent()
  8570  }
  8571  
  8572  func TestIssueEvent_GetID(tt *testing.T) {
  8573  	var zeroValue int64
  8574  	i := &IssueEvent{ID: &zeroValue}
  8575  	i.GetID()
  8576  	i = &IssueEvent{}
  8577  	i.GetID()
  8578  	i = nil
  8579  	i.GetID()
  8580  }
  8581  
  8582  func TestIssueEvent_GetIssue(tt *testing.T) {
  8583  	i := &IssueEvent{}
  8584  	i.GetIssue()
  8585  	i = nil
  8586  	i.GetIssue()
  8587  }
  8588  
  8589  func TestIssueEvent_GetLabel(tt *testing.T) {
  8590  	i := &IssueEvent{}
  8591  	i.GetLabel()
  8592  	i = nil
  8593  	i.GetLabel()
  8594  }
  8595  
  8596  func TestIssueEvent_GetLockReason(tt *testing.T) {
  8597  	var zeroValue string
  8598  	i := &IssueEvent{LockReason: &zeroValue}
  8599  	i.GetLockReason()
  8600  	i = &IssueEvent{}
  8601  	i.GetLockReason()
  8602  	i = nil
  8603  	i.GetLockReason()
  8604  }
  8605  
  8606  func TestIssueEvent_GetMilestone(tt *testing.T) {
  8607  	i := &IssueEvent{}
  8608  	i.GetMilestone()
  8609  	i = nil
  8610  	i.GetMilestone()
  8611  }
  8612  
  8613  func TestIssueEvent_GetProjectCard(tt *testing.T) {
  8614  	i := &IssueEvent{}
  8615  	i.GetProjectCard()
  8616  	i = nil
  8617  	i.GetProjectCard()
  8618  }
  8619  
  8620  func TestIssueEvent_GetRename(tt *testing.T) {
  8621  	i := &IssueEvent{}
  8622  	i.GetRename()
  8623  	i = nil
  8624  	i.GetRename()
  8625  }
  8626  
  8627  func TestIssueEvent_GetRequestedReviewer(tt *testing.T) {
  8628  	i := &IssueEvent{}
  8629  	i.GetRequestedReviewer()
  8630  	i = nil
  8631  	i.GetRequestedReviewer()
  8632  }
  8633  
  8634  func TestIssueEvent_GetReviewRequester(tt *testing.T) {
  8635  	i := &IssueEvent{}
  8636  	i.GetReviewRequester()
  8637  	i = nil
  8638  	i.GetReviewRequester()
  8639  }
  8640  
  8641  func TestIssueEvent_GetURL(tt *testing.T) {
  8642  	var zeroValue string
  8643  	i := &IssueEvent{URL: &zeroValue}
  8644  	i.GetURL()
  8645  	i = &IssueEvent{}
  8646  	i.GetURL()
  8647  	i = nil
  8648  	i.GetURL()
  8649  }
  8650  
  8651  func TestIssueImport_GetAssignee(tt *testing.T) {
  8652  	var zeroValue string
  8653  	i := &IssueImport{Assignee: &zeroValue}
  8654  	i.GetAssignee()
  8655  	i = &IssueImport{}
  8656  	i.GetAssignee()
  8657  	i = nil
  8658  	i.GetAssignee()
  8659  }
  8660  
  8661  func TestIssueImport_GetClosed(tt *testing.T) {
  8662  	var zeroValue bool
  8663  	i := &IssueImport{Closed: &zeroValue}
  8664  	i.GetClosed()
  8665  	i = &IssueImport{}
  8666  	i.GetClosed()
  8667  	i = nil
  8668  	i.GetClosed()
  8669  }
  8670  
  8671  func TestIssueImport_GetClosedAt(tt *testing.T) {
  8672  	var zeroValue time.Time
  8673  	i := &IssueImport{ClosedAt: &zeroValue}
  8674  	i.GetClosedAt()
  8675  	i = &IssueImport{}
  8676  	i.GetClosedAt()
  8677  	i = nil
  8678  	i.GetClosedAt()
  8679  }
  8680  
  8681  func TestIssueImport_GetCreatedAt(tt *testing.T) {
  8682  	var zeroValue time.Time
  8683  	i := &IssueImport{CreatedAt: &zeroValue}
  8684  	i.GetCreatedAt()
  8685  	i = &IssueImport{}
  8686  	i.GetCreatedAt()
  8687  	i = nil
  8688  	i.GetCreatedAt()
  8689  }
  8690  
  8691  func TestIssueImport_GetMilestone(tt *testing.T) {
  8692  	var zeroValue int
  8693  	i := &IssueImport{Milestone: &zeroValue}
  8694  	i.GetMilestone()
  8695  	i = &IssueImport{}
  8696  	i.GetMilestone()
  8697  	i = nil
  8698  	i.GetMilestone()
  8699  }
  8700  
  8701  func TestIssueImport_GetUpdatedAt(tt *testing.T) {
  8702  	var zeroValue time.Time
  8703  	i := &IssueImport{UpdatedAt: &zeroValue}
  8704  	i.GetUpdatedAt()
  8705  	i = &IssueImport{}
  8706  	i.GetUpdatedAt()
  8707  	i = nil
  8708  	i.GetUpdatedAt()
  8709  }
  8710  
  8711  func TestIssueImportError_GetCode(tt *testing.T) {
  8712  	var zeroValue string
  8713  	i := &IssueImportError{Code: &zeroValue}
  8714  	i.GetCode()
  8715  	i = &IssueImportError{}
  8716  	i.GetCode()
  8717  	i = nil
  8718  	i.GetCode()
  8719  }
  8720  
  8721  func TestIssueImportError_GetField(tt *testing.T) {
  8722  	var zeroValue string
  8723  	i := &IssueImportError{Field: &zeroValue}
  8724  	i.GetField()
  8725  	i = &IssueImportError{}
  8726  	i.GetField()
  8727  	i = nil
  8728  	i.GetField()
  8729  }
  8730  
  8731  func TestIssueImportError_GetLocation(tt *testing.T) {
  8732  	var zeroValue string
  8733  	i := &IssueImportError{Location: &zeroValue}
  8734  	i.GetLocation()
  8735  	i = &IssueImportError{}
  8736  	i.GetLocation()
  8737  	i = nil
  8738  	i.GetLocation()
  8739  }
  8740  
  8741  func TestIssueImportError_GetResource(tt *testing.T) {
  8742  	var zeroValue string
  8743  	i := &IssueImportError{Resource: &zeroValue}
  8744  	i.GetResource()
  8745  	i = &IssueImportError{}
  8746  	i.GetResource()
  8747  	i = nil
  8748  	i.GetResource()
  8749  }
  8750  
  8751  func TestIssueImportError_GetValue(tt *testing.T) {
  8752  	var zeroValue string
  8753  	i := &IssueImportError{Value: &zeroValue}
  8754  	i.GetValue()
  8755  	i = &IssueImportError{}
  8756  	i.GetValue()
  8757  	i = nil
  8758  	i.GetValue()
  8759  }
  8760  
  8761  func TestIssueImportResponse_GetCreatedAt(tt *testing.T) {
  8762  	var zeroValue time.Time
  8763  	i := &IssueImportResponse{CreatedAt: &zeroValue}
  8764  	i.GetCreatedAt()
  8765  	i = &IssueImportResponse{}
  8766  	i.GetCreatedAt()
  8767  	i = nil
  8768  	i.GetCreatedAt()
  8769  }
  8770  
  8771  func TestIssueImportResponse_GetDocumentationURL(tt *testing.T) {
  8772  	var zeroValue string
  8773  	i := &IssueImportResponse{DocumentationURL: &zeroValue}
  8774  	i.GetDocumentationURL()
  8775  	i = &IssueImportResponse{}
  8776  	i.GetDocumentationURL()
  8777  	i = nil
  8778  	i.GetDocumentationURL()
  8779  }
  8780  
  8781  func TestIssueImportResponse_GetID(tt *testing.T) {
  8782  	var zeroValue int
  8783  	i := &IssueImportResponse{ID: &zeroValue}
  8784  	i.GetID()
  8785  	i = &IssueImportResponse{}
  8786  	i.GetID()
  8787  	i = nil
  8788  	i.GetID()
  8789  }
  8790  
  8791  func TestIssueImportResponse_GetImportIssuesURL(tt *testing.T) {
  8792  	var zeroValue string
  8793  	i := &IssueImportResponse{ImportIssuesURL: &zeroValue}
  8794  	i.GetImportIssuesURL()
  8795  	i = &IssueImportResponse{}
  8796  	i.GetImportIssuesURL()
  8797  	i = nil
  8798  	i.GetImportIssuesURL()
  8799  }
  8800  
  8801  func TestIssueImportResponse_GetMessage(tt *testing.T) {
  8802  	var zeroValue string
  8803  	i := &IssueImportResponse{Message: &zeroValue}
  8804  	i.GetMessage()
  8805  	i = &IssueImportResponse{}
  8806  	i.GetMessage()
  8807  	i = nil
  8808  	i.GetMessage()
  8809  }
  8810  
  8811  func TestIssueImportResponse_GetRepositoryURL(tt *testing.T) {
  8812  	var zeroValue string
  8813  	i := &IssueImportResponse{RepositoryURL: &zeroValue}
  8814  	i.GetRepositoryURL()
  8815  	i = &IssueImportResponse{}
  8816  	i.GetRepositoryURL()
  8817  	i = nil
  8818  	i.GetRepositoryURL()
  8819  }
  8820  
  8821  func TestIssueImportResponse_GetStatus(tt *testing.T) {
  8822  	var zeroValue string
  8823  	i := &IssueImportResponse{Status: &zeroValue}
  8824  	i.GetStatus()
  8825  	i = &IssueImportResponse{}
  8826  	i.GetStatus()
  8827  	i = nil
  8828  	i.GetStatus()
  8829  }
  8830  
  8831  func TestIssueImportResponse_GetUpdatedAt(tt *testing.T) {
  8832  	var zeroValue time.Time
  8833  	i := &IssueImportResponse{UpdatedAt: &zeroValue}
  8834  	i.GetUpdatedAt()
  8835  	i = &IssueImportResponse{}
  8836  	i.GetUpdatedAt()
  8837  	i = nil
  8838  	i.GetUpdatedAt()
  8839  }
  8840  
  8841  func TestIssueImportResponse_GetURL(tt *testing.T) {
  8842  	var zeroValue string
  8843  	i := &IssueImportResponse{URL: &zeroValue}
  8844  	i.GetURL()
  8845  	i = &IssueImportResponse{}
  8846  	i.GetURL()
  8847  	i = nil
  8848  	i.GetURL()
  8849  }
  8850  
  8851  func TestIssueListCommentsOptions_GetDirection(tt *testing.T) {
  8852  	var zeroValue string
  8853  	i := &IssueListCommentsOptions{Direction: &zeroValue}
  8854  	i.GetDirection()
  8855  	i = &IssueListCommentsOptions{}
  8856  	i.GetDirection()
  8857  	i = nil
  8858  	i.GetDirection()
  8859  }
  8860  
  8861  func TestIssueListCommentsOptions_GetSince(tt *testing.T) {
  8862  	var zeroValue time.Time
  8863  	i := &IssueListCommentsOptions{Since: &zeroValue}
  8864  	i.GetSince()
  8865  	i = &IssueListCommentsOptions{}
  8866  	i.GetSince()
  8867  	i = nil
  8868  	i.GetSince()
  8869  }
  8870  
  8871  func TestIssueListCommentsOptions_GetSort(tt *testing.T) {
  8872  	var zeroValue string
  8873  	i := &IssueListCommentsOptions{Sort: &zeroValue}
  8874  	i.GetSort()
  8875  	i = &IssueListCommentsOptions{}
  8876  	i.GetSort()
  8877  	i = nil
  8878  	i.GetSort()
  8879  }
  8880  
  8881  func TestIssueRequest_GetAssignee(tt *testing.T) {
  8882  	var zeroValue string
  8883  	i := &IssueRequest{Assignee: &zeroValue}
  8884  	i.GetAssignee()
  8885  	i = &IssueRequest{}
  8886  	i.GetAssignee()
  8887  	i = nil
  8888  	i.GetAssignee()
  8889  }
  8890  
  8891  func TestIssueRequest_GetAssignees(tt *testing.T) {
  8892  	var zeroValue []string
  8893  	i := &IssueRequest{Assignees: &zeroValue}
  8894  	i.GetAssignees()
  8895  	i = &IssueRequest{}
  8896  	i.GetAssignees()
  8897  	i = nil
  8898  	i.GetAssignees()
  8899  }
  8900  
  8901  func TestIssueRequest_GetBody(tt *testing.T) {
  8902  	var zeroValue string
  8903  	i := &IssueRequest{Body: &zeroValue}
  8904  	i.GetBody()
  8905  	i = &IssueRequest{}
  8906  	i.GetBody()
  8907  	i = nil
  8908  	i.GetBody()
  8909  }
  8910  
  8911  func TestIssueRequest_GetLabels(tt *testing.T) {
  8912  	var zeroValue []string
  8913  	i := &IssueRequest{Labels: &zeroValue}
  8914  	i.GetLabels()
  8915  	i = &IssueRequest{}
  8916  	i.GetLabels()
  8917  	i = nil
  8918  	i.GetLabels()
  8919  }
  8920  
  8921  func TestIssueRequest_GetMilestone(tt *testing.T) {
  8922  	var zeroValue int
  8923  	i := &IssueRequest{Milestone: &zeroValue}
  8924  	i.GetMilestone()
  8925  	i = &IssueRequest{}
  8926  	i.GetMilestone()
  8927  	i = nil
  8928  	i.GetMilestone()
  8929  }
  8930  
  8931  func TestIssueRequest_GetState(tt *testing.T) {
  8932  	var zeroValue string
  8933  	i := &IssueRequest{State: &zeroValue}
  8934  	i.GetState()
  8935  	i = &IssueRequest{}
  8936  	i.GetState()
  8937  	i = nil
  8938  	i.GetState()
  8939  }
  8940  
  8941  func TestIssueRequest_GetTitle(tt *testing.T) {
  8942  	var zeroValue string
  8943  	i := &IssueRequest{Title: &zeroValue}
  8944  	i.GetTitle()
  8945  	i = &IssueRequest{}
  8946  	i.GetTitle()
  8947  	i = nil
  8948  	i.GetTitle()
  8949  }
  8950  
  8951  func TestIssuesEvent_GetAction(tt *testing.T) {
  8952  	var zeroValue string
  8953  	i := &IssuesEvent{Action: &zeroValue}
  8954  	i.GetAction()
  8955  	i = &IssuesEvent{}
  8956  	i.GetAction()
  8957  	i = nil
  8958  	i.GetAction()
  8959  }
  8960  
  8961  func TestIssuesEvent_GetAssignee(tt *testing.T) {
  8962  	i := &IssuesEvent{}
  8963  	i.GetAssignee()
  8964  	i = nil
  8965  	i.GetAssignee()
  8966  }
  8967  
  8968  func TestIssuesEvent_GetChanges(tt *testing.T) {
  8969  	i := &IssuesEvent{}
  8970  	i.GetChanges()
  8971  	i = nil
  8972  	i.GetChanges()
  8973  }
  8974  
  8975  func TestIssuesEvent_GetInstallation(tt *testing.T) {
  8976  	i := &IssuesEvent{}
  8977  	i.GetInstallation()
  8978  	i = nil
  8979  	i.GetInstallation()
  8980  }
  8981  
  8982  func TestIssuesEvent_GetIssue(tt *testing.T) {
  8983  	i := &IssuesEvent{}
  8984  	i.GetIssue()
  8985  	i = nil
  8986  	i.GetIssue()
  8987  }
  8988  
  8989  func TestIssuesEvent_GetLabel(tt *testing.T) {
  8990  	i := &IssuesEvent{}
  8991  	i.GetLabel()
  8992  	i = nil
  8993  	i.GetLabel()
  8994  }
  8995  
  8996  func TestIssuesEvent_GetRepo(tt *testing.T) {
  8997  	i := &IssuesEvent{}
  8998  	i.GetRepo()
  8999  	i = nil
  9000  	i.GetRepo()
  9001  }
  9002  
  9003  func TestIssuesEvent_GetSender(tt *testing.T) {
  9004  	i := &IssuesEvent{}
  9005  	i.GetSender()
  9006  	i = nil
  9007  	i.GetSender()
  9008  }
  9009  
  9010  func TestIssuesSearchResult_GetIncompleteResults(tt *testing.T) {
  9011  	var zeroValue bool
  9012  	i := &IssuesSearchResult{IncompleteResults: &zeroValue}
  9013  	i.GetIncompleteResults()
  9014  	i = &IssuesSearchResult{}
  9015  	i.GetIncompleteResults()
  9016  	i = nil
  9017  	i.GetIncompleteResults()
  9018  }
  9019  
  9020  func TestIssuesSearchResult_GetTotal(tt *testing.T) {
  9021  	var zeroValue int
  9022  	i := &IssuesSearchResult{Total: &zeroValue}
  9023  	i.GetTotal()
  9024  	i = &IssuesSearchResult{}
  9025  	i.GetTotal()
  9026  	i = nil
  9027  	i.GetTotal()
  9028  }
  9029  
  9030  func TestIssueStats_GetClosedIssues(tt *testing.T) {
  9031  	var zeroValue int
  9032  	i := &IssueStats{ClosedIssues: &zeroValue}
  9033  	i.GetClosedIssues()
  9034  	i = &IssueStats{}
  9035  	i.GetClosedIssues()
  9036  	i = nil
  9037  	i.GetClosedIssues()
  9038  }
  9039  
  9040  func TestIssueStats_GetOpenIssues(tt *testing.T) {
  9041  	var zeroValue int
  9042  	i := &IssueStats{OpenIssues: &zeroValue}
  9043  	i.GetOpenIssues()
  9044  	i = &IssueStats{}
  9045  	i.GetOpenIssues()
  9046  	i = nil
  9047  	i.GetOpenIssues()
  9048  }
  9049  
  9050  func TestIssueStats_GetTotalIssues(tt *testing.T) {
  9051  	var zeroValue int
  9052  	i := &IssueStats{TotalIssues: &zeroValue}
  9053  	i.GetTotalIssues()
  9054  	i = &IssueStats{}
  9055  	i.GetTotalIssues()
  9056  	i = nil
  9057  	i.GetTotalIssues()
  9058  }
  9059  
  9060  func TestJobs_GetTotalCount(tt *testing.T) {
  9061  	var zeroValue int
  9062  	j := &Jobs{TotalCount: &zeroValue}
  9063  	j.GetTotalCount()
  9064  	j = &Jobs{}
  9065  	j.GetTotalCount()
  9066  	j = nil
  9067  	j.GetTotalCount()
  9068  }
  9069  
  9070  func TestKey_GetCreatedAt(tt *testing.T) {
  9071  	var zeroValue Timestamp
  9072  	k := &Key{CreatedAt: &zeroValue}
  9073  	k.GetCreatedAt()
  9074  	k = &Key{}
  9075  	k.GetCreatedAt()
  9076  	k = nil
  9077  	k.GetCreatedAt()
  9078  }
  9079  
  9080  func TestKey_GetID(tt *testing.T) {
  9081  	var zeroValue int64
  9082  	k := &Key{ID: &zeroValue}
  9083  	k.GetID()
  9084  	k = &Key{}
  9085  	k.GetID()
  9086  	k = nil
  9087  	k.GetID()
  9088  }
  9089  
  9090  func TestKey_GetKey(tt *testing.T) {
  9091  	var zeroValue string
  9092  	k := &Key{Key: &zeroValue}
  9093  	k.GetKey()
  9094  	k = &Key{}
  9095  	k.GetKey()
  9096  	k = nil
  9097  	k.GetKey()
  9098  }
  9099  
  9100  func TestKey_GetReadOnly(tt *testing.T) {
  9101  	var zeroValue bool
  9102  	k := &Key{ReadOnly: &zeroValue}
  9103  	k.GetReadOnly()
  9104  	k = &Key{}
  9105  	k.GetReadOnly()
  9106  	k = nil
  9107  	k.GetReadOnly()
  9108  }
  9109  
  9110  func TestKey_GetTitle(tt *testing.T) {
  9111  	var zeroValue string
  9112  	k := &Key{Title: &zeroValue}
  9113  	k.GetTitle()
  9114  	k = &Key{}
  9115  	k.GetTitle()
  9116  	k = nil
  9117  	k.GetTitle()
  9118  }
  9119  
  9120  func TestKey_GetURL(tt *testing.T) {
  9121  	var zeroValue string
  9122  	k := &Key{URL: &zeroValue}
  9123  	k.GetURL()
  9124  	k = &Key{}
  9125  	k.GetURL()
  9126  	k = nil
  9127  	k.GetURL()
  9128  }
  9129  
  9130  func TestKey_GetVerified(tt *testing.T) {
  9131  	var zeroValue bool
  9132  	k := &Key{Verified: &zeroValue}
  9133  	k.GetVerified()
  9134  	k = &Key{}
  9135  	k.GetVerified()
  9136  	k = nil
  9137  	k.GetVerified()
  9138  }
  9139  
  9140  func TestLabel_GetColor(tt *testing.T) {
  9141  	var zeroValue string
  9142  	l := &Label{Color: &zeroValue}
  9143  	l.GetColor()
  9144  	l = &Label{}
  9145  	l.GetColor()
  9146  	l = nil
  9147  	l.GetColor()
  9148  }
  9149  
  9150  func TestLabel_GetDefault(tt *testing.T) {
  9151  	var zeroValue bool
  9152  	l := &Label{Default: &zeroValue}
  9153  	l.GetDefault()
  9154  	l = &Label{}
  9155  	l.GetDefault()
  9156  	l = nil
  9157  	l.GetDefault()
  9158  }
  9159  
  9160  func TestLabel_GetDescription(tt *testing.T) {
  9161  	var zeroValue string
  9162  	l := &Label{Description: &zeroValue}
  9163  	l.GetDescription()
  9164  	l = &Label{}
  9165  	l.GetDescription()
  9166  	l = nil
  9167  	l.GetDescription()
  9168  }
  9169  
  9170  func TestLabel_GetID(tt *testing.T) {
  9171  	var zeroValue int64
  9172  	l := &Label{ID: &zeroValue}
  9173  	l.GetID()
  9174  	l = &Label{}
  9175  	l.GetID()
  9176  	l = nil
  9177  	l.GetID()
  9178  }
  9179  
  9180  func TestLabel_GetName(tt *testing.T) {
  9181  	var zeroValue string
  9182  	l := &Label{Name: &zeroValue}
  9183  	l.GetName()
  9184  	l = &Label{}
  9185  	l.GetName()
  9186  	l = nil
  9187  	l.GetName()
  9188  }
  9189  
  9190  func TestLabel_GetNodeID(tt *testing.T) {
  9191  	var zeroValue string
  9192  	l := &Label{NodeID: &zeroValue}
  9193  	l.GetNodeID()
  9194  	l = &Label{}
  9195  	l.GetNodeID()
  9196  	l = nil
  9197  	l.GetNodeID()
  9198  }
  9199  
  9200  func TestLabel_GetURL(tt *testing.T) {
  9201  	var zeroValue string
  9202  	l := &Label{URL: &zeroValue}
  9203  	l.GetURL()
  9204  	l = &Label{}
  9205  	l.GetURL()
  9206  	l = nil
  9207  	l.GetURL()
  9208  }
  9209  
  9210  func TestLabelEvent_GetAction(tt *testing.T) {
  9211  	var zeroValue string
  9212  	l := &LabelEvent{Action: &zeroValue}
  9213  	l.GetAction()
  9214  	l = &LabelEvent{}
  9215  	l.GetAction()
  9216  	l = nil
  9217  	l.GetAction()
  9218  }
  9219  
  9220  func TestLabelEvent_GetChanges(tt *testing.T) {
  9221  	l := &LabelEvent{}
  9222  	l.GetChanges()
  9223  	l = nil
  9224  	l.GetChanges()
  9225  }
  9226  
  9227  func TestLabelEvent_GetInstallation(tt *testing.T) {
  9228  	l := &LabelEvent{}
  9229  	l.GetInstallation()
  9230  	l = nil
  9231  	l.GetInstallation()
  9232  }
  9233  
  9234  func TestLabelEvent_GetLabel(tt *testing.T) {
  9235  	l := &LabelEvent{}
  9236  	l.GetLabel()
  9237  	l = nil
  9238  	l.GetLabel()
  9239  }
  9240  
  9241  func TestLabelEvent_GetOrg(tt *testing.T) {
  9242  	l := &LabelEvent{}
  9243  	l.GetOrg()
  9244  	l = nil
  9245  	l.GetOrg()
  9246  }
  9247  
  9248  func TestLabelEvent_GetRepo(tt *testing.T) {
  9249  	l := &LabelEvent{}
  9250  	l.GetRepo()
  9251  	l = nil
  9252  	l.GetRepo()
  9253  }
  9254  
  9255  func TestLabelEvent_GetSender(tt *testing.T) {
  9256  	l := &LabelEvent{}
  9257  	l.GetSender()
  9258  	l = nil
  9259  	l.GetSender()
  9260  }
  9261  
  9262  func TestLabelResult_GetColor(tt *testing.T) {
  9263  	var zeroValue string
  9264  	l := &LabelResult{Color: &zeroValue}
  9265  	l.GetColor()
  9266  	l = &LabelResult{}
  9267  	l.GetColor()
  9268  	l = nil
  9269  	l.GetColor()
  9270  }
  9271  
  9272  func TestLabelResult_GetDefault(tt *testing.T) {
  9273  	var zeroValue bool
  9274  	l := &LabelResult{Default: &zeroValue}
  9275  	l.GetDefault()
  9276  	l = &LabelResult{}
  9277  	l.GetDefault()
  9278  	l = nil
  9279  	l.GetDefault()
  9280  }
  9281  
  9282  func TestLabelResult_GetDescription(tt *testing.T) {
  9283  	var zeroValue string
  9284  	l := &LabelResult{Description: &zeroValue}
  9285  	l.GetDescription()
  9286  	l = &LabelResult{}
  9287  	l.GetDescription()
  9288  	l = nil
  9289  	l.GetDescription()
  9290  }
  9291  
  9292  func TestLabelResult_GetID(tt *testing.T) {
  9293  	var zeroValue int64
  9294  	l := &LabelResult{ID: &zeroValue}
  9295  	l.GetID()
  9296  	l = &LabelResult{}
  9297  	l.GetID()
  9298  	l = nil
  9299  	l.GetID()
  9300  }
  9301  
  9302  func TestLabelResult_GetName(tt *testing.T) {
  9303  	var zeroValue string
  9304  	l := &LabelResult{Name: &zeroValue}
  9305  	l.GetName()
  9306  	l = &LabelResult{}
  9307  	l.GetName()
  9308  	l = nil
  9309  	l.GetName()
  9310  }
  9311  
  9312  func TestLabelResult_GetScore(tt *testing.T) {
  9313  	l := &LabelResult{}
  9314  	l.GetScore()
  9315  	l = nil
  9316  	l.GetScore()
  9317  }
  9318  
  9319  func TestLabelResult_GetURL(tt *testing.T) {
  9320  	var zeroValue string
  9321  	l := &LabelResult{URL: &zeroValue}
  9322  	l.GetURL()
  9323  	l = &LabelResult{}
  9324  	l.GetURL()
  9325  	l = nil
  9326  	l.GetURL()
  9327  }
  9328  
  9329  func TestLabelsSearchResult_GetIncompleteResults(tt *testing.T) {
  9330  	var zeroValue bool
  9331  	l := &LabelsSearchResult{IncompleteResults: &zeroValue}
  9332  	l.GetIncompleteResults()
  9333  	l = &LabelsSearchResult{}
  9334  	l.GetIncompleteResults()
  9335  	l = nil
  9336  	l.GetIncompleteResults()
  9337  }
  9338  
  9339  func TestLabelsSearchResult_GetTotal(tt *testing.T) {
  9340  	var zeroValue int
  9341  	l := &LabelsSearchResult{Total: &zeroValue}
  9342  	l.GetTotal()
  9343  	l = &LabelsSearchResult{}
  9344  	l.GetTotal()
  9345  	l = nil
  9346  	l.GetTotal()
  9347  }
  9348  
  9349  func TestLargeFile_GetOID(tt *testing.T) {
  9350  	var zeroValue string
  9351  	l := &LargeFile{OID: &zeroValue}
  9352  	l.GetOID()
  9353  	l = &LargeFile{}
  9354  	l.GetOID()
  9355  	l = nil
  9356  	l.GetOID()
  9357  }
  9358  
  9359  func TestLargeFile_GetPath(tt *testing.T) {
  9360  	var zeroValue string
  9361  	l := &LargeFile{Path: &zeroValue}
  9362  	l.GetPath()
  9363  	l = &LargeFile{}
  9364  	l.GetPath()
  9365  	l = nil
  9366  	l.GetPath()
  9367  }
  9368  
  9369  func TestLargeFile_GetRefName(tt *testing.T) {
  9370  	var zeroValue string
  9371  	l := &LargeFile{RefName: &zeroValue}
  9372  	l.GetRefName()
  9373  	l = &LargeFile{}
  9374  	l.GetRefName()
  9375  	l = nil
  9376  	l.GetRefName()
  9377  }
  9378  
  9379  func TestLargeFile_GetSize(tt *testing.T) {
  9380  	var zeroValue int
  9381  	l := &LargeFile{Size: &zeroValue}
  9382  	l.GetSize()
  9383  	l = &LargeFile{}
  9384  	l.GetSize()
  9385  	l = nil
  9386  	l.GetSize()
  9387  }
  9388  
  9389  func TestLicense_GetBody(tt *testing.T) {
  9390  	var zeroValue string
  9391  	l := &License{Body: &zeroValue}
  9392  	l.GetBody()
  9393  	l = &License{}
  9394  	l.GetBody()
  9395  	l = nil
  9396  	l.GetBody()
  9397  }
  9398  
  9399  func TestLicense_GetConditions(tt *testing.T) {
  9400  	var zeroValue []string
  9401  	l := &License{Conditions: &zeroValue}
  9402  	l.GetConditions()
  9403  	l = &License{}
  9404  	l.GetConditions()
  9405  	l = nil
  9406  	l.GetConditions()
  9407  }
  9408  
  9409  func TestLicense_GetDescription(tt *testing.T) {
  9410  	var zeroValue string
  9411  	l := &License{Description: &zeroValue}
  9412  	l.GetDescription()
  9413  	l = &License{}
  9414  	l.GetDescription()
  9415  	l = nil
  9416  	l.GetDescription()
  9417  }
  9418  
  9419  func TestLicense_GetFeatured(tt *testing.T) {
  9420  	var zeroValue bool
  9421  	l := &License{Featured: &zeroValue}
  9422  	l.GetFeatured()
  9423  	l = &License{}
  9424  	l.GetFeatured()
  9425  	l = nil
  9426  	l.GetFeatured()
  9427  }
  9428  
  9429  func TestLicense_GetHTMLURL(tt *testing.T) {
  9430  	var zeroValue string
  9431  	l := &License{HTMLURL: &zeroValue}
  9432  	l.GetHTMLURL()
  9433  	l = &License{}
  9434  	l.GetHTMLURL()
  9435  	l = nil
  9436  	l.GetHTMLURL()
  9437  }
  9438  
  9439  func TestLicense_GetImplementation(tt *testing.T) {
  9440  	var zeroValue string
  9441  	l := &License{Implementation: &zeroValue}
  9442  	l.GetImplementation()
  9443  	l = &License{}
  9444  	l.GetImplementation()
  9445  	l = nil
  9446  	l.GetImplementation()
  9447  }
  9448  
  9449  func TestLicense_GetKey(tt *testing.T) {
  9450  	var zeroValue string
  9451  	l := &License{Key: &zeroValue}
  9452  	l.GetKey()
  9453  	l = &License{}
  9454  	l.GetKey()
  9455  	l = nil
  9456  	l.GetKey()
  9457  }
  9458  
  9459  func TestLicense_GetLimitations(tt *testing.T) {
  9460  	var zeroValue []string
  9461  	l := &License{Limitations: &zeroValue}
  9462  	l.GetLimitations()
  9463  	l = &License{}
  9464  	l.GetLimitations()
  9465  	l = nil
  9466  	l.GetLimitations()
  9467  }
  9468  
  9469  func TestLicense_GetName(tt *testing.T) {
  9470  	var zeroValue string
  9471  	l := &License{Name: &zeroValue}
  9472  	l.GetName()
  9473  	l = &License{}
  9474  	l.GetName()
  9475  	l = nil
  9476  	l.GetName()
  9477  }
  9478  
  9479  func TestLicense_GetPermissions(tt *testing.T) {
  9480  	var zeroValue []string
  9481  	l := &License{Permissions: &zeroValue}
  9482  	l.GetPermissions()
  9483  	l = &License{}
  9484  	l.GetPermissions()
  9485  	l = nil
  9486  	l.GetPermissions()
  9487  }
  9488  
  9489  func TestLicense_GetSPDXID(tt *testing.T) {
  9490  	var zeroValue string
  9491  	l := &License{SPDXID: &zeroValue}
  9492  	l.GetSPDXID()
  9493  	l = &License{}
  9494  	l.GetSPDXID()
  9495  	l = nil
  9496  	l.GetSPDXID()
  9497  }
  9498  
  9499  func TestLicense_GetURL(tt *testing.T) {
  9500  	var zeroValue string
  9501  	l := &License{URL: &zeroValue}
  9502  	l.GetURL()
  9503  	l = &License{}
  9504  	l.GetURL()
  9505  	l = nil
  9506  	l.GetURL()
  9507  }
  9508  
  9509  func TestListCheckRunsOptions_GetAppID(tt *testing.T) {
  9510  	var zeroValue int64
  9511  	l := &ListCheckRunsOptions{AppID: &zeroValue}
  9512  	l.GetAppID()
  9513  	l = &ListCheckRunsOptions{}
  9514  	l.GetAppID()
  9515  	l = nil
  9516  	l.GetAppID()
  9517  }
  9518  
  9519  func TestListCheckRunsOptions_GetCheckName(tt *testing.T) {
  9520  	var zeroValue string
  9521  	l := &ListCheckRunsOptions{CheckName: &zeroValue}
  9522  	l.GetCheckName()
  9523  	l = &ListCheckRunsOptions{}
  9524  	l.GetCheckName()
  9525  	l = nil
  9526  	l.GetCheckName()
  9527  }
  9528  
  9529  func TestListCheckRunsOptions_GetFilter(tt *testing.T) {
  9530  	var zeroValue string
  9531  	l := &ListCheckRunsOptions{Filter: &zeroValue}
  9532  	l.GetFilter()
  9533  	l = &ListCheckRunsOptions{}
  9534  	l.GetFilter()
  9535  	l = nil
  9536  	l.GetFilter()
  9537  }
  9538  
  9539  func TestListCheckRunsOptions_GetStatus(tt *testing.T) {
  9540  	var zeroValue string
  9541  	l := &ListCheckRunsOptions{Status: &zeroValue}
  9542  	l.GetStatus()
  9543  	l = &ListCheckRunsOptions{}
  9544  	l.GetStatus()
  9545  	l = nil
  9546  	l.GetStatus()
  9547  }
  9548  
  9549  func TestListCheckRunsResults_GetTotal(tt *testing.T) {
  9550  	var zeroValue int
  9551  	l := &ListCheckRunsResults{Total: &zeroValue}
  9552  	l.GetTotal()
  9553  	l = &ListCheckRunsResults{}
  9554  	l.GetTotal()
  9555  	l = nil
  9556  	l.GetTotal()
  9557  }
  9558  
  9559  func TestListCheckSuiteOptions_GetAppID(tt *testing.T) {
  9560  	var zeroValue int
  9561  	l := &ListCheckSuiteOptions{AppID: &zeroValue}
  9562  	l.GetAppID()
  9563  	l = &ListCheckSuiteOptions{}
  9564  	l.GetAppID()
  9565  	l = nil
  9566  	l.GetAppID()
  9567  }
  9568  
  9569  func TestListCheckSuiteOptions_GetCheckName(tt *testing.T) {
  9570  	var zeroValue string
  9571  	l := &ListCheckSuiteOptions{CheckName: &zeroValue}
  9572  	l.GetCheckName()
  9573  	l = &ListCheckSuiteOptions{}
  9574  	l.GetCheckName()
  9575  	l = nil
  9576  	l.GetCheckName()
  9577  }
  9578  
  9579  func TestListCheckSuiteResults_GetTotal(tt *testing.T) {
  9580  	var zeroValue int
  9581  	l := &ListCheckSuiteResults{Total: &zeroValue}
  9582  	l.GetTotal()
  9583  	l = &ListCheckSuiteResults{}
  9584  	l.GetTotal()
  9585  	l = nil
  9586  	l.GetTotal()
  9587  }
  9588  
  9589  func TestListCollaboratorOptions_GetAffiliation(tt *testing.T) {
  9590  	var zeroValue string
  9591  	l := &ListCollaboratorOptions{Affiliation: &zeroValue}
  9592  	l.GetAffiliation()
  9593  	l = &ListCollaboratorOptions{}
  9594  	l.GetAffiliation()
  9595  	l = nil
  9596  	l.GetAffiliation()
  9597  }
  9598  
  9599  func TestListExternalGroupsOptions_GetDisplayName(tt *testing.T) {
  9600  	var zeroValue string
  9601  	l := &ListExternalGroupsOptions{DisplayName: &zeroValue}
  9602  	l.GetDisplayName()
  9603  	l = &ListExternalGroupsOptions{}
  9604  	l.GetDisplayName()
  9605  	l = nil
  9606  	l.GetDisplayName()
  9607  }
  9608  
  9609  func TestListRepositories_GetTotalCount(tt *testing.T) {
  9610  	var zeroValue int
  9611  	l := &ListRepositories{TotalCount: &zeroValue}
  9612  	l.GetTotalCount()
  9613  	l = &ListRepositories{}
  9614  	l.GetTotalCount()
  9615  	l = nil
  9616  	l.GetTotalCount()
  9617  }
  9618  
  9619  func TestListSCIMProvisionedIdentitiesOptions_GetCount(tt *testing.T) {
  9620  	var zeroValue int
  9621  	l := &ListSCIMProvisionedIdentitiesOptions{Count: &zeroValue}
  9622  	l.GetCount()
  9623  	l = &ListSCIMProvisionedIdentitiesOptions{}
  9624  	l.GetCount()
  9625  	l = nil
  9626  	l.GetCount()
  9627  }
  9628  
  9629  func TestListSCIMProvisionedIdentitiesOptions_GetFilter(tt *testing.T) {
  9630  	var zeroValue string
  9631  	l := &ListSCIMProvisionedIdentitiesOptions{Filter: &zeroValue}
  9632  	l.GetFilter()
  9633  	l = &ListSCIMProvisionedIdentitiesOptions{}
  9634  	l.GetFilter()
  9635  	l = nil
  9636  	l.GetFilter()
  9637  }
  9638  
  9639  func TestListSCIMProvisionedIdentitiesOptions_GetStartIndex(tt *testing.T) {
  9640  	var zeroValue int
  9641  	l := &ListSCIMProvisionedIdentitiesOptions{StartIndex: &zeroValue}
  9642  	l.GetStartIndex()
  9643  	l = &ListSCIMProvisionedIdentitiesOptions{}
  9644  	l.GetStartIndex()
  9645  	l = nil
  9646  	l.GetStartIndex()
  9647  }
  9648  
  9649  func TestLocation_GetEndColumn(tt *testing.T) {
  9650  	var zeroValue int
  9651  	l := &Location{EndColumn: &zeroValue}
  9652  	l.GetEndColumn()
  9653  	l = &Location{}
  9654  	l.GetEndColumn()
  9655  	l = nil
  9656  	l.GetEndColumn()
  9657  }
  9658  
  9659  func TestLocation_GetEndLine(tt *testing.T) {
  9660  	var zeroValue int
  9661  	l := &Location{EndLine: &zeroValue}
  9662  	l.GetEndLine()
  9663  	l = &Location{}
  9664  	l.GetEndLine()
  9665  	l = nil
  9666  	l.GetEndLine()
  9667  }
  9668  
  9669  func TestLocation_GetPath(tt *testing.T) {
  9670  	var zeroValue string
  9671  	l := &Location{Path: &zeroValue}
  9672  	l.GetPath()
  9673  	l = &Location{}
  9674  	l.GetPath()
  9675  	l = nil
  9676  	l.GetPath()
  9677  }
  9678  
  9679  func TestLocation_GetStartColumn(tt *testing.T) {
  9680  	var zeroValue int
  9681  	l := &Location{StartColumn: &zeroValue}
  9682  	l.GetStartColumn()
  9683  	l = &Location{}
  9684  	l.GetStartColumn()
  9685  	l = nil
  9686  	l.GetStartColumn()
  9687  }
  9688  
  9689  func TestLocation_GetStartLine(tt *testing.T) {
  9690  	var zeroValue int
  9691  	l := &Location{StartLine: &zeroValue}
  9692  	l.GetStartLine()
  9693  	l = &Location{}
  9694  	l.GetStartLine()
  9695  	l = nil
  9696  	l.GetStartLine()
  9697  }
  9698  
  9699  func TestMarketplacePendingChange_GetEffectiveDate(tt *testing.T) {
  9700  	var zeroValue Timestamp
  9701  	m := &MarketplacePendingChange{EffectiveDate: &zeroValue}
  9702  	m.GetEffectiveDate()
  9703  	m = &MarketplacePendingChange{}
  9704  	m.GetEffectiveDate()
  9705  	m = nil
  9706  	m.GetEffectiveDate()
  9707  }
  9708  
  9709  func TestMarketplacePendingChange_GetID(tt *testing.T) {
  9710  	var zeroValue int64
  9711  	m := &MarketplacePendingChange{ID: &zeroValue}
  9712  	m.GetID()
  9713  	m = &MarketplacePendingChange{}
  9714  	m.GetID()
  9715  	m = nil
  9716  	m.GetID()
  9717  }
  9718  
  9719  func TestMarketplacePendingChange_GetPlan(tt *testing.T) {
  9720  	m := &MarketplacePendingChange{}
  9721  	m.GetPlan()
  9722  	m = nil
  9723  	m.GetPlan()
  9724  }
  9725  
  9726  func TestMarketplacePendingChange_GetUnitCount(tt *testing.T) {
  9727  	var zeroValue int
  9728  	m := &MarketplacePendingChange{UnitCount: &zeroValue}
  9729  	m.GetUnitCount()
  9730  	m = &MarketplacePendingChange{}
  9731  	m.GetUnitCount()
  9732  	m = nil
  9733  	m.GetUnitCount()
  9734  }
  9735  
  9736  func TestMarketplacePlan_GetAccountsURL(tt *testing.T) {
  9737  	var zeroValue string
  9738  	m := &MarketplacePlan{AccountsURL: &zeroValue}
  9739  	m.GetAccountsURL()
  9740  	m = &MarketplacePlan{}
  9741  	m.GetAccountsURL()
  9742  	m = nil
  9743  	m.GetAccountsURL()
  9744  }
  9745  
  9746  func TestMarketplacePlan_GetBullets(tt *testing.T) {
  9747  	var zeroValue []string
  9748  	m := &MarketplacePlan{Bullets: &zeroValue}
  9749  	m.GetBullets()
  9750  	m = &MarketplacePlan{}
  9751  	m.GetBullets()
  9752  	m = nil
  9753  	m.GetBullets()
  9754  }
  9755  
  9756  func TestMarketplacePlan_GetDescription(tt *testing.T) {
  9757  	var zeroValue string
  9758  	m := &MarketplacePlan{Description: &zeroValue}
  9759  	m.GetDescription()
  9760  	m = &MarketplacePlan{}
  9761  	m.GetDescription()
  9762  	m = nil
  9763  	m.GetDescription()
  9764  }
  9765  
  9766  func TestMarketplacePlan_GetHasFreeTrial(tt *testing.T) {
  9767  	var zeroValue bool
  9768  	m := &MarketplacePlan{HasFreeTrial: &zeroValue}
  9769  	m.GetHasFreeTrial()
  9770  	m = &MarketplacePlan{}
  9771  	m.GetHasFreeTrial()
  9772  	m = nil
  9773  	m.GetHasFreeTrial()
  9774  }
  9775  
  9776  func TestMarketplacePlan_GetID(tt *testing.T) {
  9777  	var zeroValue int64
  9778  	m := &MarketplacePlan{ID: &zeroValue}
  9779  	m.GetID()
  9780  	m = &MarketplacePlan{}
  9781  	m.GetID()
  9782  	m = nil
  9783  	m.GetID()
  9784  }
  9785  
  9786  func TestMarketplacePlan_GetMonthlyPriceInCents(tt *testing.T) {
  9787  	var zeroValue int
  9788  	m := &MarketplacePlan{MonthlyPriceInCents: &zeroValue}
  9789  	m.GetMonthlyPriceInCents()
  9790  	m = &MarketplacePlan{}
  9791  	m.GetMonthlyPriceInCents()
  9792  	m = nil
  9793  	m.GetMonthlyPriceInCents()
  9794  }
  9795  
  9796  func TestMarketplacePlan_GetName(tt *testing.T) {
  9797  	var zeroValue string
  9798  	m := &MarketplacePlan{Name: &zeroValue}
  9799  	m.GetName()
  9800  	m = &MarketplacePlan{}
  9801  	m.GetName()
  9802  	m = nil
  9803  	m.GetName()
  9804  }
  9805  
  9806  func TestMarketplacePlan_GetNumber(tt *testing.T) {
  9807  	var zeroValue int
  9808  	m := &MarketplacePlan{Number: &zeroValue}
  9809  	m.GetNumber()
  9810  	m = &MarketplacePlan{}
  9811  	m.GetNumber()
  9812  	m = nil
  9813  	m.GetNumber()
  9814  }
  9815  
  9816  func TestMarketplacePlan_GetPriceModel(tt *testing.T) {
  9817  	var zeroValue string
  9818  	m := &MarketplacePlan{PriceModel: &zeroValue}
  9819  	m.GetPriceModel()
  9820  	m = &MarketplacePlan{}
  9821  	m.GetPriceModel()
  9822  	m = nil
  9823  	m.GetPriceModel()
  9824  }
  9825  
  9826  func TestMarketplacePlan_GetState(tt *testing.T) {
  9827  	var zeroValue string
  9828  	m := &MarketplacePlan{State: &zeroValue}
  9829  	m.GetState()
  9830  	m = &MarketplacePlan{}
  9831  	m.GetState()
  9832  	m = nil
  9833  	m.GetState()
  9834  }
  9835  
  9836  func TestMarketplacePlan_GetUnitName(tt *testing.T) {
  9837  	var zeroValue string
  9838  	m := &MarketplacePlan{UnitName: &zeroValue}
  9839  	m.GetUnitName()
  9840  	m = &MarketplacePlan{}
  9841  	m.GetUnitName()
  9842  	m = nil
  9843  	m.GetUnitName()
  9844  }
  9845  
  9846  func TestMarketplacePlan_GetURL(tt *testing.T) {
  9847  	var zeroValue string
  9848  	m := &MarketplacePlan{URL: &zeroValue}
  9849  	m.GetURL()
  9850  	m = &MarketplacePlan{}
  9851  	m.GetURL()
  9852  	m = nil
  9853  	m.GetURL()
  9854  }
  9855  
  9856  func TestMarketplacePlan_GetYearlyPriceInCents(tt *testing.T) {
  9857  	var zeroValue int
  9858  	m := &MarketplacePlan{YearlyPriceInCents: &zeroValue}
  9859  	m.GetYearlyPriceInCents()
  9860  	m = &MarketplacePlan{}
  9861  	m.GetYearlyPriceInCents()
  9862  	m = nil
  9863  	m.GetYearlyPriceInCents()
  9864  }
  9865  
  9866  func TestMarketplacePlanAccount_GetID(tt *testing.T) {
  9867  	var zeroValue int64
  9868  	m := &MarketplacePlanAccount{ID: &zeroValue}
  9869  	m.GetID()
  9870  	m = &MarketplacePlanAccount{}
  9871  	m.GetID()
  9872  	m = nil
  9873  	m.GetID()
  9874  }
  9875  
  9876  func TestMarketplacePlanAccount_GetLogin(tt *testing.T) {
  9877  	var zeroValue string
  9878  	m := &MarketplacePlanAccount{Login: &zeroValue}
  9879  	m.GetLogin()
  9880  	m = &MarketplacePlanAccount{}
  9881  	m.GetLogin()
  9882  	m = nil
  9883  	m.GetLogin()
  9884  }
  9885  
  9886  func TestMarketplacePlanAccount_GetMarketplacePendingChange(tt *testing.T) {
  9887  	m := &MarketplacePlanAccount{}
  9888  	m.GetMarketplacePendingChange()
  9889  	m = nil
  9890  	m.GetMarketplacePendingChange()
  9891  }
  9892  
  9893  func TestMarketplacePlanAccount_GetMarketplacePurchase(tt *testing.T) {
  9894  	m := &MarketplacePlanAccount{}
  9895  	m.GetMarketplacePurchase()
  9896  	m = nil
  9897  	m.GetMarketplacePurchase()
  9898  }
  9899  
  9900  func TestMarketplacePlanAccount_GetOrganizationBillingEmail(tt *testing.T) {
  9901  	var zeroValue string
  9902  	m := &MarketplacePlanAccount{OrganizationBillingEmail: &zeroValue}
  9903  	m.GetOrganizationBillingEmail()
  9904  	m = &MarketplacePlanAccount{}
  9905  	m.GetOrganizationBillingEmail()
  9906  	m = nil
  9907  	m.GetOrganizationBillingEmail()
  9908  }
  9909  
  9910  func TestMarketplacePlanAccount_GetType(tt *testing.T) {
  9911  	var zeroValue string
  9912  	m := &MarketplacePlanAccount{Type: &zeroValue}
  9913  	m.GetType()
  9914  	m = &MarketplacePlanAccount{}
  9915  	m.GetType()
  9916  	m = nil
  9917  	m.GetType()
  9918  }
  9919  
  9920  func TestMarketplacePlanAccount_GetURL(tt *testing.T) {
  9921  	var zeroValue string
  9922  	m := &MarketplacePlanAccount{URL: &zeroValue}
  9923  	m.GetURL()
  9924  	m = &MarketplacePlanAccount{}
  9925  	m.GetURL()
  9926  	m = nil
  9927  	m.GetURL()
  9928  }
  9929  
  9930  func TestMarketplacePurchase_GetBillingCycle(tt *testing.T) {
  9931  	var zeroValue string
  9932  	m := &MarketplacePurchase{BillingCycle: &zeroValue}
  9933  	m.GetBillingCycle()
  9934  	m = &MarketplacePurchase{}
  9935  	m.GetBillingCycle()
  9936  	m = nil
  9937  	m.GetBillingCycle()
  9938  }
  9939  
  9940  func TestMarketplacePurchase_GetFreeTrialEndsOn(tt *testing.T) {
  9941  	var zeroValue Timestamp
  9942  	m := &MarketplacePurchase{FreeTrialEndsOn: &zeroValue}
  9943  	m.GetFreeTrialEndsOn()
  9944  	m = &MarketplacePurchase{}
  9945  	m.GetFreeTrialEndsOn()
  9946  	m = nil
  9947  	m.GetFreeTrialEndsOn()
  9948  }
  9949  
  9950  func TestMarketplacePurchase_GetNextBillingDate(tt *testing.T) {
  9951  	var zeroValue Timestamp
  9952  	m := &MarketplacePurchase{NextBillingDate: &zeroValue}
  9953  	m.GetNextBillingDate()
  9954  	m = &MarketplacePurchase{}
  9955  	m.GetNextBillingDate()
  9956  	m = nil
  9957  	m.GetNextBillingDate()
  9958  }
  9959  
  9960  func TestMarketplacePurchase_GetOnFreeTrial(tt *testing.T) {
  9961  	var zeroValue bool
  9962  	m := &MarketplacePurchase{OnFreeTrial: &zeroValue}
  9963  	m.GetOnFreeTrial()
  9964  	m = &MarketplacePurchase{}
  9965  	m.GetOnFreeTrial()
  9966  	m = nil
  9967  	m.GetOnFreeTrial()
  9968  }
  9969  
  9970  func TestMarketplacePurchase_GetPlan(tt *testing.T) {
  9971  	m := &MarketplacePurchase{}
  9972  	m.GetPlan()
  9973  	m = nil
  9974  	m.GetPlan()
  9975  }
  9976  
  9977  func TestMarketplacePurchase_GetUnitCount(tt *testing.T) {
  9978  	var zeroValue int
  9979  	m := &MarketplacePurchase{UnitCount: &zeroValue}
  9980  	m.GetUnitCount()
  9981  	m = &MarketplacePurchase{}
  9982  	m.GetUnitCount()
  9983  	m = nil
  9984  	m.GetUnitCount()
  9985  }
  9986  
  9987  func TestMarketplacePurchase_GetUpdatedAt(tt *testing.T) {
  9988  	var zeroValue Timestamp
  9989  	m := &MarketplacePurchase{UpdatedAt: &zeroValue}
  9990  	m.GetUpdatedAt()
  9991  	m = &MarketplacePurchase{}
  9992  	m.GetUpdatedAt()
  9993  	m = nil
  9994  	m.GetUpdatedAt()
  9995  }
  9996  
  9997  func TestMarketplacePurchaseEvent_GetAction(tt *testing.T) {
  9998  	var zeroValue string
  9999  	m := &MarketplacePurchaseEvent{Action: &zeroValue}
 10000  	m.GetAction()
 10001  	m = &MarketplacePurchaseEvent{}
 10002  	m.GetAction()
 10003  	m = nil
 10004  	m.GetAction()
 10005  }
 10006  
 10007  func TestMarketplacePurchaseEvent_GetEffectiveDate(tt *testing.T) {
 10008  	var zeroValue Timestamp
 10009  	m := &MarketplacePurchaseEvent{EffectiveDate: &zeroValue}
 10010  	m.GetEffectiveDate()
 10011  	m = &MarketplacePurchaseEvent{}
 10012  	m.GetEffectiveDate()
 10013  	m = nil
 10014  	m.GetEffectiveDate()
 10015  }
 10016  
 10017  func TestMarketplacePurchaseEvent_GetInstallation(tt *testing.T) {
 10018  	m := &MarketplacePurchaseEvent{}
 10019  	m.GetInstallation()
 10020  	m = nil
 10021  	m.GetInstallation()
 10022  }
 10023  
 10024  func TestMarketplacePurchaseEvent_GetMarketplacePurchase(tt *testing.T) {
 10025  	m := &MarketplacePurchaseEvent{}
 10026  	m.GetMarketplacePurchase()
 10027  	m = nil
 10028  	m.GetMarketplacePurchase()
 10029  }
 10030  
 10031  func TestMarketplacePurchaseEvent_GetPreviousMarketplacePurchase(tt *testing.T) {
 10032  	m := &MarketplacePurchaseEvent{}
 10033  	m.GetPreviousMarketplacePurchase()
 10034  	m = nil
 10035  	m.GetPreviousMarketplacePurchase()
 10036  }
 10037  
 10038  func TestMarketplacePurchaseEvent_GetSender(tt *testing.T) {
 10039  	m := &MarketplacePurchaseEvent{}
 10040  	m.GetSender()
 10041  	m = nil
 10042  	m.GetSender()
 10043  }
 10044  
 10045  func TestMatch_GetText(tt *testing.T) {
 10046  	var zeroValue string
 10047  	m := &Match{Text: &zeroValue}
 10048  	m.GetText()
 10049  	m = &Match{}
 10050  	m.GetText()
 10051  	m = nil
 10052  	m.GetText()
 10053  }
 10054  
 10055  func TestMemberEvent_GetAction(tt *testing.T) {
 10056  	var zeroValue string
 10057  	m := &MemberEvent{Action: &zeroValue}
 10058  	m.GetAction()
 10059  	m = &MemberEvent{}
 10060  	m.GetAction()
 10061  	m = nil
 10062  	m.GetAction()
 10063  }
 10064  
 10065  func TestMemberEvent_GetInstallation(tt *testing.T) {
 10066  	m := &MemberEvent{}
 10067  	m.GetInstallation()
 10068  	m = nil
 10069  	m.GetInstallation()
 10070  }
 10071  
 10072  func TestMemberEvent_GetMember(tt *testing.T) {
 10073  	m := &MemberEvent{}
 10074  	m.GetMember()
 10075  	m = nil
 10076  	m.GetMember()
 10077  }
 10078  
 10079  func TestMemberEvent_GetRepo(tt *testing.T) {
 10080  	m := &MemberEvent{}
 10081  	m.GetRepo()
 10082  	m = nil
 10083  	m.GetRepo()
 10084  }
 10085  
 10086  func TestMemberEvent_GetSender(tt *testing.T) {
 10087  	m := &MemberEvent{}
 10088  	m.GetSender()
 10089  	m = nil
 10090  	m.GetSender()
 10091  }
 10092  
 10093  func TestMembership_GetOrganization(tt *testing.T) {
 10094  	m := &Membership{}
 10095  	m.GetOrganization()
 10096  	m = nil
 10097  	m.GetOrganization()
 10098  }
 10099  
 10100  func TestMembership_GetOrganizationURL(tt *testing.T) {
 10101  	var zeroValue string
 10102  	m := &Membership{OrganizationURL: &zeroValue}
 10103  	m.GetOrganizationURL()
 10104  	m = &Membership{}
 10105  	m.GetOrganizationURL()
 10106  	m = nil
 10107  	m.GetOrganizationURL()
 10108  }
 10109  
 10110  func TestMembership_GetRole(tt *testing.T) {
 10111  	var zeroValue string
 10112  	m := &Membership{Role: &zeroValue}
 10113  	m.GetRole()
 10114  	m = &Membership{}
 10115  	m.GetRole()
 10116  	m = nil
 10117  	m.GetRole()
 10118  }
 10119  
 10120  func TestMembership_GetState(tt *testing.T) {
 10121  	var zeroValue string
 10122  	m := &Membership{State: &zeroValue}
 10123  	m.GetState()
 10124  	m = &Membership{}
 10125  	m.GetState()
 10126  	m = nil
 10127  	m.GetState()
 10128  }
 10129  
 10130  func TestMembership_GetURL(tt *testing.T) {
 10131  	var zeroValue string
 10132  	m := &Membership{URL: &zeroValue}
 10133  	m.GetURL()
 10134  	m = &Membership{}
 10135  	m.GetURL()
 10136  	m = nil
 10137  	m.GetURL()
 10138  }
 10139  
 10140  func TestMembership_GetUser(tt *testing.T) {
 10141  	m := &Membership{}
 10142  	m.GetUser()
 10143  	m = nil
 10144  	m.GetUser()
 10145  }
 10146  
 10147  func TestMembershipEvent_GetAction(tt *testing.T) {
 10148  	var zeroValue string
 10149  	m := &MembershipEvent{Action: &zeroValue}
 10150  	m.GetAction()
 10151  	m = &MembershipEvent{}
 10152  	m.GetAction()
 10153  	m = nil
 10154  	m.GetAction()
 10155  }
 10156  
 10157  func TestMembershipEvent_GetInstallation(tt *testing.T) {
 10158  	m := &MembershipEvent{}
 10159  	m.GetInstallation()
 10160  	m = nil
 10161  	m.GetInstallation()
 10162  }
 10163  
 10164  func TestMembershipEvent_GetMember(tt *testing.T) {
 10165  	m := &MembershipEvent{}
 10166  	m.GetMember()
 10167  	m = nil
 10168  	m.GetMember()
 10169  }
 10170  
 10171  func TestMembershipEvent_GetOrg(tt *testing.T) {
 10172  	m := &MembershipEvent{}
 10173  	m.GetOrg()
 10174  	m = nil
 10175  	m.GetOrg()
 10176  }
 10177  
 10178  func TestMembershipEvent_GetScope(tt *testing.T) {
 10179  	var zeroValue string
 10180  	m := &MembershipEvent{Scope: &zeroValue}
 10181  	m.GetScope()
 10182  	m = &MembershipEvent{}
 10183  	m.GetScope()
 10184  	m = nil
 10185  	m.GetScope()
 10186  }
 10187  
 10188  func TestMembershipEvent_GetSender(tt *testing.T) {
 10189  	m := &MembershipEvent{}
 10190  	m.GetSender()
 10191  	m = nil
 10192  	m.GetSender()
 10193  }
 10194  
 10195  func TestMembershipEvent_GetTeam(tt *testing.T) {
 10196  	m := &MembershipEvent{}
 10197  	m.GetTeam()
 10198  	m = nil
 10199  	m.GetTeam()
 10200  }
 10201  
 10202  func TestMessage_GetText(tt *testing.T) {
 10203  	var zeroValue string
 10204  	m := &Message{Text: &zeroValue}
 10205  	m.GetText()
 10206  	m = &Message{}
 10207  	m.GetText()
 10208  	m = nil
 10209  	m.GetText()
 10210  }
 10211  
 10212  func TestMetaEvent_GetAction(tt *testing.T) {
 10213  	var zeroValue string
 10214  	m := &MetaEvent{Action: &zeroValue}
 10215  	m.GetAction()
 10216  	m = &MetaEvent{}
 10217  	m.GetAction()
 10218  	m = nil
 10219  	m.GetAction()
 10220  }
 10221  
 10222  func TestMetaEvent_GetHook(tt *testing.T) {
 10223  	m := &MetaEvent{}
 10224  	m.GetHook()
 10225  	m = nil
 10226  	m.GetHook()
 10227  }
 10228  
 10229  func TestMetaEvent_GetHookID(tt *testing.T) {
 10230  	var zeroValue int64
 10231  	m := &MetaEvent{HookID: &zeroValue}
 10232  	m.GetHookID()
 10233  	m = &MetaEvent{}
 10234  	m.GetHookID()
 10235  	m = nil
 10236  	m.GetHookID()
 10237  }
 10238  
 10239  func TestMetaEvent_GetInstallation(tt *testing.T) {
 10240  	m := &MetaEvent{}
 10241  	m.GetInstallation()
 10242  	m = nil
 10243  	m.GetInstallation()
 10244  }
 10245  
 10246  func TestMetaEvent_GetOrg(tt *testing.T) {
 10247  	m := &MetaEvent{}
 10248  	m.GetOrg()
 10249  	m = nil
 10250  	m.GetOrg()
 10251  }
 10252  
 10253  func TestMetaEvent_GetRepo(tt *testing.T) {
 10254  	m := &MetaEvent{}
 10255  	m.GetRepo()
 10256  	m = nil
 10257  	m.GetRepo()
 10258  }
 10259  
 10260  func TestMetaEvent_GetSender(tt *testing.T) {
 10261  	m := &MetaEvent{}
 10262  	m.GetSender()
 10263  	m = nil
 10264  	m.GetSender()
 10265  }
 10266  
 10267  func TestMetric_GetHTMLURL(tt *testing.T) {
 10268  	var zeroValue string
 10269  	m := &Metric{HTMLURL: &zeroValue}
 10270  	m.GetHTMLURL()
 10271  	m = &Metric{}
 10272  	m.GetHTMLURL()
 10273  	m = nil
 10274  	m.GetHTMLURL()
 10275  }
 10276  
 10277  func TestMetric_GetKey(tt *testing.T) {
 10278  	var zeroValue string
 10279  	m := &Metric{Key: &zeroValue}
 10280  	m.GetKey()
 10281  	m = &Metric{}
 10282  	m.GetKey()
 10283  	m = nil
 10284  	m.GetKey()
 10285  }
 10286  
 10287  func TestMetric_GetName(tt *testing.T) {
 10288  	var zeroValue string
 10289  	m := &Metric{Name: &zeroValue}
 10290  	m.GetName()
 10291  	m = &Metric{}
 10292  	m.GetName()
 10293  	m = nil
 10294  	m.GetName()
 10295  }
 10296  
 10297  func TestMetric_GetNodeID(tt *testing.T) {
 10298  	var zeroValue string
 10299  	m := &Metric{NodeID: &zeroValue}
 10300  	m.GetNodeID()
 10301  	m = &Metric{}
 10302  	m.GetNodeID()
 10303  	m = nil
 10304  	m.GetNodeID()
 10305  }
 10306  
 10307  func TestMetric_GetSPDXID(tt *testing.T) {
 10308  	var zeroValue string
 10309  	m := &Metric{SPDXID: &zeroValue}
 10310  	m.GetSPDXID()
 10311  	m = &Metric{}
 10312  	m.GetSPDXID()
 10313  	m = nil
 10314  	m.GetSPDXID()
 10315  }
 10316  
 10317  func TestMetric_GetURL(tt *testing.T) {
 10318  	var zeroValue string
 10319  	m := &Metric{URL: &zeroValue}
 10320  	m.GetURL()
 10321  	m = &Metric{}
 10322  	m.GetURL()
 10323  	m = nil
 10324  	m.GetURL()
 10325  }
 10326  
 10327  func TestMigration_GetCreatedAt(tt *testing.T) {
 10328  	var zeroValue string
 10329  	m := &Migration{CreatedAt: &zeroValue}
 10330  	m.GetCreatedAt()
 10331  	m = &Migration{}
 10332  	m.GetCreatedAt()
 10333  	m = nil
 10334  	m.GetCreatedAt()
 10335  }
 10336  
 10337  func TestMigration_GetExcludeAttachments(tt *testing.T) {
 10338  	var zeroValue bool
 10339  	m := &Migration{ExcludeAttachments: &zeroValue}
 10340  	m.GetExcludeAttachments()
 10341  	m = &Migration{}
 10342  	m.GetExcludeAttachments()
 10343  	m = nil
 10344  	m.GetExcludeAttachments()
 10345  }
 10346  
 10347  func TestMigration_GetGUID(tt *testing.T) {
 10348  	var zeroValue string
 10349  	m := &Migration{GUID: &zeroValue}
 10350  	m.GetGUID()
 10351  	m = &Migration{}
 10352  	m.GetGUID()
 10353  	m = nil
 10354  	m.GetGUID()
 10355  }
 10356  
 10357  func TestMigration_GetID(tt *testing.T) {
 10358  	var zeroValue int64
 10359  	m := &Migration{ID: &zeroValue}
 10360  	m.GetID()
 10361  	m = &Migration{}
 10362  	m.GetID()
 10363  	m = nil
 10364  	m.GetID()
 10365  }
 10366  
 10367  func TestMigration_GetLockRepositories(tt *testing.T) {
 10368  	var zeroValue bool
 10369  	m := &Migration{LockRepositories: &zeroValue}
 10370  	m.GetLockRepositories()
 10371  	m = &Migration{}
 10372  	m.GetLockRepositories()
 10373  	m = nil
 10374  	m.GetLockRepositories()
 10375  }
 10376  
 10377  func TestMigration_GetState(tt *testing.T) {
 10378  	var zeroValue string
 10379  	m := &Migration{State: &zeroValue}
 10380  	m.GetState()
 10381  	m = &Migration{}
 10382  	m.GetState()
 10383  	m = nil
 10384  	m.GetState()
 10385  }
 10386  
 10387  func TestMigration_GetUpdatedAt(tt *testing.T) {
 10388  	var zeroValue string
 10389  	m := &Migration{UpdatedAt: &zeroValue}
 10390  	m.GetUpdatedAt()
 10391  	m = &Migration{}
 10392  	m.GetUpdatedAt()
 10393  	m = nil
 10394  	m.GetUpdatedAt()
 10395  }
 10396  
 10397  func TestMigration_GetURL(tt *testing.T) {
 10398  	var zeroValue string
 10399  	m := &Migration{URL: &zeroValue}
 10400  	m.GetURL()
 10401  	m = &Migration{}
 10402  	m.GetURL()
 10403  	m = nil
 10404  	m.GetURL()
 10405  }
 10406  
 10407  func TestMilestone_GetClosedAt(tt *testing.T) {
 10408  	var zeroValue time.Time
 10409  	m := &Milestone{ClosedAt: &zeroValue}
 10410  	m.GetClosedAt()
 10411  	m = &Milestone{}
 10412  	m.GetClosedAt()
 10413  	m = nil
 10414  	m.GetClosedAt()
 10415  }
 10416  
 10417  func TestMilestone_GetClosedIssues(tt *testing.T) {
 10418  	var zeroValue int
 10419  	m := &Milestone{ClosedIssues: &zeroValue}
 10420  	m.GetClosedIssues()
 10421  	m = &Milestone{}
 10422  	m.GetClosedIssues()
 10423  	m = nil
 10424  	m.GetClosedIssues()
 10425  }
 10426  
 10427  func TestMilestone_GetCreatedAt(tt *testing.T) {
 10428  	var zeroValue time.Time
 10429  	m := &Milestone{CreatedAt: &zeroValue}
 10430  	m.GetCreatedAt()
 10431  	m = &Milestone{}
 10432  	m.GetCreatedAt()
 10433  	m = nil
 10434  	m.GetCreatedAt()
 10435  }
 10436  
 10437  func TestMilestone_GetCreator(tt *testing.T) {
 10438  	m := &Milestone{}
 10439  	m.GetCreator()
 10440  	m = nil
 10441  	m.GetCreator()
 10442  }
 10443  
 10444  func TestMilestone_GetDescription(tt *testing.T) {
 10445  	var zeroValue string
 10446  	m := &Milestone{Description: &zeroValue}
 10447  	m.GetDescription()
 10448  	m = &Milestone{}
 10449  	m.GetDescription()
 10450  	m = nil
 10451  	m.GetDescription()
 10452  }
 10453  
 10454  func TestMilestone_GetDueOn(tt *testing.T) {
 10455  	var zeroValue time.Time
 10456  	m := &Milestone{DueOn: &zeroValue}
 10457  	m.GetDueOn()
 10458  	m = &Milestone{}
 10459  	m.GetDueOn()
 10460  	m = nil
 10461  	m.GetDueOn()
 10462  }
 10463  
 10464  func TestMilestone_GetHTMLURL(tt *testing.T) {
 10465  	var zeroValue string
 10466  	m := &Milestone{HTMLURL: &zeroValue}
 10467  	m.GetHTMLURL()
 10468  	m = &Milestone{}
 10469  	m.GetHTMLURL()
 10470  	m = nil
 10471  	m.GetHTMLURL()
 10472  }
 10473  
 10474  func TestMilestone_GetID(tt *testing.T) {
 10475  	var zeroValue int64
 10476  	m := &Milestone{ID: &zeroValue}
 10477  	m.GetID()
 10478  	m = &Milestone{}
 10479  	m.GetID()
 10480  	m = nil
 10481  	m.GetID()
 10482  }
 10483  
 10484  func TestMilestone_GetLabelsURL(tt *testing.T) {
 10485  	var zeroValue string
 10486  	m := &Milestone{LabelsURL: &zeroValue}
 10487  	m.GetLabelsURL()
 10488  	m = &Milestone{}
 10489  	m.GetLabelsURL()
 10490  	m = nil
 10491  	m.GetLabelsURL()
 10492  }
 10493  
 10494  func TestMilestone_GetNodeID(tt *testing.T) {
 10495  	var zeroValue string
 10496  	m := &Milestone{NodeID: &zeroValue}
 10497  	m.GetNodeID()
 10498  	m = &Milestone{}
 10499  	m.GetNodeID()
 10500  	m = nil
 10501  	m.GetNodeID()
 10502  }
 10503  
 10504  func TestMilestone_GetNumber(tt *testing.T) {
 10505  	var zeroValue int
 10506  	m := &Milestone{Number: &zeroValue}
 10507  	m.GetNumber()
 10508  	m = &Milestone{}
 10509  	m.GetNumber()
 10510  	m = nil
 10511  	m.GetNumber()
 10512  }
 10513  
 10514  func TestMilestone_GetOpenIssues(tt *testing.T) {
 10515  	var zeroValue int
 10516  	m := &Milestone{OpenIssues: &zeroValue}
 10517  	m.GetOpenIssues()
 10518  	m = &Milestone{}
 10519  	m.GetOpenIssues()
 10520  	m = nil
 10521  	m.GetOpenIssues()
 10522  }
 10523  
 10524  func TestMilestone_GetState(tt *testing.T) {
 10525  	var zeroValue string
 10526  	m := &Milestone{State: &zeroValue}
 10527  	m.GetState()
 10528  	m = &Milestone{}
 10529  	m.GetState()
 10530  	m = nil
 10531  	m.GetState()
 10532  }
 10533  
 10534  func TestMilestone_GetTitle(tt *testing.T) {
 10535  	var zeroValue string
 10536  	m := &Milestone{Title: &zeroValue}
 10537  	m.GetTitle()
 10538  	m = &Milestone{}
 10539  	m.GetTitle()
 10540  	m = nil
 10541  	m.GetTitle()
 10542  }
 10543  
 10544  func TestMilestone_GetUpdatedAt(tt *testing.T) {
 10545  	var zeroValue time.Time
 10546  	m := &Milestone{UpdatedAt: &zeroValue}
 10547  	m.GetUpdatedAt()
 10548  	m = &Milestone{}
 10549  	m.GetUpdatedAt()
 10550  	m = nil
 10551  	m.GetUpdatedAt()
 10552  }
 10553  
 10554  func TestMilestone_GetURL(tt *testing.T) {
 10555  	var zeroValue string
 10556  	m := &Milestone{URL: &zeroValue}
 10557  	m.GetURL()
 10558  	m = &Milestone{}
 10559  	m.GetURL()
 10560  	m = nil
 10561  	m.GetURL()
 10562  }
 10563  
 10564  func TestMilestoneEvent_GetAction(tt *testing.T) {
 10565  	var zeroValue string
 10566  	m := &MilestoneEvent{Action: &zeroValue}
 10567  	m.GetAction()
 10568  	m = &MilestoneEvent{}
 10569  	m.GetAction()
 10570  	m = nil
 10571  	m.GetAction()
 10572  }
 10573  
 10574  func TestMilestoneEvent_GetChanges(tt *testing.T) {
 10575  	m := &MilestoneEvent{}
 10576  	m.GetChanges()
 10577  	m = nil
 10578  	m.GetChanges()
 10579  }
 10580  
 10581  func TestMilestoneEvent_GetInstallation(tt *testing.T) {
 10582  	m := &MilestoneEvent{}
 10583  	m.GetInstallation()
 10584  	m = nil
 10585  	m.GetInstallation()
 10586  }
 10587  
 10588  func TestMilestoneEvent_GetMilestone(tt *testing.T) {
 10589  	m := &MilestoneEvent{}
 10590  	m.GetMilestone()
 10591  	m = nil
 10592  	m.GetMilestone()
 10593  }
 10594  
 10595  func TestMilestoneEvent_GetOrg(tt *testing.T) {
 10596  	m := &MilestoneEvent{}
 10597  	m.GetOrg()
 10598  	m = nil
 10599  	m.GetOrg()
 10600  }
 10601  
 10602  func TestMilestoneEvent_GetRepo(tt *testing.T) {
 10603  	m := &MilestoneEvent{}
 10604  	m.GetRepo()
 10605  	m = nil
 10606  	m.GetRepo()
 10607  }
 10608  
 10609  func TestMilestoneEvent_GetSender(tt *testing.T) {
 10610  	m := &MilestoneEvent{}
 10611  	m.GetSender()
 10612  	m = nil
 10613  	m.GetSender()
 10614  }
 10615  
 10616  func TestMilestoneStats_GetClosedMilestones(tt *testing.T) {
 10617  	var zeroValue int
 10618  	m := &MilestoneStats{ClosedMilestones: &zeroValue}
 10619  	m.GetClosedMilestones()
 10620  	m = &MilestoneStats{}
 10621  	m.GetClosedMilestones()
 10622  	m = nil
 10623  	m.GetClosedMilestones()
 10624  }
 10625  
 10626  func TestMilestoneStats_GetOpenMilestones(tt *testing.T) {
 10627  	var zeroValue int
 10628  	m := &MilestoneStats{OpenMilestones: &zeroValue}
 10629  	m.GetOpenMilestones()
 10630  	m = &MilestoneStats{}
 10631  	m.GetOpenMilestones()
 10632  	m = nil
 10633  	m.GetOpenMilestones()
 10634  }
 10635  
 10636  func TestMilestoneStats_GetTotalMilestones(tt *testing.T) {
 10637  	var zeroValue int
 10638  	m := &MilestoneStats{TotalMilestones: &zeroValue}
 10639  	m.GetTotalMilestones()
 10640  	m = &MilestoneStats{}
 10641  	m.GetTotalMilestones()
 10642  	m = nil
 10643  	m.GetTotalMilestones()
 10644  }
 10645  
 10646  func TestMostRecentInstance_GetAnalysisKey(tt *testing.T) {
 10647  	var zeroValue string
 10648  	m := &MostRecentInstance{AnalysisKey: &zeroValue}
 10649  	m.GetAnalysisKey()
 10650  	m = &MostRecentInstance{}
 10651  	m.GetAnalysisKey()
 10652  	m = nil
 10653  	m.GetAnalysisKey()
 10654  }
 10655  
 10656  func TestMostRecentInstance_GetCommitSHA(tt *testing.T) {
 10657  	var zeroValue string
 10658  	m := &MostRecentInstance{CommitSHA: &zeroValue}
 10659  	m.GetCommitSHA()
 10660  	m = &MostRecentInstance{}
 10661  	m.GetCommitSHA()
 10662  	m = nil
 10663  	m.GetCommitSHA()
 10664  }
 10665  
 10666  func TestMostRecentInstance_GetEnvironment(tt *testing.T) {
 10667  	var zeroValue string
 10668  	m := &MostRecentInstance{Environment: &zeroValue}
 10669  	m.GetEnvironment()
 10670  	m = &MostRecentInstance{}
 10671  	m.GetEnvironment()
 10672  	m = nil
 10673  	m.GetEnvironment()
 10674  }
 10675  
 10676  func TestMostRecentInstance_GetLocation(tt *testing.T) {
 10677  	m := &MostRecentInstance{}
 10678  	m.GetLocation()
 10679  	m = nil
 10680  	m.GetLocation()
 10681  }
 10682  
 10683  func TestMostRecentInstance_GetMessage(tt *testing.T) {
 10684  	m := &MostRecentInstance{}
 10685  	m.GetMessage()
 10686  	m = nil
 10687  	m.GetMessage()
 10688  }
 10689  
 10690  func TestMostRecentInstance_GetRef(tt *testing.T) {
 10691  	var zeroValue string
 10692  	m := &MostRecentInstance{Ref: &zeroValue}
 10693  	m.GetRef()
 10694  	m = &MostRecentInstance{}
 10695  	m.GetRef()
 10696  	m = nil
 10697  	m.GetRef()
 10698  }
 10699  
 10700  func TestMostRecentInstance_GetState(tt *testing.T) {
 10701  	var zeroValue string
 10702  	m := &MostRecentInstance{State: &zeroValue}
 10703  	m.GetState()
 10704  	m = &MostRecentInstance{}
 10705  	m.GetState()
 10706  	m = nil
 10707  	m.GetState()
 10708  }
 10709  
 10710  func TestNewPullRequest_GetBase(tt *testing.T) {
 10711  	var zeroValue string
 10712  	n := &NewPullRequest{Base: &zeroValue}
 10713  	n.GetBase()
 10714  	n = &NewPullRequest{}
 10715  	n.GetBase()
 10716  	n = nil
 10717  	n.GetBase()
 10718  }
 10719  
 10720  func TestNewPullRequest_GetBody(tt *testing.T) {
 10721  	var zeroValue string
 10722  	n := &NewPullRequest{Body: &zeroValue}
 10723  	n.GetBody()
 10724  	n = &NewPullRequest{}
 10725  	n.GetBody()
 10726  	n = nil
 10727  	n.GetBody()
 10728  }
 10729  
 10730  func TestNewPullRequest_GetDraft(tt *testing.T) {
 10731  	var zeroValue bool
 10732  	n := &NewPullRequest{Draft: &zeroValue}
 10733  	n.GetDraft()
 10734  	n = &NewPullRequest{}
 10735  	n.GetDraft()
 10736  	n = nil
 10737  	n.GetDraft()
 10738  }
 10739  
 10740  func TestNewPullRequest_GetHead(tt *testing.T) {
 10741  	var zeroValue string
 10742  	n := &NewPullRequest{Head: &zeroValue}
 10743  	n.GetHead()
 10744  	n = &NewPullRequest{}
 10745  	n.GetHead()
 10746  	n = nil
 10747  	n.GetHead()
 10748  }
 10749  
 10750  func TestNewPullRequest_GetIssue(tt *testing.T) {
 10751  	var zeroValue int
 10752  	n := &NewPullRequest{Issue: &zeroValue}
 10753  	n.GetIssue()
 10754  	n = &NewPullRequest{}
 10755  	n.GetIssue()
 10756  	n = nil
 10757  	n.GetIssue()
 10758  }
 10759  
 10760  func TestNewPullRequest_GetMaintainerCanModify(tt *testing.T) {
 10761  	var zeroValue bool
 10762  	n := &NewPullRequest{MaintainerCanModify: &zeroValue}
 10763  	n.GetMaintainerCanModify()
 10764  	n = &NewPullRequest{}
 10765  	n.GetMaintainerCanModify()
 10766  	n = nil
 10767  	n.GetMaintainerCanModify()
 10768  }
 10769  
 10770  func TestNewPullRequest_GetTitle(tt *testing.T) {
 10771  	var zeroValue string
 10772  	n := &NewPullRequest{Title: &zeroValue}
 10773  	n.GetTitle()
 10774  	n = &NewPullRequest{}
 10775  	n.GetTitle()
 10776  	n = nil
 10777  	n.GetTitle()
 10778  }
 10779  
 10780  func TestNewTeam_GetDescription(tt *testing.T) {
 10781  	var zeroValue string
 10782  	n := &NewTeam{Description: &zeroValue}
 10783  	n.GetDescription()
 10784  	n = &NewTeam{}
 10785  	n.GetDescription()
 10786  	n = nil
 10787  	n.GetDescription()
 10788  }
 10789  
 10790  func TestNewTeam_GetLDAPDN(tt *testing.T) {
 10791  	var zeroValue string
 10792  	n := &NewTeam{LDAPDN: &zeroValue}
 10793  	n.GetLDAPDN()
 10794  	n = &NewTeam{}
 10795  	n.GetLDAPDN()
 10796  	n = nil
 10797  	n.GetLDAPDN()
 10798  }
 10799  
 10800  func TestNewTeam_GetParentTeamID(tt *testing.T) {
 10801  	var zeroValue int64
 10802  	n := &NewTeam{ParentTeamID: &zeroValue}
 10803  	n.GetParentTeamID()
 10804  	n = &NewTeam{}
 10805  	n.GetParentTeamID()
 10806  	n = nil
 10807  	n.GetParentTeamID()
 10808  }
 10809  
 10810  func TestNewTeam_GetPermission(tt *testing.T) {
 10811  	var zeroValue string
 10812  	n := &NewTeam{Permission: &zeroValue}
 10813  	n.GetPermission()
 10814  	n = &NewTeam{}
 10815  	n.GetPermission()
 10816  	n = nil
 10817  	n.GetPermission()
 10818  }
 10819  
 10820  func TestNewTeam_GetPrivacy(tt *testing.T) {
 10821  	var zeroValue string
 10822  	n := &NewTeam{Privacy: &zeroValue}
 10823  	n.GetPrivacy()
 10824  	n = &NewTeam{}
 10825  	n.GetPrivacy()
 10826  	n = nil
 10827  	n.GetPrivacy()
 10828  }
 10829  
 10830  func TestNotification_GetID(tt *testing.T) {
 10831  	var zeroValue string
 10832  	n := &Notification{ID: &zeroValue}
 10833  	n.GetID()
 10834  	n = &Notification{}
 10835  	n.GetID()
 10836  	n = nil
 10837  	n.GetID()
 10838  }
 10839  
 10840  func TestNotification_GetLastReadAt(tt *testing.T) {
 10841  	var zeroValue time.Time
 10842  	n := &Notification{LastReadAt: &zeroValue}
 10843  	n.GetLastReadAt()
 10844  	n = &Notification{}
 10845  	n.GetLastReadAt()
 10846  	n = nil
 10847  	n.GetLastReadAt()
 10848  }
 10849  
 10850  func TestNotification_GetReason(tt *testing.T) {
 10851  	var zeroValue string
 10852  	n := &Notification{Reason: &zeroValue}
 10853  	n.GetReason()
 10854  	n = &Notification{}
 10855  	n.GetReason()
 10856  	n = nil
 10857  	n.GetReason()
 10858  }
 10859  
 10860  func TestNotification_GetRepository(tt *testing.T) {
 10861  	n := &Notification{}
 10862  	n.GetRepository()
 10863  	n = nil
 10864  	n.GetRepository()
 10865  }
 10866  
 10867  func TestNotification_GetSubject(tt *testing.T) {
 10868  	n := &Notification{}
 10869  	n.GetSubject()
 10870  	n = nil
 10871  	n.GetSubject()
 10872  }
 10873  
 10874  func TestNotification_GetUnread(tt *testing.T) {
 10875  	var zeroValue bool
 10876  	n := &Notification{Unread: &zeroValue}
 10877  	n.GetUnread()
 10878  	n = &Notification{}
 10879  	n.GetUnread()
 10880  	n = nil
 10881  	n.GetUnread()
 10882  }
 10883  
 10884  func TestNotification_GetUpdatedAt(tt *testing.T) {
 10885  	var zeroValue time.Time
 10886  	n := &Notification{UpdatedAt: &zeroValue}
 10887  	n.GetUpdatedAt()
 10888  	n = &Notification{}
 10889  	n.GetUpdatedAt()
 10890  	n = nil
 10891  	n.GetUpdatedAt()
 10892  }
 10893  
 10894  func TestNotification_GetURL(tt *testing.T) {
 10895  	var zeroValue string
 10896  	n := &Notification{URL: &zeroValue}
 10897  	n.GetURL()
 10898  	n = &Notification{}
 10899  	n.GetURL()
 10900  	n = nil
 10901  	n.GetURL()
 10902  }
 10903  
 10904  func TestNotificationSubject_GetLatestCommentURL(tt *testing.T) {
 10905  	var zeroValue string
 10906  	n := &NotificationSubject{LatestCommentURL: &zeroValue}
 10907  	n.GetLatestCommentURL()
 10908  	n = &NotificationSubject{}
 10909  	n.GetLatestCommentURL()
 10910  	n = nil
 10911  	n.GetLatestCommentURL()
 10912  }
 10913  
 10914  func TestNotificationSubject_GetTitle(tt *testing.T) {
 10915  	var zeroValue string
 10916  	n := &NotificationSubject{Title: &zeroValue}
 10917  	n.GetTitle()
 10918  	n = &NotificationSubject{}
 10919  	n.GetTitle()
 10920  	n = nil
 10921  	n.GetTitle()
 10922  }
 10923  
 10924  func TestNotificationSubject_GetType(tt *testing.T) {
 10925  	var zeroValue string
 10926  	n := &NotificationSubject{Type: &zeroValue}
 10927  	n.GetType()
 10928  	n = &NotificationSubject{}
 10929  	n.GetType()
 10930  	n = nil
 10931  	n.GetType()
 10932  }
 10933  
 10934  func TestNotificationSubject_GetURL(tt *testing.T) {
 10935  	var zeroValue string
 10936  	n := &NotificationSubject{URL: &zeroValue}
 10937  	n.GetURL()
 10938  	n = &NotificationSubject{}
 10939  	n.GetURL()
 10940  	n = nil
 10941  	n.GetURL()
 10942  }
 10943  
 10944  func TestOAuthAPP_GetClientID(tt *testing.T) {
 10945  	var zeroValue string
 10946  	o := &OAuthAPP{ClientID: &zeroValue}
 10947  	o.GetClientID()
 10948  	o = &OAuthAPP{}
 10949  	o.GetClientID()
 10950  	o = nil
 10951  	o.GetClientID()
 10952  }
 10953  
 10954  func TestOAuthAPP_GetName(tt *testing.T) {
 10955  	var zeroValue string
 10956  	o := &OAuthAPP{Name: &zeroValue}
 10957  	o.GetName()
 10958  	o = &OAuthAPP{}
 10959  	o.GetName()
 10960  	o = nil
 10961  	o.GetName()
 10962  }
 10963  
 10964  func TestOAuthAPP_GetURL(tt *testing.T) {
 10965  	var zeroValue string
 10966  	o := &OAuthAPP{URL: &zeroValue}
 10967  	o.GetURL()
 10968  	o = &OAuthAPP{}
 10969  	o.GetURL()
 10970  	o = nil
 10971  	o.GetURL()
 10972  }
 10973  
 10974  func TestOrganization_GetAvatarURL(tt *testing.T) {
 10975  	var zeroValue string
 10976  	o := &Organization{AvatarURL: &zeroValue}
 10977  	o.GetAvatarURL()
 10978  	o = &Organization{}
 10979  	o.GetAvatarURL()
 10980  	o = nil
 10981  	o.GetAvatarURL()
 10982  }
 10983  
 10984  func TestOrganization_GetBillingEmail(tt *testing.T) {
 10985  	var zeroValue string
 10986  	o := &Organization{BillingEmail: &zeroValue}
 10987  	o.GetBillingEmail()
 10988  	o = &Organization{}
 10989  	o.GetBillingEmail()
 10990  	o = nil
 10991  	o.GetBillingEmail()
 10992  }
 10993  
 10994  func TestOrganization_GetBlog(tt *testing.T) {
 10995  	var zeroValue string
 10996  	o := &Organization{Blog: &zeroValue}
 10997  	o.GetBlog()
 10998  	o = &Organization{}
 10999  	o.GetBlog()
 11000  	o = nil
 11001  	o.GetBlog()
 11002  }
 11003  
 11004  func TestOrganization_GetCollaborators(tt *testing.T) {
 11005  	var zeroValue int
 11006  	o := &Organization{Collaborators: &zeroValue}
 11007  	o.GetCollaborators()
 11008  	o = &Organization{}
 11009  	o.GetCollaborators()
 11010  	o = nil
 11011  	o.GetCollaborators()
 11012  }
 11013  
 11014  func TestOrganization_GetCompany(tt *testing.T) {
 11015  	var zeroValue string
 11016  	o := &Organization{Company: &zeroValue}
 11017  	o.GetCompany()
 11018  	o = &Organization{}
 11019  	o.GetCompany()
 11020  	o = nil
 11021  	o.GetCompany()
 11022  }
 11023  
 11024  func TestOrganization_GetCreatedAt(tt *testing.T) {
 11025  	var zeroValue time.Time
 11026  	o := &Organization{CreatedAt: &zeroValue}
 11027  	o.GetCreatedAt()
 11028  	o = &Organization{}
 11029  	o.GetCreatedAt()
 11030  	o = nil
 11031  	o.GetCreatedAt()
 11032  }
 11033  
 11034  func TestOrganization_GetDefaultRepoPermission(tt *testing.T) {
 11035  	var zeroValue string
 11036  	o := &Organization{DefaultRepoPermission: &zeroValue}
 11037  	o.GetDefaultRepoPermission()
 11038  	o = &Organization{}
 11039  	o.GetDefaultRepoPermission()
 11040  	o = nil
 11041  	o.GetDefaultRepoPermission()
 11042  }
 11043  
 11044  func TestOrganization_GetDefaultRepoSettings(tt *testing.T) {
 11045  	var zeroValue string
 11046  	o := &Organization{DefaultRepoSettings: &zeroValue}
 11047  	o.GetDefaultRepoSettings()
 11048  	o = &Organization{}
 11049  	o.GetDefaultRepoSettings()
 11050  	o = nil
 11051  	o.GetDefaultRepoSettings()
 11052  }
 11053  
 11054  func TestOrganization_GetDescription(tt *testing.T) {
 11055  	var zeroValue string
 11056  	o := &Organization{Description: &zeroValue}
 11057  	o.GetDescription()
 11058  	o = &Organization{}
 11059  	o.GetDescription()
 11060  	o = nil
 11061  	o.GetDescription()
 11062  }
 11063  
 11064  func TestOrganization_GetDiskUsage(tt *testing.T) {
 11065  	var zeroValue int
 11066  	o := &Organization{DiskUsage: &zeroValue}
 11067  	o.GetDiskUsage()
 11068  	o = &Organization{}
 11069  	o.GetDiskUsage()
 11070  	o = nil
 11071  	o.GetDiskUsage()
 11072  }
 11073  
 11074  func TestOrganization_GetEmail(tt *testing.T) {
 11075  	var zeroValue string
 11076  	o := &Organization{Email: &zeroValue}
 11077  	o.GetEmail()
 11078  	o = &Organization{}
 11079  	o.GetEmail()
 11080  	o = nil
 11081  	o.GetEmail()
 11082  }
 11083  
 11084  func TestOrganization_GetEventsURL(tt *testing.T) {
 11085  	var zeroValue string
 11086  	o := &Organization{EventsURL: &zeroValue}
 11087  	o.GetEventsURL()
 11088  	o = &Organization{}
 11089  	o.GetEventsURL()
 11090  	o = nil
 11091  	o.GetEventsURL()
 11092  }
 11093  
 11094  func TestOrganization_GetFollowers(tt *testing.T) {
 11095  	var zeroValue int
 11096  	o := &Organization{Followers: &zeroValue}
 11097  	o.GetFollowers()
 11098  	o = &Organization{}
 11099  	o.GetFollowers()
 11100  	o = nil
 11101  	o.GetFollowers()
 11102  }
 11103  
 11104  func TestOrganization_GetFollowing(tt *testing.T) {
 11105  	var zeroValue int
 11106  	o := &Organization{Following: &zeroValue}
 11107  	o.GetFollowing()
 11108  	o = &Organization{}
 11109  	o.GetFollowing()
 11110  	o = nil
 11111  	o.GetFollowing()
 11112  }
 11113  
 11114  func TestOrganization_GetHasOrganizationProjects(tt *testing.T) {
 11115  	var zeroValue bool
 11116  	o := &Organization{HasOrganizationProjects: &zeroValue}
 11117  	o.GetHasOrganizationProjects()
 11118  	o = &Organization{}
 11119  	o.GetHasOrganizationProjects()
 11120  	o = nil
 11121  	o.GetHasOrganizationProjects()
 11122  }
 11123  
 11124  func TestOrganization_GetHasRepositoryProjects(tt *testing.T) {
 11125  	var zeroValue bool
 11126  	o := &Organization{HasRepositoryProjects: &zeroValue}
 11127  	o.GetHasRepositoryProjects()
 11128  	o = &Organization{}
 11129  	o.GetHasRepositoryProjects()
 11130  	o = nil
 11131  	o.GetHasRepositoryProjects()
 11132  }
 11133  
 11134  func TestOrganization_GetHooksURL(tt *testing.T) {
 11135  	var zeroValue string
 11136  	o := &Organization{HooksURL: &zeroValue}
 11137  	o.GetHooksURL()
 11138  	o = &Organization{}
 11139  	o.GetHooksURL()
 11140  	o = nil
 11141  	o.GetHooksURL()
 11142  }
 11143  
 11144  func TestOrganization_GetHTMLURL(tt *testing.T) {
 11145  	var zeroValue string
 11146  	o := &Organization{HTMLURL: &zeroValue}
 11147  	o.GetHTMLURL()
 11148  	o = &Organization{}
 11149  	o.GetHTMLURL()
 11150  	o = nil
 11151  	o.GetHTMLURL()
 11152  }
 11153  
 11154  func TestOrganization_GetID(tt *testing.T) {
 11155  	var zeroValue int64
 11156  	o := &Organization{ID: &zeroValue}
 11157  	o.GetID()
 11158  	o = &Organization{}
 11159  	o.GetID()
 11160  	o = nil
 11161  	o.GetID()
 11162  }
 11163  
 11164  func TestOrganization_GetIssuesURL(tt *testing.T) {
 11165  	var zeroValue string
 11166  	o := &Organization{IssuesURL: &zeroValue}
 11167  	o.GetIssuesURL()
 11168  	o = &Organization{}
 11169  	o.GetIssuesURL()
 11170  	o = nil
 11171  	o.GetIssuesURL()
 11172  }
 11173  
 11174  func TestOrganization_GetIsVerified(tt *testing.T) {
 11175  	var zeroValue bool
 11176  	o := &Organization{IsVerified: &zeroValue}
 11177  	o.GetIsVerified()
 11178  	o = &Organization{}
 11179  	o.GetIsVerified()
 11180  	o = nil
 11181  	o.GetIsVerified()
 11182  }
 11183  
 11184  func TestOrganization_GetLocation(tt *testing.T) {
 11185  	var zeroValue string
 11186  	o := &Organization{Location: &zeroValue}
 11187  	o.GetLocation()
 11188  	o = &Organization{}
 11189  	o.GetLocation()
 11190  	o = nil
 11191  	o.GetLocation()
 11192  }
 11193  
 11194  func TestOrganization_GetLogin(tt *testing.T) {
 11195  	var zeroValue string
 11196  	o := &Organization{Login: &zeroValue}
 11197  	o.GetLogin()
 11198  	o = &Organization{}
 11199  	o.GetLogin()
 11200  	o = nil
 11201  	o.GetLogin()
 11202  }
 11203  
 11204  func TestOrganization_GetMembersAllowedRepositoryCreationType(tt *testing.T) {
 11205  	var zeroValue string
 11206  	o := &Organization{MembersAllowedRepositoryCreationType: &zeroValue}
 11207  	o.GetMembersAllowedRepositoryCreationType()
 11208  	o = &Organization{}
 11209  	o.GetMembersAllowedRepositoryCreationType()
 11210  	o = nil
 11211  	o.GetMembersAllowedRepositoryCreationType()
 11212  }
 11213  
 11214  func TestOrganization_GetMembersCanCreateInternalRepos(tt *testing.T) {
 11215  	var zeroValue bool
 11216  	o := &Organization{MembersCanCreateInternalRepos: &zeroValue}
 11217  	o.GetMembersCanCreateInternalRepos()
 11218  	o = &Organization{}
 11219  	o.GetMembersCanCreateInternalRepos()
 11220  	o = nil
 11221  	o.GetMembersCanCreateInternalRepos()
 11222  }
 11223  
 11224  func TestOrganization_GetMembersCanCreatePages(tt *testing.T) {
 11225  	var zeroValue bool
 11226  	o := &Organization{MembersCanCreatePages: &zeroValue}
 11227  	o.GetMembersCanCreatePages()
 11228  	o = &Organization{}
 11229  	o.GetMembersCanCreatePages()
 11230  	o = nil
 11231  	o.GetMembersCanCreatePages()
 11232  }
 11233  
 11234  func TestOrganization_GetMembersCanCreatePrivatePages(tt *testing.T) {
 11235  	var zeroValue bool
 11236  	o := &Organization{MembersCanCreatePrivatePages: &zeroValue}
 11237  	o.GetMembersCanCreatePrivatePages()
 11238  	o = &Organization{}
 11239  	o.GetMembersCanCreatePrivatePages()
 11240  	o = nil
 11241  	o.GetMembersCanCreatePrivatePages()
 11242  }
 11243  
 11244  func TestOrganization_GetMembersCanCreatePrivateRepos(tt *testing.T) {
 11245  	var zeroValue bool
 11246  	o := &Organization{MembersCanCreatePrivateRepos: &zeroValue}
 11247  	o.GetMembersCanCreatePrivateRepos()
 11248  	o = &Organization{}
 11249  	o.GetMembersCanCreatePrivateRepos()
 11250  	o = nil
 11251  	o.GetMembersCanCreatePrivateRepos()
 11252  }
 11253  
 11254  func TestOrganization_GetMembersCanCreatePublicPages(tt *testing.T) {
 11255  	var zeroValue bool
 11256  	o := &Organization{MembersCanCreatePublicPages: &zeroValue}
 11257  	o.GetMembersCanCreatePublicPages()
 11258  	o = &Organization{}
 11259  	o.GetMembersCanCreatePublicPages()
 11260  	o = nil
 11261  	o.GetMembersCanCreatePublicPages()
 11262  }
 11263  
 11264  func TestOrganization_GetMembersCanCreatePublicRepos(tt *testing.T) {
 11265  	var zeroValue bool
 11266  	o := &Organization{MembersCanCreatePublicRepos: &zeroValue}
 11267  	o.GetMembersCanCreatePublicRepos()
 11268  	o = &Organization{}
 11269  	o.GetMembersCanCreatePublicRepos()
 11270  	o = nil
 11271  	o.GetMembersCanCreatePublicRepos()
 11272  }
 11273  
 11274  func TestOrganization_GetMembersCanCreateRepos(tt *testing.T) {
 11275  	var zeroValue bool
 11276  	o := &Organization{MembersCanCreateRepos: &zeroValue}
 11277  	o.GetMembersCanCreateRepos()
 11278  	o = &Organization{}
 11279  	o.GetMembersCanCreateRepos()
 11280  	o = nil
 11281  	o.GetMembersCanCreateRepos()
 11282  }
 11283  
 11284  func TestOrganization_GetMembersCanForkPrivateRepos(tt *testing.T) {
 11285  	var zeroValue bool
 11286  	o := &Organization{MembersCanForkPrivateRepos: &zeroValue}
 11287  	o.GetMembersCanForkPrivateRepos()
 11288  	o = &Organization{}
 11289  	o.GetMembersCanForkPrivateRepos()
 11290  	o = nil
 11291  	o.GetMembersCanForkPrivateRepos()
 11292  }
 11293  
 11294  func TestOrganization_GetMembersURL(tt *testing.T) {
 11295  	var zeroValue string
 11296  	o := &Organization{MembersURL: &zeroValue}
 11297  	o.GetMembersURL()
 11298  	o = &Organization{}
 11299  	o.GetMembersURL()
 11300  	o = nil
 11301  	o.GetMembersURL()
 11302  }
 11303  
 11304  func TestOrganization_GetName(tt *testing.T) {
 11305  	var zeroValue string
 11306  	o := &Organization{Name: &zeroValue}
 11307  	o.GetName()
 11308  	o = &Organization{}
 11309  	o.GetName()
 11310  	o = nil
 11311  	o.GetName()
 11312  }
 11313  
 11314  func TestOrganization_GetNodeID(tt *testing.T) {
 11315  	var zeroValue string
 11316  	o := &Organization{NodeID: &zeroValue}
 11317  	o.GetNodeID()
 11318  	o = &Organization{}
 11319  	o.GetNodeID()
 11320  	o = nil
 11321  	o.GetNodeID()
 11322  }
 11323  
 11324  func TestOrganization_GetOwnedPrivateRepos(tt *testing.T) {
 11325  	var zeroValue int
 11326  	o := &Organization{OwnedPrivateRepos: &zeroValue}
 11327  	o.GetOwnedPrivateRepos()
 11328  	o = &Organization{}
 11329  	o.GetOwnedPrivateRepos()
 11330  	o = nil
 11331  	o.GetOwnedPrivateRepos()
 11332  }
 11333  
 11334  func TestOrganization_GetPlan(tt *testing.T) {
 11335  	o := &Organization{}
 11336  	o.GetPlan()
 11337  	o = nil
 11338  	o.GetPlan()
 11339  }
 11340  
 11341  func TestOrganization_GetPrivateGists(tt *testing.T) {
 11342  	var zeroValue int
 11343  	o := &Organization{PrivateGists: &zeroValue}
 11344  	o.GetPrivateGists()
 11345  	o = &Organization{}
 11346  	o.GetPrivateGists()
 11347  	o = nil
 11348  	o.GetPrivateGists()
 11349  }
 11350  
 11351  func TestOrganization_GetPublicGists(tt *testing.T) {
 11352  	var zeroValue int
 11353  	o := &Organization{PublicGists: &zeroValue}
 11354  	o.GetPublicGists()
 11355  	o = &Organization{}
 11356  	o.GetPublicGists()
 11357  	o = nil
 11358  	o.GetPublicGists()
 11359  }
 11360  
 11361  func TestOrganization_GetPublicMembersURL(tt *testing.T) {
 11362  	var zeroValue string
 11363  	o := &Organization{PublicMembersURL: &zeroValue}
 11364  	o.GetPublicMembersURL()
 11365  	o = &Organization{}
 11366  	o.GetPublicMembersURL()
 11367  	o = nil
 11368  	o.GetPublicMembersURL()
 11369  }
 11370  
 11371  func TestOrganization_GetPublicRepos(tt *testing.T) {
 11372  	var zeroValue int
 11373  	o := &Organization{PublicRepos: &zeroValue}
 11374  	o.GetPublicRepos()
 11375  	o = &Organization{}
 11376  	o.GetPublicRepos()
 11377  	o = nil
 11378  	o.GetPublicRepos()
 11379  }
 11380  
 11381  func TestOrganization_GetReposURL(tt *testing.T) {
 11382  	var zeroValue string
 11383  	o := &Organization{ReposURL: &zeroValue}
 11384  	o.GetReposURL()
 11385  	o = &Organization{}
 11386  	o.GetReposURL()
 11387  	o = nil
 11388  	o.GetReposURL()
 11389  }
 11390  
 11391  func TestOrganization_GetTotalPrivateRepos(tt *testing.T) {
 11392  	var zeroValue int
 11393  	o := &Organization{TotalPrivateRepos: &zeroValue}
 11394  	o.GetTotalPrivateRepos()
 11395  	o = &Organization{}
 11396  	o.GetTotalPrivateRepos()
 11397  	o = nil
 11398  	o.GetTotalPrivateRepos()
 11399  }
 11400  
 11401  func TestOrganization_GetTwitterUsername(tt *testing.T) {
 11402  	var zeroValue string
 11403  	o := &Organization{TwitterUsername: &zeroValue}
 11404  	o.GetTwitterUsername()
 11405  	o = &Organization{}
 11406  	o.GetTwitterUsername()
 11407  	o = nil
 11408  	o.GetTwitterUsername()
 11409  }
 11410  
 11411  func TestOrganization_GetTwoFactorRequirementEnabled(tt *testing.T) {
 11412  	var zeroValue bool
 11413  	o := &Organization{TwoFactorRequirementEnabled: &zeroValue}
 11414  	o.GetTwoFactorRequirementEnabled()
 11415  	o = &Organization{}
 11416  	o.GetTwoFactorRequirementEnabled()
 11417  	o = nil
 11418  	o.GetTwoFactorRequirementEnabled()
 11419  }
 11420  
 11421  func TestOrganization_GetType(tt *testing.T) {
 11422  	var zeroValue string
 11423  	o := &Organization{Type: &zeroValue}
 11424  	o.GetType()
 11425  	o = &Organization{}
 11426  	o.GetType()
 11427  	o = nil
 11428  	o.GetType()
 11429  }
 11430  
 11431  func TestOrganization_GetUpdatedAt(tt *testing.T) {
 11432  	var zeroValue time.Time
 11433  	o := &Organization{UpdatedAt: &zeroValue}
 11434  	o.GetUpdatedAt()
 11435  	o = &Organization{}
 11436  	o.GetUpdatedAt()
 11437  	o = nil
 11438  	o.GetUpdatedAt()
 11439  }
 11440  
 11441  func TestOrganization_GetURL(tt *testing.T) {
 11442  	var zeroValue string
 11443  	o := &Organization{URL: &zeroValue}
 11444  	o.GetURL()
 11445  	o = &Organization{}
 11446  	o.GetURL()
 11447  	o = nil
 11448  	o.GetURL()
 11449  }
 11450  
 11451  func TestOrganizationCustomRepoRoles_GetTotalCount(tt *testing.T) {
 11452  	var zeroValue int
 11453  	o := &OrganizationCustomRepoRoles{TotalCount: &zeroValue}
 11454  	o.GetTotalCount()
 11455  	o = &OrganizationCustomRepoRoles{}
 11456  	o.GetTotalCount()
 11457  	o = nil
 11458  	o.GetTotalCount()
 11459  }
 11460  
 11461  func TestOrganizationEvent_GetAction(tt *testing.T) {
 11462  	var zeroValue string
 11463  	o := &OrganizationEvent{Action: &zeroValue}
 11464  	o.GetAction()
 11465  	o = &OrganizationEvent{}
 11466  	o.GetAction()
 11467  	o = nil
 11468  	o.GetAction()
 11469  }
 11470  
 11471  func TestOrganizationEvent_GetInstallation(tt *testing.T) {
 11472  	o := &OrganizationEvent{}
 11473  	o.GetInstallation()
 11474  	o = nil
 11475  	o.GetInstallation()
 11476  }
 11477  
 11478  func TestOrganizationEvent_GetInvitation(tt *testing.T) {
 11479  	o := &OrganizationEvent{}
 11480  	o.GetInvitation()
 11481  	o = nil
 11482  	o.GetInvitation()
 11483  }
 11484  
 11485  func TestOrganizationEvent_GetMembership(tt *testing.T) {
 11486  	o := &OrganizationEvent{}
 11487  	o.GetMembership()
 11488  	o = nil
 11489  	o.GetMembership()
 11490  }
 11491  
 11492  func TestOrganizationEvent_GetOrganization(tt *testing.T) {
 11493  	o := &OrganizationEvent{}
 11494  	o.GetOrganization()
 11495  	o = nil
 11496  	o.GetOrganization()
 11497  }
 11498  
 11499  func TestOrganizationEvent_GetSender(tt *testing.T) {
 11500  	o := &OrganizationEvent{}
 11501  	o.GetSender()
 11502  	o = nil
 11503  	o.GetSender()
 11504  }
 11505  
 11506  func TestOrganizationInstallations_GetTotalCount(tt *testing.T) {
 11507  	var zeroValue int
 11508  	o := &OrganizationInstallations{TotalCount: &zeroValue}
 11509  	o.GetTotalCount()
 11510  	o = &OrganizationInstallations{}
 11511  	o.GetTotalCount()
 11512  	o = nil
 11513  	o.GetTotalCount()
 11514  }
 11515  
 11516  func TestOrgBlockEvent_GetAction(tt *testing.T) {
 11517  	var zeroValue string
 11518  	o := &OrgBlockEvent{Action: &zeroValue}
 11519  	o.GetAction()
 11520  	o = &OrgBlockEvent{}
 11521  	o.GetAction()
 11522  	o = nil
 11523  	o.GetAction()
 11524  }
 11525  
 11526  func TestOrgBlockEvent_GetBlockedUser(tt *testing.T) {
 11527  	o := &OrgBlockEvent{}
 11528  	o.GetBlockedUser()
 11529  	o = nil
 11530  	o.GetBlockedUser()
 11531  }
 11532  
 11533  func TestOrgBlockEvent_GetInstallation(tt *testing.T) {
 11534  	o := &OrgBlockEvent{}
 11535  	o.GetInstallation()
 11536  	o = nil
 11537  	o.GetInstallation()
 11538  }
 11539  
 11540  func TestOrgBlockEvent_GetOrganization(tt *testing.T) {
 11541  	o := &OrgBlockEvent{}
 11542  	o.GetOrganization()
 11543  	o = nil
 11544  	o.GetOrganization()
 11545  }
 11546  
 11547  func TestOrgBlockEvent_GetSender(tt *testing.T) {
 11548  	o := &OrgBlockEvent{}
 11549  	o.GetSender()
 11550  	o = nil
 11551  	o.GetSender()
 11552  }
 11553  
 11554  func TestOrgStats_GetDisabledOrgs(tt *testing.T) {
 11555  	var zeroValue int
 11556  	o := &OrgStats{DisabledOrgs: &zeroValue}
 11557  	o.GetDisabledOrgs()
 11558  	o = &OrgStats{}
 11559  	o.GetDisabledOrgs()
 11560  	o = nil
 11561  	o.GetDisabledOrgs()
 11562  }
 11563  
 11564  func TestOrgStats_GetTotalOrgs(tt *testing.T) {
 11565  	var zeroValue int
 11566  	o := &OrgStats{TotalOrgs: &zeroValue}
 11567  	o.GetTotalOrgs()
 11568  	o = &OrgStats{}
 11569  	o.GetTotalOrgs()
 11570  	o = nil
 11571  	o.GetTotalOrgs()
 11572  }
 11573  
 11574  func TestOrgStats_GetTotalTeamMembers(tt *testing.T) {
 11575  	var zeroValue int
 11576  	o := &OrgStats{TotalTeamMembers: &zeroValue}
 11577  	o.GetTotalTeamMembers()
 11578  	o = &OrgStats{}
 11579  	o.GetTotalTeamMembers()
 11580  	o = nil
 11581  	o.GetTotalTeamMembers()
 11582  }
 11583  
 11584  func TestOrgStats_GetTotalTeams(tt *testing.T) {
 11585  	var zeroValue int
 11586  	o := &OrgStats{TotalTeams: &zeroValue}
 11587  	o.GetTotalTeams()
 11588  	o = &OrgStats{}
 11589  	o.GetTotalTeams()
 11590  	o = nil
 11591  	o.GetTotalTeams()
 11592  }
 11593  
 11594  func TestPackage_GetCreatedAt(tt *testing.T) {
 11595  	var zeroValue Timestamp
 11596  	p := &Package{CreatedAt: &zeroValue}
 11597  	p.GetCreatedAt()
 11598  	p = &Package{}
 11599  	p.GetCreatedAt()
 11600  	p = nil
 11601  	p.GetCreatedAt()
 11602  }
 11603  
 11604  func TestPackage_GetHTMLURL(tt *testing.T) {
 11605  	var zeroValue string
 11606  	p := &Package{HTMLURL: &zeroValue}
 11607  	p.GetHTMLURL()
 11608  	p = &Package{}
 11609  	p.GetHTMLURL()
 11610  	p = nil
 11611  	p.GetHTMLURL()
 11612  }
 11613  
 11614  func TestPackage_GetID(tt *testing.T) {
 11615  	var zeroValue int64
 11616  	p := &Package{ID: &zeroValue}
 11617  	p.GetID()
 11618  	p = &Package{}
 11619  	p.GetID()
 11620  	p = nil
 11621  	p.GetID()
 11622  }
 11623  
 11624  func TestPackage_GetName(tt *testing.T) {
 11625  	var zeroValue string
 11626  	p := &Package{Name: &zeroValue}
 11627  	p.GetName()
 11628  	p = &Package{}
 11629  	p.GetName()
 11630  	p = nil
 11631  	p.GetName()
 11632  }
 11633  
 11634  func TestPackage_GetOwner(tt *testing.T) {
 11635  	p := &Package{}
 11636  	p.GetOwner()
 11637  	p = nil
 11638  	p.GetOwner()
 11639  }
 11640  
 11641  func TestPackage_GetPackageType(tt *testing.T) {
 11642  	var zeroValue string
 11643  	p := &Package{PackageType: &zeroValue}
 11644  	p.GetPackageType()
 11645  	p = &Package{}
 11646  	p.GetPackageType()
 11647  	p = nil
 11648  	p.GetPackageType()
 11649  }
 11650  
 11651  func TestPackage_GetPackageVersion(tt *testing.T) {
 11652  	p := &Package{}
 11653  	p.GetPackageVersion()
 11654  	p = nil
 11655  	p.GetPackageVersion()
 11656  }
 11657  
 11658  func TestPackage_GetRegistry(tt *testing.T) {
 11659  	p := &Package{}
 11660  	p.GetRegistry()
 11661  	p = nil
 11662  	p.GetRegistry()
 11663  }
 11664  
 11665  func TestPackage_GetRepository(tt *testing.T) {
 11666  	p := &Package{}
 11667  	p.GetRepository()
 11668  	p = nil
 11669  	p.GetRepository()
 11670  }
 11671  
 11672  func TestPackage_GetUpdatedAt(tt *testing.T) {
 11673  	var zeroValue Timestamp
 11674  	p := &Package{UpdatedAt: &zeroValue}
 11675  	p.GetUpdatedAt()
 11676  	p = &Package{}
 11677  	p.GetUpdatedAt()
 11678  	p = nil
 11679  	p.GetUpdatedAt()
 11680  }
 11681  
 11682  func TestPackage_GetURL(tt *testing.T) {
 11683  	var zeroValue string
 11684  	p := &Package{URL: &zeroValue}
 11685  	p.GetURL()
 11686  	p = &Package{}
 11687  	p.GetURL()
 11688  	p = nil
 11689  	p.GetURL()
 11690  }
 11691  
 11692  func TestPackage_GetVersionCount(tt *testing.T) {
 11693  	var zeroValue int64
 11694  	p := &Package{VersionCount: &zeroValue}
 11695  	p.GetVersionCount()
 11696  	p = &Package{}
 11697  	p.GetVersionCount()
 11698  	p = nil
 11699  	p.GetVersionCount()
 11700  }
 11701  
 11702  func TestPackage_GetVisibility(tt *testing.T) {
 11703  	var zeroValue string
 11704  	p := &Package{Visibility: &zeroValue}
 11705  	p.GetVisibility()
 11706  	p = &Package{}
 11707  	p.GetVisibility()
 11708  	p = nil
 11709  	p.GetVisibility()
 11710  }
 11711  
 11712  func TestPackageEvent_GetAction(tt *testing.T) {
 11713  	var zeroValue string
 11714  	p := &PackageEvent{Action: &zeroValue}
 11715  	p.GetAction()
 11716  	p = &PackageEvent{}
 11717  	p.GetAction()
 11718  	p = nil
 11719  	p.GetAction()
 11720  }
 11721  
 11722  func TestPackageEvent_GetInstallation(tt *testing.T) {
 11723  	p := &PackageEvent{}
 11724  	p.GetInstallation()
 11725  	p = nil
 11726  	p.GetInstallation()
 11727  }
 11728  
 11729  func TestPackageEvent_GetOrg(tt *testing.T) {
 11730  	p := &PackageEvent{}
 11731  	p.GetOrg()
 11732  	p = nil
 11733  	p.GetOrg()
 11734  }
 11735  
 11736  func TestPackageEvent_GetPackage(tt *testing.T) {
 11737  	p := &PackageEvent{}
 11738  	p.GetPackage()
 11739  	p = nil
 11740  	p.GetPackage()
 11741  }
 11742  
 11743  func TestPackageEvent_GetRepo(tt *testing.T) {
 11744  	p := &PackageEvent{}
 11745  	p.GetRepo()
 11746  	p = nil
 11747  	p.GetRepo()
 11748  }
 11749  
 11750  func TestPackageEvent_GetSender(tt *testing.T) {
 11751  	p := &PackageEvent{}
 11752  	p.GetSender()
 11753  	p = nil
 11754  	p.GetSender()
 11755  }
 11756  
 11757  func TestPackageFile_GetAuthor(tt *testing.T) {
 11758  	p := &PackageFile{}
 11759  	p.GetAuthor()
 11760  	p = nil
 11761  	p.GetAuthor()
 11762  }
 11763  
 11764  func TestPackageFile_GetContentType(tt *testing.T) {
 11765  	var zeroValue string
 11766  	p := &PackageFile{ContentType: &zeroValue}
 11767  	p.GetContentType()
 11768  	p = &PackageFile{}
 11769  	p.GetContentType()
 11770  	p = nil
 11771  	p.GetContentType()
 11772  }
 11773  
 11774  func TestPackageFile_GetCreatedAt(tt *testing.T) {
 11775  	var zeroValue Timestamp
 11776  	p := &PackageFile{CreatedAt: &zeroValue}
 11777  	p.GetCreatedAt()
 11778  	p = &PackageFile{}
 11779  	p.GetCreatedAt()
 11780  	p = nil
 11781  	p.GetCreatedAt()
 11782  }
 11783  
 11784  func TestPackageFile_GetDownloadURL(tt *testing.T) {
 11785  	var zeroValue string
 11786  	p := &PackageFile{DownloadURL: &zeroValue}
 11787  	p.GetDownloadURL()
 11788  	p = &PackageFile{}
 11789  	p.GetDownloadURL()
 11790  	p = nil
 11791  	p.GetDownloadURL()
 11792  }
 11793  
 11794  func TestPackageFile_GetID(tt *testing.T) {
 11795  	var zeroValue int64
 11796  	p := &PackageFile{ID: &zeroValue}
 11797  	p.GetID()
 11798  	p = &PackageFile{}
 11799  	p.GetID()
 11800  	p = nil
 11801  	p.GetID()
 11802  }
 11803  
 11804  func TestPackageFile_GetMD5(tt *testing.T) {
 11805  	var zeroValue string
 11806  	p := &PackageFile{MD5: &zeroValue}
 11807  	p.GetMD5()
 11808  	p = &PackageFile{}
 11809  	p.GetMD5()
 11810  	p = nil
 11811  	p.GetMD5()
 11812  }
 11813  
 11814  func TestPackageFile_GetName(tt *testing.T) {
 11815  	var zeroValue string
 11816  	p := &PackageFile{Name: &zeroValue}
 11817  	p.GetName()
 11818  	p = &PackageFile{}
 11819  	p.GetName()
 11820  	p = nil
 11821  	p.GetName()
 11822  }
 11823  
 11824  func TestPackageFile_GetSHA1(tt *testing.T) {
 11825  	var zeroValue string
 11826  	p := &PackageFile{SHA1: &zeroValue}
 11827  	p.GetSHA1()
 11828  	p = &PackageFile{}
 11829  	p.GetSHA1()
 11830  	p = nil
 11831  	p.GetSHA1()
 11832  }
 11833  
 11834  func TestPackageFile_GetSHA256(tt *testing.T) {
 11835  	var zeroValue string
 11836  	p := &PackageFile{SHA256: &zeroValue}
 11837  	p.GetSHA256()
 11838  	p = &PackageFile{}
 11839  	p.GetSHA256()
 11840  	p = nil
 11841  	p.GetSHA256()
 11842  }
 11843  
 11844  func TestPackageFile_GetSize(tt *testing.T) {
 11845  	var zeroValue int64
 11846  	p := &PackageFile{Size: &zeroValue}
 11847  	p.GetSize()
 11848  	p = &PackageFile{}
 11849  	p.GetSize()
 11850  	p = nil
 11851  	p.GetSize()
 11852  }
 11853  
 11854  func TestPackageFile_GetState(tt *testing.T) {
 11855  	var zeroValue string
 11856  	p := &PackageFile{State: &zeroValue}
 11857  	p.GetState()
 11858  	p = &PackageFile{}
 11859  	p.GetState()
 11860  	p = nil
 11861  	p.GetState()
 11862  }
 11863  
 11864  func TestPackageFile_GetUpdatedAt(tt *testing.T) {
 11865  	var zeroValue Timestamp
 11866  	p := &PackageFile{UpdatedAt: &zeroValue}
 11867  	p.GetUpdatedAt()
 11868  	p = &PackageFile{}
 11869  	p.GetUpdatedAt()
 11870  	p = nil
 11871  	p.GetUpdatedAt()
 11872  }
 11873  
 11874  func TestPackageListOptions_GetPackageType(tt *testing.T) {
 11875  	var zeroValue string
 11876  	p := &PackageListOptions{PackageType: &zeroValue}
 11877  	p.GetPackageType()
 11878  	p = &PackageListOptions{}
 11879  	p.GetPackageType()
 11880  	p = nil
 11881  	p.GetPackageType()
 11882  }
 11883  
 11884  func TestPackageListOptions_GetState(tt *testing.T) {
 11885  	var zeroValue string
 11886  	p := &PackageListOptions{State: &zeroValue}
 11887  	p.GetState()
 11888  	p = &PackageListOptions{}
 11889  	p.GetState()
 11890  	p = nil
 11891  	p.GetState()
 11892  }
 11893  
 11894  func TestPackageListOptions_GetVisibility(tt *testing.T) {
 11895  	var zeroValue string
 11896  	p := &PackageListOptions{Visibility: &zeroValue}
 11897  	p.GetVisibility()
 11898  	p = &PackageListOptions{}
 11899  	p.GetVisibility()
 11900  	p = nil
 11901  	p.GetVisibility()
 11902  }
 11903  
 11904  func TestPackageMetadata_GetContainer(tt *testing.T) {
 11905  	p := &PackageMetadata{}
 11906  	p.GetContainer()
 11907  	p = nil
 11908  	p.GetContainer()
 11909  }
 11910  
 11911  func TestPackageMetadata_GetPackageType(tt *testing.T) {
 11912  	var zeroValue string
 11913  	p := &PackageMetadata{PackageType: &zeroValue}
 11914  	p.GetPackageType()
 11915  	p = &PackageMetadata{}
 11916  	p.GetPackageType()
 11917  	p = nil
 11918  	p.GetPackageType()
 11919  }
 11920  
 11921  func TestPackageRegistry_GetAboutURL(tt *testing.T) {
 11922  	var zeroValue string
 11923  	p := &PackageRegistry{AboutURL: &zeroValue}
 11924  	p.GetAboutURL()
 11925  	p = &PackageRegistry{}
 11926  	p.GetAboutURL()
 11927  	p = nil
 11928  	p.GetAboutURL()
 11929  }
 11930  
 11931  func TestPackageRegistry_GetName(tt *testing.T) {
 11932  	var zeroValue string
 11933  	p := &PackageRegistry{Name: &zeroValue}
 11934  	p.GetName()
 11935  	p = &PackageRegistry{}
 11936  	p.GetName()
 11937  	p = nil
 11938  	p.GetName()
 11939  }
 11940  
 11941  func TestPackageRegistry_GetType(tt *testing.T) {
 11942  	var zeroValue string
 11943  	p := &PackageRegistry{Type: &zeroValue}
 11944  	p.GetType()
 11945  	p = &PackageRegistry{}
 11946  	p.GetType()
 11947  	p = nil
 11948  	p.GetType()
 11949  }
 11950  
 11951  func TestPackageRegistry_GetURL(tt *testing.T) {
 11952  	var zeroValue string
 11953  	p := &PackageRegistry{URL: &zeroValue}
 11954  	p.GetURL()
 11955  	p = &PackageRegistry{}
 11956  	p.GetURL()
 11957  	p = nil
 11958  	p.GetURL()
 11959  }
 11960  
 11961  func TestPackageRegistry_GetVendor(tt *testing.T) {
 11962  	var zeroValue string
 11963  	p := &PackageRegistry{Vendor: &zeroValue}
 11964  	p.GetVendor()
 11965  	p = &PackageRegistry{}
 11966  	p.GetVendor()
 11967  	p = nil
 11968  	p.GetVendor()
 11969  }
 11970  
 11971  func TestPackageRelease_GetAuthor(tt *testing.T) {
 11972  	p := &PackageRelease{}
 11973  	p.GetAuthor()
 11974  	p = nil
 11975  	p.GetAuthor()
 11976  }
 11977  
 11978  func TestPackageRelease_GetCreatedAt(tt *testing.T) {
 11979  	var zeroValue Timestamp
 11980  	p := &PackageRelease{CreatedAt: &zeroValue}
 11981  	p.GetCreatedAt()
 11982  	p = &PackageRelease{}
 11983  	p.GetCreatedAt()
 11984  	p = nil
 11985  	p.GetCreatedAt()
 11986  }
 11987  
 11988  func TestPackageRelease_GetDraft(tt *testing.T) {
 11989  	var zeroValue bool
 11990  	p := &PackageRelease{Draft: &zeroValue}
 11991  	p.GetDraft()
 11992  	p = &PackageRelease{}
 11993  	p.GetDraft()
 11994  	p = nil
 11995  	p.GetDraft()
 11996  }
 11997  
 11998  func TestPackageRelease_GetHTMLURL(tt *testing.T) {
 11999  	var zeroValue string
 12000  	p := &PackageRelease{HTMLURL: &zeroValue}
 12001  	p.GetHTMLURL()
 12002  	p = &PackageRelease{}
 12003  	p.GetHTMLURL()
 12004  	p = nil
 12005  	p.GetHTMLURL()
 12006  }
 12007  
 12008  func TestPackageRelease_GetID(tt *testing.T) {
 12009  	var zeroValue int64
 12010  	p := &PackageRelease{ID: &zeroValue}
 12011  	p.GetID()
 12012  	p = &PackageRelease{}
 12013  	p.GetID()
 12014  	p = nil
 12015  	p.GetID()
 12016  }
 12017  
 12018  func TestPackageRelease_GetName(tt *testing.T) {
 12019  	var zeroValue string
 12020  	p := &PackageRelease{Name: &zeroValue}
 12021  	p.GetName()
 12022  	p = &PackageRelease{}
 12023  	p.GetName()
 12024  	p = nil
 12025  	p.GetName()
 12026  }
 12027  
 12028  func TestPackageRelease_GetPrerelease(tt *testing.T) {
 12029  	var zeroValue bool
 12030  	p := &PackageRelease{Prerelease: &zeroValue}
 12031  	p.GetPrerelease()
 12032  	p = &PackageRelease{}
 12033  	p.GetPrerelease()
 12034  	p = nil
 12035  	p.GetPrerelease()
 12036  }
 12037  
 12038  func TestPackageRelease_GetPublishedAt(tt *testing.T) {
 12039  	var zeroValue Timestamp
 12040  	p := &PackageRelease{PublishedAt: &zeroValue}
 12041  	p.GetPublishedAt()
 12042  	p = &PackageRelease{}
 12043  	p.GetPublishedAt()
 12044  	p = nil
 12045  	p.GetPublishedAt()
 12046  }
 12047  
 12048  func TestPackageRelease_GetTagName(tt *testing.T) {
 12049  	var zeroValue string
 12050  	p := &PackageRelease{TagName: &zeroValue}
 12051  	p.GetTagName()
 12052  	p = &PackageRelease{}
 12053  	p.GetTagName()
 12054  	p = nil
 12055  	p.GetTagName()
 12056  }
 12057  
 12058  func TestPackageRelease_GetTargetCommitish(tt *testing.T) {
 12059  	var zeroValue string
 12060  	p := &PackageRelease{TargetCommitish: &zeroValue}
 12061  	p.GetTargetCommitish()
 12062  	p = &PackageRelease{}
 12063  	p.GetTargetCommitish()
 12064  	p = nil
 12065  	p.GetTargetCommitish()
 12066  }
 12067  
 12068  func TestPackageRelease_GetURL(tt *testing.T) {
 12069  	var zeroValue string
 12070  	p := &PackageRelease{URL: &zeroValue}
 12071  	p.GetURL()
 12072  	p = &PackageRelease{}
 12073  	p.GetURL()
 12074  	p = nil
 12075  	p.GetURL()
 12076  }
 12077  
 12078  func TestPackageVersion_GetAuthor(tt *testing.T) {
 12079  	p := &PackageVersion{}
 12080  	p.GetAuthor()
 12081  	p = nil
 12082  	p.GetAuthor()
 12083  }
 12084  
 12085  func TestPackageVersion_GetBody(tt *testing.T) {
 12086  	var zeroValue string
 12087  	p := &PackageVersion{Body: &zeroValue}
 12088  	p.GetBody()
 12089  	p = &PackageVersion{}
 12090  	p.GetBody()
 12091  	p = nil
 12092  	p.GetBody()
 12093  }
 12094  
 12095  func TestPackageVersion_GetBodyHTML(tt *testing.T) {
 12096  	var zeroValue string
 12097  	p := &PackageVersion{BodyHTML: &zeroValue}
 12098  	p.GetBodyHTML()
 12099  	p = &PackageVersion{}
 12100  	p.GetBodyHTML()
 12101  	p = nil
 12102  	p.GetBodyHTML()
 12103  }
 12104  
 12105  func TestPackageVersion_GetCreatedAt(tt *testing.T) {
 12106  	var zeroValue Timestamp
 12107  	p := &PackageVersion{CreatedAt: &zeroValue}
 12108  	p.GetCreatedAt()
 12109  	p = &PackageVersion{}
 12110  	p.GetCreatedAt()
 12111  	p = nil
 12112  	p.GetCreatedAt()
 12113  }
 12114  
 12115  func TestPackageVersion_GetDraft(tt *testing.T) {
 12116  	var zeroValue bool
 12117  	p := &PackageVersion{Draft: &zeroValue}
 12118  	p.GetDraft()
 12119  	p = &PackageVersion{}
 12120  	p.GetDraft()
 12121  	p = nil
 12122  	p.GetDraft()
 12123  }
 12124  
 12125  func TestPackageVersion_GetHTMLURL(tt *testing.T) {
 12126  	var zeroValue string
 12127  	p := &PackageVersion{HTMLURL: &zeroValue}
 12128  	p.GetHTMLURL()
 12129  	p = &PackageVersion{}
 12130  	p.GetHTMLURL()
 12131  	p = nil
 12132  	p.GetHTMLURL()
 12133  }
 12134  
 12135  func TestPackageVersion_GetID(tt *testing.T) {
 12136  	var zeroValue int64
 12137  	p := &PackageVersion{ID: &zeroValue}
 12138  	p.GetID()
 12139  	p = &PackageVersion{}
 12140  	p.GetID()
 12141  	p = nil
 12142  	p.GetID()
 12143  }
 12144  
 12145  func TestPackageVersion_GetInstallationCommand(tt *testing.T) {
 12146  	var zeroValue string
 12147  	p := &PackageVersion{InstallationCommand: &zeroValue}
 12148  	p.GetInstallationCommand()
 12149  	p = &PackageVersion{}
 12150  	p.GetInstallationCommand()
 12151  	p = nil
 12152  	p.GetInstallationCommand()
 12153  }
 12154  
 12155  func TestPackageVersion_GetManifest(tt *testing.T) {
 12156  	var zeroValue string
 12157  	p := &PackageVersion{Manifest: &zeroValue}
 12158  	p.GetManifest()
 12159  	p = &PackageVersion{}
 12160  	p.GetManifest()
 12161  	p = nil
 12162  	p.GetManifest()
 12163  }
 12164  
 12165  func TestPackageVersion_GetMetadata(tt *testing.T) {
 12166  	p := &PackageVersion{}
 12167  	p.GetMetadata()
 12168  	p = nil
 12169  	p.GetMetadata()
 12170  }
 12171  
 12172  func TestPackageVersion_GetName(tt *testing.T) {
 12173  	var zeroValue string
 12174  	p := &PackageVersion{Name: &zeroValue}
 12175  	p.GetName()
 12176  	p = &PackageVersion{}
 12177  	p.GetName()
 12178  	p = nil
 12179  	p.GetName()
 12180  }
 12181  
 12182  func TestPackageVersion_GetPackageHTMLURL(tt *testing.T) {
 12183  	var zeroValue string
 12184  	p := &PackageVersion{PackageHTMLURL: &zeroValue}
 12185  	p.GetPackageHTMLURL()
 12186  	p = &PackageVersion{}
 12187  	p.GetPackageHTMLURL()
 12188  	p = nil
 12189  	p.GetPackageHTMLURL()
 12190  }
 12191  
 12192  func TestPackageVersion_GetPrerelease(tt *testing.T) {
 12193  	var zeroValue bool
 12194  	p := &PackageVersion{Prerelease: &zeroValue}
 12195  	p.GetPrerelease()
 12196  	p = &PackageVersion{}
 12197  	p.GetPrerelease()
 12198  	p = nil
 12199  	p.GetPrerelease()
 12200  }
 12201  
 12202  func TestPackageVersion_GetRelease(tt *testing.T) {
 12203  	p := &PackageVersion{}
 12204  	p.GetRelease()
 12205  	p = nil
 12206  	p.GetRelease()
 12207  }
 12208  
 12209  func TestPackageVersion_GetSummary(tt *testing.T) {
 12210  	var zeroValue string
 12211  	p := &PackageVersion{Summary: &zeroValue}
 12212  	p.GetSummary()
 12213  	p = &PackageVersion{}
 12214  	p.GetSummary()
 12215  	p = nil
 12216  	p.GetSummary()
 12217  }
 12218  
 12219  func TestPackageVersion_GetTagName(tt *testing.T) {
 12220  	var zeroValue string
 12221  	p := &PackageVersion{TagName: &zeroValue}
 12222  	p.GetTagName()
 12223  	p = &PackageVersion{}
 12224  	p.GetTagName()
 12225  	p = nil
 12226  	p.GetTagName()
 12227  }
 12228  
 12229  func TestPackageVersion_GetTargetCommitish(tt *testing.T) {
 12230  	var zeroValue string
 12231  	p := &PackageVersion{TargetCommitish: &zeroValue}
 12232  	p.GetTargetCommitish()
 12233  	p = &PackageVersion{}
 12234  	p.GetTargetCommitish()
 12235  	p = nil
 12236  	p.GetTargetCommitish()
 12237  }
 12238  
 12239  func TestPackageVersion_GetTargetOID(tt *testing.T) {
 12240  	var zeroValue string
 12241  	p := &PackageVersion{TargetOID: &zeroValue}
 12242  	p.GetTargetOID()
 12243  	p = &PackageVersion{}
 12244  	p.GetTargetOID()
 12245  	p = nil
 12246  	p.GetTargetOID()
 12247  }
 12248  
 12249  func TestPackageVersion_GetUpdatedAt(tt *testing.T) {
 12250  	var zeroValue Timestamp
 12251  	p := &PackageVersion{UpdatedAt: &zeroValue}
 12252  	p.GetUpdatedAt()
 12253  	p = &PackageVersion{}
 12254  	p.GetUpdatedAt()
 12255  	p = nil
 12256  	p.GetUpdatedAt()
 12257  }
 12258  
 12259  func TestPackageVersion_GetURL(tt *testing.T) {
 12260  	var zeroValue string
 12261  	p := &PackageVersion{URL: &zeroValue}
 12262  	p.GetURL()
 12263  	p = &PackageVersion{}
 12264  	p.GetURL()
 12265  	p = nil
 12266  	p.GetURL()
 12267  }
 12268  
 12269  func TestPackageVersion_GetVersion(tt *testing.T) {
 12270  	var zeroValue string
 12271  	p := &PackageVersion{Version: &zeroValue}
 12272  	p.GetVersion()
 12273  	p = &PackageVersion{}
 12274  	p.GetVersion()
 12275  	p = nil
 12276  	p.GetVersion()
 12277  }
 12278  
 12279  func TestPage_GetAction(tt *testing.T) {
 12280  	var zeroValue string
 12281  	p := &Page{Action: &zeroValue}
 12282  	p.GetAction()
 12283  	p = &Page{}
 12284  	p.GetAction()
 12285  	p = nil
 12286  	p.GetAction()
 12287  }
 12288  
 12289  func TestPage_GetHTMLURL(tt *testing.T) {
 12290  	var zeroValue string
 12291  	p := &Page{HTMLURL: &zeroValue}
 12292  	p.GetHTMLURL()
 12293  	p = &Page{}
 12294  	p.GetHTMLURL()
 12295  	p = nil
 12296  	p.GetHTMLURL()
 12297  }
 12298  
 12299  func TestPage_GetPageName(tt *testing.T) {
 12300  	var zeroValue string
 12301  	p := &Page{PageName: &zeroValue}
 12302  	p.GetPageName()
 12303  	p = &Page{}
 12304  	p.GetPageName()
 12305  	p = nil
 12306  	p.GetPageName()
 12307  }
 12308  
 12309  func TestPage_GetSHA(tt *testing.T) {
 12310  	var zeroValue string
 12311  	p := &Page{SHA: &zeroValue}
 12312  	p.GetSHA()
 12313  	p = &Page{}
 12314  	p.GetSHA()
 12315  	p = nil
 12316  	p.GetSHA()
 12317  }
 12318  
 12319  func TestPage_GetSummary(tt *testing.T) {
 12320  	var zeroValue string
 12321  	p := &Page{Summary: &zeroValue}
 12322  	p.GetSummary()
 12323  	p = &Page{}
 12324  	p.GetSummary()
 12325  	p = nil
 12326  	p.GetSummary()
 12327  }
 12328  
 12329  func TestPage_GetTitle(tt *testing.T) {
 12330  	var zeroValue string
 12331  	p := &Page{Title: &zeroValue}
 12332  	p.GetTitle()
 12333  	p = &Page{}
 12334  	p.GetTitle()
 12335  	p = nil
 12336  	p.GetTitle()
 12337  }
 12338  
 12339  func TestPageBuildEvent_GetBuild(tt *testing.T) {
 12340  	p := &PageBuildEvent{}
 12341  	p.GetBuild()
 12342  	p = nil
 12343  	p.GetBuild()
 12344  }
 12345  
 12346  func TestPageBuildEvent_GetID(tt *testing.T) {
 12347  	var zeroValue int64
 12348  	p := &PageBuildEvent{ID: &zeroValue}
 12349  	p.GetID()
 12350  	p = &PageBuildEvent{}
 12351  	p.GetID()
 12352  	p = nil
 12353  	p.GetID()
 12354  }
 12355  
 12356  func TestPageBuildEvent_GetInstallation(tt *testing.T) {
 12357  	p := &PageBuildEvent{}
 12358  	p.GetInstallation()
 12359  	p = nil
 12360  	p.GetInstallation()
 12361  }
 12362  
 12363  func TestPageBuildEvent_GetRepo(tt *testing.T) {
 12364  	p := &PageBuildEvent{}
 12365  	p.GetRepo()
 12366  	p = nil
 12367  	p.GetRepo()
 12368  }
 12369  
 12370  func TestPageBuildEvent_GetSender(tt *testing.T) {
 12371  	p := &PageBuildEvent{}
 12372  	p.GetSender()
 12373  	p = nil
 12374  	p.GetSender()
 12375  }
 12376  
 12377  func TestPages_GetCNAME(tt *testing.T) {
 12378  	var zeroValue string
 12379  	p := &Pages{CNAME: &zeroValue}
 12380  	p.GetCNAME()
 12381  	p = &Pages{}
 12382  	p.GetCNAME()
 12383  	p = nil
 12384  	p.GetCNAME()
 12385  }
 12386  
 12387  func TestPages_GetCustom404(tt *testing.T) {
 12388  	var zeroValue bool
 12389  	p := &Pages{Custom404: &zeroValue}
 12390  	p.GetCustom404()
 12391  	p = &Pages{}
 12392  	p.GetCustom404()
 12393  	p = nil
 12394  	p.GetCustom404()
 12395  }
 12396  
 12397  func TestPages_GetHTMLURL(tt *testing.T) {
 12398  	var zeroValue string
 12399  	p := &Pages{HTMLURL: &zeroValue}
 12400  	p.GetHTMLURL()
 12401  	p = &Pages{}
 12402  	p.GetHTMLURL()
 12403  	p = nil
 12404  	p.GetHTMLURL()
 12405  }
 12406  
 12407  func TestPages_GetHTTPSCertificate(tt *testing.T) {
 12408  	p := &Pages{}
 12409  	p.GetHTTPSCertificate()
 12410  	p = nil
 12411  	p.GetHTTPSCertificate()
 12412  }
 12413  
 12414  func TestPages_GetHTTPSEnforced(tt *testing.T) {
 12415  	var zeroValue bool
 12416  	p := &Pages{HTTPSEnforced: &zeroValue}
 12417  	p.GetHTTPSEnforced()
 12418  	p = &Pages{}
 12419  	p.GetHTTPSEnforced()
 12420  	p = nil
 12421  	p.GetHTTPSEnforced()
 12422  }
 12423  
 12424  func TestPages_GetPublic(tt *testing.T) {
 12425  	var zeroValue bool
 12426  	p := &Pages{Public: &zeroValue}
 12427  	p.GetPublic()
 12428  	p = &Pages{}
 12429  	p.GetPublic()
 12430  	p = nil
 12431  	p.GetPublic()
 12432  }
 12433  
 12434  func TestPages_GetSource(tt *testing.T) {
 12435  	p := &Pages{}
 12436  	p.GetSource()
 12437  	p = nil
 12438  	p.GetSource()
 12439  }
 12440  
 12441  func TestPages_GetStatus(tt *testing.T) {
 12442  	var zeroValue string
 12443  	p := &Pages{Status: &zeroValue}
 12444  	p.GetStatus()
 12445  	p = &Pages{}
 12446  	p.GetStatus()
 12447  	p = nil
 12448  	p.GetStatus()
 12449  }
 12450  
 12451  func TestPages_GetURL(tt *testing.T) {
 12452  	var zeroValue string
 12453  	p := &Pages{URL: &zeroValue}
 12454  	p.GetURL()
 12455  	p = &Pages{}
 12456  	p.GetURL()
 12457  	p = nil
 12458  	p.GetURL()
 12459  }
 12460  
 12461  func TestPagesBuild_GetCommit(tt *testing.T) {
 12462  	var zeroValue string
 12463  	p := &PagesBuild{Commit: &zeroValue}
 12464  	p.GetCommit()
 12465  	p = &PagesBuild{}
 12466  	p.GetCommit()
 12467  	p = nil
 12468  	p.GetCommit()
 12469  }
 12470  
 12471  func TestPagesBuild_GetCreatedAt(tt *testing.T) {
 12472  	var zeroValue Timestamp
 12473  	p := &PagesBuild{CreatedAt: &zeroValue}
 12474  	p.GetCreatedAt()
 12475  	p = &PagesBuild{}
 12476  	p.GetCreatedAt()
 12477  	p = nil
 12478  	p.GetCreatedAt()
 12479  }
 12480  
 12481  func TestPagesBuild_GetDuration(tt *testing.T) {
 12482  	var zeroValue int
 12483  	p := &PagesBuild{Duration: &zeroValue}
 12484  	p.GetDuration()
 12485  	p = &PagesBuild{}
 12486  	p.GetDuration()
 12487  	p = nil
 12488  	p.GetDuration()
 12489  }
 12490  
 12491  func TestPagesBuild_GetError(tt *testing.T) {
 12492  	p := &PagesBuild{}
 12493  	p.GetError()
 12494  	p = nil
 12495  	p.GetError()
 12496  }
 12497  
 12498  func TestPagesBuild_GetPusher(tt *testing.T) {
 12499  	p := &PagesBuild{}
 12500  	p.GetPusher()
 12501  	p = nil
 12502  	p.GetPusher()
 12503  }
 12504  
 12505  func TestPagesBuild_GetStatus(tt *testing.T) {
 12506  	var zeroValue string
 12507  	p := &PagesBuild{Status: &zeroValue}
 12508  	p.GetStatus()
 12509  	p = &PagesBuild{}
 12510  	p.GetStatus()
 12511  	p = nil
 12512  	p.GetStatus()
 12513  }
 12514  
 12515  func TestPagesBuild_GetUpdatedAt(tt *testing.T) {
 12516  	var zeroValue Timestamp
 12517  	p := &PagesBuild{UpdatedAt: &zeroValue}
 12518  	p.GetUpdatedAt()
 12519  	p = &PagesBuild{}
 12520  	p.GetUpdatedAt()
 12521  	p = nil
 12522  	p.GetUpdatedAt()
 12523  }
 12524  
 12525  func TestPagesBuild_GetURL(tt *testing.T) {
 12526  	var zeroValue string
 12527  	p := &PagesBuild{URL: &zeroValue}
 12528  	p.GetURL()
 12529  	p = &PagesBuild{}
 12530  	p.GetURL()
 12531  	p = nil
 12532  	p.GetURL()
 12533  }
 12534  
 12535  func TestPagesError_GetMessage(tt *testing.T) {
 12536  	var zeroValue string
 12537  	p := &PagesError{Message: &zeroValue}
 12538  	p.GetMessage()
 12539  	p = &PagesError{}
 12540  	p.GetMessage()
 12541  	p = nil
 12542  	p.GetMessage()
 12543  }
 12544  
 12545  func TestPagesHTTPSCertificate_GetDescription(tt *testing.T) {
 12546  	var zeroValue string
 12547  	p := &PagesHTTPSCertificate{Description: &zeroValue}
 12548  	p.GetDescription()
 12549  	p = &PagesHTTPSCertificate{}
 12550  	p.GetDescription()
 12551  	p = nil
 12552  	p.GetDescription()
 12553  }
 12554  
 12555  func TestPagesHTTPSCertificate_GetExpiresAt(tt *testing.T) {
 12556  	var zeroValue string
 12557  	p := &PagesHTTPSCertificate{ExpiresAt: &zeroValue}
 12558  	p.GetExpiresAt()
 12559  	p = &PagesHTTPSCertificate{}
 12560  	p.GetExpiresAt()
 12561  	p = nil
 12562  	p.GetExpiresAt()
 12563  }
 12564  
 12565  func TestPagesHTTPSCertificate_GetState(tt *testing.T) {
 12566  	var zeroValue string
 12567  	p := &PagesHTTPSCertificate{State: &zeroValue}
 12568  	p.GetState()
 12569  	p = &PagesHTTPSCertificate{}
 12570  	p.GetState()
 12571  	p = nil
 12572  	p.GetState()
 12573  }
 12574  
 12575  func TestPagesSource_GetBranch(tt *testing.T) {
 12576  	var zeroValue string
 12577  	p := &PagesSource{Branch: &zeroValue}
 12578  	p.GetBranch()
 12579  	p = &PagesSource{}
 12580  	p.GetBranch()
 12581  	p = nil
 12582  	p.GetBranch()
 12583  }
 12584  
 12585  func TestPagesSource_GetPath(tt *testing.T) {
 12586  	var zeroValue string
 12587  	p := &PagesSource{Path: &zeroValue}
 12588  	p.GetPath()
 12589  	p = &PagesSource{}
 12590  	p.GetPath()
 12591  	p = nil
 12592  	p.GetPath()
 12593  }
 12594  
 12595  func TestPageStats_GetTotalPages(tt *testing.T) {
 12596  	var zeroValue int
 12597  	p := &PageStats{TotalPages: &zeroValue}
 12598  	p.GetTotalPages()
 12599  	p = &PageStats{}
 12600  	p.GetTotalPages()
 12601  	p = nil
 12602  	p.GetTotalPages()
 12603  }
 12604  
 12605  func TestPagesUpdate_GetCNAME(tt *testing.T) {
 12606  	var zeroValue string
 12607  	p := &PagesUpdate{CNAME: &zeroValue}
 12608  	p.GetCNAME()
 12609  	p = &PagesUpdate{}
 12610  	p.GetCNAME()
 12611  	p = nil
 12612  	p.GetCNAME()
 12613  }
 12614  
 12615  func TestPagesUpdate_GetHTTPSEnforced(tt *testing.T) {
 12616  	var zeroValue bool
 12617  	p := &PagesUpdate{HTTPSEnforced: &zeroValue}
 12618  	p.GetHTTPSEnforced()
 12619  	p = &PagesUpdate{}
 12620  	p.GetHTTPSEnforced()
 12621  	p = nil
 12622  	p.GetHTTPSEnforced()
 12623  }
 12624  
 12625  func TestPagesUpdate_GetPublic(tt *testing.T) {
 12626  	var zeroValue bool
 12627  	p := &PagesUpdate{Public: &zeroValue}
 12628  	p.GetPublic()
 12629  	p = &PagesUpdate{}
 12630  	p.GetPublic()
 12631  	p = nil
 12632  	p.GetPublic()
 12633  }
 12634  
 12635  func TestPagesUpdate_GetSource(tt *testing.T) {
 12636  	var zeroValue string
 12637  	p := &PagesUpdate{Source: &zeroValue}
 12638  	p.GetSource()
 12639  	p = &PagesUpdate{}
 12640  	p.GetSource()
 12641  	p = nil
 12642  	p.GetSource()
 12643  }
 12644  
 12645  func TestPingEvent_GetHook(tt *testing.T) {
 12646  	p := &PingEvent{}
 12647  	p.GetHook()
 12648  	p = nil
 12649  	p.GetHook()
 12650  }
 12651  
 12652  func TestPingEvent_GetHookID(tt *testing.T) {
 12653  	var zeroValue int64
 12654  	p := &PingEvent{HookID: &zeroValue}
 12655  	p.GetHookID()
 12656  	p = &PingEvent{}
 12657  	p.GetHookID()
 12658  	p = nil
 12659  	p.GetHookID()
 12660  }
 12661  
 12662  func TestPingEvent_GetInstallation(tt *testing.T) {
 12663  	p := &PingEvent{}
 12664  	p.GetInstallation()
 12665  	p = nil
 12666  	p.GetInstallation()
 12667  }
 12668  
 12669  func TestPingEvent_GetOrg(tt *testing.T) {
 12670  	p := &PingEvent{}
 12671  	p.GetOrg()
 12672  	p = nil
 12673  	p.GetOrg()
 12674  }
 12675  
 12676  func TestPingEvent_GetRepo(tt *testing.T) {
 12677  	p := &PingEvent{}
 12678  	p.GetRepo()
 12679  	p = nil
 12680  	p.GetRepo()
 12681  }
 12682  
 12683  func TestPingEvent_GetSender(tt *testing.T) {
 12684  	p := &PingEvent{}
 12685  	p.GetSender()
 12686  	p = nil
 12687  	p.GetSender()
 12688  }
 12689  
 12690  func TestPingEvent_GetZen(tt *testing.T) {
 12691  	var zeroValue string
 12692  	p := &PingEvent{Zen: &zeroValue}
 12693  	p.GetZen()
 12694  	p = &PingEvent{}
 12695  	p.GetZen()
 12696  	p = nil
 12697  	p.GetZen()
 12698  }
 12699  
 12700  func TestPlan_GetCollaborators(tt *testing.T) {
 12701  	var zeroValue int
 12702  	p := &Plan{Collaborators: &zeroValue}
 12703  	p.GetCollaborators()
 12704  	p = &Plan{}
 12705  	p.GetCollaborators()
 12706  	p = nil
 12707  	p.GetCollaborators()
 12708  }
 12709  
 12710  func TestPlan_GetFilledSeats(tt *testing.T) {
 12711  	var zeroValue int
 12712  	p := &Plan{FilledSeats: &zeroValue}
 12713  	p.GetFilledSeats()
 12714  	p = &Plan{}
 12715  	p.GetFilledSeats()
 12716  	p = nil
 12717  	p.GetFilledSeats()
 12718  }
 12719  
 12720  func TestPlan_GetName(tt *testing.T) {
 12721  	var zeroValue string
 12722  	p := &Plan{Name: &zeroValue}
 12723  	p.GetName()
 12724  	p = &Plan{}
 12725  	p.GetName()
 12726  	p = nil
 12727  	p.GetName()
 12728  }
 12729  
 12730  func TestPlan_GetPrivateRepos(tt *testing.T) {
 12731  	var zeroValue int
 12732  	p := &Plan{PrivateRepos: &zeroValue}
 12733  	p.GetPrivateRepos()
 12734  	p = &Plan{}
 12735  	p.GetPrivateRepos()
 12736  	p = nil
 12737  	p.GetPrivateRepos()
 12738  }
 12739  
 12740  func TestPlan_GetSeats(tt *testing.T) {
 12741  	var zeroValue int
 12742  	p := &Plan{Seats: &zeroValue}
 12743  	p.GetSeats()
 12744  	p = &Plan{}
 12745  	p.GetSeats()
 12746  	p = nil
 12747  	p.GetSeats()
 12748  }
 12749  
 12750  func TestPlan_GetSpace(tt *testing.T) {
 12751  	var zeroValue int
 12752  	p := &Plan{Space: &zeroValue}
 12753  	p.GetSpace()
 12754  	p = &Plan{}
 12755  	p.GetSpace()
 12756  	p = nil
 12757  	p.GetSpace()
 12758  }
 12759  
 12760  func TestPreReceiveHook_GetConfigURL(tt *testing.T) {
 12761  	var zeroValue string
 12762  	p := &PreReceiveHook{ConfigURL: &zeroValue}
 12763  	p.GetConfigURL()
 12764  	p = &PreReceiveHook{}
 12765  	p.GetConfigURL()
 12766  	p = nil
 12767  	p.GetConfigURL()
 12768  }
 12769  
 12770  func TestPreReceiveHook_GetEnforcement(tt *testing.T) {
 12771  	var zeroValue string
 12772  	p := &PreReceiveHook{Enforcement: &zeroValue}
 12773  	p.GetEnforcement()
 12774  	p = &PreReceiveHook{}
 12775  	p.GetEnforcement()
 12776  	p = nil
 12777  	p.GetEnforcement()
 12778  }
 12779  
 12780  func TestPreReceiveHook_GetID(tt *testing.T) {
 12781  	var zeroValue int64
 12782  	p := &PreReceiveHook{ID: &zeroValue}
 12783  	p.GetID()
 12784  	p = &PreReceiveHook{}
 12785  	p.GetID()
 12786  	p = nil
 12787  	p.GetID()
 12788  }
 12789  
 12790  func TestPreReceiveHook_GetName(tt *testing.T) {
 12791  	var zeroValue string
 12792  	p := &PreReceiveHook{Name: &zeroValue}
 12793  	p.GetName()
 12794  	p = &PreReceiveHook{}
 12795  	p.GetName()
 12796  	p = nil
 12797  	p.GetName()
 12798  }
 12799  
 12800  func TestPRLink_GetHRef(tt *testing.T) {
 12801  	var zeroValue string
 12802  	p := &PRLink{HRef: &zeroValue}
 12803  	p.GetHRef()
 12804  	p = &PRLink{}
 12805  	p.GetHRef()
 12806  	p = nil
 12807  	p.GetHRef()
 12808  }
 12809  
 12810  func TestPRLinks_GetComments(tt *testing.T) {
 12811  	p := &PRLinks{}
 12812  	p.GetComments()
 12813  	p = nil
 12814  	p.GetComments()
 12815  }
 12816  
 12817  func TestPRLinks_GetCommits(tt *testing.T) {
 12818  	p := &PRLinks{}
 12819  	p.GetCommits()
 12820  	p = nil
 12821  	p.GetCommits()
 12822  }
 12823  
 12824  func TestPRLinks_GetHTML(tt *testing.T) {
 12825  	p := &PRLinks{}
 12826  	p.GetHTML()
 12827  	p = nil
 12828  	p.GetHTML()
 12829  }
 12830  
 12831  func TestPRLinks_GetIssue(tt *testing.T) {
 12832  	p := &PRLinks{}
 12833  	p.GetIssue()
 12834  	p = nil
 12835  	p.GetIssue()
 12836  }
 12837  
 12838  func TestPRLinks_GetReviewComment(tt *testing.T) {
 12839  	p := &PRLinks{}
 12840  	p.GetReviewComment()
 12841  	p = nil
 12842  	p.GetReviewComment()
 12843  }
 12844  
 12845  func TestPRLinks_GetReviewComments(tt *testing.T) {
 12846  	p := &PRLinks{}
 12847  	p.GetReviewComments()
 12848  	p = nil
 12849  	p.GetReviewComments()
 12850  }
 12851  
 12852  func TestPRLinks_GetSelf(tt *testing.T) {
 12853  	p := &PRLinks{}
 12854  	p.GetSelf()
 12855  	p = nil
 12856  	p.GetSelf()
 12857  }
 12858  
 12859  func TestPRLinks_GetStatuses(tt *testing.T) {
 12860  	p := &PRLinks{}
 12861  	p.GetStatuses()
 12862  	p = nil
 12863  	p.GetStatuses()
 12864  }
 12865  
 12866  func TestProject_GetBody(tt *testing.T) {
 12867  	var zeroValue string
 12868  	p := &Project{Body: &zeroValue}
 12869  	p.GetBody()
 12870  	p = &Project{}
 12871  	p.GetBody()
 12872  	p = nil
 12873  	p.GetBody()
 12874  }
 12875  
 12876  func TestProject_GetColumnsURL(tt *testing.T) {
 12877  	var zeroValue string
 12878  	p := &Project{ColumnsURL: &zeroValue}
 12879  	p.GetColumnsURL()
 12880  	p = &Project{}
 12881  	p.GetColumnsURL()
 12882  	p = nil
 12883  	p.GetColumnsURL()
 12884  }
 12885  
 12886  func TestProject_GetCreatedAt(tt *testing.T) {
 12887  	var zeroValue Timestamp
 12888  	p := &Project{CreatedAt: &zeroValue}
 12889  	p.GetCreatedAt()
 12890  	p = &Project{}
 12891  	p.GetCreatedAt()
 12892  	p = nil
 12893  	p.GetCreatedAt()
 12894  }
 12895  
 12896  func TestProject_GetCreator(tt *testing.T) {
 12897  	p := &Project{}
 12898  	p.GetCreator()
 12899  	p = nil
 12900  	p.GetCreator()
 12901  }
 12902  
 12903  func TestProject_GetHTMLURL(tt *testing.T) {
 12904  	var zeroValue string
 12905  	p := &Project{HTMLURL: &zeroValue}
 12906  	p.GetHTMLURL()
 12907  	p = &Project{}
 12908  	p.GetHTMLURL()
 12909  	p = nil
 12910  	p.GetHTMLURL()
 12911  }
 12912  
 12913  func TestProject_GetID(tt *testing.T) {
 12914  	var zeroValue int64
 12915  	p := &Project{ID: &zeroValue}
 12916  	p.GetID()
 12917  	p = &Project{}
 12918  	p.GetID()
 12919  	p = nil
 12920  	p.GetID()
 12921  }
 12922  
 12923  func TestProject_GetName(tt *testing.T) {
 12924  	var zeroValue string
 12925  	p := &Project{Name: &zeroValue}
 12926  	p.GetName()
 12927  	p = &Project{}
 12928  	p.GetName()
 12929  	p = nil
 12930  	p.GetName()
 12931  }
 12932  
 12933  func TestProject_GetNodeID(tt *testing.T) {
 12934  	var zeroValue string
 12935  	p := &Project{NodeID: &zeroValue}
 12936  	p.GetNodeID()
 12937  	p = &Project{}
 12938  	p.GetNodeID()
 12939  	p = nil
 12940  	p.GetNodeID()
 12941  }
 12942  
 12943  func TestProject_GetNumber(tt *testing.T) {
 12944  	var zeroValue int
 12945  	p := &Project{Number: &zeroValue}
 12946  	p.GetNumber()
 12947  	p = &Project{}
 12948  	p.GetNumber()
 12949  	p = nil
 12950  	p.GetNumber()
 12951  }
 12952  
 12953  func TestProject_GetOrganizationPermission(tt *testing.T) {
 12954  	var zeroValue string
 12955  	p := &Project{OrganizationPermission: &zeroValue}
 12956  	p.GetOrganizationPermission()
 12957  	p = &Project{}
 12958  	p.GetOrganizationPermission()
 12959  	p = nil
 12960  	p.GetOrganizationPermission()
 12961  }
 12962  
 12963  func TestProject_GetOwnerURL(tt *testing.T) {
 12964  	var zeroValue string
 12965  	p := &Project{OwnerURL: &zeroValue}
 12966  	p.GetOwnerURL()
 12967  	p = &Project{}
 12968  	p.GetOwnerURL()
 12969  	p = nil
 12970  	p.GetOwnerURL()
 12971  }
 12972  
 12973  func TestProject_GetPrivate(tt *testing.T) {
 12974  	var zeroValue bool
 12975  	p := &Project{Private: &zeroValue}
 12976  	p.GetPrivate()
 12977  	p = &Project{}
 12978  	p.GetPrivate()
 12979  	p = nil
 12980  	p.GetPrivate()
 12981  }
 12982  
 12983  func TestProject_GetState(tt *testing.T) {
 12984  	var zeroValue string
 12985  	p := &Project{State: &zeroValue}
 12986  	p.GetState()
 12987  	p = &Project{}
 12988  	p.GetState()
 12989  	p = nil
 12990  	p.GetState()
 12991  }
 12992  
 12993  func TestProject_GetUpdatedAt(tt *testing.T) {
 12994  	var zeroValue Timestamp
 12995  	p := &Project{UpdatedAt: &zeroValue}
 12996  	p.GetUpdatedAt()
 12997  	p = &Project{}
 12998  	p.GetUpdatedAt()
 12999  	p = nil
 13000  	p.GetUpdatedAt()
 13001  }
 13002  
 13003  func TestProject_GetURL(tt *testing.T) {
 13004  	var zeroValue string
 13005  	p := &Project{URL: &zeroValue}
 13006  	p.GetURL()
 13007  	p = &Project{}
 13008  	p.GetURL()
 13009  	p = nil
 13010  	p.GetURL()
 13011  }
 13012  
 13013  func TestProjectBody_GetFrom(tt *testing.T) {
 13014  	var zeroValue string
 13015  	p := &ProjectBody{From: &zeroValue}
 13016  	p.GetFrom()
 13017  	p = &ProjectBody{}
 13018  	p.GetFrom()
 13019  	p = nil
 13020  	p.GetFrom()
 13021  }
 13022  
 13023  func TestProjectCard_GetArchived(tt *testing.T) {
 13024  	var zeroValue bool
 13025  	p := &ProjectCard{Archived: &zeroValue}
 13026  	p.GetArchived()
 13027  	p = &ProjectCard{}
 13028  	p.GetArchived()
 13029  	p = nil
 13030  	p.GetArchived()
 13031  }
 13032  
 13033  func TestProjectCard_GetColumnID(tt *testing.T) {
 13034  	var zeroValue int64
 13035  	p := &ProjectCard{ColumnID: &zeroValue}
 13036  	p.GetColumnID()
 13037  	p = &ProjectCard{}
 13038  	p.GetColumnID()
 13039  	p = nil
 13040  	p.GetColumnID()
 13041  }
 13042  
 13043  func TestProjectCard_GetColumnName(tt *testing.T) {
 13044  	var zeroValue string
 13045  	p := &ProjectCard{ColumnName: &zeroValue}
 13046  	p.GetColumnName()
 13047  	p = &ProjectCard{}
 13048  	p.GetColumnName()
 13049  	p = nil
 13050  	p.GetColumnName()
 13051  }
 13052  
 13053  func TestProjectCard_GetColumnURL(tt *testing.T) {
 13054  	var zeroValue string
 13055  	p := &ProjectCard{ColumnURL: &zeroValue}
 13056  	p.GetColumnURL()
 13057  	p = &ProjectCard{}
 13058  	p.GetColumnURL()
 13059  	p = nil
 13060  	p.GetColumnURL()
 13061  }
 13062  
 13063  func TestProjectCard_GetContentURL(tt *testing.T) {
 13064  	var zeroValue string
 13065  	p := &ProjectCard{ContentURL: &zeroValue}
 13066  	p.GetContentURL()
 13067  	p = &ProjectCard{}
 13068  	p.GetContentURL()
 13069  	p = nil
 13070  	p.GetContentURL()
 13071  }
 13072  
 13073  func TestProjectCard_GetCreatedAt(tt *testing.T) {
 13074  	var zeroValue Timestamp
 13075  	p := &ProjectCard{CreatedAt: &zeroValue}
 13076  	p.GetCreatedAt()
 13077  	p = &ProjectCard{}
 13078  	p.GetCreatedAt()
 13079  	p = nil
 13080  	p.GetCreatedAt()
 13081  }
 13082  
 13083  func TestProjectCard_GetCreator(tt *testing.T) {
 13084  	p := &ProjectCard{}
 13085  	p.GetCreator()
 13086  	p = nil
 13087  	p.GetCreator()
 13088  }
 13089  
 13090  func TestProjectCard_GetID(tt *testing.T) {
 13091  	var zeroValue int64
 13092  	p := &ProjectCard{ID: &zeroValue}
 13093  	p.GetID()
 13094  	p = &ProjectCard{}
 13095  	p.GetID()
 13096  	p = nil
 13097  	p.GetID()
 13098  }
 13099  
 13100  func TestProjectCard_GetNodeID(tt *testing.T) {
 13101  	var zeroValue string
 13102  	p := &ProjectCard{NodeID: &zeroValue}
 13103  	p.GetNodeID()
 13104  	p = &ProjectCard{}
 13105  	p.GetNodeID()
 13106  	p = nil
 13107  	p.GetNodeID()
 13108  }
 13109  
 13110  func TestProjectCard_GetNote(tt *testing.T) {
 13111  	var zeroValue string
 13112  	p := &ProjectCard{Note: &zeroValue}
 13113  	p.GetNote()
 13114  	p = &ProjectCard{}
 13115  	p.GetNote()
 13116  	p = nil
 13117  	p.GetNote()
 13118  }
 13119  
 13120  func TestProjectCard_GetPreviousColumnName(tt *testing.T) {
 13121  	var zeroValue string
 13122  	p := &ProjectCard{PreviousColumnName: &zeroValue}
 13123  	p.GetPreviousColumnName()
 13124  	p = &ProjectCard{}
 13125  	p.GetPreviousColumnName()
 13126  	p = nil
 13127  	p.GetPreviousColumnName()
 13128  }
 13129  
 13130  func TestProjectCard_GetProjectID(tt *testing.T) {
 13131  	var zeroValue int64
 13132  	p := &ProjectCard{ProjectID: &zeroValue}
 13133  	p.GetProjectID()
 13134  	p = &ProjectCard{}
 13135  	p.GetProjectID()
 13136  	p = nil
 13137  	p.GetProjectID()
 13138  }
 13139  
 13140  func TestProjectCard_GetProjectURL(tt *testing.T) {
 13141  	var zeroValue string
 13142  	p := &ProjectCard{ProjectURL: &zeroValue}
 13143  	p.GetProjectURL()
 13144  	p = &ProjectCard{}
 13145  	p.GetProjectURL()
 13146  	p = nil
 13147  	p.GetProjectURL()
 13148  }
 13149  
 13150  func TestProjectCard_GetUpdatedAt(tt *testing.T) {
 13151  	var zeroValue Timestamp
 13152  	p := &ProjectCard{UpdatedAt: &zeroValue}
 13153  	p.GetUpdatedAt()
 13154  	p = &ProjectCard{}
 13155  	p.GetUpdatedAt()
 13156  	p = nil
 13157  	p.GetUpdatedAt()
 13158  }
 13159  
 13160  func TestProjectCard_GetURL(tt *testing.T) {
 13161  	var zeroValue string
 13162  	p := &ProjectCard{URL: &zeroValue}
 13163  	p.GetURL()
 13164  	p = &ProjectCard{}
 13165  	p.GetURL()
 13166  	p = nil
 13167  	p.GetURL()
 13168  }
 13169  
 13170  func TestProjectCardChange_GetNote(tt *testing.T) {
 13171  	p := &ProjectCardChange{}
 13172  	p.GetNote()
 13173  	p = nil
 13174  	p.GetNote()
 13175  }
 13176  
 13177  func TestProjectCardEvent_GetAction(tt *testing.T) {
 13178  	var zeroValue string
 13179  	p := &ProjectCardEvent{Action: &zeroValue}
 13180  	p.GetAction()
 13181  	p = &ProjectCardEvent{}
 13182  	p.GetAction()
 13183  	p = nil
 13184  	p.GetAction()
 13185  }
 13186  
 13187  func TestProjectCardEvent_GetAfterID(tt *testing.T) {
 13188  	var zeroValue int64
 13189  	p := &ProjectCardEvent{AfterID: &zeroValue}
 13190  	p.GetAfterID()
 13191  	p = &ProjectCardEvent{}
 13192  	p.GetAfterID()
 13193  	p = nil
 13194  	p.GetAfterID()
 13195  }
 13196  
 13197  func TestProjectCardEvent_GetChanges(tt *testing.T) {
 13198  	p := &ProjectCardEvent{}
 13199  	p.GetChanges()
 13200  	p = nil
 13201  	p.GetChanges()
 13202  }
 13203  
 13204  func TestProjectCardEvent_GetInstallation(tt *testing.T) {
 13205  	p := &ProjectCardEvent{}
 13206  	p.GetInstallation()
 13207  	p = nil
 13208  	p.GetInstallation()
 13209  }
 13210  
 13211  func TestProjectCardEvent_GetOrg(tt *testing.T) {
 13212  	p := &ProjectCardEvent{}
 13213  	p.GetOrg()
 13214  	p = nil
 13215  	p.GetOrg()
 13216  }
 13217  
 13218  func TestProjectCardEvent_GetProjectCard(tt *testing.T) {
 13219  	p := &ProjectCardEvent{}
 13220  	p.GetProjectCard()
 13221  	p = nil
 13222  	p.GetProjectCard()
 13223  }
 13224  
 13225  func TestProjectCardEvent_GetRepo(tt *testing.T) {
 13226  	p := &ProjectCardEvent{}
 13227  	p.GetRepo()
 13228  	p = nil
 13229  	p.GetRepo()
 13230  }
 13231  
 13232  func TestProjectCardEvent_GetSender(tt *testing.T) {
 13233  	p := &ProjectCardEvent{}
 13234  	p.GetSender()
 13235  	p = nil
 13236  	p.GetSender()
 13237  }
 13238  
 13239  func TestProjectCardListOptions_GetArchivedState(tt *testing.T) {
 13240  	var zeroValue string
 13241  	p := &ProjectCardListOptions{ArchivedState: &zeroValue}
 13242  	p.GetArchivedState()
 13243  	p = &ProjectCardListOptions{}
 13244  	p.GetArchivedState()
 13245  	p = nil
 13246  	p.GetArchivedState()
 13247  }
 13248  
 13249  func TestProjectCardNote_GetFrom(tt *testing.T) {
 13250  	var zeroValue string
 13251  	p := &ProjectCardNote{From: &zeroValue}
 13252  	p.GetFrom()
 13253  	p = &ProjectCardNote{}
 13254  	p.GetFrom()
 13255  	p = nil
 13256  	p.GetFrom()
 13257  }
 13258  
 13259  func TestProjectCardOptions_GetArchived(tt *testing.T) {
 13260  	var zeroValue bool
 13261  	p := &ProjectCardOptions{Archived: &zeroValue}
 13262  	p.GetArchived()
 13263  	p = &ProjectCardOptions{}
 13264  	p.GetArchived()
 13265  	p = nil
 13266  	p.GetArchived()
 13267  }
 13268  
 13269  func TestProjectChange_GetBody(tt *testing.T) {
 13270  	p := &ProjectChange{}
 13271  	p.GetBody()
 13272  	p = nil
 13273  	p.GetBody()
 13274  }
 13275  
 13276  func TestProjectChange_GetName(tt *testing.T) {
 13277  	p := &ProjectChange{}
 13278  	p.GetName()
 13279  	p = nil
 13280  	p.GetName()
 13281  }
 13282  
 13283  func TestProjectCollaboratorOptions_GetPermission(tt *testing.T) {
 13284  	var zeroValue string
 13285  	p := &ProjectCollaboratorOptions{Permission: &zeroValue}
 13286  	p.GetPermission()
 13287  	p = &ProjectCollaboratorOptions{}
 13288  	p.GetPermission()
 13289  	p = nil
 13290  	p.GetPermission()
 13291  }
 13292  
 13293  func TestProjectColumn_GetCardsURL(tt *testing.T) {
 13294  	var zeroValue string
 13295  	p := &ProjectColumn{CardsURL: &zeroValue}
 13296  	p.GetCardsURL()
 13297  	p = &ProjectColumn{}
 13298  	p.GetCardsURL()
 13299  	p = nil
 13300  	p.GetCardsURL()
 13301  }
 13302  
 13303  func TestProjectColumn_GetCreatedAt(tt *testing.T) {
 13304  	var zeroValue Timestamp
 13305  	p := &ProjectColumn{CreatedAt: &zeroValue}
 13306  	p.GetCreatedAt()
 13307  	p = &ProjectColumn{}
 13308  	p.GetCreatedAt()
 13309  	p = nil
 13310  	p.GetCreatedAt()
 13311  }
 13312  
 13313  func TestProjectColumn_GetID(tt *testing.T) {
 13314  	var zeroValue int64
 13315  	p := &ProjectColumn{ID: &zeroValue}
 13316  	p.GetID()
 13317  	p = &ProjectColumn{}
 13318  	p.GetID()
 13319  	p = nil
 13320  	p.GetID()
 13321  }
 13322  
 13323  func TestProjectColumn_GetName(tt *testing.T) {
 13324  	var zeroValue string
 13325  	p := &ProjectColumn{Name: &zeroValue}
 13326  	p.GetName()
 13327  	p = &ProjectColumn{}
 13328  	p.GetName()
 13329  	p = nil
 13330  	p.GetName()
 13331  }
 13332  
 13333  func TestProjectColumn_GetNodeID(tt *testing.T) {
 13334  	var zeroValue string
 13335  	p := &ProjectColumn{NodeID: &zeroValue}
 13336  	p.GetNodeID()
 13337  	p = &ProjectColumn{}
 13338  	p.GetNodeID()
 13339  	p = nil
 13340  	p.GetNodeID()
 13341  }
 13342  
 13343  func TestProjectColumn_GetProjectURL(tt *testing.T) {
 13344  	var zeroValue string
 13345  	p := &ProjectColumn{ProjectURL: &zeroValue}
 13346  	p.GetProjectURL()
 13347  	p = &ProjectColumn{}
 13348  	p.GetProjectURL()
 13349  	p = nil
 13350  	p.GetProjectURL()
 13351  }
 13352  
 13353  func TestProjectColumn_GetUpdatedAt(tt *testing.T) {
 13354  	var zeroValue Timestamp
 13355  	p := &ProjectColumn{UpdatedAt: &zeroValue}
 13356  	p.GetUpdatedAt()
 13357  	p = &ProjectColumn{}
 13358  	p.GetUpdatedAt()
 13359  	p = nil
 13360  	p.GetUpdatedAt()
 13361  }
 13362  
 13363  func TestProjectColumn_GetURL(tt *testing.T) {
 13364  	var zeroValue string
 13365  	p := &ProjectColumn{URL: &zeroValue}
 13366  	p.GetURL()
 13367  	p = &ProjectColumn{}
 13368  	p.GetURL()
 13369  	p = nil
 13370  	p.GetURL()
 13371  }
 13372  
 13373  func TestProjectColumnChange_GetName(tt *testing.T) {
 13374  	p := &ProjectColumnChange{}
 13375  	p.GetName()
 13376  	p = nil
 13377  	p.GetName()
 13378  }
 13379  
 13380  func TestProjectColumnEvent_GetAction(tt *testing.T) {
 13381  	var zeroValue string
 13382  	p := &ProjectColumnEvent{Action: &zeroValue}
 13383  	p.GetAction()
 13384  	p = &ProjectColumnEvent{}
 13385  	p.GetAction()
 13386  	p = nil
 13387  	p.GetAction()
 13388  }
 13389  
 13390  func TestProjectColumnEvent_GetAfterID(tt *testing.T) {
 13391  	var zeroValue int64
 13392  	p := &ProjectColumnEvent{AfterID: &zeroValue}
 13393  	p.GetAfterID()
 13394  	p = &ProjectColumnEvent{}
 13395  	p.GetAfterID()
 13396  	p = nil
 13397  	p.GetAfterID()
 13398  }
 13399  
 13400  func TestProjectColumnEvent_GetChanges(tt *testing.T) {
 13401  	p := &ProjectColumnEvent{}
 13402  	p.GetChanges()
 13403  	p = nil
 13404  	p.GetChanges()
 13405  }
 13406  
 13407  func TestProjectColumnEvent_GetInstallation(tt *testing.T) {
 13408  	p := &ProjectColumnEvent{}
 13409  	p.GetInstallation()
 13410  	p = nil
 13411  	p.GetInstallation()
 13412  }
 13413  
 13414  func TestProjectColumnEvent_GetOrg(tt *testing.T) {
 13415  	p := &ProjectColumnEvent{}
 13416  	p.GetOrg()
 13417  	p = nil
 13418  	p.GetOrg()
 13419  }
 13420  
 13421  func TestProjectColumnEvent_GetProjectColumn(tt *testing.T) {
 13422  	p := &ProjectColumnEvent{}
 13423  	p.GetProjectColumn()
 13424  	p = nil
 13425  	p.GetProjectColumn()
 13426  }
 13427  
 13428  func TestProjectColumnEvent_GetRepo(tt *testing.T) {
 13429  	p := &ProjectColumnEvent{}
 13430  	p.GetRepo()
 13431  	p = nil
 13432  	p.GetRepo()
 13433  }
 13434  
 13435  func TestProjectColumnEvent_GetSender(tt *testing.T) {
 13436  	p := &ProjectColumnEvent{}
 13437  	p.GetSender()
 13438  	p = nil
 13439  	p.GetSender()
 13440  }
 13441  
 13442  func TestProjectColumnName_GetFrom(tt *testing.T) {
 13443  	var zeroValue string
 13444  	p := &ProjectColumnName{From: &zeroValue}
 13445  	p.GetFrom()
 13446  	p = &ProjectColumnName{}
 13447  	p.GetFrom()
 13448  	p = nil
 13449  	p.GetFrom()
 13450  }
 13451  
 13452  func TestProjectEvent_GetAction(tt *testing.T) {
 13453  	var zeroValue string
 13454  	p := &ProjectEvent{Action: &zeroValue}
 13455  	p.GetAction()
 13456  	p = &ProjectEvent{}
 13457  	p.GetAction()
 13458  	p = nil
 13459  	p.GetAction()
 13460  }
 13461  
 13462  func TestProjectEvent_GetChanges(tt *testing.T) {
 13463  	p := &ProjectEvent{}
 13464  	p.GetChanges()
 13465  	p = nil
 13466  	p.GetChanges()
 13467  }
 13468  
 13469  func TestProjectEvent_GetInstallation(tt *testing.T) {
 13470  	p := &ProjectEvent{}
 13471  	p.GetInstallation()
 13472  	p = nil
 13473  	p.GetInstallation()
 13474  }
 13475  
 13476  func TestProjectEvent_GetOrg(tt *testing.T) {
 13477  	p := &ProjectEvent{}
 13478  	p.GetOrg()
 13479  	p = nil
 13480  	p.GetOrg()
 13481  }
 13482  
 13483  func TestProjectEvent_GetProject(tt *testing.T) {
 13484  	p := &ProjectEvent{}
 13485  	p.GetProject()
 13486  	p = nil
 13487  	p.GetProject()
 13488  }
 13489  
 13490  func TestProjectEvent_GetRepo(tt *testing.T) {
 13491  	p := &ProjectEvent{}
 13492  	p.GetRepo()
 13493  	p = nil
 13494  	p.GetRepo()
 13495  }
 13496  
 13497  func TestProjectEvent_GetSender(tt *testing.T) {
 13498  	p := &ProjectEvent{}
 13499  	p.GetSender()
 13500  	p = nil
 13501  	p.GetSender()
 13502  }
 13503  
 13504  func TestProjectName_GetFrom(tt *testing.T) {
 13505  	var zeroValue string
 13506  	p := &ProjectName{From: &zeroValue}
 13507  	p.GetFrom()
 13508  	p = &ProjectName{}
 13509  	p.GetFrom()
 13510  	p = nil
 13511  	p.GetFrom()
 13512  }
 13513  
 13514  func TestProjectOptions_GetBody(tt *testing.T) {
 13515  	var zeroValue string
 13516  	p := &ProjectOptions{Body: &zeroValue}
 13517  	p.GetBody()
 13518  	p = &ProjectOptions{}
 13519  	p.GetBody()
 13520  	p = nil
 13521  	p.GetBody()
 13522  }
 13523  
 13524  func TestProjectOptions_GetName(tt *testing.T) {
 13525  	var zeroValue string
 13526  	p := &ProjectOptions{Name: &zeroValue}
 13527  	p.GetName()
 13528  	p = &ProjectOptions{}
 13529  	p.GetName()
 13530  	p = nil
 13531  	p.GetName()
 13532  }
 13533  
 13534  func TestProjectOptions_GetOrganizationPermission(tt *testing.T) {
 13535  	var zeroValue string
 13536  	p := &ProjectOptions{OrganizationPermission: &zeroValue}
 13537  	p.GetOrganizationPermission()
 13538  	p = &ProjectOptions{}
 13539  	p.GetOrganizationPermission()
 13540  	p = nil
 13541  	p.GetOrganizationPermission()
 13542  }
 13543  
 13544  func TestProjectOptions_GetPrivate(tt *testing.T) {
 13545  	var zeroValue bool
 13546  	p := &ProjectOptions{Private: &zeroValue}
 13547  	p.GetPrivate()
 13548  	p = &ProjectOptions{}
 13549  	p.GetPrivate()
 13550  	p = nil
 13551  	p.GetPrivate()
 13552  }
 13553  
 13554  func TestProjectOptions_GetState(tt *testing.T) {
 13555  	var zeroValue string
 13556  	p := &ProjectOptions{State: &zeroValue}
 13557  	p.GetState()
 13558  	p = &ProjectOptions{}
 13559  	p.GetState()
 13560  	p = nil
 13561  	p.GetState()
 13562  }
 13563  
 13564  func TestProjectPermissionLevel_GetPermission(tt *testing.T) {
 13565  	var zeroValue string
 13566  	p := &ProjectPermissionLevel{Permission: &zeroValue}
 13567  	p.GetPermission()
 13568  	p = &ProjectPermissionLevel{}
 13569  	p.GetPermission()
 13570  	p = nil
 13571  	p.GetPermission()
 13572  }
 13573  
 13574  func TestProjectPermissionLevel_GetUser(tt *testing.T) {
 13575  	p := &ProjectPermissionLevel{}
 13576  	p.GetUser()
 13577  	p = nil
 13578  	p.GetUser()
 13579  }
 13580  
 13581  func TestProtection_GetAllowDeletions(tt *testing.T) {
 13582  	p := &Protection{}
 13583  	p.GetAllowDeletions()
 13584  	p = nil
 13585  	p.GetAllowDeletions()
 13586  }
 13587  
 13588  func TestProtection_GetAllowForcePushes(tt *testing.T) {
 13589  	p := &Protection{}
 13590  	p.GetAllowForcePushes()
 13591  	p = nil
 13592  	p.GetAllowForcePushes()
 13593  }
 13594  
 13595  func TestProtection_GetEnforceAdmins(tt *testing.T) {
 13596  	p := &Protection{}
 13597  	p.GetEnforceAdmins()
 13598  	p = nil
 13599  	p.GetEnforceAdmins()
 13600  }
 13601  
 13602  func TestProtection_GetRequiredConversationResolution(tt *testing.T) {
 13603  	p := &Protection{}
 13604  	p.GetRequiredConversationResolution()
 13605  	p = nil
 13606  	p.GetRequiredConversationResolution()
 13607  }
 13608  
 13609  func TestProtection_GetRequiredPullRequestReviews(tt *testing.T) {
 13610  	p := &Protection{}
 13611  	p.GetRequiredPullRequestReviews()
 13612  	p = nil
 13613  	p.GetRequiredPullRequestReviews()
 13614  }
 13615  
 13616  func TestProtection_GetRequiredStatusChecks(tt *testing.T) {
 13617  	p := &Protection{}
 13618  	p.GetRequiredStatusChecks()
 13619  	p = nil
 13620  	p.GetRequiredStatusChecks()
 13621  }
 13622  
 13623  func TestProtection_GetRequireLinearHistory(tt *testing.T) {
 13624  	p := &Protection{}
 13625  	p.GetRequireLinearHistory()
 13626  	p = nil
 13627  	p.GetRequireLinearHistory()
 13628  }
 13629  
 13630  func TestProtection_GetRestrictions(tt *testing.T) {
 13631  	p := &Protection{}
 13632  	p.GetRestrictions()
 13633  	p = nil
 13634  	p.GetRestrictions()
 13635  }
 13636  
 13637  func TestProtectionChanges_GetAuthorizedActorNames(tt *testing.T) {
 13638  	p := &ProtectionChanges{}
 13639  	p.GetAuthorizedActorNames()
 13640  	p = nil
 13641  	p.GetAuthorizedActorNames()
 13642  }
 13643  
 13644  func TestProtectionChanges_GetAuthorizedActorsOnly(tt *testing.T) {
 13645  	p := &ProtectionChanges{}
 13646  	p.GetAuthorizedActorsOnly()
 13647  	p = nil
 13648  	p.GetAuthorizedActorsOnly()
 13649  }
 13650  
 13651  func TestProtectionRequest_GetAllowDeletions(tt *testing.T) {
 13652  	var zeroValue bool
 13653  	p := &ProtectionRequest{AllowDeletions: &zeroValue}
 13654  	p.GetAllowDeletions()
 13655  	p = &ProtectionRequest{}
 13656  	p.GetAllowDeletions()
 13657  	p = nil
 13658  	p.GetAllowDeletions()
 13659  }
 13660  
 13661  func TestProtectionRequest_GetAllowForcePushes(tt *testing.T) {
 13662  	var zeroValue bool
 13663  	p := &ProtectionRequest{AllowForcePushes: &zeroValue}
 13664  	p.GetAllowForcePushes()
 13665  	p = &ProtectionRequest{}
 13666  	p.GetAllowForcePushes()
 13667  	p = nil
 13668  	p.GetAllowForcePushes()
 13669  }
 13670  
 13671  func TestProtectionRequest_GetRequiredConversationResolution(tt *testing.T) {
 13672  	var zeroValue bool
 13673  	p := &ProtectionRequest{RequiredConversationResolution: &zeroValue}
 13674  	p.GetRequiredConversationResolution()
 13675  	p = &ProtectionRequest{}
 13676  	p.GetRequiredConversationResolution()
 13677  	p = nil
 13678  	p.GetRequiredConversationResolution()
 13679  }
 13680  
 13681  func TestProtectionRequest_GetRequiredPullRequestReviews(tt *testing.T) {
 13682  	p := &ProtectionRequest{}
 13683  	p.GetRequiredPullRequestReviews()
 13684  	p = nil
 13685  	p.GetRequiredPullRequestReviews()
 13686  }
 13687  
 13688  func TestProtectionRequest_GetRequiredStatusChecks(tt *testing.T) {
 13689  	p := &ProtectionRequest{}
 13690  	p.GetRequiredStatusChecks()
 13691  	p = nil
 13692  	p.GetRequiredStatusChecks()
 13693  }
 13694  
 13695  func TestProtectionRequest_GetRequireLinearHistory(tt *testing.T) {
 13696  	var zeroValue bool
 13697  	p := &ProtectionRequest{RequireLinearHistory: &zeroValue}
 13698  	p.GetRequireLinearHistory()
 13699  	p = &ProtectionRequest{}
 13700  	p.GetRequireLinearHistory()
 13701  	p = nil
 13702  	p.GetRequireLinearHistory()
 13703  }
 13704  
 13705  func TestProtectionRequest_GetRestrictions(tt *testing.T) {
 13706  	p := &ProtectionRequest{}
 13707  	p.GetRestrictions()
 13708  	p = nil
 13709  	p.GetRestrictions()
 13710  }
 13711  
 13712  func TestProtectionRule_GetID(tt *testing.T) {
 13713  	var zeroValue int64
 13714  	p := &ProtectionRule{ID: &zeroValue}
 13715  	p.GetID()
 13716  	p = &ProtectionRule{}
 13717  	p.GetID()
 13718  	p = nil
 13719  	p.GetID()
 13720  }
 13721  
 13722  func TestProtectionRule_GetNodeID(tt *testing.T) {
 13723  	var zeroValue string
 13724  	p := &ProtectionRule{NodeID: &zeroValue}
 13725  	p.GetNodeID()
 13726  	p = &ProtectionRule{}
 13727  	p.GetNodeID()
 13728  	p = nil
 13729  	p.GetNodeID()
 13730  }
 13731  
 13732  func TestProtectionRule_GetType(tt *testing.T) {
 13733  	var zeroValue string
 13734  	p := &ProtectionRule{Type: &zeroValue}
 13735  	p.GetType()
 13736  	p = &ProtectionRule{}
 13737  	p.GetType()
 13738  	p = nil
 13739  	p.GetType()
 13740  }
 13741  
 13742  func TestProtectionRule_GetWaitTimer(tt *testing.T) {
 13743  	var zeroValue int
 13744  	p := &ProtectionRule{WaitTimer: &zeroValue}
 13745  	p.GetWaitTimer()
 13746  	p = &ProtectionRule{}
 13747  	p.GetWaitTimer()
 13748  	p = nil
 13749  	p.GetWaitTimer()
 13750  }
 13751  
 13752  func TestPublicEvent_GetInstallation(tt *testing.T) {
 13753  	p := &PublicEvent{}
 13754  	p.GetInstallation()
 13755  	p = nil
 13756  	p.GetInstallation()
 13757  }
 13758  
 13759  func TestPublicEvent_GetRepo(tt *testing.T) {
 13760  	p := &PublicEvent{}
 13761  	p.GetRepo()
 13762  	p = nil
 13763  	p.GetRepo()
 13764  }
 13765  
 13766  func TestPublicEvent_GetSender(tt *testing.T) {
 13767  	p := &PublicEvent{}
 13768  	p.GetSender()
 13769  	p = nil
 13770  	p.GetSender()
 13771  }
 13772  
 13773  func TestPublicKey_GetKey(tt *testing.T) {
 13774  	var zeroValue string
 13775  	p := &PublicKey{Key: &zeroValue}
 13776  	p.GetKey()
 13777  	p = &PublicKey{}
 13778  	p.GetKey()
 13779  	p = nil
 13780  	p.GetKey()
 13781  }
 13782  
 13783  func TestPublicKey_GetKeyID(tt *testing.T) {
 13784  	var zeroValue string
 13785  	p := &PublicKey{KeyID: &zeroValue}
 13786  	p.GetKeyID()
 13787  	p = &PublicKey{}
 13788  	p.GetKeyID()
 13789  	p = nil
 13790  	p.GetKeyID()
 13791  }
 13792  
 13793  func TestPullRequest_GetActiveLockReason(tt *testing.T) {
 13794  	var zeroValue string
 13795  	p := &PullRequest{ActiveLockReason: &zeroValue}
 13796  	p.GetActiveLockReason()
 13797  	p = &PullRequest{}
 13798  	p.GetActiveLockReason()
 13799  	p = nil
 13800  	p.GetActiveLockReason()
 13801  }
 13802  
 13803  func TestPullRequest_GetAdditions(tt *testing.T) {
 13804  	var zeroValue int
 13805  	p := &PullRequest{Additions: &zeroValue}
 13806  	p.GetAdditions()
 13807  	p = &PullRequest{}
 13808  	p.GetAdditions()
 13809  	p = nil
 13810  	p.GetAdditions()
 13811  }
 13812  
 13813  func TestPullRequest_GetAssignee(tt *testing.T) {
 13814  	p := &PullRequest{}
 13815  	p.GetAssignee()
 13816  	p = nil
 13817  	p.GetAssignee()
 13818  }
 13819  
 13820  func TestPullRequest_GetAuthorAssociation(tt *testing.T) {
 13821  	var zeroValue string
 13822  	p := &PullRequest{AuthorAssociation: &zeroValue}
 13823  	p.GetAuthorAssociation()
 13824  	p = &PullRequest{}
 13825  	p.GetAuthorAssociation()
 13826  	p = nil
 13827  	p.GetAuthorAssociation()
 13828  }
 13829  
 13830  func TestPullRequest_GetAutoMerge(tt *testing.T) {
 13831  	p := &PullRequest{}
 13832  	p.GetAutoMerge()
 13833  	p = nil
 13834  	p.GetAutoMerge()
 13835  }
 13836  
 13837  func TestPullRequest_GetBase(tt *testing.T) {
 13838  	p := &PullRequest{}
 13839  	p.GetBase()
 13840  	p = nil
 13841  	p.GetBase()
 13842  }
 13843  
 13844  func TestPullRequest_GetBody(tt *testing.T) {
 13845  	var zeroValue string
 13846  	p := &PullRequest{Body: &zeroValue}
 13847  	p.GetBody()
 13848  	p = &PullRequest{}
 13849  	p.GetBody()
 13850  	p = nil
 13851  	p.GetBody()
 13852  }
 13853  
 13854  func TestPullRequest_GetChangedFiles(tt *testing.T) {
 13855  	var zeroValue int
 13856  	p := &PullRequest{ChangedFiles: &zeroValue}
 13857  	p.GetChangedFiles()
 13858  	p = &PullRequest{}
 13859  	p.GetChangedFiles()
 13860  	p = nil
 13861  	p.GetChangedFiles()
 13862  }
 13863  
 13864  func TestPullRequest_GetClosedAt(tt *testing.T) {
 13865  	var zeroValue time.Time
 13866  	p := &PullRequest{ClosedAt: &zeroValue}
 13867  	p.GetClosedAt()
 13868  	p = &PullRequest{}
 13869  	p.GetClosedAt()
 13870  	p = nil
 13871  	p.GetClosedAt()
 13872  }
 13873  
 13874  func TestPullRequest_GetComments(tt *testing.T) {
 13875  	var zeroValue int
 13876  	p := &PullRequest{Comments: &zeroValue}
 13877  	p.GetComments()
 13878  	p = &PullRequest{}
 13879  	p.GetComments()
 13880  	p = nil
 13881  	p.GetComments()
 13882  }
 13883  
 13884  func TestPullRequest_GetCommentsURL(tt *testing.T) {
 13885  	var zeroValue string
 13886  	p := &PullRequest{CommentsURL: &zeroValue}
 13887  	p.GetCommentsURL()
 13888  	p = &PullRequest{}
 13889  	p.GetCommentsURL()
 13890  	p = nil
 13891  	p.GetCommentsURL()
 13892  }
 13893  
 13894  func TestPullRequest_GetCommits(tt *testing.T) {
 13895  	var zeroValue int
 13896  	p := &PullRequest{Commits: &zeroValue}
 13897  	p.GetCommits()
 13898  	p = &PullRequest{}
 13899  	p.GetCommits()
 13900  	p = nil
 13901  	p.GetCommits()
 13902  }
 13903  
 13904  func TestPullRequest_GetCommitsURL(tt *testing.T) {
 13905  	var zeroValue string
 13906  	p := &PullRequest{CommitsURL: &zeroValue}
 13907  	p.GetCommitsURL()
 13908  	p = &PullRequest{}
 13909  	p.GetCommitsURL()
 13910  	p = nil
 13911  	p.GetCommitsURL()
 13912  }
 13913  
 13914  func TestPullRequest_GetCreatedAt(tt *testing.T) {
 13915  	var zeroValue time.Time
 13916  	p := &PullRequest{CreatedAt: &zeroValue}
 13917  	p.GetCreatedAt()
 13918  	p = &PullRequest{}
 13919  	p.GetCreatedAt()
 13920  	p = nil
 13921  	p.GetCreatedAt()
 13922  }
 13923  
 13924  func TestPullRequest_GetDeletions(tt *testing.T) {
 13925  	var zeroValue int
 13926  	p := &PullRequest{Deletions: &zeroValue}
 13927  	p.GetDeletions()
 13928  	p = &PullRequest{}
 13929  	p.GetDeletions()
 13930  	p = nil
 13931  	p.GetDeletions()
 13932  }
 13933  
 13934  func TestPullRequest_GetDiffURL(tt *testing.T) {
 13935  	var zeroValue string
 13936  	p := &PullRequest{DiffURL: &zeroValue}
 13937  	p.GetDiffURL()
 13938  	p = &PullRequest{}
 13939  	p.GetDiffURL()
 13940  	p = nil
 13941  	p.GetDiffURL()
 13942  }
 13943  
 13944  func TestPullRequest_GetDraft(tt *testing.T) {
 13945  	var zeroValue bool
 13946  	p := &PullRequest{Draft: &zeroValue}
 13947  	p.GetDraft()
 13948  	p = &PullRequest{}
 13949  	p.GetDraft()
 13950  	p = nil
 13951  	p.GetDraft()
 13952  }
 13953  
 13954  func TestPullRequest_GetHead(tt *testing.T) {
 13955  	p := &PullRequest{}
 13956  	p.GetHead()
 13957  	p = nil
 13958  	p.GetHead()
 13959  }
 13960  
 13961  func TestPullRequest_GetHTMLURL(tt *testing.T) {
 13962  	var zeroValue string
 13963  	p := &PullRequest{HTMLURL: &zeroValue}
 13964  	p.GetHTMLURL()
 13965  	p = &PullRequest{}
 13966  	p.GetHTMLURL()
 13967  	p = nil
 13968  	p.GetHTMLURL()
 13969  }
 13970  
 13971  func TestPullRequest_GetID(tt *testing.T) {
 13972  	var zeroValue int64
 13973  	p := &PullRequest{ID: &zeroValue}
 13974  	p.GetID()
 13975  	p = &PullRequest{}
 13976  	p.GetID()
 13977  	p = nil
 13978  	p.GetID()
 13979  }
 13980  
 13981  func TestPullRequest_GetIssueURL(tt *testing.T) {
 13982  	var zeroValue string
 13983  	p := &PullRequest{IssueURL: &zeroValue}
 13984  	p.GetIssueURL()
 13985  	p = &PullRequest{}
 13986  	p.GetIssueURL()
 13987  	p = nil
 13988  	p.GetIssueURL()
 13989  }
 13990  
 13991  func TestPullRequest_GetLinks(tt *testing.T) {
 13992  	p := &PullRequest{}
 13993  	p.GetLinks()
 13994  	p = nil
 13995  	p.GetLinks()
 13996  }
 13997  
 13998  func TestPullRequest_GetLocked(tt *testing.T) {
 13999  	var zeroValue bool
 14000  	p := &PullRequest{Locked: &zeroValue}
 14001  	p.GetLocked()
 14002  	p = &PullRequest{}
 14003  	p.GetLocked()
 14004  	p = nil
 14005  	p.GetLocked()
 14006  }
 14007  
 14008  func TestPullRequest_GetMaintainerCanModify(tt *testing.T) {
 14009  	var zeroValue bool
 14010  	p := &PullRequest{MaintainerCanModify: &zeroValue}
 14011  	p.GetMaintainerCanModify()
 14012  	p = &PullRequest{}
 14013  	p.GetMaintainerCanModify()
 14014  	p = nil
 14015  	p.GetMaintainerCanModify()
 14016  }
 14017  
 14018  func TestPullRequest_GetMergeable(tt *testing.T) {
 14019  	var zeroValue bool
 14020  	p := &PullRequest{Mergeable: &zeroValue}
 14021  	p.GetMergeable()
 14022  	p = &PullRequest{}
 14023  	p.GetMergeable()
 14024  	p = nil
 14025  	p.GetMergeable()
 14026  }
 14027  
 14028  func TestPullRequest_GetMergeableState(tt *testing.T) {
 14029  	var zeroValue string
 14030  	p := &PullRequest{MergeableState: &zeroValue}
 14031  	p.GetMergeableState()
 14032  	p = &PullRequest{}
 14033  	p.GetMergeableState()
 14034  	p = nil
 14035  	p.GetMergeableState()
 14036  }
 14037  
 14038  func TestPullRequest_GetMergeCommitSHA(tt *testing.T) {
 14039  	var zeroValue string
 14040  	p := &PullRequest{MergeCommitSHA: &zeroValue}
 14041  	p.GetMergeCommitSHA()
 14042  	p = &PullRequest{}
 14043  	p.GetMergeCommitSHA()
 14044  	p = nil
 14045  	p.GetMergeCommitSHA()
 14046  }
 14047  
 14048  func TestPullRequest_GetMerged(tt *testing.T) {
 14049  	var zeroValue bool
 14050  	p := &PullRequest{Merged: &zeroValue}
 14051  	p.GetMerged()
 14052  	p = &PullRequest{}
 14053  	p.GetMerged()
 14054  	p = nil
 14055  	p.GetMerged()
 14056  }
 14057  
 14058  func TestPullRequest_GetMergedAt(tt *testing.T) {
 14059  	var zeroValue time.Time
 14060  	p := &PullRequest{MergedAt: &zeroValue}
 14061  	p.GetMergedAt()
 14062  	p = &PullRequest{}
 14063  	p.GetMergedAt()
 14064  	p = nil
 14065  	p.GetMergedAt()
 14066  }
 14067  
 14068  func TestPullRequest_GetMergedBy(tt *testing.T) {
 14069  	p := &PullRequest{}
 14070  	p.GetMergedBy()
 14071  	p = nil
 14072  	p.GetMergedBy()
 14073  }
 14074  
 14075  func TestPullRequest_GetMilestone(tt *testing.T) {
 14076  	p := &PullRequest{}
 14077  	p.GetMilestone()
 14078  	p = nil
 14079  	p.GetMilestone()
 14080  }
 14081  
 14082  func TestPullRequest_GetNodeID(tt *testing.T) {
 14083  	var zeroValue string
 14084  	p := &PullRequest{NodeID: &zeroValue}
 14085  	p.GetNodeID()
 14086  	p = &PullRequest{}
 14087  	p.GetNodeID()
 14088  	p = nil
 14089  	p.GetNodeID()
 14090  }
 14091  
 14092  func TestPullRequest_GetNumber(tt *testing.T) {
 14093  	var zeroValue int
 14094  	p := &PullRequest{Number: &zeroValue}
 14095  	p.GetNumber()
 14096  	p = &PullRequest{}
 14097  	p.GetNumber()
 14098  	p = nil
 14099  	p.GetNumber()
 14100  }
 14101  
 14102  func TestPullRequest_GetPatchURL(tt *testing.T) {
 14103  	var zeroValue string
 14104  	p := &PullRequest{PatchURL: &zeroValue}
 14105  	p.GetPatchURL()
 14106  	p = &PullRequest{}
 14107  	p.GetPatchURL()
 14108  	p = nil
 14109  	p.GetPatchURL()
 14110  }
 14111  
 14112  func TestPullRequest_GetRebaseable(tt *testing.T) {
 14113  	var zeroValue bool
 14114  	p := &PullRequest{Rebaseable: &zeroValue}
 14115  	p.GetRebaseable()
 14116  	p = &PullRequest{}
 14117  	p.GetRebaseable()
 14118  	p = nil
 14119  	p.GetRebaseable()
 14120  }
 14121  
 14122  func TestPullRequest_GetReviewComments(tt *testing.T) {
 14123  	var zeroValue int
 14124  	p := &PullRequest{ReviewComments: &zeroValue}
 14125  	p.GetReviewComments()
 14126  	p = &PullRequest{}
 14127  	p.GetReviewComments()
 14128  	p = nil
 14129  	p.GetReviewComments()
 14130  }
 14131  
 14132  func TestPullRequest_GetReviewCommentsURL(tt *testing.T) {
 14133  	var zeroValue string
 14134  	p := &PullRequest{ReviewCommentsURL: &zeroValue}
 14135  	p.GetReviewCommentsURL()
 14136  	p = &PullRequest{}
 14137  	p.GetReviewCommentsURL()
 14138  	p = nil
 14139  	p.GetReviewCommentsURL()
 14140  }
 14141  
 14142  func TestPullRequest_GetReviewCommentURL(tt *testing.T) {
 14143  	var zeroValue string
 14144  	p := &PullRequest{ReviewCommentURL: &zeroValue}
 14145  	p.GetReviewCommentURL()
 14146  	p = &PullRequest{}
 14147  	p.GetReviewCommentURL()
 14148  	p = nil
 14149  	p.GetReviewCommentURL()
 14150  }
 14151  
 14152  func TestPullRequest_GetState(tt *testing.T) {
 14153  	var zeroValue string
 14154  	p := &PullRequest{State: &zeroValue}
 14155  	p.GetState()
 14156  	p = &PullRequest{}
 14157  	p.GetState()
 14158  	p = nil
 14159  	p.GetState()
 14160  }
 14161  
 14162  func TestPullRequest_GetStatusesURL(tt *testing.T) {
 14163  	var zeroValue string
 14164  	p := &PullRequest{StatusesURL: &zeroValue}
 14165  	p.GetStatusesURL()
 14166  	p = &PullRequest{}
 14167  	p.GetStatusesURL()
 14168  	p = nil
 14169  	p.GetStatusesURL()
 14170  }
 14171  
 14172  func TestPullRequest_GetTitle(tt *testing.T) {
 14173  	var zeroValue string
 14174  	p := &PullRequest{Title: &zeroValue}
 14175  	p.GetTitle()
 14176  	p = &PullRequest{}
 14177  	p.GetTitle()
 14178  	p = nil
 14179  	p.GetTitle()
 14180  }
 14181  
 14182  func TestPullRequest_GetUpdatedAt(tt *testing.T) {
 14183  	var zeroValue time.Time
 14184  	p := &PullRequest{UpdatedAt: &zeroValue}
 14185  	p.GetUpdatedAt()
 14186  	p = &PullRequest{}
 14187  	p.GetUpdatedAt()
 14188  	p = nil
 14189  	p.GetUpdatedAt()
 14190  }
 14191  
 14192  func TestPullRequest_GetURL(tt *testing.T) {
 14193  	var zeroValue string
 14194  	p := &PullRequest{URL: &zeroValue}
 14195  	p.GetURL()
 14196  	p = &PullRequest{}
 14197  	p.GetURL()
 14198  	p = nil
 14199  	p.GetURL()
 14200  }
 14201  
 14202  func TestPullRequest_GetUser(tt *testing.T) {
 14203  	p := &PullRequest{}
 14204  	p.GetUser()
 14205  	p = nil
 14206  	p.GetUser()
 14207  }
 14208  
 14209  func TestPullRequestAutoMerge_GetCommitMessage(tt *testing.T) {
 14210  	var zeroValue string
 14211  	p := &PullRequestAutoMerge{CommitMessage: &zeroValue}
 14212  	p.GetCommitMessage()
 14213  	p = &PullRequestAutoMerge{}
 14214  	p.GetCommitMessage()
 14215  	p = nil
 14216  	p.GetCommitMessage()
 14217  }
 14218  
 14219  func TestPullRequestAutoMerge_GetCommitTitle(tt *testing.T) {
 14220  	var zeroValue string
 14221  	p := &PullRequestAutoMerge{CommitTitle: &zeroValue}
 14222  	p.GetCommitTitle()
 14223  	p = &PullRequestAutoMerge{}
 14224  	p.GetCommitTitle()
 14225  	p = nil
 14226  	p.GetCommitTitle()
 14227  }
 14228  
 14229  func TestPullRequestAutoMerge_GetEnabledBy(tt *testing.T) {
 14230  	p := &PullRequestAutoMerge{}
 14231  	p.GetEnabledBy()
 14232  	p = nil
 14233  	p.GetEnabledBy()
 14234  }
 14235  
 14236  func TestPullRequestAutoMerge_GetMergeMethod(tt *testing.T) {
 14237  	var zeroValue string
 14238  	p := &PullRequestAutoMerge{MergeMethod: &zeroValue}
 14239  	p.GetMergeMethod()
 14240  	p = &PullRequestAutoMerge{}
 14241  	p.GetMergeMethod()
 14242  	p = nil
 14243  	p.GetMergeMethod()
 14244  }
 14245  
 14246  func TestPullRequestBranch_GetLabel(tt *testing.T) {
 14247  	var zeroValue string
 14248  	p := &PullRequestBranch{Label: &zeroValue}
 14249  	p.GetLabel()
 14250  	p = &PullRequestBranch{}
 14251  	p.GetLabel()
 14252  	p = nil
 14253  	p.GetLabel()
 14254  }
 14255  
 14256  func TestPullRequestBranch_GetRef(tt *testing.T) {
 14257  	var zeroValue string
 14258  	p := &PullRequestBranch{Ref: &zeroValue}
 14259  	p.GetRef()
 14260  	p = &PullRequestBranch{}
 14261  	p.GetRef()
 14262  	p = nil
 14263  	p.GetRef()
 14264  }
 14265  
 14266  func TestPullRequestBranch_GetRepo(tt *testing.T) {
 14267  	p := &PullRequestBranch{}
 14268  	p.GetRepo()
 14269  	p = nil
 14270  	p.GetRepo()
 14271  }
 14272  
 14273  func TestPullRequestBranch_GetSHA(tt *testing.T) {
 14274  	var zeroValue string
 14275  	p := &PullRequestBranch{SHA: &zeroValue}
 14276  	p.GetSHA()
 14277  	p = &PullRequestBranch{}
 14278  	p.GetSHA()
 14279  	p = nil
 14280  	p.GetSHA()
 14281  }
 14282  
 14283  func TestPullRequestBranch_GetUser(tt *testing.T) {
 14284  	p := &PullRequestBranch{}
 14285  	p.GetUser()
 14286  	p = nil
 14287  	p.GetUser()
 14288  }
 14289  
 14290  func TestPullRequestBranchUpdateOptions_GetExpectedHeadSHA(tt *testing.T) {
 14291  	var zeroValue string
 14292  	p := &PullRequestBranchUpdateOptions{ExpectedHeadSHA: &zeroValue}
 14293  	p.GetExpectedHeadSHA()
 14294  	p = &PullRequestBranchUpdateOptions{}
 14295  	p.GetExpectedHeadSHA()
 14296  	p = nil
 14297  	p.GetExpectedHeadSHA()
 14298  }
 14299  
 14300  func TestPullRequestBranchUpdateResponse_GetMessage(tt *testing.T) {
 14301  	var zeroValue string
 14302  	p := &PullRequestBranchUpdateResponse{Message: &zeroValue}
 14303  	p.GetMessage()
 14304  	p = &PullRequestBranchUpdateResponse{}
 14305  	p.GetMessage()
 14306  	p = nil
 14307  	p.GetMessage()
 14308  }
 14309  
 14310  func TestPullRequestBranchUpdateResponse_GetURL(tt *testing.T) {
 14311  	var zeroValue string
 14312  	p := &PullRequestBranchUpdateResponse{URL: &zeroValue}
 14313  	p.GetURL()
 14314  	p = &PullRequestBranchUpdateResponse{}
 14315  	p.GetURL()
 14316  	p = nil
 14317  	p.GetURL()
 14318  }
 14319  
 14320  func TestPullRequestComment_GetAuthorAssociation(tt *testing.T) {
 14321  	var zeroValue string
 14322  	p := &PullRequestComment{AuthorAssociation: &zeroValue}
 14323  	p.GetAuthorAssociation()
 14324  	p = &PullRequestComment{}
 14325  	p.GetAuthorAssociation()
 14326  	p = nil
 14327  	p.GetAuthorAssociation()
 14328  }
 14329  
 14330  func TestPullRequestComment_GetBody(tt *testing.T) {
 14331  	var zeroValue string
 14332  	p := &PullRequestComment{Body: &zeroValue}
 14333  	p.GetBody()
 14334  	p = &PullRequestComment{}
 14335  	p.GetBody()
 14336  	p = nil
 14337  	p.GetBody()
 14338  }
 14339  
 14340  func TestPullRequestComment_GetCommitID(tt *testing.T) {
 14341  	var zeroValue string
 14342  	p := &PullRequestComment{CommitID: &zeroValue}
 14343  	p.GetCommitID()
 14344  	p = &PullRequestComment{}
 14345  	p.GetCommitID()
 14346  	p = nil
 14347  	p.GetCommitID()
 14348  }
 14349  
 14350  func TestPullRequestComment_GetCreatedAt(tt *testing.T) {
 14351  	var zeroValue time.Time
 14352  	p := &PullRequestComment{CreatedAt: &zeroValue}
 14353  	p.GetCreatedAt()
 14354  	p = &PullRequestComment{}
 14355  	p.GetCreatedAt()
 14356  	p = nil
 14357  	p.GetCreatedAt()
 14358  }
 14359  
 14360  func TestPullRequestComment_GetDiffHunk(tt *testing.T) {
 14361  	var zeroValue string
 14362  	p := &PullRequestComment{DiffHunk: &zeroValue}
 14363  	p.GetDiffHunk()
 14364  	p = &PullRequestComment{}
 14365  	p.GetDiffHunk()
 14366  	p = nil
 14367  	p.GetDiffHunk()
 14368  }
 14369  
 14370  func TestPullRequestComment_GetHTMLURL(tt *testing.T) {
 14371  	var zeroValue string
 14372  	p := &PullRequestComment{HTMLURL: &zeroValue}
 14373  	p.GetHTMLURL()
 14374  	p = &PullRequestComment{}
 14375  	p.GetHTMLURL()
 14376  	p = nil
 14377  	p.GetHTMLURL()
 14378  }
 14379  
 14380  func TestPullRequestComment_GetID(tt *testing.T) {
 14381  	var zeroValue int64
 14382  	p := &PullRequestComment{ID: &zeroValue}
 14383  	p.GetID()
 14384  	p = &PullRequestComment{}
 14385  	p.GetID()
 14386  	p = nil
 14387  	p.GetID()
 14388  }
 14389  
 14390  func TestPullRequestComment_GetInReplyTo(tt *testing.T) {
 14391  	var zeroValue int64
 14392  	p := &PullRequestComment{InReplyTo: &zeroValue}
 14393  	p.GetInReplyTo()
 14394  	p = &PullRequestComment{}
 14395  	p.GetInReplyTo()
 14396  	p = nil
 14397  	p.GetInReplyTo()
 14398  }
 14399  
 14400  func TestPullRequestComment_GetLine(tt *testing.T) {
 14401  	var zeroValue int
 14402  	p := &PullRequestComment{Line: &zeroValue}
 14403  	p.GetLine()
 14404  	p = &PullRequestComment{}
 14405  	p.GetLine()
 14406  	p = nil
 14407  	p.GetLine()
 14408  }
 14409  
 14410  func TestPullRequestComment_GetNodeID(tt *testing.T) {
 14411  	var zeroValue string
 14412  	p := &PullRequestComment{NodeID: &zeroValue}
 14413  	p.GetNodeID()
 14414  	p = &PullRequestComment{}
 14415  	p.GetNodeID()
 14416  	p = nil
 14417  	p.GetNodeID()
 14418  }
 14419  
 14420  func TestPullRequestComment_GetOriginalCommitID(tt *testing.T) {
 14421  	var zeroValue string
 14422  	p := &PullRequestComment{OriginalCommitID: &zeroValue}
 14423  	p.GetOriginalCommitID()
 14424  	p = &PullRequestComment{}
 14425  	p.GetOriginalCommitID()
 14426  	p = nil
 14427  	p.GetOriginalCommitID()
 14428  }
 14429  
 14430  func TestPullRequestComment_GetOriginalLine(tt *testing.T) {
 14431  	var zeroValue int
 14432  	p := &PullRequestComment{OriginalLine: &zeroValue}
 14433  	p.GetOriginalLine()
 14434  	p = &PullRequestComment{}
 14435  	p.GetOriginalLine()
 14436  	p = nil
 14437  	p.GetOriginalLine()
 14438  }
 14439  
 14440  func TestPullRequestComment_GetOriginalPosition(tt *testing.T) {
 14441  	var zeroValue int
 14442  	p := &PullRequestComment{OriginalPosition: &zeroValue}
 14443  	p.GetOriginalPosition()
 14444  	p = &PullRequestComment{}
 14445  	p.GetOriginalPosition()
 14446  	p = nil
 14447  	p.GetOriginalPosition()
 14448  }
 14449  
 14450  func TestPullRequestComment_GetOriginalStartLine(tt *testing.T) {
 14451  	var zeroValue int
 14452  	p := &PullRequestComment{OriginalStartLine: &zeroValue}
 14453  	p.GetOriginalStartLine()
 14454  	p = &PullRequestComment{}
 14455  	p.GetOriginalStartLine()
 14456  	p = nil
 14457  	p.GetOriginalStartLine()
 14458  }
 14459  
 14460  func TestPullRequestComment_GetPath(tt *testing.T) {
 14461  	var zeroValue string
 14462  	p := &PullRequestComment{Path: &zeroValue}
 14463  	p.GetPath()
 14464  	p = &PullRequestComment{}
 14465  	p.GetPath()
 14466  	p = nil
 14467  	p.GetPath()
 14468  }
 14469  
 14470  func TestPullRequestComment_GetPosition(tt *testing.T) {
 14471  	var zeroValue int
 14472  	p := &PullRequestComment{Position: &zeroValue}
 14473  	p.GetPosition()
 14474  	p = &PullRequestComment{}
 14475  	p.GetPosition()
 14476  	p = nil
 14477  	p.GetPosition()
 14478  }
 14479  
 14480  func TestPullRequestComment_GetPullRequestReviewID(tt *testing.T) {
 14481  	var zeroValue int64
 14482  	p := &PullRequestComment{PullRequestReviewID: &zeroValue}
 14483  	p.GetPullRequestReviewID()
 14484  	p = &PullRequestComment{}
 14485  	p.GetPullRequestReviewID()
 14486  	p = nil
 14487  	p.GetPullRequestReviewID()
 14488  }
 14489  
 14490  func TestPullRequestComment_GetPullRequestURL(tt *testing.T) {
 14491  	var zeroValue string
 14492  	p := &PullRequestComment{PullRequestURL: &zeroValue}
 14493  	p.GetPullRequestURL()
 14494  	p = &PullRequestComment{}
 14495  	p.GetPullRequestURL()
 14496  	p = nil
 14497  	p.GetPullRequestURL()
 14498  }
 14499  
 14500  func TestPullRequestComment_GetReactions(tt *testing.T) {
 14501  	p := &PullRequestComment{}
 14502  	p.GetReactions()
 14503  	p = nil
 14504  	p.GetReactions()
 14505  }
 14506  
 14507  func TestPullRequestComment_GetSide(tt *testing.T) {
 14508  	var zeroValue string
 14509  	p := &PullRequestComment{Side: &zeroValue}
 14510  	p.GetSide()
 14511  	p = &PullRequestComment{}
 14512  	p.GetSide()
 14513  	p = nil
 14514  	p.GetSide()
 14515  }
 14516  
 14517  func TestPullRequestComment_GetStartLine(tt *testing.T) {
 14518  	var zeroValue int
 14519  	p := &PullRequestComment{StartLine: &zeroValue}
 14520  	p.GetStartLine()
 14521  	p = &PullRequestComment{}
 14522  	p.GetStartLine()
 14523  	p = nil
 14524  	p.GetStartLine()
 14525  }
 14526  
 14527  func TestPullRequestComment_GetStartSide(tt *testing.T) {
 14528  	var zeroValue string
 14529  	p := &PullRequestComment{StartSide: &zeroValue}
 14530  	p.GetStartSide()
 14531  	p = &PullRequestComment{}
 14532  	p.GetStartSide()
 14533  	p = nil
 14534  	p.GetStartSide()
 14535  }
 14536  
 14537  func TestPullRequestComment_GetUpdatedAt(tt *testing.T) {
 14538  	var zeroValue time.Time
 14539  	p := &PullRequestComment{UpdatedAt: &zeroValue}
 14540  	p.GetUpdatedAt()
 14541  	p = &PullRequestComment{}
 14542  	p.GetUpdatedAt()
 14543  	p = nil
 14544  	p.GetUpdatedAt()
 14545  }
 14546  
 14547  func TestPullRequestComment_GetURL(tt *testing.T) {
 14548  	var zeroValue string
 14549  	p := &PullRequestComment{URL: &zeroValue}
 14550  	p.GetURL()
 14551  	p = &PullRequestComment{}
 14552  	p.GetURL()
 14553  	p = nil
 14554  	p.GetURL()
 14555  }
 14556  
 14557  func TestPullRequestComment_GetUser(tt *testing.T) {
 14558  	p := &PullRequestComment{}
 14559  	p.GetUser()
 14560  	p = nil
 14561  	p.GetUser()
 14562  }
 14563  
 14564  func TestPullRequestEvent_GetAction(tt *testing.T) {
 14565  	var zeroValue string
 14566  	p := &PullRequestEvent{Action: &zeroValue}
 14567  	p.GetAction()
 14568  	p = &PullRequestEvent{}
 14569  	p.GetAction()
 14570  	p = nil
 14571  	p.GetAction()
 14572  }
 14573  
 14574  func TestPullRequestEvent_GetAfter(tt *testing.T) {
 14575  	var zeroValue string
 14576  	p := &PullRequestEvent{After: &zeroValue}
 14577  	p.GetAfter()
 14578  	p = &PullRequestEvent{}
 14579  	p.GetAfter()
 14580  	p = nil
 14581  	p.GetAfter()
 14582  }
 14583  
 14584  func TestPullRequestEvent_GetAssignee(tt *testing.T) {
 14585  	p := &PullRequestEvent{}
 14586  	p.GetAssignee()
 14587  	p = nil
 14588  	p.GetAssignee()
 14589  }
 14590  
 14591  func TestPullRequestEvent_GetBefore(tt *testing.T) {
 14592  	var zeroValue string
 14593  	p := &PullRequestEvent{Before: &zeroValue}
 14594  	p.GetBefore()
 14595  	p = &PullRequestEvent{}
 14596  	p.GetBefore()
 14597  	p = nil
 14598  	p.GetBefore()
 14599  }
 14600  
 14601  func TestPullRequestEvent_GetChanges(tt *testing.T) {
 14602  	p := &PullRequestEvent{}
 14603  	p.GetChanges()
 14604  	p = nil
 14605  	p.GetChanges()
 14606  }
 14607  
 14608  func TestPullRequestEvent_GetInstallation(tt *testing.T) {
 14609  	p := &PullRequestEvent{}
 14610  	p.GetInstallation()
 14611  	p = nil
 14612  	p.GetInstallation()
 14613  }
 14614  
 14615  func TestPullRequestEvent_GetLabel(tt *testing.T) {
 14616  	p := &PullRequestEvent{}
 14617  	p.GetLabel()
 14618  	p = nil
 14619  	p.GetLabel()
 14620  }
 14621  
 14622  func TestPullRequestEvent_GetNumber(tt *testing.T) {
 14623  	var zeroValue int
 14624  	p := &PullRequestEvent{Number: &zeroValue}
 14625  	p.GetNumber()
 14626  	p = &PullRequestEvent{}
 14627  	p.GetNumber()
 14628  	p = nil
 14629  	p.GetNumber()
 14630  }
 14631  
 14632  func TestPullRequestEvent_GetOrganization(tt *testing.T) {
 14633  	p := &PullRequestEvent{}
 14634  	p.GetOrganization()
 14635  	p = nil
 14636  	p.GetOrganization()
 14637  }
 14638  
 14639  func TestPullRequestEvent_GetPullRequest(tt *testing.T) {
 14640  	p := &PullRequestEvent{}
 14641  	p.GetPullRequest()
 14642  	p = nil
 14643  	p.GetPullRequest()
 14644  }
 14645  
 14646  func TestPullRequestEvent_GetRepo(tt *testing.T) {
 14647  	p := &PullRequestEvent{}
 14648  	p.GetRepo()
 14649  	p = nil
 14650  	p.GetRepo()
 14651  }
 14652  
 14653  func TestPullRequestEvent_GetRequestedReviewer(tt *testing.T) {
 14654  	p := &PullRequestEvent{}
 14655  	p.GetRequestedReviewer()
 14656  	p = nil
 14657  	p.GetRequestedReviewer()
 14658  }
 14659  
 14660  func TestPullRequestEvent_GetRequestedTeam(tt *testing.T) {
 14661  	p := &PullRequestEvent{}
 14662  	p.GetRequestedTeam()
 14663  	p = nil
 14664  	p.GetRequestedTeam()
 14665  }
 14666  
 14667  func TestPullRequestEvent_GetSender(tt *testing.T) {
 14668  	p := &PullRequestEvent{}
 14669  	p.GetSender()
 14670  	p = nil
 14671  	p.GetSender()
 14672  }
 14673  
 14674  func TestPullRequestLinks_GetDiffURL(tt *testing.T) {
 14675  	var zeroValue string
 14676  	p := &PullRequestLinks{DiffURL: &zeroValue}
 14677  	p.GetDiffURL()
 14678  	p = &PullRequestLinks{}
 14679  	p.GetDiffURL()
 14680  	p = nil
 14681  	p.GetDiffURL()
 14682  }
 14683  
 14684  func TestPullRequestLinks_GetHTMLURL(tt *testing.T) {
 14685  	var zeroValue string
 14686  	p := &PullRequestLinks{HTMLURL: &zeroValue}
 14687  	p.GetHTMLURL()
 14688  	p = &PullRequestLinks{}
 14689  	p.GetHTMLURL()
 14690  	p = nil
 14691  	p.GetHTMLURL()
 14692  }
 14693  
 14694  func TestPullRequestLinks_GetPatchURL(tt *testing.T) {
 14695  	var zeroValue string
 14696  	p := &PullRequestLinks{PatchURL: &zeroValue}
 14697  	p.GetPatchURL()
 14698  	p = &PullRequestLinks{}
 14699  	p.GetPatchURL()
 14700  	p = nil
 14701  	p.GetPatchURL()
 14702  }
 14703  
 14704  func TestPullRequestLinks_GetURL(tt *testing.T) {
 14705  	var zeroValue string
 14706  	p := &PullRequestLinks{URL: &zeroValue}
 14707  	p.GetURL()
 14708  	p = &PullRequestLinks{}
 14709  	p.GetURL()
 14710  	p = nil
 14711  	p.GetURL()
 14712  }
 14713  
 14714  func TestPullRequestMergeResult_GetMerged(tt *testing.T) {
 14715  	var zeroValue bool
 14716  	p := &PullRequestMergeResult{Merged: &zeroValue}
 14717  	p.GetMerged()
 14718  	p = &PullRequestMergeResult{}
 14719  	p.GetMerged()
 14720  	p = nil
 14721  	p.GetMerged()
 14722  }
 14723  
 14724  func TestPullRequestMergeResult_GetMessage(tt *testing.T) {
 14725  	var zeroValue string
 14726  	p := &PullRequestMergeResult{Message: &zeroValue}
 14727  	p.GetMessage()
 14728  	p = &PullRequestMergeResult{}
 14729  	p.GetMessage()
 14730  	p = nil
 14731  	p.GetMessage()
 14732  }
 14733  
 14734  func TestPullRequestMergeResult_GetSHA(tt *testing.T) {
 14735  	var zeroValue string
 14736  	p := &PullRequestMergeResult{SHA: &zeroValue}
 14737  	p.GetSHA()
 14738  	p = &PullRequestMergeResult{}
 14739  	p.GetSHA()
 14740  	p = nil
 14741  	p.GetSHA()
 14742  }
 14743  
 14744  func TestPullRequestReview_GetAuthorAssociation(tt *testing.T) {
 14745  	var zeroValue string
 14746  	p := &PullRequestReview{AuthorAssociation: &zeroValue}
 14747  	p.GetAuthorAssociation()
 14748  	p = &PullRequestReview{}
 14749  	p.GetAuthorAssociation()
 14750  	p = nil
 14751  	p.GetAuthorAssociation()
 14752  }
 14753  
 14754  func TestPullRequestReview_GetBody(tt *testing.T) {
 14755  	var zeroValue string
 14756  	p := &PullRequestReview{Body: &zeroValue}
 14757  	p.GetBody()
 14758  	p = &PullRequestReview{}
 14759  	p.GetBody()
 14760  	p = nil
 14761  	p.GetBody()
 14762  }
 14763  
 14764  func TestPullRequestReview_GetCommitID(tt *testing.T) {
 14765  	var zeroValue string
 14766  	p := &PullRequestReview{CommitID: &zeroValue}
 14767  	p.GetCommitID()
 14768  	p = &PullRequestReview{}
 14769  	p.GetCommitID()
 14770  	p = nil
 14771  	p.GetCommitID()
 14772  }
 14773  
 14774  func TestPullRequestReview_GetHTMLURL(tt *testing.T) {
 14775  	var zeroValue string
 14776  	p := &PullRequestReview{HTMLURL: &zeroValue}
 14777  	p.GetHTMLURL()
 14778  	p = &PullRequestReview{}
 14779  	p.GetHTMLURL()
 14780  	p = nil
 14781  	p.GetHTMLURL()
 14782  }
 14783  
 14784  func TestPullRequestReview_GetID(tt *testing.T) {
 14785  	var zeroValue int64
 14786  	p := &PullRequestReview{ID: &zeroValue}
 14787  	p.GetID()
 14788  	p = &PullRequestReview{}
 14789  	p.GetID()
 14790  	p = nil
 14791  	p.GetID()
 14792  }
 14793  
 14794  func TestPullRequestReview_GetNodeID(tt *testing.T) {
 14795  	var zeroValue string
 14796  	p := &PullRequestReview{NodeID: &zeroValue}
 14797  	p.GetNodeID()
 14798  	p = &PullRequestReview{}
 14799  	p.GetNodeID()
 14800  	p = nil
 14801  	p.GetNodeID()
 14802  }
 14803  
 14804  func TestPullRequestReview_GetPullRequestURL(tt *testing.T) {
 14805  	var zeroValue string
 14806  	p := &PullRequestReview{PullRequestURL: &zeroValue}
 14807  	p.GetPullRequestURL()
 14808  	p = &PullRequestReview{}
 14809  	p.GetPullRequestURL()
 14810  	p = nil
 14811  	p.GetPullRequestURL()
 14812  }
 14813  
 14814  func TestPullRequestReview_GetState(tt *testing.T) {
 14815  	var zeroValue string
 14816  	p := &PullRequestReview{State: &zeroValue}
 14817  	p.GetState()
 14818  	p = &PullRequestReview{}
 14819  	p.GetState()
 14820  	p = nil
 14821  	p.GetState()
 14822  }
 14823  
 14824  func TestPullRequestReview_GetSubmittedAt(tt *testing.T) {
 14825  	var zeroValue time.Time
 14826  	p := &PullRequestReview{SubmittedAt: &zeroValue}
 14827  	p.GetSubmittedAt()
 14828  	p = &PullRequestReview{}
 14829  	p.GetSubmittedAt()
 14830  	p = nil
 14831  	p.GetSubmittedAt()
 14832  }
 14833  
 14834  func TestPullRequestReview_GetUser(tt *testing.T) {
 14835  	p := &PullRequestReview{}
 14836  	p.GetUser()
 14837  	p = nil
 14838  	p.GetUser()
 14839  }
 14840  
 14841  func TestPullRequestReviewCommentEvent_GetAction(tt *testing.T) {
 14842  	var zeroValue string
 14843  	p := &PullRequestReviewCommentEvent{Action: &zeroValue}
 14844  	p.GetAction()
 14845  	p = &PullRequestReviewCommentEvent{}
 14846  	p.GetAction()
 14847  	p = nil
 14848  	p.GetAction()
 14849  }
 14850  
 14851  func TestPullRequestReviewCommentEvent_GetChanges(tt *testing.T) {
 14852  	p := &PullRequestReviewCommentEvent{}
 14853  	p.GetChanges()
 14854  	p = nil
 14855  	p.GetChanges()
 14856  }
 14857  
 14858  func TestPullRequestReviewCommentEvent_GetComment(tt *testing.T) {
 14859  	p := &PullRequestReviewCommentEvent{}
 14860  	p.GetComment()
 14861  	p = nil
 14862  	p.GetComment()
 14863  }
 14864  
 14865  func TestPullRequestReviewCommentEvent_GetInstallation(tt *testing.T) {
 14866  	p := &PullRequestReviewCommentEvent{}
 14867  	p.GetInstallation()
 14868  	p = nil
 14869  	p.GetInstallation()
 14870  }
 14871  
 14872  func TestPullRequestReviewCommentEvent_GetPullRequest(tt *testing.T) {
 14873  	p := &PullRequestReviewCommentEvent{}
 14874  	p.GetPullRequest()
 14875  	p = nil
 14876  	p.GetPullRequest()
 14877  }
 14878  
 14879  func TestPullRequestReviewCommentEvent_GetRepo(tt *testing.T) {
 14880  	p := &PullRequestReviewCommentEvent{}
 14881  	p.GetRepo()
 14882  	p = nil
 14883  	p.GetRepo()
 14884  }
 14885  
 14886  func TestPullRequestReviewCommentEvent_GetSender(tt *testing.T) {
 14887  	p := &PullRequestReviewCommentEvent{}
 14888  	p.GetSender()
 14889  	p = nil
 14890  	p.GetSender()
 14891  }
 14892  
 14893  func TestPullRequestReviewDismissalRequest_GetMessage(tt *testing.T) {
 14894  	var zeroValue string
 14895  	p := &PullRequestReviewDismissalRequest{Message: &zeroValue}
 14896  	p.GetMessage()
 14897  	p = &PullRequestReviewDismissalRequest{}
 14898  	p.GetMessage()
 14899  	p = nil
 14900  	p.GetMessage()
 14901  }
 14902  
 14903  func TestPullRequestReviewEvent_GetAction(tt *testing.T) {
 14904  	var zeroValue string
 14905  	p := &PullRequestReviewEvent{Action: &zeroValue}
 14906  	p.GetAction()
 14907  	p = &PullRequestReviewEvent{}
 14908  	p.GetAction()
 14909  	p = nil
 14910  	p.GetAction()
 14911  }
 14912  
 14913  func TestPullRequestReviewEvent_GetInstallation(tt *testing.T) {
 14914  	p := &PullRequestReviewEvent{}
 14915  	p.GetInstallation()
 14916  	p = nil
 14917  	p.GetInstallation()
 14918  }
 14919  
 14920  func TestPullRequestReviewEvent_GetOrganization(tt *testing.T) {
 14921  	p := &PullRequestReviewEvent{}
 14922  	p.GetOrganization()
 14923  	p = nil
 14924  	p.GetOrganization()
 14925  }
 14926  
 14927  func TestPullRequestReviewEvent_GetPullRequest(tt *testing.T) {
 14928  	p := &PullRequestReviewEvent{}
 14929  	p.GetPullRequest()
 14930  	p = nil
 14931  	p.GetPullRequest()
 14932  }
 14933  
 14934  func TestPullRequestReviewEvent_GetRepo(tt *testing.T) {
 14935  	p := &PullRequestReviewEvent{}
 14936  	p.GetRepo()
 14937  	p = nil
 14938  	p.GetRepo()
 14939  }
 14940  
 14941  func TestPullRequestReviewEvent_GetReview(tt *testing.T) {
 14942  	p := &PullRequestReviewEvent{}
 14943  	p.GetReview()
 14944  	p = nil
 14945  	p.GetReview()
 14946  }
 14947  
 14948  func TestPullRequestReviewEvent_GetSender(tt *testing.T) {
 14949  	p := &PullRequestReviewEvent{}
 14950  	p.GetSender()
 14951  	p = nil
 14952  	p.GetSender()
 14953  }
 14954  
 14955  func TestPullRequestReviewRequest_GetBody(tt *testing.T) {
 14956  	var zeroValue string
 14957  	p := &PullRequestReviewRequest{Body: &zeroValue}
 14958  	p.GetBody()
 14959  	p = &PullRequestReviewRequest{}
 14960  	p.GetBody()
 14961  	p = nil
 14962  	p.GetBody()
 14963  }
 14964  
 14965  func TestPullRequestReviewRequest_GetCommitID(tt *testing.T) {
 14966  	var zeroValue string
 14967  	p := &PullRequestReviewRequest{CommitID: &zeroValue}
 14968  	p.GetCommitID()
 14969  	p = &PullRequestReviewRequest{}
 14970  	p.GetCommitID()
 14971  	p = nil
 14972  	p.GetCommitID()
 14973  }
 14974  
 14975  func TestPullRequestReviewRequest_GetEvent(tt *testing.T) {
 14976  	var zeroValue string
 14977  	p := &PullRequestReviewRequest{Event: &zeroValue}
 14978  	p.GetEvent()
 14979  	p = &PullRequestReviewRequest{}
 14980  	p.GetEvent()
 14981  	p = nil
 14982  	p.GetEvent()
 14983  }
 14984  
 14985  func TestPullRequestReviewRequest_GetNodeID(tt *testing.T) {
 14986  	var zeroValue string
 14987  	p := &PullRequestReviewRequest{NodeID: &zeroValue}
 14988  	p.GetNodeID()
 14989  	p = &PullRequestReviewRequest{}
 14990  	p.GetNodeID()
 14991  	p = nil
 14992  	p.GetNodeID()
 14993  }
 14994  
 14995  func TestPullRequestReviewsEnforcement_GetDismissalRestrictions(tt *testing.T) {
 14996  	p := &PullRequestReviewsEnforcement{}
 14997  	p.GetDismissalRestrictions()
 14998  	p = nil
 14999  	p.GetDismissalRestrictions()
 15000  }
 15001  
 15002  func TestPullRequestReviewsEnforcementRequest_GetDismissalRestrictionsRequest(tt *testing.T) {
 15003  	p := &PullRequestReviewsEnforcementRequest{}
 15004  	p.GetDismissalRestrictionsRequest()
 15005  	p = nil
 15006  	p.GetDismissalRestrictionsRequest()
 15007  }
 15008  
 15009  func TestPullRequestReviewsEnforcementUpdate_GetDismissalRestrictionsRequest(tt *testing.T) {
 15010  	p := &PullRequestReviewsEnforcementUpdate{}
 15011  	p.GetDismissalRestrictionsRequest()
 15012  	p = nil
 15013  	p.GetDismissalRestrictionsRequest()
 15014  }
 15015  
 15016  func TestPullRequestReviewsEnforcementUpdate_GetDismissStaleReviews(tt *testing.T) {
 15017  	var zeroValue bool
 15018  	p := &PullRequestReviewsEnforcementUpdate{DismissStaleReviews: &zeroValue}
 15019  	p.GetDismissStaleReviews()
 15020  	p = &PullRequestReviewsEnforcementUpdate{}
 15021  	p.GetDismissStaleReviews()
 15022  	p = nil
 15023  	p.GetDismissStaleReviews()
 15024  }
 15025  
 15026  func TestPullRequestReviewsEnforcementUpdate_GetRequireCodeOwnerReviews(tt *testing.T) {
 15027  	var zeroValue bool
 15028  	p := &PullRequestReviewsEnforcementUpdate{RequireCodeOwnerReviews: &zeroValue}
 15029  	p.GetRequireCodeOwnerReviews()
 15030  	p = &PullRequestReviewsEnforcementUpdate{}
 15031  	p.GetRequireCodeOwnerReviews()
 15032  	p = nil
 15033  	p.GetRequireCodeOwnerReviews()
 15034  }
 15035  
 15036  func TestPullRequestReviewThreadEvent_GetAction(tt *testing.T) {
 15037  	var zeroValue string
 15038  	p := &PullRequestReviewThreadEvent{Action: &zeroValue}
 15039  	p.GetAction()
 15040  	p = &PullRequestReviewThreadEvent{}
 15041  	p.GetAction()
 15042  	p = nil
 15043  	p.GetAction()
 15044  }
 15045  
 15046  func TestPullRequestReviewThreadEvent_GetInstallation(tt *testing.T) {
 15047  	p := &PullRequestReviewThreadEvent{}
 15048  	p.GetInstallation()
 15049  	p = nil
 15050  	p.GetInstallation()
 15051  }
 15052  
 15053  func TestPullRequestReviewThreadEvent_GetPullRequest(tt *testing.T) {
 15054  	p := &PullRequestReviewThreadEvent{}
 15055  	p.GetPullRequest()
 15056  	p = nil
 15057  	p.GetPullRequest()
 15058  }
 15059  
 15060  func TestPullRequestReviewThreadEvent_GetRepo(tt *testing.T) {
 15061  	p := &PullRequestReviewThreadEvent{}
 15062  	p.GetRepo()
 15063  	p = nil
 15064  	p.GetRepo()
 15065  }
 15066  
 15067  func TestPullRequestReviewThreadEvent_GetSender(tt *testing.T) {
 15068  	p := &PullRequestReviewThreadEvent{}
 15069  	p.GetSender()
 15070  	p = nil
 15071  	p.GetSender()
 15072  }
 15073  
 15074  func TestPullRequestReviewThreadEvent_GetThread(tt *testing.T) {
 15075  	p := &PullRequestReviewThreadEvent{}
 15076  	p.GetThread()
 15077  	p = nil
 15078  	p.GetThread()
 15079  }
 15080  
 15081  func TestPullRequestTargetEvent_GetAction(tt *testing.T) {
 15082  	var zeroValue string
 15083  	p := &PullRequestTargetEvent{Action: &zeroValue}
 15084  	p.GetAction()
 15085  	p = &PullRequestTargetEvent{}
 15086  	p.GetAction()
 15087  	p = nil
 15088  	p.GetAction()
 15089  }
 15090  
 15091  func TestPullRequestTargetEvent_GetAfter(tt *testing.T) {
 15092  	var zeroValue string
 15093  	p := &PullRequestTargetEvent{After: &zeroValue}
 15094  	p.GetAfter()
 15095  	p = &PullRequestTargetEvent{}
 15096  	p.GetAfter()
 15097  	p = nil
 15098  	p.GetAfter()
 15099  }
 15100  
 15101  func TestPullRequestTargetEvent_GetAssignee(tt *testing.T) {
 15102  	p := &PullRequestTargetEvent{}
 15103  	p.GetAssignee()
 15104  	p = nil
 15105  	p.GetAssignee()
 15106  }
 15107  
 15108  func TestPullRequestTargetEvent_GetBefore(tt *testing.T) {
 15109  	var zeroValue string
 15110  	p := &PullRequestTargetEvent{Before: &zeroValue}
 15111  	p.GetBefore()
 15112  	p = &PullRequestTargetEvent{}
 15113  	p.GetBefore()
 15114  	p = nil
 15115  	p.GetBefore()
 15116  }
 15117  
 15118  func TestPullRequestTargetEvent_GetChanges(tt *testing.T) {
 15119  	p := &PullRequestTargetEvent{}
 15120  	p.GetChanges()
 15121  	p = nil
 15122  	p.GetChanges()
 15123  }
 15124  
 15125  func TestPullRequestTargetEvent_GetInstallation(tt *testing.T) {
 15126  	p := &PullRequestTargetEvent{}
 15127  	p.GetInstallation()
 15128  	p = nil
 15129  	p.GetInstallation()
 15130  }
 15131  
 15132  func TestPullRequestTargetEvent_GetLabel(tt *testing.T) {
 15133  	p := &PullRequestTargetEvent{}
 15134  	p.GetLabel()
 15135  	p = nil
 15136  	p.GetLabel()
 15137  }
 15138  
 15139  func TestPullRequestTargetEvent_GetNumber(tt *testing.T) {
 15140  	var zeroValue int
 15141  	p := &PullRequestTargetEvent{Number: &zeroValue}
 15142  	p.GetNumber()
 15143  	p = &PullRequestTargetEvent{}
 15144  	p.GetNumber()
 15145  	p = nil
 15146  	p.GetNumber()
 15147  }
 15148  
 15149  func TestPullRequestTargetEvent_GetOrganization(tt *testing.T) {
 15150  	p := &PullRequestTargetEvent{}
 15151  	p.GetOrganization()
 15152  	p = nil
 15153  	p.GetOrganization()
 15154  }
 15155  
 15156  func TestPullRequestTargetEvent_GetPullRequest(tt *testing.T) {
 15157  	p := &PullRequestTargetEvent{}
 15158  	p.GetPullRequest()
 15159  	p = nil
 15160  	p.GetPullRequest()
 15161  }
 15162  
 15163  func TestPullRequestTargetEvent_GetRepo(tt *testing.T) {
 15164  	p := &PullRequestTargetEvent{}
 15165  	p.GetRepo()
 15166  	p = nil
 15167  	p.GetRepo()
 15168  }
 15169  
 15170  func TestPullRequestTargetEvent_GetRequestedReviewer(tt *testing.T) {
 15171  	p := &PullRequestTargetEvent{}
 15172  	p.GetRequestedReviewer()
 15173  	p = nil
 15174  	p.GetRequestedReviewer()
 15175  }
 15176  
 15177  func TestPullRequestTargetEvent_GetRequestedTeam(tt *testing.T) {
 15178  	p := &PullRequestTargetEvent{}
 15179  	p.GetRequestedTeam()
 15180  	p = nil
 15181  	p.GetRequestedTeam()
 15182  }
 15183  
 15184  func TestPullRequestTargetEvent_GetSender(tt *testing.T) {
 15185  	p := &PullRequestTargetEvent{}
 15186  	p.GetSender()
 15187  	p = nil
 15188  	p.GetSender()
 15189  }
 15190  
 15191  func TestPullRequestThread_GetID(tt *testing.T) {
 15192  	var zeroValue int64
 15193  	p := &PullRequestThread{ID: &zeroValue}
 15194  	p.GetID()
 15195  	p = &PullRequestThread{}
 15196  	p.GetID()
 15197  	p = nil
 15198  	p.GetID()
 15199  }
 15200  
 15201  func TestPullRequestThread_GetNodeID(tt *testing.T) {
 15202  	var zeroValue string
 15203  	p := &PullRequestThread{NodeID: &zeroValue}
 15204  	p.GetNodeID()
 15205  	p = &PullRequestThread{}
 15206  	p.GetNodeID()
 15207  	p = nil
 15208  	p.GetNodeID()
 15209  }
 15210  
 15211  func TestPullStats_GetMergablePulls(tt *testing.T) {
 15212  	var zeroValue int
 15213  	p := &PullStats{MergablePulls: &zeroValue}
 15214  	p.GetMergablePulls()
 15215  	p = &PullStats{}
 15216  	p.GetMergablePulls()
 15217  	p = nil
 15218  	p.GetMergablePulls()
 15219  }
 15220  
 15221  func TestPullStats_GetMergedPulls(tt *testing.T) {
 15222  	var zeroValue int
 15223  	p := &PullStats{MergedPulls: &zeroValue}
 15224  	p.GetMergedPulls()
 15225  	p = &PullStats{}
 15226  	p.GetMergedPulls()
 15227  	p = nil
 15228  	p.GetMergedPulls()
 15229  }
 15230  
 15231  func TestPullStats_GetTotalPulls(tt *testing.T) {
 15232  	var zeroValue int
 15233  	p := &PullStats{TotalPulls: &zeroValue}
 15234  	p.GetTotalPulls()
 15235  	p = &PullStats{}
 15236  	p.GetTotalPulls()
 15237  	p = nil
 15238  	p.GetTotalPulls()
 15239  }
 15240  
 15241  func TestPullStats_GetUnmergablePulls(tt *testing.T) {
 15242  	var zeroValue int
 15243  	p := &PullStats{UnmergablePulls: &zeroValue}
 15244  	p.GetUnmergablePulls()
 15245  	p = &PullStats{}
 15246  	p.GetUnmergablePulls()
 15247  	p = nil
 15248  	p.GetUnmergablePulls()
 15249  }
 15250  
 15251  func TestPunchCard_GetCommits(tt *testing.T) {
 15252  	var zeroValue int
 15253  	p := &PunchCard{Commits: &zeroValue}
 15254  	p.GetCommits()
 15255  	p = &PunchCard{}
 15256  	p.GetCommits()
 15257  	p = nil
 15258  	p.GetCommits()
 15259  }
 15260  
 15261  func TestPunchCard_GetDay(tt *testing.T) {
 15262  	var zeroValue int
 15263  	p := &PunchCard{Day: &zeroValue}
 15264  	p.GetDay()
 15265  	p = &PunchCard{}
 15266  	p.GetDay()
 15267  	p = nil
 15268  	p.GetDay()
 15269  }
 15270  
 15271  func TestPunchCard_GetHour(tt *testing.T) {
 15272  	var zeroValue int
 15273  	p := &PunchCard{Hour: &zeroValue}
 15274  	p.GetHour()
 15275  	p = &PunchCard{}
 15276  	p.GetHour()
 15277  	p = nil
 15278  	p.GetHour()
 15279  }
 15280  
 15281  func TestPushEvent_GetAction(tt *testing.T) {
 15282  	var zeroValue string
 15283  	p := &PushEvent{Action: &zeroValue}
 15284  	p.GetAction()
 15285  	p = &PushEvent{}
 15286  	p.GetAction()
 15287  	p = nil
 15288  	p.GetAction()
 15289  }
 15290  
 15291  func TestPushEvent_GetAfter(tt *testing.T) {
 15292  	var zeroValue string
 15293  	p := &PushEvent{After: &zeroValue}
 15294  	p.GetAfter()
 15295  	p = &PushEvent{}
 15296  	p.GetAfter()
 15297  	p = nil
 15298  	p.GetAfter()
 15299  }
 15300  
 15301  func TestPushEvent_GetBaseRef(tt *testing.T) {
 15302  	var zeroValue string
 15303  	p := &PushEvent{BaseRef: &zeroValue}
 15304  	p.GetBaseRef()
 15305  	p = &PushEvent{}
 15306  	p.GetBaseRef()
 15307  	p = nil
 15308  	p.GetBaseRef()
 15309  }
 15310  
 15311  func TestPushEvent_GetBefore(tt *testing.T) {
 15312  	var zeroValue string
 15313  	p := &PushEvent{Before: &zeroValue}
 15314  	p.GetBefore()
 15315  	p = &PushEvent{}
 15316  	p.GetBefore()
 15317  	p = nil
 15318  	p.GetBefore()
 15319  }
 15320  
 15321  func TestPushEvent_GetCompare(tt *testing.T) {
 15322  	var zeroValue string
 15323  	p := &PushEvent{Compare: &zeroValue}
 15324  	p.GetCompare()
 15325  	p = &PushEvent{}
 15326  	p.GetCompare()
 15327  	p = nil
 15328  	p.GetCompare()
 15329  }
 15330  
 15331  func TestPushEvent_GetCreated(tt *testing.T) {
 15332  	var zeroValue bool
 15333  	p := &PushEvent{Created: &zeroValue}
 15334  	p.GetCreated()
 15335  	p = &PushEvent{}
 15336  	p.GetCreated()
 15337  	p = nil
 15338  	p.GetCreated()
 15339  }
 15340  
 15341  func TestPushEvent_GetDeleted(tt *testing.T) {
 15342  	var zeroValue bool
 15343  	p := &PushEvent{Deleted: &zeroValue}
 15344  	p.GetDeleted()
 15345  	p = &PushEvent{}
 15346  	p.GetDeleted()
 15347  	p = nil
 15348  	p.GetDeleted()
 15349  }
 15350  
 15351  func TestPushEvent_GetDistinctSize(tt *testing.T) {
 15352  	var zeroValue int
 15353  	p := &PushEvent{DistinctSize: &zeroValue}
 15354  	p.GetDistinctSize()
 15355  	p = &PushEvent{}
 15356  	p.GetDistinctSize()
 15357  	p = nil
 15358  	p.GetDistinctSize()
 15359  }
 15360  
 15361  func TestPushEvent_GetForced(tt *testing.T) {
 15362  	var zeroValue bool
 15363  	p := &PushEvent{Forced: &zeroValue}
 15364  	p.GetForced()
 15365  	p = &PushEvent{}
 15366  	p.GetForced()
 15367  	p = nil
 15368  	p.GetForced()
 15369  }
 15370  
 15371  func TestPushEvent_GetHead(tt *testing.T) {
 15372  	var zeroValue string
 15373  	p := &PushEvent{Head: &zeroValue}
 15374  	p.GetHead()
 15375  	p = &PushEvent{}
 15376  	p.GetHead()
 15377  	p = nil
 15378  	p.GetHead()
 15379  }
 15380  
 15381  func TestPushEvent_GetHeadCommit(tt *testing.T) {
 15382  	p := &PushEvent{}
 15383  	p.GetHeadCommit()
 15384  	p = nil
 15385  	p.GetHeadCommit()
 15386  }
 15387  
 15388  func TestPushEvent_GetInstallation(tt *testing.T) {
 15389  	p := &PushEvent{}
 15390  	p.GetInstallation()
 15391  	p = nil
 15392  	p.GetInstallation()
 15393  }
 15394  
 15395  func TestPushEvent_GetOrganization(tt *testing.T) {
 15396  	p := &PushEvent{}
 15397  	p.GetOrganization()
 15398  	p = nil
 15399  	p.GetOrganization()
 15400  }
 15401  
 15402  func TestPushEvent_GetPusher(tt *testing.T) {
 15403  	p := &PushEvent{}
 15404  	p.GetPusher()
 15405  	p = nil
 15406  	p.GetPusher()
 15407  }
 15408  
 15409  func TestPushEvent_GetPushID(tt *testing.T) {
 15410  	var zeroValue int64
 15411  	p := &PushEvent{PushID: &zeroValue}
 15412  	p.GetPushID()
 15413  	p = &PushEvent{}
 15414  	p.GetPushID()
 15415  	p = nil
 15416  	p.GetPushID()
 15417  }
 15418  
 15419  func TestPushEvent_GetRef(tt *testing.T) {
 15420  	var zeroValue string
 15421  	p := &PushEvent{Ref: &zeroValue}
 15422  	p.GetRef()
 15423  	p = &PushEvent{}
 15424  	p.GetRef()
 15425  	p = nil
 15426  	p.GetRef()
 15427  }
 15428  
 15429  func TestPushEvent_GetRepo(tt *testing.T) {
 15430  	p := &PushEvent{}
 15431  	p.GetRepo()
 15432  	p = nil
 15433  	p.GetRepo()
 15434  }
 15435  
 15436  func TestPushEvent_GetSender(tt *testing.T) {
 15437  	p := &PushEvent{}
 15438  	p.GetSender()
 15439  	p = nil
 15440  	p.GetSender()
 15441  }
 15442  
 15443  func TestPushEvent_GetSize(tt *testing.T) {
 15444  	var zeroValue int
 15445  	p := &PushEvent{Size: &zeroValue}
 15446  	p.GetSize()
 15447  	p = &PushEvent{}
 15448  	p.GetSize()
 15449  	p = nil
 15450  	p.GetSize()
 15451  }
 15452  
 15453  func TestPushEventRepoOwner_GetEmail(tt *testing.T) {
 15454  	var zeroValue string
 15455  	p := &PushEventRepoOwner{Email: &zeroValue}
 15456  	p.GetEmail()
 15457  	p = &PushEventRepoOwner{}
 15458  	p.GetEmail()
 15459  	p = nil
 15460  	p.GetEmail()
 15461  }
 15462  
 15463  func TestPushEventRepoOwner_GetName(tt *testing.T) {
 15464  	var zeroValue string
 15465  	p := &PushEventRepoOwner{Name: &zeroValue}
 15466  	p.GetName()
 15467  	p = &PushEventRepoOwner{}
 15468  	p.GetName()
 15469  	p = nil
 15470  	p.GetName()
 15471  }
 15472  
 15473  func TestPushEventRepository_GetArchived(tt *testing.T) {
 15474  	var zeroValue bool
 15475  	p := &PushEventRepository{Archived: &zeroValue}
 15476  	p.GetArchived()
 15477  	p = &PushEventRepository{}
 15478  	p.GetArchived()
 15479  	p = nil
 15480  	p.GetArchived()
 15481  }
 15482  
 15483  func TestPushEventRepository_GetArchiveURL(tt *testing.T) {
 15484  	var zeroValue string
 15485  	p := &PushEventRepository{ArchiveURL: &zeroValue}
 15486  	p.GetArchiveURL()
 15487  	p = &PushEventRepository{}
 15488  	p.GetArchiveURL()
 15489  	p = nil
 15490  	p.GetArchiveURL()
 15491  }
 15492  
 15493  func TestPushEventRepository_GetCloneURL(tt *testing.T) {
 15494  	var zeroValue string
 15495  	p := &PushEventRepository{CloneURL: &zeroValue}
 15496  	p.GetCloneURL()
 15497  	p = &PushEventRepository{}
 15498  	p.GetCloneURL()
 15499  	p = nil
 15500  	p.GetCloneURL()
 15501  }
 15502  
 15503  func TestPushEventRepository_GetCreatedAt(tt *testing.T) {
 15504  	var zeroValue Timestamp
 15505  	p := &PushEventRepository{CreatedAt: &zeroValue}
 15506  	p.GetCreatedAt()
 15507  	p = &PushEventRepository{}
 15508  	p.GetCreatedAt()
 15509  	p = nil
 15510  	p.GetCreatedAt()
 15511  }
 15512  
 15513  func TestPushEventRepository_GetDefaultBranch(tt *testing.T) {
 15514  	var zeroValue string
 15515  	p := &PushEventRepository{DefaultBranch: &zeroValue}
 15516  	p.GetDefaultBranch()
 15517  	p = &PushEventRepository{}
 15518  	p.GetDefaultBranch()
 15519  	p = nil
 15520  	p.GetDefaultBranch()
 15521  }
 15522  
 15523  func TestPushEventRepository_GetDescription(tt *testing.T) {
 15524  	var zeroValue string
 15525  	p := &PushEventRepository{Description: &zeroValue}
 15526  	p.GetDescription()
 15527  	p = &PushEventRepository{}
 15528  	p.GetDescription()
 15529  	p = nil
 15530  	p.GetDescription()
 15531  }
 15532  
 15533  func TestPushEventRepository_GetDisabled(tt *testing.T) {
 15534  	var zeroValue bool
 15535  	p := &PushEventRepository{Disabled: &zeroValue}
 15536  	p.GetDisabled()
 15537  	p = &PushEventRepository{}
 15538  	p.GetDisabled()
 15539  	p = nil
 15540  	p.GetDisabled()
 15541  }
 15542  
 15543  func TestPushEventRepository_GetFork(tt *testing.T) {
 15544  	var zeroValue bool
 15545  	p := &PushEventRepository{Fork: &zeroValue}
 15546  	p.GetFork()
 15547  	p = &PushEventRepository{}
 15548  	p.GetFork()
 15549  	p = nil
 15550  	p.GetFork()
 15551  }
 15552  
 15553  func TestPushEventRepository_GetForksCount(tt *testing.T) {
 15554  	var zeroValue int
 15555  	p := &PushEventRepository{ForksCount: &zeroValue}
 15556  	p.GetForksCount()
 15557  	p = &PushEventRepository{}
 15558  	p.GetForksCount()
 15559  	p = nil
 15560  	p.GetForksCount()
 15561  }
 15562  
 15563  func TestPushEventRepository_GetFullName(tt *testing.T) {
 15564  	var zeroValue string
 15565  	p := &PushEventRepository{FullName: &zeroValue}
 15566  	p.GetFullName()
 15567  	p = &PushEventRepository{}
 15568  	p.GetFullName()
 15569  	p = nil
 15570  	p.GetFullName()
 15571  }
 15572  
 15573  func TestPushEventRepository_GetGitURL(tt *testing.T) {
 15574  	var zeroValue string
 15575  	p := &PushEventRepository{GitURL: &zeroValue}
 15576  	p.GetGitURL()
 15577  	p = &PushEventRepository{}
 15578  	p.GetGitURL()
 15579  	p = nil
 15580  	p.GetGitURL()
 15581  }
 15582  
 15583  func TestPushEventRepository_GetHasDownloads(tt *testing.T) {
 15584  	var zeroValue bool
 15585  	p := &PushEventRepository{HasDownloads: &zeroValue}
 15586  	p.GetHasDownloads()
 15587  	p = &PushEventRepository{}
 15588  	p.GetHasDownloads()
 15589  	p = nil
 15590  	p.GetHasDownloads()
 15591  }
 15592  
 15593  func TestPushEventRepository_GetHasIssues(tt *testing.T) {
 15594  	var zeroValue bool
 15595  	p := &PushEventRepository{HasIssues: &zeroValue}
 15596  	p.GetHasIssues()
 15597  	p = &PushEventRepository{}
 15598  	p.GetHasIssues()
 15599  	p = nil
 15600  	p.GetHasIssues()
 15601  }
 15602  
 15603  func TestPushEventRepository_GetHasPages(tt *testing.T) {
 15604  	var zeroValue bool
 15605  	p := &PushEventRepository{HasPages: &zeroValue}
 15606  	p.GetHasPages()
 15607  	p = &PushEventRepository{}
 15608  	p.GetHasPages()
 15609  	p = nil
 15610  	p.GetHasPages()
 15611  }
 15612  
 15613  func TestPushEventRepository_GetHasWiki(tt *testing.T) {
 15614  	var zeroValue bool
 15615  	p := &PushEventRepository{HasWiki: &zeroValue}
 15616  	p.GetHasWiki()
 15617  	p = &PushEventRepository{}
 15618  	p.GetHasWiki()
 15619  	p = nil
 15620  	p.GetHasWiki()
 15621  }
 15622  
 15623  func TestPushEventRepository_GetHomepage(tt *testing.T) {
 15624  	var zeroValue string
 15625  	p := &PushEventRepository{Homepage: &zeroValue}
 15626  	p.GetHomepage()
 15627  	p = &PushEventRepository{}
 15628  	p.GetHomepage()
 15629  	p = nil
 15630  	p.GetHomepage()
 15631  }
 15632  
 15633  func TestPushEventRepository_GetHTMLURL(tt *testing.T) {
 15634  	var zeroValue string
 15635  	p := &PushEventRepository{HTMLURL: &zeroValue}
 15636  	p.GetHTMLURL()
 15637  	p = &PushEventRepository{}
 15638  	p.GetHTMLURL()
 15639  	p = nil
 15640  	p.GetHTMLURL()
 15641  }
 15642  
 15643  func TestPushEventRepository_GetID(tt *testing.T) {
 15644  	var zeroValue int64
 15645  	p := &PushEventRepository{ID: &zeroValue}
 15646  	p.GetID()
 15647  	p = &PushEventRepository{}
 15648  	p.GetID()
 15649  	p = nil
 15650  	p.GetID()
 15651  }
 15652  
 15653  func TestPushEventRepository_GetLanguage(tt *testing.T) {
 15654  	var zeroValue string
 15655  	p := &PushEventRepository{Language: &zeroValue}
 15656  	p.GetLanguage()
 15657  	p = &PushEventRepository{}
 15658  	p.GetLanguage()
 15659  	p = nil
 15660  	p.GetLanguage()
 15661  }
 15662  
 15663  func TestPushEventRepository_GetMasterBranch(tt *testing.T) {
 15664  	var zeroValue string
 15665  	p := &PushEventRepository{MasterBranch: &zeroValue}
 15666  	p.GetMasterBranch()
 15667  	p = &PushEventRepository{}
 15668  	p.GetMasterBranch()
 15669  	p = nil
 15670  	p.GetMasterBranch()
 15671  }
 15672  
 15673  func TestPushEventRepository_GetName(tt *testing.T) {
 15674  	var zeroValue string
 15675  	p := &PushEventRepository{Name: &zeroValue}
 15676  	p.GetName()
 15677  	p = &PushEventRepository{}
 15678  	p.GetName()
 15679  	p = nil
 15680  	p.GetName()
 15681  }
 15682  
 15683  func TestPushEventRepository_GetNodeID(tt *testing.T) {
 15684  	var zeroValue string
 15685  	p := &PushEventRepository{NodeID: &zeroValue}
 15686  	p.GetNodeID()
 15687  	p = &PushEventRepository{}
 15688  	p.GetNodeID()
 15689  	p = nil
 15690  	p.GetNodeID()
 15691  }
 15692  
 15693  func TestPushEventRepository_GetOpenIssuesCount(tt *testing.T) {
 15694  	var zeroValue int
 15695  	p := &PushEventRepository{OpenIssuesCount: &zeroValue}
 15696  	p.GetOpenIssuesCount()
 15697  	p = &PushEventRepository{}
 15698  	p.GetOpenIssuesCount()
 15699  	p = nil
 15700  	p.GetOpenIssuesCount()
 15701  }
 15702  
 15703  func TestPushEventRepository_GetOrganization(tt *testing.T) {
 15704  	var zeroValue string
 15705  	p := &PushEventRepository{Organization: &zeroValue}
 15706  	p.GetOrganization()
 15707  	p = &PushEventRepository{}
 15708  	p.GetOrganization()
 15709  	p = nil
 15710  	p.GetOrganization()
 15711  }
 15712  
 15713  func TestPushEventRepository_GetOwner(tt *testing.T) {
 15714  	p := &PushEventRepository{}
 15715  	p.GetOwner()
 15716  	p = nil
 15717  	p.GetOwner()
 15718  }
 15719  
 15720  func TestPushEventRepository_GetPrivate(tt *testing.T) {
 15721  	var zeroValue bool
 15722  	p := &PushEventRepository{Private: &zeroValue}
 15723  	p.GetPrivate()
 15724  	p = &PushEventRepository{}
 15725  	p.GetPrivate()
 15726  	p = nil
 15727  	p.GetPrivate()
 15728  }
 15729  
 15730  func TestPushEventRepository_GetPullsURL(tt *testing.T) {
 15731  	var zeroValue string
 15732  	p := &PushEventRepository{PullsURL: &zeroValue}
 15733  	p.GetPullsURL()
 15734  	p = &PushEventRepository{}
 15735  	p.GetPullsURL()
 15736  	p = nil
 15737  	p.GetPullsURL()
 15738  }
 15739  
 15740  func TestPushEventRepository_GetPushedAt(tt *testing.T) {
 15741  	var zeroValue Timestamp
 15742  	p := &PushEventRepository{PushedAt: &zeroValue}
 15743  	p.GetPushedAt()
 15744  	p = &PushEventRepository{}
 15745  	p.GetPushedAt()
 15746  	p = nil
 15747  	p.GetPushedAt()
 15748  }
 15749  
 15750  func TestPushEventRepository_GetSize(tt *testing.T) {
 15751  	var zeroValue int
 15752  	p := &PushEventRepository{Size: &zeroValue}
 15753  	p.GetSize()
 15754  	p = &PushEventRepository{}
 15755  	p.GetSize()
 15756  	p = nil
 15757  	p.GetSize()
 15758  }
 15759  
 15760  func TestPushEventRepository_GetSSHURL(tt *testing.T) {
 15761  	var zeroValue string
 15762  	p := &PushEventRepository{SSHURL: &zeroValue}
 15763  	p.GetSSHURL()
 15764  	p = &PushEventRepository{}
 15765  	p.GetSSHURL()
 15766  	p = nil
 15767  	p.GetSSHURL()
 15768  }
 15769  
 15770  func TestPushEventRepository_GetStargazersCount(tt *testing.T) {
 15771  	var zeroValue int
 15772  	p := &PushEventRepository{StargazersCount: &zeroValue}
 15773  	p.GetStargazersCount()
 15774  	p = &PushEventRepository{}
 15775  	p.GetStargazersCount()
 15776  	p = nil
 15777  	p.GetStargazersCount()
 15778  }
 15779  
 15780  func TestPushEventRepository_GetStatusesURL(tt *testing.T) {
 15781  	var zeroValue string
 15782  	p := &PushEventRepository{StatusesURL: &zeroValue}
 15783  	p.GetStatusesURL()
 15784  	p = &PushEventRepository{}
 15785  	p.GetStatusesURL()
 15786  	p = nil
 15787  	p.GetStatusesURL()
 15788  }
 15789  
 15790  func TestPushEventRepository_GetSVNURL(tt *testing.T) {
 15791  	var zeroValue string
 15792  	p := &PushEventRepository{SVNURL: &zeroValue}
 15793  	p.GetSVNURL()
 15794  	p = &PushEventRepository{}
 15795  	p.GetSVNURL()
 15796  	p = nil
 15797  	p.GetSVNURL()
 15798  }
 15799  
 15800  func TestPushEventRepository_GetUpdatedAt(tt *testing.T) {
 15801  	var zeroValue Timestamp
 15802  	p := &PushEventRepository{UpdatedAt: &zeroValue}
 15803  	p.GetUpdatedAt()
 15804  	p = &PushEventRepository{}
 15805  	p.GetUpdatedAt()
 15806  	p = nil
 15807  	p.GetUpdatedAt()
 15808  }
 15809  
 15810  func TestPushEventRepository_GetURL(tt *testing.T) {
 15811  	var zeroValue string
 15812  	p := &PushEventRepository{URL: &zeroValue}
 15813  	p.GetURL()
 15814  	p = &PushEventRepository{}
 15815  	p.GetURL()
 15816  	p = nil
 15817  	p.GetURL()
 15818  }
 15819  
 15820  func TestPushEventRepository_GetWatchersCount(tt *testing.T) {
 15821  	var zeroValue int
 15822  	p := &PushEventRepository{WatchersCount: &zeroValue}
 15823  	p.GetWatchersCount()
 15824  	p = &PushEventRepository{}
 15825  	p.GetWatchersCount()
 15826  	p = nil
 15827  	p.GetWatchersCount()
 15828  }
 15829  
 15830  func TestRateLimits_GetActionsRunnerRegistration(tt *testing.T) {
 15831  	r := &RateLimits{}
 15832  	r.GetActionsRunnerRegistration()
 15833  	r = nil
 15834  	r.GetActionsRunnerRegistration()
 15835  }
 15836  
 15837  func TestRateLimits_GetCodeScanningUpload(tt *testing.T) {
 15838  	r := &RateLimits{}
 15839  	r.GetCodeScanningUpload()
 15840  	r = nil
 15841  	r.GetCodeScanningUpload()
 15842  }
 15843  
 15844  func TestRateLimits_GetCore(tt *testing.T) {
 15845  	r := &RateLimits{}
 15846  	r.GetCore()
 15847  	r = nil
 15848  	r.GetCore()
 15849  }
 15850  
 15851  func TestRateLimits_GetGraphQL(tt *testing.T) {
 15852  	r := &RateLimits{}
 15853  	r.GetGraphQL()
 15854  	r = nil
 15855  	r.GetGraphQL()
 15856  }
 15857  
 15858  func TestRateLimits_GetIntegrationManifest(tt *testing.T) {
 15859  	r := &RateLimits{}
 15860  	r.GetIntegrationManifest()
 15861  	r = nil
 15862  	r.GetIntegrationManifest()
 15863  }
 15864  
 15865  func TestRateLimits_GetSCIM(tt *testing.T) {
 15866  	r := &RateLimits{}
 15867  	r.GetSCIM()
 15868  	r = nil
 15869  	r.GetSCIM()
 15870  }
 15871  
 15872  func TestRateLimits_GetSearch(tt *testing.T) {
 15873  	r := &RateLimits{}
 15874  	r.GetSearch()
 15875  	r = nil
 15876  	r.GetSearch()
 15877  }
 15878  
 15879  func TestRateLimits_GetSourceImport(tt *testing.T) {
 15880  	r := &RateLimits{}
 15881  	r.GetSourceImport()
 15882  	r = nil
 15883  	r.GetSourceImport()
 15884  }
 15885  
 15886  func TestReaction_GetContent(tt *testing.T) {
 15887  	var zeroValue string
 15888  	r := &Reaction{Content: &zeroValue}
 15889  	r.GetContent()
 15890  	r = &Reaction{}
 15891  	r.GetContent()
 15892  	r = nil
 15893  	r.GetContent()
 15894  }
 15895  
 15896  func TestReaction_GetID(tt *testing.T) {
 15897  	var zeroValue int64
 15898  	r := &Reaction{ID: &zeroValue}
 15899  	r.GetID()
 15900  	r = &Reaction{}
 15901  	r.GetID()
 15902  	r = nil
 15903  	r.GetID()
 15904  }
 15905  
 15906  func TestReaction_GetNodeID(tt *testing.T) {
 15907  	var zeroValue string
 15908  	r := &Reaction{NodeID: &zeroValue}
 15909  	r.GetNodeID()
 15910  	r = &Reaction{}
 15911  	r.GetNodeID()
 15912  	r = nil
 15913  	r.GetNodeID()
 15914  }
 15915  
 15916  func TestReaction_GetUser(tt *testing.T) {
 15917  	r := &Reaction{}
 15918  	r.GetUser()
 15919  	r = nil
 15920  	r.GetUser()
 15921  }
 15922  
 15923  func TestReactions_GetConfused(tt *testing.T) {
 15924  	var zeroValue int
 15925  	r := &Reactions{Confused: &zeroValue}
 15926  	r.GetConfused()
 15927  	r = &Reactions{}
 15928  	r.GetConfused()
 15929  	r = nil
 15930  	r.GetConfused()
 15931  }
 15932  
 15933  func TestReactions_GetEyes(tt *testing.T) {
 15934  	var zeroValue int
 15935  	r := &Reactions{Eyes: &zeroValue}
 15936  	r.GetEyes()
 15937  	r = &Reactions{}
 15938  	r.GetEyes()
 15939  	r = nil
 15940  	r.GetEyes()
 15941  }
 15942  
 15943  func TestReactions_GetHeart(tt *testing.T) {
 15944  	var zeroValue int
 15945  	r := &Reactions{Heart: &zeroValue}
 15946  	r.GetHeart()
 15947  	r = &Reactions{}
 15948  	r.GetHeart()
 15949  	r = nil
 15950  	r.GetHeart()
 15951  }
 15952  
 15953  func TestReactions_GetHooray(tt *testing.T) {
 15954  	var zeroValue int
 15955  	r := &Reactions{Hooray: &zeroValue}
 15956  	r.GetHooray()
 15957  	r = &Reactions{}
 15958  	r.GetHooray()
 15959  	r = nil
 15960  	r.GetHooray()
 15961  }
 15962  
 15963  func TestReactions_GetLaugh(tt *testing.T) {
 15964  	var zeroValue int
 15965  	r := &Reactions{Laugh: &zeroValue}
 15966  	r.GetLaugh()
 15967  	r = &Reactions{}
 15968  	r.GetLaugh()
 15969  	r = nil
 15970  	r.GetLaugh()
 15971  }
 15972  
 15973  func TestReactions_GetMinusOne(tt *testing.T) {
 15974  	var zeroValue int
 15975  	r := &Reactions{MinusOne: &zeroValue}
 15976  	r.GetMinusOne()
 15977  	r = &Reactions{}
 15978  	r.GetMinusOne()
 15979  	r = nil
 15980  	r.GetMinusOne()
 15981  }
 15982  
 15983  func TestReactions_GetPlusOne(tt *testing.T) {
 15984  	var zeroValue int
 15985  	r := &Reactions{PlusOne: &zeroValue}
 15986  	r.GetPlusOne()
 15987  	r = &Reactions{}
 15988  	r.GetPlusOne()
 15989  	r = nil
 15990  	r.GetPlusOne()
 15991  }
 15992  
 15993  func TestReactions_GetRocket(tt *testing.T) {
 15994  	var zeroValue int
 15995  	r := &Reactions{Rocket: &zeroValue}
 15996  	r.GetRocket()
 15997  	r = &Reactions{}
 15998  	r.GetRocket()
 15999  	r = nil
 16000  	r.GetRocket()
 16001  }
 16002  
 16003  func TestReactions_GetTotalCount(tt *testing.T) {
 16004  	var zeroValue int
 16005  	r := &Reactions{TotalCount: &zeroValue}
 16006  	r.GetTotalCount()
 16007  	r = &Reactions{}
 16008  	r.GetTotalCount()
 16009  	r = nil
 16010  	r.GetTotalCount()
 16011  }
 16012  
 16013  func TestReactions_GetURL(tt *testing.T) {
 16014  	var zeroValue string
 16015  	r := &Reactions{URL: &zeroValue}
 16016  	r.GetURL()
 16017  	r = &Reactions{}
 16018  	r.GetURL()
 16019  	r = nil
 16020  	r.GetURL()
 16021  }
 16022  
 16023  func TestReference_GetNodeID(tt *testing.T) {
 16024  	var zeroValue string
 16025  	r := &Reference{NodeID: &zeroValue}
 16026  	r.GetNodeID()
 16027  	r = &Reference{}
 16028  	r.GetNodeID()
 16029  	r = nil
 16030  	r.GetNodeID()
 16031  }
 16032  
 16033  func TestReference_GetObject(tt *testing.T) {
 16034  	r := &Reference{}
 16035  	r.GetObject()
 16036  	r = nil
 16037  	r.GetObject()
 16038  }
 16039  
 16040  func TestReference_GetRef(tt *testing.T) {
 16041  	var zeroValue string
 16042  	r := &Reference{Ref: &zeroValue}
 16043  	r.GetRef()
 16044  	r = &Reference{}
 16045  	r.GetRef()
 16046  	r = nil
 16047  	r.GetRef()
 16048  }
 16049  
 16050  func TestReference_GetURL(tt *testing.T) {
 16051  	var zeroValue string
 16052  	r := &Reference{URL: &zeroValue}
 16053  	r.GetURL()
 16054  	r = &Reference{}
 16055  	r.GetURL()
 16056  	r = nil
 16057  	r.GetURL()
 16058  }
 16059  
 16060  func TestRegistrationToken_GetExpiresAt(tt *testing.T) {
 16061  	var zeroValue Timestamp
 16062  	r := &RegistrationToken{ExpiresAt: &zeroValue}
 16063  	r.GetExpiresAt()
 16064  	r = &RegistrationToken{}
 16065  	r.GetExpiresAt()
 16066  	r = nil
 16067  	r.GetExpiresAt()
 16068  }
 16069  
 16070  func TestRegistrationToken_GetToken(tt *testing.T) {
 16071  	var zeroValue string
 16072  	r := &RegistrationToken{Token: &zeroValue}
 16073  	r.GetToken()
 16074  	r = &RegistrationToken{}
 16075  	r.GetToken()
 16076  	r = nil
 16077  	r.GetToken()
 16078  }
 16079  
 16080  func TestReleaseAsset_GetBrowserDownloadURL(tt *testing.T) {
 16081  	var zeroValue string
 16082  	r := &ReleaseAsset{BrowserDownloadURL: &zeroValue}
 16083  	r.GetBrowserDownloadURL()
 16084  	r = &ReleaseAsset{}
 16085  	r.GetBrowserDownloadURL()
 16086  	r = nil
 16087  	r.GetBrowserDownloadURL()
 16088  }
 16089  
 16090  func TestReleaseAsset_GetContentType(tt *testing.T) {
 16091  	var zeroValue string
 16092  	r := &ReleaseAsset{ContentType: &zeroValue}
 16093  	r.GetContentType()
 16094  	r = &ReleaseAsset{}
 16095  	r.GetContentType()
 16096  	r = nil
 16097  	r.GetContentType()
 16098  }
 16099  
 16100  func TestReleaseAsset_GetCreatedAt(tt *testing.T) {
 16101  	var zeroValue Timestamp
 16102  	r := &ReleaseAsset{CreatedAt: &zeroValue}
 16103  	r.GetCreatedAt()
 16104  	r = &ReleaseAsset{}
 16105  	r.GetCreatedAt()
 16106  	r = nil
 16107  	r.GetCreatedAt()
 16108  }
 16109  
 16110  func TestReleaseAsset_GetDownloadCount(tt *testing.T) {
 16111  	var zeroValue int
 16112  	r := &ReleaseAsset{DownloadCount: &zeroValue}
 16113  	r.GetDownloadCount()
 16114  	r = &ReleaseAsset{}
 16115  	r.GetDownloadCount()
 16116  	r = nil
 16117  	r.GetDownloadCount()
 16118  }
 16119  
 16120  func TestReleaseAsset_GetID(tt *testing.T) {
 16121  	var zeroValue int64
 16122  	r := &ReleaseAsset{ID: &zeroValue}
 16123  	r.GetID()
 16124  	r = &ReleaseAsset{}
 16125  	r.GetID()
 16126  	r = nil
 16127  	r.GetID()
 16128  }
 16129  
 16130  func TestReleaseAsset_GetLabel(tt *testing.T) {
 16131  	var zeroValue string
 16132  	r := &ReleaseAsset{Label: &zeroValue}
 16133  	r.GetLabel()
 16134  	r = &ReleaseAsset{}
 16135  	r.GetLabel()
 16136  	r = nil
 16137  	r.GetLabel()
 16138  }
 16139  
 16140  func TestReleaseAsset_GetName(tt *testing.T) {
 16141  	var zeroValue string
 16142  	r := &ReleaseAsset{Name: &zeroValue}
 16143  	r.GetName()
 16144  	r = &ReleaseAsset{}
 16145  	r.GetName()
 16146  	r = nil
 16147  	r.GetName()
 16148  }
 16149  
 16150  func TestReleaseAsset_GetNodeID(tt *testing.T) {
 16151  	var zeroValue string
 16152  	r := &ReleaseAsset{NodeID: &zeroValue}
 16153  	r.GetNodeID()
 16154  	r = &ReleaseAsset{}
 16155  	r.GetNodeID()
 16156  	r = nil
 16157  	r.GetNodeID()
 16158  }
 16159  
 16160  func TestReleaseAsset_GetSize(tt *testing.T) {
 16161  	var zeroValue int
 16162  	r := &ReleaseAsset{Size: &zeroValue}
 16163  	r.GetSize()
 16164  	r = &ReleaseAsset{}
 16165  	r.GetSize()
 16166  	r = nil
 16167  	r.GetSize()
 16168  }
 16169  
 16170  func TestReleaseAsset_GetState(tt *testing.T) {
 16171  	var zeroValue string
 16172  	r := &ReleaseAsset{State: &zeroValue}
 16173  	r.GetState()
 16174  	r = &ReleaseAsset{}
 16175  	r.GetState()
 16176  	r = nil
 16177  	r.GetState()
 16178  }
 16179  
 16180  func TestReleaseAsset_GetUpdatedAt(tt *testing.T) {
 16181  	var zeroValue Timestamp
 16182  	r := &ReleaseAsset{UpdatedAt: &zeroValue}
 16183  	r.GetUpdatedAt()
 16184  	r = &ReleaseAsset{}
 16185  	r.GetUpdatedAt()
 16186  	r = nil
 16187  	r.GetUpdatedAt()
 16188  }
 16189  
 16190  func TestReleaseAsset_GetUploader(tt *testing.T) {
 16191  	r := &ReleaseAsset{}
 16192  	r.GetUploader()
 16193  	r = nil
 16194  	r.GetUploader()
 16195  }
 16196  
 16197  func TestReleaseAsset_GetURL(tt *testing.T) {
 16198  	var zeroValue string
 16199  	r := &ReleaseAsset{URL: &zeroValue}
 16200  	r.GetURL()
 16201  	r = &ReleaseAsset{}
 16202  	r.GetURL()
 16203  	r = nil
 16204  	r.GetURL()
 16205  }
 16206  
 16207  func TestReleaseEvent_GetAction(tt *testing.T) {
 16208  	var zeroValue string
 16209  	r := &ReleaseEvent{Action: &zeroValue}
 16210  	r.GetAction()
 16211  	r = &ReleaseEvent{}
 16212  	r.GetAction()
 16213  	r = nil
 16214  	r.GetAction()
 16215  }
 16216  
 16217  func TestReleaseEvent_GetInstallation(tt *testing.T) {
 16218  	r := &ReleaseEvent{}
 16219  	r.GetInstallation()
 16220  	r = nil
 16221  	r.GetInstallation()
 16222  }
 16223  
 16224  func TestReleaseEvent_GetRelease(tt *testing.T) {
 16225  	r := &ReleaseEvent{}
 16226  	r.GetRelease()
 16227  	r = nil
 16228  	r.GetRelease()
 16229  }
 16230  
 16231  func TestReleaseEvent_GetRepo(tt *testing.T) {
 16232  	r := &ReleaseEvent{}
 16233  	r.GetRepo()
 16234  	r = nil
 16235  	r.GetRepo()
 16236  }
 16237  
 16238  func TestReleaseEvent_GetSender(tt *testing.T) {
 16239  	r := &ReleaseEvent{}
 16240  	r.GetSender()
 16241  	r = nil
 16242  	r.GetSender()
 16243  }
 16244  
 16245  func TestRemoveToken_GetExpiresAt(tt *testing.T) {
 16246  	var zeroValue Timestamp
 16247  	r := &RemoveToken{ExpiresAt: &zeroValue}
 16248  	r.GetExpiresAt()
 16249  	r = &RemoveToken{}
 16250  	r.GetExpiresAt()
 16251  	r = nil
 16252  	r.GetExpiresAt()
 16253  }
 16254  
 16255  func TestRemoveToken_GetToken(tt *testing.T) {
 16256  	var zeroValue string
 16257  	r := &RemoveToken{Token: &zeroValue}
 16258  	r.GetToken()
 16259  	r = &RemoveToken{}
 16260  	r.GetToken()
 16261  	r = nil
 16262  	r.GetToken()
 16263  }
 16264  
 16265  func TestRename_GetFrom(tt *testing.T) {
 16266  	var zeroValue string
 16267  	r := &Rename{From: &zeroValue}
 16268  	r.GetFrom()
 16269  	r = &Rename{}
 16270  	r.GetFrom()
 16271  	r = nil
 16272  	r.GetFrom()
 16273  }
 16274  
 16275  func TestRename_GetTo(tt *testing.T) {
 16276  	var zeroValue string
 16277  	r := &Rename{To: &zeroValue}
 16278  	r.GetTo()
 16279  	r = &Rename{}
 16280  	r.GetTo()
 16281  	r = nil
 16282  	r.GetTo()
 16283  }
 16284  
 16285  func TestRenameOrgResponse_GetMessage(tt *testing.T) {
 16286  	var zeroValue string
 16287  	r := &RenameOrgResponse{Message: &zeroValue}
 16288  	r.GetMessage()
 16289  	r = &RenameOrgResponse{}
 16290  	r.GetMessage()
 16291  	r = nil
 16292  	r.GetMessage()
 16293  }
 16294  
 16295  func TestRenameOrgResponse_GetURL(tt *testing.T) {
 16296  	var zeroValue string
 16297  	r := &RenameOrgResponse{URL: &zeroValue}
 16298  	r.GetURL()
 16299  	r = &RenameOrgResponse{}
 16300  	r.GetURL()
 16301  	r = nil
 16302  	r.GetURL()
 16303  }
 16304  
 16305  func TestRepoMergeUpstreamRequest_GetBranch(tt *testing.T) {
 16306  	var zeroValue string
 16307  	r := &RepoMergeUpstreamRequest{Branch: &zeroValue}
 16308  	r.GetBranch()
 16309  	r = &RepoMergeUpstreamRequest{}
 16310  	r.GetBranch()
 16311  	r = nil
 16312  	r.GetBranch()
 16313  }
 16314  
 16315  func TestRepoMergeUpstreamResult_GetBaseBranch(tt *testing.T) {
 16316  	var zeroValue string
 16317  	r := &RepoMergeUpstreamResult{BaseBranch: &zeroValue}
 16318  	r.GetBaseBranch()
 16319  	r = &RepoMergeUpstreamResult{}
 16320  	r.GetBaseBranch()
 16321  	r = nil
 16322  	r.GetBaseBranch()
 16323  }
 16324  
 16325  func TestRepoMergeUpstreamResult_GetMergeType(tt *testing.T) {
 16326  	var zeroValue string
 16327  	r := &RepoMergeUpstreamResult{MergeType: &zeroValue}
 16328  	r.GetMergeType()
 16329  	r = &RepoMergeUpstreamResult{}
 16330  	r.GetMergeType()
 16331  	r = nil
 16332  	r.GetMergeType()
 16333  }
 16334  
 16335  func TestRepoMergeUpstreamResult_GetMessage(tt *testing.T) {
 16336  	var zeroValue string
 16337  	r := &RepoMergeUpstreamResult{Message: &zeroValue}
 16338  	r.GetMessage()
 16339  	r = &RepoMergeUpstreamResult{}
 16340  	r.GetMessage()
 16341  	r = nil
 16342  	r.GetMessage()
 16343  }
 16344  
 16345  func TestRepoName_GetFrom(tt *testing.T) {
 16346  	var zeroValue string
 16347  	r := &RepoName{From: &zeroValue}
 16348  	r.GetFrom()
 16349  	r = &RepoName{}
 16350  	r.GetFrom()
 16351  	r = nil
 16352  	r.GetFrom()
 16353  }
 16354  
 16355  func TestRepositoriesSearchResult_GetIncompleteResults(tt *testing.T) {
 16356  	var zeroValue bool
 16357  	r := &RepositoriesSearchResult{IncompleteResults: &zeroValue}
 16358  	r.GetIncompleteResults()
 16359  	r = &RepositoriesSearchResult{}
 16360  	r.GetIncompleteResults()
 16361  	r = nil
 16362  	r.GetIncompleteResults()
 16363  }
 16364  
 16365  func TestRepositoriesSearchResult_GetTotal(tt *testing.T) {
 16366  	var zeroValue int
 16367  	r := &RepositoriesSearchResult{Total: &zeroValue}
 16368  	r.GetTotal()
 16369  	r = &RepositoriesSearchResult{}
 16370  	r.GetTotal()
 16371  	r = nil
 16372  	r.GetTotal()
 16373  }
 16374  
 16375  func TestRepository_GetAllowAutoMerge(tt *testing.T) {
 16376  	var zeroValue bool
 16377  	r := &Repository{AllowAutoMerge: &zeroValue}
 16378  	r.GetAllowAutoMerge()
 16379  	r = &Repository{}
 16380  	r.GetAllowAutoMerge()
 16381  	r = nil
 16382  	r.GetAllowAutoMerge()
 16383  }
 16384  
 16385  func TestRepository_GetAllowForking(tt *testing.T) {
 16386  	var zeroValue bool
 16387  	r := &Repository{AllowForking: &zeroValue}
 16388  	r.GetAllowForking()
 16389  	r = &Repository{}
 16390  	r.GetAllowForking()
 16391  	r = nil
 16392  	r.GetAllowForking()
 16393  }
 16394  
 16395  func TestRepository_GetAllowMergeCommit(tt *testing.T) {
 16396  	var zeroValue bool
 16397  	r := &Repository{AllowMergeCommit: &zeroValue}
 16398  	r.GetAllowMergeCommit()
 16399  	r = &Repository{}
 16400  	r.GetAllowMergeCommit()
 16401  	r = nil
 16402  	r.GetAllowMergeCommit()
 16403  }
 16404  
 16405  func TestRepository_GetAllowRebaseMerge(tt *testing.T) {
 16406  	var zeroValue bool
 16407  	r := &Repository{AllowRebaseMerge: &zeroValue}
 16408  	r.GetAllowRebaseMerge()
 16409  	r = &Repository{}
 16410  	r.GetAllowRebaseMerge()
 16411  	r = nil
 16412  	r.GetAllowRebaseMerge()
 16413  }
 16414  
 16415  func TestRepository_GetAllowSquashMerge(tt *testing.T) {
 16416  	var zeroValue bool
 16417  	r := &Repository{AllowSquashMerge: &zeroValue}
 16418  	r.GetAllowSquashMerge()
 16419  	r = &Repository{}
 16420  	r.GetAllowSquashMerge()
 16421  	r = nil
 16422  	r.GetAllowSquashMerge()
 16423  }
 16424  
 16425  func TestRepository_GetAllowUpdateBranch(tt *testing.T) {
 16426  	var zeroValue bool
 16427  	r := &Repository{AllowUpdateBranch: &zeroValue}
 16428  	r.GetAllowUpdateBranch()
 16429  	r = &Repository{}
 16430  	r.GetAllowUpdateBranch()
 16431  	r = nil
 16432  	r.GetAllowUpdateBranch()
 16433  }
 16434  
 16435  func TestRepository_GetArchived(tt *testing.T) {
 16436  	var zeroValue bool
 16437  	r := &Repository{Archived: &zeroValue}
 16438  	r.GetArchived()
 16439  	r = &Repository{}
 16440  	r.GetArchived()
 16441  	r = nil
 16442  	r.GetArchived()
 16443  }
 16444  
 16445  func TestRepository_GetArchiveURL(tt *testing.T) {
 16446  	var zeroValue string
 16447  	r := &Repository{ArchiveURL: &zeroValue}
 16448  	r.GetArchiveURL()
 16449  	r = &Repository{}
 16450  	r.GetArchiveURL()
 16451  	r = nil
 16452  	r.GetArchiveURL()
 16453  }
 16454  
 16455  func TestRepository_GetAssigneesURL(tt *testing.T) {
 16456  	var zeroValue string
 16457  	r := &Repository{AssigneesURL: &zeroValue}
 16458  	r.GetAssigneesURL()
 16459  	r = &Repository{}
 16460  	r.GetAssigneesURL()
 16461  	r = nil
 16462  	r.GetAssigneesURL()
 16463  }
 16464  
 16465  func TestRepository_GetAutoInit(tt *testing.T) {
 16466  	var zeroValue bool
 16467  	r := &Repository{AutoInit: &zeroValue}
 16468  	r.GetAutoInit()
 16469  	r = &Repository{}
 16470  	r.GetAutoInit()
 16471  	r = nil
 16472  	r.GetAutoInit()
 16473  }
 16474  
 16475  func TestRepository_GetBlobsURL(tt *testing.T) {
 16476  	var zeroValue string
 16477  	r := &Repository{BlobsURL: &zeroValue}
 16478  	r.GetBlobsURL()
 16479  	r = &Repository{}
 16480  	r.GetBlobsURL()
 16481  	r = nil
 16482  	r.GetBlobsURL()
 16483  }
 16484  
 16485  func TestRepository_GetBranchesURL(tt *testing.T) {
 16486  	var zeroValue string
 16487  	r := &Repository{BranchesURL: &zeroValue}
 16488  	r.GetBranchesURL()
 16489  	r = &Repository{}
 16490  	r.GetBranchesURL()
 16491  	r = nil
 16492  	r.GetBranchesURL()
 16493  }
 16494  
 16495  func TestRepository_GetCloneURL(tt *testing.T) {
 16496  	var zeroValue string
 16497  	r := &Repository{CloneURL: &zeroValue}
 16498  	r.GetCloneURL()
 16499  	r = &Repository{}
 16500  	r.GetCloneURL()
 16501  	r = nil
 16502  	r.GetCloneURL()
 16503  }
 16504  
 16505  func TestRepository_GetCodeOfConduct(tt *testing.T) {
 16506  	r := &Repository{}
 16507  	r.GetCodeOfConduct()
 16508  	r = nil
 16509  	r.GetCodeOfConduct()
 16510  }
 16511  
 16512  func TestRepository_GetCollaboratorsURL(tt *testing.T) {
 16513  	var zeroValue string
 16514  	r := &Repository{CollaboratorsURL: &zeroValue}
 16515  	r.GetCollaboratorsURL()
 16516  	r = &Repository{}
 16517  	r.GetCollaboratorsURL()
 16518  	r = nil
 16519  	r.GetCollaboratorsURL()
 16520  }
 16521  
 16522  func TestRepository_GetCommentsURL(tt *testing.T) {
 16523  	var zeroValue string
 16524  	r := &Repository{CommentsURL: &zeroValue}
 16525  	r.GetCommentsURL()
 16526  	r = &Repository{}
 16527  	r.GetCommentsURL()
 16528  	r = nil
 16529  	r.GetCommentsURL()
 16530  }
 16531  
 16532  func TestRepository_GetCommitsURL(tt *testing.T) {
 16533  	var zeroValue string
 16534  	r := &Repository{CommitsURL: &zeroValue}
 16535  	r.GetCommitsURL()
 16536  	r = &Repository{}
 16537  	r.GetCommitsURL()
 16538  	r = nil
 16539  	r.GetCommitsURL()
 16540  }
 16541  
 16542  func TestRepository_GetCompareURL(tt *testing.T) {
 16543  	var zeroValue string
 16544  	r := &Repository{CompareURL: &zeroValue}
 16545  	r.GetCompareURL()
 16546  	r = &Repository{}
 16547  	r.GetCompareURL()
 16548  	r = nil
 16549  	r.GetCompareURL()
 16550  }
 16551  
 16552  func TestRepository_GetContentsURL(tt *testing.T) {
 16553  	var zeroValue string
 16554  	r := &Repository{ContentsURL: &zeroValue}
 16555  	r.GetContentsURL()
 16556  	r = &Repository{}
 16557  	r.GetContentsURL()
 16558  	r = nil
 16559  	r.GetContentsURL()
 16560  }
 16561  
 16562  func TestRepository_GetContributorsURL(tt *testing.T) {
 16563  	var zeroValue string
 16564  	r := &Repository{ContributorsURL: &zeroValue}
 16565  	r.GetContributorsURL()
 16566  	r = &Repository{}
 16567  	r.GetContributorsURL()
 16568  	r = nil
 16569  	r.GetContributorsURL()
 16570  }
 16571  
 16572  func TestRepository_GetCreatedAt(tt *testing.T) {
 16573  	var zeroValue Timestamp
 16574  	r := &Repository{CreatedAt: &zeroValue}
 16575  	r.GetCreatedAt()
 16576  	r = &Repository{}
 16577  	r.GetCreatedAt()
 16578  	r = nil
 16579  	r.GetCreatedAt()
 16580  }
 16581  
 16582  func TestRepository_GetDefaultBranch(tt *testing.T) {
 16583  	var zeroValue string
 16584  	r := &Repository{DefaultBranch: &zeroValue}
 16585  	r.GetDefaultBranch()
 16586  	r = &Repository{}
 16587  	r.GetDefaultBranch()
 16588  	r = nil
 16589  	r.GetDefaultBranch()
 16590  }
 16591  
 16592  func TestRepository_GetDeleteBranchOnMerge(tt *testing.T) {
 16593  	var zeroValue bool
 16594  	r := &Repository{DeleteBranchOnMerge: &zeroValue}
 16595  	r.GetDeleteBranchOnMerge()
 16596  	r = &Repository{}
 16597  	r.GetDeleteBranchOnMerge()
 16598  	r = nil
 16599  	r.GetDeleteBranchOnMerge()
 16600  }
 16601  
 16602  func TestRepository_GetDeploymentsURL(tt *testing.T) {
 16603  	var zeroValue string
 16604  	r := &Repository{DeploymentsURL: &zeroValue}
 16605  	r.GetDeploymentsURL()
 16606  	r = &Repository{}
 16607  	r.GetDeploymentsURL()
 16608  	r = nil
 16609  	r.GetDeploymentsURL()
 16610  }
 16611  
 16612  func TestRepository_GetDescription(tt *testing.T) {
 16613  	var zeroValue string
 16614  	r := &Repository{Description: &zeroValue}
 16615  	r.GetDescription()
 16616  	r = &Repository{}
 16617  	r.GetDescription()
 16618  	r = nil
 16619  	r.GetDescription()
 16620  }
 16621  
 16622  func TestRepository_GetDisabled(tt *testing.T) {
 16623  	var zeroValue bool
 16624  	r := &Repository{Disabled: &zeroValue}
 16625  	r.GetDisabled()
 16626  	r = &Repository{}
 16627  	r.GetDisabled()
 16628  	r = nil
 16629  	r.GetDisabled()
 16630  }
 16631  
 16632  func TestRepository_GetDownloadsURL(tt *testing.T) {
 16633  	var zeroValue string
 16634  	r := &Repository{DownloadsURL: &zeroValue}
 16635  	r.GetDownloadsURL()
 16636  	r = &Repository{}
 16637  	r.GetDownloadsURL()
 16638  	r = nil
 16639  	r.GetDownloadsURL()
 16640  }
 16641  
 16642  func TestRepository_GetEventsURL(tt *testing.T) {
 16643  	var zeroValue string
 16644  	r := &Repository{EventsURL: &zeroValue}
 16645  	r.GetEventsURL()
 16646  	r = &Repository{}
 16647  	r.GetEventsURL()
 16648  	r = nil
 16649  	r.GetEventsURL()
 16650  }
 16651  
 16652  func TestRepository_GetFork(tt *testing.T) {
 16653  	var zeroValue bool
 16654  	r := &Repository{Fork: &zeroValue}
 16655  	r.GetFork()
 16656  	r = &Repository{}
 16657  	r.GetFork()
 16658  	r = nil
 16659  	r.GetFork()
 16660  }
 16661  
 16662  func TestRepository_GetForksCount(tt *testing.T) {
 16663  	var zeroValue int
 16664  	r := &Repository{ForksCount: &zeroValue}
 16665  	r.GetForksCount()
 16666  	r = &Repository{}
 16667  	r.GetForksCount()
 16668  	r = nil
 16669  	r.GetForksCount()
 16670  }
 16671  
 16672  func TestRepository_GetForksURL(tt *testing.T) {
 16673  	var zeroValue string
 16674  	r := &Repository{ForksURL: &zeroValue}
 16675  	r.GetForksURL()
 16676  	r = &Repository{}
 16677  	r.GetForksURL()
 16678  	r = nil
 16679  	r.GetForksURL()
 16680  }
 16681  
 16682  func TestRepository_GetFullName(tt *testing.T) {
 16683  	var zeroValue string
 16684  	r := &Repository{FullName: &zeroValue}
 16685  	r.GetFullName()
 16686  	r = &Repository{}
 16687  	r.GetFullName()
 16688  	r = nil
 16689  	r.GetFullName()
 16690  }
 16691  
 16692  func TestRepository_GetGitCommitsURL(tt *testing.T) {
 16693  	var zeroValue string
 16694  	r := &Repository{GitCommitsURL: &zeroValue}
 16695  	r.GetGitCommitsURL()
 16696  	r = &Repository{}
 16697  	r.GetGitCommitsURL()
 16698  	r = nil
 16699  	r.GetGitCommitsURL()
 16700  }
 16701  
 16702  func TestRepository_GetGitignoreTemplate(tt *testing.T) {
 16703  	var zeroValue string
 16704  	r := &Repository{GitignoreTemplate: &zeroValue}
 16705  	r.GetGitignoreTemplate()
 16706  	r = &Repository{}
 16707  	r.GetGitignoreTemplate()
 16708  	r = nil
 16709  	r.GetGitignoreTemplate()
 16710  }
 16711  
 16712  func TestRepository_GetGitRefsURL(tt *testing.T) {
 16713  	var zeroValue string
 16714  	r := &Repository{GitRefsURL: &zeroValue}
 16715  	r.GetGitRefsURL()
 16716  	r = &Repository{}
 16717  	r.GetGitRefsURL()
 16718  	r = nil
 16719  	r.GetGitRefsURL()
 16720  }
 16721  
 16722  func TestRepository_GetGitTagsURL(tt *testing.T) {
 16723  	var zeroValue string
 16724  	r := &Repository{GitTagsURL: &zeroValue}
 16725  	r.GetGitTagsURL()
 16726  	r = &Repository{}
 16727  	r.GetGitTagsURL()
 16728  	r = nil
 16729  	r.GetGitTagsURL()
 16730  }
 16731  
 16732  func TestRepository_GetGitURL(tt *testing.T) {
 16733  	var zeroValue string
 16734  	r := &Repository{GitURL: &zeroValue}
 16735  	r.GetGitURL()
 16736  	r = &Repository{}
 16737  	r.GetGitURL()
 16738  	r = nil
 16739  	r.GetGitURL()
 16740  }
 16741  
 16742  func TestRepository_GetHasDownloads(tt *testing.T) {
 16743  	var zeroValue bool
 16744  	r := &Repository{HasDownloads: &zeroValue}
 16745  	r.GetHasDownloads()
 16746  	r = &Repository{}
 16747  	r.GetHasDownloads()
 16748  	r = nil
 16749  	r.GetHasDownloads()
 16750  }
 16751  
 16752  func TestRepository_GetHasIssues(tt *testing.T) {
 16753  	var zeroValue bool
 16754  	r := &Repository{HasIssues: &zeroValue}
 16755  	r.GetHasIssues()
 16756  	r = &Repository{}
 16757  	r.GetHasIssues()
 16758  	r = nil
 16759  	r.GetHasIssues()
 16760  }
 16761  
 16762  func TestRepository_GetHasPages(tt *testing.T) {
 16763  	var zeroValue bool
 16764  	r := &Repository{HasPages: &zeroValue}
 16765  	r.GetHasPages()
 16766  	r = &Repository{}
 16767  	r.GetHasPages()
 16768  	r = nil
 16769  	r.GetHasPages()
 16770  }
 16771  
 16772  func TestRepository_GetHasProjects(tt *testing.T) {
 16773  	var zeroValue bool
 16774  	r := &Repository{HasProjects: &zeroValue}
 16775  	r.GetHasProjects()
 16776  	r = &Repository{}
 16777  	r.GetHasProjects()
 16778  	r = nil
 16779  	r.GetHasProjects()
 16780  }
 16781  
 16782  func TestRepository_GetHasWiki(tt *testing.T) {
 16783  	var zeroValue bool
 16784  	r := &Repository{HasWiki: &zeroValue}
 16785  	r.GetHasWiki()
 16786  	r = &Repository{}
 16787  	r.GetHasWiki()
 16788  	r = nil
 16789  	r.GetHasWiki()
 16790  }
 16791  
 16792  func TestRepository_GetHomepage(tt *testing.T) {
 16793  	var zeroValue string
 16794  	r := &Repository{Homepage: &zeroValue}
 16795  	r.GetHomepage()
 16796  	r = &Repository{}
 16797  	r.GetHomepage()
 16798  	r = nil
 16799  	r.GetHomepage()
 16800  }
 16801  
 16802  func TestRepository_GetHooksURL(tt *testing.T) {
 16803  	var zeroValue string
 16804  	r := &Repository{HooksURL: &zeroValue}
 16805  	r.GetHooksURL()
 16806  	r = &Repository{}
 16807  	r.GetHooksURL()
 16808  	r = nil
 16809  	r.GetHooksURL()
 16810  }
 16811  
 16812  func TestRepository_GetHTMLURL(tt *testing.T) {
 16813  	var zeroValue string
 16814  	r := &Repository{HTMLURL: &zeroValue}
 16815  	r.GetHTMLURL()
 16816  	r = &Repository{}
 16817  	r.GetHTMLURL()
 16818  	r = nil
 16819  	r.GetHTMLURL()
 16820  }
 16821  
 16822  func TestRepository_GetID(tt *testing.T) {
 16823  	var zeroValue int64
 16824  	r := &Repository{ID: &zeroValue}
 16825  	r.GetID()
 16826  	r = &Repository{}
 16827  	r.GetID()
 16828  	r = nil
 16829  	r.GetID()
 16830  }
 16831  
 16832  func TestRepository_GetIssueCommentURL(tt *testing.T) {
 16833  	var zeroValue string
 16834  	r := &Repository{IssueCommentURL: &zeroValue}
 16835  	r.GetIssueCommentURL()
 16836  	r = &Repository{}
 16837  	r.GetIssueCommentURL()
 16838  	r = nil
 16839  	r.GetIssueCommentURL()
 16840  }
 16841  
 16842  func TestRepository_GetIssueEventsURL(tt *testing.T) {
 16843  	var zeroValue string
 16844  	r := &Repository{IssueEventsURL: &zeroValue}
 16845  	r.GetIssueEventsURL()
 16846  	r = &Repository{}
 16847  	r.GetIssueEventsURL()
 16848  	r = nil
 16849  	r.GetIssueEventsURL()
 16850  }
 16851  
 16852  func TestRepository_GetIssuesURL(tt *testing.T) {
 16853  	var zeroValue string
 16854  	r := &Repository{IssuesURL: &zeroValue}
 16855  	r.GetIssuesURL()
 16856  	r = &Repository{}
 16857  	r.GetIssuesURL()
 16858  	r = nil
 16859  	r.GetIssuesURL()
 16860  }
 16861  
 16862  func TestRepository_GetIsTemplate(tt *testing.T) {
 16863  	var zeroValue bool
 16864  	r := &Repository{IsTemplate: &zeroValue}
 16865  	r.GetIsTemplate()
 16866  	r = &Repository{}
 16867  	r.GetIsTemplate()
 16868  	r = nil
 16869  	r.GetIsTemplate()
 16870  }
 16871  
 16872  func TestRepository_GetKeysURL(tt *testing.T) {
 16873  	var zeroValue string
 16874  	r := &Repository{KeysURL: &zeroValue}
 16875  	r.GetKeysURL()
 16876  	r = &Repository{}
 16877  	r.GetKeysURL()
 16878  	r = nil
 16879  	r.GetKeysURL()
 16880  }
 16881  
 16882  func TestRepository_GetLabelsURL(tt *testing.T) {
 16883  	var zeroValue string
 16884  	r := &Repository{LabelsURL: &zeroValue}
 16885  	r.GetLabelsURL()
 16886  	r = &Repository{}
 16887  	r.GetLabelsURL()
 16888  	r = nil
 16889  	r.GetLabelsURL()
 16890  }
 16891  
 16892  func TestRepository_GetLanguage(tt *testing.T) {
 16893  	var zeroValue string
 16894  	r := &Repository{Language: &zeroValue}
 16895  	r.GetLanguage()
 16896  	r = &Repository{}
 16897  	r.GetLanguage()
 16898  	r = nil
 16899  	r.GetLanguage()
 16900  }
 16901  
 16902  func TestRepository_GetLanguagesURL(tt *testing.T) {
 16903  	var zeroValue string
 16904  	r := &Repository{LanguagesURL: &zeroValue}
 16905  	r.GetLanguagesURL()
 16906  	r = &Repository{}
 16907  	r.GetLanguagesURL()
 16908  	r = nil
 16909  	r.GetLanguagesURL()
 16910  }
 16911  
 16912  func TestRepository_GetLicense(tt *testing.T) {
 16913  	r := &Repository{}
 16914  	r.GetLicense()
 16915  	r = nil
 16916  	r.GetLicense()
 16917  }
 16918  
 16919  func TestRepository_GetLicenseTemplate(tt *testing.T) {
 16920  	var zeroValue string
 16921  	r := &Repository{LicenseTemplate: &zeroValue}
 16922  	r.GetLicenseTemplate()
 16923  	r = &Repository{}
 16924  	r.GetLicenseTemplate()
 16925  	r = nil
 16926  	r.GetLicenseTemplate()
 16927  }
 16928  
 16929  func TestRepository_GetMasterBranch(tt *testing.T) {
 16930  	var zeroValue string
 16931  	r := &Repository{MasterBranch: &zeroValue}
 16932  	r.GetMasterBranch()
 16933  	r = &Repository{}
 16934  	r.GetMasterBranch()
 16935  	r = nil
 16936  	r.GetMasterBranch()
 16937  }
 16938  
 16939  func TestRepository_GetMergesURL(tt *testing.T) {
 16940  	var zeroValue string
 16941  	r := &Repository{MergesURL: &zeroValue}
 16942  	r.GetMergesURL()
 16943  	r = &Repository{}
 16944  	r.GetMergesURL()
 16945  	r = nil
 16946  	r.GetMergesURL()
 16947  }
 16948  
 16949  func TestRepository_GetMilestonesURL(tt *testing.T) {
 16950  	var zeroValue string
 16951  	r := &Repository{MilestonesURL: &zeroValue}
 16952  	r.GetMilestonesURL()
 16953  	r = &Repository{}
 16954  	r.GetMilestonesURL()
 16955  	r = nil
 16956  	r.GetMilestonesURL()
 16957  }
 16958  
 16959  func TestRepository_GetMirrorURL(tt *testing.T) {
 16960  	var zeroValue string
 16961  	r := &Repository{MirrorURL: &zeroValue}
 16962  	r.GetMirrorURL()
 16963  	r = &Repository{}
 16964  	r.GetMirrorURL()
 16965  	r = nil
 16966  	r.GetMirrorURL()
 16967  }
 16968  
 16969  func TestRepository_GetName(tt *testing.T) {
 16970  	var zeroValue string
 16971  	r := &Repository{Name: &zeroValue}
 16972  	r.GetName()
 16973  	r = &Repository{}
 16974  	r.GetName()
 16975  	r = nil
 16976  	r.GetName()
 16977  }
 16978  
 16979  func TestRepository_GetNetworkCount(tt *testing.T) {
 16980  	var zeroValue int
 16981  	r := &Repository{NetworkCount: &zeroValue}
 16982  	r.GetNetworkCount()
 16983  	r = &Repository{}
 16984  	r.GetNetworkCount()
 16985  	r = nil
 16986  	r.GetNetworkCount()
 16987  }
 16988  
 16989  func TestRepository_GetNodeID(tt *testing.T) {
 16990  	var zeroValue string
 16991  	r := &Repository{NodeID: &zeroValue}
 16992  	r.GetNodeID()
 16993  	r = &Repository{}
 16994  	r.GetNodeID()
 16995  	r = nil
 16996  	r.GetNodeID()
 16997  }
 16998  
 16999  func TestRepository_GetNotificationsURL(tt *testing.T) {
 17000  	var zeroValue string
 17001  	r := &Repository{NotificationsURL: &zeroValue}
 17002  	r.GetNotificationsURL()
 17003  	r = &Repository{}
 17004  	r.GetNotificationsURL()
 17005  	r = nil
 17006  	r.GetNotificationsURL()
 17007  }
 17008  
 17009  func TestRepository_GetOpenIssues(tt *testing.T) {
 17010  	var zeroValue int
 17011  	r := &Repository{OpenIssues: &zeroValue}
 17012  	r.GetOpenIssues()
 17013  	r = &Repository{}
 17014  	r.GetOpenIssues()
 17015  	r = nil
 17016  	r.GetOpenIssues()
 17017  }
 17018  
 17019  func TestRepository_GetOpenIssuesCount(tt *testing.T) {
 17020  	var zeroValue int
 17021  	r := &Repository{OpenIssuesCount: &zeroValue}
 17022  	r.GetOpenIssuesCount()
 17023  	r = &Repository{}
 17024  	r.GetOpenIssuesCount()
 17025  	r = nil
 17026  	r.GetOpenIssuesCount()
 17027  }
 17028  
 17029  func TestRepository_GetOrganization(tt *testing.T) {
 17030  	r := &Repository{}
 17031  	r.GetOrganization()
 17032  	r = nil
 17033  	r.GetOrganization()
 17034  }
 17035  
 17036  func TestRepository_GetOwner(tt *testing.T) {
 17037  	r := &Repository{}
 17038  	r.GetOwner()
 17039  	r = nil
 17040  	r.GetOwner()
 17041  }
 17042  
 17043  func TestRepository_GetParent(tt *testing.T) {
 17044  	r := &Repository{}
 17045  	r.GetParent()
 17046  	r = nil
 17047  	r.GetParent()
 17048  }
 17049  
 17050  func TestRepository_GetPermissions(tt *testing.T) {
 17051  	zeroValue := map[string]bool{}
 17052  	r := &Repository{Permissions: zeroValue}
 17053  	r.GetPermissions()
 17054  	r = &Repository{}
 17055  	r.GetPermissions()
 17056  	r = nil
 17057  	r.GetPermissions()
 17058  }
 17059  
 17060  func TestRepository_GetPrivate(tt *testing.T) {
 17061  	var zeroValue bool
 17062  	r := &Repository{Private: &zeroValue}
 17063  	r.GetPrivate()
 17064  	r = &Repository{}
 17065  	r.GetPrivate()
 17066  	r = nil
 17067  	r.GetPrivate()
 17068  }
 17069  
 17070  func TestRepository_GetPullsURL(tt *testing.T) {
 17071  	var zeroValue string
 17072  	r := &Repository{PullsURL: &zeroValue}
 17073  	r.GetPullsURL()
 17074  	r = &Repository{}
 17075  	r.GetPullsURL()
 17076  	r = nil
 17077  	r.GetPullsURL()
 17078  }
 17079  
 17080  func TestRepository_GetPushedAt(tt *testing.T) {
 17081  	var zeroValue Timestamp
 17082  	r := &Repository{PushedAt: &zeroValue}
 17083  	r.GetPushedAt()
 17084  	r = &Repository{}
 17085  	r.GetPushedAt()
 17086  	r = nil
 17087  	r.GetPushedAt()
 17088  }
 17089  
 17090  func TestRepository_GetReleasesURL(tt *testing.T) {
 17091  	var zeroValue string
 17092  	r := &Repository{ReleasesURL: &zeroValue}
 17093  	r.GetReleasesURL()
 17094  	r = &Repository{}
 17095  	r.GetReleasesURL()
 17096  	r = nil
 17097  	r.GetReleasesURL()
 17098  }
 17099  
 17100  func TestRepository_GetRoleName(tt *testing.T) {
 17101  	var zeroValue string
 17102  	r := &Repository{RoleName: &zeroValue}
 17103  	r.GetRoleName()
 17104  	r = &Repository{}
 17105  	r.GetRoleName()
 17106  	r = nil
 17107  	r.GetRoleName()
 17108  }
 17109  
 17110  func TestRepository_GetSecurityAndAnalysis(tt *testing.T) {
 17111  	r := &Repository{}
 17112  	r.GetSecurityAndAnalysis()
 17113  	r = nil
 17114  	r.GetSecurityAndAnalysis()
 17115  }
 17116  
 17117  func TestRepository_GetSize(tt *testing.T) {
 17118  	var zeroValue int
 17119  	r := &Repository{Size: &zeroValue}
 17120  	r.GetSize()
 17121  	r = &Repository{}
 17122  	r.GetSize()
 17123  	r = nil
 17124  	r.GetSize()
 17125  }
 17126  
 17127  func TestRepository_GetSource(tt *testing.T) {
 17128  	r := &Repository{}
 17129  	r.GetSource()
 17130  	r = nil
 17131  	r.GetSource()
 17132  }
 17133  
 17134  func TestRepository_GetSSHURL(tt *testing.T) {
 17135  	var zeroValue string
 17136  	r := &Repository{SSHURL: &zeroValue}
 17137  	r.GetSSHURL()
 17138  	r = &Repository{}
 17139  	r.GetSSHURL()
 17140  	r = nil
 17141  	r.GetSSHURL()
 17142  }
 17143  
 17144  func TestRepository_GetStargazersCount(tt *testing.T) {
 17145  	var zeroValue int
 17146  	r := &Repository{StargazersCount: &zeroValue}
 17147  	r.GetStargazersCount()
 17148  	r = &Repository{}
 17149  	r.GetStargazersCount()
 17150  	r = nil
 17151  	r.GetStargazersCount()
 17152  }
 17153  
 17154  func TestRepository_GetStargazersURL(tt *testing.T) {
 17155  	var zeroValue string
 17156  	r := &Repository{StargazersURL: &zeroValue}
 17157  	r.GetStargazersURL()
 17158  	r = &Repository{}
 17159  	r.GetStargazersURL()
 17160  	r = nil
 17161  	r.GetStargazersURL()
 17162  }
 17163  
 17164  func TestRepository_GetStatusesURL(tt *testing.T) {
 17165  	var zeroValue string
 17166  	r := &Repository{StatusesURL: &zeroValue}
 17167  	r.GetStatusesURL()
 17168  	r = &Repository{}
 17169  	r.GetStatusesURL()
 17170  	r = nil
 17171  	r.GetStatusesURL()
 17172  }
 17173  
 17174  func TestRepository_GetSubscribersCount(tt *testing.T) {
 17175  	var zeroValue int
 17176  	r := &Repository{SubscribersCount: &zeroValue}
 17177  	r.GetSubscribersCount()
 17178  	r = &Repository{}
 17179  	r.GetSubscribersCount()
 17180  	r = nil
 17181  	r.GetSubscribersCount()
 17182  }
 17183  
 17184  func TestRepository_GetSubscribersURL(tt *testing.T) {
 17185  	var zeroValue string
 17186  	r := &Repository{SubscribersURL: &zeroValue}
 17187  	r.GetSubscribersURL()
 17188  	r = &Repository{}
 17189  	r.GetSubscribersURL()
 17190  	r = nil
 17191  	r.GetSubscribersURL()
 17192  }
 17193  
 17194  func TestRepository_GetSubscriptionURL(tt *testing.T) {
 17195  	var zeroValue string
 17196  	r := &Repository{SubscriptionURL: &zeroValue}
 17197  	r.GetSubscriptionURL()
 17198  	r = &Repository{}
 17199  	r.GetSubscriptionURL()
 17200  	r = nil
 17201  	r.GetSubscriptionURL()
 17202  }
 17203  
 17204  func TestRepository_GetSVNURL(tt *testing.T) {
 17205  	var zeroValue string
 17206  	r := &Repository{SVNURL: &zeroValue}
 17207  	r.GetSVNURL()
 17208  	r = &Repository{}
 17209  	r.GetSVNURL()
 17210  	r = nil
 17211  	r.GetSVNURL()
 17212  }
 17213  
 17214  func TestRepository_GetTagsURL(tt *testing.T) {
 17215  	var zeroValue string
 17216  	r := &Repository{TagsURL: &zeroValue}
 17217  	r.GetTagsURL()
 17218  	r = &Repository{}
 17219  	r.GetTagsURL()
 17220  	r = nil
 17221  	r.GetTagsURL()
 17222  }
 17223  
 17224  func TestRepository_GetTeamID(tt *testing.T) {
 17225  	var zeroValue int64
 17226  	r := &Repository{TeamID: &zeroValue}
 17227  	r.GetTeamID()
 17228  	r = &Repository{}
 17229  	r.GetTeamID()
 17230  	r = nil
 17231  	r.GetTeamID()
 17232  }
 17233  
 17234  func TestRepository_GetTeamsURL(tt *testing.T) {
 17235  	var zeroValue string
 17236  	r := &Repository{TeamsURL: &zeroValue}
 17237  	r.GetTeamsURL()
 17238  	r = &Repository{}
 17239  	r.GetTeamsURL()
 17240  	r = nil
 17241  	r.GetTeamsURL()
 17242  }
 17243  
 17244  func TestRepository_GetTemplateRepository(tt *testing.T) {
 17245  	r := &Repository{}
 17246  	r.GetTemplateRepository()
 17247  	r = nil
 17248  	r.GetTemplateRepository()
 17249  }
 17250  
 17251  func TestRepository_GetTreesURL(tt *testing.T) {
 17252  	var zeroValue string
 17253  	r := &Repository{TreesURL: &zeroValue}
 17254  	r.GetTreesURL()
 17255  	r = &Repository{}
 17256  	r.GetTreesURL()
 17257  	r = nil
 17258  	r.GetTreesURL()
 17259  }
 17260  
 17261  func TestRepository_GetUpdatedAt(tt *testing.T) {
 17262  	var zeroValue Timestamp
 17263  	r := &Repository{UpdatedAt: &zeroValue}
 17264  	r.GetUpdatedAt()
 17265  	r = &Repository{}
 17266  	r.GetUpdatedAt()
 17267  	r = nil
 17268  	r.GetUpdatedAt()
 17269  }
 17270  
 17271  func TestRepository_GetURL(tt *testing.T) {
 17272  	var zeroValue string
 17273  	r := &Repository{URL: &zeroValue}
 17274  	r.GetURL()
 17275  	r = &Repository{}
 17276  	r.GetURL()
 17277  	r = nil
 17278  	r.GetURL()
 17279  }
 17280  
 17281  func TestRepository_GetUseSquashPRTitleAsDefault(tt *testing.T) {
 17282  	var zeroValue bool
 17283  	r := &Repository{UseSquashPRTitleAsDefault: &zeroValue}
 17284  	r.GetUseSquashPRTitleAsDefault()
 17285  	r = &Repository{}
 17286  	r.GetUseSquashPRTitleAsDefault()
 17287  	r = nil
 17288  	r.GetUseSquashPRTitleAsDefault()
 17289  }
 17290  
 17291  func TestRepository_GetVisibility(tt *testing.T) {
 17292  	var zeroValue string
 17293  	r := &Repository{Visibility: &zeroValue}
 17294  	r.GetVisibility()
 17295  	r = &Repository{}
 17296  	r.GetVisibility()
 17297  	r = nil
 17298  	r.GetVisibility()
 17299  }
 17300  
 17301  func TestRepository_GetWatchers(tt *testing.T) {
 17302  	var zeroValue int
 17303  	r := &Repository{Watchers: &zeroValue}
 17304  	r.GetWatchers()
 17305  	r = &Repository{}
 17306  	r.GetWatchers()
 17307  	r = nil
 17308  	r.GetWatchers()
 17309  }
 17310  
 17311  func TestRepository_GetWatchersCount(tt *testing.T) {
 17312  	var zeroValue int
 17313  	r := &Repository{WatchersCount: &zeroValue}
 17314  	r.GetWatchersCount()
 17315  	r = &Repository{}
 17316  	r.GetWatchersCount()
 17317  	r = nil
 17318  	r.GetWatchersCount()
 17319  }
 17320  
 17321  func TestRepositoryActiveCommitters_GetAdvancedSecurityCommitters(tt *testing.T) {
 17322  	var zeroValue int
 17323  	r := &RepositoryActiveCommitters{AdvancedSecurityCommitters: &zeroValue}
 17324  	r.GetAdvancedSecurityCommitters()
 17325  	r = &RepositoryActiveCommitters{}
 17326  	r.GetAdvancedSecurityCommitters()
 17327  	r = nil
 17328  	r.GetAdvancedSecurityCommitters()
 17329  }
 17330  
 17331  func TestRepositoryActiveCommitters_GetName(tt *testing.T) {
 17332  	var zeroValue string
 17333  	r := &RepositoryActiveCommitters{Name: &zeroValue}
 17334  	r.GetName()
 17335  	r = &RepositoryActiveCommitters{}
 17336  	r.GetName()
 17337  	r = nil
 17338  	r.GetName()
 17339  }
 17340  
 17341  func TestRepositoryComment_GetBody(tt *testing.T) {
 17342  	var zeroValue string
 17343  	r := &RepositoryComment{Body: &zeroValue}
 17344  	r.GetBody()
 17345  	r = &RepositoryComment{}
 17346  	r.GetBody()
 17347  	r = nil
 17348  	r.GetBody()
 17349  }
 17350  
 17351  func TestRepositoryComment_GetCommitID(tt *testing.T) {
 17352  	var zeroValue string
 17353  	r := &RepositoryComment{CommitID: &zeroValue}
 17354  	r.GetCommitID()
 17355  	r = &RepositoryComment{}
 17356  	r.GetCommitID()
 17357  	r = nil
 17358  	r.GetCommitID()
 17359  }
 17360  
 17361  func TestRepositoryComment_GetCreatedAt(tt *testing.T) {
 17362  	var zeroValue time.Time
 17363  	r := &RepositoryComment{CreatedAt: &zeroValue}
 17364  	r.GetCreatedAt()
 17365  	r = &RepositoryComment{}
 17366  	r.GetCreatedAt()
 17367  	r = nil
 17368  	r.GetCreatedAt()
 17369  }
 17370  
 17371  func TestRepositoryComment_GetHTMLURL(tt *testing.T) {
 17372  	var zeroValue string
 17373  	r := &RepositoryComment{HTMLURL: &zeroValue}
 17374  	r.GetHTMLURL()
 17375  	r = &RepositoryComment{}
 17376  	r.GetHTMLURL()
 17377  	r = nil
 17378  	r.GetHTMLURL()
 17379  }
 17380  
 17381  func TestRepositoryComment_GetID(tt *testing.T) {
 17382  	var zeroValue int64
 17383  	r := &RepositoryComment{ID: &zeroValue}
 17384  	r.GetID()
 17385  	r = &RepositoryComment{}
 17386  	r.GetID()
 17387  	r = nil
 17388  	r.GetID()
 17389  }
 17390  
 17391  func TestRepositoryComment_GetNodeID(tt *testing.T) {
 17392  	var zeroValue string
 17393  	r := &RepositoryComment{NodeID: &zeroValue}
 17394  	r.GetNodeID()
 17395  	r = &RepositoryComment{}
 17396  	r.GetNodeID()
 17397  	r = nil
 17398  	r.GetNodeID()
 17399  }
 17400  
 17401  func TestRepositoryComment_GetPath(tt *testing.T) {
 17402  	var zeroValue string
 17403  	r := &RepositoryComment{Path: &zeroValue}
 17404  	r.GetPath()
 17405  	r = &RepositoryComment{}
 17406  	r.GetPath()
 17407  	r = nil
 17408  	r.GetPath()
 17409  }
 17410  
 17411  func TestRepositoryComment_GetPosition(tt *testing.T) {
 17412  	var zeroValue int
 17413  	r := &RepositoryComment{Position: &zeroValue}
 17414  	r.GetPosition()
 17415  	r = &RepositoryComment{}
 17416  	r.GetPosition()
 17417  	r = nil
 17418  	r.GetPosition()
 17419  }
 17420  
 17421  func TestRepositoryComment_GetReactions(tt *testing.T) {
 17422  	r := &RepositoryComment{}
 17423  	r.GetReactions()
 17424  	r = nil
 17425  	r.GetReactions()
 17426  }
 17427  
 17428  func TestRepositoryComment_GetUpdatedAt(tt *testing.T) {
 17429  	var zeroValue time.Time
 17430  	r := &RepositoryComment{UpdatedAt: &zeroValue}
 17431  	r.GetUpdatedAt()
 17432  	r = &RepositoryComment{}
 17433  	r.GetUpdatedAt()
 17434  	r = nil
 17435  	r.GetUpdatedAt()
 17436  }
 17437  
 17438  func TestRepositoryComment_GetURL(tt *testing.T) {
 17439  	var zeroValue string
 17440  	r := &RepositoryComment{URL: &zeroValue}
 17441  	r.GetURL()
 17442  	r = &RepositoryComment{}
 17443  	r.GetURL()
 17444  	r = nil
 17445  	r.GetURL()
 17446  }
 17447  
 17448  func TestRepositoryComment_GetUser(tt *testing.T) {
 17449  	r := &RepositoryComment{}
 17450  	r.GetUser()
 17451  	r = nil
 17452  	r.GetUser()
 17453  }
 17454  
 17455  func TestRepositoryCommit_GetAuthor(tt *testing.T) {
 17456  	r := &RepositoryCommit{}
 17457  	r.GetAuthor()
 17458  	r = nil
 17459  	r.GetAuthor()
 17460  }
 17461  
 17462  func TestRepositoryCommit_GetCommentsURL(tt *testing.T) {
 17463  	var zeroValue string
 17464  	r := &RepositoryCommit{CommentsURL: &zeroValue}
 17465  	r.GetCommentsURL()
 17466  	r = &RepositoryCommit{}
 17467  	r.GetCommentsURL()
 17468  	r = nil
 17469  	r.GetCommentsURL()
 17470  }
 17471  
 17472  func TestRepositoryCommit_GetCommit(tt *testing.T) {
 17473  	r := &RepositoryCommit{}
 17474  	r.GetCommit()
 17475  	r = nil
 17476  	r.GetCommit()
 17477  }
 17478  
 17479  func TestRepositoryCommit_GetCommitter(tt *testing.T) {
 17480  	r := &RepositoryCommit{}
 17481  	r.GetCommitter()
 17482  	r = nil
 17483  	r.GetCommitter()
 17484  }
 17485  
 17486  func TestRepositoryCommit_GetHTMLURL(tt *testing.T) {
 17487  	var zeroValue string
 17488  	r := &RepositoryCommit{HTMLURL: &zeroValue}
 17489  	r.GetHTMLURL()
 17490  	r = &RepositoryCommit{}
 17491  	r.GetHTMLURL()
 17492  	r = nil
 17493  	r.GetHTMLURL()
 17494  }
 17495  
 17496  func TestRepositoryCommit_GetNodeID(tt *testing.T) {
 17497  	var zeroValue string
 17498  	r := &RepositoryCommit{NodeID: &zeroValue}
 17499  	r.GetNodeID()
 17500  	r = &RepositoryCommit{}
 17501  	r.GetNodeID()
 17502  	r = nil
 17503  	r.GetNodeID()
 17504  }
 17505  
 17506  func TestRepositoryCommit_GetSHA(tt *testing.T) {
 17507  	var zeroValue string
 17508  	r := &RepositoryCommit{SHA: &zeroValue}
 17509  	r.GetSHA()
 17510  	r = &RepositoryCommit{}
 17511  	r.GetSHA()
 17512  	r = nil
 17513  	r.GetSHA()
 17514  }
 17515  
 17516  func TestRepositoryCommit_GetStats(tt *testing.T) {
 17517  	r := &RepositoryCommit{}
 17518  	r.GetStats()
 17519  	r = nil
 17520  	r.GetStats()
 17521  }
 17522  
 17523  func TestRepositoryCommit_GetURL(tt *testing.T) {
 17524  	var zeroValue string
 17525  	r := &RepositoryCommit{URL: &zeroValue}
 17526  	r.GetURL()
 17527  	r = &RepositoryCommit{}
 17528  	r.GetURL()
 17529  	r = nil
 17530  	r.GetURL()
 17531  }
 17532  
 17533  func TestRepositoryContent_GetDownloadURL(tt *testing.T) {
 17534  	var zeroValue string
 17535  	r := &RepositoryContent{DownloadURL: &zeroValue}
 17536  	r.GetDownloadURL()
 17537  	r = &RepositoryContent{}
 17538  	r.GetDownloadURL()
 17539  	r = nil
 17540  	r.GetDownloadURL()
 17541  }
 17542  
 17543  func TestRepositoryContent_GetEncoding(tt *testing.T) {
 17544  	var zeroValue string
 17545  	r := &RepositoryContent{Encoding: &zeroValue}
 17546  	r.GetEncoding()
 17547  	r = &RepositoryContent{}
 17548  	r.GetEncoding()
 17549  	r = nil
 17550  	r.GetEncoding()
 17551  }
 17552  
 17553  func TestRepositoryContent_GetGitURL(tt *testing.T) {
 17554  	var zeroValue string
 17555  	r := &RepositoryContent{GitURL: &zeroValue}
 17556  	r.GetGitURL()
 17557  	r = &RepositoryContent{}
 17558  	r.GetGitURL()
 17559  	r = nil
 17560  	r.GetGitURL()
 17561  }
 17562  
 17563  func TestRepositoryContent_GetHTMLURL(tt *testing.T) {
 17564  	var zeroValue string
 17565  	r := &RepositoryContent{HTMLURL: &zeroValue}
 17566  	r.GetHTMLURL()
 17567  	r = &RepositoryContent{}
 17568  	r.GetHTMLURL()
 17569  	r = nil
 17570  	r.GetHTMLURL()
 17571  }
 17572  
 17573  func TestRepositoryContent_GetName(tt *testing.T) {
 17574  	var zeroValue string
 17575  	r := &RepositoryContent{Name: &zeroValue}
 17576  	r.GetName()
 17577  	r = &RepositoryContent{}
 17578  	r.GetName()
 17579  	r = nil
 17580  	r.GetName()
 17581  }
 17582  
 17583  func TestRepositoryContent_GetPath(tt *testing.T) {
 17584  	var zeroValue string
 17585  	r := &RepositoryContent{Path: &zeroValue}
 17586  	r.GetPath()
 17587  	r = &RepositoryContent{}
 17588  	r.GetPath()
 17589  	r = nil
 17590  	r.GetPath()
 17591  }
 17592  
 17593  func TestRepositoryContent_GetSHA(tt *testing.T) {
 17594  	var zeroValue string
 17595  	r := &RepositoryContent{SHA: &zeroValue}
 17596  	r.GetSHA()
 17597  	r = &RepositoryContent{}
 17598  	r.GetSHA()
 17599  	r = nil
 17600  	r.GetSHA()
 17601  }
 17602  
 17603  func TestRepositoryContent_GetSize(tt *testing.T) {
 17604  	var zeroValue int
 17605  	r := &RepositoryContent{Size: &zeroValue}
 17606  	r.GetSize()
 17607  	r = &RepositoryContent{}
 17608  	r.GetSize()
 17609  	r = nil
 17610  	r.GetSize()
 17611  }
 17612  
 17613  func TestRepositoryContent_GetTarget(tt *testing.T) {
 17614  	var zeroValue string
 17615  	r := &RepositoryContent{Target: &zeroValue}
 17616  	r.GetTarget()
 17617  	r = &RepositoryContent{}
 17618  	r.GetTarget()
 17619  	r = nil
 17620  	r.GetTarget()
 17621  }
 17622  
 17623  func TestRepositoryContent_GetType(tt *testing.T) {
 17624  	var zeroValue string
 17625  	r := &RepositoryContent{Type: &zeroValue}
 17626  	r.GetType()
 17627  	r = &RepositoryContent{}
 17628  	r.GetType()
 17629  	r = nil
 17630  	r.GetType()
 17631  }
 17632  
 17633  func TestRepositoryContent_GetURL(tt *testing.T) {
 17634  	var zeroValue string
 17635  	r := &RepositoryContent{URL: &zeroValue}
 17636  	r.GetURL()
 17637  	r = &RepositoryContent{}
 17638  	r.GetURL()
 17639  	r = nil
 17640  	r.GetURL()
 17641  }
 17642  
 17643  func TestRepositoryContentFileOptions_GetAuthor(tt *testing.T) {
 17644  	r := &RepositoryContentFileOptions{}
 17645  	r.GetAuthor()
 17646  	r = nil
 17647  	r.GetAuthor()
 17648  }
 17649  
 17650  func TestRepositoryContentFileOptions_GetBranch(tt *testing.T) {
 17651  	var zeroValue string
 17652  	r := &RepositoryContentFileOptions{Branch: &zeroValue}
 17653  	r.GetBranch()
 17654  	r = &RepositoryContentFileOptions{}
 17655  	r.GetBranch()
 17656  	r = nil
 17657  	r.GetBranch()
 17658  }
 17659  
 17660  func TestRepositoryContentFileOptions_GetCommitter(tt *testing.T) {
 17661  	r := &RepositoryContentFileOptions{}
 17662  	r.GetCommitter()
 17663  	r = nil
 17664  	r.GetCommitter()
 17665  }
 17666  
 17667  func TestRepositoryContentFileOptions_GetMessage(tt *testing.T) {
 17668  	var zeroValue string
 17669  	r := &RepositoryContentFileOptions{Message: &zeroValue}
 17670  	r.GetMessage()
 17671  	r = &RepositoryContentFileOptions{}
 17672  	r.GetMessage()
 17673  	r = nil
 17674  	r.GetMessage()
 17675  }
 17676  
 17677  func TestRepositoryContentFileOptions_GetSHA(tt *testing.T) {
 17678  	var zeroValue string
 17679  	r := &RepositoryContentFileOptions{SHA: &zeroValue}
 17680  	r.GetSHA()
 17681  	r = &RepositoryContentFileOptions{}
 17682  	r.GetSHA()
 17683  	r = nil
 17684  	r.GetSHA()
 17685  }
 17686  
 17687  func TestRepositoryContentResponse_GetContent(tt *testing.T) {
 17688  	r := &RepositoryContentResponse{}
 17689  	r.GetContent()
 17690  	r = nil
 17691  	r.GetContent()
 17692  }
 17693  
 17694  func TestRepositoryDispatchEvent_GetAction(tt *testing.T) {
 17695  	var zeroValue string
 17696  	r := &RepositoryDispatchEvent{Action: &zeroValue}
 17697  	r.GetAction()
 17698  	r = &RepositoryDispatchEvent{}
 17699  	r.GetAction()
 17700  	r = nil
 17701  	r.GetAction()
 17702  }
 17703  
 17704  func TestRepositoryDispatchEvent_GetBranch(tt *testing.T) {
 17705  	var zeroValue string
 17706  	r := &RepositoryDispatchEvent{Branch: &zeroValue}
 17707  	r.GetBranch()
 17708  	r = &RepositoryDispatchEvent{}
 17709  	r.GetBranch()
 17710  	r = nil
 17711  	r.GetBranch()
 17712  }
 17713  
 17714  func TestRepositoryDispatchEvent_GetInstallation(tt *testing.T) {
 17715  	r := &RepositoryDispatchEvent{}
 17716  	r.GetInstallation()
 17717  	r = nil
 17718  	r.GetInstallation()
 17719  }
 17720  
 17721  func TestRepositoryDispatchEvent_GetOrg(tt *testing.T) {
 17722  	r := &RepositoryDispatchEvent{}
 17723  	r.GetOrg()
 17724  	r = nil
 17725  	r.GetOrg()
 17726  }
 17727  
 17728  func TestRepositoryDispatchEvent_GetRepo(tt *testing.T) {
 17729  	r := &RepositoryDispatchEvent{}
 17730  	r.GetRepo()
 17731  	r = nil
 17732  	r.GetRepo()
 17733  }
 17734  
 17735  func TestRepositoryDispatchEvent_GetSender(tt *testing.T) {
 17736  	r := &RepositoryDispatchEvent{}
 17737  	r.GetSender()
 17738  	r = nil
 17739  	r.GetSender()
 17740  }
 17741  
 17742  func TestRepositoryEvent_GetAction(tt *testing.T) {
 17743  	var zeroValue string
 17744  	r := &RepositoryEvent{Action: &zeroValue}
 17745  	r.GetAction()
 17746  	r = &RepositoryEvent{}
 17747  	r.GetAction()
 17748  	r = nil
 17749  	r.GetAction()
 17750  }
 17751  
 17752  func TestRepositoryEvent_GetChanges(tt *testing.T) {
 17753  	r := &RepositoryEvent{}
 17754  	r.GetChanges()
 17755  	r = nil
 17756  	r.GetChanges()
 17757  }
 17758  
 17759  func TestRepositoryEvent_GetInstallation(tt *testing.T) {
 17760  	r := &RepositoryEvent{}
 17761  	r.GetInstallation()
 17762  	r = nil
 17763  	r.GetInstallation()
 17764  }
 17765  
 17766  func TestRepositoryEvent_GetOrg(tt *testing.T) {
 17767  	r := &RepositoryEvent{}
 17768  	r.GetOrg()
 17769  	r = nil
 17770  	r.GetOrg()
 17771  }
 17772  
 17773  func TestRepositoryEvent_GetRepo(tt *testing.T) {
 17774  	r := &RepositoryEvent{}
 17775  	r.GetRepo()
 17776  	r = nil
 17777  	r.GetRepo()
 17778  }
 17779  
 17780  func TestRepositoryEvent_GetSender(tt *testing.T) {
 17781  	r := &RepositoryEvent{}
 17782  	r.GetSender()
 17783  	r = nil
 17784  	r.GetSender()
 17785  }
 17786  
 17787  func TestRepositoryImportEvent_GetOrg(tt *testing.T) {
 17788  	r := &RepositoryImportEvent{}
 17789  	r.GetOrg()
 17790  	r = nil
 17791  	r.GetOrg()
 17792  }
 17793  
 17794  func TestRepositoryImportEvent_GetRepo(tt *testing.T) {
 17795  	r := &RepositoryImportEvent{}
 17796  	r.GetRepo()
 17797  	r = nil
 17798  	r.GetRepo()
 17799  }
 17800  
 17801  func TestRepositoryImportEvent_GetSender(tt *testing.T) {
 17802  	r := &RepositoryImportEvent{}
 17803  	r.GetSender()
 17804  	r = nil
 17805  	r.GetSender()
 17806  }
 17807  
 17808  func TestRepositoryImportEvent_GetStatus(tt *testing.T) {
 17809  	var zeroValue string
 17810  	r := &RepositoryImportEvent{Status: &zeroValue}
 17811  	r.GetStatus()
 17812  	r = &RepositoryImportEvent{}
 17813  	r.GetStatus()
 17814  	r = nil
 17815  	r.GetStatus()
 17816  }
 17817  
 17818  func TestRepositoryInvitation_GetCreatedAt(tt *testing.T) {
 17819  	var zeroValue Timestamp
 17820  	r := &RepositoryInvitation{CreatedAt: &zeroValue}
 17821  	r.GetCreatedAt()
 17822  	r = &RepositoryInvitation{}
 17823  	r.GetCreatedAt()
 17824  	r = nil
 17825  	r.GetCreatedAt()
 17826  }
 17827  
 17828  func TestRepositoryInvitation_GetHTMLURL(tt *testing.T) {
 17829  	var zeroValue string
 17830  	r := &RepositoryInvitation{HTMLURL: &zeroValue}
 17831  	r.GetHTMLURL()
 17832  	r = &RepositoryInvitation{}
 17833  	r.GetHTMLURL()
 17834  	r = nil
 17835  	r.GetHTMLURL()
 17836  }
 17837  
 17838  func TestRepositoryInvitation_GetID(tt *testing.T) {
 17839  	var zeroValue int64
 17840  	r := &RepositoryInvitation{ID: &zeroValue}
 17841  	r.GetID()
 17842  	r = &RepositoryInvitation{}
 17843  	r.GetID()
 17844  	r = nil
 17845  	r.GetID()
 17846  }
 17847  
 17848  func TestRepositoryInvitation_GetInvitee(tt *testing.T) {
 17849  	r := &RepositoryInvitation{}
 17850  	r.GetInvitee()
 17851  	r = nil
 17852  	r.GetInvitee()
 17853  }
 17854  
 17855  func TestRepositoryInvitation_GetInviter(tt *testing.T) {
 17856  	r := &RepositoryInvitation{}
 17857  	r.GetInviter()
 17858  	r = nil
 17859  	r.GetInviter()
 17860  }
 17861  
 17862  func TestRepositoryInvitation_GetPermissions(tt *testing.T) {
 17863  	var zeroValue string
 17864  	r := &RepositoryInvitation{Permissions: &zeroValue}
 17865  	r.GetPermissions()
 17866  	r = &RepositoryInvitation{}
 17867  	r.GetPermissions()
 17868  	r = nil
 17869  	r.GetPermissions()
 17870  }
 17871  
 17872  func TestRepositoryInvitation_GetRepo(tt *testing.T) {
 17873  	r := &RepositoryInvitation{}
 17874  	r.GetRepo()
 17875  	r = nil
 17876  	r.GetRepo()
 17877  }
 17878  
 17879  func TestRepositoryInvitation_GetURL(tt *testing.T) {
 17880  	var zeroValue string
 17881  	r := &RepositoryInvitation{URL: &zeroValue}
 17882  	r.GetURL()
 17883  	r = &RepositoryInvitation{}
 17884  	r.GetURL()
 17885  	r = nil
 17886  	r.GetURL()
 17887  }
 17888  
 17889  func TestRepositoryLicense_GetContent(tt *testing.T) {
 17890  	var zeroValue string
 17891  	r := &RepositoryLicense{Content: &zeroValue}
 17892  	r.GetContent()
 17893  	r = &RepositoryLicense{}
 17894  	r.GetContent()
 17895  	r = nil
 17896  	r.GetContent()
 17897  }
 17898  
 17899  func TestRepositoryLicense_GetDownloadURL(tt *testing.T) {
 17900  	var zeroValue string
 17901  	r := &RepositoryLicense{DownloadURL: &zeroValue}
 17902  	r.GetDownloadURL()
 17903  	r = &RepositoryLicense{}
 17904  	r.GetDownloadURL()
 17905  	r = nil
 17906  	r.GetDownloadURL()
 17907  }
 17908  
 17909  func TestRepositoryLicense_GetEncoding(tt *testing.T) {
 17910  	var zeroValue string
 17911  	r := &RepositoryLicense{Encoding: &zeroValue}
 17912  	r.GetEncoding()
 17913  	r = &RepositoryLicense{}
 17914  	r.GetEncoding()
 17915  	r = nil
 17916  	r.GetEncoding()
 17917  }
 17918  
 17919  func TestRepositoryLicense_GetGitURL(tt *testing.T) {
 17920  	var zeroValue string
 17921  	r := &RepositoryLicense{GitURL: &zeroValue}
 17922  	r.GetGitURL()
 17923  	r = &RepositoryLicense{}
 17924  	r.GetGitURL()
 17925  	r = nil
 17926  	r.GetGitURL()
 17927  }
 17928  
 17929  func TestRepositoryLicense_GetHTMLURL(tt *testing.T) {
 17930  	var zeroValue string
 17931  	r := &RepositoryLicense{HTMLURL: &zeroValue}
 17932  	r.GetHTMLURL()
 17933  	r = &RepositoryLicense{}
 17934  	r.GetHTMLURL()
 17935  	r = nil
 17936  	r.GetHTMLURL()
 17937  }
 17938  
 17939  func TestRepositoryLicense_GetLicense(tt *testing.T) {
 17940  	r := &RepositoryLicense{}
 17941  	r.GetLicense()
 17942  	r = nil
 17943  	r.GetLicense()
 17944  }
 17945  
 17946  func TestRepositoryLicense_GetName(tt *testing.T) {
 17947  	var zeroValue string
 17948  	r := &RepositoryLicense{Name: &zeroValue}
 17949  	r.GetName()
 17950  	r = &RepositoryLicense{}
 17951  	r.GetName()
 17952  	r = nil
 17953  	r.GetName()
 17954  }
 17955  
 17956  func TestRepositoryLicense_GetPath(tt *testing.T) {
 17957  	var zeroValue string
 17958  	r := &RepositoryLicense{Path: &zeroValue}
 17959  	r.GetPath()
 17960  	r = &RepositoryLicense{}
 17961  	r.GetPath()
 17962  	r = nil
 17963  	r.GetPath()
 17964  }
 17965  
 17966  func TestRepositoryLicense_GetSHA(tt *testing.T) {
 17967  	var zeroValue string
 17968  	r := &RepositoryLicense{SHA: &zeroValue}
 17969  	r.GetSHA()
 17970  	r = &RepositoryLicense{}
 17971  	r.GetSHA()
 17972  	r = nil
 17973  	r.GetSHA()
 17974  }
 17975  
 17976  func TestRepositoryLicense_GetSize(tt *testing.T) {
 17977  	var zeroValue int
 17978  	r := &RepositoryLicense{Size: &zeroValue}
 17979  	r.GetSize()
 17980  	r = &RepositoryLicense{}
 17981  	r.GetSize()
 17982  	r = nil
 17983  	r.GetSize()
 17984  }
 17985  
 17986  func TestRepositoryLicense_GetType(tt *testing.T) {
 17987  	var zeroValue string
 17988  	r := &RepositoryLicense{Type: &zeroValue}
 17989  	r.GetType()
 17990  	r = &RepositoryLicense{}
 17991  	r.GetType()
 17992  	r = nil
 17993  	r.GetType()
 17994  }
 17995  
 17996  func TestRepositoryLicense_GetURL(tt *testing.T) {
 17997  	var zeroValue string
 17998  	r := &RepositoryLicense{URL: &zeroValue}
 17999  	r.GetURL()
 18000  	r = &RepositoryLicense{}
 18001  	r.GetURL()
 18002  	r = nil
 18003  	r.GetURL()
 18004  }
 18005  
 18006  func TestRepositoryMergeRequest_GetBase(tt *testing.T) {
 18007  	var zeroValue string
 18008  	r := &RepositoryMergeRequest{Base: &zeroValue}
 18009  	r.GetBase()
 18010  	r = &RepositoryMergeRequest{}
 18011  	r.GetBase()
 18012  	r = nil
 18013  	r.GetBase()
 18014  }
 18015  
 18016  func TestRepositoryMergeRequest_GetCommitMessage(tt *testing.T) {
 18017  	var zeroValue string
 18018  	r := &RepositoryMergeRequest{CommitMessage: &zeroValue}
 18019  	r.GetCommitMessage()
 18020  	r = &RepositoryMergeRequest{}
 18021  	r.GetCommitMessage()
 18022  	r = nil
 18023  	r.GetCommitMessage()
 18024  }
 18025  
 18026  func TestRepositoryMergeRequest_GetHead(tt *testing.T) {
 18027  	var zeroValue string
 18028  	r := &RepositoryMergeRequest{Head: &zeroValue}
 18029  	r.GetHead()
 18030  	r = &RepositoryMergeRequest{}
 18031  	r.GetHead()
 18032  	r = nil
 18033  	r.GetHead()
 18034  }
 18035  
 18036  func TestRepositoryPermissionLevel_GetPermission(tt *testing.T) {
 18037  	var zeroValue string
 18038  	r := &RepositoryPermissionLevel{Permission: &zeroValue}
 18039  	r.GetPermission()
 18040  	r = &RepositoryPermissionLevel{}
 18041  	r.GetPermission()
 18042  	r = nil
 18043  	r.GetPermission()
 18044  }
 18045  
 18046  func TestRepositoryPermissionLevel_GetUser(tt *testing.T) {
 18047  	r := &RepositoryPermissionLevel{}
 18048  	r.GetUser()
 18049  	r = nil
 18050  	r.GetUser()
 18051  }
 18052  
 18053  func TestRepositoryRelease_GetAssetsURL(tt *testing.T) {
 18054  	var zeroValue string
 18055  	r := &RepositoryRelease{AssetsURL: &zeroValue}
 18056  	r.GetAssetsURL()
 18057  	r = &RepositoryRelease{}
 18058  	r.GetAssetsURL()
 18059  	r = nil
 18060  	r.GetAssetsURL()
 18061  }
 18062  
 18063  func TestRepositoryRelease_GetAuthor(tt *testing.T) {
 18064  	r := &RepositoryRelease{}
 18065  	r.GetAuthor()
 18066  	r = nil
 18067  	r.GetAuthor()
 18068  }
 18069  
 18070  func TestRepositoryRelease_GetBody(tt *testing.T) {
 18071  	var zeroValue string
 18072  	r := &RepositoryRelease{Body: &zeroValue}
 18073  	r.GetBody()
 18074  	r = &RepositoryRelease{}
 18075  	r.GetBody()
 18076  	r = nil
 18077  	r.GetBody()
 18078  }
 18079  
 18080  func TestRepositoryRelease_GetCreatedAt(tt *testing.T) {
 18081  	var zeroValue Timestamp
 18082  	r := &RepositoryRelease{CreatedAt: &zeroValue}
 18083  	r.GetCreatedAt()
 18084  	r = &RepositoryRelease{}
 18085  	r.GetCreatedAt()
 18086  	r = nil
 18087  	r.GetCreatedAt()
 18088  }
 18089  
 18090  func TestRepositoryRelease_GetDiscussionCategoryName(tt *testing.T) {
 18091  	var zeroValue string
 18092  	r := &RepositoryRelease{DiscussionCategoryName: &zeroValue}
 18093  	r.GetDiscussionCategoryName()
 18094  	r = &RepositoryRelease{}
 18095  	r.GetDiscussionCategoryName()
 18096  	r = nil
 18097  	r.GetDiscussionCategoryName()
 18098  }
 18099  
 18100  func TestRepositoryRelease_GetDraft(tt *testing.T) {
 18101  	var zeroValue bool
 18102  	r := &RepositoryRelease{Draft: &zeroValue}
 18103  	r.GetDraft()
 18104  	r = &RepositoryRelease{}
 18105  	r.GetDraft()
 18106  	r = nil
 18107  	r.GetDraft()
 18108  }
 18109  
 18110  func TestRepositoryRelease_GetGenerateReleaseNotes(tt *testing.T) {
 18111  	var zeroValue bool
 18112  	r := &RepositoryRelease{GenerateReleaseNotes: &zeroValue}
 18113  	r.GetGenerateReleaseNotes()
 18114  	r = &RepositoryRelease{}
 18115  	r.GetGenerateReleaseNotes()
 18116  	r = nil
 18117  	r.GetGenerateReleaseNotes()
 18118  }
 18119  
 18120  func TestRepositoryRelease_GetHTMLURL(tt *testing.T) {
 18121  	var zeroValue string
 18122  	r := &RepositoryRelease{HTMLURL: &zeroValue}
 18123  	r.GetHTMLURL()
 18124  	r = &RepositoryRelease{}
 18125  	r.GetHTMLURL()
 18126  	r = nil
 18127  	r.GetHTMLURL()
 18128  }
 18129  
 18130  func TestRepositoryRelease_GetID(tt *testing.T) {
 18131  	var zeroValue int64
 18132  	r := &RepositoryRelease{ID: &zeroValue}
 18133  	r.GetID()
 18134  	r = &RepositoryRelease{}
 18135  	r.GetID()
 18136  	r = nil
 18137  	r.GetID()
 18138  }
 18139  
 18140  func TestRepositoryRelease_GetName(tt *testing.T) {
 18141  	var zeroValue string
 18142  	r := &RepositoryRelease{Name: &zeroValue}
 18143  	r.GetName()
 18144  	r = &RepositoryRelease{}
 18145  	r.GetName()
 18146  	r = nil
 18147  	r.GetName()
 18148  }
 18149  
 18150  func TestRepositoryRelease_GetNodeID(tt *testing.T) {
 18151  	var zeroValue string
 18152  	r := &RepositoryRelease{NodeID: &zeroValue}
 18153  	r.GetNodeID()
 18154  	r = &RepositoryRelease{}
 18155  	r.GetNodeID()
 18156  	r = nil
 18157  	r.GetNodeID()
 18158  }
 18159  
 18160  func TestRepositoryRelease_GetPrerelease(tt *testing.T) {
 18161  	var zeroValue bool
 18162  	r := &RepositoryRelease{Prerelease: &zeroValue}
 18163  	r.GetPrerelease()
 18164  	r = &RepositoryRelease{}
 18165  	r.GetPrerelease()
 18166  	r = nil
 18167  	r.GetPrerelease()
 18168  }
 18169  
 18170  func TestRepositoryRelease_GetPublishedAt(tt *testing.T) {
 18171  	var zeroValue Timestamp
 18172  	r := &RepositoryRelease{PublishedAt: &zeroValue}
 18173  	r.GetPublishedAt()
 18174  	r = &RepositoryRelease{}
 18175  	r.GetPublishedAt()
 18176  	r = nil
 18177  	r.GetPublishedAt()
 18178  }
 18179  
 18180  func TestRepositoryRelease_GetTagName(tt *testing.T) {
 18181  	var zeroValue string
 18182  	r := &RepositoryRelease{TagName: &zeroValue}
 18183  	r.GetTagName()
 18184  	r = &RepositoryRelease{}
 18185  	r.GetTagName()
 18186  	r = nil
 18187  	r.GetTagName()
 18188  }
 18189  
 18190  func TestRepositoryRelease_GetTarballURL(tt *testing.T) {
 18191  	var zeroValue string
 18192  	r := &RepositoryRelease{TarballURL: &zeroValue}
 18193  	r.GetTarballURL()
 18194  	r = &RepositoryRelease{}
 18195  	r.GetTarballURL()
 18196  	r = nil
 18197  	r.GetTarballURL()
 18198  }
 18199  
 18200  func TestRepositoryRelease_GetTargetCommitish(tt *testing.T) {
 18201  	var zeroValue string
 18202  	r := &RepositoryRelease{TargetCommitish: &zeroValue}
 18203  	r.GetTargetCommitish()
 18204  	r = &RepositoryRelease{}
 18205  	r.GetTargetCommitish()
 18206  	r = nil
 18207  	r.GetTargetCommitish()
 18208  }
 18209  
 18210  func TestRepositoryRelease_GetUploadURL(tt *testing.T) {
 18211  	var zeroValue string
 18212  	r := &RepositoryRelease{UploadURL: &zeroValue}
 18213  	r.GetUploadURL()
 18214  	r = &RepositoryRelease{}
 18215  	r.GetUploadURL()
 18216  	r = nil
 18217  	r.GetUploadURL()
 18218  }
 18219  
 18220  func TestRepositoryRelease_GetURL(tt *testing.T) {
 18221  	var zeroValue string
 18222  	r := &RepositoryRelease{URL: &zeroValue}
 18223  	r.GetURL()
 18224  	r = &RepositoryRelease{}
 18225  	r.GetURL()
 18226  	r = nil
 18227  	r.GetURL()
 18228  }
 18229  
 18230  func TestRepositoryRelease_GetZipballURL(tt *testing.T) {
 18231  	var zeroValue string
 18232  	r := &RepositoryRelease{ZipballURL: &zeroValue}
 18233  	r.GetZipballURL()
 18234  	r = &RepositoryRelease{}
 18235  	r.GetZipballURL()
 18236  	r = nil
 18237  	r.GetZipballURL()
 18238  }
 18239  
 18240  func TestRepositoryTag_GetCommit(tt *testing.T) {
 18241  	r := &RepositoryTag{}
 18242  	r.GetCommit()
 18243  	r = nil
 18244  	r.GetCommit()
 18245  }
 18246  
 18247  func TestRepositoryTag_GetName(tt *testing.T) {
 18248  	var zeroValue string
 18249  	r := &RepositoryTag{Name: &zeroValue}
 18250  	r.GetName()
 18251  	r = &RepositoryTag{}
 18252  	r.GetName()
 18253  	r = nil
 18254  	r.GetName()
 18255  }
 18256  
 18257  func TestRepositoryTag_GetTarballURL(tt *testing.T) {
 18258  	var zeroValue string
 18259  	r := &RepositoryTag{TarballURL: &zeroValue}
 18260  	r.GetTarballURL()
 18261  	r = &RepositoryTag{}
 18262  	r.GetTarballURL()
 18263  	r = nil
 18264  	r.GetTarballURL()
 18265  }
 18266  
 18267  func TestRepositoryTag_GetZipballURL(tt *testing.T) {
 18268  	var zeroValue string
 18269  	r := &RepositoryTag{ZipballURL: &zeroValue}
 18270  	r.GetZipballURL()
 18271  	r = &RepositoryTag{}
 18272  	r.GetZipballURL()
 18273  	r = nil
 18274  	r.GetZipballURL()
 18275  }
 18276  
 18277  func TestRepositoryVulnerabilityAlert_GetAffectedPackageName(tt *testing.T) {
 18278  	var zeroValue string
 18279  	r := &RepositoryVulnerabilityAlert{AffectedPackageName: &zeroValue}
 18280  	r.GetAffectedPackageName()
 18281  	r = &RepositoryVulnerabilityAlert{}
 18282  	r.GetAffectedPackageName()
 18283  	r = nil
 18284  	r.GetAffectedPackageName()
 18285  }
 18286  
 18287  func TestRepositoryVulnerabilityAlert_GetAffectedRange(tt *testing.T) {
 18288  	var zeroValue string
 18289  	r := &RepositoryVulnerabilityAlert{AffectedRange: &zeroValue}
 18290  	r.GetAffectedRange()
 18291  	r = &RepositoryVulnerabilityAlert{}
 18292  	r.GetAffectedRange()
 18293  	r = nil
 18294  	r.GetAffectedRange()
 18295  }
 18296  
 18297  func TestRepositoryVulnerabilityAlert_GetCreatedAt(tt *testing.T) {
 18298  	var zeroValue Timestamp
 18299  	r := &RepositoryVulnerabilityAlert{CreatedAt: &zeroValue}
 18300  	r.GetCreatedAt()
 18301  	r = &RepositoryVulnerabilityAlert{}
 18302  	r.GetCreatedAt()
 18303  	r = nil
 18304  	r.GetCreatedAt()
 18305  }
 18306  
 18307  func TestRepositoryVulnerabilityAlert_GetDismissedAt(tt *testing.T) {
 18308  	var zeroValue Timestamp
 18309  	r := &RepositoryVulnerabilityAlert{DismissedAt: &zeroValue}
 18310  	r.GetDismissedAt()
 18311  	r = &RepositoryVulnerabilityAlert{}
 18312  	r.GetDismissedAt()
 18313  	r = nil
 18314  	r.GetDismissedAt()
 18315  }
 18316  
 18317  func TestRepositoryVulnerabilityAlert_GetDismisser(tt *testing.T) {
 18318  	r := &RepositoryVulnerabilityAlert{}
 18319  	r.GetDismisser()
 18320  	r = nil
 18321  	r.GetDismisser()
 18322  }
 18323  
 18324  func TestRepositoryVulnerabilityAlert_GetDismissReason(tt *testing.T) {
 18325  	var zeroValue string
 18326  	r := &RepositoryVulnerabilityAlert{DismissReason: &zeroValue}
 18327  	r.GetDismissReason()
 18328  	r = &RepositoryVulnerabilityAlert{}
 18329  	r.GetDismissReason()
 18330  	r = nil
 18331  	r.GetDismissReason()
 18332  }
 18333  
 18334  func TestRepositoryVulnerabilityAlert_GetExternalIdentifier(tt *testing.T) {
 18335  	var zeroValue string
 18336  	r := &RepositoryVulnerabilityAlert{ExternalIdentifier: &zeroValue}
 18337  	r.GetExternalIdentifier()
 18338  	r = &RepositoryVulnerabilityAlert{}
 18339  	r.GetExternalIdentifier()
 18340  	r = nil
 18341  	r.GetExternalIdentifier()
 18342  }
 18343  
 18344  func TestRepositoryVulnerabilityAlert_GetExternalReference(tt *testing.T) {
 18345  	var zeroValue string
 18346  	r := &RepositoryVulnerabilityAlert{ExternalReference: &zeroValue}
 18347  	r.GetExternalReference()
 18348  	r = &RepositoryVulnerabilityAlert{}
 18349  	r.GetExternalReference()
 18350  	r = nil
 18351  	r.GetExternalReference()
 18352  }
 18353  
 18354  func TestRepositoryVulnerabilityAlert_GetFixedIn(tt *testing.T) {
 18355  	var zeroValue string
 18356  	r := &RepositoryVulnerabilityAlert{FixedIn: &zeroValue}
 18357  	r.GetFixedIn()
 18358  	r = &RepositoryVulnerabilityAlert{}
 18359  	r.GetFixedIn()
 18360  	r = nil
 18361  	r.GetFixedIn()
 18362  }
 18363  
 18364  func TestRepositoryVulnerabilityAlert_GetGitHubSecurityAdvisoryID(tt *testing.T) {
 18365  	var zeroValue string
 18366  	r := &RepositoryVulnerabilityAlert{GitHubSecurityAdvisoryID: &zeroValue}
 18367  	r.GetGitHubSecurityAdvisoryID()
 18368  	r = &RepositoryVulnerabilityAlert{}
 18369  	r.GetGitHubSecurityAdvisoryID()
 18370  	r = nil
 18371  	r.GetGitHubSecurityAdvisoryID()
 18372  }
 18373  
 18374  func TestRepositoryVulnerabilityAlert_GetID(tt *testing.T) {
 18375  	var zeroValue int64
 18376  	r := &RepositoryVulnerabilityAlert{ID: &zeroValue}
 18377  	r.GetID()
 18378  	r = &RepositoryVulnerabilityAlert{}
 18379  	r.GetID()
 18380  	r = nil
 18381  	r.GetID()
 18382  }
 18383  
 18384  func TestRepositoryVulnerabilityAlert_GetSeverity(tt *testing.T) {
 18385  	var zeroValue string
 18386  	r := &RepositoryVulnerabilityAlert{Severity: &zeroValue}
 18387  	r.GetSeverity()
 18388  	r = &RepositoryVulnerabilityAlert{}
 18389  	r.GetSeverity()
 18390  	r = nil
 18391  	r.GetSeverity()
 18392  }
 18393  
 18394  func TestRepositoryVulnerabilityAlertEvent_GetAction(tt *testing.T) {
 18395  	var zeroValue string
 18396  	r := &RepositoryVulnerabilityAlertEvent{Action: &zeroValue}
 18397  	r.GetAction()
 18398  	r = &RepositoryVulnerabilityAlertEvent{}
 18399  	r.GetAction()
 18400  	r = nil
 18401  	r.GetAction()
 18402  }
 18403  
 18404  func TestRepositoryVulnerabilityAlertEvent_GetAlert(tt *testing.T) {
 18405  	r := &RepositoryVulnerabilityAlertEvent{}
 18406  	r.GetAlert()
 18407  	r = nil
 18408  	r.GetAlert()
 18409  }
 18410  
 18411  func TestRepositoryVulnerabilityAlertEvent_GetInstallation(tt *testing.T) {
 18412  	r := &RepositoryVulnerabilityAlertEvent{}
 18413  	r.GetInstallation()
 18414  	r = nil
 18415  	r.GetInstallation()
 18416  }
 18417  
 18418  func TestRepositoryVulnerabilityAlertEvent_GetRepository(tt *testing.T) {
 18419  	r := &RepositoryVulnerabilityAlertEvent{}
 18420  	r.GetRepository()
 18421  	r = nil
 18422  	r.GetRepository()
 18423  }
 18424  
 18425  func TestRepositoryVulnerabilityAlertEvent_GetSender(tt *testing.T) {
 18426  	r := &RepositoryVulnerabilityAlertEvent{}
 18427  	r.GetSender()
 18428  	r = nil
 18429  	r.GetSender()
 18430  }
 18431  
 18432  func TestRepoStats_GetForkRepos(tt *testing.T) {
 18433  	var zeroValue int
 18434  	r := &RepoStats{ForkRepos: &zeroValue}
 18435  	r.GetForkRepos()
 18436  	r = &RepoStats{}
 18437  	r.GetForkRepos()
 18438  	r = nil
 18439  	r.GetForkRepos()
 18440  }
 18441  
 18442  func TestRepoStats_GetOrgRepos(tt *testing.T) {
 18443  	var zeroValue int
 18444  	r := &RepoStats{OrgRepos: &zeroValue}
 18445  	r.GetOrgRepos()
 18446  	r = &RepoStats{}
 18447  	r.GetOrgRepos()
 18448  	r = nil
 18449  	r.GetOrgRepos()
 18450  }
 18451  
 18452  func TestRepoStats_GetRootRepos(tt *testing.T) {
 18453  	var zeroValue int
 18454  	r := &RepoStats{RootRepos: &zeroValue}
 18455  	r.GetRootRepos()
 18456  	r = &RepoStats{}
 18457  	r.GetRootRepos()
 18458  	r = nil
 18459  	r.GetRootRepos()
 18460  }
 18461  
 18462  func TestRepoStats_GetTotalPushes(tt *testing.T) {
 18463  	var zeroValue int
 18464  	r := &RepoStats{TotalPushes: &zeroValue}
 18465  	r.GetTotalPushes()
 18466  	r = &RepoStats{}
 18467  	r.GetTotalPushes()
 18468  	r = nil
 18469  	r.GetTotalPushes()
 18470  }
 18471  
 18472  func TestRepoStats_GetTotalRepos(tt *testing.T) {
 18473  	var zeroValue int
 18474  	r := &RepoStats{TotalRepos: &zeroValue}
 18475  	r.GetTotalRepos()
 18476  	r = &RepoStats{}
 18477  	r.GetTotalRepos()
 18478  	r = nil
 18479  	r.GetTotalRepos()
 18480  }
 18481  
 18482  func TestRepoStats_GetTotalWikis(tt *testing.T) {
 18483  	var zeroValue int
 18484  	r := &RepoStats{TotalWikis: &zeroValue}
 18485  	r.GetTotalWikis()
 18486  	r = &RepoStats{}
 18487  	r.GetTotalWikis()
 18488  	r = nil
 18489  	r.GetTotalWikis()
 18490  }
 18491  
 18492  func TestRepoStatus_GetAvatarURL(tt *testing.T) {
 18493  	var zeroValue string
 18494  	r := &RepoStatus{AvatarURL: &zeroValue}
 18495  	r.GetAvatarURL()
 18496  	r = &RepoStatus{}
 18497  	r.GetAvatarURL()
 18498  	r = nil
 18499  	r.GetAvatarURL()
 18500  }
 18501  
 18502  func TestRepoStatus_GetContext(tt *testing.T) {
 18503  	var zeroValue string
 18504  	r := &RepoStatus{Context: &zeroValue}
 18505  	r.GetContext()
 18506  	r = &RepoStatus{}
 18507  	r.GetContext()
 18508  	r = nil
 18509  	r.GetContext()
 18510  }
 18511  
 18512  func TestRepoStatus_GetCreatedAt(tt *testing.T) {
 18513  	var zeroValue time.Time
 18514  	r := &RepoStatus{CreatedAt: &zeroValue}
 18515  	r.GetCreatedAt()
 18516  	r = &RepoStatus{}
 18517  	r.GetCreatedAt()
 18518  	r = nil
 18519  	r.GetCreatedAt()
 18520  }
 18521  
 18522  func TestRepoStatus_GetCreator(tt *testing.T) {
 18523  	r := &RepoStatus{}
 18524  	r.GetCreator()
 18525  	r = nil
 18526  	r.GetCreator()
 18527  }
 18528  
 18529  func TestRepoStatus_GetDescription(tt *testing.T) {
 18530  	var zeroValue string
 18531  	r := &RepoStatus{Description: &zeroValue}
 18532  	r.GetDescription()
 18533  	r = &RepoStatus{}
 18534  	r.GetDescription()
 18535  	r = nil
 18536  	r.GetDescription()
 18537  }
 18538  
 18539  func TestRepoStatus_GetID(tt *testing.T) {
 18540  	var zeroValue int64
 18541  	r := &RepoStatus{ID: &zeroValue}
 18542  	r.GetID()
 18543  	r = &RepoStatus{}
 18544  	r.GetID()
 18545  	r = nil
 18546  	r.GetID()
 18547  }
 18548  
 18549  func TestRepoStatus_GetNodeID(tt *testing.T) {
 18550  	var zeroValue string
 18551  	r := &RepoStatus{NodeID: &zeroValue}
 18552  	r.GetNodeID()
 18553  	r = &RepoStatus{}
 18554  	r.GetNodeID()
 18555  	r = nil
 18556  	r.GetNodeID()
 18557  }
 18558  
 18559  func TestRepoStatus_GetState(tt *testing.T) {
 18560  	var zeroValue string
 18561  	r := &RepoStatus{State: &zeroValue}
 18562  	r.GetState()
 18563  	r = &RepoStatus{}
 18564  	r.GetState()
 18565  	r = nil
 18566  	r.GetState()
 18567  }
 18568  
 18569  func TestRepoStatus_GetTargetURL(tt *testing.T) {
 18570  	var zeroValue string
 18571  	r := &RepoStatus{TargetURL: &zeroValue}
 18572  	r.GetTargetURL()
 18573  	r = &RepoStatus{}
 18574  	r.GetTargetURL()
 18575  	r = nil
 18576  	r.GetTargetURL()
 18577  }
 18578  
 18579  func TestRepoStatus_GetUpdatedAt(tt *testing.T) {
 18580  	var zeroValue time.Time
 18581  	r := &RepoStatus{UpdatedAt: &zeroValue}
 18582  	r.GetUpdatedAt()
 18583  	r = &RepoStatus{}
 18584  	r.GetUpdatedAt()
 18585  	r = nil
 18586  	r.GetUpdatedAt()
 18587  }
 18588  
 18589  func TestRepoStatus_GetURL(tt *testing.T) {
 18590  	var zeroValue string
 18591  	r := &RepoStatus{URL: &zeroValue}
 18592  	r.GetURL()
 18593  	r = &RepoStatus{}
 18594  	r.GetURL()
 18595  	r = nil
 18596  	r.GetURL()
 18597  }
 18598  
 18599  func TestRequiredReviewer_GetType(tt *testing.T) {
 18600  	var zeroValue string
 18601  	r := &RequiredReviewer{Type: &zeroValue}
 18602  	r.GetType()
 18603  	r = &RequiredReviewer{}
 18604  	r.GetType()
 18605  	r = nil
 18606  	r.GetType()
 18607  }
 18608  
 18609  func TestRequiredStatusCheck_GetAppID(tt *testing.T) {
 18610  	var zeroValue int64
 18611  	r := &RequiredStatusCheck{AppID: &zeroValue}
 18612  	r.GetAppID()
 18613  	r = &RequiredStatusCheck{}
 18614  	r.GetAppID()
 18615  	r = nil
 18616  	r.GetAppID()
 18617  }
 18618  
 18619  func TestRequiredStatusChecksRequest_GetStrict(tt *testing.T) {
 18620  	var zeroValue bool
 18621  	r := &RequiredStatusChecksRequest{Strict: &zeroValue}
 18622  	r.GetStrict()
 18623  	r = &RequiredStatusChecksRequest{}
 18624  	r.GetStrict()
 18625  	r = nil
 18626  	r.GetStrict()
 18627  }
 18628  
 18629  func TestReviewersRequest_GetNodeID(tt *testing.T) {
 18630  	var zeroValue string
 18631  	r := &ReviewersRequest{NodeID: &zeroValue}
 18632  	r.GetNodeID()
 18633  	r = &ReviewersRequest{}
 18634  	r.GetNodeID()
 18635  	r = nil
 18636  	r.GetNodeID()
 18637  }
 18638  
 18639  func TestRule_GetDescription(tt *testing.T) {
 18640  	var zeroValue string
 18641  	r := &Rule{Description: &zeroValue}
 18642  	r.GetDescription()
 18643  	r = &Rule{}
 18644  	r.GetDescription()
 18645  	r = nil
 18646  	r.GetDescription()
 18647  }
 18648  
 18649  func TestRule_GetFullDescription(tt *testing.T) {
 18650  	var zeroValue string
 18651  	r := &Rule{FullDescription: &zeroValue}
 18652  	r.GetFullDescription()
 18653  	r = &Rule{}
 18654  	r.GetFullDescription()
 18655  	r = nil
 18656  	r.GetFullDescription()
 18657  }
 18658  
 18659  func TestRule_GetHelp(tt *testing.T) {
 18660  	var zeroValue string
 18661  	r := &Rule{Help: &zeroValue}
 18662  	r.GetHelp()
 18663  	r = &Rule{}
 18664  	r.GetHelp()
 18665  	r = nil
 18666  	r.GetHelp()
 18667  }
 18668  
 18669  func TestRule_GetID(tt *testing.T) {
 18670  	var zeroValue string
 18671  	r := &Rule{ID: &zeroValue}
 18672  	r.GetID()
 18673  	r = &Rule{}
 18674  	r.GetID()
 18675  	r = nil
 18676  	r.GetID()
 18677  }
 18678  
 18679  func TestRule_GetName(tt *testing.T) {
 18680  	var zeroValue string
 18681  	r := &Rule{Name: &zeroValue}
 18682  	r.GetName()
 18683  	r = &Rule{}
 18684  	r.GetName()
 18685  	r = nil
 18686  	r.GetName()
 18687  }
 18688  
 18689  func TestRule_GetSecuritySeverityLevel(tt *testing.T) {
 18690  	var zeroValue string
 18691  	r := &Rule{SecuritySeverityLevel: &zeroValue}
 18692  	r.GetSecuritySeverityLevel()
 18693  	r = &Rule{}
 18694  	r.GetSecuritySeverityLevel()
 18695  	r = nil
 18696  	r.GetSecuritySeverityLevel()
 18697  }
 18698  
 18699  func TestRule_GetSeverity(tt *testing.T) {
 18700  	var zeroValue string
 18701  	r := &Rule{Severity: &zeroValue}
 18702  	r.GetSeverity()
 18703  	r = &Rule{}
 18704  	r.GetSeverity()
 18705  	r = nil
 18706  	r.GetSeverity()
 18707  }
 18708  
 18709  func TestRunner_GetBusy(tt *testing.T) {
 18710  	var zeroValue bool
 18711  	r := &Runner{Busy: &zeroValue}
 18712  	r.GetBusy()
 18713  	r = &Runner{}
 18714  	r.GetBusy()
 18715  	r = nil
 18716  	r.GetBusy()
 18717  }
 18718  
 18719  func TestRunner_GetID(tt *testing.T) {
 18720  	var zeroValue int64
 18721  	r := &Runner{ID: &zeroValue}
 18722  	r.GetID()
 18723  	r = &Runner{}
 18724  	r.GetID()
 18725  	r = nil
 18726  	r.GetID()
 18727  }
 18728  
 18729  func TestRunner_GetName(tt *testing.T) {
 18730  	var zeroValue string
 18731  	r := &Runner{Name: &zeroValue}
 18732  	r.GetName()
 18733  	r = &Runner{}
 18734  	r.GetName()
 18735  	r = nil
 18736  	r.GetName()
 18737  }
 18738  
 18739  func TestRunner_GetOS(tt *testing.T) {
 18740  	var zeroValue string
 18741  	r := &Runner{OS: &zeroValue}
 18742  	r.GetOS()
 18743  	r = &Runner{}
 18744  	r.GetOS()
 18745  	r = nil
 18746  	r.GetOS()
 18747  }
 18748  
 18749  func TestRunner_GetStatus(tt *testing.T) {
 18750  	var zeroValue string
 18751  	r := &Runner{Status: &zeroValue}
 18752  	r.GetStatus()
 18753  	r = &Runner{}
 18754  	r.GetStatus()
 18755  	r = nil
 18756  	r.GetStatus()
 18757  }
 18758  
 18759  func TestRunnerApplicationDownload_GetArchitecture(tt *testing.T) {
 18760  	var zeroValue string
 18761  	r := &RunnerApplicationDownload{Architecture: &zeroValue}
 18762  	r.GetArchitecture()
 18763  	r = &RunnerApplicationDownload{}
 18764  	r.GetArchitecture()
 18765  	r = nil
 18766  	r.GetArchitecture()
 18767  }
 18768  
 18769  func TestRunnerApplicationDownload_GetDownloadURL(tt *testing.T) {
 18770  	var zeroValue string
 18771  	r := &RunnerApplicationDownload{DownloadURL: &zeroValue}
 18772  	r.GetDownloadURL()
 18773  	r = &RunnerApplicationDownload{}
 18774  	r.GetDownloadURL()
 18775  	r = nil
 18776  	r.GetDownloadURL()
 18777  }
 18778  
 18779  func TestRunnerApplicationDownload_GetFilename(tt *testing.T) {
 18780  	var zeroValue string
 18781  	r := &RunnerApplicationDownload{Filename: &zeroValue}
 18782  	r.GetFilename()
 18783  	r = &RunnerApplicationDownload{}
 18784  	r.GetFilename()
 18785  	r = nil
 18786  	r.GetFilename()
 18787  }
 18788  
 18789  func TestRunnerApplicationDownload_GetOS(tt *testing.T) {
 18790  	var zeroValue string
 18791  	r := &RunnerApplicationDownload{OS: &zeroValue}
 18792  	r.GetOS()
 18793  	r = &RunnerApplicationDownload{}
 18794  	r.GetOS()
 18795  	r = nil
 18796  	r.GetOS()
 18797  }
 18798  
 18799  func TestRunnerApplicationDownload_GetSHA256Checksum(tt *testing.T) {
 18800  	var zeroValue string
 18801  	r := &RunnerApplicationDownload{SHA256Checksum: &zeroValue}
 18802  	r.GetSHA256Checksum()
 18803  	r = &RunnerApplicationDownload{}
 18804  	r.GetSHA256Checksum()
 18805  	r = nil
 18806  	r.GetSHA256Checksum()
 18807  }
 18808  
 18809  func TestRunnerApplicationDownload_GetTempDownloadToken(tt *testing.T) {
 18810  	var zeroValue string
 18811  	r := &RunnerApplicationDownload{TempDownloadToken: &zeroValue}
 18812  	r.GetTempDownloadToken()
 18813  	r = &RunnerApplicationDownload{}
 18814  	r.GetTempDownloadToken()
 18815  	r = nil
 18816  	r.GetTempDownloadToken()
 18817  }
 18818  
 18819  func TestRunnerGroup_GetAllowsPublicRepositories(tt *testing.T) {
 18820  	var zeroValue bool
 18821  	r := &RunnerGroup{AllowsPublicRepositories: &zeroValue}
 18822  	r.GetAllowsPublicRepositories()
 18823  	r = &RunnerGroup{}
 18824  	r.GetAllowsPublicRepositories()
 18825  	r = nil
 18826  	r.GetAllowsPublicRepositories()
 18827  }
 18828  
 18829  func TestRunnerGroup_GetDefault(tt *testing.T) {
 18830  	var zeroValue bool
 18831  	r := &RunnerGroup{Default: &zeroValue}
 18832  	r.GetDefault()
 18833  	r = &RunnerGroup{}
 18834  	r.GetDefault()
 18835  	r = nil
 18836  	r.GetDefault()
 18837  }
 18838  
 18839  func TestRunnerGroup_GetID(tt *testing.T) {
 18840  	var zeroValue int64
 18841  	r := &RunnerGroup{ID: &zeroValue}
 18842  	r.GetID()
 18843  	r = &RunnerGroup{}
 18844  	r.GetID()
 18845  	r = nil
 18846  	r.GetID()
 18847  }
 18848  
 18849  func TestRunnerGroup_GetInherited(tt *testing.T) {
 18850  	var zeroValue bool
 18851  	r := &RunnerGroup{Inherited: &zeroValue}
 18852  	r.GetInherited()
 18853  	r = &RunnerGroup{}
 18854  	r.GetInherited()
 18855  	r = nil
 18856  	r.GetInherited()
 18857  }
 18858  
 18859  func TestRunnerGroup_GetName(tt *testing.T) {
 18860  	var zeroValue string
 18861  	r := &RunnerGroup{Name: &zeroValue}
 18862  	r.GetName()
 18863  	r = &RunnerGroup{}
 18864  	r.GetName()
 18865  	r = nil
 18866  	r.GetName()
 18867  }
 18868  
 18869  func TestRunnerGroup_GetRunnersURL(tt *testing.T) {
 18870  	var zeroValue string
 18871  	r := &RunnerGroup{RunnersURL: &zeroValue}
 18872  	r.GetRunnersURL()
 18873  	r = &RunnerGroup{}
 18874  	r.GetRunnersURL()
 18875  	r = nil
 18876  	r.GetRunnersURL()
 18877  }
 18878  
 18879  func TestRunnerGroup_GetSelectedRepositoriesURL(tt *testing.T) {
 18880  	var zeroValue string
 18881  	r := &RunnerGroup{SelectedRepositoriesURL: &zeroValue}
 18882  	r.GetSelectedRepositoriesURL()
 18883  	r = &RunnerGroup{}
 18884  	r.GetSelectedRepositoriesURL()
 18885  	r = nil
 18886  	r.GetSelectedRepositoriesURL()
 18887  }
 18888  
 18889  func TestRunnerGroup_GetVisibility(tt *testing.T) {
 18890  	var zeroValue string
 18891  	r := &RunnerGroup{Visibility: &zeroValue}
 18892  	r.GetVisibility()
 18893  	r = &RunnerGroup{}
 18894  	r.GetVisibility()
 18895  	r = nil
 18896  	r.GetVisibility()
 18897  }
 18898  
 18899  func TestRunnerLabels_GetID(tt *testing.T) {
 18900  	var zeroValue int64
 18901  	r := &RunnerLabels{ID: &zeroValue}
 18902  	r.GetID()
 18903  	r = &RunnerLabels{}
 18904  	r.GetID()
 18905  	r = nil
 18906  	r.GetID()
 18907  }
 18908  
 18909  func TestRunnerLabels_GetName(tt *testing.T) {
 18910  	var zeroValue string
 18911  	r := &RunnerLabels{Name: &zeroValue}
 18912  	r.GetName()
 18913  	r = &RunnerLabels{}
 18914  	r.GetName()
 18915  	r = nil
 18916  	r.GetName()
 18917  }
 18918  
 18919  func TestRunnerLabels_GetType(tt *testing.T) {
 18920  	var zeroValue string
 18921  	r := &RunnerLabels{Type: &zeroValue}
 18922  	r.GetType()
 18923  	r = &RunnerLabels{}
 18924  	r.GetType()
 18925  	r = nil
 18926  	r.GetType()
 18927  }
 18928  
 18929  func TestSarifAnalysis_GetCheckoutURI(tt *testing.T) {
 18930  	var zeroValue string
 18931  	s := &SarifAnalysis{CheckoutURI: &zeroValue}
 18932  	s.GetCheckoutURI()
 18933  	s = &SarifAnalysis{}
 18934  	s.GetCheckoutURI()
 18935  	s = nil
 18936  	s.GetCheckoutURI()
 18937  }
 18938  
 18939  func TestSarifAnalysis_GetCommitSHA(tt *testing.T) {
 18940  	var zeroValue string
 18941  	s := &SarifAnalysis{CommitSHA: &zeroValue}
 18942  	s.GetCommitSHA()
 18943  	s = &SarifAnalysis{}
 18944  	s.GetCommitSHA()
 18945  	s = nil
 18946  	s.GetCommitSHA()
 18947  }
 18948  
 18949  func TestSarifAnalysis_GetRef(tt *testing.T) {
 18950  	var zeroValue string
 18951  	s := &SarifAnalysis{Ref: &zeroValue}
 18952  	s.GetRef()
 18953  	s = &SarifAnalysis{}
 18954  	s.GetRef()
 18955  	s = nil
 18956  	s.GetRef()
 18957  }
 18958  
 18959  func TestSarifAnalysis_GetSarif(tt *testing.T) {
 18960  	var zeroValue string
 18961  	s := &SarifAnalysis{Sarif: &zeroValue}
 18962  	s.GetSarif()
 18963  	s = &SarifAnalysis{}
 18964  	s.GetSarif()
 18965  	s = nil
 18966  	s.GetSarif()
 18967  }
 18968  
 18969  func TestSarifAnalysis_GetStartedAt(tt *testing.T) {
 18970  	var zeroValue Timestamp
 18971  	s := &SarifAnalysis{StartedAt: &zeroValue}
 18972  	s.GetStartedAt()
 18973  	s = &SarifAnalysis{}
 18974  	s.GetStartedAt()
 18975  	s = nil
 18976  	s.GetStartedAt()
 18977  }
 18978  
 18979  func TestSarifAnalysis_GetToolName(tt *testing.T) {
 18980  	var zeroValue string
 18981  	s := &SarifAnalysis{ToolName: &zeroValue}
 18982  	s.GetToolName()
 18983  	s = &SarifAnalysis{}
 18984  	s.GetToolName()
 18985  	s = nil
 18986  	s.GetToolName()
 18987  }
 18988  
 18989  func TestSarifID_GetID(tt *testing.T) {
 18990  	var zeroValue string
 18991  	s := &SarifID{ID: &zeroValue}
 18992  	s.GetID()
 18993  	s = &SarifID{}
 18994  	s.GetID()
 18995  	s = nil
 18996  	s.GetID()
 18997  }
 18998  
 18999  func TestSarifID_GetURL(tt *testing.T) {
 19000  	var zeroValue string
 19001  	s := &SarifID{URL: &zeroValue}
 19002  	s.GetURL()
 19003  	s = &SarifID{}
 19004  	s.GetURL()
 19005  	s = nil
 19006  	s.GetURL()
 19007  }
 19008  
 19009  func TestScanningAnalysis_GetAnalysisKey(tt *testing.T) {
 19010  	var zeroValue string
 19011  	s := &ScanningAnalysis{AnalysisKey: &zeroValue}
 19012  	s.GetAnalysisKey()
 19013  	s = &ScanningAnalysis{}
 19014  	s.GetAnalysisKey()
 19015  	s = nil
 19016  	s.GetAnalysisKey()
 19017  }
 19018  
 19019  func TestScanningAnalysis_GetCategory(tt *testing.T) {
 19020  	var zeroValue string
 19021  	s := &ScanningAnalysis{Category: &zeroValue}
 19022  	s.GetCategory()
 19023  	s = &ScanningAnalysis{}
 19024  	s.GetCategory()
 19025  	s = nil
 19026  	s.GetCategory()
 19027  }
 19028  
 19029  func TestScanningAnalysis_GetCommitSHA(tt *testing.T) {
 19030  	var zeroValue string
 19031  	s := &ScanningAnalysis{CommitSHA: &zeroValue}
 19032  	s.GetCommitSHA()
 19033  	s = &ScanningAnalysis{}
 19034  	s.GetCommitSHA()
 19035  	s = nil
 19036  	s.GetCommitSHA()
 19037  }
 19038  
 19039  func TestScanningAnalysis_GetCreatedAt(tt *testing.T) {
 19040  	var zeroValue Timestamp
 19041  	s := &ScanningAnalysis{CreatedAt: &zeroValue}
 19042  	s.GetCreatedAt()
 19043  	s = &ScanningAnalysis{}
 19044  	s.GetCreatedAt()
 19045  	s = nil
 19046  	s.GetCreatedAt()
 19047  }
 19048  
 19049  func TestScanningAnalysis_GetDeletable(tt *testing.T) {
 19050  	var zeroValue bool
 19051  	s := &ScanningAnalysis{Deletable: &zeroValue}
 19052  	s.GetDeletable()
 19053  	s = &ScanningAnalysis{}
 19054  	s.GetDeletable()
 19055  	s = nil
 19056  	s.GetDeletable()
 19057  }
 19058  
 19059  func TestScanningAnalysis_GetEnvironment(tt *testing.T) {
 19060  	var zeroValue string
 19061  	s := &ScanningAnalysis{Environment: &zeroValue}
 19062  	s.GetEnvironment()
 19063  	s = &ScanningAnalysis{}
 19064  	s.GetEnvironment()
 19065  	s = nil
 19066  	s.GetEnvironment()
 19067  }
 19068  
 19069  func TestScanningAnalysis_GetError(tt *testing.T) {
 19070  	var zeroValue string
 19071  	s := &ScanningAnalysis{Error: &zeroValue}
 19072  	s.GetError()
 19073  	s = &ScanningAnalysis{}
 19074  	s.GetError()
 19075  	s = nil
 19076  	s.GetError()
 19077  }
 19078  
 19079  func TestScanningAnalysis_GetID(tt *testing.T) {
 19080  	var zeroValue int64
 19081  	s := &ScanningAnalysis{ID: &zeroValue}
 19082  	s.GetID()
 19083  	s = &ScanningAnalysis{}
 19084  	s.GetID()
 19085  	s = nil
 19086  	s.GetID()
 19087  }
 19088  
 19089  func TestScanningAnalysis_GetRef(tt *testing.T) {
 19090  	var zeroValue string
 19091  	s := &ScanningAnalysis{Ref: &zeroValue}
 19092  	s.GetRef()
 19093  	s = &ScanningAnalysis{}
 19094  	s.GetRef()
 19095  	s = nil
 19096  	s.GetRef()
 19097  }
 19098  
 19099  func TestScanningAnalysis_GetResultsCount(tt *testing.T) {
 19100  	var zeroValue int
 19101  	s := &ScanningAnalysis{ResultsCount: &zeroValue}
 19102  	s.GetResultsCount()
 19103  	s = &ScanningAnalysis{}
 19104  	s.GetResultsCount()
 19105  	s = nil
 19106  	s.GetResultsCount()
 19107  }
 19108  
 19109  func TestScanningAnalysis_GetRulesCount(tt *testing.T) {
 19110  	var zeroValue int
 19111  	s := &ScanningAnalysis{RulesCount: &zeroValue}
 19112  	s.GetRulesCount()
 19113  	s = &ScanningAnalysis{}
 19114  	s.GetRulesCount()
 19115  	s = nil
 19116  	s.GetRulesCount()
 19117  }
 19118  
 19119  func TestScanningAnalysis_GetSarifID(tt *testing.T) {
 19120  	var zeroValue string
 19121  	s := &ScanningAnalysis{SarifID: &zeroValue}
 19122  	s.GetSarifID()
 19123  	s = &ScanningAnalysis{}
 19124  	s.GetSarifID()
 19125  	s = nil
 19126  	s.GetSarifID()
 19127  }
 19128  
 19129  func TestScanningAnalysis_GetTool(tt *testing.T) {
 19130  	s := &ScanningAnalysis{}
 19131  	s.GetTool()
 19132  	s = nil
 19133  	s.GetTool()
 19134  }
 19135  
 19136  func TestScanningAnalysis_GetURL(tt *testing.T) {
 19137  	var zeroValue string
 19138  	s := &ScanningAnalysis{URL: &zeroValue}
 19139  	s.GetURL()
 19140  	s = &ScanningAnalysis{}
 19141  	s.GetURL()
 19142  	s = nil
 19143  	s.GetURL()
 19144  }
 19145  
 19146  func TestScanningAnalysis_GetWarning(tt *testing.T) {
 19147  	var zeroValue string
 19148  	s := &ScanningAnalysis{Warning: &zeroValue}
 19149  	s.GetWarning()
 19150  	s = &ScanningAnalysis{}
 19151  	s.GetWarning()
 19152  	s = nil
 19153  	s.GetWarning()
 19154  }
 19155  
 19156  func TestSCIMUserAttributes_GetActive(tt *testing.T) {
 19157  	var zeroValue bool
 19158  	s := &SCIMUserAttributes{Active: &zeroValue}
 19159  	s.GetActive()
 19160  	s = &SCIMUserAttributes{}
 19161  	s.GetActive()
 19162  	s = nil
 19163  	s.GetActive()
 19164  }
 19165  
 19166  func TestSCIMUserAttributes_GetDisplayName(tt *testing.T) {
 19167  	var zeroValue string
 19168  	s := &SCIMUserAttributes{DisplayName: &zeroValue}
 19169  	s.GetDisplayName()
 19170  	s = &SCIMUserAttributes{}
 19171  	s.GetDisplayName()
 19172  	s = nil
 19173  	s.GetDisplayName()
 19174  }
 19175  
 19176  func TestSCIMUserAttributes_GetExternalID(tt *testing.T) {
 19177  	var zeroValue string
 19178  	s := &SCIMUserAttributes{ExternalID: &zeroValue}
 19179  	s.GetExternalID()
 19180  	s = &SCIMUserAttributes{}
 19181  	s.GetExternalID()
 19182  	s = nil
 19183  	s.GetExternalID()
 19184  }
 19185  
 19186  func TestSCIMUserEmail_GetPrimary(tt *testing.T) {
 19187  	var zeroValue bool
 19188  	s := &SCIMUserEmail{Primary: &zeroValue}
 19189  	s.GetPrimary()
 19190  	s = &SCIMUserEmail{}
 19191  	s.GetPrimary()
 19192  	s = nil
 19193  	s.GetPrimary()
 19194  }
 19195  
 19196  func TestSCIMUserEmail_GetType(tt *testing.T) {
 19197  	var zeroValue string
 19198  	s := &SCIMUserEmail{Type: &zeroValue}
 19199  	s.GetType()
 19200  	s = &SCIMUserEmail{}
 19201  	s.GetType()
 19202  	s = nil
 19203  	s.GetType()
 19204  }
 19205  
 19206  func TestSCIMUserName_GetFormatted(tt *testing.T) {
 19207  	var zeroValue string
 19208  	s := &SCIMUserName{Formatted: &zeroValue}
 19209  	s.GetFormatted()
 19210  	s = &SCIMUserName{}
 19211  	s.GetFormatted()
 19212  	s = nil
 19213  	s.GetFormatted()
 19214  }
 19215  
 19216  func TestSecretScanning_GetStatus(tt *testing.T) {
 19217  	var zeroValue string
 19218  	s := &SecretScanning{Status: &zeroValue}
 19219  	s.GetStatus()
 19220  	s = &SecretScanning{}
 19221  	s.GetStatus()
 19222  	s = nil
 19223  	s.GetStatus()
 19224  }
 19225  
 19226  func TestSecretScanningAlert_GetCreatedAt(tt *testing.T) {
 19227  	var zeroValue Timestamp
 19228  	s := &SecretScanningAlert{CreatedAt: &zeroValue}
 19229  	s.GetCreatedAt()
 19230  	s = &SecretScanningAlert{}
 19231  	s.GetCreatedAt()
 19232  	s = nil
 19233  	s.GetCreatedAt()
 19234  }
 19235  
 19236  func TestSecretScanningAlert_GetHTMLURL(tt *testing.T) {
 19237  	var zeroValue string
 19238  	s := &SecretScanningAlert{HTMLURL: &zeroValue}
 19239  	s.GetHTMLURL()
 19240  	s = &SecretScanningAlert{}
 19241  	s.GetHTMLURL()
 19242  	s = nil
 19243  	s.GetHTMLURL()
 19244  }
 19245  
 19246  func TestSecretScanningAlert_GetLocationsURL(tt *testing.T) {
 19247  	var zeroValue string
 19248  	s := &SecretScanningAlert{LocationsURL: &zeroValue}
 19249  	s.GetLocationsURL()
 19250  	s = &SecretScanningAlert{}
 19251  	s.GetLocationsURL()
 19252  	s = nil
 19253  	s.GetLocationsURL()
 19254  }
 19255  
 19256  func TestSecretScanningAlert_GetNumber(tt *testing.T) {
 19257  	var zeroValue int
 19258  	s := &SecretScanningAlert{Number: &zeroValue}
 19259  	s.GetNumber()
 19260  	s = &SecretScanningAlert{}
 19261  	s.GetNumber()
 19262  	s = nil
 19263  	s.GetNumber()
 19264  }
 19265  
 19266  func TestSecretScanningAlert_GetResolution(tt *testing.T) {
 19267  	var zeroValue string
 19268  	s := &SecretScanningAlert{Resolution: &zeroValue}
 19269  	s.GetResolution()
 19270  	s = &SecretScanningAlert{}
 19271  	s.GetResolution()
 19272  	s = nil
 19273  	s.GetResolution()
 19274  }
 19275  
 19276  func TestSecretScanningAlert_GetResolvedAt(tt *testing.T) {
 19277  	var zeroValue Timestamp
 19278  	s := &SecretScanningAlert{ResolvedAt: &zeroValue}
 19279  	s.GetResolvedAt()
 19280  	s = &SecretScanningAlert{}
 19281  	s.GetResolvedAt()
 19282  	s = nil
 19283  	s.GetResolvedAt()
 19284  }
 19285  
 19286  func TestSecretScanningAlert_GetResolvedBy(tt *testing.T) {
 19287  	s := &SecretScanningAlert{}
 19288  	s.GetResolvedBy()
 19289  	s = nil
 19290  	s.GetResolvedBy()
 19291  }
 19292  
 19293  func TestSecretScanningAlert_GetSecret(tt *testing.T) {
 19294  	var zeroValue string
 19295  	s := &SecretScanningAlert{Secret: &zeroValue}
 19296  	s.GetSecret()
 19297  	s = &SecretScanningAlert{}
 19298  	s.GetSecret()
 19299  	s = nil
 19300  	s.GetSecret()
 19301  }
 19302  
 19303  func TestSecretScanningAlert_GetSecretType(tt *testing.T) {
 19304  	var zeroValue string
 19305  	s := &SecretScanningAlert{SecretType: &zeroValue}
 19306  	s.GetSecretType()
 19307  	s = &SecretScanningAlert{}
 19308  	s.GetSecretType()
 19309  	s = nil
 19310  	s.GetSecretType()
 19311  }
 19312  
 19313  func TestSecretScanningAlert_GetState(tt *testing.T) {
 19314  	var zeroValue string
 19315  	s := &SecretScanningAlert{State: &zeroValue}
 19316  	s.GetState()
 19317  	s = &SecretScanningAlert{}
 19318  	s.GetState()
 19319  	s = nil
 19320  	s.GetState()
 19321  }
 19322  
 19323  func TestSecretScanningAlert_GetURL(tt *testing.T) {
 19324  	var zeroValue string
 19325  	s := &SecretScanningAlert{URL: &zeroValue}
 19326  	s.GetURL()
 19327  	s = &SecretScanningAlert{}
 19328  	s.GetURL()
 19329  	s = nil
 19330  	s.GetURL()
 19331  }
 19332  
 19333  func TestSecretScanningAlertEvent_GetAction(tt *testing.T) {
 19334  	var zeroValue string
 19335  	s := &SecretScanningAlertEvent{Action: &zeroValue}
 19336  	s.GetAction()
 19337  	s = &SecretScanningAlertEvent{}
 19338  	s.GetAction()
 19339  	s = nil
 19340  	s.GetAction()
 19341  }
 19342  
 19343  func TestSecretScanningAlertEvent_GetAlert(tt *testing.T) {
 19344  	s := &SecretScanningAlertEvent{}
 19345  	s.GetAlert()
 19346  	s = nil
 19347  	s.GetAlert()
 19348  }
 19349  
 19350  func TestSecretScanningAlertEvent_GetEnterprise(tt *testing.T) {
 19351  	s := &SecretScanningAlertEvent{}
 19352  	s.GetEnterprise()
 19353  	s = nil
 19354  	s.GetEnterprise()
 19355  }
 19356  
 19357  func TestSecretScanningAlertEvent_GetInstallation(tt *testing.T) {
 19358  	s := &SecretScanningAlertEvent{}
 19359  	s.GetInstallation()
 19360  	s = nil
 19361  	s.GetInstallation()
 19362  }
 19363  
 19364  func TestSecretScanningAlertEvent_GetOrganization(tt *testing.T) {
 19365  	s := &SecretScanningAlertEvent{}
 19366  	s.GetOrganization()
 19367  	s = nil
 19368  	s.GetOrganization()
 19369  }
 19370  
 19371  func TestSecretScanningAlertEvent_GetRepo(tt *testing.T) {
 19372  	s := &SecretScanningAlertEvent{}
 19373  	s.GetRepo()
 19374  	s = nil
 19375  	s.GetRepo()
 19376  }
 19377  
 19378  func TestSecretScanningAlertEvent_GetSender(tt *testing.T) {
 19379  	s := &SecretScanningAlertEvent{}
 19380  	s.GetSender()
 19381  	s = nil
 19382  	s.GetSender()
 19383  }
 19384  
 19385  func TestSecretScanningAlertLocation_GetDetails(tt *testing.T) {
 19386  	s := &SecretScanningAlertLocation{}
 19387  	s.GetDetails()
 19388  	s = nil
 19389  	s.GetDetails()
 19390  }
 19391  
 19392  func TestSecretScanningAlertLocation_GetType(tt *testing.T) {
 19393  	var zeroValue string
 19394  	s := &SecretScanningAlertLocation{Type: &zeroValue}
 19395  	s.GetType()
 19396  	s = &SecretScanningAlertLocation{}
 19397  	s.GetType()
 19398  	s = nil
 19399  	s.GetType()
 19400  }
 19401  
 19402  func TestSecretScanningAlertLocationDetails_GetBlobSHA(tt *testing.T) {
 19403  	var zeroValue string
 19404  	s := &SecretScanningAlertLocationDetails{BlobSHA: &zeroValue}
 19405  	s.GetBlobSHA()
 19406  	s = &SecretScanningAlertLocationDetails{}
 19407  	s.GetBlobSHA()
 19408  	s = nil
 19409  	s.GetBlobSHA()
 19410  }
 19411  
 19412  func TestSecretScanningAlertLocationDetails_GetBlobURL(tt *testing.T) {
 19413  	var zeroValue string
 19414  	s := &SecretScanningAlertLocationDetails{BlobURL: &zeroValue}
 19415  	s.GetBlobURL()
 19416  	s = &SecretScanningAlertLocationDetails{}
 19417  	s.GetBlobURL()
 19418  	s = nil
 19419  	s.GetBlobURL()
 19420  }
 19421  
 19422  func TestSecretScanningAlertLocationDetails_GetCommitSHA(tt *testing.T) {
 19423  	var zeroValue string
 19424  	s := &SecretScanningAlertLocationDetails{CommitSHA: &zeroValue}
 19425  	s.GetCommitSHA()
 19426  	s = &SecretScanningAlertLocationDetails{}
 19427  	s.GetCommitSHA()
 19428  	s = nil
 19429  	s.GetCommitSHA()
 19430  }
 19431  
 19432  func TestSecretScanningAlertLocationDetails_GetCommitURL(tt *testing.T) {
 19433  	var zeroValue string
 19434  	s := &SecretScanningAlertLocationDetails{CommitURL: &zeroValue}
 19435  	s.GetCommitURL()
 19436  	s = &SecretScanningAlertLocationDetails{}
 19437  	s.GetCommitURL()
 19438  	s = nil
 19439  	s.GetCommitURL()
 19440  }
 19441  
 19442  func TestSecretScanningAlertLocationDetails_GetEndColumn(tt *testing.T) {
 19443  	var zeroValue int
 19444  	s := &SecretScanningAlertLocationDetails{EndColumn: &zeroValue}
 19445  	s.GetEndColumn()
 19446  	s = &SecretScanningAlertLocationDetails{}
 19447  	s.GetEndColumn()
 19448  	s = nil
 19449  	s.GetEndColumn()
 19450  }
 19451  
 19452  func TestSecretScanningAlertLocationDetails_GetEndLine(tt *testing.T) {
 19453  	var zeroValue int
 19454  	s := &SecretScanningAlertLocationDetails{EndLine: &zeroValue}
 19455  	s.GetEndLine()
 19456  	s = &SecretScanningAlertLocationDetails{}
 19457  	s.GetEndLine()
 19458  	s = nil
 19459  	s.GetEndLine()
 19460  }
 19461  
 19462  func TestSecretScanningAlertLocationDetails_GetPath(tt *testing.T) {
 19463  	var zeroValue string
 19464  	s := &SecretScanningAlertLocationDetails{Path: &zeroValue}
 19465  	s.GetPath()
 19466  	s = &SecretScanningAlertLocationDetails{}
 19467  	s.GetPath()
 19468  	s = nil
 19469  	s.GetPath()
 19470  }
 19471  
 19472  func TestSecretScanningAlertLocationDetails_GetStartColumn(tt *testing.T) {
 19473  	var zeroValue int
 19474  	s := &SecretScanningAlertLocationDetails{StartColumn: &zeroValue}
 19475  	s.GetStartColumn()
 19476  	s = &SecretScanningAlertLocationDetails{}
 19477  	s.GetStartColumn()
 19478  	s = nil
 19479  	s.GetStartColumn()
 19480  }
 19481  
 19482  func TestSecretScanningAlertLocationDetails_GetStartline(tt *testing.T) {
 19483  	var zeroValue int
 19484  	s := &SecretScanningAlertLocationDetails{Startline: &zeroValue}
 19485  	s.GetStartline()
 19486  	s = &SecretScanningAlertLocationDetails{}
 19487  	s.GetStartline()
 19488  	s = nil
 19489  	s.GetStartline()
 19490  }
 19491  
 19492  func TestSecretScanningAlertUpdateOptions_GetResolution(tt *testing.T) {
 19493  	var zeroValue string
 19494  	s := &SecretScanningAlertUpdateOptions{Resolution: &zeroValue}
 19495  	s.GetResolution()
 19496  	s = &SecretScanningAlertUpdateOptions{}
 19497  	s.GetResolution()
 19498  	s = nil
 19499  	s.GetResolution()
 19500  }
 19501  
 19502  func TestSecretScanningAlertUpdateOptions_GetSecretType(tt *testing.T) {
 19503  	var zeroValue string
 19504  	s := &SecretScanningAlertUpdateOptions{SecretType: &zeroValue}
 19505  	s.GetSecretType()
 19506  	s = &SecretScanningAlertUpdateOptions{}
 19507  	s.GetSecretType()
 19508  	s = nil
 19509  	s.GetSecretType()
 19510  }
 19511  
 19512  func TestSecretScanningAlertUpdateOptions_GetState(tt *testing.T) {
 19513  	var zeroValue string
 19514  	s := &SecretScanningAlertUpdateOptions{State: &zeroValue}
 19515  	s.GetState()
 19516  	s = &SecretScanningAlertUpdateOptions{}
 19517  	s.GetState()
 19518  	s = nil
 19519  	s.GetState()
 19520  }
 19521  
 19522  func TestSecurityAdvisory_GetDescription(tt *testing.T) {
 19523  	var zeroValue string
 19524  	s := &SecurityAdvisory{Description: &zeroValue}
 19525  	s.GetDescription()
 19526  	s = &SecurityAdvisory{}
 19527  	s.GetDescription()
 19528  	s = nil
 19529  	s.GetDescription()
 19530  }
 19531  
 19532  func TestSecurityAdvisory_GetGHSAID(tt *testing.T) {
 19533  	var zeroValue string
 19534  	s := &SecurityAdvisory{GHSAID: &zeroValue}
 19535  	s.GetGHSAID()
 19536  	s = &SecurityAdvisory{}
 19537  	s.GetGHSAID()
 19538  	s = nil
 19539  	s.GetGHSAID()
 19540  }
 19541  
 19542  func TestSecurityAdvisory_GetPublishedAt(tt *testing.T) {
 19543  	var zeroValue Timestamp
 19544  	s := &SecurityAdvisory{PublishedAt: &zeroValue}
 19545  	s.GetPublishedAt()
 19546  	s = &SecurityAdvisory{}
 19547  	s.GetPublishedAt()
 19548  	s = nil
 19549  	s.GetPublishedAt()
 19550  }
 19551  
 19552  func TestSecurityAdvisory_GetSeverity(tt *testing.T) {
 19553  	var zeroValue string
 19554  	s := &SecurityAdvisory{Severity: &zeroValue}
 19555  	s.GetSeverity()
 19556  	s = &SecurityAdvisory{}
 19557  	s.GetSeverity()
 19558  	s = nil
 19559  	s.GetSeverity()
 19560  }
 19561  
 19562  func TestSecurityAdvisory_GetSummary(tt *testing.T) {
 19563  	var zeroValue string
 19564  	s := &SecurityAdvisory{Summary: &zeroValue}
 19565  	s.GetSummary()
 19566  	s = &SecurityAdvisory{}
 19567  	s.GetSummary()
 19568  	s = nil
 19569  	s.GetSummary()
 19570  }
 19571  
 19572  func TestSecurityAdvisory_GetUpdatedAt(tt *testing.T) {
 19573  	var zeroValue Timestamp
 19574  	s := &SecurityAdvisory{UpdatedAt: &zeroValue}
 19575  	s.GetUpdatedAt()
 19576  	s = &SecurityAdvisory{}
 19577  	s.GetUpdatedAt()
 19578  	s = nil
 19579  	s.GetUpdatedAt()
 19580  }
 19581  
 19582  func TestSecurityAdvisory_GetWithdrawnAt(tt *testing.T) {
 19583  	var zeroValue Timestamp
 19584  	s := &SecurityAdvisory{WithdrawnAt: &zeroValue}
 19585  	s.GetWithdrawnAt()
 19586  	s = &SecurityAdvisory{}
 19587  	s.GetWithdrawnAt()
 19588  	s = nil
 19589  	s.GetWithdrawnAt()
 19590  }
 19591  
 19592  func TestSecurityAdvisoryEvent_GetAction(tt *testing.T) {
 19593  	var zeroValue string
 19594  	s := &SecurityAdvisoryEvent{Action: &zeroValue}
 19595  	s.GetAction()
 19596  	s = &SecurityAdvisoryEvent{}
 19597  	s.GetAction()
 19598  	s = nil
 19599  	s.GetAction()
 19600  }
 19601  
 19602  func TestSecurityAdvisoryEvent_GetSecurityAdvisory(tt *testing.T) {
 19603  	s := &SecurityAdvisoryEvent{}
 19604  	s.GetSecurityAdvisory()
 19605  	s = nil
 19606  	s.GetSecurityAdvisory()
 19607  }
 19608  
 19609  func TestSecurityAndAnalysis_GetAdvancedSecurity(tt *testing.T) {
 19610  	s := &SecurityAndAnalysis{}
 19611  	s.GetAdvancedSecurity()
 19612  	s = nil
 19613  	s.GetAdvancedSecurity()
 19614  }
 19615  
 19616  func TestSecurityAndAnalysis_GetSecretScanning(tt *testing.T) {
 19617  	s := &SecurityAndAnalysis{}
 19618  	s.GetSecretScanning()
 19619  	s = nil
 19620  	s.GetSecretScanning()
 19621  }
 19622  
 19623  func TestSelectedReposList_GetTotalCount(tt *testing.T) {
 19624  	var zeroValue int
 19625  	s := &SelectedReposList{TotalCount: &zeroValue}
 19626  	s.GetTotalCount()
 19627  	s = &SelectedReposList{}
 19628  	s.GetTotalCount()
 19629  	s = nil
 19630  	s.GetTotalCount()
 19631  }
 19632  
 19633  func TestServiceHook_GetName(tt *testing.T) {
 19634  	var zeroValue string
 19635  	s := &ServiceHook{Name: &zeroValue}
 19636  	s.GetName()
 19637  	s = &ServiceHook{}
 19638  	s.GetName()
 19639  	s = nil
 19640  	s.GetName()
 19641  }
 19642  
 19643  func TestSignaturesProtectedBranch_GetEnabled(tt *testing.T) {
 19644  	var zeroValue bool
 19645  	s := &SignaturesProtectedBranch{Enabled: &zeroValue}
 19646  	s.GetEnabled()
 19647  	s = &SignaturesProtectedBranch{}
 19648  	s.GetEnabled()
 19649  	s = nil
 19650  	s.GetEnabled()
 19651  }
 19652  
 19653  func TestSignaturesProtectedBranch_GetURL(tt *testing.T) {
 19654  	var zeroValue string
 19655  	s := &SignaturesProtectedBranch{URL: &zeroValue}
 19656  	s.GetURL()
 19657  	s = &SignaturesProtectedBranch{}
 19658  	s.GetURL()
 19659  	s = nil
 19660  	s.GetURL()
 19661  }
 19662  
 19663  func TestSignatureVerification_GetPayload(tt *testing.T) {
 19664  	var zeroValue string
 19665  	s := &SignatureVerification{Payload: &zeroValue}
 19666  	s.GetPayload()
 19667  	s = &SignatureVerification{}
 19668  	s.GetPayload()
 19669  	s = nil
 19670  	s.GetPayload()
 19671  }
 19672  
 19673  func TestSignatureVerification_GetReason(tt *testing.T) {
 19674  	var zeroValue string
 19675  	s := &SignatureVerification{Reason: &zeroValue}
 19676  	s.GetReason()
 19677  	s = &SignatureVerification{}
 19678  	s.GetReason()
 19679  	s = nil
 19680  	s.GetReason()
 19681  }
 19682  
 19683  func TestSignatureVerification_GetSignature(tt *testing.T) {
 19684  	var zeroValue string
 19685  	s := &SignatureVerification{Signature: &zeroValue}
 19686  	s.GetSignature()
 19687  	s = &SignatureVerification{}
 19688  	s.GetSignature()
 19689  	s = nil
 19690  	s.GetSignature()
 19691  }
 19692  
 19693  func TestSignatureVerification_GetVerified(tt *testing.T) {
 19694  	var zeroValue bool
 19695  	s := &SignatureVerification{Verified: &zeroValue}
 19696  	s.GetVerified()
 19697  	s = &SignatureVerification{}
 19698  	s.GetVerified()
 19699  	s = nil
 19700  	s.GetVerified()
 19701  }
 19702  
 19703  func TestSource_GetActor(tt *testing.T) {
 19704  	s := &Source{}
 19705  	s.GetActor()
 19706  	s = nil
 19707  	s.GetActor()
 19708  }
 19709  
 19710  func TestSource_GetID(tt *testing.T) {
 19711  	var zeroValue int64
 19712  	s := &Source{ID: &zeroValue}
 19713  	s.GetID()
 19714  	s = &Source{}
 19715  	s.GetID()
 19716  	s = nil
 19717  	s.GetID()
 19718  }
 19719  
 19720  func TestSource_GetIssue(tt *testing.T) {
 19721  	s := &Source{}
 19722  	s.GetIssue()
 19723  	s = nil
 19724  	s.GetIssue()
 19725  }
 19726  
 19727  func TestSource_GetType(tt *testing.T) {
 19728  	var zeroValue string
 19729  	s := &Source{Type: &zeroValue}
 19730  	s.GetType()
 19731  	s = &Source{}
 19732  	s.GetType()
 19733  	s = nil
 19734  	s.GetType()
 19735  }
 19736  
 19737  func TestSource_GetURL(tt *testing.T) {
 19738  	var zeroValue string
 19739  	s := &Source{URL: &zeroValue}
 19740  	s.GetURL()
 19741  	s = &Source{}
 19742  	s.GetURL()
 19743  	s = nil
 19744  	s.GetURL()
 19745  }
 19746  
 19747  func TestSourceImportAuthor_GetEmail(tt *testing.T) {
 19748  	var zeroValue string
 19749  	s := &SourceImportAuthor{Email: &zeroValue}
 19750  	s.GetEmail()
 19751  	s = &SourceImportAuthor{}
 19752  	s.GetEmail()
 19753  	s = nil
 19754  	s.GetEmail()
 19755  }
 19756  
 19757  func TestSourceImportAuthor_GetID(tt *testing.T) {
 19758  	var zeroValue int64
 19759  	s := &SourceImportAuthor{ID: &zeroValue}
 19760  	s.GetID()
 19761  	s = &SourceImportAuthor{}
 19762  	s.GetID()
 19763  	s = nil
 19764  	s.GetID()
 19765  }
 19766  
 19767  func TestSourceImportAuthor_GetImportURL(tt *testing.T) {
 19768  	var zeroValue string
 19769  	s := &SourceImportAuthor{ImportURL: &zeroValue}
 19770  	s.GetImportURL()
 19771  	s = &SourceImportAuthor{}
 19772  	s.GetImportURL()
 19773  	s = nil
 19774  	s.GetImportURL()
 19775  }
 19776  
 19777  func TestSourceImportAuthor_GetName(tt *testing.T) {
 19778  	var zeroValue string
 19779  	s := &SourceImportAuthor{Name: &zeroValue}
 19780  	s.GetName()
 19781  	s = &SourceImportAuthor{}
 19782  	s.GetName()
 19783  	s = nil
 19784  	s.GetName()
 19785  }
 19786  
 19787  func TestSourceImportAuthor_GetRemoteID(tt *testing.T) {
 19788  	var zeroValue string
 19789  	s := &SourceImportAuthor{RemoteID: &zeroValue}
 19790  	s.GetRemoteID()
 19791  	s = &SourceImportAuthor{}
 19792  	s.GetRemoteID()
 19793  	s = nil
 19794  	s.GetRemoteID()
 19795  }
 19796  
 19797  func TestSourceImportAuthor_GetRemoteName(tt *testing.T) {
 19798  	var zeroValue string
 19799  	s := &SourceImportAuthor{RemoteName: &zeroValue}
 19800  	s.GetRemoteName()
 19801  	s = &SourceImportAuthor{}
 19802  	s.GetRemoteName()
 19803  	s = nil
 19804  	s.GetRemoteName()
 19805  }
 19806  
 19807  func TestSourceImportAuthor_GetURL(tt *testing.T) {
 19808  	var zeroValue string
 19809  	s := &SourceImportAuthor{URL: &zeroValue}
 19810  	s.GetURL()
 19811  	s = &SourceImportAuthor{}
 19812  	s.GetURL()
 19813  	s = nil
 19814  	s.GetURL()
 19815  }
 19816  
 19817  func TestStarEvent_GetAction(tt *testing.T) {
 19818  	var zeroValue string
 19819  	s := &StarEvent{Action: &zeroValue}
 19820  	s.GetAction()
 19821  	s = &StarEvent{}
 19822  	s.GetAction()
 19823  	s = nil
 19824  	s.GetAction()
 19825  }
 19826  
 19827  func TestStarEvent_GetInstallation(tt *testing.T) {
 19828  	s := &StarEvent{}
 19829  	s.GetInstallation()
 19830  	s = nil
 19831  	s.GetInstallation()
 19832  }
 19833  
 19834  func TestStarEvent_GetOrg(tt *testing.T) {
 19835  	s := &StarEvent{}
 19836  	s.GetOrg()
 19837  	s = nil
 19838  	s.GetOrg()
 19839  }
 19840  
 19841  func TestStarEvent_GetRepo(tt *testing.T) {
 19842  	s := &StarEvent{}
 19843  	s.GetRepo()
 19844  	s = nil
 19845  	s.GetRepo()
 19846  }
 19847  
 19848  func TestStarEvent_GetSender(tt *testing.T) {
 19849  	s := &StarEvent{}
 19850  	s.GetSender()
 19851  	s = nil
 19852  	s.GetSender()
 19853  }
 19854  
 19855  func TestStarEvent_GetStarredAt(tt *testing.T) {
 19856  	var zeroValue Timestamp
 19857  	s := &StarEvent{StarredAt: &zeroValue}
 19858  	s.GetStarredAt()
 19859  	s = &StarEvent{}
 19860  	s.GetStarredAt()
 19861  	s = nil
 19862  	s.GetStarredAt()
 19863  }
 19864  
 19865  func TestStargazer_GetStarredAt(tt *testing.T) {
 19866  	var zeroValue Timestamp
 19867  	s := &Stargazer{StarredAt: &zeroValue}
 19868  	s.GetStarredAt()
 19869  	s = &Stargazer{}
 19870  	s.GetStarredAt()
 19871  	s = nil
 19872  	s.GetStarredAt()
 19873  }
 19874  
 19875  func TestStargazer_GetUser(tt *testing.T) {
 19876  	s := &Stargazer{}
 19877  	s.GetUser()
 19878  	s = nil
 19879  	s.GetUser()
 19880  }
 19881  
 19882  func TestStarredRepository_GetRepository(tt *testing.T) {
 19883  	s := &StarredRepository{}
 19884  	s.GetRepository()
 19885  	s = nil
 19886  	s.GetRepository()
 19887  }
 19888  
 19889  func TestStarredRepository_GetStarredAt(tt *testing.T) {
 19890  	var zeroValue Timestamp
 19891  	s := &StarredRepository{StarredAt: &zeroValue}
 19892  	s.GetStarredAt()
 19893  	s = &StarredRepository{}
 19894  	s.GetStarredAt()
 19895  	s = nil
 19896  	s.GetStarredAt()
 19897  }
 19898  
 19899  func TestStatusEvent_GetCommit(tt *testing.T) {
 19900  	s := &StatusEvent{}
 19901  	s.GetCommit()
 19902  	s = nil
 19903  	s.GetCommit()
 19904  }
 19905  
 19906  func TestStatusEvent_GetContext(tt *testing.T) {
 19907  	var zeroValue string
 19908  	s := &StatusEvent{Context: &zeroValue}
 19909  	s.GetContext()
 19910  	s = &StatusEvent{}
 19911  	s.GetContext()
 19912  	s = nil
 19913  	s.GetContext()
 19914  }
 19915  
 19916  func TestStatusEvent_GetCreatedAt(tt *testing.T) {
 19917  	var zeroValue Timestamp
 19918  	s := &StatusEvent{CreatedAt: &zeroValue}
 19919  	s.GetCreatedAt()
 19920  	s = &StatusEvent{}
 19921  	s.GetCreatedAt()
 19922  	s = nil
 19923  	s.GetCreatedAt()
 19924  }
 19925  
 19926  func TestStatusEvent_GetDescription(tt *testing.T) {
 19927  	var zeroValue string
 19928  	s := &StatusEvent{Description: &zeroValue}
 19929  	s.GetDescription()
 19930  	s = &StatusEvent{}
 19931  	s.GetDescription()
 19932  	s = nil
 19933  	s.GetDescription()
 19934  }
 19935  
 19936  func TestStatusEvent_GetID(tt *testing.T) {
 19937  	var zeroValue int64
 19938  	s := &StatusEvent{ID: &zeroValue}
 19939  	s.GetID()
 19940  	s = &StatusEvent{}
 19941  	s.GetID()
 19942  	s = nil
 19943  	s.GetID()
 19944  }
 19945  
 19946  func TestStatusEvent_GetInstallation(tt *testing.T) {
 19947  	s := &StatusEvent{}
 19948  	s.GetInstallation()
 19949  	s = nil
 19950  	s.GetInstallation()
 19951  }
 19952  
 19953  func TestStatusEvent_GetName(tt *testing.T) {
 19954  	var zeroValue string
 19955  	s := &StatusEvent{Name: &zeroValue}
 19956  	s.GetName()
 19957  	s = &StatusEvent{}
 19958  	s.GetName()
 19959  	s = nil
 19960  	s.GetName()
 19961  }
 19962  
 19963  func TestStatusEvent_GetRepo(tt *testing.T) {
 19964  	s := &StatusEvent{}
 19965  	s.GetRepo()
 19966  	s = nil
 19967  	s.GetRepo()
 19968  }
 19969  
 19970  func TestStatusEvent_GetSender(tt *testing.T) {
 19971  	s := &StatusEvent{}
 19972  	s.GetSender()
 19973  	s = nil
 19974  	s.GetSender()
 19975  }
 19976  
 19977  func TestStatusEvent_GetSHA(tt *testing.T) {
 19978  	var zeroValue string
 19979  	s := &StatusEvent{SHA: &zeroValue}
 19980  	s.GetSHA()
 19981  	s = &StatusEvent{}
 19982  	s.GetSHA()
 19983  	s = nil
 19984  	s.GetSHA()
 19985  }
 19986  
 19987  func TestStatusEvent_GetState(tt *testing.T) {
 19988  	var zeroValue string
 19989  	s := &StatusEvent{State: &zeroValue}
 19990  	s.GetState()
 19991  	s = &StatusEvent{}
 19992  	s.GetState()
 19993  	s = nil
 19994  	s.GetState()
 19995  }
 19996  
 19997  func TestStatusEvent_GetTargetURL(tt *testing.T) {
 19998  	var zeroValue string
 19999  	s := &StatusEvent{TargetURL: &zeroValue}
 20000  	s.GetTargetURL()
 20001  	s = &StatusEvent{}
 20002  	s.GetTargetURL()
 20003  	s = nil
 20004  	s.GetTargetURL()
 20005  }
 20006  
 20007  func TestStatusEvent_GetUpdatedAt(tt *testing.T) {
 20008  	var zeroValue Timestamp
 20009  	s := &StatusEvent{UpdatedAt: &zeroValue}
 20010  	s.GetUpdatedAt()
 20011  	s = &StatusEvent{}
 20012  	s.GetUpdatedAt()
 20013  	s = nil
 20014  	s.GetUpdatedAt()
 20015  }
 20016  
 20017  func TestSubscription_GetCreatedAt(tt *testing.T) {
 20018  	var zeroValue Timestamp
 20019  	s := &Subscription{CreatedAt: &zeroValue}
 20020  	s.GetCreatedAt()
 20021  	s = &Subscription{}
 20022  	s.GetCreatedAt()
 20023  	s = nil
 20024  	s.GetCreatedAt()
 20025  }
 20026  
 20027  func TestSubscription_GetIgnored(tt *testing.T) {
 20028  	var zeroValue bool
 20029  	s := &Subscription{Ignored: &zeroValue}
 20030  	s.GetIgnored()
 20031  	s = &Subscription{}
 20032  	s.GetIgnored()
 20033  	s = nil
 20034  	s.GetIgnored()
 20035  }
 20036  
 20037  func TestSubscription_GetReason(tt *testing.T) {
 20038  	var zeroValue string
 20039  	s := &Subscription{Reason: &zeroValue}
 20040  	s.GetReason()
 20041  	s = &Subscription{}
 20042  	s.GetReason()
 20043  	s = nil
 20044  	s.GetReason()
 20045  }
 20046  
 20047  func TestSubscription_GetRepositoryURL(tt *testing.T) {
 20048  	var zeroValue string
 20049  	s := &Subscription{RepositoryURL: &zeroValue}
 20050  	s.GetRepositoryURL()
 20051  	s = &Subscription{}
 20052  	s.GetRepositoryURL()
 20053  	s = nil
 20054  	s.GetRepositoryURL()
 20055  }
 20056  
 20057  func TestSubscription_GetSubscribed(tt *testing.T) {
 20058  	var zeroValue bool
 20059  	s := &Subscription{Subscribed: &zeroValue}
 20060  	s.GetSubscribed()
 20061  	s = &Subscription{}
 20062  	s.GetSubscribed()
 20063  	s = nil
 20064  	s.GetSubscribed()
 20065  }
 20066  
 20067  func TestSubscription_GetThreadURL(tt *testing.T) {
 20068  	var zeroValue string
 20069  	s := &Subscription{ThreadURL: &zeroValue}
 20070  	s.GetThreadURL()
 20071  	s = &Subscription{}
 20072  	s.GetThreadURL()
 20073  	s = nil
 20074  	s.GetThreadURL()
 20075  }
 20076  
 20077  func TestSubscription_GetURL(tt *testing.T) {
 20078  	var zeroValue string
 20079  	s := &Subscription{URL: &zeroValue}
 20080  	s.GetURL()
 20081  	s = &Subscription{}
 20082  	s.GetURL()
 20083  	s = nil
 20084  	s.GetURL()
 20085  }
 20086  
 20087  func TestTag_GetMessage(tt *testing.T) {
 20088  	var zeroValue string
 20089  	t := &Tag{Message: &zeroValue}
 20090  	t.GetMessage()
 20091  	t = &Tag{}
 20092  	t.GetMessage()
 20093  	t = nil
 20094  	t.GetMessage()
 20095  }
 20096  
 20097  func TestTag_GetNodeID(tt *testing.T) {
 20098  	var zeroValue string
 20099  	t := &Tag{NodeID: &zeroValue}
 20100  	t.GetNodeID()
 20101  	t = &Tag{}
 20102  	t.GetNodeID()
 20103  	t = nil
 20104  	t.GetNodeID()
 20105  }
 20106  
 20107  func TestTag_GetObject(tt *testing.T) {
 20108  	t := &Tag{}
 20109  	t.GetObject()
 20110  	t = nil
 20111  	t.GetObject()
 20112  }
 20113  
 20114  func TestTag_GetSHA(tt *testing.T) {
 20115  	var zeroValue string
 20116  	t := &Tag{SHA: &zeroValue}
 20117  	t.GetSHA()
 20118  	t = &Tag{}
 20119  	t.GetSHA()
 20120  	t = nil
 20121  	t.GetSHA()
 20122  }
 20123  
 20124  func TestTag_GetTag(tt *testing.T) {
 20125  	var zeroValue string
 20126  	t := &Tag{Tag: &zeroValue}
 20127  	t.GetTag()
 20128  	t = &Tag{}
 20129  	t.GetTag()
 20130  	t = nil
 20131  	t.GetTag()
 20132  }
 20133  
 20134  func TestTag_GetTagger(tt *testing.T) {
 20135  	t := &Tag{}
 20136  	t.GetTagger()
 20137  	t = nil
 20138  	t.GetTagger()
 20139  }
 20140  
 20141  func TestTag_GetURL(tt *testing.T) {
 20142  	var zeroValue string
 20143  	t := &Tag{URL: &zeroValue}
 20144  	t.GetURL()
 20145  	t = &Tag{}
 20146  	t.GetURL()
 20147  	t = nil
 20148  	t.GetURL()
 20149  }
 20150  
 20151  func TestTag_GetVerification(tt *testing.T) {
 20152  	t := &Tag{}
 20153  	t.GetVerification()
 20154  	t = nil
 20155  	t.GetVerification()
 20156  }
 20157  
 20158  func TestTaskStep_GetCompletedAt(tt *testing.T) {
 20159  	var zeroValue Timestamp
 20160  	t := &TaskStep{CompletedAt: &zeroValue}
 20161  	t.GetCompletedAt()
 20162  	t = &TaskStep{}
 20163  	t.GetCompletedAt()
 20164  	t = nil
 20165  	t.GetCompletedAt()
 20166  }
 20167  
 20168  func TestTaskStep_GetConclusion(tt *testing.T) {
 20169  	var zeroValue string
 20170  	t := &TaskStep{Conclusion: &zeroValue}
 20171  	t.GetConclusion()
 20172  	t = &TaskStep{}
 20173  	t.GetConclusion()
 20174  	t = nil
 20175  	t.GetConclusion()
 20176  }
 20177  
 20178  func TestTaskStep_GetName(tt *testing.T) {
 20179  	var zeroValue string
 20180  	t := &TaskStep{Name: &zeroValue}
 20181  	t.GetName()
 20182  	t = &TaskStep{}
 20183  	t.GetName()
 20184  	t = nil
 20185  	t.GetName()
 20186  }
 20187  
 20188  func TestTaskStep_GetNumber(tt *testing.T) {
 20189  	var zeroValue int64
 20190  	t := &TaskStep{Number: &zeroValue}
 20191  	t.GetNumber()
 20192  	t = &TaskStep{}
 20193  	t.GetNumber()
 20194  	t = nil
 20195  	t.GetNumber()
 20196  }
 20197  
 20198  func TestTaskStep_GetStartedAt(tt *testing.T) {
 20199  	var zeroValue Timestamp
 20200  	t := &TaskStep{StartedAt: &zeroValue}
 20201  	t.GetStartedAt()
 20202  	t = &TaskStep{}
 20203  	t.GetStartedAt()
 20204  	t = nil
 20205  	t.GetStartedAt()
 20206  }
 20207  
 20208  func TestTaskStep_GetStatus(tt *testing.T) {
 20209  	var zeroValue string
 20210  	t := &TaskStep{Status: &zeroValue}
 20211  	t.GetStatus()
 20212  	t = &TaskStep{}
 20213  	t.GetStatus()
 20214  	t = nil
 20215  	t.GetStatus()
 20216  }
 20217  
 20218  func TestTeam_GetDescription(tt *testing.T) {
 20219  	var zeroValue string
 20220  	t := &Team{Description: &zeroValue}
 20221  	t.GetDescription()
 20222  	t = &Team{}
 20223  	t.GetDescription()
 20224  	t = nil
 20225  	t.GetDescription()
 20226  }
 20227  
 20228  func TestTeam_GetHTMLURL(tt *testing.T) {
 20229  	var zeroValue string
 20230  	t := &Team{HTMLURL: &zeroValue}
 20231  	t.GetHTMLURL()
 20232  	t = &Team{}
 20233  	t.GetHTMLURL()
 20234  	t = nil
 20235  	t.GetHTMLURL()
 20236  }
 20237  
 20238  func TestTeam_GetID(tt *testing.T) {
 20239  	var zeroValue int64
 20240  	t := &Team{ID: &zeroValue}
 20241  	t.GetID()
 20242  	t = &Team{}
 20243  	t.GetID()
 20244  	t = nil
 20245  	t.GetID()
 20246  }
 20247  
 20248  func TestTeam_GetLDAPDN(tt *testing.T) {
 20249  	var zeroValue string
 20250  	t := &Team{LDAPDN: &zeroValue}
 20251  	t.GetLDAPDN()
 20252  	t = &Team{}
 20253  	t.GetLDAPDN()
 20254  	t = nil
 20255  	t.GetLDAPDN()
 20256  }
 20257  
 20258  func TestTeam_GetMembersCount(tt *testing.T) {
 20259  	var zeroValue int
 20260  	t := &Team{MembersCount: &zeroValue}
 20261  	t.GetMembersCount()
 20262  	t = &Team{}
 20263  	t.GetMembersCount()
 20264  	t = nil
 20265  	t.GetMembersCount()
 20266  }
 20267  
 20268  func TestTeam_GetMembersURL(tt *testing.T) {
 20269  	var zeroValue string
 20270  	t := &Team{MembersURL: &zeroValue}
 20271  	t.GetMembersURL()
 20272  	t = &Team{}
 20273  	t.GetMembersURL()
 20274  	t = nil
 20275  	t.GetMembersURL()
 20276  }
 20277  
 20278  func TestTeam_GetName(tt *testing.T) {
 20279  	var zeroValue string
 20280  	t := &Team{Name: &zeroValue}
 20281  	t.GetName()
 20282  	t = &Team{}
 20283  	t.GetName()
 20284  	t = nil
 20285  	t.GetName()
 20286  }
 20287  
 20288  func TestTeam_GetNodeID(tt *testing.T) {
 20289  	var zeroValue string
 20290  	t := &Team{NodeID: &zeroValue}
 20291  	t.GetNodeID()
 20292  	t = &Team{}
 20293  	t.GetNodeID()
 20294  	t = nil
 20295  	t.GetNodeID()
 20296  }
 20297  
 20298  func TestTeam_GetOrganization(tt *testing.T) {
 20299  	t := &Team{}
 20300  	t.GetOrganization()
 20301  	t = nil
 20302  	t.GetOrganization()
 20303  }
 20304  
 20305  func TestTeam_GetParent(tt *testing.T) {
 20306  	t := &Team{}
 20307  	t.GetParent()
 20308  	t = nil
 20309  	t.GetParent()
 20310  }
 20311  
 20312  func TestTeam_GetPermission(tt *testing.T) {
 20313  	var zeroValue string
 20314  	t := &Team{Permission: &zeroValue}
 20315  	t.GetPermission()
 20316  	t = &Team{}
 20317  	t.GetPermission()
 20318  	t = nil
 20319  	t.GetPermission()
 20320  }
 20321  
 20322  func TestTeam_GetPermissions(tt *testing.T) {
 20323  	zeroValue := map[string]bool{}
 20324  	t := &Team{Permissions: zeroValue}
 20325  	t.GetPermissions()
 20326  	t = &Team{}
 20327  	t.GetPermissions()
 20328  	t = nil
 20329  	t.GetPermissions()
 20330  }
 20331  
 20332  func TestTeam_GetPrivacy(tt *testing.T) {
 20333  	var zeroValue string
 20334  	t := &Team{Privacy: &zeroValue}
 20335  	t.GetPrivacy()
 20336  	t = &Team{}
 20337  	t.GetPrivacy()
 20338  	t = nil
 20339  	t.GetPrivacy()
 20340  }
 20341  
 20342  func TestTeam_GetReposCount(tt *testing.T) {
 20343  	var zeroValue int
 20344  	t := &Team{ReposCount: &zeroValue}
 20345  	t.GetReposCount()
 20346  	t = &Team{}
 20347  	t.GetReposCount()
 20348  	t = nil
 20349  	t.GetReposCount()
 20350  }
 20351  
 20352  func TestTeam_GetRepositoriesURL(tt *testing.T) {
 20353  	var zeroValue string
 20354  	t := &Team{RepositoriesURL: &zeroValue}
 20355  	t.GetRepositoriesURL()
 20356  	t = &Team{}
 20357  	t.GetRepositoriesURL()
 20358  	t = nil
 20359  	t.GetRepositoriesURL()
 20360  }
 20361  
 20362  func TestTeam_GetSlug(tt *testing.T) {
 20363  	var zeroValue string
 20364  	t := &Team{Slug: &zeroValue}
 20365  	t.GetSlug()
 20366  	t = &Team{}
 20367  	t.GetSlug()
 20368  	t = nil
 20369  	t.GetSlug()
 20370  }
 20371  
 20372  func TestTeam_GetURL(tt *testing.T) {
 20373  	var zeroValue string
 20374  	t := &Team{URL: &zeroValue}
 20375  	t.GetURL()
 20376  	t = &Team{}
 20377  	t.GetURL()
 20378  	t = nil
 20379  	t.GetURL()
 20380  }
 20381  
 20382  func TestTeamAddEvent_GetInstallation(tt *testing.T) {
 20383  	t := &TeamAddEvent{}
 20384  	t.GetInstallation()
 20385  	t = nil
 20386  	t.GetInstallation()
 20387  }
 20388  
 20389  func TestTeamAddEvent_GetOrg(tt *testing.T) {
 20390  	t := &TeamAddEvent{}
 20391  	t.GetOrg()
 20392  	t = nil
 20393  	t.GetOrg()
 20394  }
 20395  
 20396  func TestTeamAddEvent_GetRepo(tt *testing.T) {
 20397  	t := &TeamAddEvent{}
 20398  	t.GetRepo()
 20399  	t = nil
 20400  	t.GetRepo()
 20401  }
 20402  
 20403  func TestTeamAddEvent_GetSender(tt *testing.T) {
 20404  	t := &TeamAddEvent{}
 20405  	t.GetSender()
 20406  	t = nil
 20407  	t.GetSender()
 20408  }
 20409  
 20410  func TestTeamAddEvent_GetTeam(tt *testing.T) {
 20411  	t := &TeamAddEvent{}
 20412  	t.GetTeam()
 20413  	t = nil
 20414  	t.GetTeam()
 20415  }
 20416  
 20417  func TestTeamChange_GetDescription(tt *testing.T) {
 20418  	t := &TeamChange{}
 20419  	t.GetDescription()
 20420  	t = nil
 20421  	t.GetDescription()
 20422  }
 20423  
 20424  func TestTeamChange_GetName(tt *testing.T) {
 20425  	t := &TeamChange{}
 20426  	t.GetName()
 20427  	t = nil
 20428  	t.GetName()
 20429  }
 20430  
 20431  func TestTeamChange_GetPrivacy(tt *testing.T) {
 20432  	t := &TeamChange{}
 20433  	t.GetPrivacy()
 20434  	t = nil
 20435  	t.GetPrivacy()
 20436  }
 20437  
 20438  func TestTeamChange_GetRepository(tt *testing.T) {
 20439  	t := &TeamChange{}
 20440  	t.GetRepository()
 20441  	t = nil
 20442  	t.GetRepository()
 20443  }
 20444  
 20445  func TestTeamDescription_GetFrom(tt *testing.T) {
 20446  	var zeroValue string
 20447  	t := &TeamDescription{From: &zeroValue}
 20448  	t.GetFrom()
 20449  	t = &TeamDescription{}
 20450  	t.GetFrom()
 20451  	t = nil
 20452  	t.GetFrom()
 20453  }
 20454  
 20455  func TestTeamDiscussion_GetAuthor(tt *testing.T) {
 20456  	t := &TeamDiscussion{}
 20457  	t.GetAuthor()
 20458  	t = nil
 20459  	t.GetAuthor()
 20460  }
 20461  
 20462  func TestTeamDiscussion_GetBody(tt *testing.T) {
 20463  	var zeroValue string
 20464  	t := &TeamDiscussion{Body: &zeroValue}
 20465  	t.GetBody()
 20466  	t = &TeamDiscussion{}
 20467  	t.GetBody()
 20468  	t = nil
 20469  	t.GetBody()
 20470  }
 20471  
 20472  func TestTeamDiscussion_GetBodyHTML(tt *testing.T) {
 20473  	var zeroValue string
 20474  	t := &TeamDiscussion{BodyHTML: &zeroValue}
 20475  	t.GetBodyHTML()
 20476  	t = &TeamDiscussion{}
 20477  	t.GetBodyHTML()
 20478  	t = nil
 20479  	t.GetBodyHTML()
 20480  }
 20481  
 20482  func TestTeamDiscussion_GetBodyVersion(tt *testing.T) {
 20483  	var zeroValue string
 20484  	t := &TeamDiscussion{BodyVersion: &zeroValue}
 20485  	t.GetBodyVersion()
 20486  	t = &TeamDiscussion{}
 20487  	t.GetBodyVersion()
 20488  	t = nil
 20489  	t.GetBodyVersion()
 20490  }
 20491  
 20492  func TestTeamDiscussion_GetCommentsCount(tt *testing.T) {
 20493  	var zeroValue int
 20494  	t := &TeamDiscussion{CommentsCount: &zeroValue}
 20495  	t.GetCommentsCount()
 20496  	t = &TeamDiscussion{}
 20497  	t.GetCommentsCount()
 20498  	t = nil
 20499  	t.GetCommentsCount()
 20500  }
 20501  
 20502  func TestTeamDiscussion_GetCommentsURL(tt *testing.T) {
 20503  	var zeroValue string
 20504  	t := &TeamDiscussion{CommentsURL: &zeroValue}
 20505  	t.GetCommentsURL()
 20506  	t = &TeamDiscussion{}
 20507  	t.GetCommentsURL()
 20508  	t = nil
 20509  	t.GetCommentsURL()
 20510  }
 20511  
 20512  func TestTeamDiscussion_GetCreatedAt(tt *testing.T) {
 20513  	var zeroValue Timestamp
 20514  	t := &TeamDiscussion{CreatedAt: &zeroValue}
 20515  	t.GetCreatedAt()
 20516  	t = &TeamDiscussion{}
 20517  	t.GetCreatedAt()
 20518  	t = nil
 20519  	t.GetCreatedAt()
 20520  }
 20521  
 20522  func TestTeamDiscussion_GetHTMLURL(tt *testing.T) {
 20523  	var zeroValue string
 20524  	t := &TeamDiscussion{HTMLURL: &zeroValue}
 20525  	t.GetHTMLURL()
 20526  	t = &TeamDiscussion{}
 20527  	t.GetHTMLURL()
 20528  	t = nil
 20529  	t.GetHTMLURL()
 20530  }
 20531  
 20532  func TestTeamDiscussion_GetLastEditedAt(tt *testing.T) {
 20533  	var zeroValue Timestamp
 20534  	t := &TeamDiscussion{LastEditedAt: &zeroValue}
 20535  	t.GetLastEditedAt()
 20536  	t = &TeamDiscussion{}
 20537  	t.GetLastEditedAt()
 20538  	t = nil
 20539  	t.GetLastEditedAt()
 20540  }
 20541  
 20542  func TestTeamDiscussion_GetNodeID(tt *testing.T) {
 20543  	var zeroValue string
 20544  	t := &TeamDiscussion{NodeID: &zeroValue}
 20545  	t.GetNodeID()
 20546  	t = &TeamDiscussion{}
 20547  	t.GetNodeID()
 20548  	t = nil
 20549  	t.GetNodeID()
 20550  }
 20551  
 20552  func TestTeamDiscussion_GetNumber(tt *testing.T) {
 20553  	var zeroValue int
 20554  	t := &TeamDiscussion{Number: &zeroValue}
 20555  	t.GetNumber()
 20556  	t = &TeamDiscussion{}
 20557  	t.GetNumber()
 20558  	t = nil
 20559  	t.GetNumber()
 20560  }
 20561  
 20562  func TestTeamDiscussion_GetPinned(tt *testing.T) {
 20563  	var zeroValue bool
 20564  	t := &TeamDiscussion{Pinned: &zeroValue}
 20565  	t.GetPinned()
 20566  	t = &TeamDiscussion{}
 20567  	t.GetPinned()
 20568  	t = nil
 20569  	t.GetPinned()
 20570  }
 20571  
 20572  func TestTeamDiscussion_GetPrivate(tt *testing.T) {
 20573  	var zeroValue bool
 20574  	t := &TeamDiscussion{Private: &zeroValue}
 20575  	t.GetPrivate()
 20576  	t = &TeamDiscussion{}
 20577  	t.GetPrivate()
 20578  	t = nil
 20579  	t.GetPrivate()
 20580  }
 20581  
 20582  func TestTeamDiscussion_GetReactions(tt *testing.T) {
 20583  	t := &TeamDiscussion{}
 20584  	t.GetReactions()
 20585  	t = nil
 20586  	t.GetReactions()
 20587  }
 20588  
 20589  func TestTeamDiscussion_GetTeamURL(tt *testing.T) {
 20590  	var zeroValue string
 20591  	t := &TeamDiscussion{TeamURL: &zeroValue}
 20592  	t.GetTeamURL()
 20593  	t = &TeamDiscussion{}
 20594  	t.GetTeamURL()
 20595  	t = nil
 20596  	t.GetTeamURL()
 20597  }
 20598  
 20599  func TestTeamDiscussion_GetTitle(tt *testing.T) {
 20600  	var zeroValue string
 20601  	t := &TeamDiscussion{Title: &zeroValue}
 20602  	t.GetTitle()
 20603  	t = &TeamDiscussion{}
 20604  	t.GetTitle()
 20605  	t = nil
 20606  	t.GetTitle()
 20607  }
 20608  
 20609  func TestTeamDiscussion_GetUpdatedAt(tt *testing.T) {
 20610  	var zeroValue Timestamp
 20611  	t := &TeamDiscussion{UpdatedAt: &zeroValue}
 20612  	t.GetUpdatedAt()
 20613  	t = &TeamDiscussion{}
 20614  	t.GetUpdatedAt()
 20615  	t = nil
 20616  	t.GetUpdatedAt()
 20617  }
 20618  
 20619  func TestTeamDiscussion_GetURL(tt *testing.T) {
 20620  	var zeroValue string
 20621  	t := &TeamDiscussion{URL: &zeroValue}
 20622  	t.GetURL()
 20623  	t = &TeamDiscussion{}
 20624  	t.GetURL()
 20625  	t = nil
 20626  	t.GetURL()
 20627  }
 20628  
 20629  func TestTeamEvent_GetAction(tt *testing.T) {
 20630  	var zeroValue string
 20631  	t := &TeamEvent{Action: &zeroValue}
 20632  	t.GetAction()
 20633  	t = &TeamEvent{}
 20634  	t.GetAction()
 20635  	t = nil
 20636  	t.GetAction()
 20637  }
 20638  
 20639  func TestTeamEvent_GetChanges(tt *testing.T) {
 20640  	t := &TeamEvent{}
 20641  	t.GetChanges()
 20642  	t = nil
 20643  	t.GetChanges()
 20644  }
 20645  
 20646  func TestTeamEvent_GetInstallation(tt *testing.T) {
 20647  	t := &TeamEvent{}
 20648  	t.GetInstallation()
 20649  	t = nil
 20650  	t.GetInstallation()
 20651  }
 20652  
 20653  func TestTeamEvent_GetOrg(tt *testing.T) {
 20654  	t := &TeamEvent{}
 20655  	t.GetOrg()
 20656  	t = nil
 20657  	t.GetOrg()
 20658  }
 20659  
 20660  func TestTeamEvent_GetRepo(tt *testing.T) {
 20661  	t := &TeamEvent{}
 20662  	t.GetRepo()
 20663  	t = nil
 20664  	t.GetRepo()
 20665  }
 20666  
 20667  func TestTeamEvent_GetSender(tt *testing.T) {
 20668  	t := &TeamEvent{}
 20669  	t.GetSender()
 20670  	t = nil
 20671  	t.GetSender()
 20672  }
 20673  
 20674  func TestTeamEvent_GetTeam(tt *testing.T) {
 20675  	t := &TeamEvent{}
 20676  	t.GetTeam()
 20677  	t = nil
 20678  	t.GetTeam()
 20679  }
 20680  
 20681  func TestTeamLDAPMapping_GetDescription(tt *testing.T) {
 20682  	var zeroValue string
 20683  	t := &TeamLDAPMapping{Description: &zeroValue}
 20684  	t.GetDescription()
 20685  	t = &TeamLDAPMapping{}
 20686  	t.GetDescription()
 20687  	t = nil
 20688  	t.GetDescription()
 20689  }
 20690  
 20691  func TestTeamLDAPMapping_GetID(tt *testing.T) {
 20692  	var zeroValue int64
 20693  	t := &TeamLDAPMapping{ID: &zeroValue}
 20694  	t.GetID()
 20695  	t = &TeamLDAPMapping{}
 20696  	t.GetID()
 20697  	t = nil
 20698  	t.GetID()
 20699  }
 20700  
 20701  func TestTeamLDAPMapping_GetLDAPDN(tt *testing.T) {
 20702  	var zeroValue string
 20703  	t := &TeamLDAPMapping{LDAPDN: &zeroValue}
 20704  	t.GetLDAPDN()
 20705  	t = &TeamLDAPMapping{}
 20706  	t.GetLDAPDN()
 20707  	t = nil
 20708  	t.GetLDAPDN()
 20709  }
 20710  
 20711  func TestTeamLDAPMapping_GetMembersURL(tt *testing.T) {
 20712  	var zeroValue string
 20713  	t := &TeamLDAPMapping{MembersURL: &zeroValue}
 20714  	t.GetMembersURL()
 20715  	t = &TeamLDAPMapping{}
 20716  	t.GetMembersURL()
 20717  	t = nil
 20718  	t.GetMembersURL()
 20719  }
 20720  
 20721  func TestTeamLDAPMapping_GetName(tt *testing.T) {
 20722  	var zeroValue string
 20723  	t := &TeamLDAPMapping{Name: &zeroValue}
 20724  	t.GetName()
 20725  	t = &TeamLDAPMapping{}
 20726  	t.GetName()
 20727  	t = nil
 20728  	t.GetName()
 20729  }
 20730  
 20731  func TestTeamLDAPMapping_GetPermission(tt *testing.T) {
 20732  	var zeroValue string
 20733  	t := &TeamLDAPMapping{Permission: &zeroValue}
 20734  	t.GetPermission()
 20735  	t = &TeamLDAPMapping{}
 20736  	t.GetPermission()
 20737  	t = nil
 20738  	t.GetPermission()
 20739  }
 20740  
 20741  func TestTeamLDAPMapping_GetPrivacy(tt *testing.T) {
 20742  	var zeroValue string
 20743  	t := &TeamLDAPMapping{Privacy: &zeroValue}
 20744  	t.GetPrivacy()
 20745  	t = &TeamLDAPMapping{}
 20746  	t.GetPrivacy()
 20747  	t = nil
 20748  	t.GetPrivacy()
 20749  }
 20750  
 20751  func TestTeamLDAPMapping_GetRepositoriesURL(tt *testing.T) {
 20752  	var zeroValue string
 20753  	t := &TeamLDAPMapping{RepositoriesURL: &zeroValue}
 20754  	t.GetRepositoriesURL()
 20755  	t = &TeamLDAPMapping{}
 20756  	t.GetRepositoriesURL()
 20757  	t = nil
 20758  	t.GetRepositoriesURL()
 20759  }
 20760  
 20761  func TestTeamLDAPMapping_GetSlug(tt *testing.T) {
 20762  	var zeroValue string
 20763  	t := &TeamLDAPMapping{Slug: &zeroValue}
 20764  	t.GetSlug()
 20765  	t = &TeamLDAPMapping{}
 20766  	t.GetSlug()
 20767  	t = nil
 20768  	t.GetSlug()
 20769  }
 20770  
 20771  func TestTeamLDAPMapping_GetURL(tt *testing.T) {
 20772  	var zeroValue string
 20773  	t := &TeamLDAPMapping{URL: &zeroValue}
 20774  	t.GetURL()
 20775  	t = &TeamLDAPMapping{}
 20776  	t.GetURL()
 20777  	t = nil
 20778  	t.GetURL()
 20779  }
 20780  
 20781  func TestTeamName_GetFrom(tt *testing.T) {
 20782  	var zeroValue string
 20783  	t := &TeamName{From: &zeroValue}
 20784  	t.GetFrom()
 20785  	t = &TeamName{}
 20786  	t.GetFrom()
 20787  	t = nil
 20788  	t.GetFrom()
 20789  }
 20790  
 20791  func TestTeamPermissions_GetFrom(tt *testing.T) {
 20792  	t := &TeamPermissions{}
 20793  	t.GetFrom()
 20794  	t = nil
 20795  	t.GetFrom()
 20796  }
 20797  
 20798  func TestTeamPermissionsFrom_GetAdmin(tt *testing.T) {
 20799  	var zeroValue bool
 20800  	t := &TeamPermissionsFrom{Admin: &zeroValue}
 20801  	t.GetAdmin()
 20802  	t = &TeamPermissionsFrom{}
 20803  	t.GetAdmin()
 20804  	t = nil
 20805  	t.GetAdmin()
 20806  }
 20807  
 20808  func TestTeamPermissionsFrom_GetPull(tt *testing.T) {
 20809  	var zeroValue bool
 20810  	t := &TeamPermissionsFrom{Pull: &zeroValue}
 20811  	t.GetPull()
 20812  	t = &TeamPermissionsFrom{}
 20813  	t.GetPull()
 20814  	t = nil
 20815  	t.GetPull()
 20816  }
 20817  
 20818  func TestTeamPermissionsFrom_GetPush(tt *testing.T) {
 20819  	var zeroValue bool
 20820  	t := &TeamPermissionsFrom{Push: &zeroValue}
 20821  	t.GetPush()
 20822  	t = &TeamPermissionsFrom{}
 20823  	t.GetPush()
 20824  	t = nil
 20825  	t.GetPush()
 20826  }
 20827  
 20828  func TestTeamPrivacy_GetFrom(tt *testing.T) {
 20829  	var zeroValue string
 20830  	t := &TeamPrivacy{From: &zeroValue}
 20831  	t.GetFrom()
 20832  	t = &TeamPrivacy{}
 20833  	t.GetFrom()
 20834  	t = nil
 20835  	t.GetFrom()
 20836  }
 20837  
 20838  func TestTeamProjectOptions_GetPermission(tt *testing.T) {
 20839  	var zeroValue string
 20840  	t := &TeamProjectOptions{Permission: &zeroValue}
 20841  	t.GetPermission()
 20842  	t = &TeamProjectOptions{}
 20843  	t.GetPermission()
 20844  	t = nil
 20845  	t.GetPermission()
 20846  }
 20847  
 20848  func TestTeamRepository_GetPermissions(tt *testing.T) {
 20849  	t := &TeamRepository{}
 20850  	t.GetPermissions()
 20851  	t = nil
 20852  	t.GetPermissions()
 20853  }
 20854  
 20855  func TestTemplateRepoRequest_GetDescription(tt *testing.T) {
 20856  	var zeroValue string
 20857  	t := &TemplateRepoRequest{Description: &zeroValue}
 20858  	t.GetDescription()
 20859  	t = &TemplateRepoRequest{}
 20860  	t.GetDescription()
 20861  	t = nil
 20862  	t.GetDescription()
 20863  }
 20864  
 20865  func TestTemplateRepoRequest_GetIncludeAllBranches(tt *testing.T) {
 20866  	var zeroValue bool
 20867  	t := &TemplateRepoRequest{IncludeAllBranches: &zeroValue}
 20868  	t.GetIncludeAllBranches()
 20869  	t = &TemplateRepoRequest{}
 20870  	t.GetIncludeAllBranches()
 20871  	t = nil
 20872  	t.GetIncludeAllBranches()
 20873  }
 20874  
 20875  func TestTemplateRepoRequest_GetName(tt *testing.T) {
 20876  	var zeroValue string
 20877  	t := &TemplateRepoRequest{Name: &zeroValue}
 20878  	t.GetName()
 20879  	t = &TemplateRepoRequest{}
 20880  	t.GetName()
 20881  	t = nil
 20882  	t.GetName()
 20883  }
 20884  
 20885  func TestTemplateRepoRequest_GetOwner(tt *testing.T) {
 20886  	var zeroValue string
 20887  	t := &TemplateRepoRequest{Owner: &zeroValue}
 20888  	t.GetOwner()
 20889  	t = &TemplateRepoRequest{}
 20890  	t.GetOwner()
 20891  	t = nil
 20892  	t.GetOwner()
 20893  }
 20894  
 20895  func TestTemplateRepoRequest_GetPrivate(tt *testing.T) {
 20896  	var zeroValue bool
 20897  	t := &TemplateRepoRequest{Private: &zeroValue}
 20898  	t.GetPrivate()
 20899  	t = &TemplateRepoRequest{}
 20900  	t.GetPrivate()
 20901  	t = nil
 20902  	t.GetPrivate()
 20903  }
 20904  
 20905  func TestTextMatch_GetFragment(tt *testing.T) {
 20906  	var zeroValue string
 20907  	t := &TextMatch{Fragment: &zeroValue}
 20908  	t.GetFragment()
 20909  	t = &TextMatch{}
 20910  	t.GetFragment()
 20911  	t = nil
 20912  	t.GetFragment()
 20913  }
 20914  
 20915  func TestTextMatch_GetObjectType(tt *testing.T) {
 20916  	var zeroValue string
 20917  	t := &TextMatch{ObjectType: &zeroValue}
 20918  	t.GetObjectType()
 20919  	t = &TextMatch{}
 20920  	t.GetObjectType()
 20921  	t = nil
 20922  	t.GetObjectType()
 20923  }
 20924  
 20925  func TestTextMatch_GetObjectURL(tt *testing.T) {
 20926  	var zeroValue string
 20927  	t := &TextMatch{ObjectURL: &zeroValue}
 20928  	t.GetObjectURL()
 20929  	t = &TextMatch{}
 20930  	t.GetObjectURL()
 20931  	t = nil
 20932  	t.GetObjectURL()
 20933  }
 20934  
 20935  func TestTextMatch_GetProperty(tt *testing.T) {
 20936  	var zeroValue string
 20937  	t := &TextMatch{Property: &zeroValue}
 20938  	t.GetProperty()
 20939  	t = &TextMatch{}
 20940  	t.GetProperty()
 20941  	t = nil
 20942  	t.GetProperty()
 20943  }
 20944  
 20945  func TestTimeline_GetActor(tt *testing.T) {
 20946  	t := &Timeline{}
 20947  	t.GetActor()
 20948  	t = nil
 20949  	t.GetActor()
 20950  }
 20951  
 20952  func TestTimeline_GetAssignee(tt *testing.T) {
 20953  	t := &Timeline{}
 20954  	t.GetAssignee()
 20955  	t = nil
 20956  	t.GetAssignee()
 20957  }
 20958  
 20959  func TestTimeline_GetAssigner(tt *testing.T) {
 20960  	t := &Timeline{}
 20961  	t.GetAssigner()
 20962  	t = nil
 20963  	t.GetAssigner()
 20964  }
 20965  
 20966  func TestTimeline_GetAuthor(tt *testing.T) {
 20967  	t := &Timeline{}
 20968  	t.GetAuthor()
 20969  	t = nil
 20970  	t.GetAuthor()
 20971  }
 20972  
 20973  func TestTimeline_GetBody(tt *testing.T) {
 20974  	var zeroValue string
 20975  	t := &Timeline{Body: &zeroValue}
 20976  	t.GetBody()
 20977  	t = &Timeline{}
 20978  	t.GetBody()
 20979  	t = nil
 20980  	t.GetBody()
 20981  }
 20982  
 20983  func TestTimeline_GetCommitID(tt *testing.T) {
 20984  	var zeroValue string
 20985  	t := &Timeline{CommitID: &zeroValue}
 20986  	t.GetCommitID()
 20987  	t = &Timeline{}
 20988  	t.GetCommitID()
 20989  	t = nil
 20990  	t.GetCommitID()
 20991  }
 20992  
 20993  func TestTimeline_GetCommitter(tt *testing.T) {
 20994  	t := &Timeline{}
 20995  	t.GetCommitter()
 20996  	t = nil
 20997  	t.GetCommitter()
 20998  }
 20999  
 21000  func TestTimeline_GetCommitURL(tt *testing.T) {
 21001  	var zeroValue string
 21002  	t := &Timeline{CommitURL: &zeroValue}
 21003  	t.GetCommitURL()
 21004  	t = &Timeline{}
 21005  	t.GetCommitURL()
 21006  	t = nil
 21007  	t.GetCommitURL()
 21008  }
 21009  
 21010  func TestTimeline_GetCreatedAt(tt *testing.T) {
 21011  	var zeroValue time.Time
 21012  	t := &Timeline{CreatedAt: &zeroValue}
 21013  	t.GetCreatedAt()
 21014  	t = &Timeline{}
 21015  	t.GetCreatedAt()
 21016  	t = nil
 21017  	t.GetCreatedAt()
 21018  }
 21019  
 21020  func TestTimeline_GetEvent(tt *testing.T) {
 21021  	var zeroValue string
 21022  	t := &Timeline{Event: &zeroValue}
 21023  	t.GetEvent()
 21024  	t = &Timeline{}
 21025  	t.GetEvent()
 21026  	t = nil
 21027  	t.GetEvent()
 21028  }
 21029  
 21030  func TestTimeline_GetID(tt *testing.T) {
 21031  	var zeroValue int64
 21032  	t := &Timeline{ID: &zeroValue}
 21033  	t.GetID()
 21034  	t = &Timeline{}
 21035  	t.GetID()
 21036  	t = nil
 21037  	t.GetID()
 21038  }
 21039  
 21040  func TestTimeline_GetLabel(tt *testing.T) {
 21041  	t := &Timeline{}
 21042  	t.GetLabel()
 21043  	t = nil
 21044  	t.GetLabel()
 21045  }
 21046  
 21047  func TestTimeline_GetMessage(tt *testing.T) {
 21048  	var zeroValue string
 21049  	t := &Timeline{Message: &zeroValue}
 21050  	t.GetMessage()
 21051  	t = &Timeline{}
 21052  	t.GetMessage()
 21053  	t = nil
 21054  	t.GetMessage()
 21055  }
 21056  
 21057  func TestTimeline_GetMilestone(tt *testing.T) {
 21058  	t := &Timeline{}
 21059  	t.GetMilestone()
 21060  	t = nil
 21061  	t.GetMilestone()
 21062  }
 21063  
 21064  func TestTimeline_GetProjectCard(tt *testing.T) {
 21065  	t := &Timeline{}
 21066  	t.GetProjectCard()
 21067  	t = nil
 21068  	t.GetProjectCard()
 21069  }
 21070  
 21071  func TestTimeline_GetRename(tt *testing.T) {
 21072  	t := &Timeline{}
 21073  	t.GetRename()
 21074  	t = nil
 21075  	t.GetRename()
 21076  }
 21077  
 21078  func TestTimeline_GetRequester(tt *testing.T) {
 21079  	t := &Timeline{}
 21080  	t.GetRequester()
 21081  	t = nil
 21082  	t.GetRequester()
 21083  }
 21084  
 21085  func TestTimeline_GetReviewer(tt *testing.T) {
 21086  	t := &Timeline{}
 21087  	t.GetReviewer()
 21088  	t = nil
 21089  	t.GetReviewer()
 21090  }
 21091  
 21092  func TestTimeline_GetSHA(tt *testing.T) {
 21093  	var zeroValue string
 21094  	t := &Timeline{SHA: &zeroValue}
 21095  	t.GetSHA()
 21096  	t = &Timeline{}
 21097  	t.GetSHA()
 21098  	t = nil
 21099  	t.GetSHA()
 21100  }
 21101  
 21102  func TestTimeline_GetSource(tt *testing.T) {
 21103  	t := &Timeline{}
 21104  	t.GetSource()
 21105  	t = nil
 21106  	t.GetSource()
 21107  }
 21108  
 21109  func TestTimeline_GetState(tt *testing.T) {
 21110  	var zeroValue string
 21111  	t := &Timeline{State: &zeroValue}
 21112  	t.GetState()
 21113  	t = &Timeline{}
 21114  	t.GetState()
 21115  	t = nil
 21116  	t.GetState()
 21117  }
 21118  
 21119  func TestTimeline_GetSubmittedAt(tt *testing.T) {
 21120  	var zeroValue time.Time
 21121  	t := &Timeline{SubmittedAt: &zeroValue}
 21122  	t.GetSubmittedAt()
 21123  	t = &Timeline{}
 21124  	t.GetSubmittedAt()
 21125  	t = nil
 21126  	t.GetSubmittedAt()
 21127  }
 21128  
 21129  func TestTimeline_GetURL(tt *testing.T) {
 21130  	var zeroValue string
 21131  	t := &Timeline{URL: &zeroValue}
 21132  	t.GetURL()
 21133  	t = &Timeline{}
 21134  	t.GetURL()
 21135  	t = nil
 21136  	t.GetURL()
 21137  }
 21138  
 21139  func TestTimeline_GetUser(tt *testing.T) {
 21140  	t := &Timeline{}
 21141  	t.GetUser()
 21142  	t = nil
 21143  	t.GetUser()
 21144  }
 21145  
 21146  func TestTool_GetGUID(tt *testing.T) {
 21147  	var zeroValue string
 21148  	t := &Tool{GUID: &zeroValue}
 21149  	t.GetGUID()
 21150  	t = &Tool{}
 21151  	t.GetGUID()
 21152  	t = nil
 21153  	t.GetGUID()
 21154  }
 21155  
 21156  func TestTool_GetName(tt *testing.T) {
 21157  	var zeroValue string
 21158  	t := &Tool{Name: &zeroValue}
 21159  	t.GetName()
 21160  	t = &Tool{}
 21161  	t.GetName()
 21162  	t = nil
 21163  	t.GetName()
 21164  }
 21165  
 21166  func TestTool_GetVersion(tt *testing.T) {
 21167  	var zeroValue string
 21168  	t := &Tool{Version: &zeroValue}
 21169  	t.GetVersion()
 21170  	t = &Tool{}
 21171  	t.GetVersion()
 21172  	t = nil
 21173  	t.GetVersion()
 21174  }
 21175  
 21176  func TestTopicResult_GetCreatedAt(tt *testing.T) {
 21177  	var zeroValue Timestamp
 21178  	t := &TopicResult{CreatedAt: &zeroValue}
 21179  	t.GetCreatedAt()
 21180  	t = &TopicResult{}
 21181  	t.GetCreatedAt()
 21182  	t = nil
 21183  	t.GetCreatedAt()
 21184  }
 21185  
 21186  func TestTopicResult_GetCreatedBy(tt *testing.T) {
 21187  	var zeroValue string
 21188  	t := &TopicResult{CreatedBy: &zeroValue}
 21189  	t.GetCreatedBy()
 21190  	t = &TopicResult{}
 21191  	t.GetCreatedBy()
 21192  	t = nil
 21193  	t.GetCreatedBy()
 21194  }
 21195  
 21196  func TestTopicResult_GetCurated(tt *testing.T) {
 21197  	var zeroValue bool
 21198  	t := &TopicResult{Curated: &zeroValue}
 21199  	t.GetCurated()
 21200  	t = &TopicResult{}
 21201  	t.GetCurated()
 21202  	t = nil
 21203  	t.GetCurated()
 21204  }
 21205  
 21206  func TestTopicResult_GetDescription(tt *testing.T) {
 21207  	var zeroValue string
 21208  	t := &TopicResult{Description: &zeroValue}
 21209  	t.GetDescription()
 21210  	t = &TopicResult{}
 21211  	t.GetDescription()
 21212  	t = nil
 21213  	t.GetDescription()
 21214  }
 21215  
 21216  func TestTopicResult_GetDisplayName(tt *testing.T) {
 21217  	var zeroValue string
 21218  	t := &TopicResult{DisplayName: &zeroValue}
 21219  	t.GetDisplayName()
 21220  	t = &TopicResult{}
 21221  	t.GetDisplayName()
 21222  	t = nil
 21223  	t.GetDisplayName()
 21224  }
 21225  
 21226  func TestTopicResult_GetFeatured(tt *testing.T) {
 21227  	var zeroValue bool
 21228  	t := &TopicResult{Featured: &zeroValue}
 21229  	t.GetFeatured()
 21230  	t = &TopicResult{}
 21231  	t.GetFeatured()
 21232  	t = nil
 21233  	t.GetFeatured()
 21234  }
 21235  
 21236  func TestTopicResult_GetName(tt *testing.T) {
 21237  	var zeroValue string
 21238  	t := &TopicResult{Name: &zeroValue}
 21239  	t.GetName()
 21240  	t = &TopicResult{}
 21241  	t.GetName()
 21242  	t = nil
 21243  	t.GetName()
 21244  }
 21245  
 21246  func TestTopicResult_GetScore(tt *testing.T) {
 21247  	t := &TopicResult{}
 21248  	t.GetScore()
 21249  	t = nil
 21250  	t.GetScore()
 21251  }
 21252  
 21253  func TestTopicResult_GetShortDescription(tt *testing.T) {
 21254  	var zeroValue string
 21255  	t := &TopicResult{ShortDescription: &zeroValue}
 21256  	t.GetShortDescription()
 21257  	t = &TopicResult{}
 21258  	t.GetShortDescription()
 21259  	t = nil
 21260  	t.GetShortDescription()
 21261  }
 21262  
 21263  func TestTopicResult_GetUpdatedAt(tt *testing.T) {
 21264  	var zeroValue string
 21265  	t := &TopicResult{UpdatedAt: &zeroValue}
 21266  	t.GetUpdatedAt()
 21267  	t = &TopicResult{}
 21268  	t.GetUpdatedAt()
 21269  	t = nil
 21270  	t.GetUpdatedAt()
 21271  }
 21272  
 21273  func TestTopicsSearchResult_GetIncompleteResults(tt *testing.T) {
 21274  	var zeroValue bool
 21275  	t := &TopicsSearchResult{IncompleteResults: &zeroValue}
 21276  	t.GetIncompleteResults()
 21277  	t = &TopicsSearchResult{}
 21278  	t.GetIncompleteResults()
 21279  	t = nil
 21280  	t.GetIncompleteResults()
 21281  }
 21282  
 21283  func TestTopicsSearchResult_GetTotal(tt *testing.T) {
 21284  	var zeroValue int
 21285  	t := &TopicsSearchResult{Total: &zeroValue}
 21286  	t.GetTotal()
 21287  	t = &TopicsSearchResult{}
 21288  	t.GetTotal()
 21289  	t = nil
 21290  	t.GetTotal()
 21291  }
 21292  
 21293  func TestTrafficClones_GetCount(tt *testing.T) {
 21294  	var zeroValue int
 21295  	t := &TrafficClones{Count: &zeroValue}
 21296  	t.GetCount()
 21297  	t = &TrafficClones{}
 21298  	t.GetCount()
 21299  	t = nil
 21300  	t.GetCount()
 21301  }
 21302  
 21303  func TestTrafficClones_GetUniques(tt *testing.T) {
 21304  	var zeroValue int
 21305  	t := &TrafficClones{Uniques: &zeroValue}
 21306  	t.GetUniques()
 21307  	t = &TrafficClones{}
 21308  	t.GetUniques()
 21309  	t = nil
 21310  	t.GetUniques()
 21311  }
 21312  
 21313  func TestTrafficData_GetCount(tt *testing.T) {
 21314  	var zeroValue int
 21315  	t := &TrafficData{Count: &zeroValue}
 21316  	t.GetCount()
 21317  	t = &TrafficData{}
 21318  	t.GetCount()
 21319  	t = nil
 21320  	t.GetCount()
 21321  }
 21322  
 21323  func TestTrafficData_GetTimestamp(tt *testing.T) {
 21324  	var zeroValue Timestamp
 21325  	t := &TrafficData{Timestamp: &zeroValue}
 21326  	t.GetTimestamp()
 21327  	t = &TrafficData{}
 21328  	t.GetTimestamp()
 21329  	t = nil
 21330  	t.GetTimestamp()
 21331  }
 21332  
 21333  func TestTrafficData_GetUniques(tt *testing.T) {
 21334  	var zeroValue int
 21335  	t := &TrafficData{Uniques: &zeroValue}
 21336  	t.GetUniques()
 21337  	t = &TrafficData{}
 21338  	t.GetUniques()
 21339  	t = nil
 21340  	t.GetUniques()
 21341  }
 21342  
 21343  func TestTrafficPath_GetCount(tt *testing.T) {
 21344  	var zeroValue int
 21345  	t := &TrafficPath{Count: &zeroValue}
 21346  	t.GetCount()
 21347  	t = &TrafficPath{}
 21348  	t.GetCount()
 21349  	t = nil
 21350  	t.GetCount()
 21351  }
 21352  
 21353  func TestTrafficPath_GetPath(tt *testing.T) {
 21354  	var zeroValue string
 21355  	t := &TrafficPath{Path: &zeroValue}
 21356  	t.GetPath()
 21357  	t = &TrafficPath{}
 21358  	t.GetPath()
 21359  	t = nil
 21360  	t.GetPath()
 21361  }
 21362  
 21363  func TestTrafficPath_GetTitle(tt *testing.T) {
 21364  	var zeroValue string
 21365  	t := &TrafficPath{Title: &zeroValue}
 21366  	t.GetTitle()
 21367  	t = &TrafficPath{}
 21368  	t.GetTitle()
 21369  	t = nil
 21370  	t.GetTitle()
 21371  }
 21372  
 21373  func TestTrafficPath_GetUniques(tt *testing.T) {
 21374  	var zeroValue int
 21375  	t := &TrafficPath{Uniques: &zeroValue}
 21376  	t.GetUniques()
 21377  	t = &TrafficPath{}
 21378  	t.GetUniques()
 21379  	t = nil
 21380  	t.GetUniques()
 21381  }
 21382  
 21383  func TestTrafficReferrer_GetCount(tt *testing.T) {
 21384  	var zeroValue int
 21385  	t := &TrafficReferrer{Count: &zeroValue}
 21386  	t.GetCount()
 21387  	t = &TrafficReferrer{}
 21388  	t.GetCount()
 21389  	t = nil
 21390  	t.GetCount()
 21391  }
 21392  
 21393  func TestTrafficReferrer_GetReferrer(tt *testing.T) {
 21394  	var zeroValue string
 21395  	t := &TrafficReferrer{Referrer: &zeroValue}
 21396  	t.GetReferrer()
 21397  	t = &TrafficReferrer{}
 21398  	t.GetReferrer()
 21399  	t = nil
 21400  	t.GetReferrer()
 21401  }
 21402  
 21403  func TestTrafficReferrer_GetUniques(tt *testing.T) {
 21404  	var zeroValue int
 21405  	t := &TrafficReferrer{Uniques: &zeroValue}
 21406  	t.GetUniques()
 21407  	t = &TrafficReferrer{}
 21408  	t.GetUniques()
 21409  	t = nil
 21410  	t.GetUniques()
 21411  }
 21412  
 21413  func TestTrafficViews_GetCount(tt *testing.T) {
 21414  	var zeroValue int
 21415  	t := &TrafficViews{Count: &zeroValue}
 21416  	t.GetCount()
 21417  	t = &TrafficViews{}
 21418  	t.GetCount()
 21419  	t = nil
 21420  	t.GetCount()
 21421  }
 21422  
 21423  func TestTrafficViews_GetUniques(tt *testing.T) {
 21424  	var zeroValue int
 21425  	t := &TrafficViews{Uniques: &zeroValue}
 21426  	t.GetUniques()
 21427  	t = &TrafficViews{}
 21428  	t.GetUniques()
 21429  	t = nil
 21430  	t.GetUniques()
 21431  }
 21432  
 21433  func TestTree_GetSHA(tt *testing.T) {
 21434  	var zeroValue string
 21435  	t := &Tree{SHA: &zeroValue}
 21436  	t.GetSHA()
 21437  	t = &Tree{}
 21438  	t.GetSHA()
 21439  	t = nil
 21440  	t.GetSHA()
 21441  }
 21442  
 21443  func TestTree_GetTruncated(tt *testing.T) {
 21444  	var zeroValue bool
 21445  	t := &Tree{Truncated: &zeroValue}
 21446  	t.GetTruncated()
 21447  	t = &Tree{}
 21448  	t.GetTruncated()
 21449  	t = nil
 21450  	t.GetTruncated()
 21451  }
 21452  
 21453  func TestTreeEntry_GetContent(tt *testing.T) {
 21454  	var zeroValue string
 21455  	t := &TreeEntry{Content: &zeroValue}
 21456  	t.GetContent()
 21457  	t = &TreeEntry{}
 21458  	t.GetContent()
 21459  	t = nil
 21460  	t.GetContent()
 21461  }
 21462  
 21463  func TestTreeEntry_GetMode(tt *testing.T) {
 21464  	var zeroValue string
 21465  	t := &TreeEntry{Mode: &zeroValue}
 21466  	t.GetMode()
 21467  	t = &TreeEntry{}
 21468  	t.GetMode()
 21469  	t = nil
 21470  	t.GetMode()
 21471  }
 21472  
 21473  func TestTreeEntry_GetPath(tt *testing.T) {
 21474  	var zeroValue string
 21475  	t := &TreeEntry{Path: &zeroValue}
 21476  	t.GetPath()
 21477  	t = &TreeEntry{}
 21478  	t.GetPath()
 21479  	t = nil
 21480  	t.GetPath()
 21481  }
 21482  
 21483  func TestTreeEntry_GetSHA(tt *testing.T) {
 21484  	var zeroValue string
 21485  	t := &TreeEntry{SHA: &zeroValue}
 21486  	t.GetSHA()
 21487  	t = &TreeEntry{}
 21488  	t.GetSHA()
 21489  	t = nil
 21490  	t.GetSHA()
 21491  }
 21492  
 21493  func TestTreeEntry_GetSize(tt *testing.T) {
 21494  	var zeroValue int
 21495  	t := &TreeEntry{Size: &zeroValue}
 21496  	t.GetSize()
 21497  	t = &TreeEntry{}
 21498  	t.GetSize()
 21499  	t = nil
 21500  	t.GetSize()
 21501  }
 21502  
 21503  func TestTreeEntry_GetType(tt *testing.T) {
 21504  	var zeroValue string
 21505  	t := &TreeEntry{Type: &zeroValue}
 21506  	t.GetType()
 21507  	t = &TreeEntry{}
 21508  	t.GetType()
 21509  	t = nil
 21510  	t.GetType()
 21511  }
 21512  
 21513  func TestTreeEntry_GetURL(tt *testing.T) {
 21514  	var zeroValue string
 21515  	t := &TreeEntry{URL: &zeroValue}
 21516  	t.GetURL()
 21517  	t = &TreeEntry{}
 21518  	t.GetURL()
 21519  	t = nil
 21520  	t.GetURL()
 21521  }
 21522  
 21523  func TestUpdateAttributeForSCIMUserOperations_GetPath(tt *testing.T) {
 21524  	var zeroValue string
 21525  	u := &UpdateAttributeForSCIMUserOperations{Path: &zeroValue}
 21526  	u.GetPath()
 21527  	u = &UpdateAttributeForSCIMUserOperations{}
 21528  	u.GetPath()
 21529  	u = nil
 21530  	u.GetPath()
 21531  }
 21532  
 21533  func TestUpdateCheckRunOptions_GetCompletedAt(tt *testing.T) {
 21534  	var zeroValue Timestamp
 21535  	u := &UpdateCheckRunOptions{CompletedAt: &zeroValue}
 21536  	u.GetCompletedAt()
 21537  	u = &UpdateCheckRunOptions{}
 21538  	u.GetCompletedAt()
 21539  	u = nil
 21540  	u.GetCompletedAt()
 21541  }
 21542  
 21543  func TestUpdateCheckRunOptions_GetConclusion(tt *testing.T) {
 21544  	var zeroValue string
 21545  	u := &UpdateCheckRunOptions{Conclusion: &zeroValue}
 21546  	u.GetConclusion()
 21547  	u = &UpdateCheckRunOptions{}
 21548  	u.GetConclusion()
 21549  	u = nil
 21550  	u.GetConclusion()
 21551  }
 21552  
 21553  func TestUpdateCheckRunOptions_GetDetailsURL(tt *testing.T) {
 21554  	var zeroValue string
 21555  	u := &UpdateCheckRunOptions{DetailsURL: &zeroValue}
 21556  	u.GetDetailsURL()
 21557  	u = &UpdateCheckRunOptions{}
 21558  	u.GetDetailsURL()
 21559  	u = nil
 21560  	u.GetDetailsURL()
 21561  }
 21562  
 21563  func TestUpdateCheckRunOptions_GetExternalID(tt *testing.T) {
 21564  	var zeroValue string
 21565  	u := &UpdateCheckRunOptions{ExternalID: &zeroValue}
 21566  	u.GetExternalID()
 21567  	u = &UpdateCheckRunOptions{}
 21568  	u.GetExternalID()
 21569  	u = nil
 21570  	u.GetExternalID()
 21571  }
 21572  
 21573  func TestUpdateCheckRunOptions_GetOutput(tt *testing.T) {
 21574  	u := &UpdateCheckRunOptions{}
 21575  	u.GetOutput()
 21576  	u = nil
 21577  	u.GetOutput()
 21578  }
 21579  
 21580  func TestUpdateCheckRunOptions_GetStatus(tt *testing.T) {
 21581  	var zeroValue string
 21582  	u := &UpdateCheckRunOptions{Status: &zeroValue}
 21583  	u.GetStatus()
 21584  	u = &UpdateCheckRunOptions{}
 21585  	u.GetStatus()
 21586  	u = nil
 21587  	u.GetStatus()
 21588  }
 21589  
 21590  func TestUpdateRunnerGroupRequest_GetAllowsPublicRepositories(tt *testing.T) {
 21591  	var zeroValue bool
 21592  	u := &UpdateRunnerGroupRequest{AllowsPublicRepositories: &zeroValue}
 21593  	u.GetAllowsPublicRepositories()
 21594  	u = &UpdateRunnerGroupRequest{}
 21595  	u.GetAllowsPublicRepositories()
 21596  	u = nil
 21597  	u.GetAllowsPublicRepositories()
 21598  }
 21599  
 21600  func TestUpdateRunnerGroupRequest_GetName(tt *testing.T) {
 21601  	var zeroValue string
 21602  	u := &UpdateRunnerGroupRequest{Name: &zeroValue}
 21603  	u.GetName()
 21604  	u = &UpdateRunnerGroupRequest{}
 21605  	u.GetName()
 21606  	u = nil
 21607  	u.GetName()
 21608  }
 21609  
 21610  func TestUpdateRunnerGroupRequest_GetVisibility(tt *testing.T) {
 21611  	var zeroValue string
 21612  	u := &UpdateRunnerGroupRequest{Visibility: &zeroValue}
 21613  	u.GetVisibility()
 21614  	u = &UpdateRunnerGroupRequest{}
 21615  	u.GetVisibility()
 21616  	u = nil
 21617  	u.GetVisibility()
 21618  }
 21619  
 21620  func TestUser_GetAvatarURL(tt *testing.T) {
 21621  	var zeroValue string
 21622  	u := &User{AvatarURL: &zeroValue}
 21623  	u.GetAvatarURL()
 21624  	u = &User{}
 21625  	u.GetAvatarURL()
 21626  	u = nil
 21627  	u.GetAvatarURL()
 21628  }
 21629  
 21630  func TestUser_GetBio(tt *testing.T) {
 21631  	var zeroValue string
 21632  	u := &User{Bio: &zeroValue}
 21633  	u.GetBio()
 21634  	u = &User{}
 21635  	u.GetBio()
 21636  	u = nil
 21637  	u.GetBio()
 21638  }
 21639  
 21640  func TestUser_GetBlog(tt *testing.T) {
 21641  	var zeroValue string
 21642  	u := &User{Blog: &zeroValue}
 21643  	u.GetBlog()
 21644  	u = &User{}
 21645  	u.GetBlog()
 21646  	u = nil
 21647  	u.GetBlog()
 21648  }
 21649  
 21650  func TestUser_GetCollaborators(tt *testing.T) {
 21651  	var zeroValue int
 21652  	u := &User{Collaborators: &zeroValue}
 21653  	u.GetCollaborators()
 21654  	u = &User{}
 21655  	u.GetCollaborators()
 21656  	u = nil
 21657  	u.GetCollaborators()
 21658  }
 21659  
 21660  func TestUser_GetCompany(tt *testing.T) {
 21661  	var zeroValue string
 21662  	u := &User{Company: &zeroValue}
 21663  	u.GetCompany()
 21664  	u = &User{}
 21665  	u.GetCompany()
 21666  	u = nil
 21667  	u.GetCompany()
 21668  }
 21669  
 21670  func TestUser_GetCreatedAt(tt *testing.T) {
 21671  	var zeroValue Timestamp
 21672  	u := &User{CreatedAt: &zeroValue}
 21673  	u.GetCreatedAt()
 21674  	u = &User{}
 21675  	u.GetCreatedAt()
 21676  	u = nil
 21677  	u.GetCreatedAt()
 21678  }
 21679  
 21680  func TestUser_GetDiskUsage(tt *testing.T) {
 21681  	var zeroValue int
 21682  	u := &User{DiskUsage: &zeroValue}
 21683  	u.GetDiskUsage()
 21684  	u = &User{}
 21685  	u.GetDiskUsage()
 21686  	u = nil
 21687  	u.GetDiskUsage()
 21688  }
 21689  
 21690  func TestUser_GetEmail(tt *testing.T) {
 21691  	var zeroValue string
 21692  	u := &User{Email: &zeroValue}
 21693  	u.GetEmail()
 21694  	u = &User{}
 21695  	u.GetEmail()
 21696  	u = nil
 21697  	u.GetEmail()
 21698  }
 21699  
 21700  func TestUser_GetEventsURL(tt *testing.T) {
 21701  	var zeroValue string
 21702  	u := &User{EventsURL: &zeroValue}
 21703  	u.GetEventsURL()
 21704  	u = &User{}
 21705  	u.GetEventsURL()
 21706  	u = nil
 21707  	u.GetEventsURL()
 21708  }
 21709  
 21710  func TestUser_GetFollowers(tt *testing.T) {
 21711  	var zeroValue int
 21712  	u := &User{Followers: &zeroValue}
 21713  	u.GetFollowers()
 21714  	u = &User{}
 21715  	u.GetFollowers()
 21716  	u = nil
 21717  	u.GetFollowers()
 21718  }
 21719  
 21720  func TestUser_GetFollowersURL(tt *testing.T) {
 21721  	var zeroValue string
 21722  	u := &User{FollowersURL: &zeroValue}
 21723  	u.GetFollowersURL()
 21724  	u = &User{}
 21725  	u.GetFollowersURL()
 21726  	u = nil
 21727  	u.GetFollowersURL()
 21728  }
 21729  
 21730  func TestUser_GetFollowing(tt *testing.T) {
 21731  	var zeroValue int
 21732  	u := &User{Following: &zeroValue}
 21733  	u.GetFollowing()
 21734  	u = &User{}
 21735  	u.GetFollowing()
 21736  	u = nil
 21737  	u.GetFollowing()
 21738  }
 21739  
 21740  func TestUser_GetFollowingURL(tt *testing.T) {
 21741  	var zeroValue string
 21742  	u := &User{FollowingURL: &zeroValue}
 21743  	u.GetFollowingURL()
 21744  	u = &User{}
 21745  	u.GetFollowingURL()
 21746  	u = nil
 21747  	u.GetFollowingURL()
 21748  }
 21749  
 21750  func TestUser_GetGistsURL(tt *testing.T) {
 21751  	var zeroValue string
 21752  	u := &User{GistsURL: &zeroValue}
 21753  	u.GetGistsURL()
 21754  	u = &User{}
 21755  	u.GetGistsURL()
 21756  	u = nil
 21757  	u.GetGistsURL()
 21758  }
 21759  
 21760  func TestUser_GetGravatarID(tt *testing.T) {
 21761  	var zeroValue string
 21762  	u := &User{GravatarID: &zeroValue}
 21763  	u.GetGravatarID()
 21764  	u = &User{}
 21765  	u.GetGravatarID()
 21766  	u = nil
 21767  	u.GetGravatarID()
 21768  }
 21769  
 21770  func TestUser_GetHireable(tt *testing.T) {
 21771  	var zeroValue bool
 21772  	u := &User{Hireable: &zeroValue}
 21773  	u.GetHireable()
 21774  	u = &User{}
 21775  	u.GetHireable()
 21776  	u = nil
 21777  	u.GetHireable()
 21778  }
 21779  
 21780  func TestUser_GetHTMLURL(tt *testing.T) {
 21781  	var zeroValue string
 21782  	u := &User{HTMLURL: &zeroValue}
 21783  	u.GetHTMLURL()
 21784  	u = &User{}
 21785  	u.GetHTMLURL()
 21786  	u = nil
 21787  	u.GetHTMLURL()
 21788  }
 21789  
 21790  func TestUser_GetID(tt *testing.T) {
 21791  	var zeroValue int64
 21792  	u := &User{ID: &zeroValue}
 21793  	u.GetID()
 21794  	u = &User{}
 21795  	u.GetID()
 21796  	u = nil
 21797  	u.GetID()
 21798  }
 21799  
 21800  func TestUser_GetLdapDn(tt *testing.T) {
 21801  	var zeroValue string
 21802  	u := &User{LdapDn: &zeroValue}
 21803  	u.GetLdapDn()
 21804  	u = &User{}
 21805  	u.GetLdapDn()
 21806  	u = nil
 21807  	u.GetLdapDn()
 21808  }
 21809  
 21810  func TestUser_GetLocation(tt *testing.T) {
 21811  	var zeroValue string
 21812  	u := &User{Location: &zeroValue}
 21813  	u.GetLocation()
 21814  	u = &User{}
 21815  	u.GetLocation()
 21816  	u = nil
 21817  	u.GetLocation()
 21818  }
 21819  
 21820  func TestUser_GetLogin(tt *testing.T) {
 21821  	var zeroValue string
 21822  	u := &User{Login: &zeroValue}
 21823  	u.GetLogin()
 21824  	u = &User{}
 21825  	u.GetLogin()
 21826  	u = nil
 21827  	u.GetLogin()
 21828  }
 21829  
 21830  func TestUser_GetName(tt *testing.T) {
 21831  	var zeroValue string
 21832  	u := &User{Name: &zeroValue}
 21833  	u.GetName()
 21834  	u = &User{}
 21835  	u.GetName()
 21836  	u = nil
 21837  	u.GetName()
 21838  }
 21839  
 21840  func TestUser_GetNodeID(tt *testing.T) {
 21841  	var zeroValue string
 21842  	u := &User{NodeID: &zeroValue}
 21843  	u.GetNodeID()
 21844  	u = &User{}
 21845  	u.GetNodeID()
 21846  	u = nil
 21847  	u.GetNodeID()
 21848  }
 21849  
 21850  func TestUser_GetOrganizationsURL(tt *testing.T) {
 21851  	var zeroValue string
 21852  	u := &User{OrganizationsURL: &zeroValue}
 21853  	u.GetOrganizationsURL()
 21854  	u = &User{}
 21855  	u.GetOrganizationsURL()
 21856  	u = nil
 21857  	u.GetOrganizationsURL()
 21858  }
 21859  
 21860  func TestUser_GetOwnedPrivateRepos(tt *testing.T) {
 21861  	var zeroValue int
 21862  	u := &User{OwnedPrivateRepos: &zeroValue}
 21863  	u.GetOwnedPrivateRepos()
 21864  	u = &User{}
 21865  	u.GetOwnedPrivateRepos()
 21866  	u = nil
 21867  	u.GetOwnedPrivateRepos()
 21868  }
 21869  
 21870  func TestUser_GetPermissions(tt *testing.T) {
 21871  	zeroValue := map[string]bool{}
 21872  	u := &User{Permissions: zeroValue}
 21873  	u.GetPermissions()
 21874  	u = &User{}
 21875  	u.GetPermissions()
 21876  	u = nil
 21877  	u.GetPermissions()
 21878  }
 21879  
 21880  func TestUser_GetPlan(tt *testing.T) {
 21881  	u := &User{}
 21882  	u.GetPlan()
 21883  	u = nil
 21884  	u.GetPlan()
 21885  }
 21886  
 21887  func TestUser_GetPrivateGists(tt *testing.T) {
 21888  	var zeroValue int
 21889  	u := &User{PrivateGists: &zeroValue}
 21890  	u.GetPrivateGists()
 21891  	u = &User{}
 21892  	u.GetPrivateGists()
 21893  	u = nil
 21894  	u.GetPrivateGists()
 21895  }
 21896  
 21897  func TestUser_GetPublicGists(tt *testing.T) {
 21898  	var zeroValue int
 21899  	u := &User{PublicGists: &zeroValue}
 21900  	u.GetPublicGists()
 21901  	u = &User{}
 21902  	u.GetPublicGists()
 21903  	u = nil
 21904  	u.GetPublicGists()
 21905  }
 21906  
 21907  func TestUser_GetPublicRepos(tt *testing.T) {
 21908  	var zeroValue int
 21909  	u := &User{PublicRepos: &zeroValue}
 21910  	u.GetPublicRepos()
 21911  	u = &User{}
 21912  	u.GetPublicRepos()
 21913  	u = nil
 21914  	u.GetPublicRepos()
 21915  }
 21916  
 21917  func TestUser_GetReceivedEventsURL(tt *testing.T) {
 21918  	var zeroValue string
 21919  	u := &User{ReceivedEventsURL: &zeroValue}
 21920  	u.GetReceivedEventsURL()
 21921  	u = &User{}
 21922  	u.GetReceivedEventsURL()
 21923  	u = nil
 21924  	u.GetReceivedEventsURL()
 21925  }
 21926  
 21927  func TestUser_GetReposURL(tt *testing.T) {
 21928  	var zeroValue string
 21929  	u := &User{ReposURL: &zeroValue}
 21930  	u.GetReposURL()
 21931  	u = &User{}
 21932  	u.GetReposURL()
 21933  	u = nil
 21934  	u.GetReposURL()
 21935  }
 21936  
 21937  func TestUser_GetRoleName(tt *testing.T) {
 21938  	var zeroValue string
 21939  	u := &User{RoleName: &zeroValue}
 21940  	u.GetRoleName()
 21941  	u = &User{}
 21942  	u.GetRoleName()
 21943  	u = nil
 21944  	u.GetRoleName()
 21945  }
 21946  
 21947  func TestUser_GetSiteAdmin(tt *testing.T) {
 21948  	var zeroValue bool
 21949  	u := &User{SiteAdmin: &zeroValue}
 21950  	u.GetSiteAdmin()
 21951  	u = &User{}
 21952  	u.GetSiteAdmin()
 21953  	u = nil
 21954  	u.GetSiteAdmin()
 21955  }
 21956  
 21957  func TestUser_GetStarredURL(tt *testing.T) {
 21958  	var zeroValue string
 21959  	u := &User{StarredURL: &zeroValue}
 21960  	u.GetStarredURL()
 21961  	u = &User{}
 21962  	u.GetStarredURL()
 21963  	u = nil
 21964  	u.GetStarredURL()
 21965  }
 21966  
 21967  func TestUser_GetSubscriptionsURL(tt *testing.T) {
 21968  	var zeroValue string
 21969  	u := &User{SubscriptionsURL: &zeroValue}
 21970  	u.GetSubscriptionsURL()
 21971  	u = &User{}
 21972  	u.GetSubscriptionsURL()
 21973  	u = nil
 21974  	u.GetSubscriptionsURL()
 21975  }
 21976  
 21977  func TestUser_GetSuspendedAt(tt *testing.T) {
 21978  	var zeroValue Timestamp
 21979  	u := &User{SuspendedAt: &zeroValue}
 21980  	u.GetSuspendedAt()
 21981  	u = &User{}
 21982  	u.GetSuspendedAt()
 21983  	u = nil
 21984  	u.GetSuspendedAt()
 21985  }
 21986  
 21987  func TestUser_GetTotalPrivateRepos(tt *testing.T) {
 21988  	var zeroValue int
 21989  	u := &User{TotalPrivateRepos: &zeroValue}
 21990  	u.GetTotalPrivateRepos()
 21991  	u = &User{}
 21992  	u.GetTotalPrivateRepos()
 21993  	u = nil
 21994  	u.GetTotalPrivateRepos()
 21995  }
 21996  
 21997  func TestUser_GetTwitterUsername(tt *testing.T) {
 21998  	var zeroValue string
 21999  	u := &User{TwitterUsername: &zeroValue}
 22000  	u.GetTwitterUsername()
 22001  	u = &User{}
 22002  	u.GetTwitterUsername()
 22003  	u = nil
 22004  	u.GetTwitterUsername()
 22005  }
 22006  
 22007  func TestUser_GetTwoFactorAuthentication(tt *testing.T) {
 22008  	var zeroValue bool
 22009  	u := &User{TwoFactorAuthentication: &zeroValue}
 22010  	u.GetTwoFactorAuthentication()
 22011  	u = &User{}
 22012  	u.GetTwoFactorAuthentication()
 22013  	u = nil
 22014  	u.GetTwoFactorAuthentication()
 22015  }
 22016  
 22017  func TestUser_GetType(tt *testing.T) {
 22018  	var zeroValue string
 22019  	u := &User{Type: &zeroValue}
 22020  	u.GetType()
 22021  	u = &User{}
 22022  	u.GetType()
 22023  	u = nil
 22024  	u.GetType()
 22025  }
 22026  
 22027  func TestUser_GetUpdatedAt(tt *testing.T) {
 22028  	var zeroValue Timestamp
 22029  	u := &User{UpdatedAt: &zeroValue}
 22030  	u.GetUpdatedAt()
 22031  	u = &User{}
 22032  	u.GetUpdatedAt()
 22033  	u = nil
 22034  	u.GetUpdatedAt()
 22035  }
 22036  
 22037  func TestUser_GetURL(tt *testing.T) {
 22038  	var zeroValue string
 22039  	u := &User{URL: &zeroValue}
 22040  	u.GetURL()
 22041  	u = &User{}
 22042  	u.GetURL()
 22043  	u = nil
 22044  	u.GetURL()
 22045  }
 22046  
 22047  func TestUserAuthorization_GetApp(tt *testing.T) {
 22048  	u := &UserAuthorization{}
 22049  	u.GetApp()
 22050  	u = nil
 22051  	u.GetApp()
 22052  }
 22053  
 22054  func TestUserAuthorization_GetCreatedAt(tt *testing.T) {
 22055  	var zeroValue Timestamp
 22056  	u := &UserAuthorization{CreatedAt: &zeroValue}
 22057  	u.GetCreatedAt()
 22058  	u = &UserAuthorization{}
 22059  	u.GetCreatedAt()
 22060  	u = nil
 22061  	u.GetCreatedAt()
 22062  }
 22063  
 22064  func TestUserAuthorization_GetFingerprint(tt *testing.T) {
 22065  	var zeroValue string
 22066  	u := &UserAuthorization{Fingerprint: &zeroValue}
 22067  	u.GetFingerprint()
 22068  	u = &UserAuthorization{}
 22069  	u.GetFingerprint()
 22070  	u = nil
 22071  	u.GetFingerprint()
 22072  }
 22073  
 22074  func TestUserAuthorization_GetHashedToken(tt *testing.T) {
 22075  	var zeroValue string
 22076  	u := &UserAuthorization{HashedToken: &zeroValue}
 22077  	u.GetHashedToken()
 22078  	u = &UserAuthorization{}
 22079  	u.GetHashedToken()
 22080  	u = nil
 22081  	u.GetHashedToken()
 22082  }
 22083  
 22084  func TestUserAuthorization_GetID(tt *testing.T) {
 22085  	var zeroValue int64
 22086  	u := &UserAuthorization{ID: &zeroValue}
 22087  	u.GetID()
 22088  	u = &UserAuthorization{}
 22089  	u.GetID()
 22090  	u = nil
 22091  	u.GetID()
 22092  }
 22093  
 22094  func TestUserAuthorization_GetNote(tt *testing.T) {
 22095  	var zeroValue string
 22096  	u := &UserAuthorization{Note: &zeroValue}
 22097  	u.GetNote()
 22098  	u = &UserAuthorization{}
 22099  	u.GetNote()
 22100  	u = nil
 22101  	u.GetNote()
 22102  }
 22103  
 22104  func TestUserAuthorization_GetNoteURL(tt *testing.T) {
 22105  	var zeroValue string
 22106  	u := &UserAuthorization{NoteURL: &zeroValue}
 22107  	u.GetNoteURL()
 22108  	u = &UserAuthorization{}
 22109  	u.GetNoteURL()
 22110  	u = nil
 22111  	u.GetNoteURL()
 22112  }
 22113  
 22114  func TestUserAuthorization_GetToken(tt *testing.T) {
 22115  	var zeroValue string
 22116  	u := &UserAuthorization{Token: &zeroValue}
 22117  	u.GetToken()
 22118  	u = &UserAuthorization{}
 22119  	u.GetToken()
 22120  	u = nil
 22121  	u.GetToken()
 22122  }
 22123  
 22124  func TestUserAuthorization_GetTokenLastEight(tt *testing.T) {
 22125  	var zeroValue string
 22126  	u := &UserAuthorization{TokenLastEight: &zeroValue}
 22127  	u.GetTokenLastEight()
 22128  	u = &UserAuthorization{}
 22129  	u.GetTokenLastEight()
 22130  	u = nil
 22131  	u.GetTokenLastEight()
 22132  }
 22133  
 22134  func TestUserAuthorization_GetUpdatedAt(tt *testing.T) {
 22135  	var zeroValue Timestamp
 22136  	u := &UserAuthorization{UpdatedAt: &zeroValue}
 22137  	u.GetUpdatedAt()
 22138  	u = &UserAuthorization{}
 22139  	u.GetUpdatedAt()
 22140  	u = nil
 22141  	u.GetUpdatedAt()
 22142  }
 22143  
 22144  func TestUserAuthorization_GetURL(tt *testing.T) {
 22145  	var zeroValue string
 22146  	u := &UserAuthorization{URL: &zeroValue}
 22147  	u.GetURL()
 22148  	u = &UserAuthorization{}
 22149  	u.GetURL()
 22150  	u = nil
 22151  	u.GetURL()
 22152  }
 22153  
 22154  func TestUserContext_GetMessage(tt *testing.T) {
 22155  	var zeroValue string
 22156  	u := &UserContext{Message: &zeroValue}
 22157  	u.GetMessage()
 22158  	u = &UserContext{}
 22159  	u.GetMessage()
 22160  	u = nil
 22161  	u.GetMessage()
 22162  }
 22163  
 22164  func TestUserContext_GetOcticon(tt *testing.T) {
 22165  	var zeroValue string
 22166  	u := &UserContext{Octicon: &zeroValue}
 22167  	u.GetOcticon()
 22168  	u = &UserContext{}
 22169  	u.GetOcticon()
 22170  	u = nil
 22171  	u.GetOcticon()
 22172  }
 22173  
 22174  func TestUserEmail_GetEmail(tt *testing.T) {
 22175  	var zeroValue string
 22176  	u := &UserEmail{Email: &zeroValue}
 22177  	u.GetEmail()
 22178  	u = &UserEmail{}
 22179  	u.GetEmail()
 22180  	u = nil
 22181  	u.GetEmail()
 22182  }
 22183  
 22184  func TestUserEmail_GetPrimary(tt *testing.T) {
 22185  	var zeroValue bool
 22186  	u := &UserEmail{Primary: &zeroValue}
 22187  	u.GetPrimary()
 22188  	u = &UserEmail{}
 22189  	u.GetPrimary()
 22190  	u = nil
 22191  	u.GetPrimary()
 22192  }
 22193  
 22194  func TestUserEmail_GetVerified(tt *testing.T) {
 22195  	var zeroValue bool
 22196  	u := &UserEmail{Verified: &zeroValue}
 22197  	u.GetVerified()
 22198  	u = &UserEmail{}
 22199  	u.GetVerified()
 22200  	u = nil
 22201  	u.GetVerified()
 22202  }
 22203  
 22204  func TestUserEmail_GetVisibility(tt *testing.T) {
 22205  	var zeroValue string
 22206  	u := &UserEmail{Visibility: &zeroValue}
 22207  	u.GetVisibility()
 22208  	u = &UserEmail{}
 22209  	u.GetVisibility()
 22210  	u = nil
 22211  	u.GetVisibility()
 22212  }
 22213  
 22214  func TestUserEvent_GetAction(tt *testing.T) {
 22215  	var zeroValue string
 22216  	u := &UserEvent{Action: &zeroValue}
 22217  	u.GetAction()
 22218  	u = &UserEvent{}
 22219  	u.GetAction()
 22220  	u = nil
 22221  	u.GetAction()
 22222  }
 22223  
 22224  func TestUserEvent_GetEnterprise(tt *testing.T) {
 22225  	u := &UserEvent{}
 22226  	u.GetEnterprise()
 22227  	u = nil
 22228  	u.GetEnterprise()
 22229  }
 22230  
 22231  func TestUserEvent_GetInstallation(tt *testing.T) {
 22232  	u := &UserEvent{}
 22233  	u.GetInstallation()
 22234  	u = nil
 22235  	u.GetInstallation()
 22236  }
 22237  
 22238  func TestUserEvent_GetSender(tt *testing.T) {
 22239  	u := &UserEvent{}
 22240  	u.GetSender()
 22241  	u = nil
 22242  	u.GetSender()
 22243  }
 22244  
 22245  func TestUserEvent_GetUser(tt *testing.T) {
 22246  	u := &UserEvent{}
 22247  	u.GetUser()
 22248  	u = nil
 22249  	u.GetUser()
 22250  }
 22251  
 22252  func TestUserLDAPMapping_GetAvatarURL(tt *testing.T) {
 22253  	var zeroValue string
 22254  	u := &UserLDAPMapping{AvatarURL: &zeroValue}
 22255  	u.GetAvatarURL()
 22256  	u = &UserLDAPMapping{}
 22257  	u.GetAvatarURL()
 22258  	u = nil
 22259  	u.GetAvatarURL()
 22260  }
 22261  
 22262  func TestUserLDAPMapping_GetEventsURL(tt *testing.T) {
 22263  	var zeroValue string
 22264  	u := &UserLDAPMapping{EventsURL: &zeroValue}
 22265  	u.GetEventsURL()
 22266  	u = &UserLDAPMapping{}
 22267  	u.GetEventsURL()
 22268  	u = nil
 22269  	u.GetEventsURL()
 22270  }
 22271  
 22272  func TestUserLDAPMapping_GetFollowersURL(tt *testing.T) {
 22273  	var zeroValue string
 22274  	u := &UserLDAPMapping{FollowersURL: &zeroValue}
 22275  	u.GetFollowersURL()
 22276  	u = &UserLDAPMapping{}
 22277  	u.GetFollowersURL()
 22278  	u = nil
 22279  	u.GetFollowersURL()
 22280  }
 22281  
 22282  func TestUserLDAPMapping_GetFollowingURL(tt *testing.T) {
 22283  	var zeroValue string
 22284  	u := &UserLDAPMapping{FollowingURL: &zeroValue}
 22285  	u.GetFollowingURL()
 22286  	u = &UserLDAPMapping{}
 22287  	u.GetFollowingURL()
 22288  	u = nil
 22289  	u.GetFollowingURL()
 22290  }
 22291  
 22292  func TestUserLDAPMapping_GetGistsURL(tt *testing.T) {
 22293  	var zeroValue string
 22294  	u := &UserLDAPMapping{GistsURL: &zeroValue}
 22295  	u.GetGistsURL()
 22296  	u = &UserLDAPMapping{}
 22297  	u.GetGistsURL()
 22298  	u = nil
 22299  	u.GetGistsURL()
 22300  }
 22301  
 22302  func TestUserLDAPMapping_GetGravatarID(tt *testing.T) {
 22303  	var zeroValue string
 22304  	u := &UserLDAPMapping{GravatarID: &zeroValue}
 22305  	u.GetGravatarID()
 22306  	u = &UserLDAPMapping{}
 22307  	u.GetGravatarID()
 22308  	u = nil
 22309  	u.GetGravatarID()
 22310  }
 22311  
 22312  func TestUserLDAPMapping_GetID(tt *testing.T) {
 22313  	var zeroValue int64
 22314  	u := &UserLDAPMapping{ID: &zeroValue}
 22315  	u.GetID()
 22316  	u = &UserLDAPMapping{}
 22317  	u.GetID()
 22318  	u = nil
 22319  	u.GetID()
 22320  }
 22321  
 22322  func TestUserLDAPMapping_GetLDAPDN(tt *testing.T) {
 22323  	var zeroValue string
 22324  	u := &UserLDAPMapping{LDAPDN: &zeroValue}
 22325  	u.GetLDAPDN()
 22326  	u = &UserLDAPMapping{}
 22327  	u.GetLDAPDN()
 22328  	u = nil
 22329  	u.GetLDAPDN()
 22330  }
 22331  
 22332  func TestUserLDAPMapping_GetLogin(tt *testing.T) {
 22333  	var zeroValue string
 22334  	u := &UserLDAPMapping{Login: &zeroValue}
 22335  	u.GetLogin()
 22336  	u = &UserLDAPMapping{}
 22337  	u.GetLogin()
 22338  	u = nil
 22339  	u.GetLogin()
 22340  }
 22341  
 22342  func TestUserLDAPMapping_GetOrganizationsURL(tt *testing.T) {
 22343  	var zeroValue string
 22344  	u := &UserLDAPMapping{OrganizationsURL: &zeroValue}
 22345  	u.GetOrganizationsURL()
 22346  	u = &UserLDAPMapping{}
 22347  	u.GetOrganizationsURL()
 22348  	u = nil
 22349  	u.GetOrganizationsURL()
 22350  }
 22351  
 22352  func TestUserLDAPMapping_GetReceivedEventsURL(tt *testing.T) {
 22353  	var zeroValue string
 22354  	u := &UserLDAPMapping{ReceivedEventsURL: &zeroValue}
 22355  	u.GetReceivedEventsURL()
 22356  	u = &UserLDAPMapping{}
 22357  	u.GetReceivedEventsURL()
 22358  	u = nil
 22359  	u.GetReceivedEventsURL()
 22360  }
 22361  
 22362  func TestUserLDAPMapping_GetReposURL(tt *testing.T) {
 22363  	var zeroValue string
 22364  	u := &UserLDAPMapping{ReposURL: &zeroValue}
 22365  	u.GetReposURL()
 22366  	u = &UserLDAPMapping{}
 22367  	u.GetReposURL()
 22368  	u = nil
 22369  	u.GetReposURL()
 22370  }
 22371  
 22372  func TestUserLDAPMapping_GetSiteAdmin(tt *testing.T) {
 22373  	var zeroValue bool
 22374  	u := &UserLDAPMapping{SiteAdmin: &zeroValue}
 22375  	u.GetSiteAdmin()
 22376  	u = &UserLDAPMapping{}
 22377  	u.GetSiteAdmin()
 22378  	u = nil
 22379  	u.GetSiteAdmin()
 22380  }
 22381  
 22382  func TestUserLDAPMapping_GetStarredURL(tt *testing.T) {
 22383  	var zeroValue string
 22384  	u := &UserLDAPMapping{StarredURL: &zeroValue}
 22385  	u.GetStarredURL()
 22386  	u = &UserLDAPMapping{}
 22387  	u.GetStarredURL()
 22388  	u = nil
 22389  	u.GetStarredURL()
 22390  }
 22391  
 22392  func TestUserLDAPMapping_GetSubscriptionsURL(tt *testing.T) {
 22393  	var zeroValue string
 22394  	u := &UserLDAPMapping{SubscriptionsURL: &zeroValue}
 22395  	u.GetSubscriptionsURL()
 22396  	u = &UserLDAPMapping{}
 22397  	u.GetSubscriptionsURL()
 22398  	u = nil
 22399  	u.GetSubscriptionsURL()
 22400  }
 22401  
 22402  func TestUserLDAPMapping_GetType(tt *testing.T) {
 22403  	var zeroValue string
 22404  	u := &UserLDAPMapping{Type: &zeroValue}
 22405  	u.GetType()
 22406  	u = &UserLDAPMapping{}
 22407  	u.GetType()
 22408  	u = nil
 22409  	u.GetType()
 22410  }
 22411  
 22412  func TestUserLDAPMapping_GetURL(tt *testing.T) {
 22413  	var zeroValue string
 22414  	u := &UserLDAPMapping{URL: &zeroValue}
 22415  	u.GetURL()
 22416  	u = &UserLDAPMapping{}
 22417  	u.GetURL()
 22418  	u = nil
 22419  	u.GetURL()
 22420  }
 22421  
 22422  func TestUserMigration_GetCreatedAt(tt *testing.T) {
 22423  	var zeroValue string
 22424  	u := &UserMigration{CreatedAt: &zeroValue}
 22425  	u.GetCreatedAt()
 22426  	u = &UserMigration{}
 22427  	u.GetCreatedAt()
 22428  	u = nil
 22429  	u.GetCreatedAt()
 22430  }
 22431  
 22432  func TestUserMigration_GetExcludeAttachments(tt *testing.T) {
 22433  	var zeroValue bool
 22434  	u := &UserMigration{ExcludeAttachments: &zeroValue}
 22435  	u.GetExcludeAttachments()
 22436  	u = &UserMigration{}
 22437  	u.GetExcludeAttachments()
 22438  	u = nil
 22439  	u.GetExcludeAttachments()
 22440  }
 22441  
 22442  func TestUserMigration_GetGUID(tt *testing.T) {
 22443  	var zeroValue string
 22444  	u := &UserMigration{GUID: &zeroValue}
 22445  	u.GetGUID()
 22446  	u = &UserMigration{}
 22447  	u.GetGUID()
 22448  	u = nil
 22449  	u.GetGUID()
 22450  }
 22451  
 22452  func TestUserMigration_GetID(tt *testing.T) {
 22453  	var zeroValue int64
 22454  	u := &UserMigration{ID: &zeroValue}
 22455  	u.GetID()
 22456  	u = &UserMigration{}
 22457  	u.GetID()
 22458  	u = nil
 22459  	u.GetID()
 22460  }
 22461  
 22462  func TestUserMigration_GetLockRepositories(tt *testing.T) {
 22463  	var zeroValue bool
 22464  	u := &UserMigration{LockRepositories: &zeroValue}
 22465  	u.GetLockRepositories()
 22466  	u = &UserMigration{}
 22467  	u.GetLockRepositories()
 22468  	u = nil
 22469  	u.GetLockRepositories()
 22470  }
 22471  
 22472  func TestUserMigration_GetState(tt *testing.T) {
 22473  	var zeroValue string
 22474  	u := &UserMigration{State: &zeroValue}
 22475  	u.GetState()
 22476  	u = &UserMigration{}
 22477  	u.GetState()
 22478  	u = nil
 22479  	u.GetState()
 22480  }
 22481  
 22482  func TestUserMigration_GetUpdatedAt(tt *testing.T) {
 22483  	var zeroValue string
 22484  	u := &UserMigration{UpdatedAt: &zeroValue}
 22485  	u.GetUpdatedAt()
 22486  	u = &UserMigration{}
 22487  	u.GetUpdatedAt()
 22488  	u = nil
 22489  	u.GetUpdatedAt()
 22490  }
 22491  
 22492  func TestUserMigration_GetURL(tt *testing.T) {
 22493  	var zeroValue string
 22494  	u := &UserMigration{URL: &zeroValue}
 22495  	u.GetURL()
 22496  	u = &UserMigration{}
 22497  	u.GetURL()
 22498  	u = nil
 22499  	u.GetURL()
 22500  }
 22501  
 22502  func TestUsersSearchResult_GetIncompleteResults(tt *testing.T) {
 22503  	var zeroValue bool
 22504  	u := &UsersSearchResult{IncompleteResults: &zeroValue}
 22505  	u.GetIncompleteResults()
 22506  	u = &UsersSearchResult{}
 22507  	u.GetIncompleteResults()
 22508  	u = nil
 22509  	u.GetIncompleteResults()
 22510  }
 22511  
 22512  func TestUsersSearchResult_GetTotal(tt *testing.T) {
 22513  	var zeroValue int
 22514  	u := &UsersSearchResult{Total: &zeroValue}
 22515  	u.GetTotal()
 22516  	u = &UsersSearchResult{}
 22517  	u.GetTotal()
 22518  	u = nil
 22519  	u.GetTotal()
 22520  }
 22521  
 22522  func TestUserStats_GetAdminUsers(tt *testing.T) {
 22523  	var zeroValue int
 22524  	u := &UserStats{AdminUsers: &zeroValue}
 22525  	u.GetAdminUsers()
 22526  	u = &UserStats{}
 22527  	u.GetAdminUsers()
 22528  	u = nil
 22529  	u.GetAdminUsers()
 22530  }
 22531  
 22532  func TestUserStats_GetSuspendedUsers(tt *testing.T) {
 22533  	var zeroValue int
 22534  	u := &UserStats{SuspendedUsers: &zeroValue}
 22535  	u.GetSuspendedUsers()
 22536  	u = &UserStats{}
 22537  	u.GetSuspendedUsers()
 22538  	u = nil
 22539  	u.GetSuspendedUsers()
 22540  }
 22541  
 22542  func TestUserStats_GetTotalUsers(tt *testing.T) {
 22543  	var zeroValue int
 22544  	u := &UserStats{TotalUsers: &zeroValue}
 22545  	u.GetTotalUsers()
 22546  	u = &UserStats{}
 22547  	u.GetTotalUsers()
 22548  	u = nil
 22549  	u.GetTotalUsers()
 22550  }
 22551  
 22552  func TestUserSuspendOptions_GetReason(tt *testing.T) {
 22553  	var zeroValue string
 22554  	u := &UserSuspendOptions{Reason: &zeroValue}
 22555  	u.GetReason()
 22556  	u = &UserSuspendOptions{}
 22557  	u.GetReason()
 22558  	u = nil
 22559  	u.GetReason()
 22560  }
 22561  
 22562  func TestVulnerabilityPackage_GetEcosystem(tt *testing.T) {
 22563  	var zeroValue string
 22564  	v := &VulnerabilityPackage{Ecosystem: &zeroValue}
 22565  	v.GetEcosystem()
 22566  	v = &VulnerabilityPackage{}
 22567  	v.GetEcosystem()
 22568  	v = nil
 22569  	v.GetEcosystem()
 22570  }
 22571  
 22572  func TestVulnerabilityPackage_GetName(tt *testing.T) {
 22573  	var zeroValue string
 22574  	v := &VulnerabilityPackage{Name: &zeroValue}
 22575  	v.GetName()
 22576  	v = &VulnerabilityPackage{}
 22577  	v.GetName()
 22578  	v = nil
 22579  	v.GetName()
 22580  }
 22581  
 22582  func TestWatchEvent_GetAction(tt *testing.T) {
 22583  	var zeroValue string
 22584  	w := &WatchEvent{Action: &zeroValue}
 22585  	w.GetAction()
 22586  	w = &WatchEvent{}
 22587  	w.GetAction()
 22588  	w = nil
 22589  	w.GetAction()
 22590  }
 22591  
 22592  func TestWatchEvent_GetInstallation(tt *testing.T) {
 22593  	w := &WatchEvent{}
 22594  	w.GetInstallation()
 22595  	w = nil
 22596  	w.GetInstallation()
 22597  }
 22598  
 22599  func TestWatchEvent_GetRepo(tt *testing.T) {
 22600  	w := &WatchEvent{}
 22601  	w.GetRepo()
 22602  	w = nil
 22603  	w.GetRepo()
 22604  }
 22605  
 22606  func TestWatchEvent_GetSender(tt *testing.T) {
 22607  	w := &WatchEvent{}
 22608  	w.GetSender()
 22609  	w = nil
 22610  	w.GetSender()
 22611  }
 22612  
 22613  func TestWeeklyCommitActivity_GetTotal(tt *testing.T) {
 22614  	var zeroValue int
 22615  	w := &WeeklyCommitActivity{Total: &zeroValue}
 22616  	w.GetTotal()
 22617  	w = &WeeklyCommitActivity{}
 22618  	w.GetTotal()
 22619  	w = nil
 22620  	w.GetTotal()
 22621  }
 22622  
 22623  func TestWeeklyCommitActivity_GetWeek(tt *testing.T) {
 22624  	var zeroValue Timestamp
 22625  	w := &WeeklyCommitActivity{Week: &zeroValue}
 22626  	w.GetWeek()
 22627  	w = &WeeklyCommitActivity{}
 22628  	w.GetWeek()
 22629  	w = nil
 22630  	w.GetWeek()
 22631  }
 22632  
 22633  func TestWeeklyStats_GetAdditions(tt *testing.T) {
 22634  	var zeroValue int
 22635  	w := &WeeklyStats{Additions: &zeroValue}
 22636  	w.GetAdditions()
 22637  	w = &WeeklyStats{}
 22638  	w.GetAdditions()
 22639  	w = nil
 22640  	w.GetAdditions()
 22641  }
 22642  
 22643  func TestWeeklyStats_GetCommits(tt *testing.T) {
 22644  	var zeroValue int
 22645  	w := &WeeklyStats{Commits: &zeroValue}
 22646  	w.GetCommits()
 22647  	w = &WeeklyStats{}
 22648  	w.GetCommits()
 22649  	w = nil
 22650  	w.GetCommits()
 22651  }
 22652  
 22653  func TestWeeklyStats_GetDeletions(tt *testing.T) {
 22654  	var zeroValue int
 22655  	w := &WeeklyStats{Deletions: &zeroValue}
 22656  	w.GetDeletions()
 22657  	w = &WeeklyStats{}
 22658  	w.GetDeletions()
 22659  	w = nil
 22660  	w.GetDeletions()
 22661  }
 22662  
 22663  func TestWeeklyStats_GetWeek(tt *testing.T) {
 22664  	var zeroValue Timestamp
 22665  	w := &WeeklyStats{Week: &zeroValue}
 22666  	w.GetWeek()
 22667  	w = &WeeklyStats{}
 22668  	w.GetWeek()
 22669  	w = nil
 22670  	w.GetWeek()
 22671  }
 22672  
 22673  func TestWorkflow_GetBadgeURL(tt *testing.T) {
 22674  	var zeroValue string
 22675  	w := &Workflow{BadgeURL: &zeroValue}
 22676  	w.GetBadgeURL()
 22677  	w = &Workflow{}
 22678  	w.GetBadgeURL()
 22679  	w = nil
 22680  	w.GetBadgeURL()
 22681  }
 22682  
 22683  func TestWorkflow_GetCreatedAt(tt *testing.T) {
 22684  	var zeroValue Timestamp
 22685  	w := &Workflow{CreatedAt: &zeroValue}
 22686  	w.GetCreatedAt()
 22687  	w = &Workflow{}
 22688  	w.GetCreatedAt()
 22689  	w = nil
 22690  	w.GetCreatedAt()
 22691  }
 22692  
 22693  func TestWorkflow_GetHTMLURL(tt *testing.T) {
 22694  	var zeroValue string
 22695  	w := &Workflow{HTMLURL: &zeroValue}
 22696  	w.GetHTMLURL()
 22697  	w = &Workflow{}
 22698  	w.GetHTMLURL()
 22699  	w = nil
 22700  	w.GetHTMLURL()
 22701  }
 22702  
 22703  func TestWorkflow_GetID(tt *testing.T) {
 22704  	var zeroValue int64
 22705  	w := &Workflow{ID: &zeroValue}
 22706  	w.GetID()
 22707  	w = &Workflow{}
 22708  	w.GetID()
 22709  	w = nil
 22710  	w.GetID()
 22711  }
 22712  
 22713  func TestWorkflow_GetName(tt *testing.T) {
 22714  	var zeroValue string
 22715  	w := &Workflow{Name: &zeroValue}
 22716  	w.GetName()
 22717  	w = &Workflow{}
 22718  	w.GetName()
 22719  	w = nil
 22720  	w.GetName()
 22721  }
 22722  
 22723  func TestWorkflow_GetNodeID(tt *testing.T) {
 22724  	var zeroValue string
 22725  	w := &Workflow{NodeID: &zeroValue}
 22726  	w.GetNodeID()
 22727  	w = &Workflow{}
 22728  	w.GetNodeID()
 22729  	w = nil
 22730  	w.GetNodeID()
 22731  }
 22732  
 22733  func TestWorkflow_GetPath(tt *testing.T) {
 22734  	var zeroValue string
 22735  	w := &Workflow{Path: &zeroValue}
 22736  	w.GetPath()
 22737  	w = &Workflow{}
 22738  	w.GetPath()
 22739  	w = nil
 22740  	w.GetPath()
 22741  }
 22742  
 22743  func TestWorkflow_GetState(tt *testing.T) {
 22744  	var zeroValue string
 22745  	w := &Workflow{State: &zeroValue}
 22746  	w.GetState()
 22747  	w = &Workflow{}
 22748  	w.GetState()
 22749  	w = nil
 22750  	w.GetState()
 22751  }
 22752  
 22753  func TestWorkflow_GetUpdatedAt(tt *testing.T) {
 22754  	var zeroValue Timestamp
 22755  	w := &Workflow{UpdatedAt: &zeroValue}
 22756  	w.GetUpdatedAt()
 22757  	w = &Workflow{}
 22758  	w.GetUpdatedAt()
 22759  	w = nil
 22760  	w.GetUpdatedAt()
 22761  }
 22762  
 22763  func TestWorkflow_GetURL(tt *testing.T) {
 22764  	var zeroValue string
 22765  	w := &Workflow{URL: &zeroValue}
 22766  	w.GetURL()
 22767  	w = &Workflow{}
 22768  	w.GetURL()
 22769  	w = nil
 22770  	w.GetURL()
 22771  }
 22772  
 22773  func TestWorkflowBill_GetTotalMS(tt *testing.T) {
 22774  	var zeroValue int64
 22775  	w := &WorkflowBill{TotalMS: &zeroValue}
 22776  	w.GetTotalMS()
 22777  	w = &WorkflowBill{}
 22778  	w.GetTotalMS()
 22779  	w = nil
 22780  	w.GetTotalMS()
 22781  }
 22782  
 22783  func TestWorkflowDispatchEvent_GetInstallation(tt *testing.T) {
 22784  	w := &WorkflowDispatchEvent{}
 22785  	w.GetInstallation()
 22786  	w = nil
 22787  	w.GetInstallation()
 22788  }
 22789  
 22790  func TestWorkflowDispatchEvent_GetOrg(tt *testing.T) {
 22791  	w := &WorkflowDispatchEvent{}
 22792  	w.GetOrg()
 22793  	w = nil
 22794  	w.GetOrg()
 22795  }
 22796  
 22797  func TestWorkflowDispatchEvent_GetRef(tt *testing.T) {
 22798  	var zeroValue string
 22799  	w := &WorkflowDispatchEvent{Ref: &zeroValue}
 22800  	w.GetRef()
 22801  	w = &WorkflowDispatchEvent{}
 22802  	w.GetRef()
 22803  	w = nil
 22804  	w.GetRef()
 22805  }
 22806  
 22807  func TestWorkflowDispatchEvent_GetRepo(tt *testing.T) {
 22808  	w := &WorkflowDispatchEvent{}
 22809  	w.GetRepo()
 22810  	w = nil
 22811  	w.GetRepo()
 22812  }
 22813  
 22814  func TestWorkflowDispatchEvent_GetSender(tt *testing.T) {
 22815  	w := &WorkflowDispatchEvent{}
 22816  	w.GetSender()
 22817  	w = nil
 22818  	w.GetSender()
 22819  }
 22820  
 22821  func TestWorkflowDispatchEvent_GetWorkflow(tt *testing.T) {
 22822  	var zeroValue string
 22823  	w := &WorkflowDispatchEvent{Workflow: &zeroValue}
 22824  	w.GetWorkflow()
 22825  	w = &WorkflowDispatchEvent{}
 22826  	w.GetWorkflow()
 22827  	w = nil
 22828  	w.GetWorkflow()
 22829  }
 22830  
 22831  func TestWorkflowEnvironment_GetMacOS(tt *testing.T) {
 22832  	w := &WorkflowEnvironment{}
 22833  	w.GetMacOS()
 22834  	w = nil
 22835  	w.GetMacOS()
 22836  }
 22837  
 22838  func TestWorkflowEnvironment_GetUbuntu(tt *testing.T) {
 22839  	w := &WorkflowEnvironment{}
 22840  	w.GetUbuntu()
 22841  	w = nil
 22842  	w.GetUbuntu()
 22843  }
 22844  
 22845  func TestWorkflowEnvironment_GetWindows(tt *testing.T) {
 22846  	w := &WorkflowEnvironment{}
 22847  	w.GetWindows()
 22848  	w = nil
 22849  	w.GetWindows()
 22850  }
 22851  
 22852  func TestWorkflowJob_GetCheckRunURL(tt *testing.T) {
 22853  	var zeroValue string
 22854  	w := &WorkflowJob{CheckRunURL: &zeroValue}
 22855  	w.GetCheckRunURL()
 22856  	w = &WorkflowJob{}
 22857  	w.GetCheckRunURL()
 22858  	w = nil
 22859  	w.GetCheckRunURL()
 22860  }
 22861  
 22862  func TestWorkflowJob_GetCompletedAt(tt *testing.T) {
 22863  	var zeroValue Timestamp
 22864  	w := &WorkflowJob{CompletedAt: &zeroValue}
 22865  	w.GetCompletedAt()
 22866  	w = &WorkflowJob{}
 22867  	w.GetCompletedAt()
 22868  	w = nil
 22869  	w.GetCompletedAt()
 22870  }
 22871  
 22872  func TestWorkflowJob_GetConclusion(tt *testing.T) {
 22873  	var zeroValue string
 22874  	w := &WorkflowJob{Conclusion: &zeroValue}
 22875  	w.GetConclusion()
 22876  	w = &WorkflowJob{}
 22877  	w.GetConclusion()
 22878  	w = nil
 22879  	w.GetConclusion()
 22880  }
 22881  
 22882  func TestWorkflowJob_GetHeadSHA(tt *testing.T) {
 22883  	var zeroValue string
 22884  	w := &WorkflowJob{HeadSHA: &zeroValue}
 22885  	w.GetHeadSHA()
 22886  	w = &WorkflowJob{}
 22887  	w.GetHeadSHA()
 22888  	w = nil
 22889  	w.GetHeadSHA()
 22890  }
 22891  
 22892  func TestWorkflowJob_GetHTMLURL(tt *testing.T) {
 22893  	var zeroValue string
 22894  	w := &WorkflowJob{HTMLURL: &zeroValue}
 22895  	w.GetHTMLURL()
 22896  	w = &WorkflowJob{}
 22897  	w.GetHTMLURL()
 22898  	w = nil
 22899  	w.GetHTMLURL()
 22900  }
 22901  
 22902  func TestWorkflowJob_GetID(tt *testing.T) {
 22903  	var zeroValue int64
 22904  	w := &WorkflowJob{ID: &zeroValue}
 22905  	w.GetID()
 22906  	w = &WorkflowJob{}
 22907  	w.GetID()
 22908  	w = nil
 22909  	w.GetID()
 22910  }
 22911  
 22912  func TestWorkflowJob_GetName(tt *testing.T) {
 22913  	var zeroValue string
 22914  	w := &WorkflowJob{Name: &zeroValue}
 22915  	w.GetName()
 22916  	w = &WorkflowJob{}
 22917  	w.GetName()
 22918  	w = nil
 22919  	w.GetName()
 22920  }
 22921  
 22922  func TestWorkflowJob_GetNodeID(tt *testing.T) {
 22923  	var zeroValue string
 22924  	w := &WorkflowJob{NodeID: &zeroValue}
 22925  	w.GetNodeID()
 22926  	w = &WorkflowJob{}
 22927  	w.GetNodeID()
 22928  	w = nil
 22929  	w.GetNodeID()
 22930  }
 22931  
 22932  func TestWorkflowJob_GetRunID(tt *testing.T) {
 22933  	var zeroValue int64
 22934  	w := &WorkflowJob{RunID: &zeroValue}
 22935  	w.GetRunID()
 22936  	w = &WorkflowJob{}
 22937  	w.GetRunID()
 22938  	w = nil
 22939  	w.GetRunID()
 22940  }
 22941  
 22942  func TestWorkflowJob_GetRunnerGroupID(tt *testing.T) {
 22943  	var zeroValue int64
 22944  	w := &WorkflowJob{RunnerGroupID: &zeroValue}
 22945  	w.GetRunnerGroupID()
 22946  	w = &WorkflowJob{}
 22947  	w.GetRunnerGroupID()
 22948  	w = nil
 22949  	w.GetRunnerGroupID()
 22950  }
 22951  
 22952  func TestWorkflowJob_GetRunnerGroupName(tt *testing.T) {
 22953  	var zeroValue string
 22954  	w := &WorkflowJob{RunnerGroupName: &zeroValue}
 22955  	w.GetRunnerGroupName()
 22956  	w = &WorkflowJob{}
 22957  	w.GetRunnerGroupName()
 22958  	w = nil
 22959  	w.GetRunnerGroupName()
 22960  }
 22961  
 22962  func TestWorkflowJob_GetRunnerID(tt *testing.T) {
 22963  	var zeroValue int64
 22964  	w := &WorkflowJob{RunnerID: &zeroValue}
 22965  	w.GetRunnerID()
 22966  	w = &WorkflowJob{}
 22967  	w.GetRunnerID()
 22968  	w = nil
 22969  	w.GetRunnerID()
 22970  }
 22971  
 22972  func TestWorkflowJob_GetRunnerName(tt *testing.T) {
 22973  	var zeroValue string
 22974  	w := &WorkflowJob{RunnerName: &zeroValue}
 22975  	w.GetRunnerName()
 22976  	w = &WorkflowJob{}
 22977  	w.GetRunnerName()
 22978  	w = nil
 22979  	w.GetRunnerName()
 22980  }
 22981  
 22982  func TestWorkflowJob_GetRunURL(tt *testing.T) {
 22983  	var zeroValue string
 22984  	w := &WorkflowJob{RunURL: &zeroValue}
 22985  	w.GetRunURL()
 22986  	w = &WorkflowJob{}
 22987  	w.GetRunURL()
 22988  	w = nil
 22989  	w.GetRunURL()
 22990  }
 22991  
 22992  func TestWorkflowJob_GetStartedAt(tt *testing.T) {
 22993  	var zeroValue Timestamp
 22994  	w := &WorkflowJob{StartedAt: &zeroValue}
 22995  	w.GetStartedAt()
 22996  	w = &WorkflowJob{}
 22997  	w.GetStartedAt()
 22998  	w = nil
 22999  	w.GetStartedAt()
 23000  }
 23001  
 23002  func TestWorkflowJob_GetStatus(tt *testing.T) {
 23003  	var zeroValue string
 23004  	w := &WorkflowJob{Status: &zeroValue}
 23005  	w.GetStatus()
 23006  	w = &WorkflowJob{}
 23007  	w.GetStatus()
 23008  	w = nil
 23009  	w.GetStatus()
 23010  }
 23011  
 23012  func TestWorkflowJob_GetURL(tt *testing.T) {
 23013  	var zeroValue string
 23014  	w := &WorkflowJob{URL: &zeroValue}
 23015  	w.GetURL()
 23016  	w = &WorkflowJob{}
 23017  	w.GetURL()
 23018  	w = nil
 23019  	w.GetURL()
 23020  }
 23021  
 23022  func TestWorkflowJobEvent_GetAction(tt *testing.T) {
 23023  	var zeroValue string
 23024  	w := &WorkflowJobEvent{Action: &zeroValue}
 23025  	w.GetAction()
 23026  	w = &WorkflowJobEvent{}
 23027  	w.GetAction()
 23028  	w = nil
 23029  	w.GetAction()
 23030  }
 23031  
 23032  func TestWorkflowJobEvent_GetInstallation(tt *testing.T) {
 23033  	w := &WorkflowJobEvent{}
 23034  	w.GetInstallation()
 23035  	w = nil
 23036  	w.GetInstallation()
 23037  }
 23038  
 23039  func TestWorkflowJobEvent_GetOrg(tt *testing.T) {
 23040  	w := &WorkflowJobEvent{}
 23041  	w.GetOrg()
 23042  	w = nil
 23043  	w.GetOrg()
 23044  }
 23045  
 23046  func TestWorkflowJobEvent_GetRepo(tt *testing.T) {
 23047  	w := &WorkflowJobEvent{}
 23048  	w.GetRepo()
 23049  	w = nil
 23050  	w.GetRepo()
 23051  }
 23052  
 23053  func TestWorkflowJobEvent_GetSender(tt *testing.T) {
 23054  	w := &WorkflowJobEvent{}
 23055  	w.GetSender()
 23056  	w = nil
 23057  	w.GetSender()
 23058  }
 23059  
 23060  func TestWorkflowJobEvent_GetWorkflowJob(tt *testing.T) {
 23061  	w := &WorkflowJobEvent{}
 23062  	w.GetWorkflowJob()
 23063  	w = nil
 23064  	w.GetWorkflowJob()
 23065  }
 23066  
 23067  func TestWorkflowRun_GetActor(tt *testing.T) {
 23068  	w := &WorkflowRun{}
 23069  	w.GetActor()
 23070  	w = nil
 23071  	w.GetActor()
 23072  }
 23073  
 23074  func TestWorkflowRun_GetArtifactsURL(tt *testing.T) {
 23075  	var zeroValue string
 23076  	w := &WorkflowRun{ArtifactsURL: &zeroValue}
 23077  	w.GetArtifactsURL()
 23078  	w = &WorkflowRun{}
 23079  	w.GetArtifactsURL()
 23080  	w = nil
 23081  	w.GetArtifactsURL()
 23082  }
 23083  
 23084  func TestWorkflowRun_GetCancelURL(tt *testing.T) {
 23085  	var zeroValue string
 23086  	w := &WorkflowRun{CancelURL: &zeroValue}
 23087  	w.GetCancelURL()
 23088  	w = &WorkflowRun{}
 23089  	w.GetCancelURL()
 23090  	w = nil
 23091  	w.GetCancelURL()
 23092  }
 23093  
 23094  func TestWorkflowRun_GetCheckSuiteID(tt *testing.T) {
 23095  	var zeroValue int64
 23096  	w := &WorkflowRun{CheckSuiteID: &zeroValue}
 23097  	w.GetCheckSuiteID()
 23098  	w = &WorkflowRun{}
 23099  	w.GetCheckSuiteID()
 23100  	w = nil
 23101  	w.GetCheckSuiteID()
 23102  }
 23103  
 23104  func TestWorkflowRun_GetCheckSuiteNodeID(tt *testing.T) {
 23105  	var zeroValue string
 23106  	w := &WorkflowRun{CheckSuiteNodeID: &zeroValue}
 23107  	w.GetCheckSuiteNodeID()
 23108  	w = &WorkflowRun{}
 23109  	w.GetCheckSuiteNodeID()
 23110  	w = nil
 23111  	w.GetCheckSuiteNodeID()
 23112  }
 23113  
 23114  func TestWorkflowRun_GetCheckSuiteURL(tt *testing.T) {
 23115  	var zeroValue string
 23116  	w := &WorkflowRun{CheckSuiteURL: &zeroValue}
 23117  	w.GetCheckSuiteURL()
 23118  	w = &WorkflowRun{}
 23119  	w.GetCheckSuiteURL()
 23120  	w = nil
 23121  	w.GetCheckSuiteURL()
 23122  }
 23123  
 23124  func TestWorkflowRun_GetConclusion(tt *testing.T) {
 23125  	var zeroValue string
 23126  	w := &WorkflowRun{Conclusion: &zeroValue}
 23127  	w.GetConclusion()
 23128  	w = &WorkflowRun{}
 23129  	w.GetConclusion()
 23130  	w = nil
 23131  	w.GetConclusion()
 23132  }
 23133  
 23134  func TestWorkflowRun_GetCreatedAt(tt *testing.T) {
 23135  	var zeroValue Timestamp
 23136  	w := &WorkflowRun{CreatedAt: &zeroValue}
 23137  	w.GetCreatedAt()
 23138  	w = &WorkflowRun{}
 23139  	w.GetCreatedAt()
 23140  	w = nil
 23141  	w.GetCreatedAt()
 23142  }
 23143  
 23144  func TestWorkflowRun_GetEvent(tt *testing.T) {
 23145  	var zeroValue string
 23146  	w := &WorkflowRun{Event: &zeroValue}
 23147  	w.GetEvent()
 23148  	w = &WorkflowRun{}
 23149  	w.GetEvent()
 23150  	w = nil
 23151  	w.GetEvent()
 23152  }
 23153  
 23154  func TestWorkflowRun_GetHeadBranch(tt *testing.T) {
 23155  	var zeroValue string
 23156  	w := &WorkflowRun{HeadBranch: &zeroValue}
 23157  	w.GetHeadBranch()
 23158  	w = &WorkflowRun{}
 23159  	w.GetHeadBranch()
 23160  	w = nil
 23161  	w.GetHeadBranch()
 23162  }
 23163  
 23164  func TestWorkflowRun_GetHeadCommit(tt *testing.T) {
 23165  	w := &WorkflowRun{}
 23166  	w.GetHeadCommit()
 23167  	w = nil
 23168  	w.GetHeadCommit()
 23169  }
 23170  
 23171  func TestWorkflowRun_GetHeadRepository(tt *testing.T) {
 23172  	w := &WorkflowRun{}
 23173  	w.GetHeadRepository()
 23174  	w = nil
 23175  	w.GetHeadRepository()
 23176  }
 23177  
 23178  func TestWorkflowRun_GetHeadSHA(tt *testing.T) {
 23179  	var zeroValue string
 23180  	w := &WorkflowRun{HeadSHA: &zeroValue}
 23181  	w.GetHeadSHA()
 23182  	w = &WorkflowRun{}
 23183  	w.GetHeadSHA()
 23184  	w = nil
 23185  	w.GetHeadSHA()
 23186  }
 23187  
 23188  func TestWorkflowRun_GetHTMLURL(tt *testing.T) {
 23189  	var zeroValue string
 23190  	w := &WorkflowRun{HTMLURL: &zeroValue}
 23191  	w.GetHTMLURL()
 23192  	w = &WorkflowRun{}
 23193  	w.GetHTMLURL()
 23194  	w = nil
 23195  	w.GetHTMLURL()
 23196  }
 23197  
 23198  func TestWorkflowRun_GetID(tt *testing.T) {
 23199  	var zeroValue int64
 23200  	w := &WorkflowRun{ID: &zeroValue}
 23201  	w.GetID()
 23202  	w = &WorkflowRun{}
 23203  	w.GetID()
 23204  	w = nil
 23205  	w.GetID()
 23206  }
 23207  
 23208  func TestWorkflowRun_GetJobsURL(tt *testing.T) {
 23209  	var zeroValue string
 23210  	w := &WorkflowRun{JobsURL: &zeroValue}
 23211  	w.GetJobsURL()
 23212  	w = &WorkflowRun{}
 23213  	w.GetJobsURL()
 23214  	w = nil
 23215  	w.GetJobsURL()
 23216  }
 23217  
 23218  func TestWorkflowRun_GetLogsURL(tt *testing.T) {
 23219  	var zeroValue string
 23220  	w := &WorkflowRun{LogsURL: &zeroValue}
 23221  	w.GetLogsURL()
 23222  	w = &WorkflowRun{}
 23223  	w.GetLogsURL()
 23224  	w = nil
 23225  	w.GetLogsURL()
 23226  }
 23227  
 23228  func TestWorkflowRun_GetName(tt *testing.T) {
 23229  	var zeroValue string
 23230  	w := &WorkflowRun{Name: &zeroValue}
 23231  	w.GetName()
 23232  	w = &WorkflowRun{}
 23233  	w.GetName()
 23234  	w = nil
 23235  	w.GetName()
 23236  }
 23237  
 23238  func TestWorkflowRun_GetNodeID(tt *testing.T) {
 23239  	var zeroValue string
 23240  	w := &WorkflowRun{NodeID: &zeroValue}
 23241  	w.GetNodeID()
 23242  	w = &WorkflowRun{}
 23243  	w.GetNodeID()
 23244  	w = nil
 23245  	w.GetNodeID()
 23246  }
 23247  
 23248  func TestWorkflowRun_GetPreviousAttemptURL(tt *testing.T) {
 23249  	var zeroValue string
 23250  	w := &WorkflowRun{PreviousAttemptURL: &zeroValue}
 23251  	w.GetPreviousAttemptURL()
 23252  	w = &WorkflowRun{}
 23253  	w.GetPreviousAttemptURL()
 23254  	w = nil
 23255  	w.GetPreviousAttemptURL()
 23256  }
 23257  
 23258  func TestWorkflowRun_GetRepository(tt *testing.T) {
 23259  	w := &WorkflowRun{}
 23260  	w.GetRepository()
 23261  	w = nil
 23262  	w.GetRepository()
 23263  }
 23264  
 23265  func TestWorkflowRun_GetRerunURL(tt *testing.T) {
 23266  	var zeroValue string
 23267  	w := &WorkflowRun{RerunURL: &zeroValue}
 23268  	w.GetRerunURL()
 23269  	w = &WorkflowRun{}
 23270  	w.GetRerunURL()
 23271  	w = nil
 23272  	w.GetRerunURL()
 23273  }
 23274  
 23275  func TestWorkflowRun_GetRunAttempt(tt *testing.T) {
 23276  	var zeroValue int
 23277  	w := &WorkflowRun{RunAttempt: &zeroValue}
 23278  	w.GetRunAttempt()
 23279  	w = &WorkflowRun{}
 23280  	w.GetRunAttempt()
 23281  	w = nil
 23282  	w.GetRunAttempt()
 23283  }
 23284  
 23285  func TestWorkflowRun_GetRunNumber(tt *testing.T) {
 23286  	var zeroValue int
 23287  	w := &WorkflowRun{RunNumber: &zeroValue}
 23288  	w.GetRunNumber()
 23289  	w = &WorkflowRun{}
 23290  	w.GetRunNumber()
 23291  	w = nil
 23292  	w.GetRunNumber()
 23293  }
 23294  
 23295  func TestWorkflowRun_GetRunStartedAt(tt *testing.T) {
 23296  	var zeroValue Timestamp
 23297  	w := &WorkflowRun{RunStartedAt: &zeroValue}
 23298  	w.GetRunStartedAt()
 23299  	w = &WorkflowRun{}
 23300  	w.GetRunStartedAt()
 23301  	w = nil
 23302  	w.GetRunStartedAt()
 23303  }
 23304  
 23305  func TestWorkflowRun_GetStatus(tt *testing.T) {
 23306  	var zeroValue string
 23307  	w := &WorkflowRun{Status: &zeroValue}
 23308  	w.GetStatus()
 23309  	w = &WorkflowRun{}
 23310  	w.GetStatus()
 23311  	w = nil
 23312  	w.GetStatus()
 23313  }
 23314  
 23315  func TestWorkflowRun_GetUpdatedAt(tt *testing.T) {
 23316  	var zeroValue Timestamp
 23317  	w := &WorkflowRun{UpdatedAt: &zeroValue}
 23318  	w.GetUpdatedAt()
 23319  	w = &WorkflowRun{}
 23320  	w.GetUpdatedAt()
 23321  	w = nil
 23322  	w.GetUpdatedAt()
 23323  }
 23324  
 23325  func TestWorkflowRun_GetURL(tt *testing.T) {
 23326  	var zeroValue string
 23327  	w := &WorkflowRun{URL: &zeroValue}
 23328  	w.GetURL()
 23329  	w = &WorkflowRun{}
 23330  	w.GetURL()
 23331  	w = nil
 23332  	w.GetURL()
 23333  }
 23334  
 23335  func TestWorkflowRun_GetWorkflowID(tt *testing.T) {
 23336  	var zeroValue int64
 23337  	w := &WorkflowRun{WorkflowID: &zeroValue}
 23338  	w.GetWorkflowID()
 23339  	w = &WorkflowRun{}
 23340  	w.GetWorkflowID()
 23341  	w = nil
 23342  	w.GetWorkflowID()
 23343  }
 23344  
 23345  func TestWorkflowRun_GetWorkflowURL(tt *testing.T) {
 23346  	var zeroValue string
 23347  	w := &WorkflowRun{WorkflowURL: &zeroValue}
 23348  	w.GetWorkflowURL()
 23349  	w = &WorkflowRun{}
 23350  	w.GetWorkflowURL()
 23351  	w = nil
 23352  	w.GetWorkflowURL()
 23353  }
 23354  
 23355  func TestWorkflowRunAttemptOptions_GetExcludePullRequests(tt *testing.T) {
 23356  	var zeroValue bool
 23357  	w := &WorkflowRunAttemptOptions{ExcludePullRequests: &zeroValue}
 23358  	w.GetExcludePullRequests()
 23359  	w = &WorkflowRunAttemptOptions{}
 23360  	w.GetExcludePullRequests()
 23361  	w = nil
 23362  	w.GetExcludePullRequests()
 23363  }
 23364  
 23365  func TestWorkflowRunBill_GetJobs(tt *testing.T) {
 23366  	var zeroValue int
 23367  	w := &WorkflowRunBill{Jobs: &zeroValue}
 23368  	w.GetJobs()
 23369  	w = &WorkflowRunBill{}
 23370  	w.GetJobs()
 23371  	w = nil
 23372  	w.GetJobs()
 23373  }
 23374  
 23375  func TestWorkflowRunBill_GetTotalMS(tt *testing.T) {
 23376  	var zeroValue int64
 23377  	w := &WorkflowRunBill{TotalMS: &zeroValue}
 23378  	w.GetTotalMS()
 23379  	w = &WorkflowRunBill{}
 23380  	w.GetTotalMS()
 23381  	w = nil
 23382  	w.GetTotalMS()
 23383  }
 23384  
 23385  func TestWorkflowRunEnvironment_GetMacOS(tt *testing.T) {
 23386  	w := &WorkflowRunEnvironment{}
 23387  	w.GetMacOS()
 23388  	w = nil
 23389  	w.GetMacOS()
 23390  }
 23391  
 23392  func TestWorkflowRunEnvironment_GetUbuntu(tt *testing.T) {
 23393  	w := &WorkflowRunEnvironment{}
 23394  	w.GetUbuntu()
 23395  	w = nil
 23396  	w.GetUbuntu()
 23397  }
 23398  
 23399  func TestWorkflowRunEnvironment_GetWindows(tt *testing.T) {
 23400  	w := &WorkflowRunEnvironment{}
 23401  	w.GetWindows()
 23402  	w = nil
 23403  	w.GetWindows()
 23404  }
 23405  
 23406  func TestWorkflowRunEvent_GetAction(tt *testing.T) {
 23407  	var zeroValue string
 23408  	w := &WorkflowRunEvent{Action: &zeroValue}
 23409  	w.GetAction()
 23410  	w = &WorkflowRunEvent{}
 23411  	w.GetAction()
 23412  	w = nil
 23413  	w.GetAction()
 23414  }
 23415  
 23416  func TestWorkflowRunEvent_GetInstallation(tt *testing.T) {
 23417  	w := &WorkflowRunEvent{}
 23418  	w.GetInstallation()
 23419  	w = nil
 23420  	w.GetInstallation()
 23421  }
 23422  
 23423  func TestWorkflowRunEvent_GetOrg(tt *testing.T) {
 23424  	w := &WorkflowRunEvent{}
 23425  	w.GetOrg()
 23426  	w = nil
 23427  	w.GetOrg()
 23428  }
 23429  
 23430  func TestWorkflowRunEvent_GetRepo(tt *testing.T) {
 23431  	w := &WorkflowRunEvent{}
 23432  	w.GetRepo()
 23433  	w = nil
 23434  	w.GetRepo()
 23435  }
 23436  
 23437  func TestWorkflowRunEvent_GetSender(tt *testing.T) {
 23438  	w := &WorkflowRunEvent{}
 23439  	w.GetSender()
 23440  	w = nil
 23441  	w.GetSender()
 23442  }
 23443  
 23444  func TestWorkflowRunEvent_GetWorkflow(tt *testing.T) {
 23445  	w := &WorkflowRunEvent{}
 23446  	w.GetWorkflow()
 23447  	w = nil
 23448  	w.GetWorkflow()
 23449  }
 23450  
 23451  func TestWorkflowRunEvent_GetWorkflowRun(tt *testing.T) {
 23452  	w := &WorkflowRunEvent{}
 23453  	w.GetWorkflowRun()
 23454  	w = nil
 23455  	w.GetWorkflowRun()
 23456  }
 23457  
 23458  func TestWorkflowRunJobRun_GetDurationMS(tt *testing.T) {
 23459  	var zeroValue int64
 23460  	w := &WorkflowRunJobRun{DurationMS: &zeroValue}
 23461  	w.GetDurationMS()
 23462  	w = &WorkflowRunJobRun{}
 23463  	w.GetDurationMS()
 23464  	w = nil
 23465  	w.GetDurationMS()
 23466  }
 23467  
 23468  func TestWorkflowRunJobRun_GetJobID(tt *testing.T) {
 23469  	var zeroValue int
 23470  	w := &WorkflowRunJobRun{JobID: &zeroValue}
 23471  	w.GetJobID()
 23472  	w = &WorkflowRunJobRun{}
 23473  	w.GetJobID()
 23474  	w = nil
 23475  	w.GetJobID()
 23476  }
 23477  
 23478  func TestWorkflowRuns_GetTotalCount(tt *testing.T) {
 23479  	var zeroValue int
 23480  	w := &WorkflowRuns{TotalCount: &zeroValue}
 23481  	w.GetTotalCount()
 23482  	w = &WorkflowRuns{}
 23483  	w.GetTotalCount()
 23484  	w = nil
 23485  	w.GetTotalCount()
 23486  }
 23487  
 23488  func TestWorkflowRunUsage_GetBillable(tt *testing.T) {
 23489  	w := &WorkflowRunUsage{}
 23490  	w.GetBillable()
 23491  	w = nil
 23492  	w.GetBillable()
 23493  }
 23494  
 23495  func TestWorkflowRunUsage_GetRunDurationMS(tt *testing.T) {
 23496  	var zeroValue int64
 23497  	w := &WorkflowRunUsage{RunDurationMS: &zeroValue}
 23498  	w.GetRunDurationMS()
 23499  	w = &WorkflowRunUsage{}
 23500  	w.GetRunDurationMS()
 23501  	w = nil
 23502  	w.GetRunDurationMS()
 23503  }
 23504  
 23505  func TestWorkflows_GetTotalCount(tt *testing.T) {
 23506  	var zeroValue int
 23507  	w := &Workflows{TotalCount: &zeroValue}
 23508  	w.GetTotalCount()
 23509  	w = &Workflows{}
 23510  	w.GetTotalCount()
 23511  	w = nil
 23512  	w.GetTotalCount()
 23513  }
 23514  
 23515  func TestWorkflowUsage_GetBillable(tt *testing.T) {
 23516  	w := &WorkflowUsage{}
 23517  	w.GetBillable()
 23518  	w = nil
 23519  	w.GetBillable()
 23520  }
 23521  

View as plain text