github.com/google/go-github/v68@v68.0.0/github/github-stringify_test.go (about)

     1  // Copyright 2019 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-stringify-tests; 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  	"testing"
    14  )
    15  
    16  func TestActionsAllowed_String(t *testing.T) {
    17  	t.Parallel()
    18  	v := ActionsAllowed{
    19  		GithubOwnedAllowed: Ptr(false),
    20  		VerifiedAllowed:    Ptr(false),
    21  		PatternsAllowed:    []string{""},
    22  	}
    23  	want := `github.ActionsAllowed{GithubOwnedAllowed:false, VerifiedAllowed:false, PatternsAllowed:[""]}`
    24  	if got := v.String(); got != want {
    25  		t.Errorf("ActionsAllowed.String = %v, want %v", got, want)
    26  	}
    27  }
    28  
    29  func TestActionsPermissions_String(t *testing.T) {
    30  	t.Parallel()
    31  	v := ActionsPermissions{
    32  		EnabledRepositories: Ptr(""),
    33  		AllowedActions:      Ptr(""),
    34  		SelectedActionsURL:  Ptr(""),
    35  	}
    36  	want := `github.ActionsPermissions{EnabledRepositories:"", AllowedActions:"", SelectedActionsURL:""}`
    37  	if got := v.String(); got != want {
    38  		t.Errorf("ActionsPermissions.String = %v, want %v", got, want)
    39  	}
    40  }
    41  
    42  func TestActionsPermissionsEnterprise_String(t *testing.T) {
    43  	t.Parallel()
    44  	v := ActionsPermissionsEnterprise{
    45  		EnabledOrganizations: Ptr(""),
    46  		AllowedActions:       Ptr(""),
    47  		SelectedActionsURL:   Ptr(""),
    48  	}
    49  	want := `github.ActionsPermissionsEnterprise{EnabledOrganizations:"", AllowedActions:"", SelectedActionsURL:""}`
    50  	if got := v.String(); got != want {
    51  		t.Errorf("ActionsPermissionsEnterprise.String = %v, want %v", got, want)
    52  	}
    53  }
    54  
    55  func TestActionsPermissionsRepository_String(t *testing.T) {
    56  	t.Parallel()
    57  	v := ActionsPermissionsRepository{
    58  		Enabled:            Ptr(false),
    59  		AllowedActions:     Ptr(""),
    60  		SelectedActionsURL: Ptr(""),
    61  	}
    62  	want := `github.ActionsPermissionsRepository{Enabled:false, AllowedActions:"", SelectedActionsURL:""}`
    63  	if got := v.String(); got != want {
    64  		t.Errorf("ActionsPermissionsRepository.String = %v, want %v", got, want)
    65  	}
    66  }
    67  
    68  func TestAdminStats_String(t *testing.T) {
    69  	t.Parallel()
    70  	v := AdminStats{
    71  		Issues:     &IssueStats{},
    72  		Hooks:      &HookStats{},
    73  		Milestones: &MilestoneStats{},
    74  		Orgs:       &OrgStats{},
    75  		Comments:   &CommentStats{},
    76  		Pages:      &PageStats{},
    77  		Users:      &UserStats{},
    78  		Gists:      &GistStats{},
    79  		Pulls:      &PullStats{},
    80  		Repos:      &RepoStats{},
    81  	}
    82  	want := `github.AdminStats{Issues:github.IssueStats{}, Hooks:github.HookStats{}, Milestones:github.MilestoneStats{}, Orgs:github.OrgStats{}, Comments:github.CommentStats{}, Pages:github.PageStats{}, Users:github.UserStats{}, Gists:github.GistStats{}, Pulls:github.PullStats{}, Repos:github.RepoStats{}}`
    83  	if got := v.String(); got != want {
    84  		t.Errorf("AdminStats.String = %v, want %v", got, want)
    85  	}
    86  }
    87  
    88  func TestAdvancedSecurity_String(t *testing.T) {
    89  	t.Parallel()
    90  	v := AdvancedSecurity{
    91  		Status: Ptr(""),
    92  	}
    93  	want := `github.AdvancedSecurity{Status:""}`
    94  	if got := v.String(); got != want {
    95  		t.Errorf("AdvancedSecurity.String = %v, want %v", got, want)
    96  	}
    97  }
    98  
    99  func TestAuthorization_String(t *testing.T) {
   100  	t.Parallel()
   101  	v := Authorization{
   102  		ID:             Ptr(int64(0)),
   103  		URL:            Ptr(""),
   104  		Scopes:         []Scope{ScopeNone},
   105  		Token:          Ptr(""),
   106  		TokenLastEight: Ptr(""),
   107  		HashedToken:    Ptr(""),
   108  		App:            &AuthorizationApp{},
   109  		Note:           Ptr(""),
   110  		NoteURL:        Ptr(""),
   111  		UpdatedAt:      &Timestamp{},
   112  		CreatedAt:      &Timestamp{},
   113  		Fingerprint:    Ptr(""),
   114  		User:           &User{},
   115  	}
   116  	want := `github.Authorization{ID:0, URL:"", Scopes:["(no scope)"], Token:"", TokenLastEight:"", HashedToken:"", App:github.AuthorizationApp{}, Note:"", NoteURL:"", UpdatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, CreatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, Fingerprint:"", User:github.User{}}`
   117  	if got := v.String(); got != want {
   118  		t.Errorf("Authorization.String = %v, want %v", got, want)
   119  	}
   120  }
   121  
   122  func TestAuthorizationApp_String(t *testing.T) {
   123  	t.Parallel()
   124  	v := AuthorizationApp{
   125  		URL:      Ptr(""),
   126  		Name:     Ptr(""),
   127  		ClientID: Ptr(""),
   128  	}
   129  	want := `github.AuthorizationApp{URL:"", Name:"", ClientID:""}`
   130  	if got := v.String(); got != want {
   131  		t.Errorf("AuthorizationApp.String = %v, want %v", got, want)
   132  	}
   133  }
   134  
   135  func TestAuthorizationRequest_String(t *testing.T) {
   136  	t.Parallel()
   137  	v := AuthorizationRequest{
   138  		Scopes:       []Scope{ScopeNone},
   139  		Note:         Ptr(""),
   140  		NoteURL:      Ptr(""),
   141  		ClientID:     Ptr(""),
   142  		ClientSecret: Ptr(""),
   143  		Fingerprint:  Ptr(""),
   144  	}
   145  	want := `github.AuthorizationRequest{Scopes:["(no scope)"], Note:"", NoteURL:"", ClientID:"", ClientSecret:"", Fingerprint:""}`
   146  	if got := v.String(); got != want {
   147  		t.Errorf("AuthorizationRequest.String = %v, want %v", got, want)
   148  	}
   149  }
   150  
   151  func TestAuthorizationUpdateRequest_String(t *testing.T) {
   152  	t.Parallel()
   153  	v := AuthorizationUpdateRequest{
   154  		Scopes:       []string{""},
   155  		AddScopes:    []string{""},
   156  		RemoveScopes: []string{""},
   157  		Note:         Ptr(""),
   158  		NoteURL:      Ptr(""),
   159  		Fingerprint:  Ptr(""),
   160  	}
   161  	want := `github.AuthorizationUpdateRequest{Scopes:[""], AddScopes:[""], RemoveScopes:[""], Note:"", NoteURL:"", Fingerprint:""}`
   162  	if got := v.String(); got != want {
   163  		t.Errorf("AuthorizationUpdateRequest.String = %v, want %v", got, want)
   164  	}
   165  }
   166  
   167  func TestCheckRun_String(t *testing.T) {
   168  	t.Parallel()
   169  	v := CheckRun{
   170  		ID:          Ptr(int64(0)),
   171  		NodeID:      Ptr(""),
   172  		HeadSHA:     Ptr(""),
   173  		ExternalID:  Ptr(""),
   174  		URL:         Ptr(""),
   175  		HTMLURL:     Ptr(""),
   176  		DetailsURL:  Ptr(""),
   177  		Status:      Ptr(""),
   178  		Conclusion:  Ptr(""),
   179  		StartedAt:   &Timestamp{},
   180  		CompletedAt: &Timestamp{},
   181  		Output:      &CheckRunOutput{},
   182  		Name:        Ptr(""),
   183  		CheckSuite:  &CheckSuite{},
   184  		App:         &App{},
   185  	}
   186  	want := `github.CheckRun{ID:0, NodeID:"", HeadSHA:"", ExternalID:"", URL:"", HTMLURL:"", DetailsURL:"", Status:"", Conclusion:"", StartedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, CompletedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, Output:github.CheckRunOutput{}, Name:"", CheckSuite:github.CheckSuite{}, App:github.App{}}`
   187  	if got := v.String(); got != want {
   188  		t.Errorf("CheckRun.String = %v, want %v", got, want)
   189  	}
   190  }
   191  
   192  func TestCheckSuite_String(t *testing.T) {
   193  	t.Parallel()
   194  	v := CheckSuite{
   195  		ID:                   Ptr(int64(0)),
   196  		NodeID:               Ptr(""),
   197  		HeadBranch:           Ptr(""),
   198  		HeadSHA:              Ptr(""),
   199  		URL:                  Ptr(""),
   200  		BeforeSHA:            Ptr(""),
   201  		AfterSHA:             Ptr(""),
   202  		Status:               Ptr(""),
   203  		Conclusion:           Ptr(""),
   204  		CreatedAt:            &Timestamp{},
   205  		UpdatedAt:            &Timestamp{},
   206  		App:                  &App{},
   207  		Repository:           &Repository{},
   208  		HeadCommit:           &Commit{},
   209  		LatestCheckRunsCount: Ptr(int64(0)),
   210  		Rerequstable:         Ptr(false),
   211  		RunsRerequstable:     Ptr(false),
   212  	}
   213  	want := `github.CheckSuite{ID:0, NodeID:"", HeadBranch:"", HeadSHA:"", URL:"", BeforeSHA:"", AfterSHA:"", Status:"", Conclusion:"", CreatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, UpdatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, App:github.App{}, Repository:github.Repository{}, HeadCommit:github.Commit{}, LatestCheckRunsCount:0, Rerequstable:false, RunsRerequstable:false}`
   214  	if got := v.String(); got != want {
   215  		t.Errorf("CheckSuite.String = %v, want %v", got, want)
   216  	}
   217  }
   218  
   219  func TestCodeOfConduct_String(t *testing.T) {
   220  	t.Parallel()
   221  	v := CodeOfConduct{
   222  		Name: Ptr(""),
   223  		Key:  Ptr(""),
   224  		URL:  Ptr(""),
   225  		Body: Ptr(""),
   226  	}
   227  	want := `github.CodeOfConduct{Name:"", Key:"", URL:"", Body:""}`
   228  	if got := v.String(); got != want {
   229  		t.Errorf("CodeOfConduct.String = %v, want %v", got, want)
   230  	}
   231  }
   232  
   233  func TestCodeResult_String(t *testing.T) {
   234  	t.Parallel()
   235  	v := CodeResult{
   236  		Name:       Ptr(""),
   237  		Path:       Ptr(""),
   238  		SHA:        Ptr(""),
   239  		HTMLURL:    Ptr(""),
   240  		Repository: &Repository{},
   241  	}
   242  	want := `github.CodeResult{Name:"", Path:"", SHA:"", HTMLURL:"", Repository:github.Repository{}}`
   243  	if got := v.String(); got != want {
   244  		t.Errorf("CodeResult.String = %v, want %v", got, want)
   245  	}
   246  }
   247  
   248  func TestCombinedStatus_String(t *testing.T) {
   249  	t.Parallel()
   250  	v := CombinedStatus{
   251  		State:         Ptr(""),
   252  		Name:          Ptr(""),
   253  		SHA:           Ptr(""),
   254  		TotalCount:    Ptr(0),
   255  		CommitURL:     Ptr(""),
   256  		RepositoryURL: Ptr(""),
   257  	}
   258  	want := `github.CombinedStatus{State:"", Name:"", SHA:"", TotalCount:0, CommitURL:"", RepositoryURL:""}`
   259  	if got := v.String(); got != want {
   260  		t.Errorf("CombinedStatus.String = %v, want %v", got, want)
   261  	}
   262  }
   263  
   264  func TestCommentStats_String(t *testing.T) {
   265  	t.Parallel()
   266  	v := CommentStats{
   267  		TotalCommitComments:      Ptr(0),
   268  		TotalGistComments:        Ptr(0),
   269  		TotalIssueComments:       Ptr(0),
   270  		TotalPullRequestComments: Ptr(0),
   271  	}
   272  	want := `github.CommentStats{TotalCommitComments:0, TotalGistComments:0, TotalIssueComments:0, TotalPullRequestComments:0}`
   273  	if got := v.String(); got != want {
   274  		t.Errorf("CommentStats.String = %v, want %v", got, want)
   275  	}
   276  }
   277  
   278  func TestCommit_String(t *testing.T) {
   279  	t.Parallel()
   280  	v := Commit{
   281  		SHA:          Ptr(""),
   282  		Author:       &CommitAuthor{},
   283  		Committer:    &CommitAuthor{},
   284  		Message:      Ptr(""),
   285  		Tree:         &Tree{},
   286  		HTMLURL:      Ptr(""),
   287  		URL:          Ptr(""),
   288  		Verification: &SignatureVerification{},
   289  		NodeID:       Ptr(""),
   290  		CommentCount: Ptr(0),
   291  	}
   292  	want := `github.Commit{SHA:"", Author:github.CommitAuthor{}, Committer:github.CommitAuthor{}, Message:"", Tree:github.Tree{}, HTMLURL:"", URL:"", Verification:github.SignatureVerification{}, NodeID:"", CommentCount:0}`
   293  	if got := v.String(); got != want {
   294  		t.Errorf("Commit.String = %v, want %v", got, want)
   295  	}
   296  }
   297  
   298  func TestCommitAuthor_String(t *testing.T) {
   299  	t.Parallel()
   300  	v := CommitAuthor{
   301  		Date:  &Timestamp{},
   302  		Name:  Ptr(""),
   303  		Email: Ptr(""),
   304  		Login: Ptr(""),
   305  	}
   306  	want := `github.CommitAuthor{Date:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, Name:"", Email:"", Login:""}`
   307  	if got := v.String(); got != want {
   308  		t.Errorf("CommitAuthor.String = %v, want %v", got, want)
   309  	}
   310  }
   311  
   312  func TestCommitFile_String(t *testing.T) {
   313  	t.Parallel()
   314  	v := CommitFile{
   315  		SHA:              Ptr(""),
   316  		Filename:         Ptr(""),
   317  		Additions:        Ptr(0),
   318  		Deletions:        Ptr(0),
   319  		Changes:          Ptr(0),
   320  		Status:           Ptr(""),
   321  		Patch:            Ptr(""),
   322  		BlobURL:          Ptr(""),
   323  		RawURL:           Ptr(""),
   324  		ContentsURL:      Ptr(""),
   325  		PreviousFilename: Ptr(""),
   326  	}
   327  	want := `github.CommitFile{SHA:"", Filename:"", Additions:0, Deletions:0, Changes:0, Status:"", Patch:"", BlobURL:"", RawURL:"", ContentsURL:"", PreviousFilename:""}`
   328  	if got := v.String(); got != want {
   329  		t.Errorf("CommitFile.String = %v, want %v", got, want)
   330  	}
   331  }
   332  
   333  func TestCommitStats_String(t *testing.T) {
   334  	t.Parallel()
   335  	v := CommitStats{
   336  		Additions: Ptr(0),
   337  		Deletions: Ptr(0),
   338  		Total:     Ptr(0),
   339  	}
   340  	want := `github.CommitStats{Additions:0, Deletions:0, Total:0}`
   341  	if got := v.String(); got != want {
   342  		t.Errorf("CommitStats.String = %v, want %v", got, want)
   343  	}
   344  }
   345  
   346  func TestCommitsComparison_String(t *testing.T) {
   347  	t.Parallel()
   348  	v := CommitsComparison{
   349  		BaseCommit:      &RepositoryCommit{},
   350  		MergeBaseCommit: &RepositoryCommit{},
   351  		Status:          Ptr(""),
   352  		AheadBy:         Ptr(0),
   353  		BehindBy:        Ptr(0),
   354  		TotalCommits:    Ptr(0),
   355  		HTMLURL:         Ptr(""),
   356  		PermalinkURL:    Ptr(""),
   357  		DiffURL:         Ptr(""),
   358  		PatchURL:        Ptr(""),
   359  		URL:             Ptr(""),
   360  	}
   361  	want := `github.CommitsComparison{BaseCommit:github.RepositoryCommit{}, MergeBaseCommit:github.RepositoryCommit{}, Status:"", AheadBy:0, BehindBy:0, TotalCommits:0, HTMLURL:"", PermalinkURL:"", DiffURL:"", PatchURL:"", URL:""}`
   362  	if got := v.String(); got != want {
   363  		t.Errorf("CommitsComparison.String = %v, want %v", got, want)
   364  	}
   365  }
   366  
   367  func TestContributorStats_String(t *testing.T) {
   368  	t.Parallel()
   369  	v := ContributorStats{
   370  		Author: &Contributor{},
   371  		Total:  Ptr(0),
   372  	}
   373  	want := `github.ContributorStats{Author:github.Contributor{}, Total:0}`
   374  	if got := v.String(); got != want {
   375  		t.Errorf("ContributorStats.String = %v, want %v", got, want)
   376  	}
   377  }
   378  
   379  func TestDependabotSecurityUpdates_String(t *testing.T) {
   380  	t.Parallel()
   381  	v := DependabotSecurityUpdates{
   382  		Status: Ptr(""),
   383  	}
   384  	want := `github.DependabotSecurityUpdates{Status:""}`
   385  	if got := v.String(); got != want {
   386  		t.Errorf("DependabotSecurityUpdates.String = %v, want %v", got, want)
   387  	}
   388  }
   389  
   390  func TestDiscussionComment_String(t *testing.T) {
   391  	t.Parallel()
   392  	v := DiscussionComment{
   393  		Author:        &User{},
   394  		Body:          Ptr(""),
   395  		BodyHTML:      Ptr(""),
   396  		BodyVersion:   Ptr(""),
   397  		CreatedAt:     &Timestamp{},
   398  		LastEditedAt:  &Timestamp{},
   399  		DiscussionURL: Ptr(""),
   400  		HTMLURL:       Ptr(""),
   401  		NodeID:        Ptr(""),
   402  		Number:        Ptr(0),
   403  		UpdatedAt:     &Timestamp{},
   404  		URL:           Ptr(""),
   405  		Reactions:     &Reactions{},
   406  	}
   407  	want := `github.DiscussionComment{Author:github.User{}, Body:"", BodyHTML:"", BodyVersion:"", CreatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, LastEditedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, DiscussionURL:"", HTMLURL:"", NodeID:"", Number:0, UpdatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, URL:"", Reactions:github.Reactions{}}`
   408  	if got := v.String(); got != want {
   409  		t.Errorf("DiscussionComment.String = %v, want %v", got, want)
   410  	}
   411  }
   412  
   413  func TestDraftReviewComment_String(t *testing.T) {
   414  	t.Parallel()
   415  	v := DraftReviewComment{
   416  		Path:      Ptr(""),
   417  		Position:  Ptr(0),
   418  		Body:      Ptr(""),
   419  		StartSide: Ptr(""),
   420  		Side:      Ptr(""),
   421  		StartLine: Ptr(0),
   422  		Line:      Ptr(0),
   423  	}
   424  	want := `github.DraftReviewComment{Path:"", Position:0, Body:"", StartSide:"", Side:"", StartLine:0, Line:0}`
   425  	if got := v.String(); got != want {
   426  		t.Errorf("DraftReviewComment.String = %v, want %v", got, want)
   427  	}
   428  }
   429  
   430  func TestEnterprise_String(t *testing.T) {
   431  	t.Parallel()
   432  	v := Enterprise{
   433  		ID:          Ptr(0),
   434  		Slug:        Ptr(""),
   435  		Name:        Ptr(""),
   436  		NodeID:      Ptr(""),
   437  		AvatarURL:   Ptr(""),
   438  		Description: Ptr(""),
   439  		WebsiteURL:  Ptr(""),
   440  		HTMLURL:     Ptr(""),
   441  		CreatedAt:   &Timestamp{},
   442  		UpdatedAt:   &Timestamp{},
   443  	}
   444  	want := `github.Enterprise{ID:0, Slug:"", Name:"", NodeID:"", AvatarURL:"", Description:"", WebsiteURL:"", HTMLURL:"", CreatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, UpdatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}}`
   445  	if got := v.String(); got != want {
   446  		t.Errorf("Enterprise.String = %v, want %v", got, want)
   447  	}
   448  }
   449  
   450  func TestEvent_String(t *testing.T) {
   451  	t.Parallel()
   452  	v := Event{
   453  		Type:      Ptr(""),
   454  		Public:    Ptr(false),
   455  		Repo:      &Repository{},
   456  		Actor:     &User{},
   457  		Org:       &Organization{},
   458  		CreatedAt: &Timestamp{},
   459  		ID:        Ptr(""),
   460  	}
   461  	want := `github.Event{Type:"", Public:false, Repo:github.Repository{}, Actor:github.User{}, Org:github.Organization{}, CreatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, ID:""}`
   462  	if got := v.String(); got != want {
   463  		t.Errorf("Event.String = %v, want %v", got, want)
   464  	}
   465  }
   466  
   467  func TestGPGKey_String(t *testing.T) {
   468  	t.Parallel()
   469  	v := GPGKey{
   470  		ID:                Ptr(int64(0)),
   471  		PrimaryKeyID:      Ptr(int64(0)),
   472  		KeyID:             Ptr(""),
   473  		RawKey:            Ptr(""),
   474  		PublicKey:         Ptr(""),
   475  		CanSign:           Ptr(false),
   476  		CanEncryptComms:   Ptr(false),
   477  		CanEncryptStorage: Ptr(false),
   478  		CanCertify:        Ptr(false),
   479  		CreatedAt:         &Timestamp{},
   480  		ExpiresAt:         &Timestamp{},
   481  	}
   482  	want := `github.GPGKey{ID:0, PrimaryKeyID:0, KeyID:"", RawKey:"", PublicKey:"", CanSign:false, CanEncryptComms:false, CanEncryptStorage:false, CanCertify:false, CreatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, ExpiresAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}}`
   483  	if got := v.String(); got != want {
   484  		t.Errorf("GPGKey.String = %v, want %v", got, want)
   485  	}
   486  }
   487  
   488  func TestGist_String(t *testing.T) {
   489  	t.Parallel()
   490  	v := Gist{
   491  		ID:          Ptr(""),
   492  		Description: Ptr(""),
   493  		Public:      Ptr(false),
   494  		Owner:       &User{},
   495  		Comments:    Ptr(0),
   496  		HTMLURL:     Ptr(""),
   497  		GitPullURL:  Ptr(""),
   498  		GitPushURL:  Ptr(""),
   499  		CreatedAt:   &Timestamp{},
   500  		UpdatedAt:   &Timestamp{},
   501  		NodeID:      Ptr(""),
   502  	}
   503  	want := `github.Gist{ID:"", Description:"", Public:false, Owner:github.User{}, Comments:0, HTMLURL:"", GitPullURL:"", GitPushURL:"", CreatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, UpdatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, NodeID:""}`
   504  	if got := v.String(); got != want {
   505  		t.Errorf("Gist.String = %v, want %v", got, want)
   506  	}
   507  }
   508  
   509  func TestGistComment_String(t *testing.T) {
   510  	t.Parallel()
   511  	v := GistComment{
   512  		ID:        Ptr(int64(0)),
   513  		URL:       Ptr(""),
   514  		Body:      Ptr(""),
   515  		User:      &User{},
   516  		CreatedAt: &Timestamp{},
   517  	}
   518  	want := `github.GistComment{ID:0, URL:"", Body:"", User:github.User{}, CreatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}}`
   519  	if got := v.String(); got != want {
   520  		t.Errorf("GistComment.String = %v, want %v", got, want)
   521  	}
   522  }
   523  
   524  func TestGistCommit_String(t *testing.T) {
   525  	t.Parallel()
   526  	v := GistCommit{
   527  		URL:          Ptr(""),
   528  		Version:      Ptr(""),
   529  		User:         &User{},
   530  		ChangeStatus: &CommitStats{},
   531  		CommittedAt:  &Timestamp{},
   532  		NodeID:       Ptr(""),
   533  	}
   534  	want := `github.GistCommit{URL:"", Version:"", User:github.User{}, ChangeStatus:github.CommitStats{}, CommittedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, NodeID:""}`
   535  	if got := v.String(); got != want {
   536  		t.Errorf("GistCommit.String = %v, want %v", got, want)
   537  	}
   538  }
   539  
   540  func TestGistFile_String(t *testing.T) {
   541  	t.Parallel()
   542  	v := GistFile{
   543  		Size:     Ptr(0),
   544  		Filename: Ptr(""),
   545  		Language: Ptr(""),
   546  		Type:     Ptr(""),
   547  		RawURL:   Ptr(""),
   548  		Content:  Ptr(""),
   549  	}
   550  	want := `github.GistFile{Size:0, Filename:"", Language:"", Type:"", RawURL:"", Content:""}`
   551  	if got := v.String(); got != want {
   552  		t.Errorf("GistFile.String = %v, want %v", got, want)
   553  	}
   554  }
   555  
   556  func TestGistFork_String(t *testing.T) {
   557  	t.Parallel()
   558  	v := GistFork{
   559  		URL:       Ptr(""),
   560  		User:      &User{},
   561  		ID:        Ptr(""),
   562  		CreatedAt: &Timestamp{},
   563  		UpdatedAt: &Timestamp{},
   564  		NodeID:    Ptr(""),
   565  	}
   566  	want := `github.GistFork{URL:"", User:github.User{}, ID:"", CreatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, UpdatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, NodeID:""}`
   567  	if got := v.String(); got != want {
   568  		t.Errorf("GistFork.String = %v, want %v", got, want)
   569  	}
   570  }
   571  
   572  func TestGistStats_String(t *testing.T) {
   573  	t.Parallel()
   574  	v := GistStats{
   575  		TotalGists:   Ptr(0),
   576  		PrivateGists: Ptr(0),
   577  		PublicGists:  Ptr(0),
   578  	}
   579  	want := `github.GistStats{TotalGists:0, PrivateGists:0, PublicGists:0}`
   580  	if got := v.String(); got != want {
   581  		t.Errorf("GistStats.String = %v, want %v", got, want)
   582  	}
   583  }
   584  
   585  func TestGitObject_String(t *testing.T) {
   586  	t.Parallel()
   587  	v := GitObject{
   588  		Type: Ptr(""),
   589  		SHA:  Ptr(""),
   590  		URL:  Ptr(""),
   591  	}
   592  	want := `github.GitObject{Type:"", SHA:"", URL:""}`
   593  	if got := v.String(); got != want {
   594  		t.Errorf("GitObject.String = %v, want %v", got, want)
   595  	}
   596  }
   597  
   598  func TestGitignore_String(t *testing.T) {
   599  	t.Parallel()
   600  	v := Gitignore{
   601  		Name:   Ptr(""),
   602  		Source: Ptr(""),
   603  	}
   604  	want := `github.Gitignore{Name:"", Source:""}`
   605  	if got := v.String(); got != want {
   606  		t.Errorf("Gitignore.String = %v, want %v", got, want)
   607  	}
   608  }
   609  
   610  func TestGrant_String(t *testing.T) {
   611  	t.Parallel()
   612  	v := Grant{
   613  		ID:        Ptr(int64(0)),
   614  		URL:       Ptr(""),
   615  		App:       &AuthorizationApp{},
   616  		CreatedAt: &Timestamp{},
   617  		UpdatedAt: &Timestamp{},
   618  		Scopes:    []string{""},
   619  	}
   620  	want := `github.Grant{ID:0, URL:"", App:github.AuthorizationApp{}, CreatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, UpdatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, Scopes:[""]}`
   621  	if got := v.String(); got != want {
   622  		t.Errorf("Grant.String = %v, want %v", got, want)
   623  	}
   624  }
   625  
   626  func TestHeadCommit_String(t *testing.T) {
   627  	t.Parallel()
   628  	v := HeadCommit{
   629  		Message:   Ptr(""),
   630  		Author:    &CommitAuthor{},
   631  		URL:       Ptr(""),
   632  		Distinct:  Ptr(false),
   633  		SHA:       Ptr(""),
   634  		ID:        Ptr(""),
   635  		TreeID:    Ptr(""),
   636  		Timestamp: &Timestamp{},
   637  		Committer: &CommitAuthor{},
   638  		Added:     []string{""},
   639  		Removed:   []string{""},
   640  		Modified:  []string{""},
   641  	}
   642  	want := `github.HeadCommit{Message:"", Author:github.CommitAuthor{}, URL:"", Distinct:false, SHA:"", ID:"", TreeID:"", Timestamp:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, Committer:github.CommitAuthor{}, Added:[""], Removed:[""], Modified:[""]}`
   643  	if got := v.String(); got != want {
   644  		t.Errorf("HeadCommit.String = %v, want %v", got, want)
   645  	}
   646  }
   647  
   648  func TestHook_String(t *testing.T) {
   649  	t.Parallel()
   650  	v := Hook{
   651  		CreatedAt: &Timestamp{},
   652  		UpdatedAt: &Timestamp{},
   653  		URL:       Ptr(""),
   654  		ID:        Ptr(int64(0)),
   655  		Type:      Ptr(""),
   656  		Name:      Ptr(""),
   657  		TestURL:   Ptr(""),
   658  		PingURL:   Ptr(""),
   659  		Config:    &HookConfig{},
   660  		Events:    []string{""},
   661  		Active:    Ptr(false),
   662  	}
   663  	want := `github.Hook{CreatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, UpdatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, URL:"", ID:0, Type:"", Name:"", TestURL:"", PingURL:"", Config:github.HookConfig{}, Events:[""], Active:false}`
   664  	if got := v.String(); got != want {
   665  		t.Errorf("Hook.String = %v, want %v", got, want)
   666  	}
   667  }
   668  
   669  func TestHookDelivery_String(t *testing.T) {
   670  	t.Parallel()
   671  	v := HookDelivery{
   672  		ID:             Ptr(int64(0)),
   673  		GUID:           Ptr(""),
   674  		DeliveredAt:    &Timestamp{},
   675  		Redelivery:     Ptr(false),
   676  		Duration:       Ptr(0.0),
   677  		Status:         Ptr(""),
   678  		StatusCode:     Ptr(0),
   679  		Event:          Ptr(""),
   680  		Action:         Ptr(""),
   681  		InstallationID: Ptr(int64(0)),
   682  		RepositoryID:   Ptr(int64(0)),
   683  		Request:        &HookRequest{},
   684  		Response:       &HookResponse{},
   685  	}
   686  	want := `github.HookDelivery{ID:0, GUID:"", DeliveredAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, Redelivery:false, Duration:0, Status:"", StatusCode:0, Event:"", Action:"", InstallationID:0, RepositoryID:0, Request:github.HookRequest{}, Response:github.HookResponse{}}`
   687  	if got := v.String(); got != want {
   688  		t.Errorf("HookDelivery.String = %v, want %v", got, want)
   689  	}
   690  }
   691  
   692  func TestHookStats_String(t *testing.T) {
   693  	t.Parallel()
   694  	v := HookStats{
   695  		TotalHooks:    Ptr(0),
   696  		ActiveHooks:   Ptr(0),
   697  		InactiveHooks: Ptr(0),
   698  	}
   699  	want := `github.HookStats{TotalHooks:0, ActiveHooks:0, InactiveHooks:0}`
   700  	if got := v.String(); got != want {
   701  		t.Errorf("HookStats.String = %v, want %v", got, want)
   702  	}
   703  }
   704  
   705  func TestImport_String(t *testing.T) {
   706  	t.Parallel()
   707  	v := Import{
   708  		VCSURL:          Ptr(""),
   709  		VCS:             Ptr(""),
   710  		VCSUsername:     Ptr(""),
   711  		VCSPassword:     Ptr(""),
   712  		TFVCProject:     Ptr(""),
   713  		UseLFS:          Ptr(""),
   714  		HasLargeFiles:   Ptr(false),
   715  		LargeFilesSize:  Ptr(0),
   716  		LargeFilesCount: Ptr(0),
   717  		Status:          Ptr(""),
   718  		CommitCount:     Ptr(0),
   719  		StatusText:      Ptr(""),
   720  		AuthorsCount:    Ptr(0),
   721  		Percent:         Ptr(0),
   722  		PushPercent:     Ptr(0),
   723  		URL:             Ptr(""),
   724  		HTMLURL:         Ptr(""),
   725  		AuthorsURL:      Ptr(""),
   726  		RepositoryURL:   Ptr(""),
   727  		Message:         Ptr(""),
   728  		FailedStep:      Ptr(""),
   729  		HumanName:       Ptr(""),
   730  	}
   731  	want := `github.Import{VCSURL:"", VCS:"", VCSUsername:"", VCSPassword:"", TFVCProject:"", UseLFS:"", HasLargeFiles:false, LargeFilesSize:0, LargeFilesCount:0, Status:"", CommitCount:0, StatusText:"", AuthorsCount:0, Percent:0, PushPercent:0, URL:"", HTMLURL:"", AuthorsURL:"", RepositoryURL:"", Message:"", FailedStep:"", HumanName:""}`
   732  	if got := v.String(); got != want {
   733  		t.Errorf("Import.String = %v, want %v", got, want)
   734  	}
   735  }
   736  
   737  func TestInstallation_String(t *testing.T) {
   738  	t.Parallel()
   739  	v := Installation{
   740  		ID:                     Ptr(int64(0)),
   741  		NodeID:                 Ptr(""),
   742  		AppID:                  Ptr(int64(0)),
   743  		AppSlug:                Ptr(""),
   744  		TargetID:               Ptr(int64(0)),
   745  		Account:                &User{},
   746  		AccessTokensURL:        Ptr(""),
   747  		RepositoriesURL:        Ptr(""),
   748  		HTMLURL:                Ptr(""),
   749  		TargetType:             Ptr(""),
   750  		SingleFileName:         Ptr(""),
   751  		RepositorySelection:    Ptr(""),
   752  		Events:                 []string{""},
   753  		SingleFilePaths:        []string{""},
   754  		Permissions:            &InstallationPermissions{},
   755  		CreatedAt:              &Timestamp{},
   756  		UpdatedAt:              &Timestamp{},
   757  		HasMultipleSingleFiles: Ptr(false),
   758  		SuspendedBy:            &User{},
   759  		SuspendedAt:            &Timestamp{},
   760  	}
   761  	want := `github.Installation{ID:0, NodeID:"", AppID:0, AppSlug:"", TargetID:0, Account:github.User{}, AccessTokensURL:"", RepositoriesURL:"", HTMLURL:"", TargetType:"", SingleFileName:"", RepositorySelection:"", Events:[""], SingleFilePaths:[""], Permissions:github.InstallationPermissions{}, CreatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, UpdatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, HasMultipleSingleFiles:false, SuspendedBy:github.User{}, SuspendedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}}`
   762  	if got := v.String(); got != want {
   763  		t.Errorf("Installation.String = %v, want %v", got, want)
   764  	}
   765  }
   766  
   767  func TestInvitation_String(t *testing.T) {
   768  	t.Parallel()
   769  	v := Invitation{
   770  		ID:                Ptr(int64(0)),
   771  		NodeID:            Ptr(""),
   772  		Login:             Ptr(""),
   773  		Email:             Ptr(""),
   774  		Role:              Ptr(""),
   775  		CreatedAt:         &Timestamp{},
   776  		Inviter:           &User{},
   777  		TeamCount:         Ptr(0),
   778  		InvitationTeamURL: Ptr(""),
   779  		FailedAt:          &Timestamp{},
   780  		FailedReason:      Ptr(""),
   781  	}
   782  	want := `github.Invitation{ID:0, NodeID:"", Login:"", Email:"", Role:"", CreatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, Inviter:github.User{}, TeamCount:0, InvitationTeamURL:"", FailedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, FailedReason:""}`
   783  	if got := v.String(); got != want {
   784  		t.Errorf("Invitation.String = %v, want %v", got, want)
   785  	}
   786  }
   787  
   788  func TestIssue_String(t *testing.T) {
   789  	t.Parallel()
   790  	v := Issue{
   791  		ID:                Ptr(int64(0)),
   792  		Number:            Ptr(0),
   793  		State:             Ptr(""),
   794  		StateReason:       Ptr(""),
   795  		Locked:            Ptr(false),
   796  		Title:             Ptr(""),
   797  		Body:              Ptr(""),
   798  		AuthorAssociation: Ptr(""),
   799  		User:              &User{},
   800  		Assignee:          &User{},
   801  		Comments:          Ptr(0),
   802  		ClosedAt:          &Timestamp{},
   803  		CreatedAt:         &Timestamp{},
   804  		UpdatedAt:         &Timestamp{},
   805  		ClosedBy:          &User{},
   806  		URL:               Ptr(""),
   807  		HTMLURL:           Ptr(""),
   808  		CommentsURL:       Ptr(""),
   809  		EventsURL:         Ptr(""),
   810  		LabelsURL:         Ptr(""),
   811  		RepositoryURL:     Ptr(""),
   812  		Milestone:         &Milestone{},
   813  		PullRequestLinks:  &PullRequestLinks{},
   814  		Repository:        &Repository{},
   815  		Reactions:         &Reactions{},
   816  		NodeID:            Ptr(""),
   817  		Draft:             Ptr(false),
   818  		ActiveLockReason:  Ptr(""),
   819  	}
   820  	want := `github.Issue{ID:0, Number:0, State:"", StateReason:"", Locked:false, Title:"", Body:"", AuthorAssociation:"", User:github.User{}, Assignee:github.User{}, Comments:0, ClosedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, CreatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, UpdatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, ClosedBy:github.User{}, URL:"", HTMLURL:"", CommentsURL:"", EventsURL:"", LabelsURL:"", RepositoryURL:"", Milestone:github.Milestone{}, PullRequestLinks:github.PullRequestLinks{}, Repository:github.Repository{}, Reactions:github.Reactions{}, NodeID:"", Draft:false, ActiveLockReason:""}`
   821  	if got := v.String(); got != want {
   822  		t.Errorf("Issue.String = %v, want %v", got, want)
   823  	}
   824  }
   825  
   826  func TestIssueComment_String(t *testing.T) {
   827  	t.Parallel()
   828  	v := IssueComment{
   829  		ID:                Ptr(int64(0)),
   830  		NodeID:            Ptr(""),
   831  		Body:              Ptr(""),
   832  		User:              &User{},
   833  		Reactions:         &Reactions{},
   834  		CreatedAt:         &Timestamp{},
   835  		UpdatedAt:         &Timestamp{},
   836  		AuthorAssociation: Ptr(""),
   837  		URL:               Ptr(""),
   838  		HTMLURL:           Ptr(""),
   839  		IssueURL:          Ptr(""),
   840  	}
   841  	want := `github.IssueComment{ID:0, NodeID:"", Body:"", User:github.User{}, Reactions:github.Reactions{}, CreatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, UpdatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, AuthorAssociation:"", URL:"", HTMLURL:"", IssueURL:""}`
   842  	if got := v.String(); got != want {
   843  		t.Errorf("IssueComment.String = %v, want %v", got, want)
   844  	}
   845  }
   846  
   847  func TestIssueStats_String(t *testing.T) {
   848  	t.Parallel()
   849  	v := IssueStats{
   850  		TotalIssues:  Ptr(0),
   851  		OpenIssues:   Ptr(0),
   852  		ClosedIssues: Ptr(0),
   853  	}
   854  	want := `github.IssueStats{TotalIssues:0, OpenIssues:0, ClosedIssues:0}`
   855  	if got := v.String(); got != want {
   856  		t.Errorf("IssueStats.String = %v, want %v", got, want)
   857  	}
   858  }
   859  
   860  func TestKey_String(t *testing.T) {
   861  	t.Parallel()
   862  	v := Key{
   863  		ID:        Ptr(int64(0)),
   864  		Key:       Ptr(""),
   865  		URL:       Ptr(""),
   866  		Title:     Ptr(""),
   867  		ReadOnly:  Ptr(false),
   868  		Verified:  Ptr(false),
   869  		CreatedAt: &Timestamp{},
   870  		AddedBy:   Ptr(""),
   871  		LastUsed:  &Timestamp{},
   872  	}
   873  	want := `github.Key{ID:0, Key:"", URL:"", Title:"", ReadOnly:false, Verified:false, CreatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, AddedBy:"", LastUsed:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}}`
   874  	if got := v.String(); got != want {
   875  		t.Errorf("Key.String = %v, want %v", got, want)
   876  	}
   877  }
   878  
   879  func TestLabel_String(t *testing.T) {
   880  	t.Parallel()
   881  	v := Label{
   882  		ID:          Ptr(int64(0)),
   883  		URL:         Ptr(""),
   884  		Name:        Ptr(""),
   885  		Color:       Ptr(""),
   886  		Description: Ptr(""),
   887  		Default:     Ptr(false),
   888  		NodeID:      Ptr(""),
   889  	}
   890  	want := `github.Label{ID:0, URL:"", Name:"", Color:"", Description:"", Default:false, NodeID:""}`
   891  	if got := v.String(); got != want {
   892  		t.Errorf("Label.String = %v, want %v", got, want)
   893  	}
   894  }
   895  
   896  func TestLabelResult_String(t *testing.T) {
   897  	t.Parallel()
   898  	v := LabelResult{
   899  		ID:          Ptr(int64(0)),
   900  		URL:         Ptr(""),
   901  		Name:        Ptr(""),
   902  		Color:       Ptr(""),
   903  		Default:     Ptr(false),
   904  		Description: Ptr(""),
   905  		Score:       Ptr(0.0),
   906  	}
   907  	want := `github.LabelResult{ID:0, URL:"", Name:"", Color:"", Default:false, Description:"", Score:0}`
   908  	if got := v.String(); got != want {
   909  		t.Errorf("LabelResult.String = %v, want %v", got, want)
   910  	}
   911  }
   912  
   913  func TestLargeFile_String(t *testing.T) {
   914  	t.Parallel()
   915  	v := LargeFile{
   916  		RefName: Ptr(""),
   917  		Path:    Ptr(""),
   918  		OID:     Ptr(""),
   919  		Size:    Ptr(0),
   920  	}
   921  	want := `github.LargeFile{RefName:"", Path:"", OID:"", Size:0}`
   922  	if got := v.String(); got != want {
   923  		t.Errorf("LargeFile.String = %v, want %v", got, want)
   924  	}
   925  }
   926  
   927  func TestLicense_String(t *testing.T) {
   928  	t.Parallel()
   929  	v := License{
   930  		Key:            Ptr(""),
   931  		Name:           Ptr(""),
   932  		URL:            Ptr(""),
   933  		SPDXID:         Ptr(""),
   934  		HTMLURL:        Ptr(""),
   935  		Featured:       Ptr(false),
   936  		Description:    Ptr(""),
   937  		Implementation: Ptr(""),
   938  		Body:           Ptr(""),
   939  	}
   940  	want := `github.License{Key:"", Name:"", URL:"", SPDXID:"", HTMLURL:"", Featured:false, Description:"", Implementation:"", Body:""}`
   941  	if got := v.String(); got != want {
   942  		t.Errorf("License.String = %v, want %v", got, want)
   943  	}
   944  }
   945  
   946  func TestMembership_String(t *testing.T) {
   947  	t.Parallel()
   948  	v := Membership{
   949  		URL:             Ptr(""),
   950  		State:           Ptr(""),
   951  		Role:            Ptr(""),
   952  		OrganizationURL: Ptr(""),
   953  		Organization:    &Organization{},
   954  		User:            &User{},
   955  	}
   956  	want := `github.Membership{URL:"", State:"", Role:"", OrganizationURL:"", Organization:github.Organization{}, User:github.User{}}`
   957  	if got := v.String(); got != want {
   958  		t.Errorf("Membership.String = %v, want %v", got, want)
   959  	}
   960  }
   961  
   962  func TestMigration_String(t *testing.T) {
   963  	t.Parallel()
   964  	v := Migration{
   965  		ID:                 Ptr(int64(0)),
   966  		GUID:               Ptr(""),
   967  		State:              Ptr(""),
   968  		LockRepositories:   Ptr(false),
   969  		ExcludeAttachments: Ptr(false),
   970  		URL:                Ptr(""),
   971  		CreatedAt:          Ptr(""),
   972  		UpdatedAt:          Ptr(""),
   973  	}
   974  	want := `github.Migration{ID:0, GUID:"", State:"", LockRepositories:false, ExcludeAttachments:false, URL:"", CreatedAt:"", UpdatedAt:""}`
   975  	if got := v.String(); got != want {
   976  		t.Errorf("Migration.String = %v, want %v", got, want)
   977  	}
   978  }
   979  
   980  func TestMilestone_String(t *testing.T) {
   981  	t.Parallel()
   982  	v := Milestone{
   983  		URL:          Ptr(""),
   984  		HTMLURL:      Ptr(""),
   985  		LabelsURL:    Ptr(""),
   986  		ID:           Ptr(int64(0)),
   987  		Number:       Ptr(0),
   988  		State:        Ptr(""),
   989  		Title:        Ptr(""),
   990  		Description:  Ptr(""),
   991  		Creator:      &User{},
   992  		OpenIssues:   Ptr(0),
   993  		ClosedIssues: Ptr(0),
   994  		CreatedAt:    &Timestamp{},
   995  		UpdatedAt:    &Timestamp{},
   996  		ClosedAt:     &Timestamp{},
   997  		DueOn:        &Timestamp{},
   998  		NodeID:       Ptr(""),
   999  	}
  1000  	want := `github.Milestone{URL:"", HTMLURL:"", LabelsURL:"", ID:0, Number:0, State:"", Title:"", Description:"", Creator:github.User{}, OpenIssues:0, ClosedIssues:0, CreatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, UpdatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, ClosedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, DueOn:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, NodeID:""}`
  1001  	if got := v.String(); got != want {
  1002  		t.Errorf("Milestone.String = %v, want %v", got, want)
  1003  	}
  1004  }
  1005  
  1006  func TestMilestoneStats_String(t *testing.T) {
  1007  	t.Parallel()
  1008  	v := MilestoneStats{
  1009  		TotalMilestones:  Ptr(0),
  1010  		OpenMilestones:   Ptr(0),
  1011  		ClosedMilestones: Ptr(0),
  1012  	}
  1013  	want := `github.MilestoneStats{TotalMilestones:0, OpenMilestones:0, ClosedMilestones:0}`
  1014  	if got := v.String(); got != want {
  1015  		t.Errorf("MilestoneStats.String = %v, want %v", got, want)
  1016  	}
  1017  }
  1018  
  1019  func TestNewTeam_String(t *testing.T) {
  1020  	t.Parallel()
  1021  	v := NewTeam{
  1022  		Name:                "",
  1023  		Description:         Ptr(""),
  1024  		Maintainers:         []string{""},
  1025  		RepoNames:           []string{""},
  1026  		ParentTeamID:        Ptr(int64(0)),
  1027  		NotificationSetting: Ptr(""),
  1028  		Permission:          Ptr(""),
  1029  		Privacy:             Ptr(""),
  1030  		LDAPDN:              Ptr(""),
  1031  	}
  1032  	want := `github.NewTeam{Name:"", Description:"", Maintainers:[""], RepoNames:[""], ParentTeamID:0, NotificationSetting:"", Permission:"", Privacy:"", LDAPDN:""}`
  1033  	if got := v.String(); got != want {
  1034  		t.Errorf("NewTeam.String = %v, want %v", got, want)
  1035  	}
  1036  }
  1037  
  1038  func TestOAuthAPP_String(t *testing.T) {
  1039  	t.Parallel()
  1040  	v := OAuthAPP{
  1041  		URL:      Ptr(""),
  1042  		Name:     Ptr(""),
  1043  		ClientID: Ptr(""),
  1044  	}
  1045  	want := `github.OAuthAPP{URL:"", Name:"", ClientID:""}`
  1046  	if got := v.String(); got != want {
  1047  		t.Errorf("OAuthAPP.String = %v, want %v", got, want)
  1048  	}
  1049  }
  1050  
  1051  func TestOrgStats_String(t *testing.T) {
  1052  	t.Parallel()
  1053  	v := OrgStats{
  1054  		TotalOrgs:        Ptr(0),
  1055  		DisabledOrgs:     Ptr(0),
  1056  		TotalTeams:       Ptr(0),
  1057  		TotalTeamMembers: Ptr(0),
  1058  	}
  1059  	want := `github.OrgStats{TotalOrgs:0, DisabledOrgs:0, TotalTeams:0, TotalTeamMembers:0}`
  1060  	if got := v.String(); got != want {
  1061  		t.Errorf("OrgStats.String = %v, want %v", got, want)
  1062  	}
  1063  }
  1064  
  1065  func TestOrganization_String(t *testing.T) {
  1066  	t.Parallel()
  1067  	v := Organization{
  1068  		Login:                                Ptr(""),
  1069  		ID:                                   Ptr(int64(0)),
  1070  		NodeID:                               Ptr(""),
  1071  		AvatarURL:                            Ptr(""),
  1072  		HTMLURL:                              Ptr(""),
  1073  		Name:                                 Ptr(""),
  1074  		Company:                              Ptr(""),
  1075  		Blog:                                 Ptr(""),
  1076  		Location:                             Ptr(""),
  1077  		Email:                                Ptr(""),
  1078  		TwitterUsername:                      Ptr(""),
  1079  		Description:                          Ptr(""),
  1080  		PublicRepos:                          Ptr(0),
  1081  		PublicGists:                          Ptr(0),
  1082  		Followers:                            Ptr(0),
  1083  		Following:                            Ptr(0),
  1084  		CreatedAt:                            &Timestamp{},
  1085  		UpdatedAt:                            &Timestamp{},
  1086  		TotalPrivateRepos:                    Ptr(int64(0)),
  1087  		OwnedPrivateRepos:                    Ptr(int64(0)),
  1088  		PrivateGists:                         Ptr(0),
  1089  		DiskUsage:                            Ptr(0),
  1090  		Collaborators:                        Ptr(0),
  1091  		BillingEmail:                         Ptr(""),
  1092  		Type:                                 Ptr(""),
  1093  		Plan:                                 &Plan{},
  1094  		TwoFactorRequirementEnabled:          Ptr(false),
  1095  		IsVerified:                           Ptr(false),
  1096  		HasOrganizationProjects:              Ptr(false),
  1097  		HasRepositoryProjects:                Ptr(false),
  1098  		DefaultRepoPermission:                Ptr(""),
  1099  		DefaultRepoSettings:                  Ptr(""),
  1100  		MembersCanCreateRepos:                Ptr(false),
  1101  		MembersCanCreatePublicRepos:          Ptr(false),
  1102  		MembersCanCreatePrivateRepos:         Ptr(false),
  1103  		MembersCanCreateInternalRepos:        Ptr(false),
  1104  		MembersCanForkPrivateRepos:           Ptr(false),
  1105  		MembersAllowedRepositoryCreationType: Ptr(""),
  1106  		MembersCanCreatePages:                Ptr(false),
  1107  		MembersCanCreatePublicPages:          Ptr(false),
  1108  		MembersCanCreatePrivatePages:         Ptr(false),
  1109  		WebCommitSignoffRequired:             Ptr(false),
  1110  		AdvancedSecurityEnabledForNewRepos:   Ptr(false),
  1111  		DependabotAlertsEnabledForNewRepos:   Ptr(false),
  1112  		DependabotSecurityUpdatesEnabledForNewRepos:    Ptr(false),
  1113  		DependencyGraphEnabledForNewRepos:              Ptr(false),
  1114  		SecretScanningEnabledForNewRepos:               Ptr(false),
  1115  		SecretScanningPushProtectionEnabledForNewRepos: Ptr(false),
  1116  		SecretScanningValidityChecksEnabled:            Ptr(false),
  1117  		URL:                                            Ptr(""),
  1118  		EventsURL:                                      Ptr(""),
  1119  		HooksURL:                                       Ptr(""),
  1120  		IssuesURL:                                      Ptr(""),
  1121  		MembersURL:                                     Ptr(""),
  1122  		PublicMembersURL:                               Ptr(""),
  1123  		ReposURL:                                       Ptr(""),
  1124  	}
  1125  	want := `github.Organization{Login:"", ID:0, NodeID:"", AvatarURL:"", HTMLURL:"", Name:"", Company:"", Blog:"", Location:"", Email:"", TwitterUsername:"", Description:"", PublicRepos:0, PublicGists:0, Followers:0, Following:0, CreatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, UpdatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, TotalPrivateRepos:0, OwnedPrivateRepos:0, PrivateGists:0, DiskUsage:0, Collaborators:0, BillingEmail:"", Type:"", Plan:github.Plan{}, TwoFactorRequirementEnabled:false, IsVerified:false, HasOrganizationProjects:false, HasRepositoryProjects:false, DefaultRepoPermission:"", DefaultRepoSettings:"", MembersCanCreateRepos:false, MembersCanCreatePublicRepos:false, MembersCanCreatePrivateRepos:false, MembersCanCreateInternalRepos:false, MembersCanForkPrivateRepos:false, MembersAllowedRepositoryCreationType:"", MembersCanCreatePages:false, MembersCanCreatePublicPages:false, MembersCanCreatePrivatePages:false, WebCommitSignoffRequired:false, AdvancedSecurityEnabledForNewRepos:false, DependabotAlertsEnabledForNewRepos:false, DependabotSecurityUpdatesEnabledForNewRepos:false, DependencyGraphEnabledForNewRepos:false, SecretScanningEnabledForNewRepos:false, SecretScanningPushProtectionEnabledForNewRepos:false, SecretScanningValidityChecksEnabled:false, URL:"", EventsURL:"", HooksURL:"", IssuesURL:"", MembersURL:"", PublicMembersURL:"", ReposURL:""}`
  1126  	if got := v.String(); got != want {
  1127  		t.Errorf("Organization.String = %v, want %v", got, want)
  1128  	}
  1129  }
  1130  
  1131  func TestPackage_String(t *testing.T) {
  1132  	t.Parallel()
  1133  	v := Package{
  1134  		ID:             Ptr(int64(0)),
  1135  		Name:           Ptr(""),
  1136  		PackageType:    Ptr(""),
  1137  		HTMLURL:        Ptr(""),
  1138  		CreatedAt:      &Timestamp{},
  1139  		UpdatedAt:      &Timestamp{},
  1140  		Owner:          &User{},
  1141  		PackageVersion: &PackageVersion{},
  1142  		Registry:       &PackageRegistry{},
  1143  		URL:            Ptr(""),
  1144  		VersionCount:   Ptr(int64(0)),
  1145  		Visibility:     Ptr(""),
  1146  		Repository:     &Repository{},
  1147  	}
  1148  	want := `github.Package{ID:0, Name:"", PackageType:"", HTMLURL:"", CreatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, UpdatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, Owner:github.User{}, PackageVersion:github.PackageVersion{}, Registry:github.PackageRegistry{}, URL:"", VersionCount:0, Visibility:"", Repository:github.Repository{}}`
  1149  	if got := v.String(); got != want {
  1150  		t.Errorf("Package.String = %v, want %v", got, want)
  1151  	}
  1152  }
  1153  
  1154  func TestPackageContainerMetadata_String(t *testing.T) {
  1155  	t.Parallel()
  1156  	v := PackageContainerMetadata{
  1157  		Tags: []string{""},
  1158  	}
  1159  	want := `github.PackageContainerMetadata{Tags:[""]}`
  1160  	if got := v.String(); got != want {
  1161  		t.Errorf("PackageContainerMetadata.String = %v, want %v", got, want)
  1162  	}
  1163  }
  1164  
  1165  func TestPackageFile_String(t *testing.T) {
  1166  	t.Parallel()
  1167  	v := PackageFile{
  1168  		DownloadURL: Ptr(""),
  1169  		ID:          Ptr(int64(0)),
  1170  		Name:        Ptr(""),
  1171  		SHA256:      Ptr(""),
  1172  		SHA1:        Ptr(""),
  1173  		MD5:         Ptr(""),
  1174  		ContentType: Ptr(""),
  1175  		State:       Ptr(""),
  1176  		Author:      &User{},
  1177  		Size:        Ptr(int64(0)),
  1178  		CreatedAt:   &Timestamp{},
  1179  		UpdatedAt:   &Timestamp{},
  1180  	}
  1181  	want := `github.PackageFile{DownloadURL:"", ID:0, Name:"", SHA256:"", SHA1:"", MD5:"", ContentType:"", State:"", Author:github.User{}, Size:0, CreatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, UpdatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}}`
  1182  	if got := v.String(); got != want {
  1183  		t.Errorf("PackageFile.String = %v, want %v", got, want)
  1184  	}
  1185  }
  1186  
  1187  func TestPackageMetadata_String(t *testing.T) {
  1188  	t.Parallel()
  1189  	v := PackageMetadata{
  1190  		PackageType: Ptr(""),
  1191  		Container:   &PackageContainerMetadata{},
  1192  	}
  1193  	want := `github.PackageMetadata{PackageType:"", Container:github.PackageContainerMetadata{}}`
  1194  	if got := v.String(); got != want {
  1195  		t.Errorf("PackageMetadata.String = %v, want %v", got, want)
  1196  	}
  1197  }
  1198  
  1199  func TestPackageRegistry_String(t *testing.T) {
  1200  	t.Parallel()
  1201  	v := PackageRegistry{
  1202  		AboutURL: Ptr(""),
  1203  		Name:     Ptr(""),
  1204  		Type:     Ptr(""),
  1205  		URL:      Ptr(""),
  1206  		Vendor:   Ptr(""),
  1207  	}
  1208  	want := `github.PackageRegistry{AboutURL:"", Name:"", Type:"", URL:"", Vendor:""}`
  1209  	if got := v.String(); got != want {
  1210  		t.Errorf("PackageRegistry.String = %v, want %v", got, want)
  1211  	}
  1212  }
  1213  
  1214  func TestPackageRelease_String(t *testing.T) {
  1215  	t.Parallel()
  1216  	v := PackageRelease{
  1217  		URL:             Ptr(""),
  1218  		HTMLURL:         Ptr(""),
  1219  		ID:              Ptr(int64(0)),
  1220  		TagName:         Ptr(""),
  1221  		TargetCommitish: Ptr(""),
  1222  		Name:            Ptr(""),
  1223  		Draft:           Ptr(false),
  1224  		Author:          &User{},
  1225  		Prerelease:      Ptr(false),
  1226  		CreatedAt:       &Timestamp{},
  1227  		PublishedAt:     &Timestamp{},
  1228  	}
  1229  	want := `github.PackageRelease{URL:"", HTMLURL:"", ID:0, TagName:"", TargetCommitish:"", Name:"", Draft:false, Author:github.User{}, Prerelease:false, CreatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, PublishedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}}`
  1230  	if got := v.String(); got != want {
  1231  		t.Errorf("PackageRelease.String = %v, want %v", got, want)
  1232  	}
  1233  }
  1234  
  1235  func TestPackageVersion_String(t *testing.T) {
  1236  	t.Parallel()
  1237  	v := PackageVersion{
  1238  		ID:                  Ptr(int64(0)),
  1239  		Version:             Ptr(""),
  1240  		Summary:             Ptr(""),
  1241  		Body:                Ptr(""),
  1242  		BodyHTML:            Ptr(""),
  1243  		Release:             &PackageRelease{},
  1244  		Manifest:            Ptr(""),
  1245  		HTMLURL:             Ptr(""),
  1246  		TagName:             Ptr(""),
  1247  		TargetCommitish:     Ptr(""),
  1248  		TargetOID:           Ptr(""),
  1249  		Draft:               Ptr(false),
  1250  		Prerelease:          Ptr(false),
  1251  		CreatedAt:           &Timestamp{},
  1252  		UpdatedAt:           &Timestamp{},
  1253  		Author:              &User{},
  1254  		InstallationCommand: Ptr(""),
  1255  		Metadata:            &PackageMetadata{},
  1256  		PackageHTMLURL:      Ptr(""),
  1257  		Name:                Ptr(""),
  1258  		URL:                 Ptr(""),
  1259  	}
  1260  	want := `github.PackageVersion{ID:0, Version:"", Summary:"", Body:"", BodyHTML:"", Release:github.PackageRelease{}, Manifest:"", HTMLURL:"", TagName:"", TargetCommitish:"", TargetOID:"", Draft:false, Prerelease:false, CreatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, UpdatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, Author:github.User{}, InstallationCommand:"", Metadata:github.PackageMetadata{}, PackageHTMLURL:"", Name:"", URL:""}`
  1261  	if got := v.String(); got != want {
  1262  		t.Errorf("PackageVersion.String = %v, want %v", got, want)
  1263  	}
  1264  }
  1265  
  1266  func TestPageStats_String(t *testing.T) {
  1267  	t.Parallel()
  1268  	v := PageStats{
  1269  		TotalPages: Ptr(0),
  1270  	}
  1271  	want := `github.PageStats{TotalPages:0}`
  1272  	if got := v.String(); got != want {
  1273  		t.Errorf("PageStats.String = %v, want %v", got, want)
  1274  	}
  1275  }
  1276  
  1277  func TestPlan_String(t *testing.T) {
  1278  	t.Parallel()
  1279  	v := Plan{
  1280  		Name:          Ptr(""),
  1281  		Space:         Ptr(0),
  1282  		Collaborators: Ptr(0),
  1283  		PrivateRepos:  Ptr(int64(0)),
  1284  		FilledSeats:   Ptr(0),
  1285  		Seats:         Ptr(0),
  1286  	}
  1287  	want := `github.Plan{Name:"", Space:0, Collaborators:0, PrivateRepos:0, FilledSeats:0, Seats:0}`
  1288  	if got := v.String(); got != want {
  1289  		t.Errorf("Plan.String = %v, want %v", got, want)
  1290  	}
  1291  }
  1292  
  1293  func TestPreReceiveHook_String(t *testing.T) {
  1294  	t.Parallel()
  1295  	v := PreReceiveHook{
  1296  		ID:          Ptr(int64(0)),
  1297  		Name:        Ptr(""),
  1298  		Enforcement: Ptr(""),
  1299  		ConfigURL:   Ptr(""),
  1300  	}
  1301  	want := `github.PreReceiveHook{ID:0, Name:"", Enforcement:"", ConfigURL:""}`
  1302  	if got := v.String(); got != want {
  1303  		t.Errorf("PreReceiveHook.String = %v, want %v", got, want)
  1304  	}
  1305  }
  1306  
  1307  func TestPullRequest_String(t *testing.T) {
  1308  	t.Parallel()
  1309  	v := PullRequest{
  1310  		ID:                  Ptr(int64(0)),
  1311  		Number:              Ptr(0),
  1312  		State:               Ptr(""),
  1313  		Locked:              Ptr(false),
  1314  		Title:               Ptr(""),
  1315  		Body:                Ptr(""),
  1316  		CreatedAt:           &Timestamp{},
  1317  		UpdatedAt:           &Timestamp{},
  1318  		ClosedAt:            &Timestamp{},
  1319  		MergedAt:            &Timestamp{},
  1320  		User:                &User{},
  1321  		Draft:               Ptr(false),
  1322  		Merged:              Ptr(false),
  1323  		Mergeable:           Ptr(false),
  1324  		MergeableState:      Ptr(""),
  1325  		MergedBy:            &User{},
  1326  		MergeCommitSHA:      Ptr(""),
  1327  		Rebaseable:          Ptr(false),
  1328  		Comments:            Ptr(0),
  1329  		Commits:             Ptr(0),
  1330  		Additions:           Ptr(0),
  1331  		Deletions:           Ptr(0),
  1332  		ChangedFiles:        Ptr(0),
  1333  		URL:                 Ptr(""),
  1334  		HTMLURL:             Ptr(""),
  1335  		IssueURL:            Ptr(""),
  1336  		StatusesURL:         Ptr(""),
  1337  		DiffURL:             Ptr(""),
  1338  		PatchURL:            Ptr(""),
  1339  		CommitsURL:          Ptr(""),
  1340  		CommentsURL:         Ptr(""),
  1341  		ReviewCommentsURL:   Ptr(""),
  1342  		ReviewCommentURL:    Ptr(""),
  1343  		ReviewComments:      Ptr(0),
  1344  		Assignee:            &User{},
  1345  		Milestone:           &Milestone{},
  1346  		MaintainerCanModify: Ptr(false),
  1347  		AuthorAssociation:   Ptr(""),
  1348  		NodeID:              Ptr(""),
  1349  		AutoMerge:           &PullRequestAutoMerge{},
  1350  		Links:               &PRLinks{},
  1351  		Head:                &PullRequestBranch{},
  1352  		Base:                &PullRequestBranch{},
  1353  		ActiveLockReason:    Ptr(""),
  1354  	}
  1355  	want := `github.PullRequest{ID:0, Number:0, State:"", Locked:false, Title:"", Body:"", CreatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, UpdatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, ClosedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, MergedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, User:github.User{}, Draft:false, Merged:false, Mergeable:false, MergeableState:"", MergedBy:github.User{}, MergeCommitSHA:"", Rebaseable:false, Comments:0, Commits:0, Additions:0, Deletions:0, ChangedFiles:0, URL:"", HTMLURL:"", IssueURL:"", StatusesURL:"", DiffURL:"", PatchURL:"", CommitsURL:"", CommentsURL:"", ReviewCommentsURL:"", ReviewCommentURL:"", ReviewComments:0, Assignee:github.User{}, Milestone:github.Milestone{}, MaintainerCanModify:false, AuthorAssociation:"", NodeID:"", AutoMerge:github.PullRequestAutoMerge{}, Links:github.PRLinks{}, Head:github.PullRequestBranch{}, Base:github.PullRequestBranch{}, ActiveLockReason:""}`
  1356  	if got := v.String(); got != want {
  1357  		t.Errorf("PullRequest.String = %v, want %v", got, want)
  1358  	}
  1359  }
  1360  
  1361  func TestPullRequestComment_String(t *testing.T) {
  1362  	t.Parallel()
  1363  	v := PullRequestComment{
  1364  		ID:                  Ptr(int64(0)),
  1365  		NodeID:              Ptr(""),
  1366  		InReplyTo:           Ptr(int64(0)),
  1367  		Body:                Ptr(""),
  1368  		Path:                Ptr(""),
  1369  		DiffHunk:            Ptr(""),
  1370  		PullRequestReviewID: Ptr(int64(0)),
  1371  		Position:            Ptr(0),
  1372  		OriginalPosition:    Ptr(0),
  1373  		StartLine:           Ptr(0),
  1374  		Line:                Ptr(0),
  1375  		OriginalLine:        Ptr(0),
  1376  		OriginalStartLine:   Ptr(0),
  1377  		Side:                Ptr(""),
  1378  		StartSide:           Ptr(""),
  1379  		CommitID:            Ptr(""),
  1380  		OriginalCommitID:    Ptr(""),
  1381  		User:                &User{},
  1382  		Reactions:           &Reactions{},
  1383  		CreatedAt:           &Timestamp{},
  1384  		UpdatedAt:           &Timestamp{},
  1385  		AuthorAssociation:   Ptr(""),
  1386  		URL:                 Ptr(""),
  1387  		HTMLURL:             Ptr(""),
  1388  		PullRequestURL:      Ptr(""),
  1389  		SubjectType:         Ptr(""),
  1390  	}
  1391  	want := `github.PullRequestComment{ID:0, NodeID:"", InReplyTo:0, Body:"", Path:"", DiffHunk:"", PullRequestReviewID:0, Position:0, OriginalPosition:0, StartLine:0, Line:0, OriginalLine:0, OriginalStartLine:0, Side:"", StartSide:"", CommitID:"", OriginalCommitID:"", User:github.User{}, Reactions:github.Reactions{}, CreatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, UpdatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, AuthorAssociation:"", URL:"", HTMLURL:"", PullRequestURL:"", SubjectType:""}`
  1392  	if got := v.String(); got != want {
  1393  		t.Errorf("PullRequestComment.String = %v, want %v", got, want)
  1394  	}
  1395  }
  1396  
  1397  func TestPullRequestReview_String(t *testing.T) {
  1398  	t.Parallel()
  1399  	v := PullRequestReview{
  1400  		ID:                Ptr(int64(0)),
  1401  		NodeID:            Ptr(""),
  1402  		User:              &User{},
  1403  		Body:              Ptr(""),
  1404  		SubmittedAt:       &Timestamp{},
  1405  		CommitID:          Ptr(""),
  1406  		HTMLURL:           Ptr(""),
  1407  		PullRequestURL:    Ptr(""),
  1408  		State:             Ptr(""),
  1409  		AuthorAssociation: Ptr(""),
  1410  	}
  1411  	want := `github.PullRequestReview{ID:0, NodeID:"", User:github.User{}, Body:"", SubmittedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, CommitID:"", HTMLURL:"", PullRequestURL:"", State:"", AuthorAssociation:""}`
  1412  	if got := v.String(); got != want {
  1413  		t.Errorf("PullRequestReview.String = %v, want %v", got, want)
  1414  	}
  1415  }
  1416  
  1417  func TestPullRequestReviewDismissalRequest_String(t *testing.T) {
  1418  	t.Parallel()
  1419  	v := PullRequestReviewDismissalRequest{
  1420  		Message: Ptr(""),
  1421  	}
  1422  	want := `github.PullRequestReviewDismissalRequest{Message:""}`
  1423  	if got := v.String(); got != want {
  1424  		t.Errorf("PullRequestReviewDismissalRequest.String = %v, want %v", got, want)
  1425  	}
  1426  }
  1427  
  1428  func TestPullRequestReviewRequest_String(t *testing.T) {
  1429  	t.Parallel()
  1430  	v := PullRequestReviewRequest{
  1431  		NodeID:   Ptr(""),
  1432  		CommitID: Ptr(""),
  1433  		Body:     Ptr(""),
  1434  		Event:    Ptr(""),
  1435  	}
  1436  	want := `github.PullRequestReviewRequest{NodeID:"", CommitID:"", Body:"", Event:""}`
  1437  	if got := v.String(); got != want {
  1438  		t.Errorf("PullRequestReviewRequest.String = %v, want %v", got, want)
  1439  	}
  1440  }
  1441  
  1442  func TestPullRequestThread_String(t *testing.T) {
  1443  	t.Parallel()
  1444  	v := PullRequestThread{
  1445  		ID:     Ptr(int64(0)),
  1446  		NodeID: Ptr(""),
  1447  	}
  1448  	want := `github.PullRequestThread{ID:0, NodeID:""}`
  1449  	if got := v.String(); got != want {
  1450  		t.Errorf("PullRequestThread.String = %v, want %v", got, want)
  1451  	}
  1452  }
  1453  
  1454  func TestPullStats_String(t *testing.T) {
  1455  	t.Parallel()
  1456  	v := PullStats{
  1457  		TotalPulls:      Ptr(0),
  1458  		MergedPulls:     Ptr(0),
  1459  		MergablePulls:   Ptr(0),
  1460  		UnmergablePulls: Ptr(0),
  1461  	}
  1462  	want := `github.PullStats{TotalPulls:0, MergedPulls:0, MergablePulls:0, UnmergablePulls:0}`
  1463  	if got := v.String(); got != want {
  1464  		t.Errorf("PullStats.String = %v, want %v", got, want)
  1465  	}
  1466  }
  1467  
  1468  func TestPushEvent_String(t *testing.T) {
  1469  	t.Parallel()
  1470  	v := PushEvent{
  1471  		PushID:       Ptr(int64(0)),
  1472  		Head:         Ptr(""),
  1473  		Ref:          Ptr(""),
  1474  		Size:         Ptr(0),
  1475  		Before:       Ptr(""),
  1476  		DistinctSize: Ptr(0),
  1477  		Action:       Ptr(""),
  1478  		After:        Ptr(""),
  1479  		Created:      Ptr(false),
  1480  		Deleted:      Ptr(false),
  1481  		Forced:       Ptr(false),
  1482  		BaseRef:      Ptr(""),
  1483  		Compare:      Ptr(""),
  1484  		Repo:         &PushEventRepository{},
  1485  		HeadCommit:   &HeadCommit{},
  1486  		Pusher:       &CommitAuthor{},
  1487  		Sender:       &User{},
  1488  		Installation: &Installation{},
  1489  		Organization: &Organization{},
  1490  	}
  1491  	want := `github.PushEvent{PushID:0, Head:"", Ref:"", Size:0, Before:"", DistinctSize:0, Action:"", After:"", Created:false, Deleted:false, Forced:false, BaseRef:"", Compare:"", Repo:github.PushEventRepository{}, HeadCommit:github.HeadCommit{}, Pusher:github.CommitAuthor{}, Sender:github.User{}, Installation:github.Installation{}, Organization:github.Organization{}}`
  1492  	if got := v.String(); got != want {
  1493  		t.Errorf("PushEvent.String = %v, want %v", got, want)
  1494  	}
  1495  }
  1496  
  1497  func TestRate_String(t *testing.T) {
  1498  	t.Parallel()
  1499  	v := Rate{
  1500  		Limit:     0,
  1501  		Remaining: 0,
  1502  		Reset:     Timestamp{},
  1503  	}
  1504  	want := `github.Rate{Limit:0, Remaining:0, Reset:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}}`
  1505  	if got := v.String(); got != want {
  1506  		t.Errorf("Rate.String = %v, want %v", got, want)
  1507  	}
  1508  }
  1509  
  1510  func TestReaction_String(t *testing.T) {
  1511  	t.Parallel()
  1512  	v := Reaction{
  1513  		ID:      Ptr(int64(0)),
  1514  		User:    &User{},
  1515  		NodeID:  Ptr(""),
  1516  		Content: Ptr(""),
  1517  	}
  1518  	want := `github.Reaction{ID:0, User:github.User{}, NodeID:"", Content:""}`
  1519  	if got := v.String(); got != want {
  1520  		t.Errorf("Reaction.String = %v, want %v", got, want)
  1521  	}
  1522  }
  1523  
  1524  func TestReference_String(t *testing.T) {
  1525  	t.Parallel()
  1526  	v := Reference{
  1527  		Ref:    Ptr(""),
  1528  		URL:    Ptr(""),
  1529  		Object: &GitObject{},
  1530  		NodeID: Ptr(""),
  1531  	}
  1532  	want := `github.Reference{Ref:"", URL:"", Object:github.GitObject{}, NodeID:""}`
  1533  	if got := v.String(); got != want {
  1534  		t.Errorf("Reference.String = %v, want %v", got, want)
  1535  	}
  1536  }
  1537  
  1538  func TestReleaseAsset_String(t *testing.T) {
  1539  	t.Parallel()
  1540  	v := ReleaseAsset{
  1541  		ID:                 Ptr(int64(0)),
  1542  		URL:                Ptr(""),
  1543  		Name:               Ptr(""),
  1544  		Label:              Ptr(""),
  1545  		State:              Ptr(""),
  1546  		ContentType:        Ptr(""),
  1547  		Size:               Ptr(0),
  1548  		DownloadCount:      Ptr(0),
  1549  		CreatedAt:          &Timestamp{},
  1550  		UpdatedAt:          &Timestamp{},
  1551  		BrowserDownloadURL: Ptr(""),
  1552  		Uploader:           &User{},
  1553  		NodeID:             Ptr(""),
  1554  	}
  1555  	want := `github.ReleaseAsset{ID:0, URL:"", Name:"", Label:"", State:"", ContentType:"", Size:0, DownloadCount:0, CreatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, UpdatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, BrowserDownloadURL:"", Uploader:github.User{}, NodeID:""}`
  1556  	if got := v.String(); got != want {
  1557  		t.Errorf("ReleaseAsset.String = %v, want %v", got, want)
  1558  	}
  1559  }
  1560  
  1561  func TestRename_String(t *testing.T) {
  1562  	t.Parallel()
  1563  	v := Rename{
  1564  		From: Ptr(""),
  1565  		To:   Ptr(""),
  1566  	}
  1567  	want := `github.Rename{From:"", To:""}`
  1568  	if got := v.String(); got != want {
  1569  		t.Errorf("Rename.String = %v, want %v", got, want)
  1570  	}
  1571  }
  1572  
  1573  func TestRepoStats_String(t *testing.T) {
  1574  	t.Parallel()
  1575  	v := RepoStats{
  1576  		TotalRepos:  Ptr(0),
  1577  		RootRepos:   Ptr(0),
  1578  		ForkRepos:   Ptr(0),
  1579  		OrgRepos:    Ptr(0),
  1580  		TotalPushes: Ptr(0),
  1581  		TotalWikis:  Ptr(0),
  1582  	}
  1583  	want := `github.RepoStats{TotalRepos:0, RootRepos:0, ForkRepos:0, OrgRepos:0, TotalPushes:0, TotalWikis:0}`
  1584  	if got := v.String(); got != want {
  1585  		t.Errorf("RepoStats.String = %v, want %v", got, want)
  1586  	}
  1587  }
  1588  
  1589  func TestRepoStatus_String(t *testing.T) {
  1590  	t.Parallel()
  1591  	v := RepoStatus{
  1592  		ID:          Ptr(int64(0)),
  1593  		NodeID:      Ptr(""),
  1594  		URL:         Ptr(""),
  1595  		State:       Ptr(""),
  1596  		TargetURL:   Ptr(""),
  1597  		Description: Ptr(""),
  1598  		Context:     Ptr(""),
  1599  		AvatarURL:   Ptr(""),
  1600  		Creator:     &User{},
  1601  		CreatedAt:   &Timestamp{},
  1602  		UpdatedAt:   &Timestamp{},
  1603  	}
  1604  	want := `github.RepoStatus{ID:0, NodeID:"", URL:"", State:"", TargetURL:"", Description:"", Context:"", AvatarURL:"", Creator:github.User{}, CreatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, UpdatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}}`
  1605  	if got := v.String(); got != want {
  1606  		t.Errorf("RepoStatus.String = %v, want %v", got, want)
  1607  	}
  1608  }
  1609  
  1610  func TestRepository_String(t *testing.T) {
  1611  	t.Parallel()
  1612  	v := Repository{
  1613  		ID:                        Ptr(int64(0)),
  1614  		NodeID:                    Ptr(""),
  1615  		Owner:                     &User{},
  1616  		Name:                      Ptr(""),
  1617  		FullName:                  Ptr(""),
  1618  		Description:               Ptr(""),
  1619  		Homepage:                  Ptr(""),
  1620  		CodeOfConduct:             &CodeOfConduct{},
  1621  		DefaultBranch:             Ptr(""),
  1622  		MasterBranch:              Ptr(""),
  1623  		CreatedAt:                 &Timestamp{},
  1624  		PushedAt:                  &Timestamp{},
  1625  		UpdatedAt:                 &Timestamp{},
  1626  		HTMLURL:                   Ptr(""),
  1627  		CloneURL:                  Ptr(""),
  1628  		GitURL:                    Ptr(""),
  1629  		MirrorURL:                 Ptr(""),
  1630  		SSHURL:                    Ptr(""),
  1631  		SVNURL:                    Ptr(""),
  1632  		Language:                  Ptr(""),
  1633  		Fork:                      Ptr(false),
  1634  		ForksCount:                Ptr(0),
  1635  		NetworkCount:              Ptr(0),
  1636  		OpenIssuesCount:           Ptr(0),
  1637  		OpenIssues:                Ptr(0),
  1638  		StargazersCount:           Ptr(0),
  1639  		SubscribersCount:          Ptr(0),
  1640  		WatchersCount:             Ptr(0),
  1641  		Watchers:                  Ptr(0),
  1642  		Size:                      Ptr(0),
  1643  		AutoInit:                  Ptr(false),
  1644  		Parent:                    &Repository{},
  1645  		Source:                    &Repository{},
  1646  		TemplateRepository:        &Repository{},
  1647  		Organization:              &Organization{},
  1648  		AllowRebaseMerge:          Ptr(false),
  1649  		AllowUpdateBranch:         Ptr(false),
  1650  		AllowSquashMerge:          Ptr(false),
  1651  		AllowMergeCommit:          Ptr(false),
  1652  		AllowAutoMerge:            Ptr(false),
  1653  		AllowForking:              Ptr(false),
  1654  		WebCommitSignoffRequired:  Ptr(false),
  1655  		DeleteBranchOnMerge:       Ptr(false),
  1656  		UseSquashPRTitleAsDefault: Ptr(false),
  1657  		SquashMergeCommitTitle:    Ptr(""),
  1658  		SquashMergeCommitMessage:  Ptr(""),
  1659  		MergeCommitTitle:          Ptr(""),
  1660  		MergeCommitMessage:        Ptr(""),
  1661  		Topics:                    []string{""},
  1662  		Archived:                  Ptr(false),
  1663  		Disabled:                  Ptr(false),
  1664  		License:                   &License{},
  1665  		Private:                   Ptr(false),
  1666  		HasIssues:                 Ptr(false),
  1667  		HasWiki:                   Ptr(false),
  1668  		HasPages:                  Ptr(false),
  1669  		HasProjects:               Ptr(false),
  1670  		HasDownloads:              Ptr(false),
  1671  		HasDiscussions:            Ptr(false),
  1672  		IsTemplate:                Ptr(false),
  1673  		LicenseTemplate:           Ptr(""),
  1674  		GitignoreTemplate:         Ptr(""),
  1675  		SecurityAndAnalysis:       &SecurityAndAnalysis{},
  1676  		TeamID:                    Ptr(int64(0)),
  1677  		URL:                       Ptr(""),
  1678  		ArchiveURL:                Ptr(""),
  1679  		AssigneesURL:              Ptr(""),
  1680  		BlobsURL:                  Ptr(""),
  1681  		BranchesURL:               Ptr(""),
  1682  		CollaboratorsURL:          Ptr(""),
  1683  		CommentsURL:               Ptr(""),
  1684  		CommitsURL:                Ptr(""),
  1685  		CompareURL:                Ptr(""),
  1686  		ContentsURL:               Ptr(""),
  1687  		ContributorsURL:           Ptr(""),
  1688  		DeploymentsURL:            Ptr(""),
  1689  		DownloadsURL:              Ptr(""),
  1690  		EventsURL:                 Ptr(""),
  1691  		ForksURL:                  Ptr(""),
  1692  		GitCommitsURL:             Ptr(""),
  1693  		GitRefsURL:                Ptr(""),
  1694  		GitTagsURL:                Ptr(""),
  1695  		HooksURL:                  Ptr(""),
  1696  		IssueCommentURL:           Ptr(""),
  1697  		IssueEventsURL:            Ptr(""),
  1698  		IssuesURL:                 Ptr(""),
  1699  		KeysURL:                   Ptr(""),
  1700  		LabelsURL:                 Ptr(""),
  1701  		LanguagesURL:              Ptr(""),
  1702  		MergesURL:                 Ptr(""),
  1703  		MilestonesURL:             Ptr(""),
  1704  		NotificationsURL:          Ptr(""),
  1705  		PullsURL:                  Ptr(""),
  1706  		ReleasesURL:               Ptr(""),
  1707  		StargazersURL:             Ptr(""),
  1708  		StatusesURL:               Ptr(""),
  1709  		SubscribersURL:            Ptr(""),
  1710  		SubscriptionURL:           Ptr(""),
  1711  		TagsURL:                   Ptr(""),
  1712  		TreesURL:                  Ptr(""),
  1713  		TeamsURL:                  Ptr(""),
  1714  		Visibility:                Ptr(""),
  1715  		RoleName:                  Ptr(""),
  1716  	}
  1717  	want := `github.Repository{ID:0, NodeID:"", Owner:github.User{}, Name:"", FullName:"", Description:"", Homepage:"", CodeOfConduct:github.CodeOfConduct{}, DefaultBranch:"", MasterBranch:"", CreatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, PushedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, UpdatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, HTMLURL:"", CloneURL:"", GitURL:"", MirrorURL:"", SSHURL:"", SVNURL:"", Language:"", Fork:false, ForksCount:0, NetworkCount:0, OpenIssuesCount:0, OpenIssues:0, StargazersCount:0, SubscribersCount:0, WatchersCount:0, Watchers:0, Size:0, AutoInit:false, Parent:github.Repository{}, Source:github.Repository{}, TemplateRepository:github.Repository{}, Organization:github.Organization{}, AllowRebaseMerge:false, AllowUpdateBranch:false, AllowSquashMerge:false, AllowMergeCommit:false, AllowAutoMerge:false, AllowForking:false, WebCommitSignoffRequired:false, DeleteBranchOnMerge:false, UseSquashPRTitleAsDefault:false, SquashMergeCommitTitle:"", SquashMergeCommitMessage:"", MergeCommitTitle:"", MergeCommitMessage:"", Topics:[""], Archived:false, Disabled:false, License:github.License{}, Private:false, HasIssues:false, HasWiki:false, HasPages:false, HasProjects:false, HasDownloads:false, HasDiscussions:false, IsTemplate:false, LicenseTemplate:"", GitignoreTemplate:"", SecurityAndAnalysis:github.SecurityAndAnalysis{}, TeamID:0, URL:"", ArchiveURL:"", AssigneesURL:"", BlobsURL:"", BranchesURL:"", CollaboratorsURL:"", CommentsURL:"", CommitsURL:"", CompareURL:"", ContentsURL:"", ContributorsURL:"", DeploymentsURL:"", DownloadsURL:"", EventsURL:"", ForksURL:"", GitCommitsURL:"", GitRefsURL:"", GitTagsURL:"", HooksURL:"", IssueCommentURL:"", IssueEventsURL:"", IssuesURL:"", KeysURL:"", LabelsURL:"", LanguagesURL:"", MergesURL:"", MilestonesURL:"", NotificationsURL:"", PullsURL:"", ReleasesURL:"", StargazersURL:"", StatusesURL:"", SubscribersURL:"", SubscriptionURL:"", TagsURL:"", TreesURL:"", TeamsURL:"", Visibility:"", RoleName:""}`
  1718  	if got := v.String(); got != want {
  1719  		t.Errorf("Repository.String = %v, want %v", got, want)
  1720  	}
  1721  }
  1722  
  1723  func TestRepositoryComment_String(t *testing.T) {
  1724  	t.Parallel()
  1725  	v := RepositoryComment{
  1726  		HTMLURL:   Ptr(""),
  1727  		URL:       Ptr(""),
  1728  		ID:        Ptr(int64(0)),
  1729  		NodeID:    Ptr(""),
  1730  		CommitID:  Ptr(""),
  1731  		User:      &User{},
  1732  		Reactions: &Reactions{},
  1733  		CreatedAt: &Timestamp{},
  1734  		UpdatedAt: &Timestamp{},
  1735  		Body:      Ptr(""),
  1736  		Path:      Ptr(""),
  1737  		Position:  Ptr(0),
  1738  	}
  1739  	want := `github.RepositoryComment{HTMLURL:"", URL:"", ID:0, NodeID:"", CommitID:"", User:github.User{}, Reactions:github.Reactions{}, CreatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, UpdatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, Body:"", Path:"", Position:0}`
  1740  	if got := v.String(); got != want {
  1741  		t.Errorf("RepositoryComment.String = %v, want %v", got, want)
  1742  	}
  1743  }
  1744  
  1745  func TestRepositoryCommit_String(t *testing.T) {
  1746  	t.Parallel()
  1747  	v := RepositoryCommit{
  1748  		NodeID:      Ptr(""),
  1749  		SHA:         Ptr(""),
  1750  		Commit:      &Commit{},
  1751  		Author:      &User{},
  1752  		Committer:   &User{},
  1753  		HTMLURL:     Ptr(""),
  1754  		URL:         Ptr(""),
  1755  		CommentsURL: Ptr(""),
  1756  		Stats:       &CommitStats{},
  1757  	}
  1758  	want := `github.RepositoryCommit{NodeID:"", SHA:"", Commit:github.Commit{}, Author:github.User{}, Committer:github.User{}, HTMLURL:"", URL:"", CommentsURL:"", Stats:github.CommitStats{}}`
  1759  	if got := v.String(); got != want {
  1760  		t.Errorf("RepositoryCommit.String = %v, want %v", got, want)
  1761  	}
  1762  }
  1763  
  1764  func TestRepositoryContent_String(t *testing.T) {
  1765  	t.Parallel()
  1766  	v := RepositoryContent{
  1767  		Type:            Ptr(""),
  1768  		Target:          Ptr(""),
  1769  		Encoding:        Ptr(""),
  1770  		Size:            Ptr(0),
  1771  		Name:            Ptr(""),
  1772  		Path:            Ptr(""),
  1773  		Content:         Ptr(""),
  1774  		SHA:             Ptr(""),
  1775  		URL:             Ptr(""),
  1776  		GitURL:          Ptr(""),
  1777  		HTMLURL:         Ptr(""),
  1778  		DownloadURL:     Ptr(""),
  1779  		SubmoduleGitURL: Ptr(""),
  1780  	}
  1781  	want := `github.RepositoryContent{Type:"", Target:"", Encoding:"", Size:0, Name:"", Path:"", Content:"", SHA:"", URL:"", GitURL:"", HTMLURL:"", DownloadURL:"", SubmoduleGitURL:""}`
  1782  	if got := v.String(); got != want {
  1783  		t.Errorf("RepositoryContent.String = %v, want %v", got, want)
  1784  	}
  1785  }
  1786  
  1787  func TestRepositoryLicense_String(t *testing.T) {
  1788  	t.Parallel()
  1789  	v := RepositoryLicense{
  1790  		Name:        Ptr(""),
  1791  		Path:        Ptr(""),
  1792  		SHA:         Ptr(""),
  1793  		Size:        Ptr(0),
  1794  		URL:         Ptr(""),
  1795  		HTMLURL:     Ptr(""),
  1796  		GitURL:      Ptr(""),
  1797  		DownloadURL: Ptr(""),
  1798  		Type:        Ptr(""),
  1799  		Content:     Ptr(""),
  1800  		Encoding:    Ptr(""),
  1801  		License:     &License{},
  1802  	}
  1803  	want := `github.RepositoryLicense{Name:"", Path:"", SHA:"", Size:0, URL:"", HTMLURL:"", GitURL:"", DownloadURL:"", Type:"", Content:"", Encoding:"", License:github.License{}}`
  1804  	if got := v.String(); got != want {
  1805  		t.Errorf("RepositoryLicense.String = %v, want %v", got, want)
  1806  	}
  1807  }
  1808  
  1809  func TestRepositoryParticipation_String(t *testing.T) {
  1810  	t.Parallel()
  1811  	v := RepositoryParticipation{
  1812  		All:   []int{0},
  1813  		Owner: []int{0},
  1814  	}
  1815  	want := `github.RepositoryParticipation{All:[0], Owner:[0]}`
  1816  	if got := v.String(); got != want {
  1817  		t.Errorf("RepositoryParticipation.String = %v, want %v", got, want)
  1818  	}
  1819  }
  1820  
  1821  func TestRepositoryRelease_String(t *testing.T) {
  1822  	t.Parallel()
  1823  	v := RepositoryRelease{
  1824  		TagName:                Ptr(""),
  1825  		TargetCommitish:        Ptr(""),
  1826  		Name:                   Ptr(""),
  1827  		Body:                   Ptr(""),
  1828  		Draft:                  Ptr(false),
  1829  		Prerelease:             Ptr(false),
  1830  		MakeLatest:             Ptr(""),
  1831  		DiscussionCategoryName: Ptr(""),
  1832  		GenerateReleaseNotes:   Ptr(false),
  1833  		ID:                     Ptr(int64(0)),
  1834  		CreatedAt:              &Timestamp{},
  1835  		PublishedAt:            &Timestamp{},
  1836  		URL:                    Ptr(""),
  1837  		HTMLURL:                Ptr(""),
  1838  		AssetsURL:              Ptr(""),
  1839  		UploadURL:              Ptr(""),
  1840  		ZipballURL:             Ptr(""),
  1841  		TarballURL:             Ptr(""),
  1842  		Author:                 &User{},
  1843  		NodeID:                 Ptr(""),
  1844  	}
  1845  	want := `github.RepositoryRelease{TagName:"", TargetCommitish:"", Name:"", Body:"", Draft:false, Prerelease:false, MakeLatest:"", DiscussionCategoryName:"", GenerateReleaseNotes:false, ID:0, CreatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, PublishedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, URL:"", HTMLURL:"", AssetsURL:"", UploadURL:"", ZipballURL:"", TarballURL:"", Author:github.User{}, NodeID:""}`
  1846  	if got := v.String(); got != want {
  1847  		t.Errorf("RepositoryRelease.String = %v, want %v", got, want)
  1848  	}
  1849  }
  1850  
  1851  func TestSBOM_String(t *testing.T) {
  1852  	t.Parallel()
  1853  	v := SBOM{
  1854  		SBOM: &SBOMInfo{},
  1855  	}
  1856  	want := `github.SBOM{SBOM:github.SBOMInfo{}}`
  1857  	if got := v.String(); got != want {
  1858  		t.Errorf("SBOM.String = %v, want %v", got, want)
  1859  	}
  1860  }
  1861  
  1862  func TestSSHSigningKey_String(t *testing.T) {
  1863  	t.Parallel()
  1864  	v := SSHSigningKey{
  1865  		ID:        Ptr(int64(0)),
  1866  		Key:       Ptr(""),
  1867  		Title:     Ptr(""),
  1868  		CreatedAt: &Timestamp{},
  1869  	}
  1870  	want := `github.SSHSigningKey{ID:0, Key:"", Title:"", CreatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}}`
  1871  	if got := v.String(); got != want {
  1872  		t.Errorf("SSHSigningKey.String = %v, want %v", got, want)
  1873  	}
  1874  }
  1875  
  1876  func TestSecretScanning_String(t *testing.T) {
  1877  	t.Parallel()
  1878  	v := SecretScanning{
  1879  		Status: Ptr(""),
  1880  	}
  1881  	want := `github.SecretScanning{Status:""}`
  1882  	if got := v.String(); got != want {
  1883  		t.Errorf("SecretScanning.String = %v, want %v", got, want)
  1884  	}
  1885  }
  1886  
  1887  func TestSecretScanningPushProtection_String(t *testing.T) {
  1888  	t.Parallel()
  1889  	v := SecretScanningPushProtection{
  1890  		Status: Ptr(""),
  1891  	}
  1892  	want := `github.SecretScanningPushProtection{Status:""}`
  1893  	if got := v.String(); got != want {
  1894  		t.Errorf("SecretScanningPushProtection.String = %v, want %v", got, want)
  1895  	}
  1896  }
  1897  
  1898  func TestSecurityAndAnalysis_String(t *testing.T) {
  1899  	t.Parallel()
  1900  	v := SecurityAndAnalysis{
  1901  		AdvancedSecurity:             &AdvancedSecurity{},
  1902  		SecretScanning:               &SecretScanning{},
  1903  		SecretScanningPushProtection: &SecretScanningPushProtection{},
  1904  		DependabotSecurityUpdates:    &DependabotSecurityUpdates{},
  1905  		SecretScanningValidityChecks: &SecretScanningValidityChecks{},
  1906  	}
  1907  	want := `github.SecurityAndAnalysis{AdvancedSecurity:github.AdvancedSecurity{}, SecretScanning:github.SecretScanning{}, SecretScanningPushProtection:github.SecretScanningPushProtection{}, DependabotSecurityUpdates:github.DependabotSecurityUpdates{}, SecretScanningValidityChecks:github.SecretScanningValidityChecks{}}`
  1908  	if got := v.String(); got != want {
  1909  		t.Errorf("SecurityAndAnalysis.String = %v, want %v", got, want)
  1910  	}
  1911  }
  1912  
  1913  func TestSourceImportAuthor_String(t *testing.T) {
  1914  	t.Parallel()
  1915  	v := SourceImportAuthor{
  1916  		ID:         Ptr(int64(0)),
  1917  		RemoteID:   Ptr(""),
  1918  		RemoteName: Ptr(""),
  1919  		Email:      Ptr(""),
  1920  		Name:       Ptr(""),
  1921  		URL:        Ptr(""),
  1922  		ImportURL:  Ptr(""),
  1923  	}
  1924  	want := `github.SourceImportAuthor{ID:0, RemoteID:"", RemoteName:"", Email:"", Name:"", URL:"", ImportURL:""}`
  1925  	if got := v.String(); got != want {
  1926  		t.Errorf("SourceImportAuthor.String = %v, want %v", got, want)
  1927  	}
  1928  }
  1929  
  1930  func TestTeam_String(t *testing.T) {
  1931  	t.Parallel()
  1932  	v := Team{
  1933  		ID:              Ptr(int64(0)),
  1934  		NodeID:          Ptr(""),
  1935  		Name:            Ptr(""),
  1936  		Description:     Ptr(""),
  1937  		URL:             Ptr(""),
  1938  		Slug:            Ptr(""),
  1939  		Permission:      Ptr(""),
  1940  		Privacy:         Ptr(""),
  1941  		MembersCount:    Ptr(0),
  1942  		ReposCount:      Ptr(0),
  1943  		Organization:    &Organization{},
  1944  		HTMLURL:         Ptr(""),
  1945  		MembersURL:      Ptr(""),
  1946  		RepositoriesURL: Ptr(""),
  1947  		Parent:          &Team{},
  1948  		LDAPDN:          Ptr(""),
  1949  		Assignment:      Ptr(""),
  1950  	}
  1951  	want := `github.Team{ID:0, NodeID:"", Name:"", Description:"", URL:"", Slug:"", Permission:"", Privacy:"", MembersCount:0, ReposCount:0, Organization:github.Organization{}, HTMLURL:"", MembersURL:"", RepositoriesURL:"", Parent:github.Team{}, LDAPDN:"", Assignment:""}`
  1952  	if got := v.String(); got != want {
  1953  		t.Errorf("Team.String = %v, want %v", got, want)
  1954  	}
  1955  }
  1956  
  1957  func TestTeamDiscussion_String(t *testing.T) {
  1958  	t.Parallel()
  1959  	v := TeamDiscussion{
  1960  		Author:        &User{},
  1961  		Body:          Ptr(""),
  1962  		BodyHTML:      Ptr(""),
  1963  		BodyVersion:   Ptr(""),
  1964  		CommentsCount: Ptr(0),
  1965  		CommentsURL:   Ptr(""),
  1966  		CreatedAt:     &Timestamp{},
  1967  		LastEditedAt:  &Timestamp{},
  1968  		HTMLURL:       Ptr(""),
  1969  		NodeID:        Ptr(""),
  1970  		Number:        Ptr(0),
  1971  		Pinned:        Ptr(false),
  1972  		Private:       Ptr(false),
  1973  		TeamURL:       Ptr(""),
  1974  		Title:         Ptr(""),
  1975  		UpdatedAt:     &Timestamp{},
  1976  		URL:           Ptr(""),
  1977  		Reactions:     &Reactions{},
  1978  	}
  1979  	want := `github.TeamDiscussion{Author:github.User{}, Body:"", BodyHTML:"", BodyVersion:"", CommentsCount:0, CommentsURL:"", CreatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, LastEditedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, HTMLURL:"", NodeID:"", Number:0, Pinned:false, Private:false, TeamURL:"", Title:"", UpdatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, URL:"", Reactions:github.Reactions{}}`
  1980  	if got := v.String(); got != want {
  1981  		t.Errorf("TeamDiscussion.String = %v, want %v", got, want)
  1982  	}
  1983  }
  1984  
  1985  func TestTeamLDAPMapping_String(t *testing.T) {
  1986  	t.Parallel()
  1987  	v := TeamLDAPMapping{
  1988  		ID:              Ptr(int64(0)),
  1989  		LDAPDN:          Ptr(""),
  1990  		URL:             Ptr(""),
  1991  		Name:            Ptr(""),
  1992  		Slug:            Ptr(""),
  1993  		Description:     Ptr(""),
  1994  		Privacy:         Ptr(""),
  1995  		Permission:      Ptr(""),
  1996  		MembersURL:      Ptr(""),
  1997  		RepositoriesURL: Ptr(""),
  1998  	}
  1999  	want := `github.TeamLDAPMapping{ID:0, LDAPDN:"", URL:"", Name:"", Slug:"", Description:"", Privacy:"", Permission:"", MembersURL:"", RepositoriesURL:""}`
  2000  	if got := v.String(); got != want {
  2001  		t.Errorf("TeamLDAPMapping.String = %v, want %v", got, want)
  2002  	}
  2003  }
  2004  
  2005  func TestTextMatch_String(t *testing.T) {
  2006  	t.Parallel()
  2007  	v := TextMatch{
  2008  		ObjectURL:  Ptr(""),
  2009  		ObjectType: Ptr(""),
  2010  		Property:   Ptr(""),
  2011  		Fragment:   Ptr(""),
  2012  	}
  2013  	want := `github.TextMatch{ObjectURL:"", ObjectType:"", Property:"", Fragment:""}`
  2014  	if got := v.String(); got != want {
  2015  		t.Errorf("TextMatch.String = %v, want %v", got, want)
  2016  	}
  2017  }
  2018  
  2019  func TestTree_String(t *testing.T) {
  2020  	t.Parallel()
  2021  	v := Tree{
  2022  		SHA:       Ptr(""),
  2023  		Truncated: Ptr(false),
  2024  	}
  2025  	want := `github.Tree{SHA:"", Truncated:false}`
  2026  	if got := v.String(); got != want {
  2027  		t.Errorf("Tree.String = %v, want %v", got, want)
  2028  	}
  2029  }
  2030  
  2031  func TestTreeEntry_String(t *testing.T) {
  2032  	t.Parallel()
  2033  	v := TreeEntry{
  2034  		SHA:     Ptr(""),
  2035  		Path:    Ptr(""),
  2036  		Mode:    Ptr(""),
  2037  		Type:    Ptr(""),
  2038  		Size:    Ptr(0),
  2039  		Content: Ptr(""),
  2040  		URL:     Ptr(""),
  2041  	}
  2042  	want := `github.TreeEntry{SHA:"", Path:"", Mode:"", Type:"", Size:0, Content:"", URL:""}`
  2043  	if got := v.String(); got != want {
  2044  		t.Errorf("TreeEntry.String = %v, want %v", got, want)
  2045  	}
  2046  }
  2047  
  2048  func TestUser_String(t *testing.T) {
  2049  	t.Parallel()
  2050  	v := User{
  2051  		Login:                   Ptr(""),
  2052  		ID:                      Ptr(int64(0)),
  2053  		NodeID:                  Ptr(""),
  2054  		AvatarURL:               Ptr(""),
  2055  		HTMLURL:                 Ptr(""),
  2056  		GravatarID:              Ptr(""),
  2057  		Name:                    Ptr(""),
  2058  		Company:                 Ptr(""),
  2059  		Blog:                    Ptr(""),
  2060  		Location:                Ptr(""),
  2061  		Email:                   Ptr(""),
  2062  		Hireable:                Ptr(false),
  2063  		Bio:                     Ptr(""),
  2064  		TwitterUsername:         Ptr(""),
  2065  		PublicRepos:             Ptr(0),
  2066  		PublicGists:             Ptr(0),
  2067  		Followers:               Ptr(0),
  2068  		Following:               Ptr(0),
  2069  		CreatedAt:               &Timestamp{},
  2070  		UpdatedAt:               &Timestamp{},
  2071  		SuspendedAt:             &Timestamp{},
  2072  		Type:                    Ptr(""),
  2073  		SiteAdmin:               Ptr(false),
  2074  		TotalPrivateRepos:       Ptr(int64(0)),
  2075  		OwnedPrivateRepos:       Ptr(int64(0)),
  2076  		PrivateGists:            Ptr(0),
  2077  		DiskUsage:               Ptr(0),
  2078  		Collaborators:           Ptr(0),
  2079  		TwoFactorAuthentication: Ptr(false),
  2080  		Plan:                    &Plan{},
  2081  		LdapDn:                  Ptr(""),
  2082  		URL:                     Ptr(""),
  2083  		EventsURL:               Ptr(""),
  2084  		FollowingURL:            Ptr(""),
  2085  		FollowersURL:            Ptr(""),
  2086  		GistsURL:                Ptr(""),
  2087  		OrganizationsURL:        Ptr(""),
  2088  		ReceivedEventsURL:       Ptr(""),
  2089  		ReposURL:                Ptr(""),
  2090  		StarredURL:              Ptr(""),
  2091  		SubscriptionsURL:        Ptr(""),
  2092  		RoleName:                Ptr(""),
  2093  		Assignment:              Ptr(""),
  2094  		InheritedFrom:           &Team{},
  2095  	}
  2096  	want := `github.User{Login:"", ID:0, NodeID:"", AvatarURL:"", HTMLURL:"", GravatarID:"", Name:"", Company:"", Blog:"", Location:"", Email:"", Hireable:false, Bio:"", TwitterUsername:"", PublicRepos:0, PublicGists:0, Followers:0, Following:0, CreatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, UpdatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, SuspendedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, Type:"", SiteAdmin:false, TotalPrivateRepos:0, OwnedPrivateRepos:0, PrivateGists:0, DiskUsage:0, Collaborators:0, TwoFactorAuthentication:false, Plan:github.Plan{}, LdapDn:"", URL:"", EventsURL:"", FollowingURL:"", FollowersURL:"", GistsURL:"", OrganizationsURL:"", ReceivedEventsURL:"", ReposURL:"", StarredURL:"", SubscriptionsURL:"", RoleName:"", Assignment:"", InheritedFrom:github.Team{}}`
  2097  	if got := v.String(); got != want {
  2098  		t.Errorf("User.String = %v, want %v", got, want)
  2099  	}
  2100  }
  2101  
  2102  func TestUserLDAPMapping_String(t *testing.T) {
  2103  	t.Parallel()
  2104  	v := UserLDAPMapping{
  2105  		ID:                Ptr(int64(0)),
  2106  		LDAPDN:            Ptr(""),
  2107  		Login:             Ptr(""),
  2108  		AvatarURL:         Ptr(""),
  2109  		GravatarID:        Ptr(""),
  2110  		Type:              Ptr(""),
  2111  		SiteAdmin:         Ptr(false),
  2112  		URL:               Ptr(""),
  2113  		EventsURL:         Ptr(""),
  2114  		FollowingURL:      Ptr(""),
  2115  		FollowersURL:      Ptr(""),
  2116  		GistsURL:          Ptr(""),
  2117  		OrganizationsURL:  Ptr(""),
  2118  		ReceivedEventsURL: Ptr(""),
  2119  		ReposURL:          Ptr(""),
  2120  		StarredURL:        Ptr(""),
  2121  		SubscriptionsURL:  Ptr(""),
  2122  	}
  2123  	want := `github.UserLDAPMapping{ID:0, LDAPDN:"", Login:"", AvatarURL:"", GravatarID:"", Type:"", SiteAdmin:false, URL:"", EventsURL:"", FollowingURL:"", FollowersURL:"", GistsURL:"", OrganizationsURL:"", ReceivedEventsURL:"", ReposURL:"", StarredURL:"", SubscriptionsURL:""}`
  2124  	if got := v.String(); got != want {
  2125  		t.Errorf("UserLDAPMapping.String = %v, want %v", got, want)
  2126  	}
  2127  }
  2128  
  2129  func TestUserMigration_String(t *testing.T) {
  2130  	t.Parallel()
  2131  	v := UserMigration{
  2132  		ID:                 Ptr(int64(0)),
  2133  		GUID:               Ptr(""),
  2134  		State:              Ptr(""),
  2135  		LockRepositories:   Ptr(false),
  2136  		ExcludeAttachments: Ptr(false),
  2137  		URL:                Ptr(""),
  2138  		CreatedAt:          Ptr(""),
  2139  		UpdatedAt:          Ptr(""),
  2140  	}
  2141  	want := `github.UserMigration{ID:0, GUID:"", State:"", LockRepositories:false, ExcludeAttachments:false, URL:"", CreatedAt:"", UpdatedAt:""}`
  2142  	if got := v.String(); got != want {
  2143  		t.Errorf("UserMigration.String = %v, want %v", got, want)
  2144  	}
  2145  }
  2146  
  2147  func TestUserStats_String(t *testing.T) {
  2148  	t.Parallel()
  2149  	v := UserStats{
  2150  		TotalUsers:     Ptr(0),
  2151  		AdminUsers:     Ptr(0),
  2152  		SuspendedUsers: Ptr(0),
  2153  	}
  2154  	want := `github.UserStats{TotalUsers:0, AdminUsers:0, SuspendedUsers:0}`
  2155  	if got := v.String(); got != want {
  2156  		t.Errorf("UserStats.String = %v, want %v", got, want)
  2157  	}
  2158  }
  2159  
  2160  func TestWeeklyCommitActivity_String(t *testing.T) {
  2161  	t.Parallel()
  2162  	v := WeeklyCommitActivity{
  2163  		Days:  []int{0},
  2164  		Total: Ptr(0),
  2165  		Week:  &Timestamp{},
  2166  	}
  2167  	want := `github.WeeklyCommitActivity{Days:[0], Total:0, Week:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}}`
  2168  	if got := v.String(); got != want {
  2169  		t.Errorf("WeeklyCommitActivity.String = %v, want %v", got, want)
  2170  	}
  2171  }
  2172  
  2173  func TestWeeklyStats_String(t *testing.T) {
  2174  	t.Parallel()
  2175  	v := WeeklyStats{
  2176  		Week:      &Timestamp{},
  2177  		Additions: Ptr(0),
  2178  		Deletions: Ptr(0),
  2179  		Commits:   Ptr(0),
  2180  	}
  2181  	want := `github.WeeklyStats{Week:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, Additions:0, Deletions:0, Commits:0}`
  2182  	if got := v.String(); got != want {
  2183  		t.Errorf("WeeklyStats.String = %v, want %v", got, want)
  2184  	}
  2185  }