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