[gold] Rename expectations.LabelStr as expectations.Label.
Step 3 of the plan outlined in skbug.com/10522.
Bug: skia:10522
Change-Id: I7d97c256bcc37d68facf348d83e17d0ec2dfdb7a
Reviewed-on: https://skia-review.googlesource.com/c/buildbot/+/304860
Commit-Queue: Leandro Lovisolo <lovisolo@google.com>
Reviewed-by: Kevin Lubick <kjlubick@google.com>
diff --git a/gold-client/go/goldclient/goldclient.go b/gold-client/go/goldclient/goldclient.go
index 0645b21..ce105b9 100644
--- a/gold-client/go/goldclient/goldclient.go
+++ b/gold-client/go/goldclient/goldclient.go
@@ -809,7 +809,7 @@
func (c *CloudClient) TriageAsPositive(testName types.TestName, digest types.Digest, algorithmName string) error {
// Build TriageRequest struct and encode it into JSON.
triageRequest := &frontend.TriageRequest{
- TestDigestStatus: map[types.TestName]map[types.Digest]expectations.LabelStr{testName: {digest: expectations.PositiveStr}},
+ TestDigestStatus: map[types.TestName]map[types.Digest]expectations.Label{testName: {digest: expectations.Positive}},
ChangeListID: c.resultState.SharedConfig.ChangeListID,
ImageMatchingAlgorithm: algorithmName,
}
diff --git a/golden/go/baseline/simple_baseliner/simple_baseliner_test.go b/golden/go/baseline/simple_baseliner/simple_baseliner_test.go
index d1a4d89..f110a5a 100644
--- a/golden/go/baseline/simple_baseliner/simple_baseliner_test.go
+++ b/golden/go/baseline/simple_baseliner/simple_baseliner_test.go
@@ -56,13 +56,13 @@
NuNewDigest := types.Digest("5555c0dab629ef092bc0dab629ef092b")
var additionalTriages expectations.Expectations
- additionalTriages.Set("brand-new-test", IotaNewDigest, expectations.PositiveStr)
- additionalTriages.Set("brand-new-test", KappaNewDigest, expectations.NegativeStr)
- additionalTriages.Set("brand-new-test", LambdaNewDigest, expectations.UntriagedStr)
- additionalTriages.Set(three_devices.BetaTest, MuNewDigest, expectations.PositiveStr)
- additionalTriages.Set(three_devices.BetaTest, NuNewDigest, expectations.UntriagedStr)
- additionalTriages.Set(three_devices.BetaTest, three_devices.BetaPositiveDigest, expectations.NegativeStr)
- additionalTriages.Set(three_devices.BetaTest, three_devices.BetaUntriagedDigest, expectations.PositiveStr)
+ additionalTriages.Set("brand-new-test", IotaNewDigest, expectations.Positive)
+ additionalTriages.Set("brand-new-test", KappaNewDigest, expectations.Negative)
+ additionalTriages.Set("brand-new-test", LambdaNewDigest, expectations.Untriaged)
+ additionalTriages.Set(three_devices.BetaTest, MuNewDigest, expectations.Positive)
+ additionalTriages.Set(three_devices.BetaTest, NuNewDigest, expectations.Untriaged)
+ additionalTriages.Set(three_devices.BetaTest, three_devices.BetaPositiveDigest, expectations.Negative)
+ additionalTriages.Set(three_devices.BetaTest, three_devices.BetaUntriagedDigest, expectations.Positive)
mes := &mock_expectations.Store{}
mesCL := &mock_expectations.Store{}
diff --git a/golden/go/blame/blame.go b/golden/go/blame/blame.go
index a2e6a4e..0aad9d5 100644
--- a/golden/go/blame/blame.go
+++ b/golden/go/blame/blame.go
@@ -172,7 +172,7 @@
}
status := exp.Classification(testName, digest)
- if (status == expectations.UntriagedStr) && !found[digest] {
+ if (status == expectations.Untriaged) && !found[digest] {
found[digest] = true
var startIdx int
diff --git a/golden/go/code_review/updater/updater_test.go b/golden/go/code_review/updater/updater_test.go
index a701711..fb8e412 100644
--- a/golden/go/code_review/updater/updater_test.go
+++ b/golden/go/code_review/updater/updater_test.go
@@ -39,11 +39,11 @@
commits := makeCommits()
var alphaChanges expectations.Expectations
- alphaChanges.Set(someTest, digestOne, expectations.NegativeStr)
+ alphaChanges.Set(someTest, digestOne, expectations.Negative)
alphaDelta := expectations.AsDelta(&alphaChanges)
var betaChanges expectations.Expectations
- betaChanges.Set(someTest, digestTwo, expectations.PositiveStr)
+ betaChanges.Set(someTest, digestTwo, expectations.Positive)
betaDelta := expectations.AsDelta(&betaChanges)
// This data is all arbitrary.
diff --git a/golden/go/digesttools/digesttools.go b/golden/go/digesttools/digesttools.go
index 068e73c..526d6a6 100644
--- a/golden/go/digesttools/digesttools.go
+++ b/golden/go/digesttools/digesttools.go
@@ -25,7 +25,7 @@
// or NoDigestFound if there aren't any positive digests.
//
// If no digest of type 'label' is found then Closest.Digest is the empty string.
- ClosestDigest(ctx context.Context, test types.TestName, digest types.Digest, label expectations.LabelStr) (*Closest, error)
+ ClosestDigest(ctx context.Context, test types.TestName, digest types.Digest, label expectations.Label) (*Closest, error)
}
// Closest describes one digest that is the closest another digest.
@@ -72,7 +72,7 @@
}
// ClosestDigest implements the ClosestDiffFinder interface.
-func (i *Impl) ClosestDigest(ctx context.Context, test types.TestName, digest types.Digest, label expectations.LabelStr) (*Closest, error) {
+func (i *Impl) ClosestDigest(ctx context.Context, test types.TestName, digest types.Digest, label expectations.Label) (*Closest, error) {
ret := newClosest()
// Locate all digests that this test produces and match the given label.
diff --git a/golden/go/digesttools/digesttools_test.go b/golden/go/digesttools/digesttools_test.go
index 8e2f9d2..e321b68 100644
--- a/golden/go/digesttools/digesttools_test.go
+++ b/golden/go/digesttools/digesttools_test.go
@@ -31,12 +31,12 @@
defer mdc.AssertExpectations(t)
var exp expectations.Expectations
- exp.Set(mockTest, mockDigestA, expectations.PositiveStr)
- exp.Set(mockTest, mockDigestB, expectations.NegativeStr)
- exp.Set(mockTest, mockDigestC, expectations.UntriagedStr)
- exp.Set(mockTest, mockDigestD, expectations.UntriagedStr)
- exp.Set(mockTest, mockDigestF, expectations.PositiveStr)
- exp.Set(mockTest, mockDigestG, expectations.PositiveStr)
+ exp.Set(mockTest, mockDigestA, expectations.Positive)
+ exp.Set(mockTest, mockDigestB, expectations.Negative)
+ exp.Set(mockTest, mockDigestC, expectations.Untriaged)
+ exp.Set(mockTest, mockDigestD, expectations.Untriaged)
+ exp.Set(mockTest, mockDigestF, expectations.Positive)
+ exp.Set(mockTest, mockDigestG, expectations.Positive)
digestCounts := map[types.TestName]digest_counter.DigestCount{
mockTest: {
@@ -60,7 +60,7 @@
expectedToCompareAgainst := types.DigestSlice{mockDigestA}
mds.On("Get", testutils.AnyContext, mockDigestF, expectedToCompareAgainst).Return(diffEIsClosest(), nil).Once()
// First test against a test that has positive digests.
- c, err := cdf.ClosestDigest(context.Background(), mockTest, mockDigestF, expectations.PositiveStr)
+ c, err := cdf.ClosestDigest(context.Background(), mockTest, mockDigestF, expectations.Positive)
require.NoError(t, err)
require.InDelta(t, 0.0372, float64(c.Diff), 0.01)
require.Equal(t, mockDigestE, c.Digest)
@@ -70,7 +70,7 @@
expectedToCompareAgainst = types.DigestSlice{mockDigestB}
mds.On("Get", testutils.AnyContext, mockDigestF, expectedToCompareAgainst).Return(diffBIsClosest(), nil).Once()
// Now test against negative digests.
- c, err = cdf.ClosestDigest(context.Background(), mockTest, mockDigestF, expectations.NegativeStr)
+ c, err = cdf.ClosestDigest(context.Background(), mockTest, mockDigestF, expectations.Negative)
require.NoError(t, err)
require.InDelta(t, 0.0558, float64(c.Diff), 0.01)
require.Equal(t, mockDigestB, c.Digest)
@@ -87,12 +87,12 @@
defer mdc.AssertExpectations(t)
var exp expectations.Expectations
- exp.Set(mockTest, mockDigestA, expectations.PositiveStr)
- exp.Set(mockTest, mockDigestB, expectations.NegativeStr)
- exp.Set(mockTest, mockDigestC, expectations.PositiveStr)
- exp.Set(mockTest, mockDigestD, expectations.PositiveStr)
- exp.Set(mockTest, mockDigestF, expectations.PositiveStr)
- exp.Set(mockTest, mockDigestG, expectations.PositiveStr)
+ exp.Set(mockTest, mockDigestA, expectations.Positive)
+ exp.Set(mockTest, mockDigestB, expectations.Negative)
+ exp.Set(mockTest, mockDigestC, expectations.Positive)
+ exp.Set(mockTest, mockDigestD, expectations.Positive)
+ exp.Set(mockTest, mockDigestF, expectations.Positive)
+ exp.Set(mockTest, mockDigestG, expectations.Positive)
digestCounts := map[types.TestName]digest_counter.DigestCount{
mockTest: {
@@ -121,14 +121,14 @@
mds.On("Get", testutils.AnyContext, mockDigestF, expectedDigests).Return(diffEIsClosest(), nil).Once()
- c, err := cdf.ClosestDigest(context.Background(), mockTest, mockDigestF, expectations.PositiveStr)
+ c, err := cdf.ClosestDigest(context.Background(), mockTest, mockDigestF, expectations.Positive)
require.NoError(t, err)
require.InDelta(t, 0.0372, float64(c.Diff), 0.01)
require.Equal(t, mockDigestE, c.Digest)
require.Equal(t, [4]int{5, 3, 4, 0}, c.MaxRGBA)
// Now test against a test with no digests at all in the latest tile.
- c, err = cdf.ClosestDigest(context.Background(), testThatDoesNotExist, mockDigestF, expectations.PositiveStr)
+ c, err = cdf.ClosestDigest(context.Background(), testThatDoesNotExist, mockDigestF, expectations.Positive)
require.NoError(t, err)
require.Equal(t, float32(math.MaxFloat32), c.Diff)
require.Equal(t, digesttools.NoDigestFound, c.Digest)
diff --git a/golden/go/expectations/cleanup/cleanup.go b/golden/go/expectations/cleanup/cleanup.go
index b9b1fab..d893700 100644
--- a/golden/go/expectations/cleanup/cleanup.go
+++ b/golden/go/expectations/cleanup/cleanup.go
@@ -76,7 +76,7 @@
for digest := range dc {
// Untriaged digests will not (usually) be in the DB, so we shouldn't try to
// update them.
- if classifier.Classification(tn, digest) == expectations.UntriagedStr {
+ if classifier.Classification(tn, digest) == expectations.Untriaged {
continue
}
expToUpdate = append(expToUpdate, expectations.ID{
diff --git a/golden/go/expectations/expectations.go b/golden/go/expectations/expectations.go
index 0ddf0c7..568730b 100644
--- a/golden/go/expectations/expectations.go
+++ b/golden/go/expectations/expectations.go
@@ -22,7 +22,7 @@
// digest types.Digest
// grouping types.TestName
// }
- labels map[types.TestName]map[types.Digest]LabelStr
+ labels map[types.TestName]map[types.Digest]Label
}
// Baseline is a simplified view of the Expectations, suitable for JSON encoding. A Baseline only
@@ -35,7 +35,7 @@
Classifier
// ForAll will iterate through all entries in Expectations and call the callback with them.
// Iteration will stop if a non-nil error is returned (and will be forwarded to the caller).
- ForAll(fn func(types.TestName, types.Digest, LabelStr) error) error
+ ForAll(fn func(types.TestName, types.Digest, Label) error) error
// Empty returns true iff NumTests() == 0
Empty() bool
@@ -51,37 +51,37 @@
type Classifier interface {
// Classification returns the label for the given test/digest pair. By definition,
// this will return Untriaged if there isn't already a classification set.
- Classification(test types.TestName, digest types.Digest) LabelStr
+ Classification(test types.TestName, digest types.Digest) Label
}
// Set sets the label for a test_name/digest pair. If the pair already exists,
// it will be over written.
-func (e *Expectations) Set(testName types.TestName, digest types.Digest, label LabelStr) {
+func (e *Expectations) Set(testName types.TestName, digest types.Digest, label Label) {
e.mutex.Lock()
defer e.mutex.Unlock()
e.ensureInit()
if digests, ok := e.labels[testName]; ok {
- if label == UntriagedStr {
+ if label == Untriaged {
delete(digests, digest)
} else {
digests[digest] = label
}
} else {
- if label != UntriagedStr {
- e.labels[testName] = map[types.Digest]LabelStr{digest: label}
+ if label != Untriaged {
+ e.labels[testName] = map[types.Digest]Label{digest: label}
}
}
}
// setDigests is a convenience function to set the expectations of a set of digests for a
// given test_name. Callers should have the write mutex locked.
-func (e *Expectations) setDigests(testName types.TestName, labels map[types.Digest]LabelStr) {
+func (e *Expectations) setDigests(testName types.TestName, labels map[types.Digest]Label) {
digests, ok := e.labels[testName]
if !ok {
- digests = make(map[types.Digest]LabelStr, len(labels))
+ digests = make(map[types.Digest]Label, len(labels))
}
for digest, label := range labels {
- if label != UntriagedStr {
+ if label != Untriaged {
digests[digest] = label
}
}
@@ -106,7 +106,7 @@
}
// ForAll implements the ReadOnly interface.
-func (e *Expectations) ForAll(fn func(types.TestName, types.Digest, LabelStr) error) error {
+func (e *Expectations) ForAll(fn func(types.TestName, types.Digest, Label) error) error {
e.mutex.RLock()
defer e.mutex.RUnlock()
for test, digests := range e.labels {
@@ -123,20 +123,20 @@
// DeepCopy makes a deep copy of the current expectations/baseline.
func (e *Expectations) DeepCopy() *Expectations {
ret := Expectations{
- labels: make(map[types.TestName]map[types.Digest]LabelStr, len(e.labels)),
+ labels: make(map[types.TestName]map[types.Digest]Label, len(e.labels)),
}
ret.MergeExpectations(e)
return &ret
}
// Classification implements the ReadOnly interface.
-func (e *Expectations) Classification(test types.TestName, digest types.Digest) LabelStr {
+func (e *Expectations) Classification(test types.TestName, digest types.Digest) Label {
e.mutex.RLock()
defer e.mutex.RUnlock()
if label, ok := e.labels[test][digest]; ok {
return label
}
- return UntriagedStr
+ return Untriaged
}
// Empty implements the ReadOnly interface.
@@ -199,11 +199,11 @@
e.mutex.RLock()
defer e.mutex.RUnlock()
n := Expectations{
- labels: map[types.TestName]map[types.Digest]LabelStr{},
+ labels: map[types.TestName]map[types.Digest]Label{},
}
for testName, digests := range e.labels {
for d, c := range digests {
- if c != UntriagedStr {
+ if c != Untriaged {
n.Set(testName, d, c)
}
}
@@ -216,7 +216,7 @@
for testName, digestToLabelStrMap := range n.labels {
digestToLabelMap := map[types.Digest]LabelInt{}
for digest, labelStr := range digestToLabelStrMap {
- digestToLabelMap[digest] = LabelFromString(labelStr)
+ digestToLabelMap[digest] = LabelIntFromString(labelStr)
}
baseline[testName] = digestToLabelMap
}
@@ -227,7 +227,7 @@
// ensureInit expects that the write mutex is held prior to entry.
func (e *Expectations) ensureInit() {
if e.labels == nil {
- e.labels = map[types.TestName]map[types.Digest]LabelStr{}
+ e.labels = map[types.TestName]map[types.Digest]Label{}
}
}
@@ -246,13 +246,13 @@
// Classification returns the first non-untriaged label for the given
// test and digest. If none of the given ReadOnly have a match, Untriaged is returned.
-func (e JoinedExp) Classification(test types.TestName, digest types.Digest) LabelStr {
+func (e JoinedExp) Classification(test types.TestName, digest types.Digest) Label {
for _, exp := range e {
- if label := exp.Classification(test, digest); label != UntriagedStr {
+ if label := exp.Classification(test, digest); label != Untriaged {
return label
}
}
- return UntriagedStr
+ return Untriaged
}
// EmptyClassifier returns a Classifier which returns Untriaged for given input.
diff --git a/golden/go/expectations/expectations_test.go b/golden/go/expectations/expectations_test.go
index edf88ec..e6ba116 100644
--- a/golden/go/expectations/expectations_test.go
+++ b/golden/go/expectations/expectations_test.go
@@ -15,31 +15,31 @@
unittest.SmallTest(t)
var e Expectations
- e.Set("a", "pos", PositiveStr)
- e.Set("b", "neg", NegativeStr)
- e.Set("c", "untr", PositiveStr)
- e.Set("c", "untr", UntriagedStr)
+ e.Set("a", "pos", Positive)
+ e.Set("b", "neg", Negative)
+ e.Set("c", "untr", Positive)
+ e.Set("c", "untr", Untriaged)
- assert.Equal(t, e.Classification("a", "pos"), PositiveStr)
- assert.Equal(t, e.Classification("b", "neg"), NegativeStr)
- assert.Equal(t, e.Classification("c", "untr"), UntriagedStr)
- assert.Equal(t, e.Classification("d", "also_untriaged"), UntriagedStr)
- assert.Equal(t, e.Classification("a", "nope"), UntriagedStr)
- assert.Equal(t, e.Classification("b", "pos"), UntriagedStr)
+ assert.Equal(t, e.Classification("a", "pos"), Positive)
+ assert.Equal(t, e.Classification("b", "neg"), Negative)
+ assert.Equal(t, e.Classification("c", "untr"), Untriaged)
+ assert.Equal(t, e.Classification("d", "also_untriaged"), Untriaged)
+ assert.Equal(t, e.Classification("a", "nope"), Untriaged)
+ assert.Equal(t, e.Classification("b", "pos"), Untriaged)
assert.Equal(t, 2, e.Len())
assert.Equal(t, 3, e.NumTests()) // c was seen, but has all untriaged entries
- e.Set("c", "untr", PositiveStr)
- assert.Equal(t, e.Classification("c", "untr"), PositiveStr)
- assert.Equal(t, e.Classification("c", "nope"), UntriagedStr)
- assert.Equal(t, e.Classification("a", "nope"), UntriagedStr)
+ e.Set("c", "untr", Positive)
+ assert.Equal(t, e.Classification("c", "untr"), Positive)
+ assert.Equal(t, e.Classification("c", "nope"), Untriaged)
+ assert.Equal(t, e.Classification("a", "nope"), Untriaged)
assert.Equal(t, 3, e.Len())
assert.Equal(t, 3, e.NumTests())
- e.Set("a", "oops", NegativeStr)
- assert.Equal(t, e.Classification("a", "oops"), NegativeStr)
+ e.Set("a", "oops", Negative)
+ assert.Equal(t, e.Classification("a", "oops"), Negative)
assert.Equal(t, 4, e.Len())
assert.Equal(t, 3, e.NumTests())
}
@@ -48,32 +48,32 @@
unittest.SmallTest(t)
var e Expectations
- e.Set("a", "pos", PositiveStr)
- e.Set("b", "neg", PositiveStr)
- e.Set("c", "untr", UntriagedStr)
+ e.Set("a", "pos", Positive)
+ e.Set("b", "neg", Positive)
+ e.Set("c", "untr", Untriaged)
- f := Expectations{} // test both ways of initialization
- f.Set("a", "neg", NegativeStr) // creates new in existing test
- f.Set("b", "neg", NegativeStr) // overwrites previous
- f.Set("d", "neg", NegativeStr) // creates new test
+ f := Expectations{} // test both ways of initialization
+ f.Set("a", "neg", Negative) // creates new in existing test
+ f.Set("b", "neg", Negative) // overwrites previous
+ f.Set("d", "neg", Negative) // creates new test
e.MergeExpectations(&f)
e.MergeExpectations(nil)
- assert.Equal(t, PositiveStr, e.Classification("a", "pos"))
- assert.Equal(t, NegativeStr, e.Classification("a", "neg"))
- assert.Equal(t, NegativeStr, e.Classification("b", "neg"))
- assert.Equal(t, UntriagedStr, e.Classification("c", "untr"))
- assert.Equal(t, NegativeStr, e.Classification("d", "neg"))
+ assert.Equal(t, Positive, e.Classification("a", "pos"))
+ assert.Equal(t, Negative, e.Classification("a", "neg"))
+ assert.Equal(t, Negative, e.Classification("b", "neg"))
+ assert.Equal(t, Untriaged, e.Classification("c", "untr"))
+ assert.Equal(t, Negative, e.Classification("d", "neg"))
assert.Equal(t, 4, e.Len())
// f should be unchanged
- assert.Equal(t, UntriagedStr, f.Classification("a", "pos"))
- assert.Equal(t, NegativeStr, f.Classification("a", "neg"))
- assert.Equal(t, NegativeStr, f.Classification("b", "neg"))
- assert.Equal(t, UntriagedStr, f.Classification("c", "untr"))
- assert.Equal(t, NegativeStr, f.Classification("d", "neg"))
+ assert.Equal(t, Untriaged, f.Classification("a", "pos"))
+ assert.Equal(t, Negative, f.Classification("a", "neg"))
+ assert.Equal(t, Negative, f.Classification("b", "neg"))
+ assert.Equal(t, Untriaged, f.Classification("c", "untr"))
+ assert.Equal(t, Negative, f.Classification("d", "neg"))
assert.Equal(t, 3, f.Len())
}
@@ -81,30 +81,30 @@
unittest.SmallTest(t)
var e Expectations
- e.Set("a", "pos", PositiveStr)
- e.Set("b", "neg", NegativeStr)
- e.Set("c", "pos", PositiveStr)
- e.Set("c", "untr", UntriagedStr)
+ e.Set("a", "pos", Positive)
+ e.Set("b", "neg", Negative)
+ e.Set("c", "pos", Positive)
+ e.Set("c", "untr", Untriaged)
- labels := map[types.TestName]map[types.Digest]LabelStr{}
- err := e.ForAll(func(testName types.TestName, d types.Digest, l LabelStr) error {
+ labels := map[types.TestName]map[types.Digest]Label{}
+ err := e.ForAll(func(testName types.TestName, d types.Digest, l Label) error {
if digests, ok := labels[testName]; ok {
digests[d] = l
} else {
- labels[testName] = map[types.Digest]LabelStr{d: l}
+ labels[testName] = map[types.Digest]Label{d: l}
}
return nil
})
require.NoError(t, err)
- assert.Equal(t, map[types.TestName]map[types.Digest]LabelStr{
+ assert.Equal(t, map[types.TestName]map[types.Digest]Label{
"a": {
- "pos": PositiveStr,
+ "pos": Positive,
},
"b": {
- "neg": NegativeStr,
+ "neg": Negative,
},
"c": {
- "pos": PositiveStr,
+ "pos": Positive,
},
}, labels)
}
@@ -114,13 +114,13 @@
unittest.SmallTest(t)
var e Expectations
- e.Set("a", "pos", PositiveStr)
- e.Set("b", "neg", NegativeStr)
- e.Set("c", "pos", PositiveStr)
- e.Set("c", "untr", UntriagedStr)
+ e.Set("a", "pos", Positive)
+ e.Set("b", "neg", Negative)
+ e.Set("c", "pos", Positive)
+ e.Set("c", "untr", Untriaged)
counter := 0
- err := e.ForAll(func(testName types.TestName, d types.Digest, l LabelStr) error {
+ err := e.ForAll(func(testName types.TestName, d types.Digest, l Label) error {
if counter == 2 {
return errors.New("oops")
}
@@ -137,17 +137,17 @@
unittest.SmallTest(t)
var e Expectations
- e.Set("a", "pos", PositiveStr)
+ e.Set("a", "pos", Positive)
f := e.DeepCopy()
- e.Set("b", "neg", NegativeStr)
- f.Set("b", "neg", PositiveStr)
+ e.Set("b", "neg", Negative)
+ f.Set("b", "neg", Positive)
- require.Equal(t, PositiveStr, e.Classification("a", "pos"))
- require.Equal(t, NegativeStr, e.Classification("b", "neg"))
+ require.Equal(t, Positive, e.Classification("a", "pos"))
+ require.Equal(t, Negative, e.Classification("b", "neg"))
- require.Equal(t, PositiveStr, f.Classification("a", "pos"))
- require.Equal(t, PositiveStr, f.Classification("b", "neg"))
+ require.Equal(t, Positive, f.Classification("a", "pos"))
+ require.Equal(t, Positive, f.Classification("b", "neg"))
}
func TestCounts(t *testing.T) {
@@ -157,11 +157,11 @@
require.True(t, e.Empty())
require.Equal(t, 0, e.NumTests())
require.Equal(t, 0, e.Len())
- e.Set("a", "pos", PositiveStr)
- e.Set("b", "neg", NegativeStr)
- e.Set("c", "untr", UntriagedStr)
- e.Set("c", "pos", PositiveStr)
- e.Set("c", "neg", NegativeStr)
+ e.Set("a", "pos", Positive)
+ e.Set("b", "neg", Negative)
+ e.Set("c", "untr", Untriaged)
+ e.Set("c", "pos", Positive)
+ e.Set("c", "neg", Negative)
require.False(t, e.Empty())
assert.Equal(t, 3, e.NumTests())
@@ -177,16 +177,16 @@
func TestExpString(t *testing.T) {
unittest.SmallTest(t)
te := Expectations{
- labels: map[types.TestName]map[types.Digest]LabelStr{
+ labels: map[types.TestName]map[types.Digest]Label{
"beta": {
- "hash1": PositiveStr,
- "hash3": NegativeStr,
- "hash2": UntriagedStr,
+ "hash1": Positive,
+ "hash3": Negative,
+ "hash2": Untriaged,
},
"alpha": {
- "hashB": UntriagedStr,
- "hashA": NegativeStr,
- "hashC": UntriagedStr,
+ "hashB": Untriaged,
+ "hashA": Negative,
+ "hashC": Untriaged,
},
},
}
@@ -205,22 +205,22 @@
func TestAsBaseline(t *testing.T) {
unittest.SmallTest(t)
input := Expectations{
- labels: map[types.TestName]map[types.Digest]LabelStr{
+ labels: map[types.TestName]map[types.Digest]Label{
"gamma": {
- "hashX": UntriagedStr,
- "hashY": UntriagedStr,
- "hashZ": UntriagedStr,
+ "hashX": Untriaged,
+ "hashY": Untriaged,
+ "hashZ": Untriaged,
},
"beta": {
- "hash1": PositiveStr,
- "hash3": NegativeStr,
- "hash2": UntriagedStr,
- "hash4": PositiveStr,
+ "hash1": Positive,
+ "hash3": Negative,
+ "hash2": Untriaged,
+ "hash4": Positive,
},
"alpha": {
- "hashB": UntriagedStr,
- "hashA": NegativeStr,
- "hashC": UntriagedStr,
+ "hashB": Untriaged,
+ "hashA": Negative,
+ "hashC": Untriaged,
},
},
}
@@ -251,27 +251,27 @@
unittest.SmallTest(t)
var masterE Expectations
- masterE.Set(testName, alphaPositiveDigest, PositiveStr)
- masterE.Set(testName, betaNegativeDigest, PositiveStr)
+ masterE.Set(testName, alphaPositiveDigest, Positive)
+ masterE.Set(testName, betaNegativeDigest, Positive)
var changeListE Expectations
- changeListE.Set(testName, gammaPositiveDigest, PositiveStr)
- changeListE.Set(testName, betaNegativeDigest, NegativeStr) // this should win
+ changeListE.Set(testName, gammaPositiveDigest, Positive)
+ changeListE.Set(testName, betaNegativeDigest, Negative) // this should win
e := Join(&changeListE, &masterE)
- assert.Equal(t, PositiveStr, e.Classification(testName, alphaPositiveDigest))
- assert.Equal(t, PositiveStr, e.Classification(testName, gammaPositiveDigest))
- assert.Equal(t, NegativeStr, e.Classification(testName, betaNegativeDigest))
- assert.Equal(t, UntriagedStr, e.Classification(testName, untriagedDigest))
+ assert.Equal(t, Positive, e.Classification(testName, alphaPositiveDigest))
+ assert.Equal(t, Positive, e.Classification(testName, gammaPositiveDigest))
+ assert.Equal(t, Negative, e.Classification(testName, betaNegativeDigest))
+ assert.Equal(t, Untriaged, e.Classification(testName, untriagedDigest))
}
func TestEmptyClassifier(t *testing.T) {
unittest.SmallTest(t)
e := EmptyClassifier()
- assert.Equal(t, UntriagedStr, e.Classification(testName, alphaPositiveDigest))
- assert.Equal(t, UntriagedStr, e.Classification(testName, gammaPositiveDigest))
- assert.Equal(t, UntriagedStr, e.Classification(testName, betaNegativeDigest))
- assert.Equal(t, UntriagedStr, e.Classification(testName, untriagedDigest))
+ assert.Equal(t, Untriaged, e.Classification(testName, alphaPositiveDigest))
+ assert.Equal(t, Untriaged, e.Classification(testName, gammaPositiveDigest))
+ assert.Equal(t, Untriaged, e.Classification(testName, betaNegativeDigest))
+ assert.Equal(t, Untriaged, e.Classification(testName, untriagedDigest))
}
diff --git a/golden/go/expectations/fs_expectationstore/fs_expstore.go b/golden/go/expectations/fs_expectationstore/fs_expstore.go
index 492ed68..cb1d256 100644
--- a/golden/go/expectations/fs_expectationstore/fs_expstore.go
+++ b/golden/go/expectations/fs_expectationstore/fs_expstore.go
@@ -410,7 +410,7 @@
newRange := triageRange{
FirstIndex: firstIdx,
LastIndex: lastIdx,
- Label: expectations.LabelFromString(d.Label),
+ Label: expectations.LabelIntFromString(d.Label),
}
previousLabel := expectations.UntriagedInt
replacedRange := false
diff --git a/golden/go/expectations/fs_expectationstore/fs_expstore_test.go b/golden/go/expectations/fs_expectationstore/fs_expstore_test.go
index d444c39..a98b68f 100644
--- a/golden/go/expectations/fs_expectationstore/fs_expstore_test.go
+++ b/golden/go/expectations/fs_expectationstore/fs_expstore_test.go
@@ -52,12 +52,12 @@
{
Grouping: data.AlphaTest,
Digest: data.AlphaUntriagedDigest,
- Label: expectations.PositiveStr, // Intentionally wrong. Will be fixed by the next AddChange.
+ Label: expectations.Positive, // Intentionally wrong. Will be fixed by the next AddChange.
},
{
Grouping: data.AlphaTest,
Digest: data.AlphaPositiveDigest,
- Label: expectations.PositiveStr,
+ Label: expectations.Positive,
},
}, userOne)
require.NoError(t, err)
@@ -66,17 +66,17 @@
{
Grouping: data.AlphaTest,
Digest: data.AlphaNegativeDigest,
- Label: expectations.NegativeStr,
+ Label: expectations.Negative,
},
{
Grouping: data.AlphaTest,
Digest: data.AlphaUntriagedDigest, // overwrites previous
- Label: expectations.UntriagedStr,
+ Label: expectations.Untriaged,
},
{
Grouping: data.BetaTest,
Digest: data.BetaPositiveDigest,
- Label: expectations.PositiveStr,
+ Label: expectations.Positive,
},
}, userTwo)
require.NoError(t, err)
@@ -112,12 +112,12 @@
{
Grouping: data.AlphaTest,
Digest: data.AlphaUntriagedDigest,
- Label: expectations.PositiveStr,
+ Label: expectations.Positive,
},
{
Grouping: data.AlphaTest,
Digest: data.AlphaPositiveDigest,
- Label: expectations.PositiveStr,
+ Label: expectations.Positive,
},
}, userOne)
require.NoError(t, err)
@@ -126,17 +126,17 @@
{
Grouping: data.AlphaTest,
Digest: data.AlphaNegativeDigest,
- Label: expectations.NegativeStr,
+ Label: expectations.Negative,
},
{
Grouping: data.AlphaTest,
Digest: data.AlphaUntriagedDigest, // overwrites previous
- Label: expectations.UntriagedStr,
+ Label: expectations.Untriaged,
},
{
Grouping: data.BetaTest,
Digest: data.BetaPositiveDigest,
- Label: expectations.PositiveStr,
+ Label: expectations.Positive,
},
}, userTwo)
require.NoError(t, err)
@@ -165,11 +165,11 @@
}
func assertExpectationsMatchDefaults(t *testing.T, e expectations.ReadOnly) {
- assert.Equal(t, expectations.PositiveStr, e.Classification(data.AlphaTest, data.AlphaPositiveDigest))
- assert.Equal(t, expectations.NegativeStr, e.Classification(data.AlphaTest, data.AlphaNegativeDigest))
- assert.Equal(t, expectations.UntriagedStr, e.Classification(data.AlphaTest, data.AlphaUntriagedDigest))
- assert.Equal(t, expectations.PositiveStr, e.Classification(data.BetaTest, data.BetaPositiveDigest))
- assert.Equal(t, expectations.UntriagedStr, e.Classification(data.BetaTest, data.BetaUntriagedDigest))
+ assert.Equal(t, expectations.Positive, e.Classification(data.AlphaTest, data.AlphaPositiveDigest))
+ assert.Equal(t, expectations.Negative, e.Classification(data.AlphaTest, data.AlphaNegativeDigest))
+ assert.Equal(t, expectations.Untriaged, e.Classification(data.AlphaTest, data.AlphaUntriagedDigest))
+ assert.Equal(t, expectations.Positive, e.Classification(data.BetaTest, data.BetaPositiveDigest))
+ assert.Equal(t, expectations.Untriaged, e.Classification(data.BetaTest, data.BetaUntriagedDigest))
assert.Equal(t, 3, e.Len())
}
@@ -187,17 +187,17 @@
clExps, err := clStore.GetCopy(ctx)
require.NoError(t, err)
assert.Equal(t, 1, clExps.Len())
- assert.Equal(t, expectations.PositiveStr, clExps.Classification(data.AlphaTest, data.AlphaPositiveDigest))
- assert.Equal(t, expectations.UntriagedStr, clExps.Classification(data.AlphaTest, data.AlphaUntriagedDigest))
+ assert.Equal(t, expectations.Positive, clExps.Classification(data.AlphaTest, data.AlphaPositiveDigest))
+ assert.Equal(t, expectations.Untriaged, clExps.Classification(data.AlphaTest, data.AlphaUntriagedDigest))
- clExps.Set(data.AlphaTest, data.AlphaPositiveDigest, expectations.NegativeStr)
- clExps.Set(data.AlphaTest, data.AlphaUntriagedDigest, expectations.PositiveStr)
+ clExps.Set(data.AlphaTest, data.AlphaPositiveDigest, expectations.Negative)
+ clExps.Set(data.AlphaTest, data.AlphaUntriagedDigest, expectations.Positive)
shouldBeUnaffected, err := clStore.GetCopy(ctx)
require.NoError(t, err)
assert.Equal(t, 1, shouldBeUnaffected.Len())
- assert.Equal(t, expectations.PositiveStr, shouldBeUnaffected.Classification(data.AlphaTest, data.AlphaPositiveDigest))
- assert.Equal(t, expectations.UntriagedStr, shouldBeUnaffected.Classification(data.AlphaTest, data.AlphaUntriagedDigest))
+ assert.Equal(t, expectations.Positive, shouldBeUnaffected.Classification(data.AlphaTest, data.AlphaPositiveDigest))
+ assert.Equal(t, expectations.Untriaged, shouldBeUnaffected.Classification(data.AlphaTest, data.AlphaUntriagedDigest))
}
// TestGetCopy_MasterPartition_CallerMutatesReturnValue_StoreUnaffected mutates the result of
@@ -225,17 +225,17 @@
masterExps, err := masterStore.GetCopy(ctx)
require.NoError(t, err)
assert.Equal(t, 1, masterExps.Len())
- assert.Equal(t, expectations.PositiveStr, masterExps.Classification(data.AlphaTest, data.AlphaPositiveDigest))
- assert.Equal(t, expectations.UntriagedStr, masterExps.Classification(data.AlphaTest, data.AlphaUntriagedDigest))
+ assert.Equal(t, expectations.Positive, masterExps.Classification(data.AlphaTest, data.AlphaPositiveDigest))
+ assert.Equal(t, expectations.Untriaged, masterExps.Classification(data.AlphaTest, data.AlphaUntriagedDigest))
- masterExps.Set(data.AlphaTest, data.AlphaPositiveDigest, expectations.NegativeStr)
- masterExps.Set(data.AlphaTest, data.AlphaUntriagedDigest, expectations.PositiveStr)
+ masterExps.Set(data.AlphaTest, data.AlphaPositiveDigest, expectations.Negative)
+ masterExps.Set(data.AlphaTest, data.AlphaUntriagedDigest, expectations.Positive)
shouldBeUnaffected, err := masterStore.GetCopy(ctx)
require.NoError(t, err)
assert.Equal(t, 1, shouldBeUnaffected.Len())
- assert.Equal(t, expectations.PositiveStr, shouldBeUnaffected.Classification(data.AlphaTest, data.AlphaPositiveDigest))
- assert.Equal(t, expectations.UntriagedStr, shouldBeUnaffected.Classification(data.AlphaTest, data.AlphaUntriagedDigest))
+ assert.Equal(t, expectations.Positive, shouldBeUnaffected.Classification(data.AlphaTest, data.AlphaPositiveDigest))
+ assert.Equal(t, expectations.Untriaged, shouldBeUnaffected.Classification(data.AlphaTest, data.AlphaUntriagedDigest))
}
// TestInitialize_ExpectationCacheIsFilledAndUpdated_Success has both a read-write and a read-only
@@ -267,9 +267,9 @@
assert.Len(t, readOnly.entryCache, 3)
roExps, err := readOnly.Get(ctx)
require.NoError(t, err)
- assert.Equal(t, expectations.PositiveStr, roExps.Classification(data.AlphaTest, data.AlphaPositiveDigest))
- assert.Equal(t, expectations.NegativeStr, roExps.Classification(data.AlphaTest, data.AlphaNegativeDigest))
- assert.Equal(t, expectations.PositiveStr, roExps.Classification(data.AlphaTest, firstPositiveThenUntriaged))
+ assert.Equal(t, expectations.Positive, roExps.Classification(data.AlphaTest, data.AlphaPositiveDigest))
+ assert.Equal(t, expectations.Negative, roExps.Classification(data.AlphaTest, data.AlphaNegativeDigest))
+ assert.Equal(t, expectations.Positive, roExps.Classification(data.AlphaTest, firstPositiveThenUntriaged))
// This should update the existing entry, leaving us with 4 total entries, not 5
putEntry(ctx, t, masterStore, data.AlphaTest, firstPositiveThenUntriaged, expectations.UntriagedInt, userOne)
@@ -284,11 +284,11 @@
roExps2, err := readOnly.Get(ctx)
require.NoError(t, err)
assertExpectationsMatchDefaults(t, roExps2)
- assert.Equal(t, expectations.UntriagedStr, roExps2.Classification(data.AlphaTest, firstPositiveThenUntriaged))
+ assert.Equal(t, expectations.Untriaged, roExps2.Classification(data.AlphaTest, firstPositiveThenUntriaged))
// Spot check that the expectations we got first were not impacted by the new expectations
// coming in or the second call to Get.
- assert.Equal(t, expectations.PositiveStr, roExps.Classification(data.AlphaTest, firstPositiveThenUntriaged))
+ assert.Equal(t, expectations.Positive, roExps.Classification(data.AlphaTest, firstPositiveThenUntriaged))
assert.Equal(t, 5, countExpectationChanges(ctx, t, masterStore))
assert.Equal(t, 5, countTriageRecords(ctx, t, masterStore))
@@ -310,27 +310,27 @@
{
Grouping: data.AlphaTest,
Digest: data.AlphaUntriagedDigest,
- Label: expectations.UntriagedStr,
+ Label: expectations.Untriaged,
},
{
Grouping: data.AlphaTest,
Digest: data.AlphaNegativeDigest,
- Label: expectations.NegativeStr,
+ Label: expectations.Negative,
},
{
Grouping: data.AlphaTest,
Digest: data.AlphaPositiveDigest,
- Label: expectations.PositiveStr,
+ Label: expectations.Positive,
},
{
Grouping: data.BetaTest,
Digest: data.BetaPositiveDigest,
- Label: expectations.PositiveStr,
+ Label: expectations.Positive,
},
{
Grouping: data.BetaTest,
Digest: data.BetaUntriagedDigest,
- Label: expectations.UntriagedStr,
+ Label: expectations.Untriaged,
},
}
@@ -402,15 +402,15 @@
require.NoError(t, err)
// Make sure the CL expectations did not leak to the master expectations
- assert.Equal(t, expectations.NegativeStr, masterExps.Classification(data.AlphaTest, data.AlphaPositiveDigest))
- assert.Equal(t, expectations.NegativeStr, masterExps.Classification(data.AlphaTest, data.AlphaNegativeDigest))
- assert.Equal(t, expectations.UntriagedStr, masterExps.Classification(data.BetaTest, data.BetaPositiveDigest))
+ assert.Equal(t, expectations.Negative, masterExps.Classification(data.AlphaTest, data.AlphaPositiveDigest))
+ assert.Equal(t, expectations.Negative, masterExps.Classification(data.AlphaTest, data.AlphaNegativeDigest))
+ assert.Equal(t, expectations.Untriaged, masterExps.Classification(data.BetaTest, data.BetaPositiveDigest))
assert.Equal(t, 2, masterExps.Len())
// Make sure the CL expectations are separate from the master expectations.
- assert.Equal(t, expectations.PositiveStr, clExps.Classification(data.AlphaTest, data.AlphaPositiveDigest))
- assert.Equal(t, expectations.UntriagedStr, clExps.Classification(data.AlphaTest, data.AlphaNegativeDigest))
- assert.Equal(t, expectations.PositiveStr, clExps.Classification(data.BetaTest, data.BetaPositiveDigest))
+ assert.Equal(t, expectations.Positive, clExps.Classification(data.AlphaTest, data.AlphaPositiveDigest))
+ assert.Equal(t, expectations.Untriaged, clExps.Classification(data.AlphaTest, data.AlphaNegativeDigest))
+ assert.Equal(t, expectations.Positive, clExps.Classification(data.BetaTest, data.BetaPositiveDigest))
assert.Equal(t, 2, clExps.Len())
}
@@ -482,19 +482,19 @@
{
Grouping: data.AlphaTest,
Digest: data.AlphaPositiveDigest,
- Label: expectations.PositiveStr,
+ Label: expectations.Positive,
},
}
change2 := []expectations.Delta{
{
Grouping: data.AlphaTest,
Digest: data.AlphaNegativeDigest,
- Label: expectations.NegativeStr,
+ Label: expectations.Negative,
},
{
Grouping: data.BetaTest,
Digest: data.BetaPositiveDigest,
- Label: expectations.PositiveStr,
+ Label: expectations.Positive,
},
}
@@ -524,12 +524,12 @@
{
Grouping: data.AlphaTest,
Digest: data.AlphaNegativeDigest,
- Label: expectations.PositiveStr,
+ Label: expectations.Positive,
},
{
Grouping: data.AlphaTest,
Digest: data.AlphaPositiveDigest,
- Label: expectations.PositiveStr,
+ Label: expectations.Positive,
},
}, userOne)
require.NoError(t, err)
@@ -538,7 +538,7 @@
{
Grouping: data.AlphaTest,
Digest: data.AlphaNegativeDigest,
- Label: expectations.NegativeStr,
+ Label: expectations.Negative,
},
}, userTwo)
require.NoError(t, err)
@@ -652,12 +652,12 @@
{
Grouping: data.AlphaTest,
Digest: data.AlphaNegativeDigest,
- Label: expectations.PositiveStr,
+ Label: expectations.Positive,
},
{
Grouping: data.AlphaTest,
Digest: data.AlphaPositiveDigest,
- Label: expectations.PositiveStr,
+ Label: expectations.Positive,
},
}, userOne)
require.NoError(t, err)
@@ -668,7 +668,7 @@
{
Grouping: data.AlphaTest,
Digest: data.AlphaNegativeDigest,
- Label: expectations.NegativeStr,
+ Label: expectations.Negative,
},
}, userTwo)
require.NoError(t, err)
@@ -723,12 +723,12 @@
{
Grouping: data.AlphaTest,
Digest: data.AlphaNegativeDigest,
- Label: expectations.NegativeStr,
+ Label: expectations.Negative,
},
{
Grouping: data.BetaTest,
Digest: data.BetaPositiveDigest,
- Label: expectations.PositiveStr,
+ Label: expectations.Positive,
},
}, userTwo)
require.NoError(t, err)
@@ -798,12 +798,12 @@
{
Grouping: data.AlphaTest,
Digest: data.AlphaNegativeDigest,
- Label: expectations.NegativeStr,
+ Label: expectations.Negative,
},
{
Grouping: data.BetaTest,
Digest: data.BetaPositiveDigest,
- Label: expectations.PositiveStr,
+ Label: expectations.Positive,
},
}, userTwo)
require.NoError(t, err)
@@ -878,12 +878,12 @@
{
Grouping: data.AlphaTest,
Digest: data.AlphaNegativeDigest,
- Label: expectations.NegativeStr,
+ Label: expectations.Negative,
},
{
Grouping: data.BetaTest,
Digest: data.BetaPositiveDigest,
- Label: expectations.PositiveStr,
+ Label: expectations.Positive,
},
}, userTwo)
require.NoError(t, err)
@@ -903,12 +903,12 @@
{
Grouping: data.AlphaTest,
Digest: data.AlphaNegativeDigest,
- Label: expectations.NegativeStr,
+ Label: expectations.Negative,
},
{
Grouping: data.BetaTest,
Digest: data.BetaPositiveDigest,
- Label: expectations.PositiveStr,
+ Label: expectations.Positive,
},
},
},
@@ -921,7 +921,7 @@
{
Grouping: data.AlphaTest,
Digest: data.AlphaPositiveDigest,
- Label: expectations.PositiveStr,
+ Label: expectations.Positive,
},
},
},
@@ -947,7 +947,7 @@
delta = append(delta, expectations.Delta{
Grouping: n,
Digest: d,
- Label: expectations.PositiveStr,
+ Label: expectations.Positive,
})
}
err := masterStore.AddChange(ctx, delta, "test@example.com")
@@ -966,27 +966,27 @@
require.Equal(t, expectations.Delta{
Grouping: "test_000",
Digest: "00000000000000000000000000000000",
- Label: expectations.PositiveStr,
+ Label: expectations.Positive,
}, entry.Details[0])
require.Equal(t, expectations.Delta{
Grouping: "test_200",
Digest: "00000000000000000000000000000200",
- Label: expectations.PositiveStr,
+ Label: expectations.Positive,
}, entry.Details[200])
require.Equal(t, expectations.Delta{
Grouping: "test_400",
Digest: "00000000000000000000000000000400",
- Label: expectations.PositiveStr,
+ Label: expectations.Positive,
}, entry.Details[400])
require.Equal(t, expectations.Delta{
Grouping: "test_600",
Digest: "00000000000000000000000000000600",
- Label: expectations.PositiveStr,
+ Label: expectations.Positive,
}, entry.Details[600])
require.Equal(t, expectations.Delta{
Grouping: "test_799",
Digest: "00000000000000000000000000000799",
- Label: expectations.PositiveStr,
+ Label: expectations.Positive,
}, entry.Details[799])
}
@@ -1014,8 +1014,8 @@
masterExps, err := masterStore.Get(ctx)
require.NoError(t, err)
- assert.Equal(t, expectations.PositiveStr, masterExps.Classification(data.AlphaTest, data.AlphaPositiveDigest))
- assert.Equal(t, expectations.NegativeStr, masterExps.Classification(data.AlphaTest, data.AlphaNegativeDigest))
+ assert.Equal(t, expectations.Positive, masterExps.Classification(data.AlphaTest, data.AlphaPositiveDigest))
+ assert.Equal(t, expectations.Negative, masterExps.Classification(data.AlphaTest, data.AlphaNegativeDigest))
// Check that the undo shows up as the most recent entry.
entries, _, err = masterStore.QueryLog(ctx, 0, 10, true)
@@ -1027,7 +1027,7 @@
assert.Equal(t, expectations.Delta{
Grouping: data.AlphaTest,
Digest: data.AlphaPositiveDigest,
- Label: expectations.PositiveStr,
+ Label: expectations.Positive,
}, undidEntry.Details[0])
}
@@ -1056,8 +1056,8 @@
exp, err := clStore.Get(ctx)
require.NoError(t, err)
- assert.Equal(t, expectations.PositiveStr, exp.Classification(data.AlphaTest, data.AlphaPositiveDigest))
- assert.Equal(t, expectations.NegativeStr, exp.Classification(data.AlphaTest, data.AlphaNegativeDigest))
+ assert.Equal(t, expectations.Positive, exp.Classification(data.AlphaTest, data.AlphaPositiveDigest))
+ assert.Equal(t, expectations.Negative, exp.Classification(data.AlphaTest, data.AlphaNegativeDigest))
// Check that the undo shows up as the most recent entry.
entries, _, err = clStore.QueryLog(ctx, 0, 10, true)
@@ -1069,7 +1069,7 @@
assert.Equal(t, expectations.Delta{
Grouping: data.AlphaTest,
Digest: data.AlphaPositiveDigest,
- Label: expectations.PositiveStr,
+ Label: expectations.Positive,
}, undidEntry.Details[0])
}
@@ -1390,7 +1390,7 @@
{
Grouping: entryOneGrouping,
Digest: entryOneDigest,
- Label: expectations.PositiveStr,
+ Label: expectations.Positive,
},
}, "test@example.com")
require.NoError(t, err)
@@ -1567,11 +1567,11 @@
for j := 0; j < 32; j++ {
tn := types.TestName(fmt.Sprintf("test-%03d", i))
d := types.Digest(fmt.Sprintf("digest-%03d", j))
- e.Set(tn, d, expectations.PositiveStr)
+ e.Set(tn, d, expectations.Positive)
delta = append(delta, expectations.Delta{
Grouping: tn,
Digest: d,
- Label: expectations.PositiveStr,
+ Label: expectations.Positive,
})
}
diff --git a/golden/go/expectations/labels.go b/golden/go/expectations/labels.go
index 38114ec..ce0337d 100644
--- a/golden/go/expectations/labels.go
+++ b/golden/go/expectations/labels.go
@@ -1,56 +1,59 @@
package expectations
-// LabelInt for classifying digests.
+// LabelInt is the integer version of Label, used as the storage format in fs_expstore.go and in
+// goldctl.
+//
+// TODO(skbug.com/10522): Make this private to fs_expstore.go once we migrate goldctl to use Label.
type LabelInt int
const (
- // UntriagedInt represents a previously unseen digest.
+ // UntriagedInt represents a previously unseen digest. Int version of Untriaged.
UntriagedInt LabelInt = iota // == 0
- // PositiveInt represents a known good digest.
+ // PositiveInt represents a known good digest. Int version of Positive.
PositiveInt
- // NegativeInt represents a known bad digest.
+ // NegativeInt represents a known bad digest. Int version of Negative.
NegativeInt
)
-// LabelStr is the string version of LabelInt. Used e.g. to represent digest classifications in JSON.
-type LabelStr string
+// Label represents a digest classification.
+type Label string
const (
- // UntriagedStr represents a previously unseen digest. String version of Untriaged.
- UntriagedStr = LabelStr("untriaged")
+ // Untriaged represents a previously unseen digest.
+ Untriaged = Label("untriaged")
- // PositiveStr represents a known good digest. String version of Positive.
- PositiveStr = LabelStr("positive")
+ // Positive represents a known good digest
+ Positive = Label("positive")
- // NegativeStr represents a known bad digest. String version of Negative.
- NegativeStr = LabelStr("negative")
+ // Negative represents a known bad digest.
+ Negative = Label("negative")
)
-// AllLabelStr is a list of all possible LabelStr values. The index of each element in this list
+// AllLabel is a list of all possible Label values. The index of each element in this list
// must match its LabelInt value (Untriaged = 0, etc.).
-var AllLabelStr = []LabelStr{UntriagedStr, PositiveStr, NegativeStr}
+var AllLabel = []Label{Untriaged, Positive, Negative}
-func (l LabelInt) String() LabelStr {
- return AllLabelStr[l]
+func (l LabelInt) String() Label {
+ return AllLabel[l]
}
-var labels = map[LabelStr]LabelInt{
- UntriagedStr: UntriagedInt,
- PositiveStr: PositiveInt,
- NegativeStr: NegativeInt,
+var labels = map[Label]LabelInt{
+ Untriaged: UntriagedInt,
+ Positive: PositiveInt,
+ Negative: NegativeInt,
}
-// LabelFromString returns the LabelInt corresponding to the given LabelStr, or Untriaged if there is
+// LabelIntFromString returns the LabelInt corresponding to the given Label, or Untriaged if there is
// no match.
-func LabelFromString(s LabelStr) LabelInt {
+func LabelIntFromString(s Label) LabelInt {
if l, ok := labels[s]; ok {
return l
}
return UntriagedInt
}
-// ValidLabelStr returns true if the given LabelStr is valid.
-func ValidLabelStr(s LabelStr) bool {
+// ValidLabel returns true if the given Label is valid.
+func ValidLabel(s Label) bool {
_, ok := labels[s]
return ok
}
diff --git a/golden/go/expectations/labels_test.go b/golden/go/expectations/labels_test.go
index e990950..bfea40d 100644
--- a/golden/go/expectations/labels_test.go
+++ b/golden/go/expectations/labels_test.go
@@ -8,34 +8,34 @@
"go.skia.org/infra/go/testutils/unittest"
)
-func TestLabel_String_Success(t *testing.T) {
+func TestLabelInt_String_Success(t *testing.T) {
unittest.SmallTest(t)
- assert.Equal(t, UntriagedStr, UntriagedInt.String())
- assert.Equal(t, PositiveStr, PositiveInt.String())
- assert.Equal(t, NegativeStr, NegativeInt.String())
+ assert.Equal(t, Untriaged, UntriagedInt.String())
+ assert.Equal(t, Positive, PositiveInt.String())
+ assert.Equal(t, Negative, NegativeInt.String())
}
-func TestLabelFromString_KnownLabelStr_ReturnsCorrespondingLabel(t *testing.T) {
+func TestLabelIntFromString_KnownLabel_ReturnsCorrespondingLabelInt(t *testing.T) {
unittest.SmallTest(t)
- assert.Equal(t, UntriagedInt, LabelFromString(UntriagedStr))
- assert.Equal(t, PositiveInt, LabelFromString(PositiveStr))
- assert.Equal(t, NegativeInt, LabelFromString(NegativeStr))
+ assert.Equal(t, UntriagedInt, LabelIntFromString(Untriaged))
+ assert.Equal(t, PositiveInt, LabelIntFromString(Positive))
+ assert.Equal(t, NegativeInt, LabelIntFromString(Negative))
}
-func TestLabelFromString_UnknownLabelStr_ReturnsUntriaged(t *testing.T) {
+func TestLabelFromString_UnknownLabel_ReturnsUntriagedInt(t *testing.T) {
unittest.SmallTest(t)
- assert.Equal(t, UntriagedInt, LabelFromString("unknown label"))
+ assert.Equal(t, UntriagedInt, LabelIntFromString("unknown label"))
}
-func TestValidLabel_KnownLabelStr_ReturnsTrue(t *testing.T) {
+func TestValidLabel_KnownLabel_ReturnsTrue(t *testing.T) {
unittest.SmallTest(t)
- assert.True(t, ValidLabelStr(UntriagedStr))
- assert.True(t, ValidLabelStr(PositiveStr))
- assert.True(t, ValidLabelStr(NegativeStr))
+ assert.True(t, ValidLabel(Untriaged))
+ assert.True(t, ValidLabel(Positive))
+ assert.True(t, ValidLabel(Negative))
}
-func TestValidLabel_UnknownLabelStr_ReturnsFalse(t *testing.T) {
+func TestValidLabel_UnknownLabel_ReturnsFalse(t *testing.T) {
unittest.SmallTest(t)
- assert.False(t, ValidLabelStr("unknown label"))
+ assert.False(t, ValidLabel("unknown label"))
}
diff --git a/golden/go/expectations/mocks/Classifier.go b/golden/go/expectations/mocks/Classifier.go
index 52b317b..a33cdf2 100644
--- a/golden/go/expectations/mocks/Classifier.go
+++ b/golden/go/expectations/mocks/Classifier.go
@@ -15,14 +15,14 @@
}
// Classification provides a mock function with given fields: test, digest
-func (_m *Classifier) Classification(test types.TestName, digest types.Digest) expectations.LabelStr {
+func (_m *Classifier) Classification(test types.TestName, digest types.Digest) expectations.Label {
ret := _m.Called(test, digest)
- var r0 expectations.LabelStr
- if rf, ok := ret.Get(0).(func(types.TestName, types.Digest) expectations.LabelStr); ok {
+ var r0 expectations.Label
+ if rf, ok := ret.Get(0).(func(types.TestName, types.Digest) expectations.Label); ok {
r0 = rf(test, digest)
} else {
- r0 = ret.Get(0).(expectations.LabelStr)
+ r0 = ret.Get(0).(expectations.Label)
}
return r0
diff --git a/golden/go/expectations/store.go b/golden/go/expectations/store.go
index ecca476..90b5710 100644
--- a/golden/go/expectations/store.go
+++ b/golden/go/expectations/store.go
@@ -72,7 +72,7 @@
type Delta struct {
Grouping types.TestName
Digest types.Digest
- Label LabelStr
+ Label Label
}
// ID returns the ID for the Delta, as a method of convenience.
@@ -94,7 +94,7 @@
// AsDelta converts an Expectations object into a slice of Deltas.
func AsDelta(e ReadOnly) []Delta {
var delta []Delta
- _ = e.ForAll(func(tn types.TestName, d types.Digest, l LabelStr) error {
+ _ = e.ForAll(func(tn types.TestName, d types.Digest, l Label) error {
delta = append(delta, Delta{Grouping: tn, Digest: d, Label: l})
return nil
})
diff --git a/golden/go/indexer/indexer.go b/golden/go/indexer/indexer.go
index 912ab1d..4c921a8 100644
--- a/golden/go/indexer/indexer.go
+++ b/golden/go/indexer/indexer.go
@@ -265,7 +265,7 @@
// Find and return the most recent positive digest in the Trace.
for i := len(trace.Digests) - 1; i >= 0; i-- {
digest := trace.Digests[i]
- if digest != tiling.MissingDigest && exps.Classification(trace.TestName(), digest) == expectations.PositiveStr {
+ if digest != tiling.MissingDigest && exps.Classification(trace.TestName(), digest) == expectations.Positive {
return digest, nil
}
}
@@ -845,7 +845,7 @@
params.AddParams(tjr.ResultParams)
params.AddParams(tjr.Options)
tn := types.TestName(tjr.ResultParams[types.PrimaryKeyField])
- if exps.Classification(tn, tjr.Digest) == expectations.UntriagedStr {
+ if exps.Classification(tn, tjr.Digest) == expectations.Untriaged {
// If the same digest somehow shows up twice (maybe because of how we
alreadyInList := false
for _, existingResult := range existing {
diff --git a/golden/go/indexer/indexer_test.go b/golden/go/indexer/indexer_test.go
index 0417f86..d226d7e 100644
--- a/golden/go/indexer/indexer_test.go
+++ b/golden/go/indexer/indexer_test.go
@@ -222,10 +222,10 @@
mts := &mock_tjstore.Store{}
masterExp := expectations.Expectations{}
- masterExp.Set(data.AlphaTest, data.AlphaPositiveDigest, expectations.PositiveStr)
+ masterExp.Set(data.AlphaTest, data.AlphaPositiveDigest, expectations.Positive)
firstCLExp := expectations.Expectations{}
- firstCLExp.Set(data.AlphaTest, data.AlphaNegativeDigest, expectations.NegativeStr)
+ firstCLExp.Set(data.AlphaTest, data.AlphaNegativeDigest, expectations.Negative)
// secondCL has no additional expectations
mes.On("Get", testutils.AnyContext).Return(&masterExp, nil)
@@ -379,8 +379,8 @@
mts := &mock_tjstore.Store{}
masterExp := expectations.Expectations{}
- masterExp.Set(data.AlphaTest, data.AlphaPositiveDigest, expectations.PositiveStr)
- masterExp.Set(data.AlphaTest, data.AlphaNegativeDigest, expectations.NegativeStr)
+ masterExp.Set(data.AlphaTest, data.AlphaPositiveDigest, expectations.Positive)
+ masterExp.Set(data.AlphaTest, data.AlphaNegativeDigest, expectations.Negative)
// The CL has no additional expectations.
mes.On("Get", testutils.AnyContext).Return(&masterExp, nil)
@@ -616,8 +616,8 @@
mes := &mock_expectations.Store{}
masterExp := expectations.Expectations{}
- masterExp.Set(data.AlphaTest, data.AlphaPositiveDigest, expectations.PositiveStr)
- masterExp.Set(data.AlphaTest, data.AlphaNegativeDigest, expectations.NegativeStr)
+ masterExp.Set(data.AlphaTest, data.AlphaPositiveDigest, expectations.Positive)
+ masterExp.Set(data.AlphaTest, data.AlphaNegativeDigest, expectations.Negative)
// The CL has no additional expectations.
mes.On("Get", testutils.AnyContext).Return(&masterExp, nil)
@@ -942,11 +942,11 @@
// Generate expectations for the known digests.
var exps expectations.Expectations
- exps.Set(testName, goodDigest1, expectations.PositiveStr)
- exps.Set(testName, goodDigest2, expectations.PositiveStr)
- exps.Set(testName, goodDigest3, expectations.PositiveStr)
- exps.Set(testName, badDigest1, expectations.NegativeStr)
- exps.Set(testName, badDigest2, expectations.NegativeStr)
+ exps.Set(testName, goodDigest1, expectations.Positive)
+ exps.Set(testName, goodDigest2, expectations.Positive)
+ exps.Set(testName, goodDigest3, expectations.Positive)
+ exps.Set(testName, badDigest1, expectations.Negative)
+ exps.Set(testName, badDigest2, expectations.Negative)
// Build mock expectations store.
mockExpStore := &mock_expectations.Store{}
diff --git a/golden/go/mocks/ClosestDiffFinder.go b/golden/go/mocks/ClosestDiffFinder.go
index 5545dc4..1b69f29 100644
--- a/golden/go/mocks/ClosestDiffFinder.go
+++ b/golden/go/mocks/ClosestDiffFinder.go
@@ -19,11 +19,11 @@
}
// ClosestDigest provides a mock function with given fields: ctx, test, digest, label
-func (_m *ClosestDiffFinder) ClosestDigest(ctx context.Context, test types.TestName, digest types.Digest, label expectations.LabelStr) (*digesttools.Closest, error) {
+func (_m *ClosestDiffFinder) ClosestDigest(ctx context.Context, test types.TestName, digest types.Digest, label expectations.Label) (*digesttools.Closest, error) {
ret := _m.Called(ctx, test, digest, label)
var r0 *digesttools.Closest
- if rf, ok := ret.Get(0).(func(context.Context, types.TestName, types.Digest, expectations.LabelStr) *digesttools.Closest); ok {
+ if rf, ok := ret.Get(0).(func(context.Context, types.TestName, types.Digest, expectations.Label) *digesttools.Closest); ok {
r0 = rf(ctx, test, digest, label)
} else {
if ret.Get(0) != nil {
@@ -32,7 +32,7 @@
}
var r1 error
- if rf, ok := ret.Get(1).(func(context.Context, types.TestName, types.Digest, expectations.LabelStr) error); ok {
+ if rf, ok := ret.Get(1).(func(context.Context, types.TestName, types.Digest, expectations.Label) error); ok {
r1 = rf(ctx, test, digest, label)
} else {
r1 = ret.Error(1)
diff --git a/golden/go/search/frontend/types.go b/golden/go/search/frontend/types.go
index 118b20d..a42d4c6 100644
--- a/golden/go/search/frontend/types.go
+++ b/golden/go/search/frontend/types.go
@@ -26,10 +26,10 @@
Commits []frontend.Commit `json:"commits"`
TraceComments []TraceComment `json:"trace_comments"`
// BulkTriageData contains *all* digests that match the query as keys. The value for each key is
- // an expectations.LabelStr value giving the label of the closest triaged digest to the key digest
+ // an expectations.Label value giving the label of the closest triaged digest to the key digest
// or empty string if there is no "closest digest". Note the similarity to the
// frontend.TriageRequest type.
- BulkTriageData map[types.TestName]map[types.Digest]expectations.LabelStr `json:"bulk_triage_data"`
+ BulkTriageData map[types.TestName]map[types.Digest]expectations.Label `json:"bulk_triage_data"`
}
// TriageHistory represents who last triaged a certain digest for a certain test.
@@ -48,7 +48,7 @@
Test types.TestName `json:"test"`
// Status is positive, negative, or untriaged. This is also known as the expectation for the
// primary digest (for Test).
- Status expectations.LabelStr `json:"status"`
+ Status expectations.Label `json:"status"`
// TriageHistory is a history of all the times the primary digest has been retriaged for the
// given Test.
TriageHistory []TriageHistory `json:"triage_history"`
@@ -77,7 +77,7 @@
// is the image on the right side of the comparison.
Digest types.Digest `json:"digest"`
// Status represents the expectation.Label for this digest.
- Status expectations.LabelStr `json:"status"`
+ Status expectations.Label `json:"status"`
// ParamSet is all of the params of all traces that produce this digest (the digest on the right).
// It is for frontend UI presentation only; essentially a word cloud of what drew the primary
// digest.
@@ -164,8 +164,8 @@
// DigestStatus is a digest and its status, used in TraceGroup.
type DigestStatus struct {
- Digest types.Digest `json:"digest"`
- Status expectations.LabelStr `json:"status"`
+ Digest types.Digest `json:"digest"`
+ Status expectations.Label `json:"status"`
}
// DigestComparison contains the result of comparing two digests.
diff --git a/golden/go/search/query/types.go b/golden/go/search/query/types.go
index 3d4b08c..f0c3648 100644
--- a/golden/go/search/query/types.go
+++ b/golden/go/search/query/types.go
@@ -70,8 +70,8 @@
// ExcludesClassification returns true if the given label/status for a digest
// should be excluded based on the values in the query.
-func (q *Search) ExcludesClassification(cl expectations.LabelStr) bool {
- return ((cl == expectations.NegativeStr) && !q.IncludeNegativeDigests) ||
- ((cl == expectations.PositiveStr) && !q.IncludePositiveDigests) ||
- ((cl == expectations.UntriagedStr) && !q.IncludeUntriagedDigests)
+func (q *Search) ExcludesClassification(cl expectations.Label) bool {
+ return ((cl == expectations.Negative) && !q.IncludeNegativeDigests) ||
+ ((cl == expectations.Positive) && !q.IncludePositiveDigests) ||
+ ((cl == expectations.Untriaged) && !q.IncludeUntriagedDigests)
}
diff --git a/golden/go/search/ref_differ/ref_differ.go b/golden/go/search/ref_differ/ref_differ.go
index 0d8d032..9835666 100644
--- a/golden/go/search/ref_differ/ref_differ.go
+++ b/golden/go/search/ref_differ/ref_differ.go
@@ -52,8 +52,8 @@
paramsByDigest := r.idx.GetParamsetSummaryByTest(iState)[d.Test]
// TODO(kjlubick) maybe make this use an errgroup
- posDigests := r.getDigestsWithLabel(d, match, paramsByDigest, rhsQuery, expectations.PositiveStr)
- negDigests := r.getDigestsWithLabel(d, match, paramsByDigest, rhsQuery, expectations.NegativeStr)
+ posDigests := r.getDigestsWithLabel(d, match, paramsByDigest, rhsQuery, expectations.Positive)
+ negDigests := r.getDigestsWithLabel(d, match, paramsByDigest, rhsQuery, expectations.Negative)
var err error
ret := make(map[common.RefClosest]*frontend.SRDiffDigest, 2)
@@ -92,7 +92,7 @@
// getDigestsWithLabel return all digests within the given test that
// have the given label assigned to them and where the parameters
// listed in 'match' match.
-func (r *DiffImpl) getDigestsWithLabel(s *frontend.SearchResult, match []string, paramsByDigest map[types.Digest]paramtools.ParamSet, rhsQuery paramtools.ParamSet, targetLabel expectations.LabelStr) types.DigestSlice {
+func (r *DiffImpl) getDigestsWithLabel(s *frontend.SearchResult, match []string, paramsByDigest map[types.Digest]paramtools.ParamSet, rhsQuery paramtools.ParamSet, targetLabel expectations.Label) types.DigestSlice {
ret := types.DigestSlice{}
for d, digestParams := range paramsByDigest {
// Accept all digests that are: in the set of allowed digests
diff --git a/golden/go/search/ref_differ/ref_differ_test.go b/golden/go/search/ref_differ/ref_differ_test.go
index 245ee1b..30baddb 100644
--- a/golden/go/search/ref_differ/ref_differ_test.go
+++ b/golden/go/search/ref_differ/ref_differ_test.go
@@ -464,10 +464,10 @@
// makeExpClassifier returns a Classifier which has two positive entries and one negative one.
func makeExpClassifier() expectations.Classifier {
var expOne expectations.Expectations
- expOne.Set(testName, alphaPositiveDigest, expectations.PositiveStr)
- expOne.Set(testName, gammaPositiveDigest, expectations.PositiveStr)
+ expOne.Set(testName, alphaPositiveDigest, expectations.Positive)
+ expOne.Set(testName, gammaPositiveDigest, expectations.Positive)
var expTwo expectations.Expectations
- expTwo.Set(testName, betaNegativeDigest, expectations.NegativeStr)
+ expTwo.Set(testName, betaNegativeDigest, expectations.Negative)
return expectations.Join(&expOne, &expTwo)
}
diff --git a/golden/go/search/search.go b/golden/go/search/search.go
index ac83cce..ba5a8dc 100644
--- a/golden/go/search/search.go
+++ b/golden/go/search/search.go
@@ -201,21 +201,21 @@
return searchRet, nil
}
-func collectDigestsForBulkTriage(results []*frontend.SearchResult) map[types.TestName]map[types.Digest]expectations.LabelStr {
- testNameToPrimaryDigest := map[types.TestName]map[types.Digest]expectations.LabelStr{}
+func collectDigestsForBulkTriage(results []*frontend.SearchResult) map[types.TestName]map[types.Digest]expectations.Label {
+ testNameToPrimaryDigest := map[types.TestName]map[types.Digest]expectations.Label{}
for _, r := range results {
test := r.Test
digestToLabel, ok := testNameToPrimaryDigest[test]
if !ok {
- digestToLabel = map[types.Digest]expectations.LabelStr{}
+ digestToLabel = map[types.Digest]expectations.Label{}
testNameToPrimaryDigest[test] = digestToLabel
}
primary := r.Digest
switch r.ClosestRef {
case common.PositiveRef:
- digestToLabel[primary] = expectations.PositiveStr
+ digestToLabel[primary] = expectations.Positive
case common.NegativeRef:
- digestToLabel[primary] = expectations.NegativeStr
+ digestToLabel[primary] = expectations.Negative
case common.NoRef:
digestToLabel[primary] = ""
}
@@ -1071,7 +1071,7 @@
return nil, skerr.Wrap(err)
}
tn := types.TestName(tr.ResultParams[types.PrimaryKeyField])
- if exp.Classification(tn, tr.Digest) != expectations.UntriagedStr {
+ if exp.Classification(tn, tr.Digest) != expectations.Untriaged {
// It's been triaged already.
continue
}
diff --git a/golden/go/search/search_test.go b/golden/go/search/search_test.go
index 3adbf0f..bf844a8 100644
--- a/golden/go/search/search_test.go
+++ b/golden/go/search/search_test.go
@@ -204,12 +204,12 @@
},
},
},
- BulkTriageData: map[types.TestName]map[types.Digest]expectations.LabelStr{
+ BulkTriageData: map[types.TestName]map[types.Digest]expectations.Label{
data.AlphaTest: {
- data.AlphaUntriagedDigest: expectations.PositiveStr,
+ data.AlphaUntriagedDigest: expectations.Positive,
},
data.BetaTest: {
- data.BetaUntriagedDigest: expectations.PositiveStr,
+ data.BetaUntriagedDigest: expectations.Positive,
},
},
}, resp)
@@ -252,12 +252,12 @@
// This checks that the returned result is the first one of the results we expect.
assert.Equal(t, data.AlphaUntriagedDigest, resp.Results[0].Digest)
// BulkTriageData should still be fully filled out for all digests in the full results.
- assert.Equal(t, map[types.TestName]map[types.Digest]expectations.LabelStr{
+ assert.Equal(t, map[types.TestName]map[types.Digest]expectations.Label{
data.AlphaTest: {
- data.AlphaUntriagedDigest: expectations.PositiveStr,
+ data.AlphaUntriagedDigest: expectations.Positive,
},
data.BetaTest: {
- data.BetaUntriagedDigest: expectations.PositiveStr,
+ data.BetaUntriagedDigest: expectations.Positive,
},
}, resp.BulkTriageData)
@@ -273,12 +273,12 @@
// This checks that the returned result is the second one of the results we expect.
assert.Equal(t, data.BetaUntriagedDigest, resp.Results[0].Digest)
// BulkTriageData should still be fully filled out for all digests in the full results.
- assert.Equal(t, map[types.TestName]map[types.Digest]expectations.LabelStr{
+ assert.Equal(t, map[types.TestName]map[types.Digest]expectations.Label{
data.AlphaTest: {
- data.AlphaUntriagedDigest: expectations.PositiveStr,
+ data.AlphaUntriagedDigest: expectations.Positive,
},
data.BetaTest: {
- data.BetaUntriagedDigest: expectations.PositiveStr,
+ data.BetaUntriagedDigest: expectations.Positive,
},
}, resp.BulkTriageData)
}
@@ -301,7 +301,7 @@
type spotCheck struct {
test types.TestName
digest types.Digest
- labelStr expectations.LabelStr
+ labelStr expectations.Label
closestPositive types.Digest
closestNegative types.Digest
}
@@ -722,7 +722,7 @@
mes := makeThreeDevicesExpectationStore()
var ie expectations.Expectations
- ie.Set(data.AlphaTest, AlphaNowGoodDigest, expectations.PositiveStr)
+ ie.Set(data.AlphaTest, AlphaNowGoodDigest, expectations.Positive)
issueStore := addChangeListExpectations(mes, crs, clID, &ie)
// Hasn't been triaged yet
issueStore.On("GetTriageHistory", testutils.AnyContext, mock.Anything, mock.Anything).Return(nil, nil)
@@ -902,9 +902,9 @@
},
},
},
- BulkTriageData: map[types.TestName]map[types.Digest]expectations.LabelStr{
+ BulkTriageData: map[types.TestName]map[types.Digest]expectations.Label{
data.BetaTest: {
- BetaBrandNewDigest: expectations.PositiveStr,
+ BetaBrandNewDigest: expectations.Positive,
},
},
}, resp)
@@ -1125,7 +1125,7 @@
// Mock out some ChangeList expectations in which the digest we care about is negative
var ie expectations.Expectations
- ie.Set(testWeWantDetailsAbout, digestWeWantDetailsAbout, expectations.NegativeStr)
+ ie.Set(testWeWantDetailsAbout, digestWeWantDetailsAbout, expectations.Negative)
issueStore := addChangeListExpectations(mes, testCRS, testCLID, &ie)
issueStore.On("GetTriageHistory", testutils.AnyContext, mock.Anything, mock.Anything).Return([]expectations.TriageHistory{
{
@@ -1146,7 +1146,7 @@
details, err := s.GetDigestDetails(context.Background(), testWeWantDetailsAbout, digestWeWantDetailsAbout, testCLID, testCRS)
require.NoError(t, err)
- assert.Equal(t, details.Result.Status, expectations.NegativeStr)
+ assert.Equal(t, details.Result.Status, expectations.Negative)
assert.Equal(t, []frontend.TriageHistory{
{
User: clUser,
@@ -1249,7 +1249,7 @@
empty := expectations.Expectations{}
mes.On("Get", testutils.AnyContext).Return(&empty, nil)
var ie expectations.Expectations
- ie.Set(testWeWantDetailsAbout, digestWeWantDetailsAbout, expectations.PositiveStr)
+ ie.Set(testWeWantDetailsAbout, digestWeWantDetailsAbout, expectations.Positive)
addChangeListExpectations(mes, testCRS, testCLID, &ie)
// This index emulates the fact that master branch does not have the newly added test.
@@ -1336,7 +1336,7 @@
empty := expectations.Expectations{}
mes.On("Get", testutils.AnyContext).Return(&empty, nil)
var ie expectations.Expectations
- ie.Set(testWeWantDetailsAbout, digestWeWantDetailsAbout, expectations.PositiveStr)
+ ie.Set(testWeWantDetailsAbout, digestWeWantDetailsAbout, expectations.Positive)
addChangeListExpectations(mes, testCRS, testCLID, &ie)
// This index emulates the fact that master branch does not have the newly added test.
@@ -1442,7 +1442,7 @@
common.NegativeRef: {
DiffMetrics: makeBigDiffMetric(),
Digest: data.AlphaNegativeDigest,
- Status: expectations.NegativeStr,
+ Status: expectations.Negative,
ParamSet: paramtools.ParamSet{
"device": {data.AnglerDevice, data.BullheadDevice, data.CrosshatchDevice},
types.PrimaryKeyField: {string(data.AlphaTest)},
@@ -1473,7 +1473,7 @@
Left: frontend.SearchResult{
Test: testWeWantDetailsAbout,
Digest: leftDigest,
- Status: expectations.UntriagedStr,
+ Status: expectations.Untriaged,
ParamSet: paramtools.ParamSet{
"device": []string{data.BullheadDevice},
types.PrimaryKeyField: []string{string(data.AlphaTest)},
@@ -1483,7 +1483,7 @@
},
Right: &frontend.SRDiffDigest{
Digest: rightDigest,
- Status: expectations.PositiveStr,
+ Status: expectations.Positive,
DiffMetrics: makeSmallDiffMetric(),
ParamSet: paramtools.ParamSet{
"device": []string{data.AnglerDevice, data.CrosshatchDevice},
@@ -1506,7 +1506,7 @@
mes := makeThreeDevicesExpectationStore()
var ie expectations.Expectations
- ie.Set(data.AlphaTest, leftDigest, expectations.NegativeStr)
+ ie.Set(data.AlphaTest, leftDigest, expectations.Negative)
issueStore := addChangeListExpectations(mes, crs, clID, &ie)
issueStore.On("GetTriageHistory", testutils.AnyContext, mock.Anything, mock.Anything).Return(nil, nil)
@@ -1517,7 +1517,7 @@
cd, err := s.DiffDigests(context.Background(), testWeWantDetailsAbout, leftDigest, rightDigest, clID, crs)
require.NoError(t, err)
- assert.Equal(t, cd.Left.Status, expectations.NegativeStr)
+ assert.Equal(t, cd.Left.Status, expectations.Negative)
}
// TestUntriagedUnignoredTryJobExclusiveDigests_NoIndexBuilt_Success models the case where a set of
@@ -1550,7 +1550,7 @@
// gammaNegativeTryJobDigest negative (it would be untriaged on master).
mes := makeThreeDevicesExpectationStore()
var ie expectations.Expectations
- ie.Set(data.AlphaTest, gammaNegativeTryJobDigest, expectations.NegativeStr)
+ ie.Set(data.AlphaTest, gammaNegativeTryJobDigest, expectations.Negative)
addChangeListExpectations(mes, crs, clID, &ie)
cpxTile := tiling.NewComplexTile(data.MakeTestTile())
@@ -1742,7 +1742,7 @@
// gammaNegativeTryJobDigest negative (it would be untriaged on master).
mes := makeThreeDevicesExpectationStore()
var ie expectations.Expectations
- ie.Set(data.AlphaTest, gammaNegativeTryJobDigest, expectations.NegativeStr)
+ ie.Set(data.AlphaTest, gammaNegativeTryJobDigest, expectations.Negative)
addChangeListExpectations(mes, crs, clID, &ie)
cpxTile := tiling.NewComplexTile(data.MakeTestTile())
@@ -1854,7 +1854,7 @@
// stubClassifier returns Positive for everything. For the purposes of drawing traces,
// don't actually care about the expectations.
stubClassifier := &mock_expectations.Classifier{}
- stubClassifier.On("Classification", mock.Anything, mock.Anything).Return(expectations.PositiveStr)
+ stubClassifier.On("Classification", mock.Anything, mock.Anything).Return(expectations.Positive)
t.Run(desc, func(t *testing.T) {
traces := []frontend.Trace{
{
@@ -1925,7 +1925,7 @@
// stubClassifier returns Positive for everything. For the purposes of drawing traces,
// don't actually care about the expectations.
stubClassifier := &mock_expectations.Classifier{}
- stubClassifier.On("Classification", mock.Anything, mock.Anything).Return(expectations.PositiveStr)
+ stubClassifier.On("Classification", mock.Anything, mock.Anything).Return(expectations.Positive)
t.Run(desc, func(t *testing.T) {
traces := []frontend.Trace{
{
@@ -1994,7 +1994,7 @@
// stubClassifier returns Positive for everything. For the purposes of drawing traces,
// don't actually care about the expectations.
stubClassifier := &mock_expectations.Classifier{}
- stubClassifier.On("Classification", mock.Anything, mock.Anything).Return(expectations.PositiveStr)
+ stubClassifier.On("Classification", mock.Anything, mock.Anything).Return(expectations.Positive)
t.Run(desc, func(t *testing.T) {
traces := []frontend.Trace{
{
@@ -2043,7 +2043,7 @@
// stubClassifier returns Positive for everything. For the purposes of counting digests,
// don't actually care about the expectations.
stubClassifier := &mock_expectations.Classifier{}
- stubClassifier.On("Classification", mock.Anything, mock.Anything).Return(expectations.PositiveStr)
+ stubClassifier.On("Classification", mock.Anything, mock.Anything).Return(expectations.Positive)
t.Run(desc, func(t *testing.T) {
traces := make([]frontend.Trace, 0, len(inputTraceDigests))
for i, digests := range inputTraceDigests {
@@ -2109,22 +2109,22 @@
{
Test: data.AlphaTest,
Digest: data.AlphaPositiveDigest,
- Status: expectations.PositiveStr,
+ Status: expectations.Positive,
},
{
Test: data.AlphaTest,
Digest: data.AlphaNegativeDigest,
- Status: expectations.NegativeStr,
+ Status: expectations.Negative,
},
{
Test: data.BetaTest,
Digest: data.BetaPositiveDigest,
- Status: expectations.PositiveStr,
+ Status: expectations.Positive,
},
{
Test: data.BetaTest,
Digest: data.BetaUntriagedDigest,
- Status: expectations.UntriagedStr,
+ Status: expectations.Untriaged,
},
}, results)
}
@@ -2321,7 +2321,7 @@
}
bulkTriageData := collectDigestsForBulkTriage(results)
- assert.Equal(t, map[types.TestName]map[types.Digest]expectations.LabelStr{
+ assert.Equal(t, map[types.TestName]map[types.Digest]expectations.Label{
"apple": {
"grannysmith": "positive",
"honeycrisp": "",
diff --git a/golden/go/search/util.go b/golden/go/search/util.go
index 9695b71..93cf9db 100644
--- a/golden/go/search/util.go
+++ b/golden/go/search/util.go
@@ -79,7 +79,7 @@
// Fix blamer to make this easier.
if q.BlameGroupID != "" {
- if cl == expectations.UntriagedStr {
+ if cl == expectations.Untriaged {
b := idx.GetBlame(test, digest, cpxTile.DataCommits())
if b.IsEmpty() || q.BlameGroupID != blameGroupID(b, cpxTile.DataCommits()) {
continue
diff --git a/golden/go/status/status.go b/golden/go/status/status.go
index 754550f..05ed2b4 100644
--- a/golden/go/status/status.go
+++ b/golden/go/status/status.go
@@ -87,17 +87,17 @@
totalGauge metrics2.Int64Metric
// Gauges to track counts of digests by corpus / label
- corpusGauges map[string]map[expectations.LabelStr]metrics2.Int64Metric
+ corpusGauges map[string]map[expectations.Label]metrics2.Int64Metric
}
func New(ctx context.Context, swc StatusWatcherConfig) (*StatusWatcher, error) {
ret := &StatusWatcher{
StatusWatcherConfig: swc,
- allUntriagedGauge: metrics2.GetInt64Metric(allMetric, map[string]string{"type": string(expectations.UntriagedStr)}),
- allPositiveGauge: metrics2.GetInt64Metric(allMetric, map[string]string{"type": string(expectations.PositiveStr)}),
- allNegativeGauge: metrics2.GetInt64Metric(allMetric, map[string]string{"type": string(expectations.NegativeStr)}),
+ allUntriagedGauge: metrics2.GetInt64Metric(allMetric, map[string]string{"type": string(expectations.Untriaged)}),
+ allPositiveGauge: metrics2.GetInt64Metric(allMetric, map[string]string{"type": string(expectations.Positive)}),
+ allNegativeGauge: metrics2.GetInt64Metric(allMetric, map[string]string{"type": string(expectations.Negative)}),
totalGauge: metrics2.GetInt64Metric(totalDigestsMetric, nil),
- corpusGauges: map[string]map[expectations.LabelStr]metrics2.Int64Metric{},
+ corpusGauges: map[string]map[expectations.Label]metrics2.Int64Metric{},
}
if err := ret.calcAndWatchStatus(ctx); err != nil {
@@ -214,7 +214,7 @@
}
// Gathers unique labels by corpus and label.
- byCorpus := map[string]map[expectations.LabelStr]map[string]bool{}
+ byCorpus := map[string]map[expectations.Label]map[string]bool{}
// Iterate over the current traces
dataTile := cpxTile.GetTile(types.ExcludeIgnoredTraces)
@@ -242,17 +242,17 @@
corpus := trace.Corpus()
if _, ok := byCorpus[corpus]; !ok {
okByCorpus[corpus] = true
- byCorpus[corpus] = map[expectations.LabelStr]map[string]bool{
- expectations.PositiveStr: {},
- expectations.NegativeStr: {},
- expectations.UntriagedStr: {},
+ byCorpus[corpus] = map[expectations.Label]map[string]bool{
+ expectations.Positive: {},
+ expectations.Negative: {},
+ expectations.Untriaged: {},
}
if _, ok := s.corpusGauges[corpus]; !ok {
- s.corpusGauges[corpus] = map[expectations.LabelStr]metrics2.Int64Metric{
- expectations.UntriagedStr: metrics2.GetInt64Metric(corpusMetric, map[string]string{"type": string(expectations.UntriagedStr), "corpus": corpus}),
- expectations.PositiveStr: metrics2.GetInt64Metric(corpusMetric, map[string]string{"type": string(expectations.PositiveStr), "corpus": corpus}),
- expectations.NegativeStr: metrics2.GetInt64Metric(corpusMetric, map[string]string{"type": string(expectations.NegativeStr), "corpus": corpus}),
+ s.corpusGauges[corpus] = map[expectations.Label]metrics2.Int64Metric{
+ expectations.Untriaged: metrics2.GetInt64Metric(corpusMetric, map[string]string{"type": string(expectations.Untriaged), "corpus": corpus}),
+ expectations.Positive: metrics2.GetInt64Metric(corpusMetric, map[string]string{"type": string(expectations.Positive), "corpus": corpus}),
+ expectations.Negative: metrics2.GetInt64Metric(corpusMetric, map[string]string{"type": string(expectations.Negative), "corpus": corpus}),
}
}
}
@@ -263,7 +263,7 @@
status := exp.Classification(testName, digest)
okByCorpus[corpus] = okByCorpus[corpus] &&
- ((status == expectations.PositiveStr) || (status == expectations.NegativeStr))
+ ((status == expectations.Positive) || (status == expectations.Negative))
byCorpus[corpus][status][string(testName)+string(digest)] = true
}
@@ -274,9 +274,9 @@
corpStatus := make([]*GUICorpusStatus, 0, len(byCorpus))
for corpus := range byCorpus {
overallOk = overallOk && okByCorpus[corpus]
- untriagedCount := len(byCorpus[corpus][expectations.UntriagedStr])
- positiveCount := len(byCorpus[corpus][expectations.PositiveStr])
- negativeCount := len(byCorpus[corpus][expectations.NegativeStr])
+ untriagedCount := len(byCorpus[corpus][expectations.Untriaged])
+ positiveCount := len(byCorpus[corpus][expectations.Positive])
+ negativeCount := len(byCorpus[corpus][expectations.Negative])
corpStatus = append(corpStatus, &GUICorpusStatus{
Name: corpus,
OK: okByCorpus[corpus],
@@ -287,9 +287,9 @@
allNegativeCount += negativeCount
allPositiveCount += positiveCount
- s.corpusGauges[corpus][expectations.PositiveStr].Update(int64(positiveCount))
- s.corpusGauges[corpus][expectations.NegativeStr].Update(int64(negativeCount))
- s.corpusGauges[corpus][expectations.UntriagedStr].Update(int64(untriagedCount))
+ s.corpusGauges[corpus][expectations.Positive].Update(int64(positiveCount))
+ s.corpusGauges[corpus][expectations.Negative].Update(int64(negativeCount))
+ s.corpusGauges[corpus][expectations.Untriaged].Update(int64(untriagedCount))
}
s.allUntriagedGauge.Update(int64(allUntriagedCount))
s.allPositiveGauge.Update(int64(allPositiveCount))
diff --git a/golden/go/status/status_test.go b/golden/go/status/status_test.go
index 58f1e52..d8f5b2c 100644
--- a/golden/go/status/status_test.go
+++ b/golden/go/status/status_test.go
@@ -82,8 +82,8 @@
// that a user has triaged the two untraiged images
mes.On("Get", testutils.AnyContext).Return(data.MakeTestExpectations(), nil).Once()
everythingTriaged := data.MakeTestExpectations()
- everythingTriaged.Set(data.AlphaTest, data.AlphaUntriagedDigest, expectations.PositiveStr)
- everythingTriaged.Set(data.BetaTest, data.BetaUntriagedDigest, expectations.NegativeStr)
+ everythingTriaged.Set(data.AlphaTest, data.AlphaUntriagedDigest, expectations.Positive)
+ everythingTriaged.Set(data.BetaTest, data.BetaUntriagedDigest, expectations.Negative)
mes.On("Get", testutils.AnyContext).Return(everythingTriaged, nil)
eb := expectations.NewEventDispatcherForTesting()
diff --git a/golden/go/summary/summary.go b/golden/go/summary/summary.go
index 2b076b4..63a71b6 100644
--- a/golden/go/summary/summary.go
+++ b/golden/go/summary/summary.go
@@ -158,13 +158,13 @@
untHashes := types.DigestSlice{}
for _, digest := range digests {
switch s.Expectations.Classification(name, digest) {
- case expectations.UntriagedStr:
+ case expectations.Untriaged:
unt += 1
diamDigests = append(diamDigests, digest)
untHashes = append(untHashes, digest)
- case expectations.NegativeStr:
+ case expectations.Negative:
neg += 1
- case expectations.PositiveStr:
+ case expectations.Positive:
pos += 1
diamDigests = append(diamDigests, digest)
}
diff --git a/golden/go/summary/summary_test.go b/golden/go/summary/summary_test.go
index 0e1ea26..a28901b 100644
--- a/golden/go/summary/summary_test.go
+++ b/golden/go/summary/summary_test.go
@@ -382,7 +382,7 @@
}
var e expectations.Expectations
- e.Set(bug_revert.TestOne, bug_revert.AlfaPositiveDigest, expectations.PositiveStr)
+ e.Set(bug_revert.TestOne, bug_revert.AlfaPositiveDigest, expectations.Positive)
dc := digest_counter.New(tile)
blamer, err := blame.New(tile, &e)
@@ -664,12 +664,12 @@
func makeExpectations() *expectations.Expectations {
var e expectations.Expectations
- e.Set(FirstTest, "aaa", expectations.PositiveStr)
- e.Set(FirstTest, "bbb", expectations.NegativeStr)
- e.Set(FirstTest, "ccc", expectations.UntriagedStr)
- e.Set(FirstTest, "ddd", expectations.UntriagedStr)
- e.Set(FirstTest, "eee", expectations.PositiveStr)
+ e.Set(FirstTest, "aaa", expectations.Positive)
+ e.Set(FirstTest, "bbb", expectations.Negative)
+ e.Set(FirstTest, "ccc", expectations.Untriaged)
+ e.Set(FirstTest, "ddd", expectations.Untriaged)
+ e.Set(FirstTest, "eee", expectations.Positive)
- e.Set(SecondTest, "fff", expectations.NegativeStr)
+ e.Set(SecondTest, "fff", expectations.Negative)
return &e
}
diff --git a/golden/go/testutils/data_bug_revert/bug_revert.go b/golden/go/testutils/data_bug_revert/bug_revert.go
index 7d00da1..3ae8ca8 100644
--- a/golden/go/testutils/data_bug_revert/bug_revert.go
+++ b/golden/go/testutils/data_bug_revert/bug_revert.go
@@ -164,8 +164,8 @@
func MakeTestExpectations() *expectations.Expectations {
var e expectations.Expectations
- e.Set(TestOne, AlfaPositiveDigest, expectations.PositiveStr)
- e.Set(TestTwo, CharliePositiveDigest, expectations.PositiveStr)
- e.Set(TestTwo, EchoPositiveDigest, expectations.PositiveStr)
+ e.Set(TestOne, AlfaPositiveDigest, expectations.Positive)
+ e.Set(TestTwo, CharliePositiveDigest, expectations.Positive)
+ e.Set(TestTwo, EchoPositiveDigest, expectations.Positive)
return &e
}
diff --git a/golden/go/testutils/data_three_devices/three_devices.go b/golden/go/testutils/data_three_devices/three_devices.go
index 3339f21..60d6aa0 100644
--- a/golden/go/testutils/data_three_devices/three_devices.go
+++ b/golden/go/testutils/data_three_devices/three_devices.go
@@ -165,11 +165,11 @@
func MakeTestExpectations() *expectations.Expectations {
var e expectations.Expectations
- e.Set(AlphaTest, AlphaPositiveDigest, expectations.PositiveStr)
- e.Set(AlphaTest, AlphaUntriagedDigest, expectations.UntriagedStr)
- e.Set(AlphaTest, AlphaNegativeDigest, expectations.NegativeStr)
+ e.Set(AlphaTest, AlphaPositiveDigest, expectations.Positive)
+ e.Set(AlphaTest, AlphaUntriagedDigest, expectations.Untriaged)
+ e.Set(AlphaTest, AlphaNegativeDigest, expectations.Negative)
- e.Set(BetaTest, BetaPositiveDigest, expectations.PositiveStr)
- e.Set(BetaTest, BetaUntriagedDigest, expectations.UntriagedStr)
+ e.Set(BetaTest, BetaPositiveDigest, expectations.Positive)
+ e.Set(BetaTest, BetaUntriagedDigest, expectations.Untriaged)
return &e
}
diff --git a/golden/go/warmer/warmer.go b/golden/go/warmer/warmer.go
index d72a1c9..af159b7 100644
--- a/golden/go/warmer/warmer.go
+++ b/golden/go/warmer/warmer.go
@@ -77,7 +77,7 @@
nt := metrics2.NewTimer("gold_warmer_cycle")
// Calculating the closest digest has the side effect of filling
// in the diffstore with the diff images.
- _, err := diffFinder.ClosestDigest(ctx, test, digest, expectations.PositiveStr)
+ _, err := diffFinder.ClosestDigest(ctx, test, digest, expectations.Positive)
if err != nil {
if firstErr == nil {
firstErr = err
@@ -85,7 +85,7 @@
sklog.Debugf("non-terminating error precomputing diff: %s", err)
errCount++
}
- _, err = diffFinder.ClosestDigest(ctx, test, digest, expectations.NegativeStr)
+ _, err = diffFinder.ClosestDigest(ctx, test, digest, expectations.Negative)
if err != nil {
if firstErr == nil {
firstErr = err
diff --git a/golden/go/warmer/warmer_test.go b/golden/go/warmer/warmer_test.go
index 77b3a79..9171b72 100644
--- a/golden/go/warmer/warmer_test.go
+++ b/golden/go/warmer/warmer_test.go
@@ -41,10 +41,10 @@
mdf.On("Precompute", testutils.AnyContext).Return(nil).Once()
// Can return nil because warmer shouldn't care about what is actually the closest.
- mdf.On("ClosestDigest", testutils.AnyContext, data.AlphaTest, data.AlphaUntriagedDigest, expectations.PositiveStr).Return(nil, nil).Once()
- mdf.On("ClosestDigest", testutils.AnyContext, data.AlphaTest, data.AlphaUntriagedDigest, expectations.NegativeStr).Return(nil, nil).Once()
- mdf.On("ClosestDigest", testutils.AnyContext, data.BetaTest, data.BetaUntriagedDigest, expectations.PositiveStr).Return(nil, nil).Once()
- mdf.On("ClosestDigest", testutils.AnyContext, data.BetaTest, data.BetaUntriagedDigest, expectations.NegativeStr).Return(nil, nil).Once()
+ mdf.On("ClosestDigest", testutils.AnyContext, data.AlphaTest, data.AlphaUntriagedDigest, expectations.Positive).Return(nil, nil).Once()
+ mdf.On("ClosestDigest", testutils.AnyContext, data.AlphaTest, data.AlphaUntriagedDigest, expectations.Negative).Return(nil, nil).Once()
+ mdf.On("ClosestDigest", testutils.AnyContext, data.BetaTest, data.BetaUntriagedDigest, expectations.Positive).Return(nil, nil).Once()
+ mdf.On("ClosestDigest", testutils.AnyContext, data.BetaTest, data.BetaUntriagedDigest, expectations.Negative).Return(nil, nil).Once()
w := New()
wd := Data{
@@ -78,10 +78,10 @@
mdf.On("Precompute", testutils.AnyContext).Return(nil).Once()
// Can return nil because warmer shouldn't care about what is actually the closest.
- mdf.On("ClosestDigest", testutils.AnyContext, data.AlphaTest, data.AlphaUntriagedDigest, expectations.PositiveStr).Return(nil, nil).Once()
- mdf.On("ClosestDigest", testutils.AnyContext, data.AlphaTest, data.AlphaUntriagedDigest, expectations.NegativeStr).Return(nil, errors.New("transient gcs error")).Once()
- mdf.On("ClosestDigest", testutils.AnyContext, data.BetaTest, data.BetaUntriagedDigest, expectations.PositiveStr).Return(nil, nil).Once()
- mdf.On("ClosestDigest", testutils.AnyContext, data.BetaTest, data.BetaUntriagedDigest, expectations.NegativeStr).Return(nil, errors.New("sentient AI error")).Once()
+ mdf.On("ClosestDigest", testutils.AnyContext, data.AlphaTest, data.AlphaUntriagedDigest, expectations.Positive).Return(nil, nil).Once()
+ mdf.On("ClosestDigest", testutils.AnyContext, data.AlphaTest, data.AlphaUntriagedDigest, expectations.Negative).Return(nil, errors.New("transient gcs error")).Once()
+ mdf.On("ClosestDigest", testutils.AnyContext, data.BetaTest, data.BetaUntriagedDigest, expectations.Positive).Return(nil, nil).Once()
+ mdf.On("ClosestDigest", testutils.AnyContext, data.BetaTest, data.BetaUntriagedDigest, expectations.Negative).Return(nil, errors.New("sentient AI error")).Once()
w := New()
wd := Data{
@@ -140,8 +140,8 @@
// Can return nil because warmer shouldn't care about what is actually the closest.
// Should not call ClosestDigest on AlphaTest because only BetaTest is in testNames.
- mdf.On("ClosestDigest", testutils.AnyContext, data.BetaTest, data.BetaUntriagedDigest, expectations.PositiveStr).Return(nil, nil).Once()
- mdf.On("ClosestDigest", testutils.AnyContext, data.BetaTest, data.BetaUntriagedDigest, expectations.NegativeStr).Return(nil, nil).Once()
+ mdf.On("ClosestDigest", testutils.AnyContext, data.BetaTest, data.BetaUntriagedDigest, expectations.Positive).Return(nil, nil).Once()
+ mdf.On("ClosestDigest", testutils.AnyContext, data.BetaTest, data.BetaUntriagedDigest, expectations.Negative).Return(nil, nil).Once()
w := New()
wd := Data{
diff --git a/golden/go/web/frontend/generate_typescript_rpc_types/main.go b/golden/go/web/frontend/generate_typescript_rpc_types/main.go
index 92a8213..d548b55 100644
--- a/golden/go/web/frontend/generate_typescript_rpc_types/main.go
+++ b/golden/go/web/frontend/generate_typescript_rpc_types/main.go
@@ -49,7 +49,7 @@
return skerr.Wrap(err)
}
- if err := generator.AddUnionWithName(expectations.AllLabelStr, "LabelStr"); err != nil {
+ if err := generator.AddUnionWithName(expectations.AllLabel, "Label"); err != nil {
return skerr.Wrap(err)
}
diff --git a/golden/go/web/frontend/types.go b/golden/go/web/frontend/types.go
index fc30110..0ebe0c4 100644
--- a/golden/go/web/frontend/types.go
+++ b/golden/go/web/frontend/types.go
@@ -93,7 +93,7 @@
type TriageRequest struct {
// TestDigestStatus maps status to test name and digests. The strings are
// expectation.Label.String() values
- TestDigestStatus map[types.TestName]map[types.Digest]expectations.LabelStr `json:"testDigestStatus"`
+ TestDigestStatus map[types.TestName]map[types.Digest]expectations.Label `json:"testDigestStatus"`
// ChangeListID is the id of the ChangeList for which we want to change the expectations.
// "issue" is the JSON field for backwards compatibility.
@@ -112,9 +112,9 @@
// TriageDelta represents one changed digest and the label that was
// assigned as part of the triage operation.
type TriageDelta struct {
- TestName types.TestName `json:"test_name"`
- Digest types.Digest `json:"digest"`
- Label expectations.LabelStr `json:"label"`
+ TestName types.TestName `json:"test_name"`
+ Digest types.Digest `json:"digest"`
+ Label expectations.Label `json:"label"`
}
// TriageLogEntry represents a set of changes by a single person.
diff --git a/golden/go/web/web.go b/golden/go/web/web.go
index cefd27c..80f47f6 100644
--- a/golden/go/web/web.go
+++ b/golden/go/web/web.go
@@ -755,7 +755,7 @@
idxMatched = i
// Check to see if the digest is untriaged at head
- if d := trace.AtHead(); d != tiling.MissingDigest && exp.Classification(trace.TestName(), d) == expectations.UntriagedStr {
+ if d := trace.AtHead(); d != tiling.MissingDigest && exp.Classification(trace.TestName(), d) == expectations.Untriaged {
ruleCounts[i].UntriagedCount++
untMatched++
untIdxMatched = i
@@ -923,7 +923,7 @@
// side than make the JS check for empty string and mutate the POST body.
continue
}
- if !expectations.ValidLabelStr(label) {
+ if !expectations.ValidLabel(label) {
return skerr.Fmt("invalid label %q in triage request", label)
}
tc = append(tc, expectations.Delta{
@@ -1047,8 +1047,8 @@
// Node represents a single node in a d3 diagram. Used in ClusterDiffResult.
type Node struct {
- Name types.Digest `json:"name"`
- Status expectations.LabelStr `json:"status"`
+ Name types.Digest `json:"name"`
+ Status expectations.Label `json:"status"`
}
// Link represents a link between d3 nodes, used in ClusterDiffResult.
diff --git a/golden/go/web/web_test.go b/golden/go/web/web_test.go
index d750633..2419a43 100644
--- a/golden/go/web/web_test.go
+++ b/golden/go/web/web_test.go
@@ -567,7 +567,7 @@
{
Grouping: bug_revert.TestOne,
Digest: bug_revert.BravoUntriagedDigest,
- Label: expectations.NegativeStr,
+ Label: expectations.Negative,
},
}, user).Return(nil)
@@ -579,9 +579,9 @@
tr := frontend.TriageRequest{
ChangeListID: "",
- TestDigestStatus: map[types.TestName]map[types.Digest]expectations.LabelStr{
+ TestDigestStatus: map[types.TestName]map[types.Digest]expectations.Label{
bug_revert.TestOne: {
- bug_revert.BravoUntriagedDigest: expectations.NegativeStr,
+ bug_revert.BravoUntriagedDigest: expectations.Negative,
},
},
}
@@ -603,7 +603,7 @@
{
Grouping: bug_revert.TestOne,
Digest: bug_revert.BravoUntriagedDigest,
- Label: expectations.NegativeStr,
+ Label: expectations.Negative,
},
}, algorithmName).Return(nil)
@@ -615,9 +615,9 @@
tr := frontend.TriageRequest{
ChangeListID: "",
- TestDigestStatus: map[types.TestName]map[types.Digest]expectations.LabelStr{
+ TestDigestStatus: map[types.TestName]map[types.Digest]expectations.Label{
bug_revert.TestOne: {
- bug_revert.BravoUntriagedDigest: expectations.NegativeStr,
+ bug_revert.BravoUntriagedDigest: expectations.Negative,
},
},
ImageMatchingAlgorithm: algorithmName,
@@ -649,7 +649,7 @@
{
Grouping: bug_revert.TestOne,
Digest: bug_revert.BravoUntriagedDigest,
- Label: expectations.NegativeStr,
+ Label: expectations.Negative,
},
}, user).Return(nil)
@@ -664,9 +664,9 @@
tr := frontend.TriageRequest{
ChangeListID: clID,
- TestDigestStatus: map[types.TestName]map[types.Digest]expectations.LabelStr{
+ TestDigestStatus: map[types.TestName]map[types.Digest]expectations.Label{
bug_revert.TestOne: {
- bug_revert.BravoUntriagedDigest: expectations.NegativeStr,
+ bug_revert.BravoUntriagedDigest: expectations.Negative,
},
},
}
@@ -696,7 +696,7 @@
{
Grouping: bug_revert.TestOne,
Digest: bug_revert.BravoUntriagedDigest,
- Label: expectations.NegativeStr,
+ Label: expectations.Negative,
},
}, algorithmName).Return(nil)
@@ -711,9 +711,9 @@
tr := frontend.TriageRequest{
ChangeListID: clID,
- TestDigestStatus: map[types.TestName]map[types.Digest]expectations.LabelStr{
+ TestDigestStatus: map[types.TestName]map[types.Digest]expectations.Label{
bug_revert.TestOne: {
- bug_revert.BravoUntriagedDigest: expectations.NegativeStr,
+ bug_revert.BravoUntriagedDigest: expectations.Negative,
},
},
ImageMatchingAlgorithm: algorithmName,
@@ -737,22 +737,22 @@
assert.Contains(t, delta, expectations.Delta{
Grouping: bug_revert.TestOne,
Digest: bug_revert.AlfaPositiveDigest,
- Label: expectations.UntriagedStr,
+ Label: expectations.Untriaged,
})
assert.Contains(t, delta, expectations.Delta{
Grouping: bug_revert.TestOne,
Digest: bug_revert.BravoUntriagedDigest,
- Label: expectations.NegativeStr,
+ Label: expectations.Negative,
})
assert.Contains(t, delta, expectations.Delta{
Grouping: bug_revert.TestTwo,
Digest: bug_revert.CharliePositiveDigest,
- Label: expectations.PositiveStr,
+ Label: expectations.Positive,
})
assert.Contains(t, delta, expectations.Delta{
Grouping: bug_revert.TestTwo,
Digest: bug_revert.DeltaUntriagedDigest,
- Label: expectations.NegativeStr,
+ Label: expectations.Negative,
})
return true
})
@@ -767,14 +767,14 @@
tr := frontend.TriageRequest{
ChangeListID: "",
- TestDigestStatus: map[types.TestName]map[types.Digest]expectations.LabelStr{
+ TestDigestStatus: map[types.TestName]map[types.Digest]expectations.Label{
bug_revert.TestOne: {
- bug_revert.AlfaPositiveDigest: expectations.UntriagedStr,
- bug_revert.BravoUntriagedDigest: expectations.NegativeStr,
+ bug_revert.AlfaPositiveDigest: expectations.Untriaged,
+ bug_revert.BravoUntriagedDigest: expectations.Negative,
},
bug_revert.TestTwo: {
- bug_revert.CharliePositiveDigest: expectations.PositiveStr,
- bug_revert.DeltaUntriagedDigest: expectations.NegativeStr,
+ bug_revert.CharliePositiveDigest: expectations.Positive,
+ bug_revert.DeltaUntriagedDigest: expectations.Negative,
"digestWithNoClosestPositive": "",
},
},
@@ -798,7 +798,7 @@
{
Grouping: bug_revert.TestOne,
Digest: bug_revert.BravoUntriagedDigest,
- Label: expectations.NegativeStr,
+ Label: expectations.Negative,
},
}, user).Return(nil)
@@ -810,9 +810,9 @@
tr := frontend.TriageRequest{
ChangeListID: "0",
- TestDigestStatus: map[types.TestName]map[types.Digest]expectations.LabelStr{
+ TestDigestStatus: map[types.TestName]map[types.Digest]expectations.Label{
bug_revert.TestOne: {
- bug_revert.BravoUntriagedDigest: expectations.NegativeStr,
+ bug_revert.BravoUntriagedDigest: expectations.Negative,
},
},
}
@@ -851,7 +851,7 @@
TS: ts1,
Details: []expectations.Delta{
{
- Label: expectations.PositiveStr,
+ Label: expectations.Positive,
Digest: bug_revert.DeltaUntriagedDigest,
Grouping: bug_revert.TestOne,
},
@@ -864,12 +864,12 @@
TS: ts2,
Details: []expectations.Delta{
{
- Label: expectations.PositiveStr,
+ Label: expectations.Positive,
Digest: bug_revert.BravoUntriagedDigest,
Grouping: bug_revert.TestOne,
},
{
- Label: expectations.NegativeStr,
+ Label: expectations.Negative,
Digest: bug_revert.CharliePositiveDigest,
Grouping: bug_revert.TestOne,
},
@@ -890,7 +890,7 @@
TS: ts1.Unix() * 1000,
Details: []frontend.TriageDelta{
{
- Label: expectations.PositiveStr,
+ Label: expectations.Positive,
Digest: bug_revert.DeltaUntriagedDigest,
TestName: bug_revert.TestOne,
},
@@ -903,12 +903,12 @@
TS: ts2.Unix() * 1000,
Details: []frontend.TriageDelta{
{
- Label: expectations.PositiveStr,
+ Label: expectations.Positive,
Digest: bug_revert.BravoUntriagedDigest,
TestName: bug_revert.TestOne,
},
{
- Label: expectations.NegativeStr,
+ Label: expectations.Negative,
Digest: bug_revert.CharliePositiveDigest,
TestName: bug_revert.TestOne,
},
@@ -1005,7 +1005,7 @@
// Pretending EchoPositiveDigest is untriaged makes the data a bit more interesting, in the sense
// that we can observe differences between Count/ExclusiveCount and
// UntriagedCount/ExclusiveUntriagedCount.
- exp.Set(bug_revert.TestTwo, bug_revert.EchoPositiveDigest, expectations.UntriagedStr)
+ exp.Set(bug_revert.TestTwo, bug_revert.EchoPositiveDigest, expectations.Untriaged)
mes.On("Get", testutils.AnyContext).Return(exp, nil)
fis := makeBugRevertIndexWithIgnores(makeIgnoreRules(), 1)
@@ -1078,7 +1078,7 @@
exp := bug_revert.MakeTestExpectations()
// This makes the data a bit more interesting
- exp.Set(bug_revert.TestTwo, bug_revert.EchoPositiveDigest, expectations.UntriagedStr)
+ exp.Set(bug_revert.TestTwo, bug_revert.EchoPositiveDigest, expectations.Untriaged)
mes.On("Get", testutils.AnyContext).Return(exp, nil)
fis := makeBugRevertIndexWithIgnores(makeIgnoreRules(), 50)
diff --git a/golden/modules/rpc_types.ts b/golden/modules/rpc_types.ts
index a9df6c2..94d31e2 100644
--- a/golden/modules/rpc_types.ts
+++ b/golden/modules/rpc_types.ts
@@ -44,7 +44,7 @@
export interface DigestStatus {
digest: Digest;
- status: LabelStr;
+ status: Label;
}
export interface TraceGroup {
@@ -61,7 +61,7 @@
dimDiffer?: boolean;
diffs?: { [key: string]: number };
digest: Digest;
- status: LabelStr;
+ status: Label;
paramset: ParamSet;
n: number;
}
@@ -69,7 +69,7 @@
export interface SearchResult {
digest: Digest;
test: TestName;
- status: LabelStr;
+ status: Label;
triage_history: TriageHistory[] | null;
paramset: ParamSet;
traces: TraceGroup;
@@ -101,7 +101,7 @@
size: number;
commits: Commit[] | null;
trace_comments: TraceComment[] | null;
- bulk_triage_data: { [key: string]: { [key: string]: LabelStr } };
+ bulk_triage_data: { [key: string]: { [key: string]: Label } };
}
export interface GUICorpusStatus {
@@ -127,7 +127,7 @@
export type TestName = string;
-export type LabelStr = "untriaged" | "positive" | "negative";
+export type Label = "untriaged" | "positive" | "negative";
export type ParamSet = { [key: string]: string[] | null };
