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