func (fa *FakeAuth) Login(rietveldURL string, after time.Time) error { fa.callLog = append(fa.callLog, "Login", rietveldURL) if !after.Equal(fixedSignTime) { return fmt.Errorf("FakeAuth: want fixedSignTime, got %v", after) } return nil }
// calculateMovingAverageTxDates determines the buy and sell dates for a unit based on moving average crossovers // it returns the buyDates and the sellDates func calculateMovingAverageTxDates(fastAvgPeriod int, slowAvgPeriod int, firstAllowedBuyDate time.Time, pricesPtr *[]metric.Metric) (*[]time.Time, *[]time.Time) { fastAvg := analyser.MovingAverage(fastAvgPeriod, pricesPtr) slowAvg := analyser.MovingAverage(slowAvgPeriod, pricesPtr) // Make the avgs start on the same date fastAvg = fastAvg[slowAvgPeriod-fastAvgPeriod:] // Work out the buy and sell dates buy := make([]time.Time, 0) sell := make([]time.Time, 0) for i := 1; i < len(fastAvg); i++ { if fastAvg[i].Value > slowAvg[i].Value && fastAvg[i-1].Value < slowAvg[i-1].Value && (firstAllowedBuyDate.Before(fastAvg[i].Time) || firstAllowedBuyDate.Equal(fastAvg[i].Time)) { // Low to high crossover - buy buy = append(buy, fastAvg[i].Time) } else if fastAvg[i].Value < slowAvg[i].Value && fastAvg[i-1].Value > slowAvg[i-1].Value && len(buy) > 0 { // High to low crossover - sell, can only sell if we've previously bought sell = append(sell, fastAvg[i].Time) } } return &buy, &sell }
// Begins returns the timestamp of the beginning of this RRA assuming // that that the argument "now" is within it. This will be a time // approximately but not exactly the RRA length ago, because it is // aligned on the RRA step boundary. func (rra *RoundRobinArchive) Begins(now time.Time) time.Time { rraStart := now.Add(rra.step * time.Duration(rra.size) * -1).Truncate(rra.step) if now.Equal(now.Truncate(rra.step)) { rraStart = rraStart.Add(rra.step) } return rraStart }
func (s *RethinkSuite) TestTimeISO8601(c *test.C) { var t1, t2 time.Time t2, _ = time.Parse("2006-01-02T15:04:05-07:00", "1986-11-03T08:30:00-07:00") err := ISO8601("1986-11-03T08:30:00-07:00").RunRow(sess).Scan(&t1) c.Assert(err, test.IsNil) c.Assert(t1.Equal(t2), test.Equals, true) }
// isKeyValidAt returns whether the account key is valid at 'when' time. func (ak *AccountKey) isKeyValidAt(when time.Time) bool { valid := when.After(ak.since) || when.Equal(ak.since) if valid && !ak.until.IsZero() { valid = when.Before(ak.until) } return valid }
func TestMock(t *testing.T) { example := mockResult(1, "int", "str", "bool", "float", "time") example.Next() var num int64 var str string var boolean bool var float float64 var timestamp time.Time example.Scanner.Scan(&num, &str, &boolean, &float, ×tamp) if num != mockInt { t.Errorf("Unequal mock int: have %d, want %d", num, mockInt) } if str != mockStr { t.Errorf("Unequal mock str: have %s, want %s", str, mockStr) } if boolean != mockBool { t.Errorf("Unequal mock bool: have %t, want %t", boolean, mockBool) } if float != mockFloat { t.Errorf("Unequal mock float: have %f, want %f", float, mockFloat) } if !timestamp.Equal(mockTime) { t.Errorf("Unequal mock time: have %v, want %v", timestamp, mockTime) } }
func TestParse(t *testing.T) { var ( s string p, x time.Time err error ) // Local time now := time.Now() times := map[string]time.Time{ "5m": now.Add(time.Duration(time.Minute * 5)), "-0h": now.Add(-time.Duration(time.Hour * 0)), "-48h5m": now.Add(-time.Duration(time.Hour*48 + time.Minute*5)), // UTC "2013-04-10": time.Date(2013, 4, 10, 0, 0, 0, 0, time.UTC), "April 4, 2013": time.Date(2013, 4, 4, 0, 0, 0, 0, time.UTC), "Apr 04, 2013": time.Date(2013, 4, 4, 0, 0, 0, 0, time.UTC), "47065363200000000": time.Date(1492, 6, 11, 0, 0, 0, 0, time.UTC), "02-01-2006": time.Date(2006, 1, 2, 0, 0, 0, 0, time.UTC), "02-01-2006 2:04 PM": time.Date(2006, 1, 2, 14, 4, 0, 0, time.UTC), "02-01-2006 2:04 PM -0700": time.Date(2006, 1, 2, 21, 4, 0, 0, time.UTC), "02-01-2006 2:04 PM -07:00": time.Date(2006, 1, 2, 21, 4, 0, 0, time.UTC), "2 January 2006": time.Date(2006, 1, 2, 0, 0, 0, 0, time.UTC), "2 January 2006 3:04 PM": time.Date(2006, 1, 2, 15, 4, 0, 0, time.UTC), "2 January 2006 3:04 PM -0700": time.Date(2006, 1, 2, 22, 4, 0, 0, time.UTC), "2 January 2006 3:04 PM -07:00": time.Date(2006, 1, 2, 22, 4, 0, 0, time.UTC), "2006-01-02": time.Date(2006, 1, 2, 0, 0, 0, 0, time.UTC), "2006-01-02 3:04 PM": time.Date(2006, 1, 2, 15, 4, 0, 0, time.UTC), "2006-01-02 3:04 PM -0700": time.Date(2006, 1, 2, 22, 4, 0, 0, time.UTC), "2006-01-02 3:04 PM -07:00": time.Date(2006, 1, 2, 22, 4, 0, 0, time.UTC), "January 2, 2006": time.Date(2006, 1, 2, 0, 0, 0, 0, time.UTC), "January 2, 2006 3:04 PM": time.Date(2006, 1, 2, 15, 4, 0, 0, time.UTC), "January 2, 2006 3:04 PM -0700": time.Date(2006, 1, 2, 22, 4, 0, 0, time.UTC), "January 2, 2006 3:04 PM -07:00": time.Date(2006, 1, 2, 22, 4, 0, 0, time.UTC), "Jan 2, 2006": time.Date(2006, 1, 2, 0, 0, 0, 0, time.UTC), "Jan 2, 2006, 3:04 PM": time.Date(2006, 1, 2, 15, 4, 0, 0, time.UTC), "Jan 2, 2006 3:04 PM -0700": time.Date(2006, 1, 2, 22, 4, 0, 0, time.UTC), "Jan 2, 2006 3:04 PM -07:00": time.Date(2006, 1, 2, 22, 4, 0, 0, time.UTC), } // Duration to truncate for comparison. td := time.Second for s, x = range times { p, err = Parse(s) if err != nil { t.Errorf("time: failed to parse %s as time", s) } else { x = x.Truncate(td) p = p.Truncate(td) if !p.Equal(x) { t.Errorf("time: expected %s, got %s", x, p) } } } }
func isStartOfMonth(t time.Time) bool { y := t.Year() m := t.Month() utcLoc, _ := time.LoadLocation("UTC") startOfMonth := time.Date(y, m, 1, 0, 0, 0, 0, utcLoc) return t.Equal(startOfMonth) }
func LoadPerf(fName string, since, until time.Time) ([]PerfLogEntry, error) { fIn, err := os.Open(fName) if err != nil { return nil, err } defer fIn.Close() dec := json.NewDecoder(fIn) var result []PerfLogEntry for { var entry PerfLogEntry err = dec.Decode(&entry) if err != nil { if strings.Contains(err.Error(), "EOF") { break } else { return nil, fmt.Errorf("Decode error: %v", err) } } else { if !since.Equal(time.Time{}) && since.After(entry.Timestamp) { continue } if !until.Equal(time.Time{}) && until.Before(entry.Timestamp) { continue } result = append(result, entry) } } return result, nil }
func in(date, start, end time.Time) bool { if date.Equal(start) || date.Equal(end) { return true } return date.After(start) && date.Before(end) }
func (r *VirtualMtimeRepo) GetMtime(path string, diskMtime time.Time) time.Time { data, exists := r.ns.Bytes(path) if !exists { // Absense of debug print is significant enough in itself here return diskMtime } var mtime time.Time if err := mtime.UnmarshalBinary(data[:len(data)/2]); err != nil { panic(fmt.Sprintf("Can't unmarshal stored mtime at path %s: %v", path, err)) } if mtime.Equal(diskMtime) { if err := mtime.UnmarshalBinary(data[len(data)/2:]); err != nil { panic(fmt.Sprintf("Can't unmarshal stored mtime at path %s: %v", path, err)) } if debug { l.Debugf("virtual mtime: return %v instead of %v for path: %s", mtime, diskMtime, path) } return mtime } if debug { l.Debugf("virtual mtime: record exists, but mismatch inDisk: %v dbDisk: %v for path: %s", diskMtime, mtime, path) } return diskMtime }
// surroundingStep returns begin and end of a PDP which either // includes or ends on a given time mark. func surroundingStep(mark time.Time, step time.Duration) (time.Time, time.Time) { begin := mark.Truncate(step) if mark.Equal(begin) { // We are exactly at the end, need to move one step back. begin = begin.Add(step * -1) } return begin, begin.Add(step) }
func ftime2Func(t time.Time) string { if t == zeroTime || t.Equal(walker.NotYetCrawled) { return "" } else { return t.Format(timeFormat) } }
func assertExpectedTUFMetaInStore(t *testing.T, s MetaStore, expected []StoredTUFMeta, current bool) { for _, tufObj := range expected { var prevTime *time.Time if current { cDate, tufdata, err := s.GetCurrent(tufObj.Gun, tufObj.Role) require.NoError(t, err) require.Equal(t, tufObj.Data, tufdata) // the update date was sometime wthin the last minute require.True(t, cDate.After(time.Now().Add(-1*time.Minute))) require.True(t, cDate.Before(time.Now().Add(5*time.Second))) prevTime = cDate } checksumBytes := sha256.Sum256(tufObj.Data) checksum := hex.EncodeToString(checksumBytes[:]) cDate, tufdata, err := s.GetChecksum(tufObj.Gun, tufObj.Role, checksum) require.NoError(t, err) require.Equal(t, tufObj.Data, tufdata) if current { require.True(t, prevTime.Equal(*cDate), "%s should be equal to %s", prevTime, cDate) } else { // the update date was sometime wthin the last minute require.True(t, cDate.After(time.Now().Add(-1*time.Minute))) require.True(t, cDate.Before(time.Now().Add(5*time.Second))) } } }
// ValidAt returns whether the system-user is valid at 'when' time. func (su *SystemUser) ValidAt(when time.Time) bool { valid := when.After(su.since) || when.Equal(su.since) if valid { valid = when.Before(su.until) } return valid }
// tryUpdate tries to update conf with the named resolv.conf file. // The name variable only exists for testing. It is otherwise always // "/etc/resolv.conf". func (conf *resolverConfig) tryUpdate(name string) { conf.initOnce.Do(conf.init) // Ensure only one update at a time checks resolv.conf. if !conf.tryAcquireSema() { return } defer conf.releaseSema() now := time.Now() if conf.lastChecked.After(now.Add(-5 * time.Second)) { return } conf.lastChecked = now var mtime time.Time if fi, err := os.Stat(name); err == nil { mtime = fi.ModTime() } if mtime.Equal(conf.dnsConfig.mtime) { return } dnsConf := dnsReadConfig(name) conf.mu.Lock() conf.dnsConfig = dnsConf conf.mu.Unlock() }
func (gp *GoPdf) bindInfo(buff *bytes.Buffer) { var zerotime time.Time buff.WriteString("/Info <<\n") if gp.info.Author != "" { buff.WriteString(fmt.Sprintf("/Author <FEFF%s>\n", encodeUtf8(gp.info.Author))) } if gp.info.Title != "" { buff.WriteString(fmt.Sprintf("/Title <FEFF%s>\n", encodeUtf8(gp.info.Title))) } if gp.info.Subject != "" { buff.WriteString(fmt.Sprintf("/Subject <FEFF%s>\n", encodeUtf8(gp.info.Subject))) } if gp.info.Creator != "" { buff.WriteString(fmt.Sprintf("/Creator <FEFF%s>\n", encodeUtf8(gp.info.Creator))) } if gp.info.Producer != "" { buff.WriteString(fmt.Sprintf("/Producer <FEFF%s>\n", encodeUtf8(gp.info.Producer))) } if !zerotime.Equal(gp.info.CreationDate) { buff.WriteString(fmt.Sprintf("/CreationDate(D:%s)>>\n", infodate(gp.info.CreationDate))) } buff.WriteString(" >>\n") }
func TestSetGetChecked(t *testing.T) { v := Value{} v.SetBytes(nil) if _, err := v.GetBytes(); err != nil { t.Fatal(err) } f := 1.1 v.SetFloat(f) if r, err := v.GetFloat(); err != nil { t.Fatal(err) } else if f != r { t.Errorf("set %f on a value and extracted it, expected %f back, but got %f", f, f, r) } i := int64(1) v.SetInt(i) if r, err := v.GetInt(); err != nil { t.Fatal(err) } else if i != r { t.Errorf("set %d on a value and extracted it, expected %d back, but got %d", i, i, r) } dec := inf.NewDec(11, 1) if err := v.SetDecimal(dec); err != nil { t.Fatal(err) } if r, err := v.GetDecimal(); err != nil { t.Fatal(err) } else if dec.Cmp(r) != 0 { t.Errorf("set %s on a value and extracted it, expected %s back, but got %s", dec, dec, r) } if err := v.SetProto(&Value{}); err != nil { t.Fatal(err) } if err := v.GetProto(&Value{}); err != nil { t.Fatal(err) } if _, err := v.GetBytes(); err != nil { t.Fatal(err) } if err := v.SetProto(&InternalTimeSeriesData{}); err != nil { t.Fatal(err) } if _, err := v.GetTimeseries(); err != nil { t.Fatal(err) } ti := time.Time{} v.SetTime(ti) if r, err := v.GetTime(); err != nil { t.Fatal(err) } else if !ti.Equal(r) { t.Errorf("set %s on a value and extracted it, expected %s back, but got %s", ti, ti, r) } }
// updateTime updates the Cluster timestamp to the specified time. func (rc *realCluster) updateTime(new_time time.Time) { if new_time.Equal(time.Time{}) { return } rc.lock.Lock() defer rc.lock.Unlock() rc.timestamp = new_time }
func isAfterMin(minTime time.Time, lastLagerTime time.Time) bool { if minTime.IsZero() { return true } if lastLagerTime.IsZero() { return false } return lastLagerTime.After(minTime) || lastLagerTime.Equal(minTime) }
func TestRDBPrivateKeyJSONUnmarshalling(t *testing.T) { created := time.Now().AddDate(-1, -1, -1) updated := time.Now().AddDate(0, -5, 0) deleted := time.Time{} publicKey := []byte("Hello world public") privateKey := []byte("Hello world private") createdMarshalled, err := json.Marshal(created) require.NoError(t, err) updatedMarshalled, err := json.Marshal(updated) require.NoError(t, err) deletedMarshalled, err := json.Marshal(deleted) require.NoError(t, err) publicMarshalled, err := json.Marshal(publicKey) require.NoError(t, err) privateMarshalled, err := json.Marshal(privateKey) require.NoError(t, err) jsonBytes := []byte(fmt.Sprintf(` { "created_at": %s, "updated_at": %s, "deleted_at": %s, "key_id": "56ee4a23129fc22c6cb4b4ba5f78d730c91ab6def514e80d807c947bb21f0d63", "encryption_alg": "A256GCM", "keywrap_alg": "PBES2-HS256+A128KW", "algorithm": "ecdsa", "passphrase_alias": "timestamp_1", "public": %s, "private": %s } `, createdMarshalled, updatedMarshalled, deletedMarshalled, publicMarshalled, privateMarshalled)) unmarshalledAnon, err := PrivateKeysRethinkTable.JSONUnmarshaller(jsonBytes) require.NoError(t, err) unmarshalled, ok := unmarshalledAnon.(RDBPrivateKey) require.True(t, ok) // There is some weirdness with comparing time.Time due to a location pointer, // so let's use time.Time's equal function to compare times, and then re-assign // the timing struct to compare the rest of the RDBTUFFile struct require.True(t, created.Equal(unmarshalled.CreatedAt)) require.True(t, updated.Equal(unmarshalled.UpdatedAt)) require.True(t, deleted.Equal(unmarshalled.DeletedAt)) expected := RDBPrivateKey{ Timing: unmarshalled.Timing, KeyID: "56ee4a23129fc22c6cb4b4ba5f78d730c91ab6def514e80d807c947bb21f0d63", EncryptionAlg: "A256GCM", KeywrapAlg: "PBES2-HS256+A128KW", Algorithm: "ecdsa", PassphraseAlias: "timestamp_1", Public: publicKey, Private: privateKey, } require.Equal(t, expected, unmarshalled) }
func (i *Datetime) withinBounds(t time.Time) bool { if t.Equal(i.Start) { return true } if t.After(i.Start) && t.Before(i.End) { return true } return false }
func (s *RethinkSuite) TestTimeTimeMillisecond(c *test.C) { var response time.Time res, err := Time(1986, 11, 3, 12, 30, 15.679, "Z").Run(sess) c.Assert(err, test.IsNil) err = res.One(&response) c.Assert(err, test.IsNil) c.Assert(response.Equal(time.Date(1986, 11, 3, 12, 30, 15, 679.00002*1000*1000, time.UTC)), test.Equals, true) }
func (s *RethinkSuite) TestTimeEpochTime(c *test.C) { var response time.Time res, err := EpochTime(531360000).Run(session) c.Assert(err, test.IsNil) err = res.One(&response) c.Assert(err, test.IsNil) c.Assert(response.Equal(time.Date(1986, 11, 3, 0, 0, 0, 0, time.UTC)), test.Equals, true) }
func (s *RethinkSuite) TestTimeTime(c *test.C) { var response time.Time res, err := Time(1986, 11, 3, 12, 30, 15, "Z").Run(session) c.Assert(err, test.IsNil) err = res.One(&response) c.Assert(err, test.IsNil) c.Assert(response.Equal(time.Date(1986, 11, 3, 12, 30, 15, 0, time.UTC)), test.Equals, true) }
func isBeforeMax(maxTime time.Time, lastLagerTime time.Time) bool { if maxTime.IsZero() { return true } if lastLagerTime.IsZero() { return true } return lastLagerTime.Before(maxTime) || lastLagerTime.Equal(maxTime) }
func renderDate(t time.Time) string { // TODO(sadovsky): For now, we always use Pacific time. loc, err := time.LoadLocation("America/Los_Angeles") CheckError(err) if t.Equal(time.Unix(0, 0)) { loc = time.UTC } // return t.In(loc).Format("Jan 2 15:04:05") return t.In(loc).Format("Jan 2") }
func (a *Assert) EqTime(expect, got time.Time, msg string, params ...interface{}) *Assert { if !expect.Equal(got) { _, file, line, _ := runtime.Caller(1) file = filepath.Base(file) sexpect, _ := expect.MarshalJSON() sgot, _ := got.MarshalJSON() a.t.Fatalf("Assert.EqTime failure <%s:%d>: (expect: %s, got:%s): %q", file, line, sexpect, sgot, fmt.Sprintf(msg, params...)) } return a }
func insertNum(t *testing.T, conn *sql.Tx, small int, bigint string, notint float64, bigreal string, text string, date time.Time, ) bool { date = date.Round(time.Second) qry := fmt.Sprintf(`INSERT INTO `+tbl+` (F_int, F_bigint, F_real, F_bigreal, F_text, F_date) VALUES (%d, %s, %3.3f, %s, '%s', TO_DATE('%s', 'YYYY-MM-DD HH24:MI:SS')) `, small, bigint, notint, bigreal, text, date.Format("2006-01-02 15:04:05")) if _, err := conn.Exec(qry); err != nil { t.Errorf("cannot insert into "+tbl+" (%q): %v", qry, err) return false } row := conn.QueryRow("SELECT F_int, F_bigint, F_real, F_bigreal, F_text, F_date FROM "+tbl+" WHERE F_int = :1", small) var ( smallO int bigintO big.Int notintO float64 bigrealF, bigrealO big.Rat bigintS, bigrealS string textO string dateO time.Time ) if err := row.Scan(&smallO, &bigintS, ¬intO, &bigrealS, &textO, &dateO); err != nil { t.Errorf("error scanning row[%d]: %v", small, errgo.Details(err)) return false } t.Logf("row: small=%d big=%s notint=%f bigreal=%s text=%q date=%s", smallO, bigintS, notintO, bigrealS, textO, dateO) if smallO != small { t.Errorf("small mismatch: got %d, awaited %d.", smallO, small) } (&bigintO).SetString(bigintS, 10) if bigintO.String() != bigint { t.Errorf("bigint mismatch: got %s, awaited %s.", bigintO, bigint) } if notintO != notint { t.Errorf("noting mismatch: got %f, awaited %f.", notintO, notint) } (&bigrealF).SetString(bigreal) (&bigrealO).SetString(bigrealS) if (&bigrealO).Cmp(&bigrealF) != 0 { t.Errorf("bigreal mismatch: got %s, awaited %f.", (&bigrealO), (&bigrealF)) } if textO != text { t.Errorf("text mismatch: got %q, awaited %q.", textO, text) } if !dateO.Equal(date) { t.Errorf("date mismatch: got %s, awaited %s.", dateO, date.Round(time.Second)) } return true }
func TestRDBTUFFileJSONUnmarshalling(t *testing.T) { created := time.Now().AddDate(-1, -1, -1) updated := time.Now().AddDate(0, -5, 0) deleted := time.Time{} data := []byte("Hello world") createdMarshalled, err := json.Marshal(created) require.NoError(t, err) updatedMarshalled, err := json.Marshal(updated) require.NoError(t, err) deletedMarshalled, err := json.Marshal(deleted) require.NoError(t, err) dataMarshalled, err := json.Marshal(data) require.NoError(t, err) jsonBytes := []byte(fmt.Sprintf(` { "created_at": %s, "updated_at": %s, "deleted_at": %s, "gun_role_version": ["completely", "invalid", "garbage"], "gun": "namespaced/name", "role": "timestamp", "version": 5, "sha256": "56ee4a23129fc22c6cb4b4ba5f78d730c91ab6def514e80d807c947bb21f0d63", "data": %s, "timestamp_checksum": "ebe6b6e082c94ef24043f1786a7046432506c3d193a47c299ed48ff4413ad7b0" } `, createdMarshalled, updatedMarshalled, deletedMarshalled, dataMarshalled)) unmarshalledAnon, err := TUFFilesRethinkTable.JSONUnmarshaller(jsonBytes) require.NoError(t, err) unmarshalled, ok := unmarshalledAnon.(RDBTUFFile) require.True(t, ok) // There is some weirdness with comparing time.Time due to a location pointer, // so let's use time.Time's equal function to compare times, and then re-assign // the timing struct to compare the rest of the RDBTUFFile struct require.True(t, created.Equal(unmarshalled.CreatedAt)) require.True(t, updated.Equal(unmarshalled.UpdatedAt)) require.True(t, deleted.Equal(unmarshalled.DeletedAt)) expected := RDBTUFFile{ Timing: unmarshalled.Timing, GunRoleVersion: []interface{}{"namespaced/name", "timestamp", 5}, Gun: "namespaced/name", Role: "timestamp", Version: 5, Sha256: "56ee4a23129fc22c6cb4b4ba5f78d730c91ab6def514e80d807c947bb21f0d63", Data: data, TSchecksum: "ebe6b6e082c94ef24043f1786a7046432506c3d193a47c299ed48ff4413ad7b0", } require.Equal(t, expected, unmarshalled) }