Merge "ref: Move unused libraries to deprecated."
diff --git a/lib/filelocker/locker.go b/lib/filelocker/locker.go
deleted file mode 100644
index 05b9af8..0000000
--- a/lib/filelocker/locker.go
+++ /dev/null
@@ -1,59 +0,0 @@
-// package filelocker provides a primitive that lets a process
-// lock access to a file.
-package filelocker
-
-import (
- "os"
- "syscall"
-
- "v.io/x/lib/vlog"
-)
-
-// Unlocker is the interface to unlock a locked file.
-type Unlocker interface {
- // Unlock unlocks the file.
- Unlock()
-}
-
-// Lock locks the provided file.
-//
-// If the file is already locked then the calling goroutine
-// blocks until the lock can be grabbed.
-//
-// The file must exist otherwise an error is returned.
-func Lock(filepath string) (Unlocker, error) {
- file, err := os.Open(filepath)
- if err != nil {
- return nil, err
- }
- if err = syscall.Flock(int(file.Fd()), syscall.LOCK_EX); err != nil {
- return nil, err
- }
- return &unlocker{file}, nil
-}
-
-// TryLock tries to grab a lock on the provided file and
-// returns an error if it fails. This function is non-blocking.
-//
-// The file must exist otherwise an error is returned.
-func TryLock(filepath string) (Unlocker, error) {
- file, err := os.Open(filepath)
- if err != nil {
- return nil, err
- }
- if err = syscall.Flock(int(file.Fd()), syscall.LOCK_EX|syscall.LOCK_NB); err != nil {
- return nil, err
- }
- return &unlocker{file}, nil
-}
-
-// unlocker implements Unlocker.
-type unlocker struct {
- file *os.File
-}
-
-func (u *unlocker) Unlock() {
- if err := u.file.Close(); err != nil {
- vlog.Errorf("failed to unlock file %q: %v", u.file.Name(), err)
- }
-}
diff --git a/lib/filelocker/locker_test.go b/lib/filelocker/locker_test.go
deleted file mode 100644
index b0ea46e..0000000
--- a/lib/filelocker/locker_test.go
+++ /dev/null
@@ -1,160 +0,0 @@
-package filelocker
-
-import (
- "bufio"
- "fmt"
- "io"
- "io/ioutil"
- "os"
- "syscall"
- "testing"
- "time"
-
- "v.io/x/ref/lib/modules"
- "v.io/x/ref/lib/testutil/expect"
-)
-
-//go:generate v23 test generate
-
-func newFile() string {
- file, err := ioutil.TempFile("", "test_lock_file")
- if err != nil {
- panic(err)
- }
- defer file.Close()
- return file.Name()
-}
-
-func grabbedLock(lock <-chan bool) bool {
- select {
- case <-lock:
- return true
- case <-time.After(100 * time.Millisecond):
- return false
- }
-}
-
-func testLockChild(stdin io.Reader, stdout, stderr io.Writer, env map[string]string, args ...string) error {
- // Lock the file
- unlocker, err := Lock(args[0])
- if err != nil {
- return fmt.Errorf("Lock failed: %v", err)
- }
- fmt.Fprintf(stdout, "locked\n")
-
- // Wait for message from parent to unlock the file.
- scanner := bufio.NewScanner(stdin)
- if scanned := scanner.Scan(); !scanned || (scanned && scanner.Text() != "unlock") {
- unlocker.Unlock()
- return fmt.Errorf("unexpected message read from stdout, expected %v", "unlock")
- }
- unlocker.Unlock()
- fmt.Fprintf(stdout, "unlocked\n")
- return nil
-}
-
-func TestLockInterProcess(t *testing.T) {
- filepath := newFile()
- defer os.Remove(filepath)
-
- sh, err := modules.NewShell(nil, nil)
- if err != nil {
- t.Fatalf("unexpected error: %s", err)
- }
- defer sh.Cleanup(os.Stderr, os.Stderr)
- h, err := sh.Start("testLockChild", nil, filepath)
- if err != nil {
- t.Fatalf("sh.Start failed: %v", err)
- }
- s := expect.NewSession(t, h.Stdout(), time.Minute)
-
- // Test that child grabbed the lock.
- s.Expect("locked")
-
- // Test that parent cannot grab the lock, and then send a message
- // to the child to release the lock.
- lock := make(chan bool)
- go func() {
- unlocker, err := Lock(filepath)
- if err != nil {
- t.Fatalf("Lock failed: %v", err)
- }
- close(lock)
- unlocker.Unlock()
- }()
- if grabbedLock(lock) {
- t.Fatal("Parent process unexpectedly grabbed lock before child released it")
- }
-
- // Test that the parent can grab the lock after the child has released it.
- h.Stdin().Write([]byte("unlock\n"))
- s.Expect("unlocked")
- if !grabbedLock(lock) {
- t.Fatal("Parent process failed to grab the lock after child released it")
- }
- s.ExpectEOF()
-}
-
-func TestLockIntraProcess(t *testing.T) {
- filepath := newFile()
- defer os.Remove(filepath)
-
- // Grab the lock within this goroutine and test that
- // another goroutine blocks when trying to grab the lock.
- unlocker, err := Lock(filepath)
- if err != nil {
- t.Fatalf("Lock failed: %v", err)
- }
- lock := make(chan bool)
- go func() {
- unlocker, err := Lock(filepath)
- if err != nil {
- t.Fatalf("Lock failed: %v", err)
- }
- close(lock)
- unlocker.Unlock()
- }()
- if grabbedLock(lock) {
- unlocker.Unlock()
- t.Fatal("Another goroutine unexpectedly grabbed lock before this goroutine released it")
- }
-
- // Release the lock and test that the goroutine can grab it.
- unlocker.Unlock()
- if !grabbedLock(lock) {
- t.Fatal("Another goroutine failed to grab the lock after this goroutine released it")
- }
-}
-
-func TestTryLock(t *testing.T) {
- filepath := newFile()
- defer os.Remove(filepath)
-
- sh, err := modules.NewShell(nil, nil)
- if err != nil {
- t.Fatalf("unexpected error: %s", err)
- }
- defer sh.Cleanup(os.Stderr, os.Stderr)
- h, err := sh.Start("testLockChild", nil, filepath)
- if err != nil {
- t.Fatalf("sh.Start failed: %v", err)
- }
- s := expect.NewSession(t, h.Stdout(), time.Minute)
-
- // Test that child grabbed the lock.
- s.Expect("locked")
-
- // Test that parent cannot grab the lock, and then send a message
- // to the child to release the lock.
- if _, err := TryLock(filepath); err != syscall.EWOULDBLOCK {
- t.Fatal("TryLock returned error: %v, want: %v", err, syscall.EWOULDBLOCK)
- }
-
- // Test that the parent can grab the lock after the child has released it.
- h.Stdin().Write([]byte("unlock\n"))
- s.Expect("unlocked")
- if _, err = TryLock(filepath); err != nil {
- t.Fatalf("TryLock failed: %v", err)
- }
- s.ExpectEOF()
-}
diff --git a/lib/filelocker/v23_internal_test.go b/lib/filelocker/v23_internal_test.go
deleted file mode 100644
index 65ed9a5..0000000
--- a/lib/filelocker/v23_internal_test.go
+++ /dev/null
@@ -1,30 +0,0 @@
-// Copyright 2015 The Vanadium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// This file was auto-generated via go generate.
-// DO NOT UPDATE MANUALLY
-package filelocker
-
-import "fmt"
-import "testing"
-import "os"
-
-import "v.io/x/ref/lib/modules"
-import "v.io/x/ref/lib/testutil"
-
-func init() {
- modules.RegisterChild("testLockChild", ``, testLockChild)
-}
-
-func TestMain(m *testing.M) {
- testutil.Init()
- if modules.IsModulesProcess() {
- if err := modules.Dispatch(); err != nil {
- fmt.Fprintf(os.Stderr, "modules.Dispatch failed: %v\n", err)
- os.Exit(1)
- }
- return
- }
- os.Exit(m.Run())
-}
diff --git a/lib/unit/distance.go b/lib/unit/distance.go
deleted file mode 100644
index 19e6312..0000000
--- a/lib/unit/distance.go
+++ /dev/null
@@ -1,186 +0,0 @@
-package unit
-
-import (
- "fmt"
- "math"
- "regexp"
- "strconv"
- "strings"
-)
-
-// metersInFoot denotes the number of meters in one foot, which is *exactly*
-// 0.3048 (i.e., there is no rounding).
-const (
- metersInFoot = 0.3048
- // MaxDistance represents the largest expressable distance.
- MaxDistance Distance = math.MaxFloat64
-)
-
-// Distance represents a physical distance with floating-point precision.
-// It can be expressed in both metric and imperial units.
-//
-// Distance is internally stored in millimeter units.
-type Distance float64
-
-// Common distances. To convert an integer number of units into a Distance,
-// multiply:
-// fmt.Print(5*unit.Meter) // prints "5m0mm"
-//
-// To count a number of units in a Distance, divide:
-// d := 5*unit.Meter
-// fmt.Print(int64(d/unit.Centimeter)) // prints 500
-//
-// Distances can be added or subtracted:
-// fmt.Print(5*unit.Meter + 3*unit.Centimeter) // prints "5m30mm"
-// fmt.Print(3*unit.Kilometer - 2*unit.Kilometer) // prints "1km0m0mm"
-const (
- Millimeter Distance = 1
- Centimeter = 10 * Millimeter
- Meter = 1000 * Millimeter
- Kilometer = 1000 * Meter
- Foot = metersInFoot * Meter
- Inch = Foot / 12
- Yard = 3 * Foot
- Mile = 1760 * Yard
-)
-
-var parseRegexp = regexp.MustCompile("^([0-9\\+\\-\\.eE]*)([mM][iI]|[kK][mM]|[mM][mM]|[cC][mM]|[fF][tT]|[iI][nN]|[fF][tT]|[yY][dD]|[mM])")
-
-// Parse parses the provided string and returns a new Distance. The provided
-// string must be of the following format:
-//
-// [+-]*(<positive_float_num>("mi"|"km"|"m"|"yd"|"ft"|"in"|"cm"|"mm"))+
-//
-// For example, the following are legitimate distance strings:
-//
-// "10.2mi8km0.3m12yd100ft18in12.82cm22mm"
-// "10km12m88cm"
-// "12yd8ft3in"
-// "-12yd3.2ft"
-//
-// ParseDistance will return an error if the string doesn't conform to the
-// above format.
-func ParseDistance(value string) (Distance, error) {
- var total Distance
- s := value
-
- // See if the string starts with a +- sign and if so consume it.
- neg := false
- if len(s) > 0 && s[0] == '+' {
- s = s[1:]
- } else if len(s) > 0 && s[0] == '-' {
- s = s[1:]
- neg = true
- }
- match := parseRegexp.FindStringSubmatch(s)
- if match == nil {
- return 0, fmt.Errorf("invalid distance string: %q", value)
- }
- for match != nil && len(match) == 3 {
- full, value, unit := match[0], match[1], match[2]
- // Parse value.
- f, err := strconv.ParseFloat(value, 64)
- if err != nil {
- return 0, fmt.Errorf("error parsing float in distance string %q: %s", value, err)
- }
- if f < 0 {
- return 0, fmt.Errorf("can't use negative float unit count in distance string %q: %f", value, f)
- }
- // Parse unit.
- var mult Distance
- switch strings.ToLower(unit) {
- case "mi":
- mult = Mile
- case "km":
- mult = Kilometer
- case "m":
- mult = Meter
- case "yd":
- mult = Yard
- case "ft":
- mult = Foot
- case "in":
- mult = Inch
- case "cm":
- mult = Centimeter
- case "mm":
- mult = Millimeter
- default: // should never happen
- return 0, fmt.Errorf("illegal unit in distance string %q: %q", value, unit)
- }
- // Add the newly parsed sub-distance to the total.
- total += Distance(f) * mult
- // Advance to the next matched sub-distance.
- s = s[len(full):]
- match = parseRegexp.FindStringSubmatch(s)
- }
-
- if len(s) > 0 {
- return 0, fmt.Errorf("invalid distance string: %q", value)
- }
-
- if neg {
- total *= -1
- }
- return total, nil
-}
-
-func (d Distance) String() string {
- var sign string
- if d < 0 {
- sign = "-"
- }
- v := math.Abs(float64(d))
- kms := math.Floor(v / float64(Kilometer))
- v = v - kms*float64(Kilometer)
- ms := math.Floor(v / float64(Meter))
- v = v - ms*float64(Meter)
- mms := v
- if kms > 0 {
- return fmt.Sprintf("%s%gkm%gm%gmm", sign, kms, ms, mms)
- }
- if ms > 0 {
- return fmt.Sprintf("%s%gm%gmm", sign, ms, mms)
- }
- return fmt.Sprintf("%s%gmm", sign, mms)
-}
-
-// Miles returns a distance value in mile units.
-func (d Distance) Miles() float64 {
- return float64(d / Mile)
-}
-
-// Kilometers returns a distance value in kilometer units.
-func (d Distance) Kilometers() float64 {
- return float64(d / Kilometer)
-}
-
-// Meters returns a distance value in meter units.
-func (d Distance) Meters() float64 {
- return float64(d / Meter)
-}
-
-// Yards returns a distance value in yard units.
-func (d Distance) Yards() float64 {
- return float64(d / Yard)
-}
-
-// Feet returns a distance value in foot units.
-func (d Distance) Feet() float64 {
- return float64(d / Foot)
-}
-
-// Inches returns a distance value in inch units.
-func (d Distance) Inches() float64 {
- return float64(d / Inch)
-}
-
-// Centimeters returns a distance value in centimeter units.
-func (d Distance) Centimeters() float64 {
- return float64(d / Centimeter)
-}
-
-// Millimeters returns a distance value in millimeter units.
-func (d Distance) Millimeters() float64 {
- return float64(d)
-}
diff --git a/lib/unit/distance_test.go b/lib/unit/distance_test.go
deleted file mode 100644
index d0521ea..0000000
--- a/lib/unit/distance_test.go
+++ /dev/null
@@ -1,259 +0,0 @@
-package unit
-
-import (
- "math"
- "testing"
-)
-
-func floatEq(first, second float64) bool {
- const maxPrecisionError = 0.00000001
- return math.Abs(float64(first)-float64(second)) <= maxPrecisionError
-}
-
-func TestDistanceAccessorsMetric(t *testing.T) {
- d := 1 * Kilometer
- if !floatEq(d.Kilometers(), 1) {
- t.Errorf("kilometers error: have %v, want %v", d.Kilometers(), 1)
- }
- if !floatEq(d.Meters(), 1000) {
- t.Errorf("meters error: have %v, want %v", d.Meters(), 1000)
- }
- if !floatEq(d.Centimeters(), 100000) {
- t.Errorf("centimeters error: have %v, want %v", d.Centimeters(), 100000)
- }
- if !floatEq(d.Millimeters(), 1000000) {
- t.Errorf("millimeters error: have %v, want %v", d.Millimeters(), 1000000)
- }
-}
-
-func TestDistanceAccessorsImperial(t *testing.T) {
- d := 1 * Mile
- if !floatEq(d.Miles(), 1) {
- t.Errorf("miles error: have %v, want %v", d.Miles(), 1)
- }
- if !floatEq(d.Yards(), 1760) {
- t.Errorf("yards error: have %v, want %v", d.Yards(), float64(5280)/3)
- }
- if !floatEq(d.Feet(), 5280) {
- t.Errorf("feet error: have %v, want %v", d.Feet(), 5280)
- }
- if !floatEq(d.Inches(), 63360) {
- t.Errorf("inches error: have %v, want %v", d.Inches(), 63360)
- }
-}
-
-func TestDistanceUnitConversions(t *testing.T) {
- d := 100.9 * Meter
- if !floatEq(d.Miles(), d.Feet()/5280) {
- t.Error("wrong miles <-> feet conversion")
- }
- if !floatEq(d.Kilometers(), d.Meters()/1000) {
- t.Error("wrong kilometers <-> meters conversion")
- }
- if !floatEq(d.Meters(), d.Centimeters()/100) {
- t.Error("wrong meters <-> centimeters conversion")
- }
- if !floatEq(d.Feet(), d.Meters()/0.3048) {
- t.Error("wrong feet <-> meters conversion")
- }
- if !floatEq(d.Feet(), d.Inches()/12) {
- t.Error("wrong feet -> inches conversion.")
- }
- if !floatEq(d.Centimeters(), d.Millimeters()/10) {
- t.Error("wrong centimeters -> millimeters conversion")
- }
-}
-
-func TestDistanceParseAgainstConstants(t *testing.T) {
- testcases := []struct {
- string string
- expected Distance
- }{
- {"1mi", 1 * Mile},
- {"1km", 1 * Kilometer},
- {"1m", 1 * Meter},
- {"1yd", 1 * Yard},
- {"1ft", 1 * Foot},
- {"1in", 1 * Inch},
- {"1cm", 1 * Centimeter},
- {"1mm", 1 * Millimeter},
- {"0.1mi", 0.1 * Mile},
- {"0.1km", 0.1 * Kilometer},
- {"0.1m", 0.1 * Meter},
- {"0.1yd", 0.1 * Yard},
- {"0.1ft", 0.1 * Foot},
- {"0.1in", 0.1 * Inch},
- {"0.1cm", 0.1 * Centimeter},
- {"0.1mm", 0.1 * Millimeter},
- {"-18.2mi", -18.2 * Mile},
- {"-18.2km", -18.2 * Kilometer},
- {"-18.2m", -18.2 * Meter},
- {"-18.2yd", -18.2 * Yard},
- {"-18.2ft", -18.2 * Foot},
- {"-18.2in", -18.2 * Inch},
- {"-18.2cm", -18.2 * Centimeter},
- {"-18.2mm", -18.2 * Millimeter},
- {"10mi9m", 10*Mile + 9*Meter},
- {"10km9m8cm", 10*Kilometer + 9*Meter + 8*Centimeter},
- {"10m9m8m", 27 * Meter},
- {"-1cm100cm20cm2m", -1 * (2*Meter + 121*Centimeter)},
- }
- for _, tc := range testcases {
- d, err := ParseDistance(tc.string)
- if err != nil {
- t.Errorf("ParseDistance(%q) returned error: %v", tc.string, err)
- continue
- }
- if !floatEq(d.Millimeters(), tc.expected.Millimeters()) {
- t.Errorf("ParseDistance(%q).Millimeters() = %v; want %v", tc.string, d.Millimeters(), tc.expected.Millimeters())
- }
- }
-}
-
-func TestDistanceParseAgainstParse(t *testing.T) {
- testcases := []struct {
- first, second string
- }{
- // Singles.
- {"1mi", "5280ft"},
- {"1km", "1000m"},
- {"1m", "100cm"},
- {"1yd", "3ft"},
- {"1ft", "12in"},
- {"1in", "2.54cm"},
- {"1cm", "10mm"},
- {"-1cm", "-10mm"},
- {"10mi", "52800ft"},
- {"10km", "10000m"},
- {"10m", "1000cm"},
- {"10yd", "30ft"},
- {"10ft", "120in"},
- {"10in", "25.4cm"},
- {"10cm", "100mm"},
- {"-10cm", "-100mm"},
- {"0.1mi", "528ft"},
- {"0.1km", "100m"},
- {"0.1m", "10cm"},
- {"0.1yd", "0.3ft"},
- {"0.1ft", "1.2in"},
- {"0.1in", "0.254cm"},
- {"0.1cm", "1mm"},
- {"-0.1cm", "-1mm"},
- // Pairs.
- {"1mi1km", "1mi1000m"},
- {"1mi1m", "1mi100cm"},
- {"1mi1yd", "1mi3ft"},
- {"1mi1ft", "5281ft"},
- {"1mi1in", "5280ft1in"},
- {"1mi1cm", "5280ft10mm"},
- {"1mi1mm", "5280ft1mm"},
- {"-1mi1mm", "-5280ft1mm"},
- {"1km1m", "1001m"},
- {"1km1yd", "1000m3ft"},
- {"1km1ft", "1000m12in"},
- {"1km1in", "1000m2.54cm"},
- {"1km1cm", "1000m10mm"},
- {"1km1mm", "1000m0.1cm"},
- {"-1km1mm", "-1000m0.1cm"},
- {"1m1yd", "3ft100cm"},
- {"1m1ft", "12in100cm"},
- {"1m1in", "102.54cm"},
- {"1m1cm", "101cm"},
- {"1m1mm", "1001mm"},
- {"-1m1mm", "-1001mm"},
- {"1yd1ft", "4ft"},
- {"1yd1in", "3ft1in"},
- {"1yd1cm", "3ft10mm"},
- {"1yd1mm", "3ft0.1cm"},
- {"-1yd1mm", "-3ft0.1cm"},
- {"1ft1in", "13in"},
- {"1ft1cm", "12in10mm"},
- {"1ft1mm", "12in0.1cm"},
- {"-1ft1mm", "-12in0.1cm"},
- {"1in1cm", "1in10mm"},
- {"1in1mm", "1in0.1cm"},
- {"-1in1mm", "-1in0.1cm"},
- {"1cm1mm", "11mm"},
- // Complex.
- {"1mi1km1m1yd1ft1in1cm1mm", "1001m5284ft1in11mm"},
- {"-1mi1km1m1yd1ft1in1cm1mm", "-1001m5284ft1in11mm"},
- // CAPS.
- {"1Mi", "1mI"},
- {"1mi", "1MI"},
- {"1Km", "1kM"},
- {"1km", "1KM"},
- {"1M", "1m"},
- {"1Yd", "1yD"},
- {"1yd", "1YD"},
- {"1Ft", "1fT"},
- {"1ft", "1FT"},
- {"1In", "1iN"},
- {"1in", "1IN"},
- {"1Cm", "1cM"},
- {"1cm", "1CM"},
- {"1Mm", "1mM"},
- {"1mm", "1MM"},
- }
- for _, tc := range testcases {
- first, err := ParseDistance(tc.first)
- if err != nil {
- t.Errorf("ParseDistance(%q) returned error: %v", tc.first, err)
- continue
- }
- second, err := ParseDistance(tc.second)
- if err != nil {
- t.Errorf("ParseDistance(%q) returned error: err", tc.second, err)
- continue
- }
- if !floatEq(first.Millimeters(), second.Millimeters()) {
- t.Errorf("ParseDistance(%q).Millimeters() = %v; want %v = ParseDistance(%q).Millimeters()", tc.first, first.Millimeters(), second.Millimeters(), tc.second)
- }
- }
-}
-
-func TestDistanceString(t *testing.T) {
- testcases := []struct {
- d Distance
- expected string
- }{
- {1 * Kilometer, "1km0m0mm"},
- {1 * Meter, "1m0mm"},
- {1 * Millimeter, "1mm"},
- {1200 * Meter, "1km200m0mm"},
- {1.3 * Kilometer, "1km300m0mm"},
- {-2.7 * Kilometer, "-2km700m0mm"},
- {5.33 * Millimeter, "5.33mm"},
- {3.0000000000001 * Millimeter, "3.0000000000001mm"},
- {9*Kilometer + 12*Meter, "9km12m0mm"},
- {9*Kilometer - 12*Meter, "8km988m0mm"},
- {12*Meter - 9*Kilometer, "-8km988m0mm"},
- {9*Kilometer + 2222*Meter + 1024.5*Millimeter, "11km223m24.5mm"},
- {-1*Kilometer - 3200.3*Meter - 22*Millimeter, "-4km200m322mm"},
- }
- for _, tc := range testcases {
- if tc.d.String() != tc.expected {
- t.Errorf("Got string %q; want %q", tc.d, tc.expected)
- }
- }
-}
-
-func TestDistanceParseError(t *testing.T) {
- testcases := []string{
- "1kf",
- "1fm",
- "1kmm",
- "m",
- "cm",
- "1ft 1mi",
- " 1ft 1mi",
- "1ft 1mi ",
- "1ft 1mi",
- "1mi-4km",
- "-3km-4m",
- }
- for _, ds := range testcases {
- if d, err := ParseDistance(ds); err == nil {
- t.Errorf("ParseDistance(%q) = %q; want error", ds, d)
- }
- }
-}
diff --git a/lib/unit/doc.go b/lib/unit/doc.go
deleted file mode 100644
index df53801..0000000
--- a/lib/unit/doc.go
+++ /dev/null
@@ -1,2 +0,0 @@
-// Package unit implements types for working with various measurement units.
-package unit
