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