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