export.go

Documentation: golang.org/x/tools/go/packages/packagestest

     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  /*
     6  Package packagestest creates temporary projects on disk for testing go tools on.
     7  
     8  By changing the exporter used, you can create projects for multiple build
     9  systems from the same description, and run the same tests on them in many
    10  cases.
    11  
    12  # Example
    13  
    14  As an example of packagestest use, consider the following test that runs
    15  the 'go list' command on the specified modules:
    16  
    17  	// TestGoList exercises the 'go list' command in module mode and in GOPATH mode.
    18  	func TestGoList(t *testing.T) { packagestest.TestAll(t, testGoList) }
    19  	func testGoList(t *testing.T, x packagestest.Exporter) {
    20  		e := packagestest.Export(t, x, []packagestest.Module{
    21  			{
    22  				Name: "gopher.example/repoa",
    23  				Files: map[string]interface{}{
    24  					"a/a.go": "package a",
    25  				},
    26  			},
    27  			{
    28  				Name: "gopher.example/repob",
    29  				Files: map[string]interface{}{
    30  					"b/b.go": "package b",
    31  				},
    32  			},
    33  		})
    34  		defer e.Cleanup()
    35  
    36  		cmd := exec.Command("go", "list", "gopher.example/...")
    37  		cmd.Dir = e.Config.Dir
    38  		cmd.Env = e.Config.Env
    39  		out, err := cmd.Output()
    40  		if err != nil {
    41  			t.Fatal(err)
    42  		}
    43  		t.Logf("'go list gopher.example/...' with %s mode layout:\n%s", x.Name(), out)
    44  	}
    45  
    46  TestGoList uses TestAll to exercise the 'go list' command with all
    47  exporters known to packagestest. Currently, packagestest includes
    48  exporters that produce module mode layouts and GOPATH mode layouts.
    49  Running the test with verbose output will print:
    50  
    51  	=== RUN   TestGoList
    52  	=== RUN   TestGoList/GOPATH
    53  	=== RUN   TestGoList/Modules
    54  	--- PASS: TestGoList (0.21s)
    55  	    --- PASS: TestGoList/GOPATH (0.03s)
    56  	        main_test.go:36: 'go list gopher.example/...' with GOPATH mode layout:
    57  	            gopher.example/repoa/a
    58  	            gopher.example/repob/b
    59  	    --- PASS: TestGoList/Modules (0.18s)
    60  	        main_test.go:36: 'go list gopher.example/...' with Modules mode layout:
    61  	            gopher.example/repoa/a
    62  	            gopher.example/repob/b
    63  */
    64  package packagestest
    65  
    66  import (
    67  	"errors"
    68  	"flag"
    69  	"fmt"
    70  	"go/token"
    71  	"io"
    72  	"io/ioutil"
    73  	"log"
    74  	"os"
    75  	"path/filepath"
    76  	"runtime"
    77  	"strings"
    78  	"testing"
    79  
    80  	"golang.org/x/tools/go/expect"
    81  	"golang.org/x/tools/go/packages"
    82  	"golang.org/x/tools/internal/testenv"
    83  )
    84  
    85  var (
    86  	skipCleanup = flag.Bool("skip-cleanup", false, "Do not delete the temporary export folders") // for debugging
    87  )
    88  
    89  // ErrUnsupported indicates an error due to an operation not supported on the
    90  // current platform.
    91  var ErrUnsupported = errors.New("operation is not supported")
    92  
    93  // Module is a representation of a go module.
    94  type Module struct {
    95  	// Name is the base name of the module as it would be in the go.mod file.
    96  	Name string
    97  	// Files is the set of source files for all packages that make up the module.
    98  	// The keys are the file fragment that follows the module name, the value can
    99  	// be a string or byte slice, in which case it is the contents of the
   100  	// file, otherwise it must be a Writer function.
   101  	Files map[string]interface{}
   102  
   103  	// Overlay is the set of source file overlays for the module.
   104  	// The keys are the file fragment as in the Files configuration.
   105  	// The values are the in memory overlay content for the file.
   106  	Overlay map[string][]byte
   107  }
   108  
   109  // A Writer is a function that writes out a test file.
   110  // It is provided the name of the file to write, and may return an error if it
   111  // cannot write the file.
   112  // These are used as the content of the Files map in a Module.
   113  type Writer func(filename string) error
   114  
   115  // Exported is returned by the Export function to report the structure that was produced on disk.
   116  type Exported struct {
   117  	// Config is a correctly configured packages.Config ready to be passed to packages.Load.
   118  	// Exactly what it will contain varies depending on the Exporter being used.
   119  	Config *packages.Config
   120  
   121  	// Modules is the module description that was used to produce this exported data set.
   122  	Modules []Module
   123  
   124  	ExpectFileSet *token.FileSet // The file set used when parsing expectations
   125  
   126  	Exporter Exporter                     // the exporter used
   127  	temp     string                       // the temporary directory that was exported to
   128  	primary  string                       // the first non GOROOT module that was exported
   129  	written  map[string]map[string]string // the full set of exported files
   130  	notes    []*expect.Note               // The list of expectations extracted from go source files
   131  	markers  map[string]Range             // The set of markers extracted from go source files
   132  }
   133  
   134  // Exporter implementations are responsible for converting from the generic description of some
   135  // test data to a driver specific file layout.
   136  type Exporter interface {
   137  	// Name reports the name of the exporter, used in logging and sub-test generation.
   138  	Name() string
   139  	// Filename reports the system filename for test data source file.
   140  	// It is given the base directory, the module the file is part of and the filename fragment to
   141  	// work from.
   142  	Filename(exported *Exported, module, fragment string) string
   143  	// Finalize is called once all files have been written to write any extra data needed and modify
   144  	// the Config to match. It is handed the full list of modules that were encountered while writing
   145  	// files.
   146  	Finalize(exported *Exported) error
   147  }
   148  
   149  // All is the list of known exporters.
   150  // This is used by TestAll to run tests with all the exporters.
   151  var All []Exporter
   152  
   153  // TestAll invokes the testing function once for each exporter registered in
   154  // the All global.
   155  // Each exporter will be run as a sub-test named after the exporter being used.
   156  func TestAll(t *testing.T, f func(*testing.T, Exporter)) {
   157  	t.Helper()
   158  	for _, e := range All {
   159  		e := e // in case f calls t.Parallel
   160  		t.Run(e.Name(), func(t *testing.T) {
   161  			t.Helper()
   162  			f(t, e)
   163  		})
   164  	}
   165  }
   166  
   167  // BenchmarkAll invokes the testing function once for each exporter registered in
   168  // the All global.
   169  // Each exporter will be run as a sub-test named after the exporter being used.
   170  func BenchmarkAll(b *testing.B, f func(*testing.B, Exporter)) {
   171  	b.Helper()
   172  	for _, e := range All {
   173  		e := e // in case f calls t.Parallel
   174  		b.Run(e.Name(), func(b *testing.B) {
   175  			b.Helper()
   176  			f(b, e)
   177  		})
   178  	}
   179  }
   180  
   181  // Export is called to write out a test directory from within a test function.
   182  // It takes the exporter and the build system agnostic module descriptions, and
   183  // uses them to build a temporary directory.
   184  // It returns an Exported with the results of the export.
   185  // The Exported.Config is prepared for loading from the exported data.
   186  // You must invoke Exported.Cleanup on the returned value to clean up.
   187  // The file deletion in the cleanup can be skipped by setting the skip-cleanup
   188  // flag when invoking the test, allowing the temporary directory to be left for
   189  // debugging tests.
   190  //
   191  // If the Writer for any file within any module returns an error equivalent to
   192  // ErrUnspported, Export skips the test.
   193  func Export(t testing.TB, exporter Exporter, modules []Module) *Exported {
   194  	t.Helper()
   195  	if exporter == Modules {
   196  		testenv.NeedsTool(t, "go")
   197  	}
   198  
   199  	dirname := strings.Replace(t.Name(), "/", "_", -1)
   200  	dirname = strings.Replace(dirname, "#", "_", -1) // duplicate subtests get a #NNN suffix.
   201  	temp, err := ioutil.TempDir("", dirname)
   202  	if err != nil {
   203  		t.Fatal(err)
   204  	}
   205  	exported := &Exported{
   206  		Config: &packages.Config{
   207  			Dir:     temp,
   208  			Env:     append(os.Environ(), "GOPACKAGESDRIVER=off", "GOROOT="), // Clear GOROOT to work around #32849.
   209  			Overlay: make(map[string][]byte),
   210  			Tests:   true,
   211  			Mode:    packages.LoadImports,
   212  		},
   213  		Modules:       modules,
   214  		Exporter:      exporter,
   215  		temp:          temp,
   216  		primary:       modules[0].Name,
   217  		written:       map[string]map[string]string{},
   218  		ExpectFileSet: token.NewFileSet(),
   219  	}
   220  	defer func() {
   221  		if t.Failed() || t.Skipped() {
   222  			exported.Cleanup()
   223  		}
   224  	}()
   225  	for _, module := range modules {
   226  		// Create all parent directories before individual files. If any file is a
   227  		// symlink to a directory, that directory must exist before the symlink is
   228  		// created or else it may be created with the wrong type on Windows.
   229  		// (See https://golang.org/issue/39183.)
   230  		for fragment := range module.Files {
   231  			fullpath := exporter.Filename(exported, module.Name, filepath.FromSlash(fragment))
   232  			if err := os.MkdirAll(filepath.Dir(fullpath), 0755); err != nil {
   233  				t.Fatal(err)
   234  			}
   235  		}
   236  
   237  		for fragment, value := range module.Files {
   238  			fullpath := exporter.Filename(exported, module.Name, filepath.FromSlash(fragment))
   239  			written, ok := exported.written[module.Name]
   240  			if !ok {
   241  				written = map[string]string{}
   242  				exported.written[module.Name] = written
   243  			}
   244  			written[fragment] = fullpath
   245  			switch value := value.(type) {
   246  			case Writer:
   247  				if err := value(fullpath); err != nil {
   248  					if errors.Is(err, ErrUnsupported) {
   249  						t.Skip(err)
   250  					}
   251  					t.Fatal(err)
   252  				}
   253  			case string:
   254  				if err := ioutil.WriteFile(fullpath, []byte(value), 0644); err != nil {
   255  					t.Fatal(err)
   256  				}
   257  			default:
   258  				t.Fatalf("Invalid type %T in files, must be string or Writer", value)
   259  			}
   260  		}
   261  		for fragment, value := range module.Overlay {
   262  			fullpath := exporter.Filename(exported, module.Name, filepath.FromSlash(fragment))
   263  			exported.Config.Overlay[fullpath] = value
   264  		}
   265  	}
   266  	if err := exporter.Finalize(exported); err != nil {
   267  		t.Fatal(err)
   268  	}
   269  	testenv.NeedsGoPackagesEnv(t, exported.Config.Env)
   270  	return exported
   271  }
   272  
   273  // Script returns a Writer that writes out contents to the file and sets the
   274  // executable bit on the created file.
   275  // It is intended for source files that are shell scripts.
   276  func Script(contents string) Writer {
   277  	return func(filename string) error {
   278  		return ioutil.WriteFile(filename, []byte(contents), 0755)
   279  	}
   280  }
   281  
   282  // Link returns a Writer that creates a hard link from the specified source to
   283  // the required file.
   284  // This is used to link testdata files into the generated testing tree.
   285  //
   286  // If hard links to source are not supported on the destination filesystem, the
   287  // returned Writer returns an error for which errors.Is(_, ErrUnsupported)
   288  // returns true.
   289  func Link(source string) Writer {
   290  	return func(filename string) error {
   291  		linkErr := os.Link(source, filename)
   292  
   293  		if linkErr != nil && !builderMustSupportLinks() {
   294  			// Probe to figure out whether Link failed because the Link operation
   295  			// isn't supported.
   296  			if stat, err := openAndStat(source); err == nil {
   297  				if err := createEmpty(filename, stat.Mode()); err == nil {
   298  					// Successfully opened the source and created the destination,
   299  					// but the result is empty and not a hard-link.
   300  					return &os.PathError{Op: "Link", Path: filename, Err: ErrUnsupported}
   301  				}
   302  			}
   303  		}
   304  
   305  		return linkErr
   306  	}
   307  }
   308  
   309  // Symlink returns a Writer that creates a symlink from the specified source to the
   310  // required file.
   311  // This is used to link testdata files into the generated testing tree.
   312  //
   313  // If symlinks to source are not supported on the destination filesystem, the
   314  // returned Writer returns an error for which errors.Is(_, ErrUnsupported)
   315  // returns true.
   316  func Symlink(source string) Writer {
   317  	if !strings.HasPrefix(source, ".") {
   318  		if absSource, err := filepath.Abs(source); err == nil {
   319  			if _, err := os.Stat(source); !os.IsNotExist(err) {
   320  				source = absSource
   321  			}
   322  		}
   323  	}
   324  	return func(filename string) error {
   325  		symlinkErr := os.Symlink(source, filename)
   326  
   327  		if symlinkErr != nil && !builderMustSupportLinks() {
   328  			// Probe to figure out whether Symlink failed because the Symlink
   329  			// operation isn't supported.
   330  			fullSource := source
   331  			if !filepath.IsAbs(source) {
   332  				// Compute the target path relative to the parent of filename, not the
   333  				// current working directory.
   334  				fullSource = filepath.Join(filename, "..", source)
   335  			}
   336  			stat, err := openAndStat(fullSource)
   337  			mode := os.ModePerm
   338  			if err == nil {
   339  				mode = stat.Mode()
   340  			} else if !errors.Is(err, os.ErrNotExist) {
   341  				// We couldn't open the source, but it might exist. We don't expect to be
   342  				// able to portably create a symlink to a file we can't see.
   343  				return symlinkErr
   344  			}
   345  
   346  			if err := createEmpty(filename, mode|0644); err == nil {
   347  				// Successfully opened the source (or verified that it does not exist) and
   348  				// created the destination, but we couldn't create it as a symlink.
   349  				// Probably the OS just doesn't support symlinks in this context.
   350  				return &os.PathError{Op: "Symlink", Path: filename, Err: ErrUnsupported}
   351  			}
   352  		}
   353  
   354  		return symlinkErr
   355  	}
   356  }
   357  
   358  // builderMustSupportLinks reports whether we are running on a Go builder
   359  // that is known to support hard and symbolic links.
   360  func builderMustSupportLinks() bool {
   361  	if os.Getenv("GO_BUILDER_NAME") == "" {
   362  		// Any OS can be configured to mount an exotic filesystem.
   363  		// Don't make assumptions about what users are running.
   364  		return false
   365  	}
   366  
   367  	switch runtime.GOOS {
   368  	case "windows", "plan9":
   369  		// Some versions of Windows and all versions of plan9 do not support
   370  		// symlinks by default.
   371  		return false
   372  
   373  	default:
   374  		// All other platforms should support symlinks by default, and our builders
   375  		// should not do anything unusual that would violate that.
   376  		return true
   377  	}
   378  }
   379  
   380  // openAndStat attempts to open source for reading.
   381  func openAndStat(source string) (os.FileInfo, error) {
   382  	src, err := os.Open(source)
   383  	if err != nil {
   384  		return nil, err
   385  	}
   386  	stat, err := src.Stat()
   387  	src.Close()
   388  	if err != nil {
   389  		return nil, err
   390  	}
   391  	return stat, nil
   392  }
   393  
   394  // createEmpty creates an empty file or directory (depending on mode)
   395  // at dst, with the same permissions as mode.
   396  func createEmpty(dst string, mode os.FileMode) error {
   397  	if mode.IsDir() {
   398  		return os.Mkdir(dst, mode.Perm())
   399  	}
   400  
   401  	f, err := os.OpenFile(dst, os.O_WRONLY|os.O_CREATE|os.O_EXCL, mode.Perm())
   402  	if err != nil {
   403  		return err
   404  	}
   405  	if err := f.Close(); err != nil {
   406  		os.Remove(dst) // best-effort
   407  		return err
   408  	}
   409  
   410  	return nil
   411  }
   412  
   413  // Copy returns a Writer that copies a file from the specified source to the
   414  // required file.
   415  // This is used to copy testdata files into the generated testing tree.
   416  func Copy(source string) Writer {
   417  	return func(filename string) error {
   418  		stat, err := os.Stat(source)
   419  		if err != nil {
   420  			return err
   421  		}
   422  		if !stat.Mode().IsRegular() {
   423  			// cannot copy non-regular files (e.g., directories,
   424  			// symlinks, devices, etc.)
   425  			return fmt.Errorf("cannot copy non regular file %s", source)
   426  		}
   427  		return copyFile(filename, source, stat.Mode().Perm())
   428  	}
   429  }
   430  
   431  func copyFile(dest, source string, perm os.FileMode) error {
   432  	src, err := os.Open(source)
   433  	if err != nil {
   434  		return err
   435  	}
   436  	defer src.Close()
   437  
   438  	dst, err := os.OpenFile(dest, os.O_WRONLY|os.O_CREATE|os.O_EXCL, perm)
   439  	if err != nil {
   440  		return err
   441  	}
   442  
   443  	_, err = io.Copy(dst, src)
   444  	if closeErr := dst.Close(); err == nil {
   445  		err = closeErr
   446  	}
   447  	return err
   448  }
   449  
   450  // GroupFilesByModules attempts to map directories to the modules within each directory.
   451  // This function assumes that the folder is structured in the following way:
   452  //
   453  //	dir/
   454  //		primarymod/
   455  //			*.go files
   456  //			packages
   457  //			go.mod (optional)
   458  //		modules/
   459  //			repoa/
   460  //				mod1/
   461  //					*.go files
   462  //					packages
   463  //					go.mod (optional)
   464  //
   465  // It scans the directory tree anchored at root and adds a Copy writer to the
   466  // map for every file found.
   467  // This is to enable the common case in tests where you have a full copy of the
   468  // package in your testdata.
   469  func GroupFilesByModules(root string) ([]Module, error) {
   470  	root = filepath.FromSlash(root)
   471  	primarymodPath := filepath.Join(root, "primarymod")
   472  
   473  	_, err := os.Stat(primarymodPath)
   474  	if os.IsNotExist(err) {
   475  		return nil, fmt.Errorf("could not find primarymod folder within %s", root)
   476  	}
   477  
   478  	primarymod := &Module{
   479  		Name:    root,
   480  		Files:   make(map[string]interface{}),
   481  		Overlay: make(map[string][]byte),
   482  	}
   483  	mods := map[string]*Module{
   484  		root: primarymod,
   485  	}
   486  	modules := []Module{*primarymod}
   487  
   488  	if err := filepath.Walk(primarymodPath, func(path string, info os.FileInfo, err error) error {
   489  		if err != nil {
   490  			return err
   491  		}
   492  		if info.IsDir() {
   493  			return nil
   494  		}
   495  		fragment, err := filepath.Rel(primarymodPath, path)
   496  		if err != nil {
   497  			return err
   498  		}
   499  		primarymod.Files[filepath.ToSlash(fragment)] = Copy(path)
   500  		return nil
   501  	}); err != nil {
   502  		return nil, err
   503  	}
   504  
   505  	modulesPath := filepath.Join(root, "modules")
   506  	if _, err := os.Stat(modulesPath); os.IsNotExist(err) {
   507  		return modules, nil
   508  	}
   509  
   510  	var currentRepo, currentModule string
   511  	updateCurrentModule := func(dir string) {
   512  		if dir == currentModule {
   513  			return
   514  		}
   515  		// Handle the case where we step into a nested directory that is a module
   516  		// and then step out into the parent which is also a module.
   517  		// Example:
   518  		// - repoa
   519  		//   - moda
   520  		//     - go.mod
   521  		//     - v2
   522  		//       - go.mod
   523  		//     - what.go
   524  		//   - modb
   525  		for dir != root {
   526  			if mods[dir] != nil {
   527  				currentModule = dir
   528  				return
   529  			}
   530  			dir = filepath.Dir(dir)
   531  		}
   532  	}
   533  
   534  	if err := filepath.Walk(modulesPath, func(path string, info os.FileInfo, err error) error {
   535  		if err != nil {
   536  			return err
   537  		}
   538  		enclosingDir := filepath.Dir(path)
   539  		// If the path is not a directory, then we want to add the path to
   540  		// the files map of the currentModule.
   541  		if !info.IsDir() {
   542  			updateCurrentModule(enclosingDir)
   543  			fragment, err := filepath.Rel(currentModule, path)
   544  			if err != nil {
   545  				return err
   546  			}
   547  			mods[currentModule].Files[filepath.ToSlash(fragment)] = Copy(path)
   548  			return nil
   549  		}
   550  		// If the path is a directory and it's enclosing folder is equal to
   551  		// the modules folder, then the path is a new repo.
   552  		if enclosingDir == modulesPath {
   553  			currentRepo = path
   554  			return nil
   555  		}
   556  		// If the path is a directory and it's enclosing folder is not the same
   557  		// as the current repo and it is not of the form `v1`,`v2`,...
   558  		// then the path is a folder/package of the current module.
   559  		if enclosingDir != currentRepo && !versionSuffixRE.MatchString(filepath.Base(path)) {
   560  			return nil
   561  		}
   562  		// If the path is a directory and it's enclosing folder is the current repo
   563  		// then the path is a new module.
   564  		module, err := filepath.Rel(modulesPath, path)
   565  		if err != nil {
   566  			return err
   567  		}
   568  		mods[path] = &Module{
   569  			Name:    filepath.ToSlash(module),
   570  			Files:   make(map[string]interface{}),
   571  			Overlay: make(map[string][]byte),
   572  		}
   573  		currentModule = path
   574  		modules = append(modules, *mods[path])
   575  		return nil
   576  	}); err != nil {
   577  		return nil, err
   578  	}
   579  	return modules, nil
   580  }
   581  
   582  // MustCopyFileTree returns a file set for a module based on a real directory tree.
   583  // It scans the directory tree anchored at root and adds a Copy writer to the
   584  // map for every file found. It skips copying files in nested modules.
   585  // This is to enable the common case in tests where you have a full copy of the
   586  // package in your testdata.
   587  // This will panic if there is any kind of error trying to walk the file tree.
   588  func MustCopyFileTree(root string) map[string]interface{} {
   589  	result := map[string]interface{}{}
   590  	if err := filepath.Walk(filepath.FromSlash(root), func(path string, info os.FileInfo, err error) error {
   591  		if err != nil {
   592  			return err
   593  		}
   594  		if info.IsDir() {
   595  			// skip nested modules.
   596  			if path != root {
   597  				if fi, err := os.Stat(filepath.Join(path, "go.mod")); err == nil && !fi.IsDir() {
   598  					return filepath.SkipDir
   599  				}
   600  			}
   601  			return nil
   602  		}
   603  		fragment, err := filepath.Rel(root, path)
   604  		if err != nil {
   605  			return err
   606  		}
   607  		result[filepath.ToSlash(fragment)] = Copy(path)
   608  		return nil
   609  	}); err != nil {
   610  		log.Panic(fmt.Sprintf("MustCopyFileTree failed: %v", err))
   611  	}
   612  	return result
   613  }
   614  
   615  // Cleanup removes the temporary directory (unless the --skip-cleanup flag was set)
   616  // It is safe to call cleanup multiple times.
   617  func (e *Exported) Cleanup() {
   618  	if e.temp == "" {
   619  		return
   620  	}
   621  	if *skipCleanup {
   622  		log.Printf("Skipping cleanup of temp dir: %s", e.temp)
   623  		return
   624  	}
   625  	// Make everything read-write so that the Module exporter's module cache can be deleted.
   626  	filepath.Walk(e.temp, func(path string, info os.FileInfo, err error) error {
   627  		if err != nil {
   628  			return nil
   629  		}
   630  		if info.IsDir() {
   631  			os.Chmod(path, 0777)
   632  		}
   633  		return nil
   634  	})
   635  	os.RemoveAll(e.temp) // ignore errors
   636  	e.temp = ""
   637  }
   638  
   639  // Temp returns the temporary directory that was generated.
   640  func (e *Exported) Temp() string {
   641  	return e.temp
   642  }
   643  
   644  // File returns the full path for the given module and file fragment.
   645  func (e *Exported) File(module, fragment string) string {
   646  	if m := e.written[module]; m != nil {
   647  		return m[fragment]
   648  	}
   649  	return ""
   650  }
   651  
   652  // FileContents returns the contents of the specified file.
   653  // It will use the overlay if the file is present, otherwise it will read it
   654  // from disk.
   655  func (e *Exported) FileContents(filename string) ([]byte, error) {
   656  	if content, found := e.Config.Overlay[filename]; found {
   657  		return content, nil
   658  	}
   659  	content, err := ioutil.ReadFile(filename)
   660  	if err != nil {
   661  		return nil, err
   662  	}
   663  	return content, nil
   664  }
   665
View as plain text