.config/coc/extensions/coc-go-data/tools/pkg/mod/golang.org/x/mod@v0.3.0/modfile/rule_test.go

   1 // Copyright 2018 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 package modfile
   6
   7 import (
   8         "bytes"
   9         "fmt"
  10         "testing"
  11
  12         "golang.org/x/mod/module"
  13 )
  14
  15 var addRequireTests = []struct {
  16         in   string
  17         path string
  18         vers string
  19         out  string
  20 }{
  21         {
  22                 `
  23                 module m
  24                 require x.y/z v1.2.3
  25                 `,
  26                 "x.y/z", "v1.5.6",
  27                 `
  28                 module m
  29                 require x.y/z v1.5.6
  30                 `,
  31         },
  32         {
  33                 `
  34                 module m
  35                 require x.y/z v1.2.3
  36                 `,
  37                 "x.y/w", "v1.5.6",
  38                 `
  39                 module m
  40                 require (
  41                         x.y/z v1.2.3
  42                         x.y/w v1.5.6
  43                 )
  44                 `,
  45         },
  46         {
  47                 `
  48                 module m
  49                 require x.y/z v1.2.3
  50                 require x.y/q/v2 v2.3.4
  51                 `,
  52                 "x.y/w", "v1.5.6",
  53                 `
  54                 module m
  55                 require x.y/z v1.2.3
  56                 require (
  57                         x.y/q/v2 v2.3.4
  58                         x.y/w v1.5.6
  59                 )
  60                 `,
  61         },
  62 }
  63
  64 var setRequireTests = []struct {
  65         in   string
  66         mods []struct {
  67                 path     string
  68                 vers     string
  69                 indirect bool
  70         }
  71         out string
  72 }{
  73         {
  74                 `module m
  75                 require (
  76                         x.y/b v1.2.3
  77
  78                         x.y/a v1.2.3
  79                         x.y/d v1.2.3
  80                 )
  81                 `,
  82                 []struct {
  83                         path     string
  84                         vers     string
  85                         indirect bool
  86                 }{
  87                         {"x.y/a", "v1.2.3", false},
  88                         {"x.y/b", "v1.2.3", false},
  89                         {"x.y/c", "v1.2.3", false},
  90                 },
  91                 `module m
  92                 require (
  93                         x.y/a v1.2.3
  94                         x.y/b v1.2.3
  95                         x.y/c v1.2.3
  96                 )
  97                 `,
  98         },
  99         {
 100                 `module m
 101                 require (
 102                         x.y/a v1.2.3
 103                         x.y/b v1.2.3 //
 104                         x.y/c v1.2.3 //c
 105                         x.y/d v1.2.3 //   c
 106                         x.y/e v1.2.3 // indirect
 107                         x.y/f v1.2.3 //indirect
 108                         x.y/g v1.2.3 // indirect
 109                 )
 110                 `,
 111                 []struct {
 112                         path     string
 113                         vers     string
 114                         indirect bool
 115                 }{
 116                         {"x.y/a", "v1.2.3", true},
 117                         {"x.y/b", "v1.2.3", true},
 118                         {"x.y/c", "v1.2.3", true},
 119                         {"x.y/d", "v1.2.3", true},
 120                         {"x.y/e", "v1.2.3", true},
 121                         {"x.y/f", "v1.2.3", true},
 122                         {"x.y/g", "v1.2.3", true},
 123                 },
 124                 `module m
 125                 require (
 126                         x.y/a v1.2.3 // indirect
 127                         x.y/b v1.2.3 // indirect
 128                         x.y/c v1.2.3 // indirect; c
 129                         x.y/d v1.2.3 // indirect; c
 130                         x.y/e v1.2.3 // indirect
 131                         x.y/f v1.2.3 //indirect
 132                         x.y/g v1.2.3 // indirect
 133                 )
 134                 `,
 135         },
 136 }
 137
 138 var addGoTests = []struct {
 139         in      string
 140         version string
 141         out     string
 142 }{
 143         {`module m
 144                 `,
 145                 `1.14`,
 146                 `module m
 147                 go 1.14
 148                 `,
 149         },
 150         {`module m
 151                 require x.y/a v1.2.3
 152                 `,
 153                 `1.14`,
 154                 `module m
 155                 go 1.14
 156                 require x.y/a v1.2.3
 157                 `,
 158         },
 159         {
 160                 `require x.y/a v1.2.3
 161                 module example.com/inverted
 162                 `,
 163                 `1.14`,
 164                 `require x.y/a v1.2.3
 165                 module example.com/inverted
 166                 go 1.14
 167                 `,
 168         },
 169         {
 170                 `require x.y/a v1.2.3
 171                 `,
 172                 `1.14`,
 173                 `require x.y/a v1.2.3
 174                 go 1.14
 175                 `,
 176         },
 177 }
 178
 179 func TestAddRequire(t *testing.T) {
 180         for i, tt := range addRequireTests {
 181                 t.Run(fmt.Sprintf("#%d", i), func(t *testing.T) {
 182                         f, err := Parse("in", []byte(tt.in), nil)
 183                         if err != nil {
 184                                 t.Fatal(err)
 185                         }
 186                         g, err := Parse("out", []byte(tt.out), nil)
 187                         if err != nil {
 188                                 t.Fatal(err)
 189                         }
 190                         golden, err := g.Format()
 191                         if err != nil {
 192                                 t.Fatal(err)
 193                         }
 194
 195                         if err := f.AddRequire(tt.path, tt.vers); err != nil {
 196                                 t.Fatal(err)
 197                         }
 198                         out, err := f.Format()
 199                         if err != nil {
 200                                 t.Fatal(err)
 201                         }
 202                         if !bytes.Equal(out, golden) {
 203                                 t.Errorf("have:\n%s\nwant:\n%s", out, golden)
 204                         }
 205                 })
 206         }
 207 }
 208
 209 func TestSetRequire(t *testing.T) {
 210         for i, tt := range setRequireTests {
 211                 t.Run(fmt.Sprintf("#%d", i), func(t *testing.T) {
 212                         f, err := Parse("in", []byte(tt.in), nil)
 213                         if err != nil {
 214                                 t.Fatal(err)
 215                         }
 216                         g, err := Parse("out", []byte(tt.out), nil)
 217                         if err != nil {
 218                                 t.Fatal(err)
 219                         }
 220                         golden, err := g.Format()
 221                         if err != nil {
 222                                 t.Fatal(err)
 223                         }
 224                         var mods []*Require
 225                         for _, mod := range tt.mods {
 226                                 mods = append(mods, &Require{
 227                                         Mod: module.Version{
 228                                                 Path:    mod.path,
 229                                                 Version: mod.vers,
 230                                         },
 231                                         Indirect: mod.indirect,
 232                                 })
 233                         }
 234
 235                         f.SetRequire(mods)
 236                         out, err := f.Format()
 237                         if err != nil {
 238                                 t.Fatal(err)
 239                         }
 240                         if !bytes.Equal(out, golden) {
 241                                 t.Errorf("have:\n%s\nwant:\n%s", out, golden)
 242                         }
 243
 244                         f.Cleanup()
 245                         if len(f.Require) != len(mods) {
 246                                 t.Errorf("after Cleanup, len(Require) = %v; want %v", len(f.Require), len(mods))
 247                         }
 248                 })
 249         }
 250 }
 251
 252 func TestAddGo(t *testing.T) {
 253         for i, tt := range addGoTests {
 254                 t.Run(fmt.Sprintf("#%d", i), func(t *testing.T) {
 255                         f, err := Parse("in", []byte(tt.in), nil)
 256                         if err != nil {
 257                                 t.Fatal(err)
 258                         }
 259                         g, err := Parse("out", []byte(tt.out), nil)
 260                         if err != nil {
 261                                 t.Fatal(err)
 262                         }
 263                         golden, err := g.Format()
 264                         if err != nil {
 265                                 t.Fatal(err)
 266                         }
 267
 268                         if err := f.AddGoStmt(tt.version); err != nil {
 269                                 t.Fatal(err)
 270                         }
 271                         out, err := f.Format()
 272                         if err != nil {
 273                                 t.Fatal(err)
 274                         }
 275                         if !bytes.Equal(out, golden) {
 276                                 t.Errorf("have:\n%s\nwant:\n%s", out, golden)
 277                         }
 278                 })
 279         }
 280 }