Wala shell

Advanced PHP File Manager

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

Name	Size	Last Modified
📁 ..	-	2025-05-25 12:27
📄 .editorconfig # top-most EditorConfig file root = true # Unix-style newlines with a newline ending every file [] end_of_line = lf insert_final_newline = true indent_style = space indent_size = 2 trim_trailing_whitespace = true # Set default charset [.{js,py,go,scala,rb,java,html,css,less,sass,md}] charset = utf-8 # Tab indentation (no size specified) [.go] indent_style = tab [.md] trim_trailing_whitespace = false # Matches the exact files either package.json or .travis.yml [{package.json,.travis.yml}] indent_style = space indent_size = 2	539 B	2025-05-25 12:27
📄 .gitattributes *.go text eol=lf	18 B	2025-05-25 12:27
📁 .github	-	2025-05-25 12:27
📄 .gitignore secrets.yml coverage.out	25 B	2025-05-25 12:27
📄 .golangci.yml linters-settings: govet: check-shadowing: true golint: min-confidence: 0 gocyclo: min-complexity: 45 maligned: suggest-new: true dupl: threshold: 200 goconst: min-len: 2 min-occurrences: 3 linters: enable-all: true disable: - maligned - unparam - lll - gochecknoinits - gochecknoglobals - funlen - godox - gocognit - whitespace - wsl - wrapcheck - testpackage - nlreturn - gomnd - exhaustivestruct - goerr113 - errorlint - nestif - godot - gofumpt - paralleltest - tparallel - thelper - ifshort - exhaustruct - varnamelen - gci - depguard - errchkjson - inamedparam - nonamedreturns - musttag - ireturn - forcetypeassert - cyclop # deprecated linters - deadcode - interfacer - scopelint - varcheck - structcheck - golint - nosnakecase	952 B	2025-05-25 12:27
📄 CODE_OF_CONDUCT.md # Contributor Covenant Code of Conduct ## Our Pledge In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to making participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, gender identity and expression, level of experience, nationality, personal appearance, race, religion, or sexual identity and orientation. ## Our Standards Examples of behavior that contributes to creating a positive environment include: * Using welcoming and inclusive language * Being respectful of differing viewpoints and experiences * Gracefully accepting constructive criticism * Focusing on what is best for the community * Showing empathy towards other community members Examples of unacceptable behavior by participants include: * The use of sexualized language or imagery and unwelcome sexual attention or advances * Trolling, insulting/derogatory comments, and personal or political attacks * Public or private harassment * Publishing others' private information, such as a physical or electronic address, without explicit permission * Other conduct which could reasonably be considered inappropriate in a professional setting ## Our Responsibilities Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior. Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful. ## Scope This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. Examples of representing a project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers. ## Enforcement Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at ivan+abuse@flanders.co.nz. All complaints will be reviewed and investigated and will result in a response that is deemed necessary and appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately. Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership. ## Attribution This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, available at [http://contributor-covenant.org/version/1/4][version] [homepage]: http://contributor-covenant.org [version]: http://contributor-covenant.org/version/1/4/	3.16 KB	2025-05-25 12:27
📄 LICENSE Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 1. Definitions. "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. 2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. 3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and (b) You must cause any modified files to carry prominent notices stating that You changed the files; and (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. 5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. 7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. 8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. 9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS APPENDIX: How to apply the Apache License to your work. To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives. Copyright [yyyy] [name of copyright owner] Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.	11.09 KB	2025-05-25 12:27
📄 README.md # Strfmt [![Build Status](https://github.com/go-openapi/strfmt/actions/workflows/go-test.yml/badge.svg)](https://github.com/go-openapi/strfmt/actions?query=workflow%3A"go+test") [![codecov](https://codecov.io/gh/go-openapi/strfmt/branch/master/graph/badge.svg)](https://codecov.io/gh/go-openapi/strfmt) [![Slack Status](https://slackin.goswagger.io/badge.svg)](https://slackin.goswagger.io) [![license](http://img.shields.io/badge/license-Apache%20v2-orange.svg)](https://raw.githubusercontent.com/go-openapi/strfmt/master/LICENSE) [![GoDoc](https://godoc.org/github.com/go-openapi/strfmt?status.svg)](http://godoc.org/github.com/go-openapi/strfmt) [![Go Report Card](https://goreportcard.com/badge/github.com/go-openapi/strfmt)](https://goreportcard.com/report/github.com/go-openapi/strfmt) This package exposes a registry of data types to support string formats in the go-openapi toolkit. strfmt represents a well known string format such as credit card or email. The go toolkit for OpenAPI specifications knows how to deal with those. ## Supported data formats go-openapi/strfmt follows the swagger 2.0 specification with the following formats defined [here](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/2.0.md#data-types). It also provides convenient extensions to go-openapi users. - [x] JSON-schema draft 4 formats - date-time - email - hostname - ipv4 - ipv6 - uri - [x] swagger 2.0 format extensions - binary - byte (e.g. base64 encoded string) - date (e.g. "1970-01-01") - password - [x] go-openapi custom format extensions - bsonobjectid (BSON objectID) - creditcard - duration (e.g. "3 weeks", "1ms") - hexcolor (e.g. "#FFFFFF") - isbn, isbn10, isbn13 - mac (e.g "01:02:03:04:05:06") - rgbcolor (e.g. "rgb(100,100,100)") - ssn - uuid, uuid3, uuid4, uuid5 - cidr (e.g. "192.0.2.1/24", "2001:db8:a0b:12f0::1/32") - ulid (e.g. "00000PP9HGSBSSDZ1JTEXBJ0PW", [spec](https://github.com/ulid/spec)) > NOTE: as the name stands for, this package is intended to support string formatting only. > It does not provide validation for numerical values with swagger format extension for JSON types "number" or > "integer" (e.g. float, double, int32...). ## Type conversion All types defined here are stringers and may be converted to strings with `.String()`. Note that most types defined by this package may be converted directly to string like `string(Email{})`. `Date` and `DateTime` may be converted directly to `time.Time` like `time.Time(Time{})`. Similarly, you can convert `Duration` to `time.Duration` as in `time.Duration(Duration{})` ## Using pointers The `conv` subpackage provides helpers to convert the types to and from pointers, just like `go-openapi/swag` does with primitive types. ## Format types Types defined in strfmt expose marshaling and validation capabilities. List of defined types: - Base64 - CreditCard - Date - DateTime - Duration - Email - HexColor - Hostname - IPv4 - IPv6 - CIDR - ISBN - ISBN10 - ISBN13 - MAC - ObjectId - Password - RGBColor - SSN - URI - UUID - UUID3 - UUID4 - UUID5 - [ULID](https://github.com/ulid/spec)	3.06 KB	2025-05-25 12:27
📄 bson.go // Copyright 2015 go-swagger maintainers // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package strfmt import ( "database/sql/driver" "fmt" "go.mongodb.org/mongo-driver/bson" "go.mongodb.org/mongo-driver/bson/bsontype" bsonprim "go.mongodb.org/mongo-driver/bson/primitive" ) func init() { var id ObjectId // register this format in the default registry Default.Add("bsonobjectid", &id, IsBSONObjectID) } // IsBSONObjectID returns true when the string is a valid BSON.ObjectId func IsBSONObjectID(str string) bool { _, err := bsonprim.ObjectIDFromHex(str) return err == nil } // ObjectId represents a BSON object ID (alias to go.mongodb.org/mongo-driver/bson/primitive.ObjectID) // // swagger:strfmt bsonobjectid type ObjectId bsonprim.ObjectID //nolint:revive,stylecheck // NewObjectId creates a ObjectId from a Hex String func NewObjectId(hex string) ObjectId { //nolint:revive,stylecheck oid, err := bsonprim.ObjectIDFromHex(hex) if err != nil { panic(err) } return ObjectId(oid) } // MarshalText turns this instance into text func (id ObjectId) MarshalText() ([]byte, error) { oid := bsonprim.ObjectID(id) if oid == bsonprim.NilObjectID { return nil, nil } return []byte(oid.Hex()), nil } // UnmarshalText hydrates this instance from text func (id ObjectId) UnmarshalText(data []byte) error { // validation is performed later on if len(data) == 0 { id = ObjectId(bsonprim.NilObjectID) return nil } oidstr := string(data) oid, err := bsonprim.ObjectIDFromHex(oidstr) if err != nil { return err } id = ObjectId(oid) return nil } // Scan read a value from a database driver func (id ObjectId) Scan(raw interface{}) error { var data []byte switch v := raw.(type) { case []byte: data = v case string: data = []byte(v) default: return fmt.Errorf("cannot sql.Scan() strfmt.URI from: %#v", v) } return id.UnmarshalText(data) } // Value converts a value to a database driver value func (id ObjectId) Value() (driver.Value, error) { return driver.Value(bsonprim.ObjectID(id).Hex()), nil } func (id ObjectId) String() string { return bsonprim.ObjectID(id).Hex() } // MarshalJSON returns the ObjectId as JSON func (id ObjectId) MarshalJSON() ([]byte, error) { return bsonprim.ObjectID(id).MarshalJSON() } // UnmarshalJSON sets the ObjectId from JSON func (id ObjectId) UnmarshalJSON(data []byte) error { var obj bsonprim.ObjectID if err := obj.UnmarshalJSON(data); err != nil { return err } id = ObjectId(obj) return nil } // MarshalBSON renders the object id as a BSON document func (id ObjectId) MarshalBSON() ([]byte, error) { return bson.Marshal(bson.M{"data": bsonprim.ObjectID(id)}) } // UnmarshalBSON reads the objectId from a BSON document func (id ObjectId) UnmarshalBSON(data []byte) error { var obj struct { Data bsonprim.ObjectID } if err := bson.Unmarshal(data, &obj); err != nil { return err } id = ObjectId(obj.Data) return nil } // MarshalBSONValue is an interface implemented by types that can marshal themselves // into a BSON document represented as bytes. The bytes returned must be a valid // BSON document if the error is nil. func (id ObjectId) MarshalBSONValue() (bsontype.Type, []byte, error) { oid := bsonprim.ObjectID(id) return bson.TypeObjectID, oid[:], nil } // UnmarshalBSONValue is an interface implemented by types that can unmarshal a // BSON value representation of themselves. The BSON bytes and type can be // assumed to be valid. UnmarshalBSONValue must copy the BSON value bytes if it // wishes to retain the data after returning. func (id ObjectId) UnmarshalBSONValue(_ bsontype.Type, data []byte) error { var oid bsonprim.ObjectID copy(oid[:], data) id = ObjectId(oid) return nil } // DeepCopyInto copies the receiver and writes its value into out. func (id ObjectId) DeepCopyInto(out ObjectId) { out = id } // DeepCopy copies the receiver into a new ObjectId. func (id ObjectId) DeepCopy() ObjectId { if id == nil { return nil } out := new(ObjectId) id.DeepCopyInto(out) return out }	4.44 KB	2025-05-25 12:27
📄 bson_test.go // Copyright 2015 go-swagger maintainers // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package strfmt import ( "testing" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" "go.mongodb.org/mongo-driver/bson" ) func TestBSONObjectId_fullCycle(t testing.T) { id := NewObjectId("507f1f77bcf86cd799439011") bytes, err := id.MarshalText() require.NoError(t, err) var idCopy ObjectId err = idCopy.Scan(bytes) require.NoError(t, err) assert.Equal(t, id, idCopy) err = idCopy.UnmarshalText(bytes) require.NoError(t, err) assert.Equal(t, id, idCopy) jsonBytes, err := id.MarshalJSON() require.NoError(t, err) err = idCopy.UnmarshalJSON(jsonBytes) require.NoError(t, err) assert.Equal(t, id, idCopy) bsonBytes, err := bson.Marshal(&id) require.NoError(t, err) err = bson.Unmarshal(bsonBytes, &idCopy) require.NoError(t, err) assert.Equal(t, id, idCopy) } func TestDeepCopyObjectId(t testing.T) { id := NewObjectId("507f1f77bcf86cd799439011") in := &id out := new(ObjectId) in.DeepCopyInto(out) assert.Equal(t, in, out) out2 := in.DeepCopy() assert.Equal(t, in, out2) var inNil *ObjectId out3 := inNil.DeepCopy() assert.Nil(t, out3) }	1.67 KB	2025-05-25 12:27
📁 conv	-	2025-05-25 12:27
📄 date.go // Copyright 2015 go-swagger maintainers // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package strfmt import ( "database/sql/driver" "encoding/json" "errors" "fmt" "time" "go.mongodb.org/mongo-driver/bson" ) func init() { d := Date{} // register this format in the default registry Default.Add("date", &d, IsDate) } // IsDate returns true when the string is a valid date func IsDate(str string) bool { _, err := time.Parse(RFC3339FullDate, str) return err == nil } const ( // RFC3339FullDate represents a full-date as specified by RFC3339 // See: http://goo.gl/xXOvVd RFC3339FullDate = "2006-01-02" ) // Date represents a date from the API // // swagger:strfmt date type Date time.Time // String converts this date into a string func (d Date) String() string { return time.Time(d).Format(RFC3339FullDate) } // UnmarshalText parses a text representation into a date type func (d Date) UnmarshalText(text []byte) error { if len(text) == 0 { return nil } dd, err := time.ParseInLocation(RFC3339FullDate, string(text), DefaultTimeLocation) if err != nil { return err } d = Date(dd) return nil } // MarshalText serializes this date type to string func (d Date) MarshalText() ([]byte, error) { return []byte(d.String()), nil } // Scan scans a Date value from database driver type. func (d Date) Scan(raw interface{}) error { switch v := raw.(type) { case []byte: return d.UnmarshalText(v) case string: return d.UnmarshalText([]byte(v)) case time.Time: d = Date(v) return nil case nil: d = Date{} return nil default: return fmt.Errorf("cannot sql.Scan() strfmt.Date from: %#v", v) } } // Value converts Date to a primitive value ready to written to a database. func (d Date) Value() (driver.Value, error) { return driver.Value(d.String()), nil } // MarshalJSON returns the Date as JSON func (d Date) MarshalJSON() ([]byte, error) { return json.Marshal(time.Time(d).Format(RFC3339FullDate)) } // UnmarshalJSON sets the Date from JSON func (d Date) UnmarshalJSON(data []byte) error { if string(data) == jsonNull { return nil } var strdate string if err := json.Unmarshal(data, &strdate); err != nil { return err } tt, err := time.ParseInLocation(RFC3339FullDate, strdate, DefaultTimeLocation) if err != nil { return err } d = Date(tt) return nil } func (d Date) MarshalBSON() ([]byte, error) { return bson.Marshal(bson.M{"data": d.String()}) } func (d Date) UnmarshalBSON(data []byte) error { var m bson.M if err := bson.Unmarshal(data, &m); err != nil { return err } if data, ok := m["data"].(string); ok { rd, err := time.ParseInLocation(RFC3339FullDate, data, DefaultTimeLocation) if err != nil { return err } d = Date(rd) return nil } return errors.New("couldn't unmarshal bson bytes value as Date") } // DeepCopyInto copies the receiver and writes its value into out. func (d Date) DeepCopyInto(out Date) { out = d } // DeepCopy copies the receiver into a new Date. func (d Date) DeepCopy() Date { if d == nil { return nil } out := new(Date) d.DeepCopyInto(out) return out } // GobEncode implements the gob.GobEncoder interface. func (d Date) GobEncode() ([]byte, error) { return d.MarshalBinary() } // GobDecode implements the gob.GobDecoder interface. func (d Date) GobDecode(data []byte) error { return d.UnmarshalBinary(data) } // MarshalBinary implements the encoding.BinaryMarshaler interface. func (d Date) MarshalBinary() ([]byte, error) { return time.Time(d).MarshalBinary() } // UnmarshalBinary implements the encoding.BinaryUnmarshaler interface. func (d Date) UnmarshalBinary(data []byte) error { var original time.Time err := original.UnmarshalBinary(data) if err != nil { return err } d = Date(original) return nil } // Equal checks if two Date instances are equal func (d Date) Equal(d2 Date) bool { return time.Time(d).Equal(time.Time(d2)) }	4.32 KB	2025-05-25 12:27
📄 date_test.go // Copyright 2015 go-swagger maintainers // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package strfmt import ( "bytes" "database/sql" "database/sql/driver" "encoding/gob" "testing" "time" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" "go.mongodb.org/mongo-driver/bson" ) var _ sql.Scanner = &Date{} var _ driver.Valuer = Date{} func TestDate(t testing.T) { pp := Date{} err := pp.UnmarshalText([]byte{}) require.NoError(t, err) err = pp.UnmarshalText([]byte("yada")) require.Error(t, err) orig := "2014-12-15" bj := []byte("\"" + orig + "\"") err = pp.UnmarshalText([]byte(orig)) require.NoError(t, err) txt, err := pp.MarshalText() require.NoError(t, err) assert.Equal(t, orig, string(txt)) err = pp.UnmarshalJSON(bj) require.NoError(t, err) assert.EqualValues(t, orig, pp.String()) err = pp.UnmarshalJSON([]byte(`"1972/01/01"`)) require.Error(t, err) b, err := pp.MarshalJSON() require.NoError(t, err) assert.Equal(t, bj, b) dateOriginal := Date(time.Date(2014, 10, 10, 0, 0, 0, 0, time.UTC)) bsonData, err := bson.Marshal(&dateOriginal) require.NoError(t, err) var dateCopy Date err = bson.Unmarshal(bsonData, &dateCopy) require.NoError(t, err) assert.Equal(t, dateOriginal, dateCopy) var dateZero Date err = dateZero.UnmarshalJSON([]byte(jsonNull)) require.NoError(t, err) assert.Equal(t, Date{}, dateZero) } func TestDate_Scan(t testing.T) { ref := time.Now().Truncate(24 * time.Hour).UTC() date, str := Date(ref), ref.Format(RFC3339FullDate) values := []interface{}{str, []byte(str), ref} for _, value := range values { result := Date{} _ = (&result).Scan(value) assert.Equal(t, date, result, "value: %#v", value) } dd := Date{} err := dd.Scan(nil) require.NoError(t, err) assert.Equal(t, Date{}, dd) err = dd.Scan(19700101) require.Error(t, err) } func TestDate_Value(t testing.T) { ref := time.Now().Truncate(24 time.Hour).UTC() date := Date(ref) dbv, err := date.Value() require.NoError(t, err) assert.EqualValues(t, dbv, ref.Format("2006-01-02")) } func TestDate_IsDate(t testing.T) { tests := []struct { value string valid bool }{ {"2017-12-22", true}, {"2017-1-1", false}, {"17-13-22", false}, {"2017-02-29", false}, // not a valid date : 2017 is not a leap year {"1900-02-29", false}, // not a valid date : 1900 is not a leap year {"2100-02-29", false}, // not a valid date : 2100 is not a leap year {"2000-02-29", true}, // a valid date : 2000 is a leap year {"2400-02-29", true}, // a valid date : 2000 is a leap year {"2017-13-22", false}, {"2017-12-32", false}, {"20171-12-32", false}, {"YYYY-MM-DD", false}, {"20-17-2017", false}, {"2017-12-22T01:02:03Z", false}, } for _, test := range tests { assert.Equal(t, test.valid, IsDate(test.value), "value [%s] should be valid: [%t]", test.value, test.valid) } } func TestDeepCopyDate(t testing.T) { ref := time.Now().Truncate(24 * time.Hour).UTC() date := Date(ref) in := &date out := new(Date) in.DeepCopyInto(out) assert.Equal(t, in, out) out2 := in.DeepCopy() assert.Equal(t, in, out2) var inNil Date out3 := inNil.DeepCopy() assert.Nil(t, out3) } func TestGobEncodingDate(t testing.T) { now := time.Now() b := bytes.Buffer{} enc := gob.NewEncoder(&b) err := enc.Encode(Date(now)) require.NoError(t, err) assert.NotEmpty(t, b.Bytes()) var result Date dec := gob.NewDecoder(&b) err = dec.Decode(&result) require.NoError(t, err) assert.Equal(t, now.Year(), time.Time(result).Year()) assert.Equal(t, now.Month(), time.Time(result).Month()) assert.Equal(t, now.Day(), time.Time(result).Day()) } func TestDate_Equal(t *testing.T) { t.Parallel() d1 := Date(time.Date(2020, 10, 11, 12, 13, 14, 15, time.UTC)) d2 := Date(time.Date(2020, 10, 11, 12, 13, 14, 15, time.UTC)) d3 := Date(time.Date(2020, 11, 12, 13, 14, 15, 16, time.UTC)) //nolint:gocritic assert.True(t, d1.Equal(d1), "Same Date should Equal itself") assert.True(t, d1.Equal(d2), "Date instances should be equal") assert.False(t, d1.Equal(d3), "Date instances should not be equal") }	4.51 KB	2025-05-25 12:27
📄 default.go // Copyright 2015 go-swagger maintainers // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package strfmt import ( "database/sql/driver" "encoding/base64" "encoding/json" "errors" "fmt" "net/mail" "regexp" "strings" "github.com/asaskevich/govalidator" "github.com/google/uuid" "go.mongodb.org/mongo-driver/bson" ) const ( // HostnamePattern http://json-schema.org/latest/json-schema-validation.html#anchor114 // A string instance is valid against this attribute if it is a valid // representation for an Internet host name, as defined by RFC 1034, section 3.1 [RFC1034]. // http://tools.ietf.org/html/rfc1034#section-3.5 // <digit> ::= any one of the ten digits 0 through 9 // var digit = /[0-9]/; // <letter> ::= any one of the 52 alphabetic characters A through Z in upper case and a through z in lower case // var letter = /[a-zA-Z]/; // <let-dig> ::= <letter> \| <digit> // var letDig = /[0-9a-zA-Z]/; // <let-dig-hyp> ::= <let-dig> \| "-" // var letDigHyp = /[-0-9a-zA-Z]/; // <ldh-str> ::= <let-dig-hyp> \| <let-dig-hyp> <ldh-str> // var ldhStr = /[-0-9a-zA-Z]+/; // <label> ::= <letter> [ [ <ldh-str> ] <let-dig> ] // var label = /[a-zA-Z](([-0-9a-zA-Z]+)?[0-9a-zA-Z])?/; // <subdomain> ::= <label> \| <subdomain> "." <label> // var subdomain = /^[a-zA-Z](([-0-9a-zA-Z]+)?[0-9a-zA-Z])?(\.[a-zA-Z](([-0-9a-zA-Z]+)?[0-9a-zA-Z])?)$/; // <domain> ::= <subdomain> \| " " // // Additional validations: // - for FDQNs, top-level domain (e.g. ".com"), is at least to letters long (no special characters here) // - hostnames may start with a digit [RFC1123] // - special registered names with an underscore ('_') are not allowed in this context // - dashes are permitted, but not at the start or the end of a segment // - long top-level domain names (e.g. example.london) are permitted // - symbol unicode points are permitted (e.g. emoji) (not for top-level domain) HostnamePattern = `^([a-zA-Z0-9\p{S}\p{L}]((-?[a-zA-Z0-9\p{S}\p{L}]{0,62})?)\|([a-zA-Z0-9\p{S}\p{L}](([a-zA-Z0-9-\p{S}\p{L}]{0,61}[a-zA-Z0-9\p{S}\p{L}])?)(\.)){1,}([a-zA-Z\p{L}]){2,63})$` // json null type jsonNull = "null" ) const ( // UUIDPattern Regex for UUID that allows uppercase // // Deprecated: strfmt no longer uses regular expressions to validate UUIDs. UUIDPattern = `(?i)(^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$)\|(^[0-9a-f]{32}$)` // UUID3Pattern Regex for UUID3 that allows uppercase // // Deprecated: strfmt no longer uses regular expressions to validate UUIDs. UUID3Pattern = `(?i)(^[0-9a-f]{8}-[0-9a-f]{4}-3[0-9a-f]{3}-[0-9a-f]{4}-[0-9a-f]{12}$)\|(^[0-9a-f]{12}3[0-9a-f]{3}?[0-9a-f]{16}$)` // UUID4Pattern Regex for UUID4 that allows uppercase // // Deprecated: strfmt no longer uses regular expressions to validate UUIDs. UUID4Pattern = `(?i)(^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$)\|(^[0-9a-f]{12}4[0-9a-f]{3}[89ab][0-9a-f]{15}$)` // UUID5Pattern Regex for UUID5 that allows uppercase // // Deprecated: strfmt no longer uses regular expressions to validate UUIDs. UUID5Pattern = `(?i)(^[0-9a-f]{8}-[0-9a-f]{4}-5[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$)\|(^[0-9a-f]{12}5[0-9a-f]{3}[89ab][0-9a-f]{15}$)` ) var ( rxHostname = regexp.MustCompile(HostnamePattern) ) // IsHostname returns true when the string is a valid hostname func IsHostname(str string) bool { if !rxHostname.MatchString(str) { return false } // the sum of all label octets and label lengths is limited to 255. if len(str) > 255 { return false } // Each node has a label, which is zero to 63 octets in length parts := strings.Split(str, ".") valid := true for _, p := range parts { if len(p) > 63 { valid = false } } return valid } // IsUUID returns true is the string matches a UUID (in any version, including v6 and v7), upper case is allowed func IsUUID(str string) bool { _, err := uuid.Parse(str) return err == nil } // IsUUID3 returns true is the string matches a UUID v3, upper case is allowed func IsUUID3(str string) bool { id, err := uuid.Parse(str) return err == nil && id.Version() == uuid.Version(3) } // IsUUID4 returns true is the string matches a UUID v4, upper case is allowed func IsUUID4(str string) bool { id, err := uuid.Parse(str) return err == nil && id.Version() == uuid.Version(4) } // IsUUID5 returns true is the string matches a UUID v5, upper case is allowed func IsUUID5(str string) bool { id, err := uuid.Parse(str) return err == nil && id.Version() == uuid.Version(5) } // IsEmail validates an email address. func IsEmail(str string) bool { addr, e := mail.ParseAddress(str) return e == nil && addr.Address != "" } func init() { // register formats in the default registry: // - byte // - creditcard // - email // - hexcolor // - hostname // - ipv4 // - ipv6 // - cidr // - isbn // - isbn10 // - isbn13 // - mac // - password // - rgbcolor // - ssn // - uri // - uuid // - uuid3 // - uuid4 // - uuid5 u := URI("") Default.Add("uri", &u, govalidator.IsRequestURI) eml := Email("") Default.Add("email", &eml, IsEmail) hn := Hostname("") Default.Add("hostname", &hn, IsHostname) ip4 := IPv4("") Default.Add("ipv4", &ip4, govalidator.IsIPv4) ip6 := IPv6("") Default.Add("ipv6", &ip6, govalidator.IsIPv6) cidr := CIDR("") Default.Add("cidr", &cidr, govalidator.IsCIDR) mac := MAC("") Default.Add("mac", &mac, govalidator.IsMAC) uid := UUID("") Default.Add("uuid", &uid, IsUUID) uid3 := UUID3("") Default.Add("uuid3", &uid3, IsUUID3) uid4 := UUID4("") Default.Add("uuid4", &uid4, IsUUID4) uid5 := UUID5("") Default.Add("uuid5", &uid5, IsUUID5) isbn := ISBN("") Default.Add("isbn", &isbn, func(str string) bool { return govalidator.IsISBN10(str) \|\| govalidator.IsISBN13(str) }) isbn10 := ISBN10("") Default.Add("isbn10", &isbn10, govalidator.IsISBN10) isbn13 := ISBN13("") Default.Add("isbn13", &isbn13, govalidator.IsISBN13) cc := CreditCard("") Default.Add("creditcard", &cc, govalidator.IsCreditCard) ssn := SSN("") Default.Add("ssn", &ssn, govalidator.IsSSN) hc := HexColor("") Default.Add("hexcolor", &hc, govalidator.IsHexcolor) rc := RGBColor("") Default.Add("rgbcolor", &rc, govalidator.IsRGBcolor) b64 := Base64([]byte(nil)) Default.Add("byte", &b64, govalidator.IsBase64) pw := Password("") Default.Add("password", &pw, func(_ string) bool { return true }) } // Base64 represents a base64 encoded string, using URLEncoding alphabet // // swagger:strfmt byte type Base64 []byte // MarshalText turns this instance into text func (b Base64) MarshalText() ([]byte, error) { enc := base64.URLEncoding src := []byte(b) buf := make([]byte, enc.EncodedLen(len(src))) enc.Encode(buf, src) return buf, nil } // UnmarshalText hydrates this instance from text func (b Base64) UnmarshalText(data []byte) error { // validation is performed later on enc := base64.URLEncoding dbuf := make([]byte, enc.DecodedLen(len(data))) n, err := enc.Decode(dbuf, data) if err != nil { return err } b = dbuf[:n] return nil } // Scan read a value from a database driver func (b Base64) Scan(raw interface{}) error { switch v := raw.(type) { case []byte: dbuf := make([]byte, base64.StdEncoding.DecodedLen(len(v))) n, err := base64.StdEncoding.Decode(dbuf, v) if err != nil { return err } b = dbuf[:n] case string: vv, err := base64.StdEncoding.DecodeString(v) if err != nil { return err } b = Base64(vv) default: return fmt.Errorf("cannot sql.Scan() strfmt.Base64 from: %#v", v) } return nil } // Value converts a value to a database driver value func (b Base64) Value() (driver.Value, error) { return driver.Value(b.String()), nil } func (b Base64) String() string { return base64.StdEncoding.EncodeToString([]byte(b)) } // MarshalJSON returns the Base64 as JSON func (b Base64) MarshalJSON() ([]byte, error) { return json.Marshal(b.String()) } // UnmarshalJSON sets the Base64 from JSON func (b Base64) UnmarshalJSON(data []byte) error { var b64str string if err := json.Unmarshal(data, &b64str); err != nil { return err } vb, err := base64.StdEncoding.DecodeString(b64str) if err != nil { return err } b = Base64(vb) return nil } // MarshalBSON document from this value func (b Base64) MarshalBSON() ([]byte, error) { return bson.Marshal(bson.M{"data": b.String()}) } // UnmarshalBSON document into this value func (b Base64) UnmarshalBSON(data []byte) error { var m bson.M if err := bson.Unmarshal(data, &m); err != nil { return err } if bd, ok := m["data"].(string); ok { vb, err := base64.StdEncoding.DecodeString(bd) if err != nil { return err } b = Base64(vb) return nil } return errors.New("couldn't unmarshal bson bytes as base64") } // DeepCopyInto copies the receiver and writes its value into out. func (b Base64) DeepCopyInto(out Base64) { out = b } // DeepCopy copies the receiver into a new Base64. func (b Base64) DeepCopy() Base64 { if b == nil { return nil } out := new(Base64) b.DeepCopyInto(out) return out } // URI represents the uri string format as specified by the json schema spec // // swagger:strfmt uri type URI string // MarshalText turns this instance into text func (u URI) MarshalText() ([]byte, error) { return []byte(string(u)), nil } // UnmarshalText hydrates this instance from text func (u URI) UnmarshalText(data []byte) error { // validation is performed later on u = URI(string(data)) return nil } // Scan read a value from a database driver func (u URI) Scan(raw interface{}) error { switch v := raw.(type) { case []byte: u = URI(string(v)) case string: u = URI(v) default: return fmt.Errorf("cannot sql.Scan() strfmt.URI from: %#v", v) } return nil } // Value converts a value to a database driver value func (u URI) Value() (driver.Value, error) { return driver.Value(string(u)), nil } func (u URI) String() string { return string(u) } // MarshalJSON returns the URI as JSON func (u URI) MarshalJSON() ([]byte, error) { return json.Marshal(string(u)) } // UnmarshalJSON sets the URI from JSON func (u URI) UnmarshalJSON(data []byte) error { var uristr string if err := json.Unmarshal(data, &uristr); err != nil { return err } u = URI(uristr) return nil } // MarshalBSON document from this value func (u URI) MarshalBSON() ([]byte, error) { return bson.Marshal(bson.M{"data": u.String()}) } // UnmarshalBSON document into this value func (u URI) UnmarshalBSON(data []byte) error { var m bson.M if err := bson.Unmarshal(data, &m); err != nil { return err } if ud, ok := m["data"].(string); ok { u = URI(ud) return nil } return errors.New("couldn't unmarshal bson bytes as uri") } // DeepCopyInto copies the receiver and writes its value into out. func (u URI) DeepCopyInto(out URI) { out = u } // DeepCopy copies the receiver into a new URI. func (u URI) DeepCopy() URI { if u == nil { return nil } out := new(URI) u.DeepCopyInto(out) return out } // Email represents the email string format as specified by the json schema spec // // swagger:strfmt email type Email string // MarshalText turns this instance into text func (e Email) MarshalText() ([]byte, error) { return []byte(string(e)), nil } // UnmarshalText hydrates this instance from text func (e Email) UnmarshalText(data []byte) error { // validation is performed later on e = Email(string(data)) return nil } // Scan read a value from a database driver func (e Email) Scan(raw interface{}) error { switch v := raw.(type) { case []byte: e = Email(string(v)) case string: e = Email(v) default: return fmt.Errorf("cannot sql.Scan() strfmt.Email from: %#v", v) } return nil } // Value converts a value to a database driver value func (e Email) Value() (driver.Value, error) { return driver.Value(string(e)), nil } func (e Email) String() string { return string(e) } // MarshalJSON returns the Email as JSON func (e Email) MarshalJSON() ([]byte, error) { return json.Marshal(string(e)) } // UnmarshalJSON sets the Email from JSON func (e Email) UnmarshalJSON(data []byte) error { var estr string if err := json.Unmarshal(data, &estr); err != nil { return err } e = Email(estr) return nil } // MarshalBSON document from this value func (e Email) MarshalBSON() ([]byte, error) { return bson.Marshal(bson.M{"data": e.String()}) } // UnmarshalBSON document into this value func (e Email) UnmarshalBSON(data []byte) error { var m bson.M if err := bson.Unmarshal(data, &m); err != nil { return err } if ud, ok := m["data"].(string); ok { e = Email(ud) return nil } return errors.New("couldn't unmarshal bson bytes as email") } // DeepCopyInto copies the receiver and writes its value into out. func (e Email) DeepCopyInto(out Email) { out = e } // DeepCopy copies the receiver into a new Email. func (e Email) DeepCopy() Email { if e == nil { return nil } out := new(Email) e.DeepCopyInto(out) return out } // Hostname represents the hostname string format as specified by the json schema spec // // swagger:strfmt hostname type Hostname string // MarshalText turns this instance into text func (h Hostname) MarshalText() ([]byte, error) { return []byte(string(h)), nil } // UnmarshalText hydrates this instance from text func (h Hostname) UnmarshalText(data []byte) error { // validation is performed later on h = Hostname(string(data)) return nil } // Scan read a value from a database driver func (h Hostname) Scan(raw interface{}) error { switch v := raw.(type) { case []byte: h = Hostname(string(v)) case string: h = Hostname(v) default: return fmt.Errorf("cannot sql.Scan() strfmt.Hostname from: %#v", v) } return nil } // Value converts a value to a database driver value func (h Hostname) Value() (driver.Value, error) { return driver.Value(string(h)), nil } func (h Hostname) String() string { return string(h) } // MarshalJSON returns the Hostname as JSON func (h Hostname) MarshalJSON() ([]byte, error) { return json.Marshal(string(h)) } // UnmarshalJSON sets the Hostname from JSON func (h Hostname) UnmarshalJSON(data []byte) error { var hstr string if err := json.Unmarshal(data, &hstr); err != nil { return err } h = Hostname(hstr) return nil } // MarshalBSON document from this value func (h Hostname) MarshalBSON() ([]byte, error) { return bson.Marshal(bson.M{"data": h.String()}) } // UnmarshalBSON document into this value func (h Hostname) UnmarshalBSON(data []byte) error { var m bson.M if err := bson.Unmarshal(data, &m); err != nil { return err } if ud, ok := m["data"].(string); ok { h = Hostname(ud) return nil } return errors.New("couldn't unmarshal bson bytes as hostname") } // DeepCopyInto copies the receiver and writes its value into out. func (h Hostname) DeepCopyInto(out Hostname) { out = h } // DeepCopy copies the receiver into a new Hostname. func (h Hostname) DeepCopy() Hostname { if h == nil { return nil } out := new(Hostname) h.DeepCopyInto(out) return out } // IPv4 represents an IP v4 address // // swagger:strfmt ipv4 type IPv4 string // MarshalText turns this instance into text func (u IPv4) MarshalText() ([]byte, error) { return []byte(string(u)), nil } // UnmarshalText hydrates this instance from text func (u IPv4) UnmarshalText(data []byte) error { // validation is performed later on u = IPv4(string(data)) return nil } // Scan read a value from a database driver func (u IPv4) Scan(raw interface{}) error { switch v := raw.(type) { case []byte: u = IPv4(string(v)) case string: u = IPv4(v) default: return fmt.Errorf("cannot sql.Scan() strfmt.IPv4 from: %#v", v) } return nil } // Value converts a value to a database driver value func (u IPv4) Value() (driver.Value, error) { return driver.Value(string(u)), nil } func (u IPv4) String() string { return string(u) } // MarshalJSON returns the IPv4 as JSON func (u IPv4) MarshalJSON() ([]byte, error) { return json.Marshal(string(u)) } // UnmarshalJSON sets the IPv4 from JSON func (u IPv4) UnmarshalJSON(data []byte) error { var ustr string if err := json.Unmarshal(data, &ustr); err != nil { return err } u = IPv4(ustr) return nil } // MarshalBSON document from this value func (u IPv4) MarshalBSON() ([]byte, error) { return bson.Marshal(bson.M{"data": u.String()}) } // UnmarshalBSON document into this value func (u IPv4) UnmarshalBSON(data []byte) error { var m bson.M if err := bson.Unmarshal(data, &m); err != nil { return err } if ud, ok := m["data"].(string); ok { u = IPv4(ud) return nil } return errors.New("couldn't unmarshal bson bytes as ipv4") } // DeepCopyInto copies the receiver and writes its value into out. func (u IPv4) DeepCopyInto(out IPv4) { out = u } // DeepCopy copies the receiver into a new IPv4. func (u IPv4) DeepCopy() IPv4 { if u == nil { return nil } out := new(IPv4) u.DeepCopyInto(out) return out } // IPv6 represents an IP v6 address // // swagger:strfmt ipv6 type IPv6 string // MarshalText turns this instance into text func (u IPv6) MarshalText() ([]byte, error) { return []byte(string(u)), nil } // UnmarshalText hydrates this instance from text func (u IPv6) UnmarshalText(data []byte) error { // validation is performed later on u = IPv6(string(data)) return nil } // Scan read a value from a database driver func (u IPv6) Scan(raw interface{}) error { switch v := raw.(type) { case []byte: u = IPv6(string(v)) case string: u = IPv6(v) default: return fmt.Errorf("cannot sql.Scan() strfmt.IPv6 from: %#v", v) } return nil } // Value converts a value to a database driver value func (u IPv6) Value() (driver.Value, error) { return driver.Value(string(u)), nil } func (u IPv6) String() string { return string(u) } // MarshalJSON returns the IPv6 as JSON func (u IPv6) MarshalJSON() ([]byte, error) { return json.Marshal(string(u)) } // UnmarshalJSON sets the IPv6 from JSON func (u IPv6) UnmarshalJSON(data []byte) error { var ustr string if err := json.Unmarshal(data, &ustr); err != nil { return err } u = IPv6(ustr) return nil } // MarshalBSON document from this value func (u IPv6) MarshalBSON() ([]byte, error) { return bson.Marshal(bson.M{"data": u.String()}) } // UnmarshalBSON document into this value func (u IPv6) UnmarshalBSON(data []byte) error { var m bson.M if err := bson.Unmarshal(data, &m); err != nil { return err } if ud, ok := m["data"].(string); ok { u = IPv6(ud) return nil } return errors.New("couldn't unmarshal bson bytes as ipv6") } // DeepCopyInto copies the receiver and writes its value into out. func (u IPv6) DeepCopyInto(out IPv6) { out = u } // DeepCopy copies the receiver into a new IPv6. func (u IPv6) DeepCopy() IPv6 { if u == nil { return nil } out := new(IPv6) u.DeepCopyInto(out) return out } // CIDR represents a Classless Inter-Domain Routing notation // // swagger:strfmt cidr type CIDR string // MarshalText turns this instance into text func (u CIDR) MarshalText() ([]byte, error) { return []byte(string(u)), nil } // UnmarshalText hydrates this instance from text func (u CIDR) UnmarshalText(data []byte) error { // validation is performed later on u = CIDR(string(data)) return nil } // Scan read a value from a database driver func (u CIDR) Scan(raw interface{}) error { switch v := raw.(type) { case []byte: u = CIDR(string(v)) case string: u = CIDR(v) default: return fmt.Errorf("cannot sql.Scan() strfmt.CIDR from: %#v", v) } return nil } // Value converts a value to a database driver value func (u CIDR) Value() (driver.Value, error) { return driver.Value(string(u)), nil } func (u CIDR) String() string { return string(u) } // MarshalJSON returns the CIDR as JSON func (u CIDR) MarshalJSON() ([]byte, error) { return json.Marshal(string(u)) } // UnmarshalJSON sets the CIDR from JSON func (u CIDR) UnmarshalJSON(data []byte) error { var ustr string if err := json.Unmarshal(data, &ustr); err != nil { return err } u = CIDR(ustr) return nil } // MarshalBSON document from this value func (u CIDR) MarshalBSON() ([]byte, error) { return bson.Marshal(bson.M{"data": u.String()}) } // UnmarshalBSON document into this value func (u CIDR) UnmarshalBSON(data []byte) error { var m bson.M if err := bson.Unmarshal(data, &m); err != nil { return err } if ud, ok := m["data"].(string); ok { u = CIDR(ud) return nil } return errors.New("couldn't unmarshal bson bytes as CIDR") } // DeepCopyInto copies the receiver and writes its value into out. func (u CIDR) DeepCopyInto(out CIDR) { out = u } // DeepCopy copies the receiver into a new CIDR. func (u CIDR) DeepCopy() CIDR { if u == nil { return nil } out := new(CIDR) u.DeepCopyInto(out) return out } // MAC represents a 48 bit MAC address // // swagger:strfmt mac type MAC string // MarshalText turns this instance into text func (u MAC) MarshalText() ([]byte, error) { return []byte(string(u)), nil } // UnmarshalText hydrates this instance from text func (u MAC) UnmarshalText(data []byte) error { // validation is performed later on u = MAC(string(data)) return nil } // Scan read a value from a database driver func (u MAC) Scan(raw interface{}) error { switch v := raw.(type) { case []byte: u = MAC(string(v)) case string: u = MAC(v) default: return fmt.Errorf("cannot sql.Scan() strfmt.IPv4 from: %#v", v) } return nil } // Value converts a value to a database driver value func (u MAC) Value() (driver.Value, error) { return driver.Value(string(u)), nil } func (u MAC) String() string { return string(u) } // MarshalJSON returns the MAC as JSON func (u MAC) MarshalJSON() ([]byte, error) { return json.Marshal(string(u)) } // UnmarshalJSON sets the MAC from JSON func (u MAC) UnmarshalJSON(data []byte) error { var ustr string if err := json.Unmarshal(data, &ustr); err != nil { return err } u = MAC(ustr) return nil } // MarshalBSON document from this value func (u MAC) MarshalBSON() ([]byte, error) { return bson.Marshal(bson.M{"data": u.String()}) } // UnmarshalBSON document into this value func (u MAC) UnmarshalBSON(data []byte) error { var m bson.M if err := bson.Unmarshal(data, &m); err != nil { return err } if ud, ok := m["data"].(string); ok { u = MAC(ud) return nil } return errors.New("couldn't unmarshal bson bytes as MAC") } // DeepCopyInto copies the receiver and writes its value into out. func (u MAC) DeepCopyInto(out MAC) { out = u } // DeepCopy copies the receiver into a new MAC. func (u MAC) DeepCopy() MAC { if u == nil { return nil } out := new(MAC) u.DeepCopyInto(out) return out } // UUID represents a uuid string format // // swagger:strfmt uuid type UUID string // MarshalText turns this instance into text func (u UUID) MarshalText() ([]byte, error) { return []byte(string(u)), nil } // UnmarshalText hydrates this instance from text func (u UUID) UnmarshalText(data []byte) error { // validation is performed later on u = UUID(string(data)) return nil } // Scan read a value from a database driver func (u UUID) Scan(raw interface{}) error { switch v := raw.(type) { case []byte: u = UUID(string(v)) case string: u = UUID(v) default: return fmt.Errorf("cannot sql.Scan() strfmt.UUID from: %#v", v) } return nil } // Value converts a value to a database driver value func (u UUID) Value() (driver.Value, error) { return driver.Value(string(u)), nil } func (u UUID) String() string { return string(u) } // MarshalJSON returns the UUID as JSON func (u UUID) MarshalJSON() ([]byte, error) { return json.Marshal(string(u)) } // UnmarshalJSON sets the UUID from JSON func (u UUID) UnmarshalJSON(data []byte) error { if string(data) == jsonNull { return nil } var ustr string if err := json.Unmarshal(data, &ustr); err != nil { return err } u = UUID(ustr) return nil } // MarshalBSON document from this value func (u UUID) MarshalBSON() ([]byte, error) { return bson.Marshal(bson.M{"data": u.String()}) } // UnmarshalBSON document into this value func (u UUID) UnmarshalBSON(data []byte) error { var m bson.M if err := bson.Unmarshal(data, &m); err != nil { return err } if ud, ok := m["data"].(string); ok { u = UUID(ud) return nil } return errors.New("couldn't unmarshal bson bytes as UUID") } // DeepCopyInto copies the receiver and writes its value into out. func (u UUID) DeepCopyInto(out UUID) { out = u } // DeepCopy copies the receiver into a new UUID. func (u UUID) DeepCopy() UUID { if u == nil { return nil } out := new(UUID) u.DeepCopyInto(out) return out } // UUID3 represents a uuid3 string format // // swagger:strfmt uuid3 type UUID3 string // MarshalText turns this instance into text func (u UUID3) MarshalText() ([]byte, error) { return []byte(string(u)), nil } // UnmarshalText hydrates this instance from text func (u UUID3) UnmarshalText(data []byte) error { // validation is performed later on u = UUID3(string(data)) return nil } // Scan read a value from a database driver func (u UUID3) Scan(raw interface{}) error { switch v := raw.(type) { case []byte: u = UUID3(string(v)) case string: u = UUID3(v) default: return fmt.Errorf("cannot sql.Scan() strfmt.UUID3 from: %#v", v) } return nil } // Value converts a value to a database driver value func (u UUID3) Value() (driver.Value, error) { return driver.Value(string(u)), nil } func (u UUID3) String() string { return string(u) } // MarshalJSON returns the UUID as JSON func (u UUID3) MarshalJSON() ([]byte, error) { return json.Marshal(string(u)) } // UnmarshalJSON sets the UUID from JSON func (u UUID3) UnmarshalJSON(data []byte) error { if string(data) == jsonNull { return nil } var ustr string if err := json.Unmarshal(data, &ustr); err != nil { return err } u = UUID3(ustr) return nil } // MarshalBSON document from this value func (u UUID3) MarshalBSON() ([]byte, error) { return bson.Marshal(bson.M{"data": u.String()}) } // UnmarshalBSON document into this value func (u UUID3) UnmarshalBSON(data []byte) error { var m bson.M if err := bson.Unmarshal(data, &m); err != nil { return err } if ud, ok := m["data"].(string); ok { u = UUID3(ud) return nil } return errors.New("couldn't unmarshal bson bytes as UUID3") } // DeepCopyInto copies the receiver and writes its value into out. func (u UUID3) DeepCopyInto(out UUID3) { out = u } // DeepCopy copies the receiver into a new UUID3. func (u UUID3) DeepCopy() UUID3 { if u == nil { return nil } out := new(UUID3) u.DeepCopyInto(out) return out } // UUID4 represents a uuid4 string format // // swagger:strfmt uuid4 type UUID4 string // MarshalText turns this instance into text func (u UUID4) MarshalText() ([]byte, error) { return []byte(string(u)), nil } // UnmarshalText hydrates this instance from text func (u UUID4) UnmarshalText(data []byte) error { // validation is performed later on u = UUID4(string(data)) return nil } // Scan read a value from a database driver func (u UUID4) Scan(raw interface{}) error { switch v := raw.(type) { case []byte: u = UUID4(string(v)) case string: u = UUID4(v) default: return fmt.Errorf("cannot sql.Scan() strfmt.UUID4 from: %#v", v) } return nil } // Value converts a value to a database driver value func (u UUID4) Value() (driver.Value, error) { return driver.Value(string(u)), nil } func (u UUID4) String() string { return string(u) } // MarshalJSON returns the UUID as JSON func (u UUID4) MarshalJSON() ([]byte, error) { return json.Marshal(string(u)) } // UnmarshalJSON sets the UUID from JSON func (u UUID4) UnmarshalJSON(data []byte) error { if string(data) == jsonNull { return nil } var ustr string if err := json.Unmarshal(data, &ustr); err != nil { return err } u = UUID4(ustr) return nil } // MarshalBSON document from this value func (u UUID4) MarshalBSON() ([]byte, error) { return bson.Marshal(bson.M{"data": u.String()}) } // UnmarshalBSON document into this value func (u UUID4) UnmarshalBSON(data []byte) error { var m bson.M if err := bson.Unmarshal(data, &m); err != nil { return err } if ud, ok := m["data"].(string); ok { u = UUID4(ud) return nil } return errors.New("couldn't unmarshal bson bytes as UUID4") } // DeepCopyInto copies the receiver and writes its value into out. func (u UUID4) DeepCopyInto(out UUID4) { out = u } // DeepCopy copies the receiver into a new UUID4. func (u UUID4) DeepCopy() UUID4 { if u == nil { return nil } out := new(UUID4) u.DeepCopyInto(out) return out } // UUID5 represents a uuid5 string format // // swagger:strfmt uuid5 type UUID5 string // MarshalText turns this instance into text func (u UUID5) MarshalText() ([]byte, error) { return []byte(string(u)), nil } // UnmarshalText hydrates this instance from text func (u UUID5) UnmarshalText(data []byte) error { // validation is performed later on u = UUID5(string(data)) return nil } // Scan read a value from a database driver func (u UUID5) Scan(raw interface{}) error { switch v := raw.(type) { case []byte: u = UUID5(string(v)) case string: u = UUID5(v) default: return fmt.Errorf("cannot sql.Scan() strfmt.UUID5 from: %#v", v) } return nil } // Value converts a value to a database driver value func (u UUID5) Value() (driver.Value, error) { return driver.Value(string(u)), nil } func (u UUID5) String() string { return string(u) } // MarshalJSON returns the UUID as JSON func (u UUID5) MarshalJSON() ([]byte, error) { return json.Marshal(string(u)) } // UnmarshalJSON sets the UUID from JSON func (u UUID5) UnmarshalJSON(data []byte) error { if string(data) == jsonNull { return nil } var ustr string if err := json.Unmarshal(data, &ustr); err != nil { return err } u = UUID5(ustr) return nil } // MarshalBSON document from this value func (u UUID5) MarshalBSON() ([]byte, error) { return bson.Marshal(bson.M{"data": u.String()}) } // UnmarshalBSON document into this value func (u UUID5) UnmarshalBSON(data []byte) error { var m bson.M if err := bson.Unmarshal(data, &m); err != nil { return err } if ud, ok := m["data"].(string); ok { u = UUID5(ud) return nil } return errors.New("couldn't unmarshal bson bytes as UUID5") } // DeepCopyInto copies the receiver and writes its value into out. func (u UUID5) DeepCopyInto(out UUID5) { out = u } // DeepCopy copies the receiver into a new UUID5. func (u UUID5) DeepCopy() UUID5 { if u == nil { return nil } out := new(UUID5) u.DeepCopyInto(out) return out } // ISBN represents an isbn string format // // swagger:strfmt isbn type ISBN string // MarshalText turns this instance into text func (u ISBN) MarshalText() ([]byte, error) { return []byte(string(u)), nil } // UnmarshalText hydrates this instance from text func (u ISBN) UnmarshalText(data []byte) error { // validation is performed later on u = ISBN(string(data)) return nil } // Scan read a value from a database driver func (u ISBN) Scan(raw interface{}) error { switch v := raw.(type) { case []byte: u = ISBN(string(v)) case string: u = ISBN(v) default: return fmt.Errorf("cannot sql.Scan() strfmt.ISBN from: %#v", v) } return nil } // Value converts a value to a database driver value func (u ISBN) Value() (driver.Value, error) { return driver.Value(string(u)), nil } func (u ISBN) String() string { return string(u) } // MarshalJSON returns the ISBN as JSON func (u ISBN) MarshalJSON() ([]byte, error) { return json.Marshal(string(u)) } // UnmarshalJSON sets the ISBN from JSON func (u ISBN) UnmarshalJSON(data []byte) error { if string(data) == jsonNull { return nil } var ustr string if err := json.Unmarshal(data, &ustr); err != nil { return err } u = ISBN(ustr) return nil } // MarshalBSON document from this value func (u ISBN) MarshalBSON() ([]byte, error) { return bson.Marshal(bson.M{"data": u.String()}) } // UnmarshalBSON document into this value func (u ISBN) UnmarshalBSON(data []byte) error { var m bson.M if err := bson.Unmarshal(data, &m); err != nil { return err } if ud, ok := m["data"].(string); ok { u = ISBN(ud) return nil } return errors.New("couldn't unmarshal bson bytes as ISBN") } // DeepCopyInto copies the receiver and writes its value into out. func (u ISBN) DeepCopyInto(out ISBN) { out = u } // DeepCopy copies the receiver into a new ISBN. func (u ISBN) DeepCopy() ISBN { if u == nil { return nil } out := new(ISBN) u.DeepCopyInto(out) return out } // ISBN10 represents an isbn 10 string format // // swagger:strfmt isbn10 type ISBN10 string // MarshalText turns this instance into text func (u ISBN10) MarshalText() ([]byte, error) { return []byte(string(u)), nil } // UnmarshalText hydrates this instance from text func (u ISBN10) UnmarshalText(data []byte) error { // validation is performed later on u = ISBN10(string(data)) return nil } // Scan read a value from a database driver func (u ISBN10) Scan(raw interface{}) error { switch v := raw.(type) { case []byte: u = ISBN10(string(v)) case string: u = ISBN10(v) default: return fmt.Errorf("cannot sql.Scan() strfmt.ISBN10 from: %#v", v) } return nil } // Value converts a value to a database driver value func (u ISBN10) Value() (driver.Value, error) { return driver.Value(string(u)), nil } func (u ISBN10) String() string { return string(u) } // MarshalJSON returns the ISBN10 as JSON func (u ISBN10) MarshalJSON() ([]byte, error) { return json.Marshal(string(u)) } // UnmarshalJSON sets the ISBN10 from JSON func (u ISBN10) UnmarshalJSON(data []byte) error { if string(data) == jsonNull { return nil } var ustr string if err := json.Unmarshal(data, &ustr); err != nil { return err } u = ISBN10(ustr) return nil } // MarshalBSON document from this value func (u ISBN10) MarshalBSON() ([]byte, error) { return bson.Marshal(bson.M{"data": u.String()}) } // UnmarshalBSON document into this value func (u ISBN10) UnmarshalBSON(data []byte) error { var m bson.M if err := bson.Unmarshal(data, &m); err != nil { return err } if ud, ok := m["data"].(string); ok { u = ISBN10(ud) return nil } return errors.New("couldn't unmarshal bson bytes as ISBN10") } // DeepCopyInto copies the receiver and writes its value into out. func (u ISBN10) DeepCopyInto(out ISBN10) { out = u } // DeepCopy copies the receiver into a new ISBN10. func (u ISBN10) DeepCopy() ISBN10 { if u == nil { return nil } out := new(ISBN10) u.DeepCopyInto(out) return out } // ISBN13 represents an isbn 13 string format // // swagger:strfmt isbn13 type ISBN13 string // MarshalText turns this instance into text func (u ISBN13) MarshalText() ([]byte, error) { return []byte(string(u)), nil } // UnmarshalText hydrates this instance from text func (u ISBN13) UnmarshalText(data []byte) error { // validation is performed later on u = ISBN13(string(data)) return nil } // Scan read a value from a database driver func (u ISBN13) Scan(raw interface{}) error { switch v := raw.(type) { case []byte: u = ISBN13(string(v)) case string: u = ISBN13(v) default: return fmt.Errorf("cannot sql.Scan() strfmt.ISBN13 from: %#v", v) } return nil } // Value converts a value to a database driver value func (u ISBN13) Value() (driver.Value, error) { return driver.Value(string(u)), nil } func (u ISBN13) String() string { return string(u) } // MarshalJSON returns the ISBN13 as JSON func (u ISBN13) MarshalJSON() ([]byte, error) { return json.Marshal(string(u)) } // UnmarshalJSON sets the ISBN13 from JSON func (u ISBN13) UnmarshalJSON(data []byte) error { if string(data) == jsonNull { return nil } var ustr string if err := json.Unmarshal(data, &ustr); err != nil { return err } u = ISBN13(ustr) return nil } // MarshalBSON document from this value func (u ISBN13) MarshalBSON() ([]byte, error) { return bson.Marshal(bson.M{"data": u.String()}) } // UnmarshalBSON document into this value func (u ISBN13) UnmarshalBSON(data []byte) error { var m bson.M if err := bson.Unmarshal(data, &m); err != nil { return err } if ud, ok := m["data"].(string); ok { u = ISBN13(ud) return nil } return errors.New("couldn't unmarshal bson bytes as ISBN13") } // DeepCopyInto copies the receiver and writes its value into out. func (u ISBN13) DeepCopyInto(out ISBN13) { out = u } // DeepCopy copies the receiver into a new ISBN13. func (u ISBN13) DeepCopy() ISBN13 { if u == nil { return nil } out := new(ISBN13) u.DeepCopyInto(out) return out } // CreditCard represents a credit card string format // // swagger:strfmt creditcard type CreditCard string // MarshalText turns this instance into text func (u CreditCard) MarshalText() ([]byte, error) { return []byte(string(u)), nil } // UnmarshalText hydrates this instance from text func (u CreditCard) UnmarshalText(data []byte) error { // validation is performed later on u = CreditCard(string(data)) return nil } // Scan read a value from a database driver func (u CreditCard) Scan(raw interface{}) error { switch v := raw.(type) { case []byte: u = CreditCard(string(v)) case string: u = CreditCard(v) default: return fmt.Errorf("cannot sql.Scan() strfmt.CreditCard from: %#v", v) } return nil } // Value converts a value to a database driver value func (u CreditCard) Value() (driver.Value, error) { return driver.Value(string(u)), nil } func (u CreditCard) String() string { return string(u) } // MarshalJSON returns the CreditCard as JSON func (u CreditCard) MarshalJSON() ([]byte, error) { return json.Marshal(string(u)) } // UnmarshalJSON sets the CreditCard from JSON func (u CreditCard) UnmarshalJSON(data []byte) error { if string(data) == jsonNull { return nil } var ustr string if err := json.Unmarshal(data, &ustr); err != nil { return err } u = CreditCard(ustr) return nil } // MarshalBSON document from this value func (u CreditCard) MarshalBSON() ([]byte, error) { return bson.Marshal(bson.M{"data": u.String()}) } // UnmarshalBSON document into this value func (u CreditCard) UnmarshalBSON(data []byte) error { var m bson.M if err := bson.Unmarshal(data, &m); err != nil { return err } if ud, ok := m["data"].(string); ok { u = CreditCard(ud) return nil } return errors.New("couldn't unmarshal bson bytes as CreditCard") } // DeepCopyInto copies the receiver and writes its value into out. func (u CreditCard) DeepCopyInto(out CreditCard) { out = u } // DeepCopy copies the receiver into a new CreditCard. func (u CreditCard) DeepCopy() CreditCard { if u == nil { return nil } out := new(CreditCard) u.DeepCopyInto(out) return out } // SSN represents a social security string format // // swagger:strfmt ssn type SSN string // MarshalText turns this instance into text func (u SSN) MarshalText() ([]byte, error) { return []byte(string(u)), nil } // UnmarshalText hydrates this instance from text func (u SSN) UnmarshalText(data []byte) error { // validation is performed later on u = SSN(string(data)) return nil } // Scan read a value from a database driver func (u SSN) Scan(raw interface{}) error { switch v := raw.(type) { case []byte: u = SSN(string(v)) case string: u = SSN(v) default: return fmt.Errorf("cannot sql.Scan() strfmt.SSN from: %#v", v) } return nil } // Value converts a value to a database driver value func (u SSN) Value() (driver.Value, error) { return driver.Value(string(u)), nil } func (u SSN) String() string { return string(u) } // MarshalJSON returns the SSN as JSON func (u SSN) MarshalJSON() ([]byte, error) { return json.Marshal(string(u)) } // UnmarshalJSON sets the SSN from JSON func (u SSN) UnmarshalJSON(data []byte) error { if string(data) == jsonNull { return nil } var ustr string if err := json.Unmarshal(data, &ustr); err != nil { return err } u = SSN(ustr) return nil } // MarshalBSON document from this value func (u SSN) MarshalBSON() ([]byte, error) { return bson.Marshal(bson.M{"data": u.String()}) } // UnmarshalBSON document into this value func (u SSN) UnmarshalBSON(data []byte) error { var m bson.M if err := bson.Unmarshal(data, &m); err != nil { return err } if ud, ok := m["data"].(string); ok { u = SSN(ud) return nil } return errors.New("couldn't unmarshal bson bytes as SSN") } // DeepCopyInto copies the receiver and writes its value into out. func (u SSN) DeepCopyInto(out SSN) { out = u } // DeepCopy copies the receiver into a new SSN. func (u SSN) DeepCopy() SSN { if u == nil { return nil } out := new(SSN) u.DeepCopyInto(out) return out } // HexColor represents a hex color string format // // swagger:strfmt hexcolor type HexColor string // MarshalText turns this instance into text func (h HexColor) MarshalText() ([]byte, error) { return []byte(string(h)), nil } // UnmarshalText hydrates this instance from text func (h HexColor) UnmarshalText(data []byte) error { // validation is performed later on h = HexColor(string(data)) return nil } // Scan read a value from a database driver func (h HexColor) Scan(raw interface{}) error { switch v := raw.(type) { case []byte: h = HexColor(string(v)) case string: h = HexColor(v) default: return fmt.Errorf("cannot sql.Scan() strfmt.HexColor from: %#v", v) } return nil } // Value converts a value to a database driver value func (h HexColor) Value() (driver.Value, error) { return driver.Value(string(h)), nil } func (h HexColor) String() string { return string(h) } // MarshalJSON returns the HexColor as JSON func (h HexColor) MarshalJSON() ([]byte, error) { return json.Marshal(string(h)) } // UnmarshalJSON sets the HexColor from JSON func (h HexColor) UnmarshalJSON(data []byte) error { if string(data) == jsonNull { return nil } var ustr string if err := json.Unmarshal(data, &ustr); err != nil { return err } h = HexColor(ustr) return nil } // MarshalBSON document from this value func (h HexColor) MarshalBSON() ([]byte, error) { return bson.Marshal(bson.M{"data": h.String()}) } // UnmarshalBSON document into this value func (h HexColor) UnmarshalBSON(data []byte) error { var m bson.M if err := bson.Unmarshal(data, &m); err != nil { return err } if ud, ok := m["data"].(string); ok { h = HexColor(ud) return nil } return errors.New("couldn't unmarshal bson bytes as HexColor") } // DeepCopyInto copies the receiver and writes its value into out. func (h HexColor) DeepCopyInto(out HexColor) { out = h } // DeepCopy copies the receiver into a new HexColor. func (h HexColor) DeepCopy() HexColor { if h == nil { return nil } out := new(HexColor) h.DeepCopyInto(out) return out } // RGBColor represents a RGB color string format // // swagger:strfmt rgbcolor type RGBColor string // MarshalText turns this instance into text func (r RGBColor) MarshalText() ([]byte, error) { return []byte(string(r)), nil } // UnmarshalText hydrates this instance from text func (r RGBColor) UnmarshalText(data []byte) error { // validation is performed later on r = RGBColor(string(data)) return nil } // Scan read a value from a database driver func (r RGBColor) Scan(raw interface{}) error { switch v := raw.(type) { case []byte: r = RGBColor(string(v)) case string: r = RGBColor(v) default: return fmt.Errorf("cannot sql.Scan() strfmt.RGBColor from: %#v", v) } return nil } // Value converts a value to a database driver value func (r RGBColor) Value() (driver.Value, error) { return driver.Value(string(r)), nil } func (r RGBColor) String() string { return string(r) } // MarshalJSON returns the RGBColor as JSON func (r RGBColor) MarshalJSON() ([]byte, error) { return json.Marshal(string(r)) } // UnmarshalJSON sets the RGBColor from JSON func (r RGBColor) UnmarshalJSON(data []byte) error { if string(data) == jsonNull { return nil } var ustr string if err := json.Unmarshal(data, &ustr); err != nil { return err } r = RGBColor(ustr) return nil } // MarshalBSON document from this value func (r RGBColor) MarshalBSON() ([]byte, error) { return bson.Marshal(bson.M{"data": r.String()}) } // UnmarshalBSON document into this value func (r RGBColor) UnmarshalBSON(data []byte) error { var m bson.M if err := bson.Unmarshal(data, &m); err != nil { return err } if ud, ok := m["data"].(string); ok { r = RGBColor(ud) return nil } return errors.New("couldn't unmarshal bson bytes as RGBColor") } // DeepCopyInto copies the receiver and writes its value into out. func (r RGBColor) DeepCopyInto(out RGBColor) { out = r } // DeepCopy copies the receiver into a new RGBColor. func (r RGBColor) DeepCopy() RGBColor { if r == nil { return nil } out := new(RGBColor) r.DeepCopyInto(out) return out } // Password represents a password. // This has no validations and is mainly used as a marker for UI components. // // swagger:strfmt password type Password string // MarshalText turns this instance into text func (r Password) MarshalText() ([]byte, error) { return []byte(string(r)), nil } // UnmarshalText hydrates this instance from text func (r Password) UnmarshalText(data []byte) error { // validation is performed later on r = Password(string(data)) return nil } // Scan read a value from a database driver func (r Password) Scan(raw interface{}) error { switch v := raw.(type) { case []byte: r = Password(string(v)) case string: r = Password(v) default: return fmt.Errorf("cannot sql.Scan() strfmt.Password from: %#v", v) } return nil } // Value converts a value to a database driver value func (r Password) Value() (driver.Value, error) { return driver.Value(string(r)), nil } func (r Password) String() string { return string(r) } // MarshalJSON returns the Password as JSON func (r Password) MarshalJSON() ([]byte, error) { return json.Marshal(string(r)) } // UnmarshalJSON sets the Password from JSON func (r Password) UnmarshalJSON(data []byte) error { if string(data) == jsonNull { return nil } var ustr string if err := json.Unmarshal(data, &ustr); err != nil { return err } r = Password(ustr) return nil } // MarshalBSON document from this value func (r Password) MarshalBSON() ([]byte, error) { return bson.Marshal(bson.M{"data": r.String()}) } // UnmarshalBSON document into this value func (r Password) UnmarshalBSON(data []byte) error { var m bson.M if err := bson.Unmarshal(data, &m); err != nil { return err } if ud, ok := m["data"].(string); ok { r = Password(ud) return nil } return errors.New("couldn't unmarshal bson bytes as Password") } // DeepCopyInto copies the receiver and writes its value into out. func (r Password) DeepCopyInto(out Password) { out = r } // DeepCopy copies the receiver into a new Password. func (r Password) DeepCopy() *Password { if r == nil { return nil } out := new(Password) r.DeepCopyInto(out) return out }	46.48 KB	2025-05-25 12:27
📄 default_test.go // Copyright 2015 go-swagger maintainers // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package strfmt import ( "database/sql" "database/sql/driver" "encoding" "encoding/base64" "encoding/json" "fmt" "io" "reflect" "regexp" "strings" "testing" "github.com/google/uuid" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" "go.mongodb.org/mongo-driver/bson" ) func TestFormatURI(t testing.T) { uri := URI("http://somewhere.com") str := "http://somewhereelse.com" testStringFormat(t, &uri, "uri", str, []string{}, []string{"somewhere.com"}) } func TestFormatEmail(t testing.T) { email := Email("somebody@somewhere.com") str := string("somebodyelse@somewhere.com") validEmails := []string{ "blah@gmail.com", "test@d.verylongtoplevel", "email+tag@gmail.com", `" "@example.com`, `"Abc\@def"@example.com`, `"Fred Bloggs"@example.com`, `"Joe\\Blow"@example.com`, `"Abc@def"@example.com`, "customer/department=shipping@example.com", "$A12345@example.com", "!def!xyz%abc@example.com", "_somename@example.com", "!#$%&'+-/=?^_`{}\|~@example.com", "Miles.O'Brian@example.com", "postmaster@☁→❄→☃→☀→☺→☂→☹→✝.ws", "root@localhost", "john@com", "api@piston.ninja", } testStringFormat(t, &email, "email", str, validEmails, []string{"somebody@somewhere@com"}) } func TestFormatHostname(t testing.T) { hostname := Hostname("somewhere.com") str := string("somewhere.com") veryLongStr := strings.Repeat("a", 256) longStr := strings.Repeat("a", 64) longAddrSegment := strings.Join([]string{"x", "y", longStr}, ".") invalidHostnames := []string{ "somewhere.com!", "user@email.domain", "1.1.1.1", veryLongStr, longAddrSegment, // dashes "www.example-.org", "www.--example.org", "-www.example.org", "www-.example.org", "www.d-.org", "www.-d.org", "www-", "-www", // other characters (not in symbols) "www.ex ample.org", "_www.example.org", "www.ex;ample.org", "www.example_underscored.org", // short top-level domains "www.詹姆斯.x", "a.b.c.d", "-xyz", "xyz-", "x.", "a.b.c.dot-", "a.b.c.é;ö", } validHostnames := []string{ "somewhere.com", "888.com", "a.com", "a.b.com", "a.b.c.com", "a.b.c.d.com", "a.b.c.d.e.com", "1.com", "1.2.com", "1.2.3.com", "1.2.3.4.com", "99.domain.com", "99.99.domain.com", "1wwworg.example.com", // valid, per RFC1123 "1000wwworg.example.com", "xn--bcher-kva.example.com", // puny encoded "xn-80ak6aa92e.co", "xn-80ak6aa92e.com", "xn--ls8h.la", "☁→❄→☃→☀→☺→☂→☹→✝.ws", "www.example.onion", "www.example.ôlà", "ôlà.ôlà", "ôlà.ôlà.ôlà", "ex$ample", "localhost", "example", "x", "x-y", "a.b.c.dot", "www.example.org", "a.b.c.d.e.f.g.dot", // extended symbol alphabet "ex=ample.com", "<foo>", "www.example-hyphenated.org", // localized hostnames "www.詹姆斯.org", "www.élégigôö.org", // long top-level domains "www.詹姆斯.london", } testStringFormat(t, &hostname, "hostname", str, []string{}, invalidHostnames) testStringFormat(t, &hostname, "hostname", str, validHostnames, []string{}) } func TestFormatIPv4(t testing.T) { ipv4 := IPv4("192.168.254.1") str := string("192.168.254.2") testStringFormat(t, &ipv4, "ipv4", str, []string{}, []string{"198.168.254.2.2"}) } func TestFormatIPv6(t testing.T) { ipv6 := IPv6("::1") str := string("::2") // TODO: test ipv6 zones testStringFormat(t, &ipv6, "ipv6", str, []string{}, []string{"127.0.0.1"}) } func TestFormatCIDR(t testing.T) { cidr := CIDR("192.168.254.1/24") str := string("192.168.254.2/24") testStringFormat(t, &cidr, "cidr", str, []string{"192.0.2.1/24", "2001:db8:a0b:12f0::1/32"}, []string{"198.168.254.2", "2001:db8:a0b:12f0::1"}) } func TestFormatMAC(t testing.T) { mac := MAC("01:02:03:04:05:06") str := string("06:05:04:03:02:01") testStringFormat(t, &mac, "mac", str, []string{}, []string{"01:02:03:04:05"}) } func TestFormatUUID3(t testing.T) { first3 := uuid.NewMD5(uuid.NameSpaceURL, []byte("somewhere.com")) other3 := uuid.NewMD5(uuid.NameSpaceURL, []byte("somewhereelse.com")) other4 := uuid.Must(uuid.NewRandom()) other5 := uuid.NewSHA1(uuid.NameSpaceURL, []byte("somewhereelse.com")) uuid3 := UUID3(first3.String()) str := other3.String() testStringFormat(t, &uuid3, "uuid3", str, []string{ other3.String(), strings.ReplaceAll(other3.String(), "-", ""), }, []string{ "not-a-uuid", other4.String(), other5.String(), strings.ReplaceAll(other4.String(), "-", ""), strings.ReplaceAll(other5.String(), "-", ""), strings.Replace(other3.String(), "-", "", 2), strings.Replace(other4.String(), "-", "", 2), strings.Replace(other5.String(), "-", "", 2), }, ) // special case for zero UUID var uuidZero UUID3 err := uuidZero.UnmarshalJSON([]byte(jsonNull)) require.NoError(t, err) assert.EqualValues(t, UUID3(""), uuidZero) } func TestFormatUUID4(t testing.T) { first4 := uuid.Must(uuid.NewRandom()) other3 := uuid.NewMD5(uuid.NameSpaceURL, []byte("somewhere.com")) other4 := uuid.Must(uuid.NewRandom()) other5 := uuid.NewSHA1(uuid.NameSpaceURL, []byte("somewhereelse.com")) uuid4 := UUID4(first4.String()) str := other4.String() testStringFormat(t, &uuid4, "uuid4", str, []string{ other4.String(), strings.ReplaceAll(other4.String(), "-", ""), }, []string{ "not-a-uuid", other3.String(), other5.String(), strings.ReplaceAll(other3.String(), "-", ""), strings.ReplaceAll(other5.String(), "-", ""), strings.Replace(other3.String(), "-", "", 2), strings.Replace(other4.String(), "-", "", 2), strings.Replace(other5.String(), "-", "", 2), }, ) // special case for zero UUID var uuidZero UUID4 err := uuidZero.UnmarshalJSON([]byte(jsonNull)) require.NoError(t, err) assert.EqualValues(t, UUID4(""), uuidZero) } func TestFormatUUID5(t testing.T) { first5 := uuid.NewSHA1(uuid.NameSpaceURL, []byte("somewhere.com")) other3 := uuid.NewMD5(uuid.NameSpaceURL, []byte("somewhere.com")) other4 := uuid.Must(uuid.NewRandom()) other5 := uuid.NewSHA1(uuid.NameSpaceURL, []byte("somewhereelse.com")) uuid5 := UUID5(first5.String()) str := other5.String() testStringFormat(t, &uuid5, "uuid5", str, []string{ other5.String(), strings.ReplaceAll(other5.String(), "-", ""), }, []string{ "not-a-uuid", other3.String(), other4.String(), strings.ReplaceAll(other3.String(), "-", ""), strings.ReplaceAll(other4.String(), "-", ""), strings.Replace(other3.String(), "-", "", 2), strings.Replace(other4.String(), "-", "", 2), strings.Replace(other5.String(), "-", "", 2), }, ) // special case for zero UUID var uuidZero UUID5 err := uuidZero.UnmarshalJSON([]byte(jsonNull)) require.NoError(t, err) assert.EqualValues(t, UUID5(""), uuidZero) } func TestFormatUUID(t testing.T) { first5 := uuid.NewSHA1(uuid.NameSpaceURL, []byte("somewhere.com")) other3 := uuid.NewSHA1(uuid.NameSpaceURL, []byte("somewhereelse.com")) other4 := uuid.Must(uuid.NewRandom()) other5 := uuid.NewSHA1(uuid.NameSpaceURL, []byte("somewhereelse.com")) other6 := uuid.Must(uuid.NewV6()) other7 := uuid.Must(uuid.NewV7()) microsoft := "0" + other4.String() + "f" uuid := UUID(first5.String()) str := other5.String() testStringFormat(t, &uuid, "uuid", str, []string{ other3.String(), other4.String(), other5.String(), strings.ReplaceAll(other3.String(), "-", ""), strings.ReplaceAll(other4.String(), "-", ""), strings.ReplaceAll(other5.String(), "-", ""), other6.String(), other7.String(), microsoft, }, []string{ "not-a-uuid", strings.Replace(other3.String(), "-", "", 2), strings.Replace(other4.String(), "-", "", 2), strings.Replace(other5.String(), "-", "", 2), }, ) // special case for zero UUID var uuidZero UUID err := uuidZero.UnmarshalJSON([]byte(jsonNull)) require.NoError(t, err) assert.EqualValues(t, UUID(""), uuidZero) } func TestFormatISBN(t testing.T) { isbn := ISBN("0321751043") str := string("0321751043") testStringFormat(t, &isbn, "isbn", str, []string{}, []string{"836217463"}) // bad checksum } func TestFormatISBN10(t testing.T) { isbn10 := ISBN10("0321751043") str := string("0321751043") testStringFormat(t, &isbn10, "isbn10", str, []string{}, []string{"836217463"}) // bad checksum } func TestFormatISBN13(t testing.T) { isbn13 := ISBN13("978-0321751041") str := string("978-0321751041") testStringFormat(t, &isbn13, "isbn13", str, []string{}, []string{"978-0321751042"}) // bad checksum } func TestFormatHexColor(t testing.T) { hexColor := HexColor("#FFFFFF") str := string("#000000") testStringFormat(t, &hexColor, "hexcolor", str, []string{}, []string{"#fffffffz"}) } func TestFormatRGBColor(t testing.T) { rgbColor := RGBColor("rgb(255,255,255)") str := string("rgb(0,0,0)") testStringFormat(t, &rgbColor, "rgbcolor", str, []string{}, []string{"rgb(300,0,0)"}) } func TestFormatSSN(t testing.T) { ssn := SSN("111-11-1111") str := string("999 99 9999") testStringFormat(t, &ssn, "ssn", str, []string{}, []string{"999 99 999"}) } func TestFormatCreditCard(t testing.T) { creditCard := CreditCard("4111-1111-1111-1111") str := string("4012-8888-8888-1881") testStringFormat(t, &creditCard, "creditcard", str, []string{}, []string{"9999-9999-9999-999"}) } func TestFormatPassword(t testing.T) { password := Password("super secret stuff here") testStringFormat(t, &password, "password", "super secret!!!", []string{"even more secret"}, []string{}) } func TestFormatBase64(t testing.T) { const b64 string = "This is a byte array with unprintable chars, but it also isn" str := base64.URLEncoding.EncodeToString([]byte(b64)) b := []byte(b64) expected := Base64(b) bj := []byte("\"" + str + "\"") var subj Base64 err := subj.UnmarshalText([]byte(str)) require.NoError(t, err) assert.EqualValues(t, expected, subj) b, err = subj.MarshalText() require.NoError(t, err) assert.Equal(t, []byte(str), b) var subj2 Base64 err = subj2.UnmarshalJSON(bj) require.NoError(t, err) assert.EqualValues(t, expected, subj2) b, err = subj2.MarshalJSON() require.NoError(t, err) assert.Equal(t, bj, b) bsonData, err := bson.Marshal(subj2) require.NoError(t, err) var b64Copy Base64 err = bson.Unmarshal(bsonData, &b64Copy) require.NoError(t, err) assert.Equal(t, subj2, b64Copy) testValid(t, "byte", str) testInvalid(t, "byte", "ZWxpemFiZXRocG9zZXk") // missing pad char // Valuer interface sqlvalue, err := subj2.Value() require.NoError(t, err) sqlvalueAsString, ok := sqlvalue.(string) if assert.Truef(t, ok, "[%s]Value: expected driver value to be a string", "byte") { assert.EqualValuesf(t, str, sqlvalueAsString, "[%s]Value: expected %v and %v to be equal", "byte", sqlvalue, str) } // Scanner interface var subj3 Base64 err = subj3.Scan([]byte(str)) require.NoError(t, err) assert.EqualValues(t, str, subj3.String()) var subj4 Base64 err = subj4.Scan(str) require.NoError(t, err) assert.EqualValues(t, str, subj4.String()) err = subj4.Scan(123) require.Error(t, err) } type testableFormat interface { encoding.TextMarshaler encoding.TextUnmarshaler json.Marshaler json.Unmarshaler bson.Marshaler bson.Unmarshaler fmt.Stringer sql.Scanner driver.Valuer } func testStringFormat(t testing.T, what testableFormat, format, with string, validSamples, invalidSamples []string) { t.Helper() // text encoding interface b := []byte(with) err := what.UnmarshalText(b) require.NoError(t, err) val := reflect.Indirect(reflect.ValueOf(what)) strVal := val.String() assert.Equalf(t, with, strVal, "[%s]UnmarshalText: expected %v and %v to be value equal", format, strVal, with) b, err = what.MarshalText() require.NoError(t, err) assert.Equalf(t, []byte(with), b, "[%s]MarshalText: expected %v and %v to be value equal as []byte", format, string(b), with) // Stringer strVal = what.String() assert.Equalf(t, []byte(with), b, "[%s]String: expected %v and %v to be equal", strVal, with) // JSON encoding interface bj := []byte("\"" + with + "\"") err = what.UnmarshalJSON(bj) require.NoError(t, err) val = reflect.Indirect(reflect.ValueOf(what)) strVal = val.String() assert.EqualValuesf(t, with, strVal, "[%s]UnmarshalJSON: expected %v and %v to be value equal", format, strVal, with) b, err = what.MarshalJSON() require.NoError(t, err) assert.Equalf(t, bj, b, "[%s]MarshalJSON: expected %v and %v to be value equal as []byte", format, string(b), with) // bson encoding interface bsonData, err := bson.Marshal(what) require.NoError(t, err) resetValue(t, format, what) err = bson.Unmarshal(bsonData, what) require.NoError(t, err) val = reflect.Indirect(reflect.ValueOf(what)) strVal = val.String() assert.EqualValuesf(t, with, strVal, "[%s]bson.Unmarshal: expected %v and %v to be equal (reset value) ", format, what, with) // Scanner interface resetValue(t, format, what) err = what.Scan(with) require.NoError(t, err) val = reflect.Indirect(reflect.ValueOf(what)) strVal = val.String() assert.EqualValuesf(t, with, strVal, "[%s]Scan: expected %v and %v to be value equal", format, strVal, with) err = what.Scan([]byte(with)) require.NoError(t, err) val = reflect.Indirect(reflect.ValueOf(what)) strVal = val.String() assert.EqualValuesf(t, with, strVal, "[%s]Scan: expected %v and %v to be value equal", format, strVal, with) err = what.Scan(123) require.Error(t, err) // Valuer interface sqlvalue, err := what.Value() require.NoError(t, err) sqlvalueAsString, ok := sqlvalue.(string) if assert.Truef(t, ok, "[%s]Value: expected driver value to be a string", format) { assert.EqualValuesf(t, with, sqlvalueAsString, "[%s]Value: expected %v and %v to be equal", format, sqlvalue, with) } // validation with Registry for _, valid := range append(validSamples, with) { testValid(t, format, valid) } for _, invalid := range invalidSamples { testInvalid(t, format, invalid) } } func resetValue(t testing.T, format string, what encoding.TextUnmarshaler) { t.Helper() err := what.UnmarshalText([]byte("reset value")) require.NoError(t, err) val := reflect.Indirect(reflect.ValueOf(what)) strVal := val.String() assert.Equalf(t, "reset value", strVal, "[%s]UnmarshalText: expected %v and %v to be equal (reset value) ", format, strVal, "reset value") } func testValid(t testing.T, name, value string) { t.Helper() ok := Default.Validates(name, value) if !ok { t.Errorf("expected %q of type %s to be valid", value, name) } } func testInvalid(t testing.T, name, value string) { t.Helper() ok := Default.Validates(name, value) if ok { t.Errorf("expected %q of type %s to be invalid", value, name) } } func TestDeepCopyBase64(t testing.T) { b64 := Base64("ZWxpemFiZXRocG9zZXk=") in := &b64 out := new(Base64) in.DeepCopyInto(out) assert.Equal(t, in, out) out2 := in.DeepCopy() assert.Equal(t, in, out2) var inNil Base64 out3 := inNil.DeepCopy() assert.Nil(t, out3) } func TestDeepCopyURI(t testing.T) { uri := URI("http://somewhere.com") in := &uri out := new(URI) in.DeepCopyInto(out) assert.Equal(t, in, out) out2 := in.DeepCopy() assert.Equal(t, in, out2) var inNil URI out3 := inNil.DeepCopy() assert.Nil(t, out3) } func TestDeepCopyEmail(t testing.T) { email := Email("somebody@somewhere.com") in := &email out := new(Email) in.DeepCopyInto(out) assert.Equal(t, in, out) out2 := in.DeepCopy() assert.Equal(t, in, out2) var inNil Email out3 := inNil.DeepCopy() assert.Nil(t, out3) } func TestDeepCopyHostname(t testing.T) { hostname := Hostname("somewhere.com") in := &hostname out := new(Hostname) in.DeepCopyInto(out) assert.Equal(t, in, out) out2 := in.DeepCopy() assert.Equal(t, in, out2) var inNil Hostname out3 := inNil.DeepCopy() assert.Nil(t, out3) } func TestDeepCopyIPv4(t testing.T) { ipv4 := IPv4("192.168.254.1") in := &ipv4 out := new(IPv4) in.DeepCopyInto(out) assert.Equal(t, in, out) out2 := in.DeepCopy() assert.Equal(t, in, out2) var inNil IPv4 out3 := inNil.DeepCopy() assert.Nil(t, out3) } func TestDeepCopyIPv6(t testing.T) { ipv6 := IPv6("::1") in := &ipv6 out := new(IPv6) in.DeepCopyInto(out) assert.Equal(t, in, out) out2 := in.DeepCopy() assert.Equal(t, in, out2) var inNil IPv6 out3 := inNil.DeepCopy() assert.Nil(t, out3) } func TestDeepCopyCIDR(t testing.T) { cidr := CIDR("192.0.2.1/24") in := &cidr out := new(CIDR) in.DeepCopyInto(out) assert.Equal(t, in, out) out2 := in.DeepCopy() assert.Equal(t, in, out2) var inNil CIDR out3 := inNil.DeepCopy() assert.Nil(t, out3) } func TestDeepCopyMAC(t testing.T) { mac := MAC("01:02:03:04:05:06") in := &mac out := new(MAC) in.DeepCopyInto(out) assert.Equal(t, in, out) out2 := in.DeepCopy() assert.Equal(t, in, out2) var inNil MAC out3 := inNil.DeepCopy() assert.Nil(t, out3) } func TestDeepCopyUUID(t testing.T) { first5 := uuid.NewSHA1(uuid.NameSpaceURL, []byte("somewhere.com")) uuid := UUID(first5.String()) in := &uuid out := new(UUID) in.DeepCopyInto(out) assert.Equal(t, in, out) out2 := in.DeepCopy() assert.Equal(t, in, out2) var inNil UUID out3 := inNil.DeepCopy() assert.Nil(t, out3) } func TestDeepCopyUUID3(t testing.T) { first3 := uuid.NewMD5(uuid.NameSpaceURL, []byte("somewhere.com")) uuid3 := UUID3(first3.String()) in := &uuid3 out := new(UUID3) in.DeepCopyInto(out) assert.Equal(t, in, out) out2 := in.DeepCopy() assert.Equal(t, in, out2) var inNil UUID3 out3 := inNil.DeepCopy() assert.Nil(t, out3) } func TestDeepCopyUUID4(t testing.T) { first4 := uuid.Must(uuid.NewRandom()) uuid4 := UUID4(first4.String()) in := &uuid4 out := new(UUID4) in.DeepCopyInto(out) assert.Equal(t, in, out) out2 := in.DeepCopy() assert.Equal(t, in, out2) var inNil UUID4 out3 := inNil.DeepCopy() assert.Nil(t, out3) } func TestDeepCopyUUID5(t testing.T) { first5 := uuid.NewSHA1(uuid.NameSpaceURL, []byte("somewhere.com")) uuid5 := UUID5(first5.String()) in := &uuid5 out := new(UUID5) in.DeepCopyInto(out) assert.Equal(t, in, out) out2 := in.DeepCopy() assert.Equal(t, in, out2) var inNil UUID5 out3 := inNil.DeepCopy() assert.Nil(t, out3) } func TestDeepCopyISBN(t testing.T) { isbn := ISBN("0321751043") in := &isbn out := new(ISBN) in.DeepCopyInto(out) assert.Equal(t, in, out) out2 := in.DeepCopy() assert.Equal(t, in, out2) var inNil ISBN out3 := inNil.DeepCopy() assert.Nil(t, out3) } func TestDeepCopyISBN10(t testing.T) { isbn10 := ISBN10("0321751043") in := &isbn10 out := new(ISBN10) in.DeepCopyInto(out) assert.Equal(t, in, out) out2 := in.DeepCopy() assert.Equal(t, in, out2) var inNil ISBN10 out3 := inNil.DeepCopy() assert.Nil(t, out3) } func TestDeepCopyISBN13(t testing.T) { isbn13 := ISBN13("978-0321751041") in := &isbn13 out := new(ISBN13) in.DeepCopyInto(out) assert.Equal(t, in, out) out2 := in.DeepCopy() assert.Equal(t, in, out2) var inNil ISBN13 out3 := inNil.DeepCopy() assert.Nil(t, out3) } func TestDeepCopyCreditCard(t testing.T) { creditCard := CreditCard("4111-1111-1111-1111") in := &creditCard out := new(CreditCard) in.DeepCopyInto(out) assert.Equal(t, in, out) out2 := in.DeepCopy() assert.Equal(t, in, out2) var inNil CreditCard out3 := inNil.DeepCopy() assert.Nil(t, out3) } func TestDeepCopySSN(t testing.T) { ssn := SSN("111-11-1111") in := &ssn out := new(SSN) in.DeepCopyInto(out) assert.Equal(t, in, out) out2 := in.DeepCopy() assert.Equal(t, in, out2) var inNil SSN out3 := inNil.DeepCopy() assert.Nil(t, out3) } func TestDeepCopyHexColor(t testing.T) { hexColor := HexColor("#FFFFFF") in := &hexColor out := new(HexColor) in.DeepCopyInto(out) assert.Equal(t, in, out) out2 := in.DeepCopy() assert.Equal(t, in, out2) var inNil HexColor out3 := inNil.DeepCopy() assert.Nil(t, out3) } func TestDeepCopyRGBColor(t testing.T) { rgbColor := RGBColor("rgb(255,255,255)") in := &rgbColor out := new(RGBColor) in.DeepCopyInto(out) assert.Equal(t, in, out) out2 := in.DeepCopy() assert.Equal(t, in, out2) var inNil RGBColor out3 := inNil.DeepCopy() assert.Nil(t, out3) } func TestDeepCopyPassword(t testing.T) { password := Password("super secret stuff here") in := &password out := new(Password) in.DeepCopyInto(out) assert.Equal(t, in, out) out2 := in.DeepCopy() assert.Equal(t, in, out2) var inNil Password out3 := inNil.DeepCopy() assert.Nil(t, out3) } func BenchmarkIsUUID(b testing.B) { const sampleSize = 100 rxUUID := regexp.MustCompile(UUIDPattern) rxUUID3 := regexp.MustCompile(UUID3Pattern) rxUUID4 := regexp.MustCompile(UUID4Pattern) rxUUID5 := regexp.MustCompile(UUID5Pattern) uuids := make([]string, 0, sampleSize) uuid3s := make([]string, 0, sampleSize) uuid4s := make([]string, 0, sampleSize) uuid5s := make([]string, 0, sampleSize) for i := 0; i < sampleSize; i++ { seed := []byte(uuid.Must(uuid.NewRandom()).String()) uuids = append(uuids, uuid.Must(uuid.NewRandom()).String()) uuid3s = append(uuid3s, uuid.NewMD5(uuid.NameSpaceURL, seed).String()) uuid4s = append(uuid4s, uuid.Must(uuid.NewRandom()).String()) uuid5s = append(uuid5s, uuid.NewSHA1(uuid.NameSpaceURL, seed).String()) } b.Run("IsUUID - google.uuid", benchmarkIs(uuids, IsUUID)) b.Run("IsUUID - regexp", benchmarkIs(uuids, func(id string) bool { return rxUUID.MatchString(id) })) b.Run("IsUUIDv3 - google.uuid", benchmarkIs(uuid3s, IsUUID3)) b.Run("IsUUIDv3 - regexp", benchmarkIs(uuid3s, func(id string) bool { return rxUUID3.MatchString(id) })) b.Run("IsUUIDv4 - google.uuid", benchmarkIs(uuid4s, IsUUID4)) b.Run("IsUUIDv4 - regexp", benchmarkIs(uuid4s, func(id string) bool { return rxUUID4.MatchString(id) })) b.Run("IsUUIDv5 - google.uuid", benchmarkIs(uuid5s, IsUUID5)) b.Run("IsUUIDv5 - regexp", benchmarkIs(uuid5s, func(id string) bool { return rxUUID5.MatchString(id) })) } func benchmarkIs(input []string, fn func(string) bool) func(testing.B) { return func(b testing.B) { var isTrue bool b.ReportAllocs() b.ResetTimer() for i := 0; i < b.N; i++ { isTrue = fn(input[i%len(input)]) } fmt.Fprintln(io.Discard, isTrue) } }	22.26 KB	2025-05-25 12:27
📄 doc.go // Copyright 2015 go-swagger maintainers // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Package strfmt contains custom string formats // // TODO: add info on how to define and register a custom format package strfmt	730 B	2025-05-25 12:27
📄 duration.go // Copyright 2015 go-swagger maintainers // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package strfmt import ( "database/sql/driver" "encoding/json" "errors" "fmt" "regexp" "strconv" "strings" "time" "go.mongodb.org/mongo-driver/bson" ) func init() { d := Duration(0) // register this format in the default registry Default.Add("duration", &d, IsDuration) } var ( timeUnits = [][]string{ {"ns", "nano"}, {"us", "µs", "micro"}, {"ms", "milli"}, {"s", "sec"}, {"m", "min"}, {"h", "hr", "hour"}, {"d", "day"}, {"w", "wk", "week"}, } timeMultiplier = map[string]time.Duration{ "ns": time.Nanosecond, "us": time.Microsecond, "ms": time.Millisecond, "s": time.Second, "m": time.Minute, "h": time.Hour, "d": 24 * time.Hour, "w": 7 * 24 * time.Hour, } durationMatcher = regexp.MustCompile(`((\d+)\s([A-Za-zµ]+))`) ) // IsDuration returns true if the provided string is a valid duration func IsDuration(str string) bool { _, err := ParseDuration(str) return err == nil } // Duration represents a duration // // Duration stores a period of time as a nanosecond count, with the largest // repesentable duration being approximately 290 years. // // swagger:strfmt duration type Duration time.Duration // MarshalText turns this instance into text func (d Duration) MarshalText() ([]byte, error) { return []byte(time.Duration(d).String()), nil } // UnmarshalText hydrates this instance from text func (d Duration) UnmarshalText(data []byte) error { // validation is performed later on dd, err := ParseDuration(string(data)) if err != nil { return err } d = Duration(dd) return nil } // ParseDuration parses a duration from a string, compatible with scala duration syntax func ParseDuration(cand string) (time.Duration, error) { if dur, err := time.ParseDuration(cand); err == nil { return dur, nil } var dur time.Duration ok := false for _, match := range durationMatcher.FindAllStringSubmatch(cand, -1) { factor, err := strconv.Atoi(match[2]) // converts string to int if err != nil { return 0, err } unit := strings.ToLower(strings.TrimSpace(match[3])) for _, variants := range timeUnits { last := len(variants) - 1 multiplier := timeMultiplier[variants[0]] for i, variant := range variants { if (last == i && strings.HasPrefix(unit, variant)) \|\| strings.EqualFold(variant, unit) { ok = true dur += (time.Duration(factor) multiplier) } } } } if ok { return dur, nil } return 0, fmt.Errorf("unable to parse %s as duration", cand) } // Scan reads a Duration value from database driver type. func (d Duration) Scan(raw interface{}) error { switch v := raw.(type) { // TODO: case []byte: // ? case int64: d = Duration(v) case float64: d = Duration(int64(v)) case nil: d = Duration(0) default: return fmt.Errorf("cannot sql.Scan() strfmt.Duration from: %#v", v) } return nil } // Value converts Duration to a primitive value ready to be written to a database. func (d Duration) Value() (driver.Value, error) { return driver.Value(int64(d)), nil } // String converts this duration to a string func (d Duration) String() string { return time.Duration(d).String() } // MarshalJSON returns the Duration as JSON func (d Duration) MarshalJSON() ([]byte, error) { return json.Marshal(time.Duration(d).String()) } // UnmarshalJSON sets the Duration from JSON func (d Duration) UnmarshalJSON(data []byte) error { if string(data) == jsonNull { return nil } var dstr string if err := json.Unmarshal(data, &dstr); err != nil { return err } tt, err := ParseDuration(dstr) if err != nil { return err } d = Duration(tt) return nil } func (d Duration) MarshalBSON() ([]byte, error) { return bson.Marshal(bson.M{"data": d.String()}) } func (d Duration) UnmarshalBSON(data []byte) error { var m bson.M if err := bson.Unmarshal(data, &m); err != nil { return err } if data, ok := m["data"].(string); ok { rd, err := ParseDuration(data) if err != nil { return err } d = Duration(rd) return nil } return errors.New("couldn't unmarshal bson bytes value as Date") } // DeepCopyInto copies the receiver and writes its value into out. func (d Duration) DeepCopyInto(out Duration) { out = d } // DeepCopy copies the receiver into a new Duration. func (d Duration) DeepCopy() Duration { if d == nil { return nil } out := new(Duration) d.DeepCopyInto(out) return out }	4.86 KB	2025-05-25 12:27
📄 duration_test.go // Copyright 2015 go-swagger maintainers // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package strfmt import ( "testing" "time" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" "go.mongodb.org/mongo-driver/bson" ) func TestDuration(t testing.T) { pp := Duration(0) err := pp.UnmarshalText([]byte("0ms")) require.NoError(t, err) err = pp.UnmarshalText([]byte("yada")) require.Error(t, err) orig := "2ms" b := []byte(orig) bj := []byte("\"" + orig + "\"") err = pp.UnmarshalText(b) require.NoError(t, err) err = pp.UnmarshalText([]byte("three week")) require.Error(t, err) err = pp.UnmarshalText([]byte("9999999999999999999999999999999999999999999999999999999 weeks")) require.Error(t, err) txt, err := pp.MarshalText() require.NoError(t, err) assert.Equal(t, orig, string(txt)) err = pp.UnmarshalJSON(bj) require.NoError(t, err) assert.EqualValues(t, orig, pp.String()) err = pp.UnmarshalJSON([]byte("yada")) require.Error(t, err) err = pp.UnmarshalJSON([]byte(`"12 parsecs"`)) require.Error(t, err) err = pp.UnmarshalJSON([]byte(`"12 y"`)) require.Error(t, err) b, err = pp.MarshalJSON() require.NoError(t, err) assert.Equal(t, bj, b) dur := Duration(42) bsonData, err := bson.Marshal(&dur) require.NoError(t, err) var durCopy Duration err = bson.Unmarshal(bsonData, &durCopy) require.NoError(t, err) assert.Equal(t, dur, durCopy) } func testDurationParser(t testing.T, toParse string, expected time.Duration) { t.Helper() r, e := ParseDuration(toParse) require.NoError(t, e) assert.Equal(t, expected, r) } func TestDurationParser_Failed(t testing.T) { _, e := ParseDuration("45 wekk") require.Error(t, e) } func TestIsDuration_Failed(t testing.T) { e := IsDuration("45 weeekks") assert.False(t, e) } func testDurationSQLScanner(t testing.T, dur time.Duration) { t.Helper() values := []interface{}{int64(dur), float64(dur)} for _, value := range values { var result Duration err := result.Scan(value) require.NoError(t, err) assert.Equal(t, dur, time.Duration(result)) // And the other way around resv, erv := result.Value() require.NoError(t, erv) assert.EqualValues(t, value, resv) } } func TestDurationScanner_Nil(t testing.T) { var result Duration err := result.Scan(nil) require.NoError(t, err) assert.EqualValues(t, 0, time.Duration(result)) err = result.Scan("1 ms") require.Error(t, err) } func TestDurationParser(t testing.T) { testcases := map[string]time.Duration{ // parse the short forms without spaces "1ns": 1 time.Nanosecond, "1us": 1 * time.Microsecond, "1µs": 1 * time.Microsecond, "1ms": 1 * time.Millisecond, "1s": 1 * time.Second, "1m": 1 * time.Minute, "1h": 1 * time.Hour, "1hr": 1 * time.Hour, "1d": 24 * time.Hour, "1w": 7 * 24 * time.Hour, "1wk": 7 * 24 * time.Hour, // parse the long forms without spaces "1nanoseconds": 1 * time.Nanosecond, "1nanos": 1 * time.Nanosecond, "1microseconds": 1 * time.Microsecond, "1micros": 1 * time.Microsecond, "1millis": 1 * time.Millisecond, "1milliseconds": 1 * time.Millisecond, "1second": 1 * time.Second, "1sec": 1 * time.Second, "1min": 1 * time.Minute, "1minute": 1 * time.Minute, "1hour": 1 * time.Hour, "1day": 24 * time.Hour, "1week": 7 * 24 * time.Hour, // parse the short forms with spaces "1 ns": 1 * time.Nanosecond, "1 us": 1 * time.Microsecond, "1 µs": 1 * time.Microsecond, "1 ms": 1 * time.Millisecond, "1 s": 1 * time.Second, "1 m": 1 * time.Minute, "1 h": 1 * time.Hour, "1 hr": 1 * time.Hour, "1 d": 24 * time.Hour, "1 w": 7 * 24 * time.Hour, "1 wk": 7 * 24 * time.Hour, // parse the long forms without spaces "1 nanoseconds": 1 * time.Nanosecond, "1 nanos": 1 * time.Nanosecond, "1 microseconds": 1 * time.Microsecond, "1 micros": 1 * time.Microsecond, "1 millis": 1 * time.Millisecond, "1 milliseconds": 1 * time.Millisecond, "1 second": 1 * time.Second, "1 sec": 1 * time.Second, "1 min": 1 * time.Minute, "1 minute": 1 * time.Minute, "1 hour": 1 * time.Hour, "1 day": 24 * time.Hour, "1 week": 7 * 24 * time.Hour, } for str, dur := range testcases { testDurationParser(t, str, dur) testDurationSQLScanner(t, dur) } } func TestIsDuration_Caveats(t testing.T) { // This works too e := IsDuration("45 weeks") assert.True(t, e) // This works too e = IsDuration("45 weekz") assert.True(t, e) // This works too e = IsDuration("12 hours") assert.True(t, e) // This works too e = IsDuration("12 minutes") assert.True(t, e) // This does not work e = IsDuration("12 phours") assert.False(t, e) } func TestDeepCopyDuration(t testing.T) { dur := Duration(42) in := &dur out := new(Duration) in.DeepCopyInto(out) assert.Equal(t, in, out) out2 := in.DeepCopy() assert.Equal(t, in, out2) var inNil *Duration out3 := inNil.DeepCopy() assert.Nil(t, out3) }	5.48 KB	2025-05-25 12:27
📄 format.go // Copyright 2015 go-swagger maintainers // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package strfmt import ( "encoding" stderrors "errors" "fmt" "reflect" "strings" "sync" "time" "github.com/go-openapi/errors" "github.com/mitchellh/mapstructure" ) // Default is the default formats registry var Default = NewSeededFormats(nil, nil) // Validator represents a validator for a string format. type Validator func(string) bool // Format represents a string format. // // All implementations of Format provide a string representation and text // marshaling/unmarshaling interface to be used by encoders (e.g. encoding/json). type Format interface { String() string encoding.TextMarshaler encoding.TextUnmarshaler } // Registry is a registry of string formats, with a validation method. type Registry interface { Add(string, Format, Validator) bool DelByName(string) bool GetType(string) (reflect.Type, bool) ContainsName(string) bool Validates(string, string) bool Parse(string, string) (interface{}, error) MapStructureHookFunc() mapstructure.DecodeHookFunc } type knownFormat struct { Name string OrigName string Type reflect.Type Validator Validator } // NameNormalizer is a function that normalizes a format name. type NameNormalizer func(string) string // DefaultNameNormalizer removes all dashes func DefaultNameNormalizer(name string) string { return strings.ReplaceAll(name, "-", "") } type defaultFormats struct { sync.Mutex data []knownFormat normalizeName NameNormalizer } // NewFormats creates a new formats registry seeded with the values from the default func NewFormats() Registry { //nolint:forcetypeassert return NewSeededFormats(Default.(defaultFormats).data, nil) } // NewSeededFormats creates a new formats registry func NewSeededFormats(seeds []knownFormat, normalizer NameNormalizer) Registry { if normalizer == nil { normalizer = DefaultNameNormalizer } // copy here, don't modify original d := append([]knownFormat(nil), seeds...) return &defaultFormats{ data: d, normalizeName: normalizer, } } // MapStructureHookFunc is a decode hook function for mapstructure func (f defaultFormats) MapStructureHookFunc() mapstructure.DecodeHookFunc { return func(from reflect.Type, to reflect.Type, obj interface{}) (interface{}, error) { if from.Kind() != reflect.String { return obj, nil } data, ok := obj.(string) if !ok { return nil, fmt.Errorf("failed to cast %+v to string", obj) } for _, v := range f.data { tpe, _ := f.GetType(v.Name) if to == tpe { switch v.Name { case "date": d, err := time.ParseInLocation(RFC3339FullDate, data, DefaultTimeLocation) if err != nil { return nil, err } return Date(d), nil case "datetime": input := data if len(input) == 0 { return nil, stderrors.New("empty string is an invalid datetime format") } return ParseDateTime(input) case "duration": dur, err := ParseDuration(data) if err != nil { return nil, err } return Duration(dur), nil case "uri": return URI(data), nil case "email": return Email(data), nil case "uuid": return UUID(data), nil case "uuid3": return UUID3(data), nil case "uuid4": return UUID4(data), nil case "uuid5": return UUID5(data), nil case "hostname": return Hostname(data), nil case "ipv4": return IPv4(data), nil case "ipv6": return IPv6(data), nil case "cidr": return CIDR(data), nil case "mac": return MAC(data), nil case "isbn": return ISBN(data), nil case "isbn10": return ISBN10(data), nil case "isbn13": return ISBN13(data), nil case "creditcard": return CreditCard(data), nil case "ssn": return SSN(data), nil case "hexcolor": return HexColor(data), nil case "rgbcolor": return RGBColor(data), nil case "byte": return Base64(data), nil case "password": return Password(data), nil case "ulid": ulid, err := ParseULID(data) if err != nil { return nil, err } return ulid, nil default: return nil, errors.InvalidTypeName(v.Name) } } } return data, nil } } // Add adds a new format, return true if this was a new item instead of a replacement func (f defaultFormats) Add(name string, strfmt Format, validator Validator) bool { f.Lock() defer f.Unlock() nme := f.normalizeName(name) tpe := reflect.TypeOf(strfmt) if tpe.Kind() == reflect.Ptr { tpe = tpe.Elem() } for i := range f.data { v := &f.data[i] if v.Name == nme { v.Type = tpe v.Validator = validator return false } } // turns out it's new after all f.data = append(f.data, knownFormat{Name: nme, OrigName: name, Type: tpe, Validator: validator}) return true } // GetType gets the type for the specified name func (f defaultFormats) GetType(name string) (reflect.Type, bool) { f.Lock() defer f.Unlock() nme := f.normalizeName(name) for _, v := range f.data { if v.Name == nme { return v.Type, true } } return nil, false } // DelByName removes the format by the specified name, returns true when an item was actually removed func (f defaultFormats) DelByName(name string) bool { f.Lock() defer f.Unlock() nme := f.normalizeName(name) for i, v := range f.data { if v.Name == nme { f.data[i] = knownFormat{} // release f.data = append(f.data[:i], f.data[i+1:]...) return true } } return false } // DelByFormat removes the specified format, returns true when an item was actually removed func (f defaultFormats) DelByFormat(strfmt Format) bool { f.Lock() defer f.Unlock() tpe := reflect.TypeOf(strfmt) if tpe.Kind() == reflect.Ptr { tpe = tpe.Elem() } for i, v := range f.data { if v.Type == tpe { f.data[i] = knownFormat{} // release f.data = append(f.data[:i], f.data[i+1:]...) return true } } return false } // ContainsName returns true if this registry contains the specified name func (f defaultFormats) ContainsName(name string) bool { f.Lock() defer f.Unlock() nme := f.normalizeName(name) for _, v := range f.data { if v.Name == nme { return true } } return false } // ContainsFormat returns true if this registry contains the specified format func (f defaultFormats) ContainsFormat(strfmt Format) bool { f.Lock() defer f.Unlock() tpe := reflect.TypeOf(strfmt) if tpe.Kind() == reflect.Ptr { tpe = tpe.Elem() } for _, v := range f.data { if v.Type == tpe { return true } } return false } // Validates passed data against format. // // Note that the format name is automatically normalized, e.g. one may // use "date-time" to use the "datetime" format validator. func (f defaultFormats) Validates(name, data string) bool { f.Lock() defer f.Unlock() nme := f.normalizeName(name) for _, v := range f.data { if v.Name == nme { return v.Validator(data) } } return false } // Parse a string into the appropriate format representation type. // // E.g. parsing a string a "date" will return a Date type. func (f defaultFormats) Parse(name, data string) (interface{}, error) { f.Lock() defer f.Unlock() nme := f.normalizeName(name) for _, v := range f.data { if v.Name == nme { nw := reflect.New(v.Type).Interface() if dec, ok := nw.(encoding.TextUnmarshaler); ok { if err := dec.UnmarshalText([]byte(data)); err != nil { return nil, err } return nw, nil } return nil, errors.InvalidTypeName(name) } } return nil, errors.InvalidTypeName(name) }	7.92 KB	2025-05-25 12:27
📄 format_test.go // Copyright 2015 go-swagger maintainers // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package strfmt import ( "strings" "testing" "time" "github.com/mitchellh/mapstructure" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) type testFormat string func (t testFormat) MarshalText() ([]byte, error) { return []byte(string(t)), nil } func (t testFormat) UnmarshalText(b []byte) error { t = testFormat(string(b)) return nil } func (t testFormat) String() string { return string(t) } func isTestFormat(s string) bool { return strings.HasPrefix(s, "tf") } type tf2 string func (t tf2) MarshalText() ([]byte, error) { return []byte(string(t)), nil } func (t tf2) UnmarshalText(b []byte) error { t = tf2(string(b)) return nil } func istf2(s string) bool { return strings.HasPrefix(s, "af") } func (t tf2) String() string { return string(t) } type bf string func (t bf) MarshalText() ([]byte, error) { return []byte(string(t)), nil } func (t bf) UnmarshalText(b []byte) error { t = bf(string(b)) return nil } func (t bf) String() string { return string(t) } func isbf(s string) bool { return strings.HasPrefix(s, "bf") } func istf3(s string) bool { return strings.HasPrefix(s, "ff") } func init() { tf := testFormat("") Default.Add("test-format", &tf, isTestFormat) } func TestFormatRegistry(t testing.T) { f2 := tf2("") f3 := bf("") registry := NewFormats() assert.True(t, registry.ContainsName("test-format")) assert.True(t, registry.ContainsName("testformat")) assert.False(t, registry.ContainsName("ttt")) assert.True(t, registry.Validates("testformat", "tfa")) assert.False(t, registry.Validates("testformat", "ffa")) assert.True(t, registry.Add("tf2", &f2, istf2)) assert.True(t, registry.ContainsName("tf2")) assert.False(t, registry.ContainsName("tfw")) assert.True(t, registry.Validates("tf2", "afa")) assert.False(t, registry.Add("tf2", &f3, isbf)) assert.True(t, registry.ContainsName("tf2")) assert.False(t, registry.ContainsName("tfw")) assert.True(t, registry.Validates("tf2", "bfa")) assert.False(t, registry.Validates("tf2", "afa")) assert.False(t, registry.Add("tf2", &f2, istf2)) assert.True(t, registry.Add("tf3", &f2, istf3)) assert.True(t, registry.ContainsName("tf3")) assert.True(t, registry.ContainsName("tf2")) assert.False(t, registry.ContainsName("tfw")) assert.True(t, registry.Validates("tf3", "ffa")) assert.True(t, registry.DelByName("tf3")) assert.True(t, registry.Add("tf3", &f2, istf3)) assert.True(t, registry.DelByName("tf3")) assert.False(t, registry.DelByName("unknown")) assert.False(t, registry.Validates("unknown", "")) } type testStruct struct { D Date `json:"d,omitempty"` DT DateTime `json:"dt,omitempty"` Dur Duration `json:"dur,omitempty"` URI URI `json:"uri,omitempty"` Eml Email `json:"eml,omitempty"` UUID UUID `json:"uuid,omitempty"` UUID3 UUID3 `json:"uuid3,omitempty"` UUID4 UUID4 `json:"uuid4,omitempty"` UUID5 UUID5 `json:"uuid5,omitempty"` Hn Hostname `json:"hn,omitempty"` Ipv4 IPv4 `json:"ipv4,omitempty"` Ipv6 IPv6 `json:"ipv6,omitempty"` Cidr CIDR `json:"cidr,omitempty"` Mac MAC `json:"mac,omitempty"` Isbn ISBN `json:"isbn,omitempty"` Isbn10 ISBN10 `json:"isbn10,omitempty"` Isbn13 ISBN13 `json:"isbn13,omitempty"` Creditcard CreditCard `json:"creditcard,omitempty"` Ssn SSN `json:"ssn,omitempty"` Hexcolor HexColor `json:"hexcolor,omitempty"` Rgbcolor RGBColor `json:"rgbcolor,omitempty"` B64 Base64 `json:"b64,omitempty"` Pw Password `json:"pw,omitempty"` ULID ULID `json:"ulid,omitempty"` } func TestDecodeHook(t testing.T) { registry := NewFormats() m := map[string]interface{}{ "d": "2014-12-15", "dt": "2012-03-02T15:06:05.999999999Z", "dur": "5s", "uri": "http://www.dummy.com", "eml": "dummy@dummy.com", "uuid": "a8098c1a-f86e-11da-bd1a-00112444be1e", "uuid3": "bcd02e22-68f0-3046-a512-327cca9def8f", "uuid4": "025b0d74-00a2-4048-bf57-227c5111bb34", "uuid5": "886313e1-3b8a-5372-9b90-0c9aee199e5d", "hn": "somewhere.com", "ipv4": "192.168.254.1", "ipv6": "::1", "cidr": "192.0.2.1/24", "mac": "01:02:03:04:05:06", "isbn": "0321751043", "isbn10": "0321751043", "isbn13": "978-0321751041", "hexcolor": "#FFFFFF", "rgbcolor": "rgb(255,255,255)", "pw": "super secret stuff here", "ssn": "111-11-1111", "creditcard": "4111-1111-1111-1111", "b64": "ZWxpemFiZXRocG9zZXk=", "ulid": "7ZZZZZZZZZZZZZZZZZZZZZZZZZ", } date, _ := time.Parse(RFC3339FullDate, "2014-12-15") dur, _ := ParseDuration("5s") dt, _ := ParseDateTime("2012-03-02T15:06:05.999999999Z") ulid, _ := ParseULID("7ZZZZZZZZZZZZZZZZZZZZZZZZZ") exp := &testStruct{ D: Date(date), DT: dt, Dur: Duration(dur), URI: URI("http://www.dummy.com"), Eml: Email("dummy@dummy.com"), UUID: UUID("a8098c1a-f86e-11da-bd1a-00112444be1e"), UUID3: UUID3("bcd02e22-68f0-3046-a512-327cca9def8f"), UUID4: UUID4("025b0d74-00a2-4048-bf57-227c5111bb34"), UUID5: UUID5("886313e1-3b8a-5372-9b90-0c9aee199e5d"), Hn: Hostname("somewhere.com"), Ipv4: IPv4("192.168.254.1"), Ipv6: IPv6("::1"), Cidr: CIDR("192.0.2.1/24"), Mac: MAC("01:02:03:04:05:06"), Isbn: ISBN("0321751043"), Isbn10: ISBN10("0321751043"), Isbn13: ISBN13("978-0321751041"), Creditcard: CreditCard("4111-1111-1111-1111"), Ssn: SSN("111-11-1111"), Hexcolor: HexColor("#FFFFFF"), Rgbcolor: RGBColor("rgb(255,255,255)"), B64: Base64("ZWxpemFiZXRocG9zZXk="), Pw: Password("super secret stuff here"), ULID: ulid, } test := new(testStruct) cfg := &mapstructure.DecoderConfig{ DecodeHook: registry.MapStructureHookFunc(), // weakly typed will pass if this passes WeaklyTypedInput: false, Result: test, } d, err := mapstructure.NewDecoder(cfg) require.NoError(t, err) err = d.Decode(m) require.NoError(t, err) assert.Equal(t, exp, test) } func TestDecodeDateTimeHook(t testing.T) { testCases := []struct { Name string Input string }{ { "empty datetime", "", }, { "invalid non empty datetime", "2019-01-01abc", }, } registry := NewFormats() type layout struct { DateTime DateTime `json:"datetime,omitempty"` } for i := range testCases { tc := testCases[i] t.Run(tc.Name, func(t testing.T) { test := new(layout) cfg := &mapstructure.DecoderConfig{ DecodeHook: registry.MapStructureHookFunc(), WeaklyTypedInput: false, Result: test, } d, err := mapstructure.NewDecoder(cfg) require.NoError(t, err) input := make(map[string]interface{}) input["datetime"] = tc.Input err = d.Decode(input) require.Error(t, err, "error expected got none") }) } } func TestDecode_ULID_Hook_Negative(t testing.T) { t.Parallel() testCases := []struct { Name string Input string }{ { "empty string for ulid", "", }, { "invalid non empty ulid", "8000000000YYYYYYYYYYYYYYYY", }, } registry := NewFormats() type layout struct { ULID ULID `json:"ulid,omitempty"` } for i := range testCases { tc := testCases[i] t.Run(tc.Name, func(t testing.T) { t.Parallel() test := new(layout) cfg := &mapstructure.DecoderConfig{ DecodeHook: registry.MapStructureHookFunc(), WeaklyTypedInput: false, Result: test, } d, err := mapstructure.NewDecoder(cfg) require.NoError(t, err) input := make(map[string]interface{}) input["ulid"] = tc.Input err = d.Decode(input) require.Error(t, err, "error expected got none") }) } }	8.33 KB	2025-05-25 12:27
📄 go.mod module github.com/go-openapi/strfmt require ( github.com/asaskevich/govalidator v0.0.0-20230301143203-a9d515a09cc2 github.com/go-openapi/errors v0.22.0 github.com/google/uuid v1.6.0 github.com/mitchellh/mapstructure v1.5.0 github.com/oklog/ulid v1.3.1 github.com/stretchr/testify v1.9.0 go.mongodb.org/mongo-driver v1.14.0 ) require ( github.com/davecgh/go-spew v1.1.1 // indirect github.com/pmezard/go-difflib v1.0.0 // indirect gopkg.in/yaml.v3 v3.0.1 // indirect ) go 1.20	489 B	2025-05-25 12:27
📄 go.sum github.com/asaskevich/govalidator v0.0.0-20230301143203-a9d515a09cc2 h1:DklsrG3dyBCFEj5IhUbnKptjxatkF07cF2ak3yi77so= github.com/asaskevich/govalidator v0.0.0-20230301143203-a9d515a09cc2/go.mod h1:WaHUgvxTVq04UNunO+XhnAqY/wQc+bxr74GqbsZ/Jqw= github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/go-openapi/errors v0.22.0 h1:c4xY/OLxUBSTiepAg3j/MHuAv5mJhnf53LLMWFB+u/w= github.com/go-openapi/errors v0.22.0/go.mod h1:J3DmZScxCDufmIMsdOuDHxJbdOGC0xtUynjIx092vXE= github.com/google/go-cmp v0.5.2 h1:X2ev0eStA3AbceY54o37/0PQ/UWqKEiiO2dKL5OPaFM= github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= github.com/mitchellh/mapstructure v1.5.0 h1:jeMsZIYE/09sWLaz43PL7Gy6RuMjD2eJVyuac5Z2hdY= github.com/mitchellh/mapstructure v1.5.0/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo= github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e h1:fD57ERR4JtEqsWbfPhv4DMiApHyliiK5xCTNVSPiaAs= github.com/oklog/ulid v1.3.1 h1:EGfNDEx6MqHz8B3uNV6QAib1UR2Lm97sHi3ocA6ESJ4= github.com/oklog/ulid v1.3.1/go.mod h1:CirwcVhetQ6Lv90oh/F+FBtV6XMibvdAFo93nm5qn4U= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg= github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= go.mongodb.org/mongo-driver v1.14.0 h1:P98w8egYRjYe3XDjxhYJagTokP/H6HzlsnojRgZRd80= go.mongodb.org/mongo-driver v1.14.0/go.mod h1:Vzb0Mk/pa7e6cWw85R4F/endUC3u0U9jGcNU603k65c= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f h1:BLraFXnmrev5lT+xlilqcH8XK9/i0At2xKjWk4p6zsU= gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=	2.19 KB	2025-05-25 12:27
📁 hack	-	2025-05-25 12:27
📄 time.go // Copyright 2015 go-swagger maintainers // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package strfmt import ( "database/sql/driver" "encoding/binary" "encoding/json" "errors" "fmt" "regexp" "strings" "time" "go.mongodb.org/mongo-driver/bson" "go.mongodb.org/mongo-driver/bson/bsontype" ) var ( // UnixZero sets the zero unix timestamp we want to compare against. // Unix 0 for an EST timezone is not equivalent to a UTC timezone. UnixZero = time.Unix(0, 0).UTC() ) func init() { dt := DateTime{} Default.Add("datetime", &dt, IsDateTime) } // IsDateTime returns true when the string is a valid date-time func IsDateTime(str string) bool { if len(str) < 4 { return false } s := strings.Split(strings.ToLower(str), "t") if len(s) < 2 \|\| !IsDate(s[0]) { return false } matches := rxDateTime.FindAllStringSubmatch(s[1], -1) if len(matches) == 0 \|\| len(matches[0]) == 0 { return false } m := matches[0] res := m[1] <= "23" && m[2] <= "59" && m[3] <= "59" return res } const ( // RFC3339Millis represents a ISO8601 format to millis instead of to nanos RFC3339Millis = "2006-01-02T15:04:05.000Z07:00" // RFC3339MillisNoColon represents a ISO8601 format to millis instead of to nanos RFC3339MillisNoColon = "2006-01-02T15:04:05.000Z0700" // RFC3339Micro represents a ISO8601 format to micro instead of to nano RFC3339Micro = "2006-01-02T15:04:05.000000Z07:00" // RFC3339MicroNoColon represents a ISO8601 format to micro instead of to nano RFC3339MicroNoColon = "2006-01-02T15:04:05.000000Z0700" // ISO8601LocalTime represents a ISO8601 format to ISO8601 in local time (no timezone) ISO8601LocalTime = "2006-01-02T15:04:05" // ISO8601TimeWithReducedPrecision represents a ISO8601 format with reduced precision (dropped secs) ISO8601TimeWithReducedPrecision = "2006-01-02T15:04Z" // ISO8601TimeWithReducedPrecisionLocaltime represents a ISO8601 format with reduced precision and no timezone (dropped seconds + no timezone) ISO8601TimeWithReducedPrecisionLocaltime = "2006-01-02T15:04" // ISO8601TimeUniversalSortableDateTimePattern represents a ISO8601 universal sortable date time pattern. ISO8601TimeUniversalSortableDateTimePattern = "2006-01-02 15:04:05" // short form of ISO8601TimeUniversalSortableDateTimePattern ISO8601TimeUniversalSortableDateTimePatternShortForm = "2006-01-02" // DateTimePattern pattern to match for the date-time format from http://tools.ietf.org/html/rfc3339#section-5.6 DateTimePattern = `^([0-9]{2}):([0-9]{2}):([0-9]{2})(.[0-9]+)?(z\|([+-][0-9]{2}:[0-9]{2}))$` ) var ( rxDateTime = regexp.MustCompile(DateTimePattern) // DateTimeFormats is the collection of formats used by ParseDateTime() DateTimeFormats = []string{RFC3339Micro, RFC3339MicroNoColon, RFC3339Millis, RFC3339MillisNoColon, time.RFC3339, time.RFC3339Nano, ISO8601LocalTime, ISO8601TimeWithReducedPrecision, ISO8601TimeWithReducedPrecisionLocaltime, ISO8601TimeUniversalSortableDateTimePattern, ISO8601TimeUniversalSortableDateTimePatternShortForm} // MarshalFormat sets the time resolution format used for marshaling time (set to milliseconds) MarshalFormat = RFC3339Millis // NormalizeTimeForMarshal provides a normalization function on time befeore marshalling (e.g. time.UTC). // By default, the time value is not changed. NormalizeTimeForMarshal = func(t time.Time) time.Time { return t } // DefaultTimeLocation provides a location for a time when the time zone is not encoded in the string (ex: ISO8601 Local variants). DefaultTimeLocation = time.UTC ) // ParseDateTime parses a string that represents an ISO8601 time or a unix epoch func ParseDateTime(data string) (DateTime, error) { if data == "" { return NewDateTime(), nil } var lastError error for _, layout := range DateTimeFormats { dd, err := time.ParseInLocation(layout, data, DefaultTimeLocation) if err != nil { lastError = err continue } return DateTime(dd), nil } return DateTime{}, lastError } // DateTime is a time but it serializes to ISO8601 format with millis // It knows how to read 3 different variations of a RFC3339 date time. // Most APIs we encounter want either millisecond or second precision times. // This just tries to make it worry-free. // // swagger:strfmt date-time type DateTime time.Time // NewDateTime is a representation of zero value for DateTime type func NewDateTime() DateTime { return DateTime(time.Unix(0, 0).UTC()) } // String converts this time to a string func (t DateTime) String() string { return NormalizeTimeForMarshal(time.Time(t)).Format(MarshalFormat) } // IsZero returns whether the date time is a zero value func (t DateTime) IsZero() bool { if t == nil { return true } return time.Time(t).IsZero() } // IsUnixZerom returns whether the date time is equivalent to time.Unix(0, 0).UTC(). func (t DateTime) IsUnixZero() bool { if t == nil { return true } return time.Time(t).Equal(UnixZero) } // MarshalText implements the text marshaller interface func (t DateTime) MarshalText() ([]byte, error) { return []byte(t.String()), nil } // UnmarshalText implements the text unmarshaller interface func (t DateTime) UnmarshalText(text []byte) error { tt, err := ParseDateTime(string(text)) if err != nil { return err } t = tt return nil } // Scan scans a DateTime value from database driver type. func (t DateTime) Scan(raw interface{}) error { // TODO: case int64: and case float64: ? switch v := raw.(type) { case []byte: return t.UnmarshalText(v) case string: return t.UnmarshalText([]byte(v)) case time.Time: t = DateTime(v) case nil: t = DateTime{} default: return fmt.Errorf("cannot sql.Scan() strfmt.DateTime from: %#v", v) } return nil } // Value converts DateTime to a primitive value ready to written to a database. func (t DateTime) Value() (driver.Value, error) { return driver.Value(t.String()), nil } // MarshalJSON returns the DateTime as JSON func (t DateTime) MarshalJSON() ([]byte, error) { return json.Marshal(NormalizeTimeForMarshal(time.Time(t)).Format(MarshalFormat)) } // UnmarshalJSON sets the DateTime from JSON func (t DateTime) UnmarshalJSON(data []byte) error { if string(data) == jsonNull { return nil } var tstr string if err := json.Unmarshal(data, &tstr); err != nil { return err } tt, err := ParseDateTime(tstr) if err != nil { return err } t = tt return nil } // MarshalBSON renders the DateTime as a BSON document func (t DateTime) MarshalBSON() ([]byte, error) { return bson.Marshal(bson.M{"data": t}) } // UnmarshalBSON reads the DateTime from a BSON document func (t DateTime) UnmarshalBSON(data []byte) error { var obj struct { Data DateTime } if err := bson.Unmarshal(data, &obj); err != nil { return err } t = obj.Data return nil } // MarshalBSONValue is an interface implemented by types that can marshal themselves // into a BSON document represented as bytes. The bytes returned must be a valid // BSON document if the error is nil. // Marshals a DateTime as a bsontype.DateTime, an int64 representing // milliseconds since epoch. func (t DateTime) MarshalBSONValue() (bsontype.Type, []byte, error) { // UnixNano cannot be used directly, the result of calling UnixNano on the zero // Time is undefined. Thats why we use time.Nanosecond() instead. tNorm := NormalizeTimeForMarshal(time.Time(t)) i64 := tNorm.Unix()1000 + int64(tNorm.Nanosecond())/1e6 buf := make([]byte, 8) binary.LittleEndian.PutUint64(buf, uint64(i64)) return bson.TypeDateTime, buf, nil } // UnmarshalBSONValue is an interface implemented by types that can unmarshal a // BSON value representation of themselves. The BSON bytes and type can be // assumed to be valid. UnmarshalBSONValue must copy the BSON value bytes if it // wishes to retain the data after returning. func (t DateTime) UnmarshalBSONValue(tpe bsontype.Type, data []byte) error { if tpe == bson.TypeNull { t = DateTime{} return nil } if len(data) != 8 { return errors.New("bson date field length not exactly 8 bytes") } i64 := int64(binary.LittleEndian.Uint64(data)) // TODO: Use bsonprim.DateTime.Time() method t = DateTime(time.Unix(i64/1000, i64%10001000000)) return nil } // DeepCopyInto copies the receiver and writes its value into out. func (t DateTime) DeepCopyInto(out DateTime) { out = t } // DeepCopy copies the receiver into a new DateTime. func (t DateTime) DeepCopy() DateTime { if t == nil { return nil } out := new(DateTime) t.DeepCopyInto(out) return out } // GobEncode implements the gob.GobEncoder interface. func (t DateTime) GobEncode() ([]byte, error) { return t.MarshalBinary() } // GobDecode implements the gob.GobDecoder interface. func (t DateTime) GobDecode(data []byte) error { return t.UnmarshalBinary(data) } // MarshalBinary implements the encoding.BinaryMarshaler interface. func (t DateTime) MarshalBinary() ([]byte, error) { return NormalizeTimeForMarshal(time.Time(t)).MarshalBinary() } // UnmarshalBinary implements the encoding.BinaryUnmarshaler interface. func (t DateTime) UnmarshalBinary(data []byte) error { var original time.Time err := original.UnmarshalBinary(data) if err != nil { return err } *t = DateTime(original) return nil } // Equal checks if two DateTime instances are equal using time.Time's Equal method func (t DateTime) Equal(t2 DateTime) bool { return time.Time(t).Equal(time.Time(t2)) }	9.66 KB	2025-05-25 12:27
📄 time_test.go // Copyright 2015 go-swagger maintainers // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package strfmt import ( "bytes" "encoding/gob" "testing" "time" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" "go.mongodb.org/mongo-driver/bson" ) var ( p, _ = time.Parse(time.RFC3339Nano, "2011-08-18T19:03:37.000000000+01:00") testCases = []struct { in []byte // externally sourced data -- to be unmarshalled time time.Time // its representation in time.Time str string // its marshalled representation utcStr string // the marshaled representation as utc }{ {[]byte("2014-12-15"), time.Date(2014, 12, 15, 0, 0, 0, 0, time.UTC), "2014-12-15T00:00:00.000Z", "2014-12-15T00:00:00.000Z"}, {[]byte("2014-12-15 08:00:00"), time.Date(2014, 12, 15, 8, 0, 0, 0, time.UTC), "2014-12-15T08:00:00.000Z", "2014-12-15T08:00:00.000Z"}, {[]byte("2014-12-15T08:00:00"), time.Date(2014, 12, 15, 8, 0, 0, 0, time.UTC), "2014-12-15T08:00:00.000Z", "2014-12-15T08:00:00.000Z"}, {[]byte("2014-12-15T08:00"), time.Date(2014, 12, 15, 8, 0, 0, 0, time.UTC), "2014-12-15T08:00:00.000Z", "2014-12-15T08:00:00.000Z"}, {[]byte("2014-12-15T08:00Z"), time.Date(2014, 12, 15, 8, 0, 0, 0, time.UTC), "2014-12-15T08:00:00.000Z", "2014-12-15T08:00:00.000Z"}, {[]byte("2018-01-28T23:54Z"), time.Date(2018, 01, 28, 23, 54, 0, 0, time.UTC), "2018-01-28T23:54:00.000Z", "2018-01-28T23:54:00.000Z"}, {[]byte("2014-12-15T08:00:00.000Z"), time.Date(2014, 12, 15, 8, 0, 0, 0, time.UTC), "2014-12-15T08:00:00.000Z", "2014-12-15T08:00:00.000Z"}, {[]byte("2011-08-18T19:03:37.123000000+01:00"), time.Date(2011, 8, 18, 19, 3, 37, 1231e6, p.Location()), "2011-08-18T19:03:37.123+01:00", "2011-08-18T18:03:37.123Z"}, {[]byte("2011-08-18T19:03:37.123000+0100"), time.Date(2011, 8, 18, 19, 3, 37, 1231e6, p.Location()), "2011-08-18T19:03:37.123+01:00", "2011-08-18T18:03:37.123Z"}, {[]byte("2011-08-18T19:03:37.123+0100"), time.Date(2011, 8, 18, 19, 3, 37, 1231e6, p.Location()), "2011-08-18T19:03:37.123+01:00", "2011-08-18T18:03:37.123Z"}, {[]byte("2014-12-15T19:30:20Z"), time.Date(2014, 12, 15, 19, 30, 20, 0, time.UTC), "2014-12-15T19:30:20.000Z", "2014-12-15T19:30:20.000Z"}, {[]byte("0001-01-01T00:00:00Z"), time.Time{}.UTC(), "0001-01-01T00:00:00.000Z", "0001-01-01T00:00:00.000Z"}, {[]byte(""), time.Unix(0, 0).UTC(), "1970-01-01T00:00:00.000Z", "1970-01-01T00:00:00.000Z"}, {[]byte(nil), time.Unix(0, 0).UTC(), "1970-01-01T00:00:00.000Z", "1970-01-01T00:00:00.000Z"}, } ) func TestNewDateTime(t testing.T) { assert.EqualValues(t, time.Unix(0, 0).UTC(), NewDateTime()) } func TestIsZero(t testing.T) { var empty DateTime assert.True(t, empty.IsZero()) var nilDt DateTime assert.True(t, nilDt.IsZero()) small := DateTime(time.Unix(100, 5)) assert.False(t, small.IsZero()) // time.Unix(0,0) does not produce a true zero value struct, // so this is expected to fail. dt := NewDateTime() assert.False(t, dt.IsZero()) } func TestIsUnixZero(t testing.T) { dt := NewDateTime() assert.True(t, dt.IsUnixZero()) assert.NotEqual(t, dt.IsZero(), dt.IsUnixZero()) // Test configuring UnixZero estLocation := time.FixedZone("EST", int((-5 time.Hour).Seconds())) estUnixZero := time.Unix(0, 0).In(estLocation) UnixZero = estUnixZero t.Cleanup(func() { UnixZero = time.Unix(0, 0).UTC() }) dtz := DateTime(estUnixZero) assert.True(t, dtz.IsUnixZero()) } func TestParseDateTime_errorCases(t testing.T) { _, err := ParseDateTime("yada") require.Error(t, err) } // TestParseDateTime tests the full cycle: // parsing -> marshalling -> unmarshalling / scanning func TestParseDateTime_fullCycle(t testing.T) { for caseNum, example := range testCases { t.Logf("Case #%d", caseNum) parsed, err := ParseDateTime(example.str) require.NoError(t, err) assert.EqualValues(t, example.time, parsed) mt, err := parsed.MarshalText() require.NoError(t, err) assert.Equal(t, []byte(example.str), mt) if example.str != "" { v := IsDateTime(example.str) assert.True(t, v) } else { t.Logf("IsDateTime() skipped for empty testcases") } pp := NewDateTime() err = pp.UnmarshalText(mt) require.NoError(t, err) assert.EqualValues(t, example.time, pp) pp = NewDateTime() err = pp.Scan(mt) require.NoError(t, err) assert.Equal(t, DateTime(example.time), pp) } } func TestDateTime_IsDateTime_errorCases(t testing.T) { v := IsDateTime("zor") assert.False(t, v) v = IsDateTime("zorg") assert.False(t, v) v = IsDateTime("zorgTx") assert.False(t, v) v = IsDateTime("1972-12-31Tx") assert.False(t, v) v = IsDateTime("1972-12-31T24:40:00.000Z") assert.False(t, v) v = IsDateTime("1972-12-31T23:63:00.000Z") assert.False(t, v) v = IsDateTime("1972-12-31T23:59:60.000Z") assert.False(t, v) } func TestDateTime_UnmarshalText_errorCases(t testing.T) { pp := NewDateTime() err := pp.UnmarshalText([]byte("yada")) require.Error(t, err) err = pp.UnmarshalJSON([]byte("yada")) require.Error(t, err) } func TestDateTime_UnmarshalText(t testing.T) { for caseNum, example := range testCases { t.Logf("Case #%d", caseNum) pp := NewDateTime() err := pp.UnmarshalText(example.in) require.NoError(t, err) assert.EqualValues(t, example.time, pp) // Other way around val, erv := pp.Value() require.NoError(t, erv) assert.EqualValues(t, example.str, val) } } func TestDateTime_UnmarshalJSON(t testing.T) { for caseNum, example := range testCases { t.Logf("Case #%d", caseNum) pp := NewDateTime() err := pp.UnmarshalJSON(esc(example.in)) require.NoError(t, err) assert.EqualValues(t, example.time, pp) } // Check UnmarshalJSON failure with no lexed items pp := NewDateTime() err := pp.UnmarshalJSON([]byte("zorg emperor")) require.Error(t, err) // Check lexer failure err = pp.UnmarshalJSON([]byte(`"zorg emperor"`)) require.Error(t, err) // Check null case err = pp.UnmarshalJSON([]byte("null")) require.NoError(t, err) } func esc(v []byte) []byte { var buf bytes.Buffer buf.WriteByte('"') buf.Write(v) buf.WriteByte('"') return buf.Bytes() } func TestDateTime_MarshalText(t testing.T) { for caseNum, example := range testCases { t.Logf("Case #%d", caseNum) dt := DateTime(example.time) mt, err := dt.MarshalText() require.NoError(t, err) assert.Equal(t, []byte(example.str), mt) } } func TestDateTime_MarshalJSON(t testing.T) { for caseNum, example := range testCases { t.Logf("Case #%d", caseNum) dt := DateTime(example.time) bb, err := dt.MarshalJSON() require.NoError(t, err) assert.EqualValues(t, esc([]byte(example.str)), bb) } } func TestDateTime_MarshalJSON_Override(t testing.T) { oldNormalizeMarshal := NormalizeTimeForMarshal defer func() { NormalizeTimeForMarshal = oldNormalizeMarshal }() NormalizeTimeForMarshal = func(t time.Time) time.Time { return t.UTC() } for caseNum, example := range testCases { t.Logf("Case #%d", caseNum) dt := DateTime(example.time.UTC()) bb, err := dt.MarshalJSON() require.NoError(t, err) assert.EqualValues(t, esc([]byte(example.utcStr)), bb) } } func TestDateTime_Scan(t testing.T) { for caseNum, example := range testCases { t.Logf("Case #%d", caseNum) pp := NewDateTime() err := pp.Scan(example.in) require.NoError(t, err) assert.Equal(t, DateTime(example.time), pp) pp = NewDateTime() err = pp.Scan(string(example.in)) require.NoError(t, err) assert.Equal(t, DateTime(example.time), pp) pp = NewDateTime() err = pp.Scan(example.time) require.NoError(t, err) assert.Equal(t, DateTime(example.time), pp) } } func TestDateTime_Scan_Failed(t testing.T) { pp := NewDateTime() zero := NewDateTime() err := pp.Scan(nil) require.NoError(t, err) // Zero values differ... // assert.Equal(t, zero, pp) assert.Equal(t, DateTime{}, pp) err = pp.Scan("") require.NoError(t, err) assert.Equal(t, zero, pp) err = pp.Scan(int64(0)) require.Error(t, err) err = pp.Scan(float64(0)) require.Error(t, err) } func TestDateTime_BSON(t testing.T) { for caseNum, example := range testCases { t.Logf("Case #%d", caseNum) dt := DateTime(example.time) bsonData, err := bson.Marshal(&dt) require.NoError(t, err) var dtCopy DateTime err = bson.Unmarshal(bsonData, &dtCopy) require.NoError(t, err) // BSON DateTime type loses timezone information, so compare UTC() assert.Equal(t, time.Time(dt).UTC(), time.Time(dtCopy).UTC()) // Check value marshaling explicitly m := bson.M{"data": dt} bsonData, err = bson.Marshal(&m) require.NoError(t, err) var mCopy bson.M err = bson.Unmarshal(bsonData, &mCopy) require.NoError(t, err) data, ok := m["data"].(DateTime) assert.True(t, ok) assert.Equal(t, time.Time(dt).UTC(), time.Time(data).UTC()) } } func TestDeepCopyDateTime(t testing.T) { p, err := ParseDateTime("2011-08-18T19:03:37.000000000+01:00") require.NoError(t, err) in := &p out := new(DateTime) in.DeepCopyInto(out) assert.Equal(t, in, out) out2 := in.DeepCopy() assert.Equal(t, in, out2) var inNil DateTime out3 := inNil.DeepCopy() assert.Nil(t, out3) } func TestGobEncodingDateTime(t testing.T) { now := time.Now() b := bytes.Buffer{} enc := gob.NewEncoder(&b) err := enc.Encode(DateTime(now)) require.NoError(t, err) assert.NotEmpty(t, b.Bytes()) var result DateTime dec := gob.NewDecoder(&b) err = dec.Decode(&result) require.NoError(t, err) assert.Equal(t, now.Year(), time.Time(result).Year()) assert.Equal(t, now.Month(), time.Time(result).Month()) assert.Equal(t, now.Day(), time.Time(result).Day()) assert.Equal(t, now.Hour(), time.Time(result).Hour()) assert.Equal(t, now.Minute(), time.Time(result).Minute()) assert.Equal(t, now.Second(), time.Time(result).Second()) } func TestDateTime_Equal(t testing.T) { t.Parallel() dt1 := DateTime(time.Now()) dt2 := DateTime(time.Time(dt1).Add(time.Second)) //nolint:gocritic assert.True(t, dt1.Equal(dt1), "DateTime instances should be equal") assert.False(t, dt1.Equal(dt2), "DateTime instances should not be equal") }	10.31 KB	2025-05-25 12:27
📄 ulid.go package strfmt import ( cryptorand "crypto/rand" "database/sql/driver" "encoding/json" "errors" "fmt" "io" "sync" "github.com/oklog/ulid" "go.mongodb.org/mongo-driver/bson" ) // ULID represents a ulid string format // ref: // // https://github.com/ulid/spec // // impl: // // https://github.com/oklog/ulid // // swagger:strfmt ulid type ULID struct { ulid.ULID } var ( ulidEntropyPool = sync.Pool{ New: func() interface{} { return cryptorand.Reader }, } ULIDScanDefaultFunc = func(raw interface{}) (ULID, error) { u := NewULIDZero() switch x := raw.(type) { case nil: // zerp ulid return u, nil case string: if x == "" { // zero ulid return u, nil } return u, u.UnmarshalText([]byte(x)) case []byte: return u, u.UnmarshalText(x) } return u, fmt.Errorf("cannot sql.Scan() strfmt.ULID from: %#v: %w", raw, ulid.ErrScanValue) } // ULIDScanOverrideFunc allows you to override the Scan method of the ULID type ULIDScanOverrideFunc = ULIDScanDefaultFunc ULIDValueDefaultFunc = func(u ULID) (driver.Value, error) { return driver.Value(u.String()), nil } // ULIDValueOverrideFunc allows you to override the Value method of the ULID type ULIDValueOverrideFunc = ULIDValueDefaultFunc ) func init() { // register formats in the default registry: // - ulid ulid := ULID{} Default.Add("ulid", &ulid, IsULID) } // IsULID checks if provided string is ULID format // Be noticed that this function considers overflowed ULID as non-ulid. // For more details see https://github.com/ulid/spec func IsULID(str string) bool { _, err := ulid.ParseStrict(str) return err == nil } // ParseULID parses a string that represents an valid ULID func ParseULID(str string) (ULID, error) { var u ULID return u, u.UnmarshalText([]byte(str)) } // NewULIDZero returns a zero valued ULID type func NewULIDZero() ULID { return ULID{} } // NewULID generates new unique ULID value and a error if any func NewULID() (ULID, error) { var u ULID obj := ulidEntropyPool.Get() entropy, ok := obj.(io.Reader) if !ok { return u, fmt.Errorf("failed to cast %+v to io.Reader", obj) } id, err := ulid.New(ulid.Now(), entropy) if err != nil { return u, err } ulidEntropyPool.Put(entropy) u.ULID = id return u, nil } // GetULID returns underlying instance of ULID func (u ULID) GetULID() interface{} { return u.ULID } // MarshalText returns this instance into text func (u ULID) MarshalText() ([]byte, error) { return u.ULID.MarshalText() } // UnmarshalText hydrates this instance from text func (u ULID) UnmarshalText(data []byte) error { // validation is performed later on return u.ULID.UnmarshalText(data) } // Scan reads a value from a database driver func (u ULID) Scan(raw interface{}) error { ul, err := ULIDScanOverrideFunc(raw) if err == nil { u = ul } return err } // Value converts a value to a database driver value func (u ULID) Value() (driver.Value, error) { return ULIDValueOverrideFunc(u) } func (u ULID) String() string { return u.ULID.String() } // MarshalJSON returns the ULID as JSON func (u ULID) MarshalJSON() ([]byte, error) { return json.Marshal(u.String()) } // UnmarshalJSON sets the ULID from JSON func (u ULID) UnmarshalJSON(data []byte) error { if string(data) == jsonNull { return nil } var ustr string if err := json.Unmarshal(data, &ustr); err != nil { return err } id, err := ulid.ParseStrict(ustr) if err != nil { return fmt.Errorf("couldn't parse JSON value as ULID: %w", err) } u.ULID = id return nil } // MarshalBSON document from this value func (u ULID) MarshalBSON() ([]byte, error) { return bson.Marshal(bson.M{"data": u.String()}) } // UnmarshalBSON document into this value func (u ULID) UnmarshalBSON(data []byte) error { var m bson.M if err := bson.Unmarshal(data, &m); err != nil { return err } if ud, ok := m["data"].(string); ok { id, err := ulid.ParseStrict(ud) if err != nil { return fmt.Errorf("couldn't parse bson bytes as ULID: %w", err) } u.ULID = id return nil } return errors.New("couldn't unmarshal bson bytes as ULID") } // DeepCopyInto copies the receiver and writes its value into out. func (u ULID) DeepCopyInto(out ULID) { out = u } // DeepCopy copies the receiver into a new ULID. func (u ULID) DeepCopy() ULID { if u == nil { return nil } out := new(ULID) u.DeepCopyInto(out) return out } // GobEncode implements the gob.GobEncoder interface. func (u ULID) GobEncode() ([]byte, error) { return u.ULID.MarshalBinary() } // GobDecode implements the gob.GobDecoder interface. func (u ULID) GobDecode(data []byte) error { return u.ULID.UnmarshalBinary(data) } // MarshalBinary implements the encoding.BinaryMarshaler interface. func (u ULID) MarshalBinary() ([]byte, error) { return u.ULID.MarshalBinary() } // UnmarshalBinary implements the encoding.BinaryUnmarshaler interface. func (u ULID) UnmarshalBinary(data []byte) error { return u.ULID.UnmarshalBinary(data) } // Equal checks if two ULID instances are equal by their underlying type func (u ULID) Equal(other ULID) bool { return u.ULID == other.ULID }	5.01 KB	2025-05-25 12:27
📄 ulid_test.go package strfmt import ( "bytes" "database/sql/driver" "encoding/gob" "fmt" "sync" "testing" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" "go.mongodb.org/mongo-driver/bson" ) const testUlid = string("01EYXZVGBHG26MFTG4JWR4K558") const testUlidAlt = string("01EYXZW663G7PYHVSQ8WTMDA67") var testUlidOverrideMtx sync.Mutex var testUlidOverrideValMtx sync.Mutex func TestFormatULID_Text(t testing.T) { t.Parallel() t.Run("positive", func(t testing.T) { t.Parallel() ulid, err := ParseULID(testUlid) require.NoError(t, err) res, err := ulid.MarshalText() require.NoError(t, err) assert.Equal(t, testUlid, string(res)) ulid2, _ := ParseULID(testUlidAlt) require.NoError(t, err) what := []byte(testUlid) err = ulid2.UnmarshalText(what) require.NoError(t, err) assert.Equal(t, testUlid, ulid2.String()) }) t.Run("negative", func(t testing.T) { t.Parallel() ulid, err := ParseULID(testUlid) require.NoError(t, err) what := []byte("00000000-0000-0000-0000-000000000000") err = ulid.UnmarshalText(what) require.Error(t, err) }) } func TestFormatULID_BSON(t testing.T) { t.Parallel() t.Run("positive", func(t testing.T) { t.Parallel() ulid, _ := ParseULID(testUlid) bsonData, err := bson.Marshal(&ulid) require.NoError(t, err) var ulidUnmarshaled ULID err = bson.Unmarshal(bsonData, &ulidUnmarshaled) require.NoError(t, err) assert.Equal(t, ulid, ulidUnmarshaled) // Check value marshaling explicitly m := bson.M{"data": ulid} bsonData, err = bson.Marshal(&m) require.NoError(t, err) var mUnmarshaled bson.M err = bson.Unmarshal(bsonData, &mUnmarshaled) require.NoError(t, err) data, ok := m["data"].(ULID) assert.True(t, ok) assert.Equal(t, ulid, data) }) t.Run("negative", func(t testing.T) { t.Parallel() uuid := UUID("00000000-0000-0000-0000-000000000000") bsonData, err := bson.Marshal(&uuid) require.NoError(t, err) var ulidUnmarshaled ULID err = bson.Unmarshal(bsonData, &ulidUnmarshaled) require.Error(t, err) }) } func TestFormatULID_JSON(t testing.T) { t.Parallel() t.Run("positive", func(t testing.T) { t.Parallel() ulid, err := ParseULID(testUlid) require.NoError(t, err) whatStr := fmt.Sprintf(`"%s"`, testUlidAlt) what := []byte(whatStr) err = ulid.UnmarshalJSON(what) require.NoError(t, err) assert.Equal(t, testUlidAlt, ulid.String()) data, err := ulid.MarshalJSON() require.NoError(t, err) assert.Equal(t, whatStr, string(data)) }) t.Run("null", func(t testing.T) { t.Parallel() ulid, err := ParseULID(testUlid) require.NoError(t, err) err = ulid.UnmarshalJSON([]byte("null")) require.NoError(t, err) }) t.Run("negative", func(t testing.T) { t.Parallel() // Check UnmarshalJSON failure with no lexed items ulid := NewULIDZero() err := ulid.UnmarshalJSON([]byte("zorg emperor")) require.Error(t, err) // Check lexer failure err = ulid.UnmarshalJSON([]byte(`"zorg emperor"`)) require.Error(t, err) }) } func TestFormatULID_Scan(t testing.T) { t.Parallel() t.Run("db.Scan", func(t testing.T) { t.Parallel() testUlidOverrideMtx.Lock() defer testUlidOverrideMtx.Unlock() srcUlid := testUlidAlt ulid, err := ParseULID(testUlid) require.NoError(t, err) err = ulid.Scan(srcUlid) require.NoError(t, err) assert.Equal(t, srcUlid, ulid.String()) ulid, _ = ParseULID(testUlid) err = ulid.Scan([]byte(srcUlid)) require.NoError(t, err) assert.Equal(t, srcUlid, ulid.String()) }) t.Run("db.Scan_Failed", func(t testing.T) { t.Parallel() testUlidOverrideMtx.Lock() defer testUlidOverrideMtx.Unlock() ulid, err := ParseULID(testUlid) zero := NewULIDZero() require.NoError(t, err) err = ulid.Scan(nil) require.NoError(t, err) assert.Equal(t, zero, ulid) err = ulid.Scan("") require.NoError(t, err) assert.Equal(t, zero, ulid) err = ulid.Scan(int64(0)) require.Error(t, err) err = ulid.Scan(float64(0)) require.Error(t, err) }) t.Run("db.Value", func(t testing.T) { t.Parallel() testUlidOverrideValMtx.Lock() defer testUlidOverrideValMtx.Unlock() ulid, err := ParseULID(testUlid) require.NoError(t, err) val, err := ulid.Value() require.NoError(t, err) assert.EqualValues(t, testUlid, val) }) t.Run("override.Scan", func(t testing.T) { t.Parallel() testUlidOverrideMtx.Lock() defer testUlidOverrideMtx.Unlock() ulid, err := ParseULID(testUlid) require.NoError(t, err) ulid2, err := ParseULID(testUlidAlt) require.NoError(t, err) ULIDScanOverrideFunc = func(raw interface{}) (ULID, error) { u := NewULIDZero() switch x := raw.(type) { case [16]byte: return u, u.ULID.UnmarshalBinary(x[:]) case int: // just for linter return u, fmt.Errorf("cannot sql.Scan() strfmt.ULID from: %#v", raw) } return u, fmt.Errorf("cannot sql.Scan() strfmt.ULID from: %#v", raw) } // get underlying binary implementation which is actually [16]byte bytes := [16]byte(ulid.ULID) err = ulid2.Scan(bytes) require.NoError(t, err) assert.Equal(t, ulid2, ulid) assert.Equal(t, ulid2.String(), ulid.String()) // check other default cases became unreachable err = ulid2.Scan(testUlid) require.Error(t, err) // return default Scan method ULIDScanOverrideFunc = ULIDScanDefaultFunc err = ulid2.Scan(testUlid) require.NoError(t, err) assert.Equal(t, testUlid, ulid2.String()) }) t.Run("override.Value", func(t testing.T) { t.Parallel() testUlidOverrideValMtx.Lock() defer testUlidOverrideValMtx.Unlock() ulid, err := ParseULID(testUlid) require.NoError(t, err) ulid2, err := ParseULID(testUlid) require.NoError(t, err) ULIDValueOverrideFunc = func(u ULID) (driver.Value, error) { bytes := [16]byte(u.ULID) return driver.Value(bytes), nil } exp := [16]byte(ulid2.ULID) val, err := ulid.Value() require.NoError(t, err) assert.EqualValues(t, exp, val) // return default Value method ULIDValueOverrideFunc = ULIDValueDefaultFunc val, err = ulid.Value() require.NoError(t, err) assert.EqualValues(t, testUlid, val) }) } func TestFormatULID_DeepCopy(t testing.T) { ulid, err := ParseULID(testUlid) require.NoError(t, err) in := &ulid out := new(ULID) in.DeepCopyInto(out) assert.Equal(t, in, out) out2 := in.DeepCopy() assert.Equal(t, in, out2) var inNil ULID out3 := inNil.DeepCopy() assert.Nil(t, out3) } func TestFormatULID_GobEncoding(t testing.T) { ulid, err := ParseULID(testUlid) require.NoError(t, err) b := bytes.Buffer{} enc := gob.NewEncoder(&b) err = enc.Encode(ulid) require.NoError(t, err) assert.NotEmpty(t, b.Bytes()) var result ULID dec := gob.NewDecoder(&b) err = dec.Decode(&result) require.NoError(t, err) assert.Equal(t, ulid, result) assert.Equal(t, ulid.String(), result.String()) } func TestFormatULID_NewULID_and_Equal(t testing.T) { t.Parallel() ulid1, err := NewULID() require.NoError(t, err) ulid2, err := NewULID() require.NoError(t, err) //nolint:gocritic assert.True(t, ulid1.Equal(ulid1), "ULID instances should be equal") assert.False(t, ulid1.Equal(ulid2), "ULID instances should not be equal") ulidZero := NewULIDZero() ulidZero2 := NewULIDZero() assert.True(t, ulidZero.Equal(ulidZero2), "ULID instances should be equal") } func TestIsULID(t testing.T) { t.Parallel() tcases := []struct { ulid string expect bool }{ {ulid: "01EYXZVGBHG26MFTG4JWR4K558", expect: true}, {ulid: "01EYXZW663G7PYHVSQ8WTMDA67", expect: true}, {ulid: "7ZZZZZZZZZ0000000000000000", expect: true}, {ulid: "00000000000000000000000000", expect: true}, {ulid: "7ZZZZZZZZZZZZZZZZZZZZZZZZZ", expect: true}, {ulid: "not-a-ulid", expect: false}, {ulid: "8000000000FJ2MMFJ3ATV3XB2C", expect: false}, {ulid: "81EYY0NEYJZZZZZZZZZZZZZZZZ", expect: false}, {ulid: "7ZZZZZZZZZ000000000000000U", expect: false}, {ulid: "7ZZZZZZZZZ000000000000000L", expect: false}, {ulid: "7ZZZZZZZZZ000000000000000O", expect: false}, {ulid: "7ZZZZZZZZZ000000000000000I", expect: false}, } for _, tcase := range tcases { tc := tcase t.Run(fmt.Sprintf("%s:%t", tc.ulid, tc.expect), func(t testing.T) { t.Parallel() if tc.expect { assert.True(t, IsULID(tc.ulid)) } else { assert.False(t, IsULID(tc.ulid)) } }) } }	8.12 KB	2025-05-25 12:27

Edit File:

Terminal