dc62de4760
Replace regular expressions to extract fields from a text proto with and actual parsed protobuf. Refactor TestFS into its own package, and implement StatFS. Test: m droid dist cts alllicensemetadata Test: repo forall -c 'echo -n "$REPO_PATH " && $ANDROID_BUILD_TOP/out/host/linux-x86/bin/compliance_checkmetadata . 2>&1' | fgrep -v PASS Change-Id: Icd17a6a2b6a4e2b6ffded48e964b9c9d6e4d64d6
129 lines
3.1 KiB
Go
129 lines
3.1 KiB
Go
// Copyright 2022 Google LLC
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
package testfs
|
|
|
|
import (
|
|
"fmt"
|
|
"io"
|
|
"io/fs"
|
|
"strings"
|
|
"time"
|
|
)
|
|
|
|
// TestFS implements a test file system (fs.FS) simulated by a map from filename to []byte content.
|
|
type TestFS map[string][]byte
|
|
|
|
var _ fs.FS = (*TestFS)(nil)
|
|
var _ fs.StatFS = (*TestFS)(nil)
|
|
|
|
// Open implements fs.FS.Open() to open a file based on the filename.
|
|
func (tfs *TestFS) Open(name string) (fs.File, error) {
|
|
if _, ok := (*tfs)[name]; !ok {
|
|
return nil, fmt.Errorf("unknown file %q", name)
|
|
}
|
|
return &TestFile{tfs, name, 0}, nil
|
|
}
|
|
|
|
// Stat implements fs.StatFS.Stat() to examine a file based on the filename.
|
|
func (tfs *TestFS) Stat(name string) (fs.FileInfo, error) {
|
|
if content, ok := (*tfs)[name]; ok {
|
|
return &TestFileInfo{name, len(content), 0666}, nil
|
|
}
|
|
dirname := name
|
|
if !strings.HasSuffix(dirname, "/") {
|
|
dirname = dirname + "/"
|
|
}
|
|
for name := range (*tfs) {
|
|
if strings.HasPrefix(name, dirname) {
|
|
return &TestFileInfo{name, 8, fs.ModeDir | fs.ModePerm}, nil
|
|
}
|
|
}
|
|
return nil, fmt.Errorf("file not found: %q", name)
|
|
}
|
|
|
|
// TestFileInfo implements a file info (fs.FileInfo) based on TestFS above.
|
|
type TestFileInfo struct {
|
|
name string
|
|
size int
|
|
mode fs.FileMode
|
|
}
|
|
|
|
var _ fs.FileInfo = (*TestFileInfo)(nil)
|
|
|
|
// Name returns the name of the file
|
|
func (fi *TestFileInfo) Name() string {
|
|
return fi.name
|
|
}
|
|
|
|
// Size returns the size of the file in bytes.
|
|
func (fi *TestFileInfo) Size() int64 {
|
|
return int64(fi.size)
|
|
}
|
|
|
|
// Mode returns the fs.FileMode bits.
|
|
func (fi *TestFileInfo) Mode() fs.FileMode {
|
|
return fi.mode
|
|
}
|
|
|
|
// ModTime fakes a modification time.
|
|
func (fi *TestFileInfo) ModTime() time.Time {
|
|
return time.UnixMicro(0xb0bb)
|
|
}
|
|
|
|
// IsDir is a synonym for Mode().IsDir()
|
|
func (fi *TestFileInfo) IsDir() bool {
|
|
return fi.mode.IsDir()
|
|
}
|
|
|
|
// Sys is unused and returns nil.
|
|
func (fi *TestFileInfo) Sys() any {
|
|
return nil
|
|
}
|
|
|
|
// TestFile implements a test file (fs.File) based on TestFS above.
|
|
type TestFile struct {
|
|
fs *TestFS
|
|
name string
|
|
posn int
|
|
}
|
|
|
|
var _ fs.File = (*TestFile)(nil)
|
|
|
|
// Stat not implemented to obviate implementing fs.FileInfo.
|
|
func (f *TestFile) Stat() (fs.FileInfo, error) {
|
|
return f.fs.Stat(f.name)
|
|
}
|
|
|
|
// Read copies bytes from the TestFS map.
|
|
func (f *TestFile) Read(b []byte) (int, error) {
|
|
if f.posn < 0 {
|
|
return 0, fmt.Errorf("file not open: %q", f.name)
|
|
}
|
|
if f.posn >= len((*f.fs)[f.name]) {
|
|
return 0, io.EOF
|
|
}
|
|
n := copy(b, (*f.fs)[f.name][f.posn:])
|
|
f.posn += n
|
|
return n, nil
|
|
}
|
|
|
|
// Close marks the TestFile as no longer in use.
|
|
func (f *TestFile) Close() error {
|
|
if f.posn < 0 {
|
|
return fmt.Errorf("file already closed: %q", f.name)
|
|
}
|
|
f.posn = -1
|
|
return nil
|
|
}
|