+func Test(t *testing.T) {

3052 · 3052 · commit beb30b97bd66 · 2025-07-12T00:06:55.000-05:00
diff --git a/canal/canal_test.go b/canal/canal_test.go
@@ -23,8 +23,6 @@ var tests = []struct {
    },
 }
 
-func TestAssets(t *testing.T) {
-   for _, test1 := range tests {
-      fmt.Println(test1.url)
-   }
+func Test(t *testing.T) {
+   fmt.Println(tests)
 }
diff --git a/cineMember/cineMember.go b/cineMember/cineMember.go
@@ -48,9 +48,9 @@ query Article($articleUrlSlug: String) {
 ` // do not use `query(`
 
 func (a *Article) Film() (*Asset, bool) {
-   for _, asset1 := range a.Assets {
-      if asset1.LinkedType == "film" {
-         return &asset1, true
+   for _, assetVar := range a.Assets {
+      if assetVar.LinkedType == "film" {
+         return &assetVar, true
       }
    }
    return nil, false
@@ -157,12 +157,12 @@ type User struct {
 }
 
 // hard geo block
-func (u User) Play(article1 *Article, asset1 *Asset) (Byte[Play], error) {
+func (u User) Play(articleVar *Article, assetVar *Asset) (Byte[Play], error) {
    data, err := json.Marshal(map[string]any{
       "query": query_asset,
       "variables": map[string]int{
-         "article_id": article1.Id,
-         "asset_id": asset1.Id,
+         "article_id": articleVar.Id,
+         "asset_id": assetVar.Id,
       },
    })
    if err != nil {
diff --git a/criterion/criterion.go b/criterion/criterion.go
@@ -42,9 +42,9 @@ type File struct {
 type Files []File
 
 func (f Files) Dash() (*File, bool) {
-   for _, file1 := range f {
-      if file1.Method == "dash" {
-         return &file1, true
+   for _, fileVar := range f {
+      if fileVar.Method == "dash" {
+         return &fileVar, true
       }
    }
    return nil, false
@@ -64,15 +64,15 @@ func (t *Token) Video(slug string) (*Video, error) {
       return nil, err
    }
    defer resp.Body.Close()
-   var video1 Video
-   err = json.NewDecoder(resp.Body).Decode(&video1)
+   var videoVar Video
+   err = json.NewDecoder(resp.Body).Decode(&videoVar)
    if err != nil {
       return nil, err
    }
-   if video1.Message != "" {
-      return nil, errors.New(video1.Message)
+   if videoVar.Message != "" {
+      return nil, errors.New(videoVar.Message)
    }
-   return &video1, nil
+   return &videoVar, nil
 }
 
 type Token struct {
@@ -111,8 +111,8 @@ func (t *Token) Unmarshal(data Byte[Token]) error {
    return json.Unmarshal(data, t)
 }
 
-func (t *Token) Files(video1 *Video) (Byte[Files], error) {
-   req, err := http.NewRequest("", video1.Links.Files.Href, nil)
+func (t *Token) Files(videoVar *Video) (Byte[Files], error) {
+   req, err := http.NewRequest("", videoVar.Links.Files.Href, nil)
    if err != nil {
       return nil, err
    }
diff --git a/criterion/criterion_test.go b/criterion/criterion_test.go
@@ -28,13 +28,13 @@ func Test(t *testing.T) {
    if err != nil {
       t.Fatal(err)
    }
-   var token1 Token
-   err = token1.Unmarshal(data)
+   var tokenVar Token
+   err = tokenVar.Unmarshal(data)
    if err != nil {
       t.Fatal(err)
    }
-   for _, test1 := range tests {
-      _, err = token1.Video(test1.slug)
+   for _, testVar := range tests {
+      _, err = tokenVar.Video(testVar.slug)
       if err != nil {
          t.Fatal(err)
       }
diff --git a/ctv/ctv.go b/ctv/ctv.go
@@ -10,15 +10,15 @@ import (
    "strings"
 )
 
-func (a *AxisContent) Mpd(content1 *Content) (string, error) {
+func (a *AxisContent) Mpd(contentVar *Content) (string, error) {
    req, _ := http.NewRequest("", "https://capi.9c9media.com", nil)
    req.URL.Path = func() string {
       b := []byte("/destinations/")
       b = append(b, a.AxisPlaybackLanguages[0].DestinationCode...)
       b = append(b, "/platforms/desktop/playback/contents/"...)
       b = strconv.AppendInt(b, a.AxisId, 10)
       b = append(b, "/contentPackages/"...)
-      b = strconv.AppendInt(b, content1.ContentPackages[0].Id, 10)
+      b = strconv.AppendInt(b, contentVar.ContentPackages[0].Id, 10)
       b = append(b, "/manifest.mpd"...)
       return string(b)
    }()
@@ -111,12 +111,12 @@ func (a *AxisContent) Content() (*Content, error) {
       return nil, err
    }
    defer resp.Body.Close()
-   content1 := &Content{}
-   err = json.NewDecoder(resp.Body).Decode(content1)
+   contentVar := &Content{}
+   err = json.NewDecoder(resp.Body).Decode(contentVar)
    if err != nil {
       return nil, err
    }
-   return content1, nil
+   return contentVar, nil
 }
 
 type Content struct {
diff --git a/ctv/ctv_test.go b/ctv/ctv_test.go
@@ -19,8 +19,8 @@ var tests = []struct {
 }
 
 func Test(t *testing.T) {
-   for _, test1 := range tests {
-      _, err := Address(test1.path).Resolve()
+   for _, testVar := range tests {
+      _, err := Address(testVar.path).Resolve()
       if err != nil {
          t.Fatal(err)
       }
diff --git a/draken/draken.go b/draken/draken.go
@@ -64,10 +64,10 @@ func (n *Login) Unmarshal(data Byte[Login]) error {
 }
 
 func (n Login) Playback(
-   movie1 *Movie, title *Entitlement,
+   movieVar *Movie, title *Entitlement,
 ) (Byte[Playback], error) {
    req, _ := http.NewRequest("POST", "https://client-api.magine.com", nil)
-   req.URL.Path = "/api/playback/v1/preflight/asset/" + movie1.Id
+   req.URL.Path = "/api/playback/v1/preflight/asset/" + movieVar.Id
    magine_accesstoken.set(req.Header)
    magine_play_devicemodel.set(req.Header)
    magine_play_deviceplatform.set(req.Header)
@@ -107,9 +107,9 @@ func (n Login) Widevine(play *Playback, data []byte) ([]byte, error) {
    return io.ReadAll(resp.Body)
 }
 
-func (n Login) Entitlement(movie1 Movie) (*Entitlement, error) {
+func (n Login) Entitlement(movieVar Movie) (*Entitlement, error) {
    req, _ := http.NewRequest("POST", "https://client-api.magine.com", nil)
-   req.URL.Path = "/api/entitlement/v2/asset/" + movie1.Id
+   req.URL.Path = "/api/entitlement/v2/asset/" + movieVar.Id
    req.Header.Set("authorization", "Bearer "+n.Token)
    magine_accesstoken.set(req.Header)
    resp, err := http.DefaultClient.Do(req)
diff --git a/draken/draken_test.go b/draken/draken_test.go
@@ -20,9 +20,9 @@ var tests = []struct {
 }
 
 func Test(t *testing.T) {
-   for _, test1 := range tests {
-      var movie1 Movie
-      err := movie1.New(test1.custom_id)
+   for _, testVar := range tests {
+      var movieVar Movie
+      err := movieVar.New(testVar.custom_id)
       if err != nil {
          t.Fatal(err)
       }
diff --git a/kanopy/kanopy_test.go b/kanopy/kanopy_test.go
@@ -31,17 +31,17 @@ func Test(t *testing.T) {
    if err != nil {
       t.Fatal(err)
    }
-   var login1 Login
-   err = login1.Unmarshal(data)
+   var loginVar Login
+   err = loginVar.Unmarshal(data)
    if err != nil {
       t.Fatal(err)
    }
-   member, err := login1.Membership()
+   member, err := loginVar.Membership()
    if err != nil {
       t.Fatal(err)
    }
-   for _, test1 := range tests {
-      _, err = login1.Plays(member, test1.video_id)
+   for _, testVar := range tests {
+      _, err = loginVar.Plays(member, testVar.video_id)
       if err != nil {
          t.Fatal(err)
       }
diff --git a/max/max.go b/max/max.go
@@ -291,11 +291,11 @@ func (v *Video) String() string {
 
 func (v *Videos) Seq() iter.Seq[*Video] {
    return func(yield func(*Video) bool) {
-      for _, video1 := range v.Included {
-         if video1.Attributes != nil {
-            switch video1.Attributes.VideoType {
+      for _, videoVar := range v.Included {
+         if videoVar.Attributes != nil {
+            switch videoVar.Attributes.VideoType {
             case "EPISODE", "MOVIE":
-               if !yield(&video1) {
+               if !yield(&videoVar) {
                   return
                }
             }
diff --git a/max/max_test.go b/max/max_test.go
@@ -77,13 +77,13 @@ func TestPlayReady(t *testing.T) {
    if err != nil {
       t.Fatal(err)
    }
-   var login1 Login
-   err = login1.Unmarshal(data)
+   var loginVar Login
+   err = loginVar.Unmarshal(data)
    if err != nil {
       t.Fatal(err)
    }
    // max.com/movies/dune/e7dc7b3a-a494-4ef1-8107-f4308aa6bbf7
-   data, err = login1.PlayReady("06a38397-862d-4419-be84-0641939825e7")
+   data, err = loginVar.PlayReady("06a38397-862d-4419-be84-0641939825e7")
    if err != nil {
       t.Fatal(err)
    }
diff --git a/molotov/molotov.go b/molotov/molotov.go
@@ -115,8 +115,8 @@ type Login struct {
    Auth Refresh
 }
 
-func (r *Refresh) Asset(view1 *View) (Byte[Asset], error) {
-   req, err := http.NewRequest("", view1.Program.Actions.Play.Url, nil)
+func (r *Refresh) Asset(viewVar *View) (Byte[Asset], error) {
+   req, err := http.NewRequest("", viewVar.Program.Actions.Play.Url, nil)
    if err != nil {
       return nil, err
    }
diff --git a/mubi/mubi.go b/mubi/mubi.go
@@ -76,11 +76,11 @@ const client = "web"
 
 // to get the MPD you have to call this or view video on the website. request
 // is hard geo blocked only the first time
-func (a *Authenticate) Viewing(film1 *Film) error {
+func (a *Authenticate) Viewing(filmVar *Film) error {
    req, _ := http.NewRequest("POST", "https://api.mubi.com", nil)
    req.URL.Path = func() string {
       b := []byte("/v3/films/")
-      b = strconv.AppendInt(b, film1.Id, 10)
+      b = strconv.AppendInt(b, filmVar.Id, 10)
       b = append(b, "/viewing"...)
       return string(b)
    }()
@@ -188,11 +188,11 @@ func (s *SecureUrl) Unmarshal(data Byte[SecureUrl]) error {
    }
    return nil
 }
-func (a *Authenticate) SecureUrl(film1 *Film) (Byte[SecureUrl], error) {
+func (a *Authenticate) SecureUrl(filmVar *Film) (Byte[SecureUrl], error) {
    req, _ := http.NewRequest("", "https://api.mubi.com", nil)
    req.URL.Path = func() string {
       b := []byte("/v3/films/")
-      b = strconv.AppendInt(b, film1.Id, 10)
+      b = strconv.AppendInt(b, filmVar.Id, 10)
       b = append(b, "/viewing/secure_url"...)
       return string(b)
    }()
@@ -239,10 +239,10 @@ func (s Slug) Film() (*Film, error) {
       return nil, err
    }
    defer resp.Body.Close()
-   film1 := &Film{}
-   err = json.NewDecoder(resp.Body).Decode(film1)
+   filmVar := &Film{}
+   err = json.NewDecoder(resp.Body).Decode(filmVar)
    if err != nil {
       return nil, err
    }
-   return film1, nil
+   return filmVar, nil
 }
diff --git a/mubi/mubi_test.go b/mubi/mubi_test.go
@@ -60,8 +60,8 @@ func Test(t *testing.T) {
    if err != nil {
       t.Fatal(err)
    }
-   for _, test1 := range tests {
-      data, err := auth.SecureUrl(&Film{Id: test1.id})
+   for _, testVar := range tests {
+      data, err := auth.SecureUrl(&Film{Id: testVar.id})
       if err != nil {
          t.Fatal(err)
       }
diff --git a/plex/plex.go b/plex/plex.go
@@ -70,8 +70,8 @@ func NewUser() (Byte[User], error) {
    return io.ReadAll(resp.Body)
 }
 
-func (u User) Widevine(part1 *Part, data []byte) ([]byte, error) {
-   req, err := http.NewRequest("POST", part1.License, bytes.NewReader(data))
+func (u User) Widevine(partVar *Part, data []byte) ([]byte, error) {
+   req, err := http.NewRequest("POST", partVar.License, bytes.NewReader(data))
    if err != nil {
       return nil, err
    }
@@ -89,8 +89,8 @@ func (u User) Widevine(part1 *Part, data []byte) ([]byte, error) {
    return io.ReadAll(resp.Body)
 }
 
-func (u User) Mpd(part1 *Part) (*http.Response, error) {
-   req, err := http.NewRequest("", part1.Key, nil)
+func (u User) Mpd(partVar *Part) (*http.Response, error) {
+   req, err := http.NewRequest("", partVar.Key, nil)
    if err != nil {
       return nil, err
    }
diff --git a/plex/plex_test.go b/plex/plex_test.go
@@ -36,8 +36,8 @@ func Test(t *testing.T) {
    if err != nil {
       t.Fatal(err)
    }
-   for _, test1 := range watch_tests {
-      match, err := userVar.Match(Url{test1.path})
+   for _, watch_test := range watch_tests {
+      match, err := userVar.Match(Url{watch_test.path})
       if err != nil {
          t.Fatal(err)
       }

Original file line number	Diff line number	Diff line change
`@@ -23,8 +23,6 @@ var tests = []struct {`
`23`	`23`	`},`
`24`	`24`	`}`
`25`	`25`
`26`		`-func TestAssets(t *testing.T) {`
`27`		`- for _, test1 := range tests {`
`28`		`- fmt.Println(test1.url)`
`29`		`- }`
	`26`	`+func Test(t *testing.T) {`
	`27`	`+ fmt.Println(tests)`
`30`	`28`	`}`
Original file line number	Diff line number	Diff line change
`@@ -42,9 +42,9 @@ type File struct {`
`42`	`42`	`type Files []File`
`43`	`43`
`44`	`44`	`func (f Files) Dash() (*File, bool) {`
`45`		`- for _, file1 := range f {`
`46`		`- if file1.Method == "dash" {`
`47`		`- return &file1, true`
	`45`	`+ for _, fileVar := range f {`
	`46`	`+ if fileVar.Method == "dash" {`
	`47`	`+ return &fileVar, true`
`48`	`48`	`}`
`49`	`49`	`}`
`50`	`50`	`return nil, false`
`@@ -64,15 +64,15 @@ func (t Token) Video(slug string) (Video, error) {`
`64`	`64`	`return nil, err`
`65`	`65`	`}`
`66`	`66`	`defer resp.Body.Close()`
`67`		`- var video1 Video`
`68`		`- err = json.NewDecoder(resp.Body).Decode(&video1)`
	`67`	`+ var videoVar Video`
	`68`	`+ err = json.NewDecoder(resp.Body).Decode(&videoVar)`
`69`	`69`	`if err != nil {`
`70`	`70`	`return nil, err`
`71`	`71`	`}`
`72`		`- if video1.Message != "" {`
`73`		`- return nil, errors.New(video1.Message)`
	`72`	`+ if videoVar.Message != "" {`
	`73`	`+ return nil, errors.New(videoVar.Message)`
`74`	`74`	`}`
`75`		`- return &video1, nil`
	`75`	`+ return &videoVar, nil`
`76`	`76`	`}`
`77`	`77`
`78`	`78`	`type Token struct {`
`@@ -111,8 +111,8 @@ func (t *Token) Unmarshal(data Byte[Token]) error {`
`111`	`111`	`return json.Unmarshal(data, t)`
`112`	`112`	`}`
`113`	`113`
`114`		`-func (t Token) Files(video1 Video) (Byte[Files], error) {`
`115`		`- req, err := http.NewRequest("", video1.Links.Files.Href, nil)`
	`114`	`+func (t Token) Files(videoVar Video) (Byte[Files], error) {`
	`115`	`+ req, err := http.NewRequest("", videoVar.Links.Files.Href, nil)`
`116`	`116`	`if err != nil {`
`117`	`117`	`return nil, err`
`118`	`118`	`}`
Original file line number	Diff line number	Diff line change
`@@ -28,13 +28,13 @@ func Test(t *testing.T) {`
`28`	`28`	`if err != nil {`
`29`	`29`	`t.Fatal(err)`
`30`	`30`	`}`
`31`		`- var token1 Token`
`32`		`- err = token1.Unmarshal(data)`
	`31`	`+ var tokenVar Token`
	`32`	`+ err = tokenVar.Unmarshal(data)`
`33`	`33`	`if err != nil {`
`34`	`34`	`t.Fatal(err)`
`35`	`35`	`}`
`36`		`- for _, test1 := range tests {`
`37`		`- _, err = token1.Video(test1.slug)`
	`36`	`+ for _, testVar := range tests {`
	`37`	`+ _, err = tokenVar.Video(testVar.slug)`
`38`	`38`	`if err != nil {`
`39`	`39`	`t.Fatal(err)`
`40`	`40`	`}`
Original file line number	Diff line number	Diff line change
`@@ -19,8 +19,8 @@ var tests = []struct {`
`19`	`19`	`}`
`20`	`20`
`21`	`21`	`func Test(t *testing.T) {`
`22`		`- for _, test1 := range tests {`
`23`		`- _, err := Address(test1.path).Resolve()`
	`22`	`+ for _, testVar := range tests {`
	`23`	`+ _, err := Address(testVar.path).Resolve()`
`24`	`24`	`if err != nil {`
`25`	`25`	`t.Fatal(err)`
`26`	`26`	`}`
Original file line number	Diff line number	Diff line change
`@@ -20,9 +20,9 @@ var tests = []struct {`
`20`	`20`	`}`
`21`	`21`
`22`	`22`	`func Test(t *testing.T) {`
`23`		`- for _, test1 := range tests {`
`24`		`- var movie1 Movie`
`25`		`- err := movie1.New(test1.custom_id)`
	`23`	`+ for _, testVar := range tests {`
	`24`	`+ var movieVar Movie`
	`25`	`+ err := movieVar.New(testVar.custom_id)`
`26`	`26`	`if err != nil {`
`27`	`27`	`t.Fatal(err)`
`28`	`28`	`}`
Original file line number	Diff line number	Diff line change
`@@ -31,17 +31,17 @@ func Test(t *testing.T) {`
`31`	`31`	`if err != nil {`
`32`	`32`	`t.Fatal(err)`
`33`	`33`	`}`
`34`		`- var login1 Login`
`35`		`- err = login1.Unmarshal(data)`
	`34`	`+ var loginVar Login`
	`35`	`+ err = loginVar.Unmarshal(data)`
`36`	`36`	`if err != nil {`
`37`	`37`	`t.Fatal(err)`
`38`	`38`	`}`
`39`		`- member, err := login1.Membership()`
	`39`	`+ member, err := loginVar.Membership()`
`40`	`40`	`if err != nil {`
`41`	`41`	`t.Fatal(err)`
`42`	`42`	`}`
`43`		`- for _, test1 := range tests {`
`44`		`- _, err = login1.Plays(member, test1.video_id)`
	`43`	`+ for _, testVar := range tests {`
	`44`	`+ _, err = loginVar.Plays(member, testVar.video_id)`
`45`	`45`	`if err != nil {`
`46`	`46`	`t.Fatal(err)`
`47`	`47`	`}`