filter/count: Fix alignment on 32-bit systems.

filter/count/count.go

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Package count contains 'counter' filters for all the gae services. This
 // serves as a set of simple example filters, and also enables other filters
 // to test to see if certain underlying APIs are called when they should be
 // (e.g. for the datastore mcache filter, for example).
 package count
 
 import (
+        "fmt"
         "sync/atomic"
 )
 
+type Counter struct {
+        value int32
+}
+
+func (c *Counter) increment() {
+        atomic.AddInt32(&c.value, 1)
+}
+
+func (c *Counter) Get() int {

[iannucci, 2015/08/22 01:10:51]

I don't think Counter is really necessary, though I suppose you're trying to
prevent slicing an int32 (why not uint32?) in the test (assuming you Get() in
parallel with the usage of the filter, which is probably unlikely to the point
of never :)).

+        return int(atomic.LoadInt32(&c.value))
+}
+
 // Entry is a success/fail pair for a single API method. It's returned
 // by the Counter interface.
 type Entry struct {
-        Successes int64
-        Errors    int64
+        Successes Counter
+        Errors    Counter
+}
+
+func (e *Entry) String() string {
+        return fmt.Sprintf("{Successes:%d, Errors:%d}", e.Successes.Get(), e.Errors.Get())
 }
 
 // Total is a convenience function for getting the total number of calls to
 // this API. It's Successes+Errors.
-func (e Entry) Total() int64 { return e.Successes + e.Errors }
+func (e *Entry) Total() int64 { return int64(e.Successes.Get()) + int64(e.Errors.Get()) }
 
 func (e *Entry) up(errs ...error) error {
         err := error(nil)
         if len(errs) > 0 {
                 err = errs[0]
         }
         if err == nil {
-                atomic.AddInt64(&e.Successes, 1)
+                e.Successes.increment()
         } else {
-                atomic.AddInt64(&e.Errors, 1)
+                e.Errors.increment()
         }
         return err
 }