github.com/ugorji/go/codec@v1.2.13-0.20240307214044-07c54c229a5a/mammoth2-test.go.tmpl (about)

     1  // +build !codec.notmammoth
     2  
     3  // Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
     4  // Use of this source code is governed by a MIT license found in the LICENSE file.
     5  
     6  // Code generated from mammoth2-test.go.tmpl - DO NOT EDIT.
     7  
     8  package codec
     9  
    10  // Increase codecoverage by covering all the codecgen paths, in fast-path and gen-helper.go....
    11  //
    12  // Note: even though this is built based on fast-path and gen-helper, we will run these tests
    13  // in all modes, including notfastpath, etc.
    14  //
    15  // Add test file for creating a mammoth generated file as _mammoth_generated.go
    16  //  - generate a second mammoth files in a different file: mammoth2_generated_test.go
    17  //    mammoth-test.go.tmpl will do this
    18  //  - run codecgen on it, into mammoth2_codecgen_generated_test.go (no build tags)
    19  //  - as part of TestMammoth, run it also
    20  //  - this will cover all the codecgen, gen-helper, etc in one full run
    21  //  - check in mammoth* files into github also
    22  //
    23  // Now, add some types:
    24  //  - some that implement BinaryMarshal, TextMarshal, JSONMarshal, and one that implements none of it
    25  //  - create a wrapper type that includes TestMammoth2, with it in slices, and maps, and the custom types
    26  //  - this wrapper object is what we work encode/decode (so that the codecgen methods are called)
    27  
    28  
    29  // import "encoding/binary"
    30  
    31  import "fmt"
    32  
    33  type TestMammoth2 struct {
    34  
    35  {{range .Values }}{{if .Primitive }}{{/*
    36  */}}{{ .MethodNamePfx "F" true }} {{ .Primitive }}
    37  {{ .MethodNamePfx "Fptr" true }} *{{ .Primitive }}
    38  {{end}}{{end}}
    39  
    40  {{range .Values }}{{if not .Primitive }}{{if not .MapKey }}{{/*
    41  */}}{{ .MethodNamePfx "F" false }} []{{ .Elem }}
    42  {{ .MethodNamePfx "Fptr" false }} *[]{{ .Elem }}
    43  {{end}}{{end}}{{end}}
    44  
    45  {{range .Values }}{{if not .Primitive }}{{if .MapKey }}{{/*
    46  */}}{{ .MethodNamePfx "F" false }} map[{{ .MapKey }}]{{ .Elem }}
    47  {{ .MethodNamePfx "Fptr" false }} *map[{{ .MapKey }}]{{ .Elem }}
    48  {{end}}{{end}}{{end}}
    49  
    50  }
    51  
    52  // -----------
    53  
    54  type testMammoth2Binary uint64
    55  func (x testMammoth2Binary) MarshalBinary() (data []byte, err error) {
    56  data = make([]byte, 8)
    57  bigenstd.PutUint64(data, uint64(x))
    58  return
    59  }
    60  func (x *testMammoth2Binary) UnmarshalBinary(data []byte) (err error) {
    61  *x = testMammoth2Binary(bigenstd.Uint64(data))
    62  return
    63  }
    64  
    65  type testMammoth2Text uint64
    66  func (x testMammoth2Text) MarshalText() (data []byte, err error) {
    67  data = []byte(fmt.Sprintf("%b", uint64(x)))
    68  return
    69  }
    70  func (x *testMammoth2Text) UnmarshalText(data []byte) (err error) {
    71  _, err = fmt.Sscanf(string(data), "%b", (*uint64)(x))
    72  return
    73  }
    74  
    75  type testMammoth2Json uint64
    76  func (x testMammoth2Json) MarshalJSON() (data []byte, err error) {
    77  data = []byte(fmt.Sprintf("%v", uint64(x)))
    78  return
    79  }
    80  func (x *testMammoth2Json) UnmarshalJSON(data []byte) (err error) {
    81  _, err = fmt.Sscanf(string(data), "%v", (*uint64)(x))
    82  return
    83  }
    84  
    85  type testMammoth2Basic [4]uint64
    86  
    87  type TestMammoth2Wrapper struct {
    88  	V TestMammoth2
    89  	T testMammoth2Text
    90  	B testMammoth2Binary
    91  	J testMammoth2Json
    92  	C testMammoth2Basic
    93  	M map[testMammoth2Basic]TestMammoth2
    94  	L []TestMammoth2
    95  	A [4]int64
    96  	
    97    	Tcomplex128 complex128
    98  	Tcomplex64 complex64
    99  	Tbytes []uint8
   100  	Tpbytes *[]uint8
   101  }