Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified	Actions
📁 ..	-	2025-05-25 12:27
📁 any	-	2025-05-25 12:27
📄 any.go // Copyright 2016 The Go 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 ptypes import ( "fmt" "strings" "github.com/golang/protobuf/proto" "google.golang.org/protobuf/reflect/protoreflect" "google.golang.org/protobuf/reflect/protoregistry" anypb "github.com/golang/protobuf/ptypes/any" ) const urlPrefix = "type.googleapis.com/" // AnyMessageName returns the message name contained in an anypb.Any message. // Most type assertions should use the Is function instead. // // Deprecated: Call the any.MessageName method instead. func AnyMessageName(any anypb.Any) (string, error) { name, err := anyMessageName(any) return string(name), err } func anyMessageName(any anypb.Any) (protoreflect.FullName, error) { if any == nil { return "", fmt.Errorf("message is nil") } name := protoreflect.FullName(any.TypeUrl) if i := strings.LastIndex(any.TypeUrl, "/"); i >= 0 { name = name[i+len("/"):] } if !name.IsValid() { return "", fmt.Errorf("message type url %q is invalid", any.TypeUrl) } return name, nil } // MarshalAny marshals the given message m into an anypb.Any message. // // Deprecated: Call the anypb.New function instead. func MarshalAny(m proto.Message) (anypb.Any, error) { switch dm := m.(type) { case DynamicAny: m = dm.Message case DynamicAny: if dm == nil { return nil, proto.ErrNil } m = dm.Message } b, err := proto.Marshal(m) if err != nil { return nil, err } return &anypb.Any{TypeUrl: urlPrefix + proto.MessageName(m), Value: b}, nil } // Empty returns a new message of the type specified in an anypb.Any message. // It returns protoregistry.NotFound if the corresponding message type could not // be resolved in the global registry. // // Deprecated: Use protoregistry.GlobalTypes.FindMessageByName instead // to resolve the message name and create a new instance of it. func Empty(any anypb.Any) (proto.Message, error) { name, err := anyMessageName(any) if err != nil { return nil, err } mt, err := protoregistry.GlobalTypes.FindMessageByName(name) if err != nil { return nil, err } return proto.MessageV1(mt.New().Interface()), nil } // UnmarshalAny unmarshals the encoded value contained in the anypb.Any message // into the provided message m. It returns an error if the target message // does not match the type in the Any message or if an unmarshal error occurs. // // The target message m may be a DynamicAny message. If the underlying message // type could not be resolved, then this returns protoregistry.NotFound. // // Deprecated: Call the any.UnmarshalTo method instead. func UnmarshalAny(any anypb.Any, m proto.Message) error { if dm, ok := m.(DynamicAny); ok { if dm.Message == nil { var err error dm.Message, err = Empty(any) if err != nil { return err } } m = dm.Message } anyName, err := AnyMessageName(any) if err != nil { return err } msgName := proto.MessageName(m) if anyName != msgName { return fmt.Errorf("mismatched message type: got %q want %q", anyName, msgName) } return proto.Unmarshal(any.Value, m) } // Is reports whether the Any message contains a message of the specified type. // // Deprecated: Call the any.MessageIs method instead. func Is(any *anypb.Any, m proto.Message) bool { if any == nil \|\| m == nil { return false } name := proto.MessageName(m) if !strings.HasSuffix(any.TypeUrl, name) { return false } return len(any.TypeUrl) == len(name) \|\| any.TypeUrl[len(any.TypeUrl)-len(name)-1] == '/' } // DynamicAny is a value that can be passed to UnmarshalAny to automatically // allocate a proto.Message for the type specified in an anypb.Any message. // The allocated message is stored in the embedded proto.Message. // // Example: // var x ptypes.DynamicAny // if err := ptypes.UnmarshalAny(a, &x); err != nil { ... } // fmt.Printf("unmarshaled message: %v", x.Message) // // Deprecated: Use the any.UnmarshalNew method instead to unmarshal // the any message contents into a new instance of the underlying message. type DynamicAny struct{ proto.Message } func (m DynamicAny) String() string { if m.Message == nil { return "<nil>" } return m.Message.String() } func (m DynamicAny) Reset() { if m.Message == nil { return } m.Message.Reset() } func (m DynamicAny) ProtoMessage() { return } func (m DynamicAny) ProtoReflect() protoreflect.Message { if m.Message == nil { return nil } return dynamicAny{proto.MessageReflect(m.Message)} } type dynamicAny struct{ protoreflect.Message } func (m dynamicAny) Type() protoreflect.MessageType { return dynamicAnyType{m.Message.Type()} } func (m dynamicAny) New() protoreflect.Message { return dynamicAnyType{m.Message.Type()}.New() } func (m dynamicAny) Interface() protoreflect.ProtoMessage { return DynamicAny{proto.MessageV1(m.Message.Interface())} } type dynamicAnyType struct{ protoreflect.MessageType } func (t dynamicAnyType) New() protoreflect.Message { return dynamicAny{t.MessageType.New()} } func (t dynamicAnyType) Zero() protoreflect.Message { return dynamicAny{t.MessageType.Zero()} }	5.02 KB	2025-05-25 12:27
📄 any_test.go // Copyright 2016 The Go 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 ptypes import ( "reflect" "testing" "github.com/golang/protobuf/proto" descriptorpb "github.com/golang/protobuf/protoc-gen-go/descriptor" anypb "github.com/golang/protobuf/ptypes/any" ) func TestMarshalUnmarshal(t testing.T) { orig := &anypb.Any{Value: []byte("test")} packed, err := MarshalAny(orig) if err != nil { t.Errorf("MarshalAny(%+v): got: _, %v exp: _, nil", orig, err) } unpacked := &anypb.Any{} err = UnmarshalAny(packed, unpacked) if err != nil \|\| !proto.Equal(unpacked, orig) { t.Errorf("got: %v, %+v; want nil, %+v", err, unpacked, orig) } } func TestIs(t testing.T) { a, err := MarshalAny(&descriptorpb.FileDescriptorProto{}) if err != nil { t.Fatal(err) } if Is(a, &descriptorpb.DescriptorProto{}) { // No spurious match for message names of different length. t.Error("FileDescriptorProto is not a DescriptorProto, but Is says it is") } if Is(a, &descriptorpb.EnumDescriptorProto{}) { // No spurious match for message names of equal length. t.Error("FileDescriptorProto is not an EnumDescriptorProto, but Is says it is") } if !Is(a, &descriptorpb.FileDescriptorProto{}) { t.Error("FileDescriptorProto is indeed a FileDescriptorProto, but Is says it is not") } } func TestIsDifferentUrlPrefixes(t testing.T) { m := &descriptorpb.FileDescriptorProto{} a := &anypb.Any{TypeUrl: "foo/bar/" + proto.MessageName(m)} if !Is(a, m) { t.Errorf("message with type url %q didn't satisfy Is for type %q", a.TypeUrl, proto.MessageName(m)) } } func TestIsCornerCases(t testing.T) { m := &descriptorpb.FileDescriptorProto{} if Is(nil, m) { t.Errorf("message with nil type url incorrectly claimed to be %q", proto.MessageName(m)) } noPrefix := &anypb.Any{TypeUrl: proto.MessageName(m)} if !Is(noPrefix, m) { t.Errorf("message with type url %q didn't satisfy Is for type %q", noPrefix.TypeUrl, proto.MessageName(m)) } shortPrefix := &anypb.Any{TypeUrl: "/" + proto.MessageName(m)} if !Is(shortPrefix, m) { t.Errorf("message with type url %q didn't satisfy Is for type %q", shortPrefix.TypeUrl, proto.MessageName(m)) } } func TestUnmarshalDynamic(t testing.T) { want := &descriptorpb.FileDescriptorProto{Name: proto.String("foo")} a, err := MarshalAny(want) if err != nil { t.Fatal(err) } var got DynamicAny if err := UnmarshalAny(a, &got); err != nil { t.Fatal(err) } if !proto.Equal(got.Message, want) { t.Errorf("invalid result from UnmarshalAny, got %q want %q", got.Message, want) } } func TestEmpty(t testing.T) { want := &descriptorpb.FileDescriptorProto{} a, err := MarshalAny(want) if err != nil { t.Fatal(err) } got, err := Empty(a) if err != nil { t.Fatal(err) } if !proto.Equal(got, want) { t.Errorf("unequal empty message, got %q, want %q", got, want) } // that's a valid type_url for a message which shouldn't be linked into this // test binary. We want an error. a.TypeUrl = "type.googleapis.com/google.protobuf.FieldMask" if _, err := Empty(a); err == nil { t.Errorf("got no error for an attempt to create a message of type %q, which shouldn't be linked in", a.TypeUrl) } } func TestEmptyCornerCases(t testing.T) { _, err := Empty(nil) if err == nil { t.Error("expected Empty for nil to fail") } want := &descriptorpb.FileDescriptorProto{} noPrefix := &anypb.Any{TypeUrl: proto.MessageName(want)} got, err := Empty(noPrefix) if err != nil { t.Errorf("Empty for any type %q failed: %s", noPrefix.TypeUrl, err) } if !proto.Equal(got, want) { t.Errorf("Empty for any type %q differs, got %q, want %q", noPrefix.TypeUrl, got, want) } shortPrefix := &anypb.Any{TypeUrl: "/" + proto.MessageName(want)} got, err = Empty(shortPrefix) if err != nil { t.Errorf("Empty for any type %q failed: %s", shortPrefix.TypeUrl, err) } if !proto.Equal(got, want) { t.Errorf("Empty for any type %q differs, got %q, want %q", shortPrefix.TypeUrl, got, want) } } func TestAnyReflect(t testing.T) { want := &descriptorpb.FileDescriptorProto{Name: proto.String("foo")} a, err := MarshalAny(want) if err != nil { t.Fatal(err) } var got DynamicAny if err := UnmarshalAny(a, &got); err != nil { t.Fatal(err) } wantName := want.ProtoReflect().Descriptor().FullName() gotName := got.ProtoReflect().Descriptor().FullName() if gotName != wantName { t.Errorf("name mismatch: got %v, want %v", gotName, wantName) } wantType := reflect.TypeOf(got) gotType := reflect.TypeOf(got.ProtoReflect().Interface()) if gotType != wantType { t.Errorf("ProtoReflect().Interface() round-trip type mismatch: got %v, want %v", gotType, wantType) } gotType = reflect.TypeOf(got.ProtoReflect().New().Interface()) if gotType != wantType { t.Errorf("ProtoReflect().New().Interface() type mismatch: got %v, want %v", gotType, wantType) } gotType = reflect.TypeOf(got.ProtoReflect().Type().New().Interface()) if gotType != wantType { t.Errorf("ProtoReflect().Type().New().Interface() type mismatch: got %v, want %v", gotType, wantType) } gotType = reflect.TypeOf(got.ProtoReflect().Type().Zero().Interface()) if gotType != wantType { t.Errorf("ProtoReflect().Type().Zero().Interface() type mismatch: got %v, want %v", gotType, wantType) } }	5.22 KB	2025-05-25 12:27
📄 doc.go // Copyright 2016 The Go 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 ptypes provides functionality for interacting with well-known types. // // Deprecated: Well-known types have specialized functionality directly // injected into the generated packages for each message type. // See the deprecation notice for each function for the suggested alternative. package ptypes	472 B	2025-05-25 12:27
📁 duration	-	2025-05-25 12:27
📄 duration.go // Copyright 2016 The Go 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 ptypes import ( "errors" "fmt" "time" durationpb "github.com/golang/protobuf/ptypes/duration" ) // Range of google.protobuf.Duration as specified in duration.proto. // This is about 10,000 years in seconds. const ( maxSeconds = int64(10000 * 365.25 * 24 * 60 * 60) minSeconds = -maxSeconds ) // Duration converts a durationpb.Duration to a time.Duration. // Duration returns an error if dur is invalid or overflows a time.Duration. // // Deprecated: Call the dur.AsDuration and dur.CheckValid methods instead. func Duration(dur durationpb.Duration) (time.Duration, error) { if err := validateDuration(dur); err != nil { return 0, err } d := time.Duration(dur.Seconds) time.Second if int64(d/time.Second) != dur.Seconds { return 0, fmt.Errorf("duration: %v is out of range for time.Duration", dur) } if dur.Nanos != 0 { d += time.Duration(dur.Nanos) * time.Nanosecond if (d < 0) != (dur.Nanos < 0) { return 0, fmt.Errorf("duration: %v is out of range for time.Duration", dur) } } return d, nil } // DurationProto converts a time.Duration to a durationpb.Duration. // // Deprecated: Call the durationpb.New function instead. func DurationProto(d time.Duration) durationpb.Duration { nanos := d.Nanoseconds() secs := nanos / 1e9 nanos -= secs 1e9 return &durationpb.Duration{ Seconds: int64(secs), Nanos: int32(nanos), } } // validateDuration determines whether the durationpb.Duration is valid // according to the definition in google/protobuf/duration.proto. // A valid durpb.Duration may still be too large to fit into a time.Duration // Note that the range of durationpb.Duration is about 10,000 years, // while the range of time.Duration is about 290 years. func validateDuration(dur *durationpb.Duration) error { if dur == nil { return errors.New("duration: nil Duration") } if dur.Seconds < minSeconds \|\| dur.Seconds > maxSeconds { return fmt.Errorf("duration: %v: seconds out of range", dur) } if dur.Nanos <= -1e9 \|\| dur.Nanos >= 1e9 { return fmt.Errorf("duration: %v: nanos out of range", dur) } // Seconds and Nanos must have the same sign, unless d.Nanos is zero. if (dur.Seconds < 0 && dur.Nanos > 0) \|\| (dur.Seconds > 0 && dur.Nanos < 0) { return fmt.Errorf("duration: %v: seconds and nanos have different signs", dur) } return nil }	2.42 KB	2025-05-25 12:27
📄 duration_test.go // Copyright 2016 The Go 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 ptypes import ( "math" "testing" "time" "github.com/golang/protobuf/proto" durpb "github.com/golang/protobuf/ptypes/duration" ) const ( minGoSeconds = math.MinInt64 / int64(1e9) maxGoSeconds = math.MaxInt64 / int64(1e9) ) var durationTests = []struct { proto durpb.Duration isValid bool inRange bool dur time.Duration }{ // The zero duration. {&durpb.Duration{Seconds: 0, Nanos: 0}, true, true, 0}, // Some ordinary non-zero durations. {&durpb.Duration{Seconds: 100, Nanos: 0}, true, true, 100 time.Second}, {&durpb.Duration{Seconds: -100, Nanos: 0}, true, true, -100 * time.Second}, {&durpb.Duration{Seconds: 100, Nanos: 987}, true, true, 100time.Second + 987}, {&durpb.Duration{Seconds: -100, Nanos: -987}, true, true, -(100time.Second + 987)}, // The largest duration representable in Go. {&durpb.Duration{Seconds: maxGoSeconds, Nanos: int32(math.MaxInt64 - 1e9maxGoSeconds)}, true, true, math.MaxInt64}, // The smallest duration representable in Go. {&durpb.Duration{Seconds: minGoSeconds, Nanos: int32(math.MinInt64 - 1e9minGoSeconds)}, true, true, math.MinInt64}, {nil, false, false, 0}, {&durpb.Duration{Seconds: -100, Nanos: 987}, false, false, 0}, {&durpb.Duration{Seconds: 100, Nanos: -987}, false, false, 0}, {&durpb.Duration{Seconds: math.MinInt64, Nanos: 0}, false, false, 0}, {&durpb.Duration{Seconds: math.MaxInt64, Nanos: 0}, false, false, 0}, // The largest valid duration. {&durpb.Duration{Seconds: maxSeconds, Nanos: 1e9 - 1}, true, false, 0}, // The smallest valid duration. {&durpb.Duration{Seconds: minSeconds, Nanos: -(1e9 - 1)}, true, false, 0}, // The smallest invalid duration above the valid range. {&durpb.Duration{Seconds: maxSeconds + 1, Nanos: 0}, false, false, 0}, // The largest invalid duration below the valid range. {&durpb.Duration{Seconds: minSeconds - 1, Nanos: -(1e9 - 1)}, false, false, 0}, // One nanosecond past the largest duration representable in Go. {&durpb.Duration{Seconds: maxGoSeconds, Nanos: int32(math.MaxInt64-1e9maxGoSeconds) + 1}, true, false, 0}, // One nanosecond past the smallest duration representable in Go. {&durpb.Duration{Seconds: minGoSeconds, Nanos: int32(math.MinInt64-1e9minGoSeconds) - 1}, true, false, 0}, // One second past the largest duration representable in Go. {&durpb.Duration{Seconds: maxGoSeconds + 1, Nanos: int32(math.MaxInt64 - 1e9maxGoSeconds)}, true, false, 0}, // One second past the smallest duration representable in Go. {&durpb.Duration{Seconds: minGoSeconds - 1, Nanos: int32(math.MinInt64 - 1e9minGoSeconds)}, true, false, 0}, } func TestValidateDuration(t testing.T) { for _, test := range durationTests { err := validateDuration(test.proto) gotValid := (err == nil) if gotValid != test.isValid { t.Errorf("validateDuration(%v) = %t, want %t", test.proto, gotValid, test.isValid) } } } func TestDuration(t testing.T) { for _, test := range durationTests { got, err := Duration(test.proto) gotOK := (err == nil) wantOK := test.isValid && test.inRange if gotOK != wantOK { t.Errorf("Duration(%v) ok = %t, want %t", test.proto, gotOK, wantOK) } if err == nil && got != test.dur { t.Errorf("Duration(%v) = %v, want %v", test.proto, got, test.dur) } } } func TestDurationProto(t *testing.T) { for _, test := range durationTests { if test.isValid && test.inRange { got := DurationProto(test.dur) if !proto.Equal(got, test.proto) { t.Errorf("DurationProto(%v) = %v, want %v", test.dur, got, test.proto) } } } }	3.6 KB	2025-05-25 12:27
📁 empty	-	2025-05-25 12:27
📁 struct	-	2025-05-25 12:27
📁 timestamp	-	2025-05-25 12:27
📄 timestamp.go // Copyright 2016 The Go 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 ptypes import ( "errors" "fmt" "time" timestamppb "github.com/golang/protobuf/ptypes/timestamp" ) // Range of google.protobuf.Duration as specified in timestamp.proto. const ( // Seconds field of the earliest valid Timestamp. // This is time.Date(1, 1, 1, 0, 0, 0, 0, time.UTC).Unix(). minValidSeconds = -62135596800 // Seconds field just after the latest valid Timestamp. // This is time.Date(10000, 1, 1, 0, 0, 0, 0, time.UTC).Unix(). maxValidSeconds = 253402300800 ) // Timestamp converts a timestamppb.Timestamp to a time.Time. // It returns an error if the argument is invalid. // // Unlike most Go functions, if Timestamp returns an error, the first return // value is not the zero time.Time. Instead, it is the value obtained from the // time.Unix function when passed the contents of the Timestamp, in the UTC // locale. This may or may not be a meaningful time; many invalid Timestamps // do map to valid time.Times. // // A nil Timestamp returns an error. The first return value in that case is // undefined. // // Deprecated: Call the ts.AsTime and ts.CheckValid methods instead. func Timestamp(ts timestamppb.Timestamp) (time.Time, error) { // Don't return the zero value on error, because corresponds to a valid // timestamp. Instead return whatever time.Unix gives us. var t time.Time if ts == nil { t = time.Unix(0, 0).UTC() // treat nil like the empty Timestamp } else { t = time.Unix(ts.Seconds, int64(ts.Nanos)).UTC() } return t, validateTimestamp(ts) } // TimestampNow returns a google.protobuf.Timestamp for the current time. // // Deprecated: Call the timestamppb.Now function instead. func TimestampNow() timestamppb.Timestamp { ts, err := TimestampProto(time.Now()) if err != nil { panic("ptypes: time.Now() out of Timestamp range") } return ts } // TimestampProto converts the time.Time to a google.protobuf.Timestamp proto. // It returns an error if the resulting Timestamp is invalid. // // Deprecated: Call the timestamppb.New function instead. func TimestampProto(t time.Time) (timestamppb.Timestamp, error) { ts := &timestamppb.Timestamp{ Seconds: t.Unix(), Nanos: int32(t.Nanosecond()), } if err := validateTimestamp(ts); err != nil { return nil, err } return ts, nil } // TimestampString returns the RFC 3339 string for valid Timestamps. // For invalid Timestamps, it returns an error message in parentheses. // // Deprecated: Call the ts.AsTime method instead, // followed by a call to the Format method on the time.Time value. func TimestampString(ts timestamppb.Timestamp) string { t, err := Timestamp(ts) if err != nil { return fmt.Sprintf("(%v)", err) } return t.Format(time.RFC3339Nano) } // validateTimestamp determines whether a Timestamp is valid. // A valid timestamp represents a time in the range [0001-01-01, 10000-01-01) // and has a Nanos field in the range [0, 1e9). // // If the Timestamp is valid, validateTimestamp returns nil. // Otherwise, it returns an error that describes the problem. // // Every valid Timestamp can be represented by a time.Time, // but the converse is not true. func validateTimestamp(ts *timestamppb.Timestamp) error { if ts == nil { return errors.New("timestamp: nil Timestamp") } if ts.Seconds < minValidSeconds { return fmt.Errorf("timestamp: %v before 0001-01-01", ts) } if ts.Seconds >= maxValidSeconds { return fmt.Errorf("timestamp: %v after 10000-01-01", ts) } if ts.Nanos < 0 \|\| ts.Nanos >= 1e9 { return fmt.Errorf("timestamp: %v: nanos not in range [0, 1e9)", ts) } return nil }	3.62 KB	2025-05-25 12:27
📄 timestamp_test.go // Copyright 2016 The Go 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 ptypes import ( "math" "testing" "time" "github.com/golang/protobuf/proto" tspb "github.com/golang/protobuf/ptypes/timestamp" ) var tests = []struct { ts tspb.Timestamp valid bool t time.Time }{ // The timestamp representing the Unix epoch date. {&tspb.Timestamp{Seconds: 0, Nanos: 0}, true, utcDate(1970, 1, 1)}, // The smallest representable timestamp. {&tspb.Timestamp{Seconds: math.MinInt64, Nanos: math.MinInt32}, false, time.Unix(math.MinInt64, math.MinInt32).UTC()}, // The smallest representable timestamp with non-negative nanos. {&tspb.Timestamp{Seconds: math.MinInt64, Nanos: 0}, false, time.Unix(math.MinInt64, 0).UTC()}, // The earliest valid timestamp. {&tspb.Timestamp{Seconds: minValidSeconds, Nanos: 0}, true, utcDate(1, 1, 1)}, //"0001-01-01T00:00:00Z"}, // The largest representable timestamp. {&tspb.Timestamp{Seconds: math.MaxInt64, Nanos: math.MaxInt32}, false, time.Unix(math.MaxInt64, math.MaxInt32).UTC()}, // The largest representable timestamp with nanos in range. {&tspb.Timestamp{Seconds: math.MaxInt64, Nanos: 1e9 - 1}, false, time.Unix(math.MaxInt64, 1e9-1).UTC()}, // The largest valid timestamp. {&tspb.Timestamp{Seconds: maxValidSeconds - 1, Nanos: 1e9 - 1}, true, time.Date(9999, 12, 31, 23, 59, 59, 1e9-1, time.UTC)}, // The smallest invalid timestamp that is larger than the valid range. {&tspb.Timestamp{Seconds: maxValidSeconds, Nanos: 0}, false, time.Unix(maxValidSeconds, 0).UTC()}, // A date before the epoch. {&tspb.Timestamp{Seconds: -281836800, Nanos: 0}, true, utcDate(1961, 1, 26)}, // A date after the epoch. {&tspb.Timestamp{Seconds: 1296000000, Nanos: 0}, true, utcDate(2011, 1, 26)}, // A date after the epoch, in the middle of the day. {&tspb.Timestamp{Seconds: 1296012345, Nanos: 940483}, true, time.Date(2011, 1, 26, 3, 25, 45, 940483, time.UTC)}, } func TestValidateTimestamp(t testing.T) { for _, s := range tests { got := validateTimestamp(s.ts) if (got == nil) != s.valid { t.Errorf("validateTimestamp(%v) = %v, want %v", s.ts, got, s.valid) } } } func TestTimestamp(t testing.T) { for _, s := range tests { got, err := Timestamp(s.ts) if (err == nil) != s.valid { t.Errorf("Timestamp(%v) error = %v, but valid = %t", s.ts, err, s.valid) } else if s.valid && got != s.t { t.Errorf("Timestamp(%v) = %v, want %v", s.ts, got, s.t) } } // Special case: a nil Timestamp is an error, but returns the 0 Unix time. got, err := Timestamp(nil) want := time.Unix(0, 0).UTC() if got != want { t.Errorf("Timestamp(nil) = %v, want %v", got, want) } if err == nil { t.Errorf("Timestamp(nil) error = nil, expected error") } } func TestTimestampProto(t testing.T) { for _, s := range tests { got, err := TimestampProto(s.t) if (err == nil) != s.valid { t.Errorf("TimestampProto(%v) error = %v, but valid = %t", s.t, err, s.valid) } else if s.valid && !proto.Equal(got, s.ts) { t.Errorf("TimestampProto(%v) = %v, want %v", s.t, got, s.ts) } } // No corresponding special case here: no time.Time results in a nil Timestamp. } func TestTimestampString(t testing.T) { for _, test := range []struct { ts tspb.Timestamp want string }{ // Not much testing needed because presumably time.Format is // well-tested. {&tspb.Timestamp{Seconds: 0, Nanos: 0}, "1970-01-01T00:00:00Z"}, } { got := TimestampString(test.ts) if got != test.want { t.Errorf("TimestampString(%v) = %q, want %q", test.ts, got, test.want) } } } func utcDate(year, month, day int) time.Time { return time.Date(year, time.Month(month), day, 0, 0, 0, 0, time.UTC) } func TestTimestampNow(t *testing.T) { // Bracket the expected time. before := time.Now() ts := TimestampNow() after := time.Now() tm, err := Timestamp(ts) if err != nil { t.Errorf("between %v and %v\nTimestampNow() = %v\nwhich is invalid (%v)", before, after, ts, err) } if tm.Before(before) \|\| tm.After(after) { t.Errorf("between %v and %v\nTimestamp(TimestampNow()) = %v", before, after, tm) } }	4.09 KB	2025-05-25 12:27
📁 wrappers	-	2025-05-25 12:27

Terminal