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

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