| package plist |
| |
| import ( |
| "errors" |
| "math" |
| "reflect" |
| "time" |
| ) |
| |
| type TestData struct { |
| Name string |
| Value interface{} |
| DecodeValue interface{} // used when the document cannot encode parts of Value |
| Documents map[int][]byte |
| SkipDecode map[int]bool |
| SkipEncode map[int]bool |
| } |
| |
| type SparseBundleHeader struct { |
| InfoDictionaryVersion string `plist:"CFBundleInfoDictionaryVersion"` |
| BandSize uint64 `plist:"band-size"` |
| BackingStoreVersion int `plist:"bundle-backingstore-version"` |
| DiskImageBundleType string `plist:"diskimage-bundle-type"` |
| Size uint64 `plist:"size"` |
| } |
| |
| type EmbedA struct { |
| EmbedC |
| EmbedB EmbedB |
| FieldA string |
| } |
| |
| type EmbedB struct { |
| FieldB string |
| *EmbedC |
| } |
| |
| type EmbedC struct { |
| FieldA1 string `plist:"FieldA"` |
| FieldA2 string |
| FieldB string |
| FieldC string |
| } |
| |
| type TextMarshalingBool struct { |
| b bool |
| } |
| |
| func (b TextMarshalingBool) MarshalText() ([]byte, error) { |
| if b.b { |
| return []byte("truthful"), nil |
| } |
| return []byte("non-factual"), nil |
| } |
| |
| func (b *TextMarshalingBool) UnmarshalText(text []byte) error { |
| if string(text) == "truthful" { |
| b.b = true |
| } |
| return nil |
| } |
| |
| type TextMarshalingBoolViaPointer struct { |
| b bool |
| } |
| |
| func (b *TextMarshalingBoolViaPointer) MarshalText() ([]byte, error) { |
| if b.b { |
| return []byte("plausible"), nil |
| } |
| return []byte("unimaginable"), nil |
| } |
| |
| func (b *TextMarshalingBoolViaPointer) UnmarshalText(text []byte) error { |
| if string(text) == "plausible" { |
| b.b = true |
| } |
| return nil |
| } |
| |
| type ArrayThatSerializesAsOneObject struct { |
| values []uint64 |
| } |
| |
| func (f ArrayThatSerializesAsOneObject) MarshalPlist() (interface{}, error) { |
| if len(f.values) == 1 { |
| return f.values[0], nil |
| } |
| return f.values, nil |
| } |
| |
| func (f *ArrayThatSerializesAsOneObject) UnmarshalPlist(unmarshal func(interface{}) error) error { |
| var ui uint64 |
| if err := unmarshal(&ui); err == nil { |
| f.values = []uint64{ui} |
| return nil |
| } |
| |
| return unmarshal(&f.values) |
| } |
| |
| type PlistMarshalingBoolByPointer struct { |
| b bool |
| } |
| |
| func (b *PlistMarshalingBoolByPointer) MarshalPlist() (interface{}, error) { |
| if b.b { |
| return int64(-1), nil |
| } |
| return int64(-2), nil |
| } |
| |
| func (b *PlistMarshalingBoolByPointer) UnmarshalPlist(unmarshal func(interface{}) error) error { |
| var val int64 |
| err := unmarshal(&val) |
| if err != nil { |
| return err |
| } |
| |
| b.b = val == -1 |
| return nil |
| } |
| |
| type BothMarshaler struct{} |
| |
| func (b *BothMarshaler) MarshalPlist() (interface{}, error) { |
| return map[string]string{"a": "b"}, nil |
| } |
| |
| func (b *BothMarshaler) MarshalText() ([]byte, error) { |
| return []byte("shouldn't see this"), nil |
| } |
| |
| type BothUnmarshaler struct { |
| Blah int64 `plist:"blah,omitempty"` |
| } |
| |
| func (b *BothUnmarshaler) UnmarshalPlist(unmarshal func(interface{}) error) error { |
| // no error |
| return nil |
| } |
| |
| func (b *BothUnmarshaler) UnmarshalText(text []byte) error { |
| return errors.New("shouldn't hit this") |
| } |
| |
| var xmlPreamble = `<?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd"> |
| ` |
| |
| var tests = []TestData{ |
| { |
| Name: "String", |
| Value: "Hello", |
| Documents: map[int][]byte{ |
| OpenStepFormat: []byte(`Hello`), |
| GNUStepFormat: []byte(`Hello`), |
| XMLFormat: []byte(xmlPreamble + `<plist version="1.0"><string>Hello</string></plist>`), |
| BinaryFormat: []byte{98, 112, 108, 105, 115, 116, 48, 48, 85, 72, 101, 108, 108, 111, 8, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14}, |
| }, |
| }, |
| { |
| Name: "String containing apostrophe", |
| Value: "'", |
| Documents: map[int][]byte{ |
| OpenStepFormat: []byte(`"'"`), |
| GNUStepFormat: []byte(`"'"`), |
| XMLFormat: []byte(xmlPreamble + `<plist version="1.0"><string>'</string></plist>`), |
| BinaryFormat: []byte{98, 112, 108, 105, 115, 116, 48, 48, 81, 39, 8, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10}, |
| }, |
| }, |
| { |
| Name: "Basic Structure", |
| Value: struct { |
| Name string |
| }{ |
| Name: "Dustin", |
| }, |
| Documents: map[int][]byte{ |
| OpenStepFormat: []byte(`{Name=Dustin;}`), |
| GNUStepFormat: []byte(`{Name=Dustin;}`), |
| XMLFormat: []byte(xmlPreamble + `<plist version="1.0"><dict><key>Name</key><string>Dustin</string></dict></plist>`), |
| BinaryFormat: []byte{98, 112, 108, 105, 115, 116, 48, 48, 209, 1, 2, 84, 78, 97, 109, 101, 86, 68, 117, 115, 116, 105, 110, 8, 11, 16, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 23}, |
| }, |
| }, |
| { |
| Name: "Basic Structure with non-exported fields", |
| Value: struct { |
| Name string |
| age int |
| }{ |
| Name: "Dustin", |
| age: 24, |
| }, |
| DecodeValue: struct { |
| Name string |
| age int |
| }{ |
| Name: "Dustin", |
| }, |
| Documents: map[int][]byte{ |
| OpenStepFormat: []byte(`{Name=Dustin;}`), |
| GNUStepFormat: []byte(`{Name=Dustin;}`), |
| XMLFormat: []byte(xmlPreamble + `<plist version="1.0"><dict><key>Name</key><string>Dustin</string></dict></plist>`), |
| BinaryFormat: []byte{98, 112, 108, 105, 115, 116, 48, 48, 209, 1, 2, 84, 78, 97, 109, 101, 86, 68, 117, 115, 116, 105, 110, 8, 11, 16, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 23}, |
| }, |
| }, |
| { |
| Name: "Basic Structure with omitted fields", |
| Value: struct { |
| Name string |
| Age int `plist:"-"` |
| }{ |
| Name: "Dustin", |
| Age: 24, |
| }, |
| DecodeValue: struct { |
| Name string |
| Age int `plist:"-"` |
| }{ |
| Name: "Dustin", |
| }, |
| Documents: map[int][]byte{ |
| OpenStepFormat: []byte(`{Name=Dustin;}`), |
| GNUStepFormat: []byte(`{Name=Dustin;}`), |
| XMLFormat: []byte(xmlPreamble + `<plist version="1.0"><dict><key>Name</key><string>Dustin</string></dict></plist>`), |
| BinaryFormat: []byte{98, 112, 108, 105, 115, 116, 48, 48, 209, 1, 2, 84, 78, 97, 109, 101, 86, 68, 117, 115, 116, 105, 110, 8, 11, 16, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 23}, |
| }, |
| }, |
| { |
| Name: "Basic Structure with empty omitempty fields", |
| Value: struct { |
| Name string |
| Age int `plist:"age,omitempty"` |
| Slice []int `plist:",omitempty"` |
| Bool bool `plist:",omitempty"` |
| Uint uint `plist:",omitempty"` |
| Float32 float32 `plist:",omitempty"` |
| Float64 float64 `plist:",omitempty"` |
| Stringptr *string `plist:",omitempty"` |
| Notempty uint `plist:",omitempty"` |
| }{ |
| Name: "Dustin", |
| Notempty: 10, |
| }, |
| DecodeValue: struct { |
| Name string |
| Age int `plist:"age,omitempty"` |
| Slice []int `plist:",omitempty"` |
| Bool bool `plist:",omitempty"` |
| Uint uint `plist:",omitempty"` |
| Float32 float32 `plist:",omitempty"` |
| Float64 float64 `plist:",omitempty"` |
| Stringptr *string `plist:",omitempty"` |
| Notempty uint `plist:",omitempty"` |
| }{ |
| Name: "Dustin", |
| Notempty: 10, |
| }, |
| Documents: map[int][]byte{ |
| OpenStepFormat: []byte(`{Name=Dustin;Notempty=10;}`), |
| GNUStepFormat: []byte(`{Name=Dustin;Notempty=<*I10>;}`), |
| XMLFormat: []byte(xmlPreamble + `<plist version="1.0"><dict><key>Name</key><string>Dustin</string><key>Notempty</key><integer>10</integer></dict></plist>`), |
| BinaryFormat: []byte{0x62, 0x70, 0x6c, 0x69, 0x73, 0x74, 0x30, 0x30, 0xd2, 0x1, 0x2, 0x3, 0x4, 0x54, 0x4e, 0x61, 0x6d, 0x65, 0x58, 0x4e, 0x6f, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x56, 0x44, 0x75, 0x73, 0x74, 0x69, 0x6e, 0x10, 0xa, 0x8, 0xd, 0x12, 0x1b, 0x22, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x24}, |
| }, |
| }, |
| { |
| Name: "Structure with Anonymous Embeds", |
| Value: EmbedA{ |
| EmbedC: EmbedC{ |
| FieldA1: "", |
| FieldA2: "", |
| FieldB: "A.C.B", |
| FieldC: "A.C.C", |
| }, |
| EmbedB: EmbedB{ |
| FieldB: "A.B.B", |
| EmbedC: &EmbedC{ |
| FieldA1: "A.B.C.A1", |
| FieldA2: "A.B.C.A2", |
| FieldB: "", // Shadowed by A.B.B |
| FieldC: "A.B.C.C", |
| }, |
| }, |
| FieldA: "A.A", |
| }, |
| Documents: map[int][]byte{ |
| OpenStepFormat: []byte(`{EmbedB={FieldA="A.B.C.A1";FieldA2="A.B.C.A2";FieldB="A.B.B";FieldC="A.B.C.C";};FieldA="A.A";FieldA2="";FieldB="A.C.B";FieldC="A.C.C";}`), |
| GNUStepFormat: []byte(`{EmbedB={FieldA=A.B.C.A1;FieldA2=A.B.C.A2;FieldB=A.B.B;FieldC=A.B.C.C;};FieldA=A.A;FieldA2="";FieldB=A.C.B;FieldC=A.C.C;}`), |
| XMLFormat: []byte(xmlPreamble + `<plist version="1.0"><dict><key>EmbedB</key><dict><key>FieldA</key><string>A.B.C.A1</string><key>FieldA2</key><string>A.B.C.A2</string><key>FieldB</key><string>A.B.B</string><key>FieldC</key><string>A.B.C.C</string></dict><key>FieldA</key><string>A.A</string><key>FieldA2</key><string/><key>FieldB</key><string>A.C.B</string><key>FieldC</key><string>A.C.C</string></dict></plist>`), |
| BinaryFormat: []byte{0x62, 0x70, 0x6c, 0x69, 0x73, 0x74, 0x30, 0x30, 0xd5, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0xb, 0xc, 0xd, 0xe, 0x56, 0x45, 0x6d, 0x62, 0x65, 0x64, 0x42, 0x56, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41, 0x57, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41, 0x32, 0x56, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42, 0x56, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43, 0xd4, 0x2, 0x3, 0x4, 0x5, 0x7, 0x8, 0x9, 0xa, 0x58, 0x41, 0x2e, 0x42, 0x2e, 0x43, 0x2e, 0x41, 0x31, 0x58, 0x41, 0x2e, 0x42, 0x2e, 0x43, 0x2e, 0x41, 0x32, 0x55, 0x41, 0x2e, 0x42, 0x2e, 0x42, 0x57, 0x41, 0x2e, 0x42, 0x2e, 0x43, 0x2e, 0x43, 0x53, 0x41, 0x2e, 0x41, 0x50, 0x55, 0x41, 0x2e, 0x43, 0x2e, 0x42, 0x55, 0x41, 0x2e, 0x43, 0x2e, 0x43, 0x8, 0x13, 0x1a, 0x21, 0x29, 0x30, 0x37, 0x40, 0x49, 0x52, 0x58, 0x60, 0x64, 0x65, 0x6b, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x71}, |
| }, |
| }, |
| { |
| Name: "Arbitrary Byte Data", |
| Value: []byte{'h', 'e', 'l', 'l', 'o'}, |
| Documents: map[int][]byte{ |
| OpenStepFormat: []byte(`<68656c6c 6f>`), |
| GNUStepFormat: []byte(`<[aGVsbG8=]>`), |
| XMLFormat: []byte(xmlPreamble + `<plist version="1.0"><data>aGVsbG8=</data></plist>`), |
| BinaryFormat: []byte{98, 112, 108, 105, 115, 116, 48, 48, 69, 104, 101, 108, 108, 111, 8, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14}, |
| }, |
| // We are not encoding base64 for GNUstep yet |
| SkipEncode: map[int]bool{GNUStepFormat: true}, |
| }, |
| { |
| Name: "Arbitrary Byte Data (array)", |
| Value: [5]byte{'h', 'e', 'l', 'l', 'o'}, |
| Documents: map[int][]byte{ |
| OpenStepFormat: []byte(`<68656c6c 6f>`), |
| GNUStepFormat: []byte(`<[aGVsbG8=]>`), |
| XMLFormat: []byte(xmlPreamble + `<plist version="1.0"><data>aGVsbG8=</data></plist>`), |
| BinaryFormat: []byte{98, 112, 108, 105, 115, 116, 48, 48, 69, 104, 101, 108, 108, 111, 8, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14}, |
| }, |
| // We are not encoding base64 for GNUstep yet |
| SkipEncode: map[int]bool{GNUStepFormat: true}, |
| }, |
| { |
| Name: "Arbitrary Integer Slice", |
| Value: []int{'h', 'e', 'l', 'l', 'o'}, |
| Documents: map[int][]byte{ |
| OpenStepFormat: []byte(`(104,101,108,108,111,)`), |
| GNUStepFormat: []byte(`(<*I104>,<*I101>,<*I108>,<*I108>,<*I111>,)`), |
| XMLFormat: []byte(xmlPreamble + `<plist version="1.0"><array><integer>104</integer><integer>101</integer><integer>108</integer><integer>108</integer><integer>111</integer></array></plist>`), |
| BinaryFormat: []byte{98, 112, 108, 105, 115, 116, 48, 48, 165, 1, 2, 3, 3, 4, 16, 104, 16, 101, 16, 108, 16, 111, 8, 14, 16, 18, 20, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 22}, |
| }, |
| }, |
| { |
| Name: "Arbitrary Integer Array", |
| Value: [3]int{'h', 'i', '!'}, |
| Documents: map[int][]byte{ |
| OpenStepFormat: []byte(`(104,105,33,)`), |
| GNUStepFormat: []byte(`(<*I104>,<*I105>,<*I33>,)`), |
| XMLFormat: []byte(xmlPreamble + `<plist version="1.0"><array><integer>104</integer><integer>105</integer><integer>33</integer></array></plist>`), |
| BinaryFormat: []byte{98, 112, 108, 105, 115, 116, 48, 48, 163, 1, 2, 3, 16, 104, 16, 105, 16, 33, 8, 12, 14, 16, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 18}, |
| }, |
| }, |
| { |
| Name: "Unsigned Integers of Increasing Size", |
| Value: []uint64{0xff, 0xfff, 0xffff, 0xfffff, 0xffffff, 0xfffffff, 0xffffffff, 0x7fffffffffffffff, 0xdeadbeeffacecafe}, |
| Documents: map[int][]byte{ |
| OpenStepFormat: []byte(`(255,4095,65535,1048575,16777215,268435455,4294967295,9223372036854775807,16045690985305262846,)`), |
| GNUStepFormat: []byte(`(<*I255>,<*I4095>,<*I65535>,<*I1048575>,<*I16777215>,<*I268435455>,<*I4294967295>,<*I9223372036854775807>,<*I16045690985305262846>,)`), |
| XMLFormat: []byte(xmlPreamble + `<plist version="1.0"><array><integer>255</integer><integer>4095</integer><integer>65535</integer><integer>1048575</integer><integer>16777215</integer><integer>268435455</integer><integer>4294967295</integer><integer>9223372036854775807</integer><integer>16045690985305262846</integer></array></plist>`), |
| BinaryFormat: []byte{0x62, 0x70, 0x6c, 0x69, 0x73, 0x74, 0x30, 0x30, 0xa9, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10, 0xff, 0x11, 0x0f, 0xff, 0x11, 0xff, 0xff, 0x12, 0x00, 0x0f, 0xff, 0xff, 0x12, 0x00, 0xff, 0xff, 0xff, 0x12, 0x0f, 0xff, 0xff, 0xff, 0x12, 0xff, 0xff, 0xff, 0xff, 0x13, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xde, 0xad, 0xbe, 0xef, 0xfa, 0xce, 0xca, 0xfe, 0x08, 0x12, 0x14, 0x17, 0x1a, 0x1f, 0x24, 0x29, 0x2e, 0x37, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x48}, |
| }, |
| }, |
| { |
| Name: "Hexadecimal Integers", |
| Value: []int{'h', 'e', 'x', 'i', 'n', 't', -42}, |
| Documents: map[int][]byte{ |
| XMLFormat: []byte(xmlPreamble + `<plist version="1.0"><array><integer>0x68</integer><integer>0X65</integer><integer>0x78</integer><integer>0X69</integer><integer>0x6e</integer><integer>0X74</integer><integer>-0x2a</integer></array></plist>`), |
| }, |
| SkipEncode: map[int]bool{XMLFormat: true}, |
| }, |
| { |
| Name: "Octal Integers (treated as Decimal)", |
| Value: []int{'o', 'c', 't', 'i', 'n', 't', -42}, |
| Documents: map[int][]byte{ |
| XMLFormat: []byte(xmlPreamble + `<plist version="1.0"><array><integer>0111</integer><integer>099</integer><integer>0116</integer><integer>0105</integer><integer>0110</integer><integer>0116</integer><integer>-042</integer></array></plist>`), |
| }, |
| SkipEncode: map[int]bool{XMLFormat: true}, |
| }, |
| { |
| Name: "Floats of Increasing Bitness", |
| Value: []interface{}{float32(math.MaxFloat32), float64(math.MaxFloat64)}, |
| Documents: map[int][]byte{ |
| OpenStepFormat: []byte(`(3.4028234663852886e+38,1.7976931348623157e+308,)`), |
| GNUStepFormat: []byte(`(<*R3.4028234663852886e+38>,<*R1.7976931348623157e+308>,)`), |
| XMLFormat: []byte(xmlPreamble + `<plist version="1.0"><array><real>3.4028234663852886e+38</real><real>1.7976931348623157e+308</real></array></plist>`), |
| BinaryFormat: []byte{98, 112, 108, 105, 115, 116, 48, 48, 162, 1, 2, 34, 127, 127, 255, 255, 35, 127, 239, 255, 255, 255, 255, 255, 255, 8, 11, 16, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 25}, |
| }, |
| // We can't store varying bitness in text formats. |
| SkipDecode: map[int]bool{XMLFormat: true, OpenStepFormat: true, GNUStepFormat: true}, |
| }, |
| { |
| Name: "Boolean True", |
| Value: true, |
| Documents: map[int][]byte{ |
| OpenStepFormat: []byte(`1`), |
| GNUStepFormat: []byte(`<*BY>`), |
| XMLFormat: []byte(xmlPreamble + `<plist version="1.0"><true/></plist>`), |
| BinaryFormat: []byte{98, 112, 108, 105, 115, 116, 48, 48, 9, 8, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9}, |
| }, |
| }, |
| { |
| Name: "Floating-Point Value", |
| Value: 3.14159265358979323846264338327950288, |
| Documents: map[int][]byte{ |
| OpenStepFormat: []byte(`3.141592653589793`), |
| GNUStepFormat: []byte(`<*R3.141592653589793>`), |
| XMLFormat: []byte(xmlPreamble + `<plist version="1.0"><real>3.141592653589793</real></plist>`), |
| BinaryFormat: []byte{98, 112, 108, 105, 115, 116, 48, 48, 35, 64, 9, 33, 251, 84, 68, 45, 24, 8, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 17}, |
| }, |
| }, |
| { |
| Name: "Map (containing arbitrary types)", |
| Value: map[string]interface{}{ |
| "float": 1.0, |
| "uint64": uint64(1), |
| }, |
| Documents: map[int][]byte{ |
| OpenStepFormat: []byte(`{float=1;uint64=1;}`), |
| GNUStepFormat: []byte(`{float=<*R1>;uint64=<*I1>;}`), |
| XMLFormat: []byte(xmlPreamble + `<plist version="1.0"><dict><key>float</key><real>1</real><key>uint64</key><integer>1</integer></dict></plist>`), |
| BinaryFormat: []byte{0x62, 0x70, 0x6c, 0x69, 0x73, 0x74, 0x30, 0x30, 0xd2, 0x1, 0x2, 0x3, 0x4, 0x55, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x56, 0x75, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x23, 0x3f, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x10, 0x1, 0x8, 0xd, 0x13, 0x1a, 0x23, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x25}, |
| }, |
| // Can't lax decode strings into numerics in a map (we don't know they want numbers) |
| SkipDecode: map[int]bool{OpenStepFormat: true}, |
| }, |
| { |
| Name: "Map (containing all variations of all types)", |
| Value: interface{}(map[string]interface{}{ |
| "intarray": []interface{}{ |
| int(1), |
| int8(8), |
| int16(16), |
| int32(32), |
| int64(64), |
| uint(2), |
| uint8(9), |
| uint16(17), |
| uint32(33), |
| uint64(65), |
| }, |
| "floats": []interface{}{ |
| float32(32.0), |
| float64(64.0), |
| }, |
| "booleans": []bool{ |
| true, |
| false, |
| }, |
| "strings": []string{ |
| "Hello, ASCII", |
| "Hello, 世界", |
| }, |
| "data": []byte{1, 2, 3, 4}, |
| "date": time.Date(2013, 11, 27, 0, 34, 0, 0, time.UTC), |
| }), |
| Documents: map[int][]byte{ |
| OpenStepFormat: []byte(`{booleans=(1,0,);data=<01020304>;date="2013-11-27 00:34:00 +0000";floats=(32,64,);intarray=(1,8,16,32,64,2,9,17,33,65,);strings=("Hello, ASCII","Hello, \U4e16\U754c",);}`), |
| GNUStepFormat: []byte(`{booleans=(<*BY>,<*BN>,);data=<01020304>;date=<*D2013-11-27 00:34:00 +0000>;floats=(<*R32>,<*R64>,);intarray=(<*I1>,<*I8>,<*I16>,<*I32>,<*I64>,<*I2>,<*I9>,<*I17>,<*I33>,<*I65>,);strings=("Hello, ASCII","Hello, \U4e16\U754c",);}`), |
| XMLFormat: []byte(xmlPreamble + `<plist version="1.0"><dict><key>booleans</key><array><true/><false/></array><key>data</key><data>AQIDBA==</data><key>date</key><date>2013-11-27T00:34:00Z</date><key>floats</key><array><real>32</real><real>64</real></array><key>intarray</key><array><integer>1</integer><integer>8</integer><integer>16</integer><integer>32</integer><integer>64</integer><integer>2</integer><integer>9</integer><integer>17</integer><integer>33</integer><integer>65</integer></array><key>strings</key><array><string>Hello, ASCII</string><string>Hello, 世界</string></array></dict></plist>`), |
| BinaryFormat: []byte{0x62, 0x70, 0x6c, 0x69, 0x73, 0x74, 0x30, 0x30, 0xd6, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0xa, 0xb, 0xc, 0xf, 0x1a, 0x58, 0x62, 0x6f, 0x6f, 0x6c, 0x65, 0x61, 0x6e, 0x73, 0x54, 0x64, 0x61, 0x74, 0x61, 0x54, 0x64, 0x61, 0x74, 0x65, 0x56, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x73, 0x58, 0x69, 0x6e, 0x74, 0x61, 0x72, 0x72, 0x61, 0x79, 0x57, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x73, 0xa2, 0x8, 0x9, 0x9, 0x8, 0x44, 0x1, 0x2, 0x3, 0x4, 0x33, 0x41, 0xb8, 0x45, 0x75, 0x78, 0x0, 0x0, 0x0, 0xa2, 0xd, 0xe, 0x22, 0x42, 0x0, 0x0, 0x0, 0x23, 0x40, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaa, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x10, 0x1, 0x10, 0x8, 0x10, 0x10, 0x10, 0x20, 0x10, 0x40, 0x10, 0x2, 0x10, 0x9, 0x10, 0x11, 0x10, 0x21, 0x10, 0x41, 0xa2, 0x1b, 0x1c, 0x5c, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x2c, 0x20, 0x41, 0x53, 0x43, 0x49, 0x49, 0x69, 0x0, 0x48, 0x0, 0x65, 0x0, 0x6c, 0x0, 0x6c, 0x0, 0x6f, 0x0, 0x2c, 0x0, 0x20, 0x4e, 0x16, 0x75, 0x4c, 0x8, 0x15, 0x1e, 0x23, 0x28, 0x2f, 0x38, 0x40, 0x43, 0x44, 0x45, 0x4a, 0x53, 0x56, 0x5b, 0x64, 0x6f, 0x71, 0x73, 0x75, 0x77, 0x79, 0x7b, 0x7d, 0x7f, 0x81, 0x83, 0x86, 0x93, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1d, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa6}, |
| }, |
| SkipDecode: map[int]bool{OpenStepFormat: true, GNUStepFormat: true, XMLFormat: true, BinaryFormat: true}, |
| }, |
| { |
| Name: "Map (containing nil)", |
| Value: map[string]interface{}{ |
| "float": 1.5, |
| "uint64": uint64(1), |
| "nil": nil, |
| }, |
| DecodeValue: map[string]interface{}{ |
| "float": 1.5, |
| "uint64": uint64(1), |
| }, |
| Documents: map[int][]byte{ |
| OpenStepFormat: []byte(`{float=1.5;uint64=1;}`), |
| GNUStepFormat: []byte(`{float=<*R1.5>;uint64=<*I1>;}`), |
| XMLFormat: []byte(xmlPreamble + `<plist version="1.0"><dict><key>float</key><real>1.5</real><key>uint64</key><integer>1</integer></dict></plist>`), |
| BinaryFormat: []byte{0x62, 0x70, 0x6c, 0x69, 0x73, 0x74, 0x30, 0x30, 0xd2, 0x1, 0x2, 0x3, 0x4, 0x55, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x56, 0x75, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x23, 0x3f, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x10, 0x1, 0x8, 0xd, 0x13, 0x1a, 0x23, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x25}, |
| }, |
| // Can't lax decode strings into numerics in a map (we don't know they want numbers) |
| SkipDecode: map[int]bool{OpenStepFormat: true}, |
| }, |
| { |
| Name: "Pointer to structure with plist tags", |
| Value: &SparseBundleHeader{ |
| InfoDictionaryVersion: "6.0", |
| BandSize: 8388608, |
| Size: 4 * 1048576 * 1024 * 1024, |
| DiskImageBundleType: "com.apple.diskimage.sparsebundle", |
| BackingStoreVersion: 1, |
| }, |
| Documents: map[int][]byte{ |
| OpenStepFormat: []byte(`{CFBundleInfoDictionaryVersion="6.0";"band-size"=8388608;"bundle-backingstore-version"=1;"diskimage-bundle-type"="com.apple.diskimage.sparsebundle";size=4398046511104;}`), |
| GNUStepFormat: []byte(`{CFBundleInfoDictionaryVersion=6.0;band-size=<*I8388608>;bundle-backingstore-version=<*I1>;diskimage-bundle-type=com.apple.diskimage.sparsebundle;size=<*I4398046511104>;}`), |
| XMLFormat: []byte(xmlPreamble + `<plist version="1.0"><dict><key>CFBundleInfoDictionaryVersion</key><string>6.0</string><key>band-size</key><integer>8388608</integer><key>bundle-backingstore-version</key><integer>1</integer><key>diskimage-bundle-type</key><string>com.apple.diskimage.sparsebundle</string><key>size</key><integer>4398046511104</integer></dict></plist>`), |
| BinaryFormat: []byte{0x62, 0x70, 0x6c, 0x69, 0x73, 0x74, 0x30, 0x30, 0xd5, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0x5f, 0x10, 0x1d, 0x43, 0x46, 0x42, 0x75, 0x6e, 0x64, 0x6c, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x44, 0x69, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x72, 0x79, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x59, 0x62, 0x61, 0x6e, 0x64, 0x2d, 0x73, 0x69, 0x7a, 0x65, 0x5f, 0x10, 0x1b, 0x62, 0x75, 0x6e, 0x64, 0x6c, 0x65, 0x2d, 0x62, 0x61, 0x63, 0x6b, 0x69, 0x6e, 0x67, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x2d, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x10, 0x15, 0x64, 0x69, 0x73, 0x6b, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x2d, 0x62, 0x75, 0x6e, 0x64, 0x6c, 0x65, 0x2d, 0x74, 0x79, 0x70, 0x65, 0x54, 0x73, 0x69, 0x7a, 0x65, 0x53, 0x36, 0x2e, 0x30, 0x12, 0x0, 0x80, 0x0, 0x0, 0x10, 0x1, 0x5f, 0x10, 0x20, 0x63, 0x6f, 0x6d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x64, 0x69, 0x73, 0x6b, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x2e, 0x73, 0x70, 0x61, 0x72, 0x73, 0x65, 0x62, 0x75, 0x6e, 0x64, 0x6c, 0x65, 0x13, 0x0, 0x0, 0x4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0x13, 0x33, 0x3d, 0x5b, 0x73, 0x78, 0x7c, 0x81, 0x83, 0xa6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaf}, |
| }, |
| SkipDecode: map[int]bool{OpenStepFormat: true}, |
| }, |
| { |
| Name: "Array of byte arrays", |
| Value: [][]byte{ |
| []byte("Hello"), |
| []byte("World"), |
| }, |
| Documents: map[int][]byte{ |
| OpenStepFormat: []byte(`(<48656c6c 6f>,<576f726c 64>,)`), |
| GNUStepFormat: []byte(`(<48656c6c 6f>,<576f726c 64>,)`), |
| XMLFormat: []byte(xmlPreamble + `<plist version="1.0"><array><data>SGVsbG8=</data><data>V29ybGQ=</data></array></plist>`), |
| BinaryFormat: []byte{98, 112, 108, 105, 115, 116, 48, 48, 162, 1, 2, 69, 72, 101, 108, 108, 111, 69, 87, 111, 114, 108, 100, 8, 11, 17, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 23}, |
| }, |
| }, |
| { |
| Name: "Date", |
| Value: time.Date(2013, 11, 27, 0, 34, 0, 0, time.UTC), |
| Documents: map[int][]byte{ |
| OpenStepFormat: []byte(`"2013-11-27 00:34:00 +0000"`), |
| GNUStepFormat: []byte(`<*D2013-11-27 00:34:00 +0000>`), |
| XMLFormat: []byte(xmlPreamble + `<plist version="1.0"><date>2013-11-27T00:34:00Z</date></plist>`), |
| BinaryFormat: []byte{98, 112, 108, 105, 115, 116, 48, 48, 51, 65, 184, 69, 117, 120, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 17}, |
| }, |
| }, |
| { |
| Name: "Floating-Point NaN", |
| Value: math.NaN(), |
| Documents: map[int][]byte{ |
| OpenStepFormat: []byte(`NaN`), |
| GNUStepFormat: []byte(`<*RNaN>`), |
| XMLFormat: []byte(xmlPreamble + `<plist version="1.0"><real>nan</real></plist>`), |
| BinaryFormat: []byte{98, 112, 108, 105, 115, 116, 48, 48, 35, 127, 248, 0, 0, 0, 0, 0, 1, 8, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 17}, |
| }, |
| SkipDecode: map[int]bool{OpenStepFormat: true, GNUStepFormat: true, XMLFormat: true, BinaryFormat: true}, |
| }, |
| { |
| Name: "Floating-Point Infinity", |
| Value: math.Inf(1), |
| Documents: map[int][]byte{ |
| OpenStepFormat: []byte(`+Inf`), |
| GNUStepFormat: []byte(`<*R+Inf>`), |
| XMLFormat: []byte(xmlPreamble + `<plist version="1.0"><real>inf</real></plist>`), |
| BinaryFormat: []byte{98, 112, 108, 105, 115, 116, 48, 48, 35, 127, 240, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 17}, |
| }, |
| }, |
| { |
| Name: "Floating-Point Negative Infinity", |
| Value: math.Inf(-1), |
| Documents: map[int][]byte{ |
| OpenStepFormat: []byte(`-Inf`), |
| GNUStepFormat: []byte(`<*R-Inf>`), |
| XMLFormat: []byte(xmlPreamble + `<plist version="1.0"><real>-inf</real></plist>`), |
| BinaryFormat: []byte{98, 112, 108, 105, 115, 116, 48, 48, 35, 255, 240, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 17}, |
| }, |
| }, |
| { |
| Name: "UTF-8 string", |
| Value: []string{"Hello, ASCII", "Hello, 世界"}, |
| Documents: map[int][]byte{ |
| OpenStepFormat: []byte(`("Hello, ASCII","Hello, \U4e16\U754c",)`), |
| GNUStepFormat: []byte(`("Hello, ASCII","Hello, \U4e16\U754c",)`), |
| XMLFormat: []byte(xmlPreamble + `<plist version="1.0"><array><string>Hello, ASCII</string><string>Hello, 世界</string></array></plist>`), |
| BinaryFormat: []byte{98, 112, 108, 105, 115, 116, 48, 48, 162, 1, 2, 92, 72, 101, 108, 108, 111, 44, 32, 65, 83, 67, 73, 73, 105, 0, 72, 0, 101, 0, 108, 0, 108, 0, 111, 0, 44, 0, 32, 78, 22, 117, 76, 8, 11, 24, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 43}, |
| }, |
| }, |
| { |
| Name: "An array containing more than fifteen items", |
| Value: []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}, |
| Documents: map[int][]byte{ |
| OpenStepFormat: []byte(`(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,)`), |
| GNUStepFormat: []byte(`(<*I1>,<*I2>,<*I3>,<*I4>,<*I5>,<*I6>,<*I7>,<*I8>,<*I9>,<*I10>,<*I11>,<*I12>,<*I13>,<*I14>,<*I15>,<*I16>,)`), |
| XMLFormat: []byte(xmlPreamble + `<plist version="1.0"><array><integer>1</integer><integer>2</integer><integer>3</integer><integer>4</integer><integer>5</integer><integer>6</integer><integer>7</integer><integer>8</integer><integer>9</integer><integer>10</integer><integer>11</integer><integer>12</integer><integer>13</integer><integer>14</integer><integer>15</integer><integer>16</integer></array></plist>`), |
| BinaryFormat: []byte{98, 112, 108, 105, 115, 116, 48, 48, 175, 16, 16, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 16, 1, 16, 2, 16, 3, 16, 4, 16, 5, 16, 6, 16, 7, 16, 8, 16, 9, 16, 10, 16, 11, 16, 12, 16, 13, 16, 14, 16, 15, 16, 16, 8, 27, 29, 31, 33, 35, 37, 39, 41, 43, 45, 47, 49, 51, 53, 55, 57, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 59}, |
| }, |
| }, |
| { |
| Name: "TextMarshaler/TextUnmarshaler", |
| Value: TextMarshalingBool{true}, |
| Documents: map[int][]byte{ |
| OpenStepFormat: []byte(`truthful`), |
| GNUStepFormat: []byte(`truthful`), |
| XMLFormat: []byte(xmlPreamble + `<plist version="1.0"><string>truthful</string></plist>`), |
| BinaryFormat: []byte{98, 112, 108, 105, 115, 116, 48, 48, 88, 116, 114, 117, 116, 104, 102, 117, 108, 8, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 17}, |
| }, |
| // We expect false here because the non-pointer version cannot mutate itself. |
| }, |
| { |
| Name: "TextMarshaler/TextUnmarshaler via Pointer", |
| Value: &TextMarshalingBoolViaPointer{false}, |
| Documents: map[int][]byte{ |
| OpenStepFormat: []byte(`unimaginable`), |
| GNUStepFormat: []byte(`unimaginable`), |
| XMLFormat: []byte(xmlPreamble + `<plist version="1.0"><string>unimaginable</string></plist>`), |
| BinaryFormat: []byte{98, 112, 108, 105, 115, 116, 48, 48, 92, 117, 110, 105, 109, 97, 103, 105, 110, 97, 98, 108, 101, 8, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 21}, |
| }, |
| DecodeValue: TextMarshalingBoolViaPointer{false}, |
| }, |
| { |
| Name: "Duplicated Values", |
| Value: []interface{}{ |
| "Hello", |
| float32(32.0), |
| float64(32.0), |
| []byte("data"), |
| float32(64.0), |
| float64(64.0), |
| uint64(100), |
| float32(32.0), |
| time.Date(2013, 11, 27, 0, 34, 0, 0, time.UTC), |
| float64(32.0), |
| float32(64.0), |
| float64(64.0), |
| "Hello", |
| []byte("data"), |
| uint64(100), |
| time.Date(2013, 11, 27, 0, 34, 0, 0, time.UTC), |
| }, |
| Documents: map[int][]byte{ |
| BinaryFormat: []byte{0x62, 0x70, 0x6c, 0x69, 0x73, 0x74, 0x30, 0x30, 0xaf, 0x10, 0x10, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x2, 0x8, 0x3, 0x5, 0x6, 0x1, 0x4, 0x7, 0x8, 0x55, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x22, 0x42, 0x0, 0x0, 0x0, 0x23, 0x40, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x44, 0x64, 0x61, 0x74, 0x61, 0x22, 0x42, 0x80, 0x0, 0x0, 0x23, 0x40, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x10, 0x64, 0x33, 0x41, 0xb8, 0x45, 0x75, 0x78, 0x0, 0x0, 0x0, 0x8, 0x1b, 0x21, 0x26, 0x2f, 0x34, 0x39, 0x42, 0x44, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4d}, |
| }, |
| }, |
| { |
| Name: "Funny Characters", |
| Value: map[string]string{ |
| "\a": "\b", |
| "\v": "\f", |
| "\\": "\"", |
| "\t\r": "\n", |
| "\u00C8": "wat", |
| "\u0100": "hundred", |
| }, |
| Documents: map[int][]byte{ |
| OpenStepFormat: []byte(`{"\a"="\b";` + "\"\t\r\"=\"\n\";" + `"\v"="\f";"\\"="\"";"\310"=wat;"\U0100"=hundred;}`), |
| GNUStepFormat: []byte(`{"\a"="\b";` + "\"\t\r\"=\"\n\";" + `"\v"="\f";"\\"="\"";"\310"=wat;"\U0100"=hundred;}`), |
| }, |
| }, |
| { |
| Name: "Signed Integers", |
| Value: []int64{-1, -127, -255, -32767, -65535, -9223372036854775808}, |
| Documents: map[int][]byte{ |
| OpenStepFormat: []byte(`(-1,-127,-255,-32767,-65535,-9223372036854775808,)`), |
| GNUStepFormat: []byte(`(<*I-1>,<*I-127>,<*I-255>,<*I-32767>,<*I-65535>,<*I-9223372036854775808>,)`), |
| XMLFormat: []byte(xmlPreamble + `<plist version="1.0"><array><integer>-1</integer><integer>-127</integer><integer>-255</integer><integer>-32767</integer><integer>-65535</integer><integer>-9223372036854775808</integer></array></plist>`), |
| BinaryFormat: []byte{0x62, 0x70, 0x6c, 0x69, 0x73, 0x74, 0x30, 0x30, 0xa6, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x13, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x13, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x81, 0x13, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x13, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x01, 0x13, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x01, 0x13, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x0f, 0x18, 0x21, 0x2a, 0x33, 0x3c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x45}, |
| }, |
| }, |
| { |
| Name: "A map with a blank key", |
| Value: map[string]string{ |
| "": "Hello", |
| }, |
| Documents: map[int][]byte{ |
| OpenStepFormat: []byte(`{""=Hello;}`), |
| GNUStepFormat: []byte(`{""=Hello;}`), |
| XMLFormat: []byte(xmlPreamble + `<plist version="1.0"><dict><key/><string>Hello</string></dict></plist>`), |
| BinaryFormat: []byte{98, 112, 108, 105, 115, 116, 48, 48, 209, 1, 2, 80, 85, 72, 101, 108, 108, 111, 8, 11, 12, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 18}, |
| }, |
| }, |
| { |
| Name: "CF Keyed Archiver UIDs (interface{})", |
| Value: []UID{ |
| 0xff, |
| 0xffff, |
| 0xffffff, |
| 0xffffffff, |
| 0xffffffffff, |
| }, |
| Documents: map[int][]byte{ |
| OpenStepFormat: []byte(`({CF$UID=255;},{CF$UID=65535;},{CF$UID=16777215;},{CF$UID=4294967295;},{CF$UID=1099511627775;},)`), |
| GNUStepFormat: []byte(`({CF$UID=<*I255>;},{CF$UID=<*I65535>;},{CF$UID=<*I16777215>;},{CF$UID=<*I4294967295>;},{CF$UID=<*I1099511627775>;},)`), |
| XMLFormat: []byte(xmlPreamble + `<plist version="1.0"><array><dict><key>CF$UID</key><integer>255</integer></dict><dict><key>CF$UID</key><integer>65535</integer></dict><dict><key>CF$UID</key><integer>16777215</integer></dict><dict><key>CF$UID</key><integer>4294967295</integer></dict><dict><key>CF$UID</key><integer>1099511627775</integer></dict></array></plist>`), |
| BinaryFormat: []byte{0x62, 0x70, 0x6c, 0x69, 0x73, 0x74, 0x30, 0x30, 0xa5, 0x01, 0x02, 0x03, 0x04, 0x05, 0x80, 0xff, 0x81, 0xff, 0xff, 0x83, 0x00, 0xff, 0xff, 0xff, 0x83, 0xff, 0xff, 0xff, 0xff, 0x87, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x08, 0x0e, 0x10, 0x13, 0x18, 0x1d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26}, |
| }, |
| }, |
| { |
| Name: "CF Keyed Archiver UID (struct)", |
| Value: struct { |
| U UID `plist:"identifier"` |
| }{ |
| U: 1024, |
| }, |
| Documents: map[int][]byte{ |
| OpenStepFormat: []byte(`{identifier={CF$UID=1024;};}`), |
| GNUStepFormat: []byte(`{identifier={CF$UID=<*I1024>;};}`), |
| XMLFormat: []byte(xmlPreamble + `<plist version="1.0"><dict><key>identifier</key><dict><key>CF$UID</key><integer>1024</integer></dict></dict></plist>`), |
| BinaryFormat: []byte{0x62, 0x70, 0x6c, 0x69, 0x73, 0x74, 0x30, 0x30, 0xd1, 0x01, 0x02, 0x5a, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x81, 0x04, 0x00, 0x08, 0x0b, 0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x19}, |
| }, |
| }, |
| { |
| Name: "CF Keyed Archiver UID as Legacy Int", |
| Value: struct { |
| U UID `plist:"identifier"` |
| }{ |
| U: 1024, |
| }, |
| Documents: map[int][]byte{ |
| OpenStepFormat: []byte(`{identifier={CF$UID=1024;};}`), |
| GNUStepFormat: []byte(`{identifier={CF$UID=<*I1024>;};}`), |
| XMLFormat: []byte(xmlPreamble + `<plist version="1.0"><dict><key>identifier</key><dict><key>CF$UID</key><integer>1024</integer></dict></dict></plist>`), |
| BinaryFormat: []byte{0x62, 0x70, 0x6c, 0x69, 0x73, 0x74, 0x30, 0x30, 0xd1, 0x01, 0x02, 0x5a, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x81, 0x04, 0x00, 0x08, 0x0b, 0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x19}, |
| }, |
| DecodeValue: struct { |
| U uint64 `plist:"identifier"` |
| }{ |
| U: 1024, |
| }, |
| }, |
| { |
| Name: "Custom Marshaller/Unmarshaller by Value", |
| Value: []ArrayThatSerializesAsOneObject{ |
| ArrayThatSerializesAsOneObject{[]uint64{100}}, |
| ArrayThatSerializesAsOneObject{[]uint64{2, 4, 6, 8}}, |
| }, |
| Documents: map[int][]byte{ |
| GNUStepFormat: []byte(`(<*I100>,(<*I2>,<*I4>,<*I6>,<*I8>,),)`), |
| }, |
| }, |
| { |
| Name: "Custom Marshaller/Unmarshaller by Pointer", |
| Value: &PlistMarshalingBoolByPointer{true}, |
| Documents: map[int][]byte{ |
| OpenStepFormat: []byte(`-1`), |
| GNUStepFormat: []byte(`<*I-1>`), |
| }, |
| }, |
| { |
| Name: "Type implementing both Text and Plist Marshaler", |
| Value: &BothMarshaler{}, |
| Documents: map[int][]byte{ |
| GNUStepFormat: []byte(`{a=b;}`), |
| }, |
| }, |
| { |
| Name: "Type implementing both Text and Plist Unmarshaler", |
| Value: &BothUnmarshaler{int64(1024)}, |
| Documents: map[int][]byte{ |
| GNUStepFormat: []byte(`{blah=<*I1024>;}`), |
| }, |
| DecodeValue: &BothUnmarshaler{int64(0)}, |
| }, |
| { |
| Name: "Comments", |
| Value: struct { |
| A, B, C int |
| S, S2 string |
| }{ |
| 1, 2, 3, |
| "/not/a/comment/", "/not*a/*comm*en/t", |
| }, |
| Documents: map[int][]byte{ |
| OpenStepFormat: []byte(`{ |
| A=1 /* A is 1 because it is the first letter */; |
| B=2; // B is 2 because comment-to-end-of-line. |
| C=3; |
| S = /not/a/comment/; |
| S2 = /not*a/*comm*en/t; |
| }`), |
| }, |
| SkipEncode: map[int]bool{OpenStepFormat: true}, |
| }, |
| { |
| Name: "Escapes", |
| Value: struct { |
| W, A, B, V, F, T, R, N, Hex1, Unicode1, Unicode2, Octal1 string |
| }{ |
| "w", "\a", "\b", "\v", "\f", "\t", "\r", "\n", "\u00ab", "\u00ac", "\u00ad", "\033", |
| }, |
| Documents: map[int][]byte{ |
| OpenStepFormat: []byte(`{ |
| W="\w"; |
| A="\a"; |
| B="\b"; |
| V="\v"; |
| F="\f"; |
| T="\t"; |
| R="\r"; |
| N="\n"; |
| Hex1="\xAB"; |
| Unicode1="\u00AC"; |
| Unicode2="\U00AD"; |
| Octal1="\033"; |
| }`), |
| }, |
| SkipEncode: map[int]bool{OpenStepFormat: true}, |
| }, |
| { |
| Name: "Empty Strings in Arrays", |
| Value: []string{"A"}, |
| Documents: map[int][]byte{ |
| OpenStepFormat: []byte(`(A,,,"",)`), |
| }, |
| SkipEncode: map[int]bool{OpenStepFormat: true}, |
| }, |
| { |
| Name: "Empty Data", |
| Value: []byte{}, |
| Documents: map[int][]byte{ |
| OpenStepFormat: []byte(`<>`), |
| }, |
| SkipEncode: map[int]bool{OpenStepFormat: true}, |
| }, |
| { |
| Name: "UTF-8 with BOM", |
| Value: "Hello", |
| Documents: map[int][]byte{ |
| OpenStepFormat: []byte("\uFEFFHello"), |
| }, |
| SkipEncode: map[int]bool{OpenStepFormat: true}, |
| }, |
| { |
| Name: "UTF-16LE with BOM", |
| Value: "Hello", |
| Documents: map[int][]byte{ |
| OpenStepFormat: []byte{0xFF, 0xFE, 'H', 0, 'e', 0, 'l', 0, 'l', 0, 'o', 0}, |
| }, |
| SkipEncode: map[int]bool{OpenStepFormat: true}, |
| }, |
| { |
| Name: "UTF-16BE with BOM", |
| Value: "Hello", |
| Documents: map[int][]byte{ |
| OpenStepFormat: []byte{0xFE, 0xFF, 0, 'H', 0, 'e', 0, 'l', 0, 'l', 0, 'o'}, |
| }, |
| SkipEncode: map[int]bool{OpenStepFormat: true}, |
| }, |
| { |
| Name: "UTF-16LE without BOM", |
| Value: "Hello", |
| Documents: map[int][]byte{ |
| OpenStepFormat: []byte{'H', 0, 'e', 0, 'l', 0, 'l', 0, 'o', 0}, |
| }, |
| SkipEncode: map[int]bool{OpenStepFormat: true}, |
| }, |
| { |
| Name: "UTF-16BE without BOM", |
| Value: "Hello", |
| Documents: map[int][]byte{ |
| OpenStepFormat: []byte{0, 'H', 0, 'e', 0, 'l', 0, 'l', 0, 'o'}, |
| }, |
| SkipEncode: map[int]bool{OpenStepFormat: true}, |
| }, |
| { |
| Name: "UTF-16BE with High Characters", |
| Value: "Hello, 世界", |
| Documents: map[int][]byte{ |
| OpenStepFormat: []byte{0, '"', 0, 'H', 0, 'e', 0, 'l', 0, 'l', 0, 'o', 0, ',', 0, ' ', 0x4E, 0x16, 0x75, 0x4C, 0, '"'}, |
| }, |
| SkipEncode: map[int]bool{OpenStepFormat: true}, |
| }, |
| { |
| Name: "Legacy Strings File Format (No Dictionary)", |
| Value: map[string]string{ |
| "Key": "Value", |
| "Key2": "Value2", |
| }, |
| Documents: map[int][]byte{ |
| OpenStepFormat: []byte(`"Key" = "Value"; |
| "Key2" = "Value2";`), |
| }, |
| SkipEncode: map[int]bool{OpenStepFormat: true}, |
| }, |
| { |
| Name: "Strings File Shortcut Format (No Values)", |
| Value: map[string]string{ |
| "Key": "Key", |
| "Key2": "Key2", |
| }, |
| Documents: map[int][]byte{ |
| OpenStepFormat: []byte(`"Key"; |
| "Key2";`), |
| }, |
| SkipEncode: map[int]bool{OpenStepFormat: true}, |
| }, |
| { |
| Name: "Various Truncated Escapes", |
| Value: "\x01\x02\x03\x04\x057", |
| Documents: map[int][]byte{ |
| OpenStepFormat: []byte(`"\x1\u02\U003\4\0057"`), |
| }, |
| SkipEncode: map[int]bool{OpenStepFormat: true}, |
| }, |
| { |
| Name: "Various Case-Insensitive Escapes", |
| Value: "\u00AB\uCDEF", |
| Documents: map[int][]byte{ |
| OpenStepFormat: []byte(`"\xaB\uCdEf"`), |
| }, |
| SkipEncode: map[int]bool{OpenStepFormat: true}, |
| }, |
| { |
| Name: "Text data long enough to trigger implementation-specific reallocation", // this is for coverage :( |
| Value: []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}, |
| Documents: map[int][]byte{ |
| OpenStepFormat: []byte("<0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001>"), |
| }, |
| SkipEncode: map[int]bool{OpenStepFormat: true}, |
| }, |
| { |
| Name: "Empty Text Document", |
| Value: map[string]interface{}{}, // Defined to be an empty dictionary |
| Documents: map[int][]byte{ |
| OpenStepFormat: []byte{}, |
| }, |
| SkipEncode: map[int]bool{OpenStepFormat: true}, |
| }, |
| { |
| Name: "Text document consisting of only whitespace", |
| Value: map[string]interface{}{}, // Defined to be an empty dictionary |
| Documents: map[int][]byte{ |
| OpenStepFormat: []byte(" \n\t"), |
| }, |
| SkipEncode: map[int]bool{OpenStepFormat: true}, |
| }, |
| { |
| Name: "Sized integers at size boundaries", |
| Value: []interface{}{ |
| int8(-128), |
| int8(127), |
| int16(-32768), |
| int16(32767), |
| int32(-2147483648), |
| int32(2147483647), |
| int64(-9223372036854775808), |
| int64(9223372036854775807), |
| }, |
| DecodeValue: []interface{}{ |
| // interface decoding promotes all numbers to u/int64 |
| int64(-128), |
| uint64(127), |
| int64(-32768), |
| uint64(32767), |
| int64(-2147483648), |
| uint64(2147483647), |
| int64(-9223372036854775808), |
| uint64(9223372036854775807), |
| }, |
| Documents: map[int][]byte{ |
| BinaryFormat: []byte{0x62, 0x70, 0x6c, 0x69, 0x73, 0x74, 0x30, 0x30, 0xa8, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x13, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x10, 0x7f, 0x13, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x00, 0x11, 0x7f, 0xff, 0x13, 0xff, 0xff, 0xff, 0xff, 0x80, 0x00, 0x00, 0x00, 0x12, 0x7f, 0xff, 0xff, 0xff, 0x13, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x13, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x08, 0x11, 0x1a, 0x1c, 0x25, 0x28, 0x31, 0x36, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x48}, |
| }, |
| }, |
| { |
| Name: "Duplicate Dictionary Keys", |
| Value: map[string]interface{}{ |
| "key": "second value", |
| }, |
| Documents: map[int][]byte{ |
| XMLFormat: []byte(`<plist><dict><key>key</key><string>value</string><key>key</key><string>second value</string></dict></plist>`), |
| OpenStepFormat: []byte(`{"key" = "value"; "key" = "second value";}`), |
| GNUStepFormat: []byte(`{"key" = "value"; "key" = "second value";}`), |
| BinaryFormat: []byte{ |
| 'b', 'p', 'l', 'i', 's', 't', '0', '0', |
| |
| 0xD2, 0x01, 0x01, 0x02, 0x03, |
| 0x53, 'k', 'e', 'y', |
| 0x55, 'v', 'a', 'l', 'u', 'e', |
| 0x5C, 's', 'e', 'c', 'o', 'n', 'd', ' ', 'v', 'a', 'l', 'u', 'e', |
| |
| 0x08, 0x0D, 0x11, 0x17, |
| |
| 0x00, 0x00, 0x00, 0x00, 0x00, |
| 0x00, |
| 0x01, |
| 0x01, |
| 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, |
| 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
| 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x24, |
| }, |
| }, |
| SkipEncode: map[int]bool{XMLFormat: true, OpenStepFormat: true, GNUStepFormat: true, BinaryFormat: true}, |
| }, |
| { |
| Name: "GNUStep base64 data ignoring invalid chars", |
| Value: [][]byte{ |
| {'h', 'e', 'l', 'l', 'o'}, |
| {'h', 'e', 'l', 'l', 'o'}, |
| }, |
| Documents: map[int][]byte{ |
| GNUStepFormat: []byte(`(<[aGVs^^bG8=]>,<[ a G V s b G 8 = ]>)`), |
| }, |
| // We are not encoding base64 for GNUstep yet |
| SkipEncode: map[int]bool{GNUStepFormat: true}, |
| }, |
| { |
| Name: "Text document with quoted GNUstep values", |
| Value: []interface{}{uint64(1048576), uint64(1234), true}, |
| Documents: map[int][]byte{ |
| GNUStepFormat: []byte(`(<*I"1048576">, <*I"1234>, <*B"Y>)`), |
| }, |
| SkipEncode: map[int]bool{GNUStepFormat: true}, |
| }, |
| } |
| |
| type EverythingTestData struct { |
| Intarray []uint64 `plist:"intarray"` |
| Floats []float64 `plist:"floats"` |
| Booleans []bool `plist:"booleans"` |
| Strings []string `plist:"strings"` |
| Dat []byte `plist:"data"` |
| Date time.Time `plist:"date"` |
| } |
| |
| var plistValueTreeRawData = &EverythingTestData{ |
| Intarray: []uint64{1, 8, 16, 32, 64, 2, 9, 17, 33, 65}, |
| Floats: []float64{32.0, 64.0}, |
| Booleans: []bool{true, false}, |
| Strings: []string{"Hello, ASCII", "Hello, 世界"}, |
| Dat: []byte{1, 2, 3, 4}, |
| Date: time.Date(2013, 11, 27, 0, 34, 0, 0, time.UTC), |
| } |
| var plistValueTree cfValue |
| var plistValueTreeAsBplist = []byte{98, 112, 108, 105, 115, 116, 48, 48, 214, 1, 13, 17, 21, 25, 27, 2, 14, 18, 22, 26, 28, 88, 105, 110, 116, 97, 114, 114, 97, 121, 170, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 16, 1, 16, 8, 16, 16, 16, 32, 16, 64, 16, 2, 16, 9, 16, 17, 16, 33, 16, 65, 86, 102, 108, 111, 97, 116, 115, 162, 15, 16, 34, 66, 0, 0, 0, 35, 64, 80, 0, 0, 0, 0, 0, 0, 88, 98, 111, 111, 108, 101, 97, 110, 115, 162, 19, 20, 9, 8, 87, 115, 116, 114, 105, 110, 103, 115, 162, 23, 24, 92, 72, 101, 108, 108, 111, 44, 32, 65, 83, 67, 73, 73, 105, 0, 72, 0, 101, 0, 108, 0, 108, 0, 111, 0, 44, 0, 32, 78, 22, 117, 76, 84, 100, 97, 116, 97, 68, 1, 2, 3, 4, 84, 100, 97, 116, 101, 51, 65, 184, 69, 117, 120, 0, 0, 0, 8, 21, 30, 41, 43, 45, 47, 49, 51, 53, 55, 57, 59, 61, 68, 71, 76, 85, 94, 97, 98, 99, 107, 110, 123, 142, 147, 152, 157, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 29, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 166} |
| var plistValueTreeAsXML = xmlPreamble + `<plist version="1.0"><dict><key>intarray</key><array><integer>1</integer><integer>8</integer><integer>16</integer><integer>32</integer><integer>64</integer><integer>2</integer><integer>9</integer><integer>17</integer><integer>33</integer><integer>65</integer></array><key>floats</key><array><real>32</real><real>64</real></array><key>booleans</key><array><true/><false/></array><key>strings</key><array><string>Hello, ASCII</string><string>Hello, 世界</string></array><key>data</key><data>AQIDBA==</data><key>date</key><date>2013-11-27T00:34:00Z</date></dict></plist>` |
| var plistValueTreeAsOpenStep = `{booleans=(1,0,);data=<01020304>;date="2013-11-27 00:34:00 +0000";floats=(32,64,);intarray=(1,8,16,32,64,2,9,17,33,65,);strings=("Hello, ASCII","Hello, \U4e16\U754c",);}` |
| var plistValueTreeAsGNUStep = `{booleans=(<*BY>,<*BN>,);data=<01020304>;date=<*D2013-11-27 00:34:00 +0000>;floats=(<*R32>,<*R64>,);intarray=(<*I1>,<*I8>,<*I16>,<*I32>,<*I64>,<*I2>,<*I9>,<*I17>,<*I33>,<*I65>,);strings=("Hello, ASCII","Hello, \U4e16\U754c",);}` |
| |
| type LaxTestData struct { |
| I64 int64 |
| U64 uint64 |
| F64 float64 |
| B bool |
| D time.Time |
| } |
| |
| var laxTestData = LaxTestData{1, 2, 3.0, true, time.Date(2013, 11, 27, 0, 34, 0, 0, time.UTC)} |
| |
| func setupPlistValues() { |
| plistValueTree = &cfDictionary{ |
| keys: []string{ |
| "intarray", |
| "floats", |
| "booleans", |
| "strings", |
| "data", |
| "date", |
| }, |
| values: []cfValue{ |
| &cfArray{ |
| values: []cfValue{ |
| &cfNumber{value: 1}, |
| &cfNumber{value: 8}, |
| &cfNumber{value: 16}, |
| &cfNumber{value: 32}, |
| &cfNumber{value: 64}, |
| &cfNumber{value: 2}, |
| &cfNumber{value: 8}, |
| &cfNumber{value: 17}, |
| &cfNumber{value: 33}, |
| &cfNumber{value: 65}, |
| }, |
| }, |
| &cfArray{ |
| values: []cfValue{ |
| &cfReal{wide: false, value: 32.0}, |
| &cfReal{wide: true, value: 64.0}, |
| }, |
| }, |
| &cfArray{ |
| values: []cfValue{ |
| cfBoolean(true), |
| cfBoolean(false), |
| }, |
| }, |
| &cfArray{ |
| values: []cfValue{ |
| cfString("Hello, ASCII"), |
| cfString("Hello, 世界"), |
| }, |
| }, |
| cfData{1, 2, 3, 4}, |
| cfDate(time.Date(2013, 11, 27, 0, 32, 0, 0, time.UTC)), |
| }, |
| } |
| } |
| |
| func init() { |
| setupPlistValues() |
| |
| // Pre-warm the type info struct to remove it from benchmarking |
| getTypeInfo(reflect.ValueOf(plistValueTreeRawData).Type()) |
| } |
