github.com/google/go-github/v60@v60.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  		Permission:   String(""),
   971  		Privacy:      String(""),
   972  		LDAPDN:       String(""),
   973  	}
   974  	want := `github.NewTeam{Name:"", Description:"", Maintainers:[""], RepoNames:[""], ParentTeamID:0, Permission:"", Privacy:"", LDAPDN:""}`
   975  	if got := v.String(); got != want {
   976  		t.Errorf("NewTeam.String = %v, want %v", got, want)
   977  	}
   978  }
   979  
   980  func TestOAuthAPP_String(t *testing.T) {
   981  	v := OAuthAPP{
   982  		URL:      String(""),
   983  		Name:     String(""),
   984  		ClientID: String(""),
   985  	}
   986  	want := `github.OAuthAPP{URL:"", Name:"", ClientID:""}`
   987  	if got := v.String(); got != want {
   988  		t.Errorf("OAuthAPP.String = %v, want %v", got, want)
   989  	}
   990  }
   991  
   992  func TestOrgStats_String(t *testing.T) {
   993  	v := OrgStats{
   994  		TotalOrgs:        Int(0),
   995  		DisabledOrgs:     Int(0),
   996  		TotalTeams:       Int(0),
   997  		TotalTeamMembers: Int(0),
   998  	}
   999  	want := `github.OrgStats{TotalOrgs:0, DisabledOrgs:0, TotalTeams:0, TotalTeamMembers:0}`
  1000  	if got := v.String(); got != want {
  1001  		t.Errorf("OrgStats.String = %v, want %v", got, want)
  1002  	}
  1003  }
  1004  
  1005  func TestOrganization_String(t *testing.T) {
  1006  	v := Organization{
  1007  		Login:                                String(""),
  1008  		ID:                                   Int64(0),
  1009  		NodeID:                               String(""),
  1010  		AvatarURL:                            String(""),
  1011  		HTMLURL:                              String(""),
  1012  		Name:                                 String(""),
  1013  		Company:                              String(""),
  1014  		Blog:                                 String(""),
  1015  		Location:                             String(""),
  1016  		Email:                                String(""),
  1017  		TwitterUsername:                      String(""),
  1018  		Description:                          String(""),
  1019  		PublicRepos:                          Int(0),
  1020  		PublicGists:                          Int(0),
  1021  		Followers:                            Int(0),
  1022  		Following:                            Int(0),
  1023  		CreatedAt:                            &Timestamp{},
  1024  		UpdatedAt:                            &Timestamp{},
  1025  		TotalPrivateRepos:                    Int64(0),
  1026  		OwnedPrivateRepos:                    Int64(0),
  1027  		PrivateGists:                         Int(0),
  1028  		DiskUsage:                            Int(0),
  1029  		Collaborators:                        Int(0),
  1030  		BillingEmail:                         String(""),
  1031  		Type:                                 String(""),
  1032  		Plan:                                 &Plan{},
  1033  		TwoFactorRequirementEnabled:          Bool(false),
  1034  		IsVerified:                           Bool(false),
  1035  		HasOrganizationProjects:              Bool(false),
  1036  		HasRepositoryProjects:                Bool(false),
  1037  		DefaultRepoPermission:                String(""),
  1038  		DefaultRepoSettings:                  String(""),
  1039  		MembersCanCreateRepos:                Bool(false),
  1040  		MembersCanCreatePublicRepos:          Bool(false),
  1041  		MembersCanCreatePrivateRepos:         Bool(false),
  1042  		MembersCanCreateInternalRepos:        Bool(false),
  1043  		MembersCanForkPrivateRepos:           Bool(false),
  1044  		MembersAllowedRepositoryCreationType: String(""),
  1045  		MembersCanCreatePages:                Bool(false),
  1046  		MembersCanCreatePublicPages:          Bool(false),
  1047  		MembersCanCreatePrivatePages:         Bool(false),
  1048  		WebCommitSignoffRequired:             Bool(false),
  1049  		AdvancedSecurityEnabledForNewRepos:   Bool(false),
  1050  		DependabotAlertsEnabledForNewRepos:   Bool(false),
  1051  		DependabotSecurityUpdatesEnabledForNewRepos:    Bool(false),
  1052  		DependencyGraphEnabledForNewRepos:              Bool(false),
  1053  		SecretScanningEnabledForNewRepos:               Bool(false),
  1054  		SecretScanningPushProtectionEnabledForNewRepos: Bool(false),
  1055  		SecretScanningValidityChecksEnabled:            Bool(false),
  1056  		URL:                                            String(""),
  1057  		EventsURL:                                      String(""),
  1058  		HooksURL:                                       String(""),
  1059  		IssuesURL:                                      String(""),
  1060  		MembersURL:                                     String(""),
  1061  		PublicMembersURL:                               String(""),
  1062  		ReposURL:                                       String(""),
  1063  	}
  1064  	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:""}`
  1065  	if got := v.String(); got != want {
  1066  		t.Errorf("Organization.String = %v, want %v", got, want)
  1067  	}
  1068  }
  1069  
  1070  func TestPackage_String(t *testing.T) {
  1071  	v := Package{
  1072  		ID:             Int64(0),
  1073  		Name:           String(""),
  1074  		PackageType:    String(""),
  1075  		HTMLURL:        String(""),
  1076  		CreatedAt:      &Timestamp{},
  1077  		UpdatedAt:      &Timestamp{},
  1078  		Owner:          &User{},
  1079  		PackageVersion: &PackageVersion{},
  1080  		Registry:       &PackageRegistry{},
  1081  		URL:            String(""),
  1082  		VersionCount:   Int64(0),
  1083  		Visibility:     String(""),
  1084  		Repository:     &Repository{},
  1085  	}
  1086  	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{}}`
  1087  	if got := v.String(); got != want {
  1088  		t.Errorf("Package.String = %v, want %v", got, want)
  1089  	}
  1090  }
  1091  
  1092  func TestPackageContainerMetadata_String(t *testing.T) {
  1093  	v := PackageContainerMetadata{
  1094  		Tags: []string{""},
  1095  	}
  1096  	want := `github.PackageContainerMetadata{Tags:[""]}`
  1097  	if got := v.String(); got != want {
  1098  		t.Errorf("PackageContainerMetadata.String = %v, want %v", got, want)
  1099  	}
  1100  }
  1101  
  1102  func TestPackageFile_String(t *testing.T) {
  1103  	v := PackageFile{
  1104  		DownloadURL: String(""),
  1105  		ID:          Int64(0),
  1106  		Name:        String(""),
  1107  		SHA256:      String(""),
  1108  		SHA1:        String(""),
  1109  		MD5:         String(""),
  1110  		ContentType: String(""),
  1111  		State:       String(""),
  1112  		Author:      &User{},
  1113  		Size:        Int64(0),
  1114  		CreatedAt:   &Timestamp{},
  1115  		UpdatedAt:   &Timestamp{},
  1116  	}
  1117  	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}}`
  1118  	if got := v.String(); got != want {
  1119  		t.Errorf("PackageFile.String = %v, want %v", got, want)
  1120  	}
  1121  }
  1122  
  1123  func TestPackageMetadata_String(t *testing.T) {
  1124  	v := PackageMetadata{
  1125  		PackageType: String(""),
  1126  		Container:   &PackageContainerMetadata{},
  1127  	}
  1128  	want := `github.PackageMetadata{PackageType:"", Container:github.PackageContainerMetadata{}}`
  1129  	if got := v.String(); got != want {
  1130  		t.Errorf("PackageMetadata.String = %v, want %v", got, want)
  1131  	}
  1132  }
  1133  
  1134  func TestPackageRegistry_String(t *testing.T) {
  1135  	v := PackageRegistry{
  1136  		AboutURL: String(""),
  1137  		Name:     String(""),
  1138  		Type:     String(""),
  1139  		URL:      String(""),
  1140  		Vendor:   String(""),
  1141  	}
  1142  	want := `github.PackageRegistry{AboutURL:"", Name:"", Type:"", URL:"", Vendor:""}`
  1143  	if got := v.String(); got != want {
  1144  		t.Errorf("PackageRegistry.String = %v, want %v", got, want)
  1145  	}
  1146  }
  1147  
  1148  func TestPackageRelease_String(t *testing.T) {
  1149  	v := PackageRelease{
  1150  		URL:             String(""),
  1151  		HTMLURL:         String(""),
  1152  		ID:              Int64(0),
  1153  		TagName:         String(""),
  1154  		TargetCommitish: String(""),
  1155  		Name:            String(""),
  1156  		Draft:           Bool(false),
  1157  		Author:          &User{},
  1158  		Prerelease:      Bool(false),
  1159  		CreatedAt:       &Timestamp{},
  1160  		PublishedAt:     &Timestamp{},
  1161  	}
  1162  	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}}`
  1163  	if got := v.String(); got != want {
  1164  		t.Errorf("PackageRelease.String = %v, want %v", got, want)
  1165  	}
  1166  }
  1167  
  1168  func TestPackageVersion_String(t *testing.T) {
  1169  	v := PackageVersion{
  1170  		ID:                  Int64(0),
  1171  		Version:             String(""),
  1172  		Summary:             String(""),
  1173  		Body:                String(""),
  1174  		BodyHTML:            String(""),
  1175  		Release:             &PackageRelease{},
  1176  		Manifest:            String(""),
  1177  		HTMLURL:             String(""),
  1178  		TagName:             String(""),
  1179  		TargetCommitish:     String(""),
  1180  		TargetOID:           String(""),
  1181  		Draft:               Bool(false),
  1182  		Prerelease:          Bool(false),
  1183  		CreatedAt:           &Timestamp{},
  1184  		UpdatedAt:           &Timestamp{},
  1185  		Author:              &User{},
  1186  		InstallationCommand: String(""),
  1187  		Metadata:            &PackageMetadata{},
  1188  		PackageHTMLURL:      String(""),
  1189  		Name:                String(""),
  1190  		URL:                 String(""),
  1191  	}
  1192  	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:""}`
  1193  	if got := v.String(); got != want {
  1194  		t.Errorf("PackageVersion.String = %v, want %v", got, want)
  1195  	}
  1196  }
  1197  
  1198  func TestPageStats_String(t *testing.T) {
  1199  	v := PageStats{
  1200  		TotalPages: Int(0),
  1201  	}
  1202  	want := `github.PageStats{TotalPages:0}`
  1203  	if got := v.String(); got != want {
  1204  		t.Errorf("PageStats.String = %v, want %v", got, want)
  1205  	}
  1206  }
  1207  
  1208  func TestPlan_String(t *testing.T) {
  1209  	v := Plan{
  1210  		Name:          String(""),
  1211  		Space:         Int(0),
  1212  		Collaborators: Int(0),
  1213  		PrivateRepos:  Int64(0),
  1214  		FilledSeats:   Int(0),
  1215  		Seats:         Int(0),
  1216  	}
  1217  	want := `github.Plan{Name:"", Space:0, Collaborators:0, PrivateRepos:0, FilledSeats:0, Seats:0}`
  1218  	if got := v.String(); got != want {
  1219  		t.Errorf("Plan.String = %v, want %v", got, want)
  1220  	}
  1221  }
  1222  
  1223  func TestPreReceiveHook_String(t *testing.T) {
  1224  	v := PreReceiveHook{
  1225  		ID:          Int64(0),
  1226  		Name:        String(""),
  1227  		Enforcement: String(""),
  1228  		ConfigURL:   String(""),
  1229  	}
  1230  	want := `github.PreReceiveHook{ID:0, Name:"", Enforcement:"", ConfigURL:""}`
  1231  	if got := v.String(); got != want {
  1232  		t.Errorf("PreReceiveHook.String = %v, want %v", got, want)
  1233  	}
  1234  }
  1235  
  1236  func TestProject_String(t *testing.T) {
  1237  	v := Project{
  1238  		ID:                     Int64(0),
  1239  		URL:                    String(""),
  1240  		HTMLURL:                String(""),
  1241  		ColumnsURL:             String(""),
  1242  		OwnerURL:               String(""),
  1243  		Name:                   String(""),
  1244  		Body:                   String(""),
  1245  		Number:                 Int(0),
  1246  		State:                  String(""),
  1247  		CreatedAt:              &Timestamp{},
  1248  		UpdatedAt:              &Timestamp{},
  1249  		NodeID:                 String(""),
  1250  		OrganizationPermission: String(""),
  1251  		Private:                Bool(false),
  1252  		Creator:                &User{},
  1253  	}
  1254  	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{}}`
  1255  	if got := v.String(); got != want {
  1256  		t.Errorf("Project.String = %v, want %v", got, want)
  1257  	}
  1258  }
  1259  
  1260  func TestPullRequest_String(t *testing.T) {
  1261  	v := PullRequest{
  1262  		ID:                  Int64(0),
  1263  		Number:              Int(0),
  1264  		State:               String(""),
  1265  		Locked:              Bool(false),
  1266  		Title:               String(""),
  1267  		Body:                String(""),
  1268  		CreatedAt:           &Timestamp{},
  1269  		UpdatedAt:           &Timestamp{},
  1270  		ClosedAt:            &Timestamp{},
  1271  		MergedAt:            &Timestamp{},
  1272  		User:                &User{},
  1273  		Draft:               Bool(false),
  1274  		Merged:              Bool(false),
  1275  		Mergeable:           Bool(false),
  1276  		MergeableState:      String(""),
  1277  		MergedBy:            &User{},
  1278  		MergeCommitSHA:      String(""),
  1279  		Rebaseable:          Bool(false),
  1280  		Comments:            Int(0),
  1281  		Commits:             Int(0),
  1282  		Additions:           Int(0),
  1283  		Deletions:           Int(0),
  1284  		ChangedFiles:        Int(0),
  1285  		URL:                 String(""),
  1286  		HTMLURL:             String(""),
  1287  		IssueURL:            String(""),
  1288  		StatusesURL:         String(""),
  1289  		DiffURL:             String(""),
  1290  		PatchURL:            String(""),
  1291  		CommitsURL:          String(""),
  1292  		CommentsURL:         String(""),
  1293  		ReviewCommentsURL:   String(""),
  1294  		ReviewCommentURL:    String(""),
  1295  		ReviewComments:      Int(0),
  1296  		Assignee:            &User{},
  1297  		Milestone:           &Milestone{},
  1298  		MaintainerCanModify: Bool(false),
  1299  		AuthorAssociation:   String(""),
  1300  		NodeID:              String(""),
  1301  		AutoMerge:           &PullRequestAutoMerge{},
  1302  		Links:               &PRLinks{},
  1303  		Head:                &PullRequestBranch{},
  1304  		Base:                &PullRequestBranch{},
  1305  		ActiveLockReason:    String(""),
  1306  	}
  1307  	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:""}`
  1308  	if got := v.String(); got != want {
  1309  		t.Errorf("PullRequest.String = %v, want %v", got, want)
  1310  	}
  1311  }
  1312  
  1313  func TestPullRequestComment_String(t *testing.T) {
  1314  	v := PullRequestComment{
  1315  		ID:                  Int64(0),
  1316  		NodeID:              String(""),
  1317  		InReplyTo:           Int64(0),
  1318  		Body:                String(""),
  1319  		Path:                String(""),
  1320  		DiffHunk:            String(""),
  1321  		PullRequestReviewID: Int64(0),
  1322  		Position:            Int(0),
  1323  		OriginalPosition:    Int(0),
  1324  		StartLine:           Int(0),
  1325  		Line:                Int(0),
  1326  		OriginalLine:        Int(0),
  1327  		OriginalStartLine:   Int(0),
  1328  		Side:                String(""),
  1329  		StartSide:           String(""),
  1330  		CommitID:            String(""),
  1331  		OriginalCommitID:    String(""),
  1332  		User:                &User{},
  1333  		Reactions:           &Reactions{},
  1334  		CreatedAt:           &Timestamp{},
  1335  		UpdatedAt:           &Timestamp{},
  1336  		AuthorAssociation:   String(""),
  1337  		URL:                 String(""),
  1338  		HTMLURL:             String(""),
  1339  		PullRequestURL:      String(""),
  1340  		SubjectType:         String(""),
  1341  	}
  1342  	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:""}`
  1343  	if got := v.String(); got != want {
  1344  		t.Errorf("PullRequestComment.String = %v, want %v", got, want)
  1345  	}
  1346  }
  1347  
  1348  func TestPullRequestReview_String(t *testing.T) {
  1349  	v := PullRequestReview{
  1350  		ID:                Int64(0),
  1351  		NodeID:            String(""),
  1352  		User:              &User{},
  1353  		Body:              String(""),
  1354  		SubmittedAt:       &Timestamp{},
  1355  		CommitID:          String(""),
  1356  		HTMLURL:           String(""),
  1357  		PullRequestURL:    String(""),
  1358  		State:             String(""),
  1359  		AuthorAssociation: String(""),
  1360  	}
  1361  	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:""}`
  1362  	if got := v.String(); got != want {
  1363  		t.Errorf("PullRequestReview.String = %v, want %v", got, want)
  1364  	}
  1365  }
  1366  
  1367  func TestPullRequestReviewDismissalRequest_String(t *testing.T) {
  1368  	v := PullRequestReviewDismissalRequest{
  1369  		Message: String(""),
  1370  	}
  1371  	want := `github.PullRequestReviewDismissalRequest{Message:""}`
  1372  	if got := v.String(); got != want {
  1373  		t.Errorf("PullRequestReviewDismissalRequest.String = %v, want %v", got, want)
  1374  	}
  1375  }
  1376  
  1377  func TestPullRequestReviewRequest_String(t *testing.T) {
  1378  	v := PullRequestReviewRequest{
  1379  		NodeID:   String(""),
  1380  		CommitID: String(""),
  1381  		Body:     String(""),
  1382  		Event:    String(""),
  1383  	}
  1384  	want := `github.PullRequestReviewRequest{NodeID:"", CommitID:"", Body:"", Event:""}`
  1385  	if got := v.String(); got != want {
  1386  		t.Errorf("PullRequestReviewRequest.String = %v, want %v", got, want)
  1387  	}
  1388  }
  1389  
  1390  func TestPullRequestThread_String(t *testing.T) {
  1391  	v := PullRequestThread{
  1392  		ID:     Int64(0),
  1393  		NodeID: String(""),
  1394  	}
  1395  	want := `github.PullRequestThread{ID:0, NodeID:""}`
  1396  	if got := v.String(); got != want {
  1397  		t.Errorf("PullRequestThread.String = %v, want %v", got, want)
  1398  	}
  1399  }
  1400  
  1401  func TestPullStats_String(t *testing.T) {
  1402  	v := PullStats{
  1403  		TotalPulls:      Int(0),
  1404  		MergedPulls:     Int(0),
  1405  		MergablePulls:   Int(0),
  1406  		UnmergablePulls: Int(0),
  1407  	}
  1408  	want := `github.PullStats{TotalPulls:0, MergedPulls:0, MergablePulls:0, UnmergablePulls:0}`
  1409  	if got := v.String(); got != want {
  1410  		t.Errorf("PullStats.String = %v, want %v", got, want)
  1411  	}
  1412  }
  1413  
  1414  func TestPushEvent_String(t *testing.T) {
  1415  	v := PushEvent{
  1416  		PushID:       Int64(0),
  1417  		Head:         String(""),
  1418  		Ref:          String(""),
  1419  		Size:         Int(0),
  1420  		Before:       String(""),
  1421  		DistinctSize: Int(0),
  1422  		Action:       String(""),
  1423  		After:        String(""),
  1424  		Created:      Bool(false),
  1425  		Deleted:      Bool(false),
  1426  		Forced:       Bool(false),
  1427  		BaseRef:      String(""),
  1428  		Compare:      String(""),
  1429  		Repo:         &PushEventRepository{},
  1430  		HeadCommit:   &HeadCommit{},
  1431  		Pusher:       &CommitAuthor{},
  1432  		Sender:       &User{},
  1433  		Installation: &Installation{},
  1434  		Organization: &Organization{},
  1435  	}
  1436  	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{}}`
  1437  	if got := v.String(); got != want {
  1438  		t.Errorf("PushEvent.String = %v, want %v", got, want)
  1439  	}
  1440  }
  1441  
  1442  func TestRate_String(t *testing.T) {
  1443  	v := Rate{
  1444  		Limit:     0,
  1445  		Remaining: 0,
  1446  		Reset:     Timestamp{},
  1447  	}
  1448  	want := `github.Rate{Limit:0, Remaining:0, Reset:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}}`
  1449  	if got := v.String(); got != want {
  1450  		t.Errorf("Rate.String = %v, want %v", got, want)
  1451  	}
  1452  }
  1453  
  1454  func TestReaction_String(t *testing.T) {
  1455  	v := Reaction{
  1456  		ID:      Int64(0),
  1457  		User:    &User{},
  1458  		NodeID:  String(""),
  1459  		Content: String(""),
  1460  	}
  1461  	want := `github.Reaction{ID:0, User:github.User{}, NodeID:"", Content:""}`
  1462  	if got := v.String(); got != want {
  1463  		t.Errorf("Reaction.String = %v, want %v", got, want)
  1464  	}
  1465  }
  1466  
  1467  func TestReference_String(t *testing.T) {
  1468  	v := Reference{
  1469  		Ref:    String(""),
  1470  		URL:    String(""),
  1471  		Object: &GitObject{},
  1472  		NodeID: String(""),
  1473  	}
  1474  	want := `github.Reference{Ref:"", URL:"", Object:github.GitObject{}, NodeID:""}`
  1475  	if got := v.String(); got != want {
  1476  		t.Errorf("Reference.String = %v, want %v", got, want)
  1477  	}
  1478  }
  1479  
  1480  func TestReleaseAsset_String(t *testing.T) {
  1481  	v := ReleaseAsset{
  1482  		ID:                 Int64(0),
  1483  		URL:                String(""),
  1484  		Name:               String(""),
  1485  		Label:              String(""),
  1486  		State:              String(""),
  1487  		ContentType:        String(""),
  1488  		Size:               Int(0),
  1489  		DownloadCount:      Int(0),
  1490  		CreatedAt:          &Timestamp{},
  1491  		UpdatedAt:          &Timestamp{},
  1492  		BrowserDownloadURL: String(""),
  1493  		Uploader:           &User{},
  1494  		NodeID:             String(""),
  1495  	}
  1496  	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:""}`
  1497  	if got := v.String(); got != want {
  1498  		t.Errorf("ReleaseAsset.String = %v, want %v", got, want)
  1499  	}
  1500  }
  1501  
  1502  func TestRename_String(t *testing.T) {
  1503  	v := Rename{
  1504  		From: String(""),
  1505  		To:   String(""),
  1506  	}
  1507  	want := `github.Rename{From:"", To:""}`
  1508  	if got := v.String(); got != want {
  1509  		t.Errorf("Rename.String = %v, want %v", got, want)
  1510  	}
  1511  }
  1512  
  1513  func TestRepoStats_String(t *testing.T) {
  1514  	v := RepoStats{
  1515  		TotalRepos:  Int(0),
  1516  		RootRepos:   Int(0),
  1517  		ForkRepos:   Int(0),
  1518  		OrgRepos:    Int(0),
  1519  		TotalPushes: Int(0),
  1520  		TotalWikis:  Int(0),
  1521  	}
  1522  	want := `github.RepoStats{TotalRepos:0, RootRepos:0, ForkRepos:0, OrgRepos:0, TotalPushes:0, TotalWikis:0}`
  1523  	if got := v.String(); got != want {
  1524  		t.Errorf("RepoStats.String = %v, want %v", got, want)
  1525  	}
  1526  }
  1527  
  1528  func TestRepoStatus_String(t *testing.T) {
  1529  	v := RepoStatus{
  1530  		ID:          Int64(0),
  1531  		NodeID:      String(""),
  1532  		URL:         String(""),
  1533  		State:       String(""),
  1534  		TargetURL:   String(""),
  1535  		Description: String(""),
  1536  		Context:     String(""),
  1537  		AvatarURL:   String(""),
  1538  		Creator:     &User{},
  1539  		CreatedAt:   &Timestamp{},
  1540  		UpdatedAt:   &Timestamp{},
  1541  	}
  1542  	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}}`
  1543  	if got := v.String(); got != want {
  1544  		t.Errorf("RepoStatus.String = %v, want %v", got, want)
  1545  	}
  1546  }
  1547  
  1548  func TestRepository_String(t *testing.T) {
  1549  	v := Repository{
  1550  		ID:                        Int64(0),
  1551  		NodeID:                    String(""),
  1552  		Owner:                     &User{},
  1553  		Name:                      String(""),
  1554  		FullName:                  String(""),
  1555  		Description:               String(""),
  1556  		Homepage:                  String(""),
  1557  		CodeOfConduct:             &CodeOfConduct{},
  1558  		DefaultBranch:             String(""),
  1559  		MasterBranch:              String(""),
  1560  		CreatedAt:                 &Timestamp{},
  1561  		PushedAt:                  &Timestamp{},
  1562  		UpdatedAt:                 &Timestamp{},
  1563  		HTMLURL:                   String(""),
  1564  		CloneURL:                  String(""),
  1565  		GitURL:                    String(""),
  1566  		MirrorURL:                 String(""),
  1567  		SSHURL:                    String(""),
  1568  		SVNURL:                    String(""),
  1569  		Language:                  String(""),
  1570  		Fork:                      Bool(false),
  1571  		ForksCount:                Int(0),
  1572  		NetworkCount:              Int(0),
  1573  		OpenIssuesCount:           Int(0),
  1574  		OpenIssues:                Int(0),
  1575  		StargazersCount:           Int(0),
  1576  		SubscribersCount:          Int(0),
  1577  		WatchersCount:             Int(0),
  1578  		Watchers:                  Int(0),
  1579  		Size:                      Int(0),
  1580  		AutoInit:                  Bool(false),
  1581  		Parent:                    &Repository{},
  1582  		Source:                    &Repository{},
  1583  		TemplateRepository:        &Repository{},
  1584  		Organization:              &Organization{},
  1585  		AllowRebaseMerge:          Bool(false),
  1586  		AllowUpdateBranch:         Bool(false),
  1587  		AllowSquashMerge:          Bool(false),
  1588  		AllowMergeCommit:          Bool(false),
  1589  		AllowAutoMerge:            Bool(false),
  1590  		AllowForking:              Bool(false),
  1591  		WebCommitSignoffRequired:  Bool(false),
  1592  		DeleteBranchOnMerge:       Bool(false),
  1593  		UseSquashPRTitleAsDefault: Bool(false),
  1594  		SquashMergeCommitTitle:    String(""),
  1595  		SquashMergeCommitMessage:  String(""),
  1596  		MergeCommitTitle:          String(""),
  1597  		MergeCommitMessage:        String(""),
  1598  		Topics:                    []string{""},
  1599  		Archived:                  Bool(false),
  1600  		Disabled:                  Bool(false),
  1601  		License:                   &License{},
  1602  		Private:                   Bool(false),
  1603  		HasIssues:                 Bool(false),
  1604  		HasWiki:                   Bool(false),
  1605  		HasPages:                  Bool(false),
  1606  		HasProjects:               Bool(false),
  1607  		HasDownloads:              Bool(false),
  1608  		HasDiscussions:            Bool(false),
  1609  		IsTemplate:                Bool(false),
  1610  		LicenseTemplate:           String(""),
  1611  		GitignoreTemplate:         String(""),
  1612  		SecurityAndAnalysis:       &SecurityAndAnalysis{},
  1613  		TeamID:                    Int64(0),
  1614  		URL:                       String(""),
  1615  		ArchiveURL:                String(""),
  1616  		AssigneesURL:              String(""),
  1617  		BlobsURL:                  String(""),
  1618  		BranchesURL:               String(""),
  1619  		CollaboratorsURL:          String(""),
  1620  		CommentsURL:               String(""),
  1621  		CommitsURL:                String(""),
  1622  		CompareURL:                String(""),
  1623  		ContentsURL:               String(""),
  1624  		ContributorsURL:           String(""),
  1625  		DeploymentsURL:            String(""),
  1626  		DownloadsURL:              String(""),
  1627  		EventsURL:                 String(""),
  1628  		ForksURL:                  String(""),
  1629  		GitCommitsURL:             String(""),
  1630  		GitRefsURL:                String(""),
  1631  		GitTagsURL:                String(""),
  1632  		HooksURL:                  String(""),
  1633  		IssueCommentURL:           String(""),
  1634  		IssueEventsURL:            String(""),
  1635  		IssuesURL:                 String(""),
  1636  		KeysURL:                   String(""),
  1637  		LabelsURL:                 String(""),
  1638  		LanguagesURL:              String(""),
  1639  		MergesURL:                 String(""),
  1640  		MilestonesURL:             String(""),
  1641  		NotificationsURL:          String(""),
  1642  		PullsURL:                  String(""),
  1643  		ReleasesURL:               String(""),
  1644  		StargazersURL:             String(""),
  1645  		StatusesURL:               String(""),
  1646  		SubscribersURL:            String(""),
  1647  		SubscriptionURL:           String(""),
  1648  		TagsURL:                   String(""),
  1649  		TreesURL:                  String(""),
  1650  		TeamsURL:                  String(""),
  1651  		Visibility:                String(""),
  1652  		RoleName:                  String(""),
  1653  	}
  1654  	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:""}`
  1655  	if got := v.String(); got != want {
  1656  		t.Errorf("Repository.String = %v, want %v", got, want)
  1657  	}
  1658  }
  1659  
  1660  func TestRepositoryComment_String(t *testing.T) {
  1661  	v := RepositoryComment{
  1662  		HTMLURL:   String(""),
  1663  		URL:       String(""),
  1664  		ID:        Int64(0),
  1665  		NodeID:    String(""),
  1666  		CommitID:  String(""),
  1667  		User:      &User{},
  1668  		Reactions: &Reactions{},
  1669  		CreatedAt: &Timestamp{},
  1670  		UpdatedAt: &Timestamp{},
  1671  		Body:      String(""),
  1672  		Path:      String(""),
  1673  		Position:  Int(0),
  1674  	}
  1675  	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}`
  1676  	if got := v.String(); got != want {
  1677  		t.Errorf("RepositoryComment.String = %v, want %v", got, want)
  1678  	}
  1679  }
  1680  
  1681  func TestRepositoryCommit_String(t *testing.T) {
  1682  	v := RepositoryCommit{
  1683  		NodeID:      String(""),
  1684  		SHA:         String(""),
  1685  		Commit:      &Commit{},
  1686  		Author:      &User{},
  1687  		Committer:   &User{},
  1688  		HTMLURL:     String(""),
  1689  		URL:         String(""),
  1690  		CommentsURL: String(""),
  1691  		Stats:       &CommitStats{},
  1692  	}
  1693  	want := `github.RepositoryCommit{NodeID:"", SHA:"", Commit:github.Commit{}, Author:github.User{}, Committer:github.User{}, HTMLURL:"", URL:"", CommentsURL:"", Stats:github.CommitStats{}}`
  1694  	if got := v.String(); got != want {
  1695  		t.Errorf("RepositoryCommit.String = %v, want %v", got, want)
  1696  	}
  1697  }
  1698  
  1699  func TestRepositoryContent_String(t *testing.T) {
  1700  	v := RepositoryContent{
  1701  		Type:            String(""),
  1702  		Target:          String(""),
  1703  		Encoding:        String(""),
  1704  		Size:            Int(0),
  1705  		Name:            String(""),
  1706  		Path:            String(""),
  1707  		Content:         String(""),
  1708  		SHA:             String(""),
  1709  		URL:             String(""),
  1710  		GitURL:          String(""),
  1711  		HTMLURL:         String(""),
  1712  		DownloadURL:     String(""),
  1713  		SubmoduleGitURL: String(""),
  1714  	}
  1715  	want := `github.RepositoryContent{Type:"", Target:"", Encoding:"", Size:0, Name:"", Path:"", Content:"", SHA:"", URL:"", GitURL:"", HTMLURL:"", DownloadURL:"", SubmoduleGitURL:""}`
  1716  	if got := v.String(); got != want {
  1717  		t.Errorf("RepositoryContent.String = %v, want %v", got, want)
  1718  	}
  1719  }
  1720  
  1721  func TestRepositoryLicense_String(t *testing.T) {
  1722  	v := RepositoryLicense{
  1723  		Name:        String(""),
  1724  		Path:        String(""),
  1725  		SHA:         String(""),
  1726  		Size:        Int(0),
  1727  		URL:         String(""),
  1728  		HTMLURL:     String(""),
  1729  		GitURL:      String(""),
  1730  		DownloadURL: String(""),
  1731  		Type:        String(""),
  1732  		Content:     String(""),
  1733  		Encoding:    String(""),
  1734  		License:     &License{},
  1735  	}
  1736  	want := `github.RepositoryLicense{Name:"", Path:"", SHA:"", Size:0, URL:"", HTMLURL:"", GitURL:"", DownloadURL:"", Type:"", Content:"", Encoding:"", License:github.License{}}`
  1737  	if got := v.String(); got != want {
  1738  		t.Errorf("RepositoryLicense.String = %v, want %v", got, want)
  1739  	}
  1740  }
  1741  
  1742  func TestRepositoryParticipation_String(t *testing.T) {
  1743  	v := RepositoryParticipation{
  1744  		All:   []int{0},
  1745  		Owner: []int{0},
  1746  	}
  1747  	want := `github.RepositoryParticipation{All:[0], Owner:[0]}`
  1748  	if got := v.String(); got != want {
  1749  		t.Errorf("RepositoryParticipation.String = %v, want %v", got, want)
  1750  	}
  1751  }
  1752  
  1753  func TestRepositoryRelease_String(t *testing.T) {
  1754  	v := RepositoryRelease{
  1755  		TagName:                String(""),
  1756  		TargetCommitish:        String(""),
  1757  		Name:                   String(""),
  1758  		Body:                   String(""),
  1759  		Draft:                  Bool(false),
  1760  		Prerelease:             Bool(false),
  1761  		MakeLatest:             String(""),
  1762  		DiscussionCategoryName: String(""),
  1763  		GenerateReleaseNotes:   Bool(false),
  1764  		ID:                     Int64(0),
  1765  		CreatedAt:              &Timestamp{},
  1766  		PublishedAt:            &Timestamp{},
  1767  		URL:                    String(""),
  1768  		HTMLURL:                String(""),
  1769  		AssetsURL:              String(""),
  1770  		UploadURL:              String(""),
  1771  		ZipballURL:             String(""),
  1772  		TarballURL:             String(""),
  1773  		Author:                 &User{},
  1774  		NodeID:                 String(""),
  1775  	}
  1776  	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:""}`
  1777  	if got := v.String(); got != want {
  1778  		t.Errorf("RepositoryRelease.String = %v, want %v", got, want)
  1779  	}
  1780  }
  1781  
  1782  func TestSBOM_String(t *testing.T) {
  1783  	v := SBOM{
  1784  		SBOM: &SBOMInfo{},
  1785  	}
  1786  	want := `github.SBOM{SBOM:github.SBOMInfo{}}`
  1787  	if got := v.String(); got != want {
  1788  		t.Errorf("SBOM.String = %v, want %v", got, want)
  1789  	}
  1790  }
  1791  
  1792  func TestSSHSigningKey_String(t *testing.T) {
  1793  	v := SSHSigningKey{
  1794  		ID:        Int64(0),
  1795  		Key:       String(""),
  1796  		Title:     String(""),
  1797  		CreatedAt: &Timestamp{},
  1798  	}
  1799  	want := `github.SSHSigningKey{ID:0, Key:"", Title:"", CreatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}}`
  1800  	if got := v.String(); got != want {
  1801  		t.Errorf("SSHSigningKey.String = %v, want %v", got, want)
  1802  	}
  1803  }
  1804  
  1805  func TestSecretScanning_String(t *testing.T) {
  1806  	v := SecretScanning{
  1807  		Status: String(""),
  1808  	}
  1809  	want := `github.SecretScanning{Status:""}`
  1810  	if got := v.String(); got != want {
  1811  		t.Errorf("SecretScanning.String = %v, want %v", got, want)
  1812  	}
  1813  }
  1814  
  1815  func TestSecretScanningPushProtection_String(t *testing.T) {
  1816  	v := SecretScanningPushProtection{
  1817  		Status: String(""),
  1818  	}
  1819  	want := `github.SecretScanningPushProtection{Status:""}`
  1820  	if got := v.String(); got != want {
  1821  		t.Errorf("SecretScanningPushProtection.String = %v, want %v", got, want)
  1822  	}
  1823  }
  1824  
  1825  func TestSecurityAndAnalysis_String(t *testing.T) {
  1826  	v := SecurityAndAnalysis{
  1827  		AdvancedSecurity:             &AdvancedSecurity{},
  1828  		SecretScanning:               &SecretScanning{},
  1829  		SecretScanningPushProtection: &SecretScanningPushProtection{},
  1830  		DependabotSecurityUpdates:    &DependabotSecurityUpdates{},
  1831  		SecretScanningValidityChecks: &SecretScanningValidityChecks{},
  1832  	}
  1833  	want := `github.SecurityAndAnalysis{AdvancedSecurity:github.AdvancedSecurity{}, SecretScanning:github.SecretScanning{}, SecretScanningPushProtection:github.SecretScanningPushProtection{}, DependabotSecurityUpdates:github.DependabotSecurityUpdates{}, SecretScanningValidityChecks:github.SecretScanningValidityChecks{}}`
  1834  	if got := v.String(); got != want {
  1835  		t.Errorf("SecurityAndAnalysis.String = %v, want %v", got, want)
  1836  	}
  1837  }
  1838  
  1839  func TestSourceImportAuthor_String(t *testing.T) {
  1840  	v := SourceImportAuthor{
  1841  		ID:         Int64(0),
  1842  		RemoteID:   String(""),
  1843  		RemoteName: String(""),
  1844  		Email:      String(""),
  1845  		Name:       String(""),
  1846  		URL:        String(""),
  1847  		ImportURL:  String(""),
  1848  	}
  1849  	want := `github.SourceImportAuthor{ID:0, RemoteID:"", RemoteName:"", Email:"", Name:"", URL:"", ImportURL:""}`
  1850  	if got := v.String(); got != want {
  1851  		t.Errorf("SourceImportAuthor.String = %v, want %v", got, want)
  1852  	}
  1853  }
  1854  
  1855  func TestTeam_String(t *testing.T) {
  1856  	v := Team{
  1857  		ID:              Int64(0),
  1858  		NodeID:          String(""),
  1859  		Name:            String(""),
  1860  		Description:     String(""),
  1861  		URL:             String(""),
  1862  		Slug:            String(""),
  1863  		Permission:      String(""),
  1864  		Privacy:         String(""),
  1865  		MembersCount:    Int(0),
  1866  		ReposCount:      Int(0),
  1867  		Organization:    &Organization{},
  1868  		HTMLURL:         String(""),
  1869  		MembersURL:      String(""),
  1870  		RepositoriesURL: String(""),
  1871  		Parent:          &Team{},
  1872  		LDAPDN:          String(""),
  1873  	}
  1874  	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:""}`
  1875  	if got := v.String(); got != want {
  1876  		t.Errorf("Team.String = %v, want %v", got, want)
  1877  	}
  1878  }
  1879  
  1880  func TestTeamDiscussion_String(t *testing.T) {
  1881  	v := TeamDiscussion{
  1882  		Author:        &User{},
  1883  		Body:          String(""),
  1884  		BodyHTML:      String(""),
  1885  		BodyVersion:   String(""),
  1886  		CommentsCount: Int(0),
  1887  		CommentsURL:   String(""),
  1888  		CreatedAt:     &Timestamp{},
  1889  		LastEditedAt:  &Timestamp{},
  1890  		HTMLURL:       String(""),
  1891  		NodeID:        String(""),
  1892  		Number:        Int(0),
  1893  		Pinned:        Bool(false),
  1894  		Private:       Bool(false),
  1895  		TeamURL:       String(""),
  1896  		Title:         String(""),
  1897  		UpdatedAt:     &Timestamp{},
  1898  		URL:           String(""),
  1899  		Reactions:     &Reactions{},
  1900  	}
  1901  	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{}}`
  1902  	if got := v.String(); got != want {
  1903  		t.Errorf("TeamDiscussion.String = %v, want %v", got, want)
  1904  	}
  1905  }
  1906  
  1907  func TestTeamLDAPMapping_String(t *testing.T) {
  1908  	v := TeamLDAPMapping{
  1909  		ID:              Int64(0),
  1910  		LDAPDN:          String(""),
  1911  		URL:             String(""),
  1912  		Name:            String(""),
  1913  		Slug:            String(""),
  1914  		Description:     String(""),
  1915  		Privacy:         String(""),
  1916  		Permission:      String(""),
  1917  		MembersURL:      String(""),
  1918  		RepositoriesURL: String(""),
  1919  	}
  1920  	want := `github.TeamLDAPMapping{ID:0, LDAPDN:"", URL:"", Name:"", Slug:"", Description:"", Privacy:"", Permission:"", MembersURL:"", RepositoriesURL:""}`
  1921  	if got := v.String(); got != want {
  1922  		t.Errorf("TeamLDAPMapping.String = %v, want %v", got, want)
  1923  	}
  1924  }
  1925  
  1926  func TestTextMatch_String(t *testing.T) {
  1927  	v := TextMatch{
  1928  		ObjectURL:  String(""),
  1929  		ObjectType: String(""),
  1930  		Property:   String(""),
  1931  		Fragment:   String(""),
  1932  	}
  1933  	want := `github.TextMatch{ObjectURL:"", ObjectType:"", Property:"", Fragment:""}`
  1934  	if got := v.String(); got != want {
  1935  		t.Errorf("TextMatch.String = %v, want %v", got, want)
  1936  	}
  1937  }
  1938  
  1939  func TestTree_String(t *testing.T) {
  1940  	v := Tree{
  1941  		SHA:       String(""),
  1942  		Truncated: Bool(false),
  1943  	}
  1944  	want := `github.Tree{SHA:"", Truncated:false}`
  1945  	if got := v.String(); got != want {
  1946  		t.Errorf("Tree.String = %v, want %v", got, want)
  1947  	}
  1948  }
  1949  
  1950  func TestTreeEntry_String(t *testing.T) {
  1951  	v := TreeEntry{
  1952  		SHA:     String(""),
  1953  		Path:    String(""),
  1954  		Mode:    String(""),
  1955  		Type:    String(""),
  1956  		Size:    Int(0),
  1957  		Content: String(""),
  1958  		URL:     String(""),
  1959  	}
  1960  	want := `github.TreeEntry{SHA:"", Path:"", Mode:"", Type:"", Size:0, Content:"", URL:""}`
  1961  	if got := v.String(); got != want {
  1962  		t.Errorf("TreeEntry.String = %v, want %v", got, want)
  1963  	}
  1964  }
  1965  
  1966  func TestUser_String(t *testing.T) {
  1967  	v := User{
  1968  		Login:                   String(""),
  1969  		ID:                      Int64(0),
  1970  		NodeID:                  String(""),
  1971  		AvatarURL:               String(""),
  1972  		HTMLURL:                 String(""),
  1973  		GravatarID:              String(""),
  1974  		Name:                    String(""),
  1975  		Company:                 String(""),
  1976  		Blog:                    String(""),
  1977  		Location:                String(""),
  1978  		Email:                   String(""),
  1979  		Hireable:                Bool(false),
  1980  		Bio:                     String(""),
  1981  		TwitterUsername:         String(""),
  1982  		PublicRepos:             Int(0),
  1983  		PublicGists:             Int(0),
  1984  		Followers:               Int(0),
  1985  		Following:               Int(0),
  1986  		CreatedAt:               &Timestamp{},
  1987  		UpdatedAt:               &Timestamp{},
  1988  		SuspendedAt:             &Timestamp{},
  1989  		Type:                    String(""),
  1990  		SiteAdmin:               Bool(false),
  1991  		TotalPrivateRepos:       Int64(0),
  1992  		OwnedPrivateRepos:       Int64(0),
  1993  		PrivateGists:            Int(0),
  1994  		DiskUsage:               Int(0),
  1995  		Collaborators:           Int(0),
  1996  		TwoFactorAuthentication: Bool(false),
  1997  		Plan:                    &Plan{},
  1998  		LdapDn:                  String(""),
  1999  		URL:                     String(""),
  2000  		EventsURL:               String(""),
  2001  		FollowingURL:            String(""),
  2002  		FollowersURL:            String(""),
  2003  		GistsURL:                String(""),
  2004  		OrganizationsURL:        String(""),
  2005  		ReceivedEventsURL:       String(""),
  2006  		ReposURL:                String(""),
  2007  		StarredURL:              String(""),
  2008  		SubscriptionsURL:        String(""),
  2009  		RoleName:                String(""),
  2010  	}
  2011  	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:""}`
  2012  	if got := v.String(); got != want {
  2013  		t.Errorf("User.String = %v, want %v", got, want)
  2014  	}
  2015  }
  2016  
  2017  func TestUserLDAPMapping_String(t *testing.T) {
  2018  	v := UserLDAPMapping{
  2019  		ID:                Int64(0),
  2020  		LDAPDN:            String(""),
  2021  		Login:             String(""),
  2022  		AvatarURL:         String(""),
  2023  		GravatarID:        String(""),
  2024  		Type:              String(""),
  2025  		SiteAdmin:         Bool(false),
  2026  		URL:               String(""),
  2027  		EventsURL:         String(""),
  2028  		FollowingURL:      String(""),
  2029  		FollowersURL:      String(""),
  2030  		GistsURL:          String(""),
  2031  		OrganizationsURL:  String(""),
  2032  		ReceivedEventsURL: String(""),
  2033  		ReposURL:          String(""),
  2034  		StarredURL:        String(""),
  2035  		SubscriptionsURL:  String(""),
  2036  	}
  2037  	want := `github.UserLDAPMapping{ID:0, LDAPDN:"", Login:"", AvatarURL:"", GravatarID:"", Type:"", SiteAdmin:false, URL:"", EventsURL:"", FollowingURL:"", FollowersURL:"", GistsURL:"", OrganizationsURL:"", ReceivedEventsURL:"", ReposURL:"", StarredURL:"", SubscriptionsURL:""}`
  2038  	if got := v.String(); got != want {
  2039  		t.Errorf("UserLDAPMapping.String = %v, want %v", got, want)
  2040  	}
  2041  }
  2042  
  2043  func TestUserMigration_String(t *testing.T) {
  2044  	v := UserMigration{
  2045  		ID:                 Int64(0),
  2046  		GUID:               String(""),
  2047  		State:              String(""),
  2048  		LockRepositories:   Bool(false),
  2049  		ExcludeAttachments: Bool(false),
  2050  		URL:                String(""),
  2051  		CreatedAt:          String(""),
  2052  		UpdatedAt:          String(""),
  2053  	}
  2054  	want := `github.UserMigration{ID:0, GUID:"", State:"", LockRepositories:false, ExcludeAttachments:false, URL:"", CreatedAt:"", UpdatedAt:""}`
  2055  	if got := v.String(); got != want {
  2056  		t.Errorf("UserMigration.String = %v, want %v", got, want)
  2057  	}
  2058  }
  2059  
  2060  func TestUserStats_String(t *testing.T) {
  2061  	v := UserStats{
  2062  		TotalUsers:     Int(0),
  2063  		AdminUsers:     Int(0),
  2064  		SuspendedUsers: Int(0),
  2065  	}
  2066  	want := `github.UserStats{TotalUsers:0, AdminUsers:0, SuspendedUsers:0}`
  2067  	if got := v.String(); got != want {
  2068  		t.Errorf("UserStats.String = %v, want %v", got, want)
  2069  	}
  2070  }
  2071  
  2072  func TestWeeklyCommitActivity_String(t *testing.T) {
  2073  	v := WeeklyCommitActivity{
  2074  		Days:  []int{0},
  2075  		Total: Int(0),
  2076  		Week:  &Timestamp{},
  2077  	}
  2078  	want := `github.WeeklyCommitActivity{Days:[0], Total:0, Week:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}}`
  2079  	if got := v.String(); got != want {
  2080  		t.Errorf("WeeklyCommitActivity.String = %v, want %v", got, want)
  2081  	}
  2082  }
  2083  
  2084  func TestWeeklyStats_String(t *testing.T) {
  2085  	v := WeeklyStats{
  2086  		Week:      &Timestamp{},
  2087  		Additions: Int(0),
  2088  		Deletions: Int(0),
  2089  		Commits:   Int(0),
  2090  	}
  2091  	want := `github.WeeklyStats{Week:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, Additions:0, Deletions:0, Commits:0}`
  2092  	if got := v.String(); got != want {
  2093  		t.Errorf("WeeklyStats.String = %v, want %v", got, want)
  2094  	}
  2095  }