vendor dependencies with dep

vendor/github.com/jinzhu/inflection/inflections_test.go

@@ -0,0 +1,213 @@
+package inflection
+
+import (
+	"strings"
+	"testing"
+)
+
+var inflections = map[string]string{
+	"star":        "stars",
+	"STAR":        "STARS",
+	"Star":        "Stars",
+	"bus":         "buses",
+	"fish":        "fish",
+	"mouse":       "mice",
+	"query":       "queries",
+	"ability":     "abilities",
+	"agency":      "agencies",
+	"movie":       "movies",
+	"archive":     "archives",
+	"index":       "indices",
+	"wife":        "wives",
+	"safe":        "saves",
+	"half":        "halves",
+	"move":        "moves",
+	"salesperson": "salespeople",
+	"person":      "people",
+	"spokesman":   "spokesmen",
+	"man":         "men",
+	"woman":       "women",
+	"basis":       "bases",
+	"diagnosis":   "diagnoses",
+	"diagnosis_a": "diagnosis_as",
+	"datum":       "data",
+	"medium":      "media",
+	"stadium":     "stadia",
+	"analysis":    "analyses",
+	"node_child":  "node_children",
+	"child":       "children",
+	"experience":  "experiences",
+	"day":         "days",
+	"comment":     "comments",
+	"foobar":      "foobars",
+	"newsletter":  "newsletters",
+	"old_news":    "old_news",
+	"news":        "news",
+	"series":      "series",
+	"species":     "species",
+	"quiz":        "quizzes",
+	"perspective": "perspectives",
+	"ox":          "oxen",
+	"photo":       "photos",
+	"buffalo":     "buffaloes",
+	"tomato":      "tomatoes",
+	"dwarf":       "dwarves",
+	"elf":         "elves",
+	"information": "information",
+	"equipment":   "equipment",
+	"criterion":   "criteria",
+}
+
+// storage is used to restore the state of the global variables
+// on each test execution, to ensure no global state pollution
+type storage struct {
+	singulars    RegularSlice
+	plurals      RegularSlice
+	irregulars   IrregularSlice
+	uncountables []string
+}
+
+var backup = storage{}
+
+func init() {
+	AddIrregular("criterion", "criteria")
+	copy(backup.singulars, singularInflections)
+	copy(backup.plurals, pluralInflections)
+	copy(backup.irregulars, irregularInflections)
+	copy(backup.uncountables, uncountableInflections)
+}
+
+func restore() {
+	copy(singularInflections, backup.singulars)
+	copy(pluralInflections, backup.plurals)
+	copy(irregularInflections, backup.irregulars)
+	copy(uncountableInflections, backup.uncountables)
+}
+
+func TestPlural(t *testing.T) {
+	for key, value := range inflections {
+		if v := Plural(strings.ToUpper(key)); v != strings.ToUpper(value) {
+			t.Errorf("%v's plural should be %v, but got %v", strings.ToUpper(key), strings.ToUpper(value), v)
+		}
+
+		if v := Plural(strings.Title(key)); v != strings.Title(value) {
+			t.Errorf("%v's plural should be %v, but got %v", strings.Title(key), strings.Title(value), v)
+		}
+
+		if v := Plural(key); v != value {
+			t.Errorf("%v's plural should be %v, but got %v", key, value, v)
+		}
+	}
+}
+
+func TestSingular(t *testing.T) {
+	for key, value := range inflections {
+		if v := Singular(strings.ToUpper(value)); v != strings.ToUpper(key) {
+			t.Errorf("%v's singular should be %v, but got %v", strings.ToUpper(value), strings.ToUpper(key), v)
+		}
+
+		if v := Singular(strings.Title(value)); v != strings.Title(key) {
+			t.Errorf("%v's singular should be %v, but got %v", strings.Title(value), strings.Title(key), v)
+		}
+
+		if v := Singular(value); v != key {
+			t.Errorf("%v's singular should be %v, but got %v", value, key, v)
+		}
+	}
+}
+
+func TestAddPlural(t *testing.T) {
+	defer restore()
+	ln := len(pluralInflections)
+	AddPlural("", "")
+	if ln+1 != len(pluralInflections) {
+		t.Errorf("Expected len %d, got %d", ln+1, len(pluralInflections))
+	}
+}
+
+func TestAddSingular(t *testing.T) {
+	defer restore()
+	ln := len(singularInflections)
+	AddSingular("", "")
+	if ln+1 != len(singularInflections) {
+		t.Errorf("Expected len %d, got %d", ln+1, len(singularInflections))
+	}
+}
+
+func TestAddIrregular(t *testing.T) {
+	defer restore()
+	ln := len(irregularInflections)
+	AddIrregular("", "")
+	if ln+1 != len(irregularInflections) {
+		t.Errorf("Expected len %d, got %d", ln+1, len(irregularInflections))
+	}
+}
+
+func TestAddUncountable(t *testing.T) {
+	defer restore()
+	ln := len(uncountableInflections)
+	AddUncountable("", "")
+	if ln+2 != len(uncountableInflections) {
+		t.Errorf("Expected len %d, got %d", ln+2, len(uncountableInflections))
+	}
+}
+
+func TestGetPlural(t *testing.T) {
+	plurals := GetPlural()
+	if len(plurals) != len(pluralInflections) {
+		t.Errorf("Expected len %d, got %d", len(plurals), len(pluralInflections))
+	}
+}
+
+func TestGetSingular(t *testing.T) {
+	singular := GetSingular()
+	if len(singular) != len(singularInflections) {
+		t.Errorf("Expected len %d, got %d", len(singular), len(singularInflections))
+	}
+}
+
+func TestGetIrregular(t *testing.T) {
+	irregular := GetIrregular()
+	if len(irregular) != len(irregularInflections) {
+		t.Errorf("Expected len %d, got %d", len(irregular), len(irregularInflections))
+	}
+}
+
+func TestGetUncountable(t *testing.T) {
+	uncountables := GetUncountable()
+	if len(uncountables) != len(uncountableInflections) {
+		t.Errorf("Expected len %d, got %d", len(uncountables), len(uncountableInflections))
+	}
+}
+
+func TestSetPlural(t *testing.T) {
+	defer restore()
+	SetPlural(RegularSlice{{}, {}})
+	if len(pluralInflections) != 2 {
+		t.Errorf("Expected len 2, got %d", len(pluralInflections))
+	}
+}
+
+func TestSetSingular(t *testing.T) {
+	defer restore()
+	SetSingular(RegularSlice{{}, {}})
+	if len(singularInflections) != 2 {
+		t.Errorf("Expected len 2, got %d", len(singularInflections))
+	}
+}
+
+func TestSetIrregular(t *testing.T) {
+	defer restore()
+	SetIrregular(IrregularSlice{{}, {}})
+	if len(irregularInflections) != 2 {
+		t.Errorf("Expected len 2, got %d", len(irregularInflections))
+	}
+}
+
+func TestSetUncountable(t *testing.T) {
+	defer restore()
+	SetUncountable([]string{"", ""})
+	if len(uncountableInflections) != 2 {
+		t.Errorf("Expected len 2, got %d", len(uncountableInflections))
+	}
+}