github.com/chunqian/pretty@v0.0.0-20200305075802-e57086a8d0c4/diff.go (about) 1 package pretty 2 3 import ( 4 "fmt" 5 "io" 6 "reflect" 7 ) 8 9 type sbuf []string 10 11 func (p *sbuf) Printf(format string, a ...interface{}) { 12 s := fmt.Sprintf(format, a...) 13 *p = append(*p, s) 14 } 15 16 // Diff returns a slice where each element describes 17 // a difference between a and b. 18 func Diff(a, b interface{}) (desc []string) { 19 Pdiff((*sbuf)(&desc), a, b) 20 return desc 21 } 22 23 // wprintfer calls Fprintf on w for each Printf call 24 // with a trailing newline. 25 type wprintfer struct{ w io.Writer } 26 27 func (p *wprintfer) Printf(format string, a ...interface{}) { 28 fmt.Fprintf(p.w, format+"\n", a...) 29 } 30 31 // Fdiff writes to w a description of the differences between a and b. 32 func Fdiff(w io.Writer, a, b interface{}) { 33 Pdiff(&wprintfer{w}, a, b) 34 } 35 36 type Printfer interface { 37 Printf(format string, a ...interface{}) 38 } 39 40 // Pdiff prints to p a description of the differences between a and b. 41 // It calls Printf once for each difference, with no trailing newline. 42 // The standard library log.Logger is a Printfer. 43 func Pdiff(p Printfer, a, b interface{}) { 44 diffPrinter{w: p}.diff(reflect.ValueOf(a), reflect.ValueOf(b)) 45 } 46 47 type Logfer interface { 48 Logf(format string, a ...interface{}) 49 } 50 51 // logprintfer calls Fprintf on w for each Printf call 52 // with a trailing newline. 53 type logprintfer struct{ l Logfer } 54 55 func (p *logprintfer) Printf(format string, a ...interface{}) { 56 p.l.Logf(format, a...) 57 } 58 59 // Ldiff prints to l a description of the differences between a and b. 60 // It calls Logf once for each difference, with no trailing newline. 61 // The standard library testing.T and testing.B are Logfers. 62 func Ldiff(l Logfer, a, b interface{}) { 63 Pdiff(&logprintfer{l}, a, b) 64 } 65 66 type diffPrinter struct { 67 w Printfer 68 l string // label 69 } 70 71 func (w diffPrinter) printf(f string, a ...interface{}) { 72 var l string 73 if w.l != "" { 74 l = w.l + ": " 75 } 76 w.w.Printf(l+f, a...) 77 } 78 79 func (w diffPrinter) diff(av, bv reflect.Value) { 80 if !av.IsValid() && bv.IsValid() { 81 w.printf("nil != %# v", formatter{v: bv, quote: true}) 82 return 83 } 84 if av.IsValid() && !bv.IsValid() { 85 w.printf("%# v != nil", formatter{v: av, quote: true}) 86 return 87 } 88 if !av.IsValid() && !bv.IsValid() { 89 return 90 } 91 92 at := av.Type() 93 bt := bv.Type() 94 if at != bt { 95 w.printf("%v != %v", at, bt) 96 return 97 } 98 99 switch kind := at.Kind(); kind { 100 case reflect.Bool: 101 if a, b := av.Bool(), bv.Bool(); a != b { 102 w.printf("%v != %v", a, b) 103 } 104 case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: 105 if a, b := av.Int(), bv.Int(); a != b { 106 w.printf("%d != %d", a, b) 107 } 108 case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: 109 if a, b := av.Uint(), bv.Uint(); a != b { 110 w.printf("%d != %d", a, b) 111 } 112 case reflect.Float32, reflect.Float64: 113 if a, b := av.Float(), bv.Float(); a != b { 114 w.printf("%v != %v", a, b) 115 } 116 case reflect.Complex64, reflect.Complex128: 117 if a, b := av.Complex(), bv.Complex(); a != b { 118 w.printf("%v != %v", a, b) 119 } 120 case reflect.Array: 121 n := av.Len() 122 for i := 0; i < n; i++ { 123 w.relabel(fmt.Sprintf("[%d]", i)).diff(av.Index(i), bv.Index(i)) 124 } 125 case reflect.Chan, reflect.Func, reflect.UnsafePointer: 126 if a, b := av.Pointer(), bv.Pointer(); a != b { 127 w.printf("%#x != %#x", a, b) 128 } 129 case reflect.Interface: 130 w.diff(av.Elem(), bv.Elem()) 131 case reflect.Map: 132 ak, both, bk := keyDiff(av.MapKeys(), bv.MapKeys()) 133 for _, k := range ak { 134 w := w.relabel(fmt.Sprintf("[%#v]", k)) 135 w.printf("%q != (missing)", av.MapIndex(k)) 136 } 137 for _, k := range both { 138 w := w.relabel(fmt.Sprintf("[%#v]", k)) 139 w.diff(av.MapIndex(k), bv.MapIndex(k)) 140 } 141 for _, k := range bk { 142 w := w.relabel(fmt.Sprintf("[%#v]", k)) 143 w.printf("(missing) != %q", bv.MapIndex(k)) 144 } 145 case reflect.Ptr: 146 switch { 147 case av.IsNil() && !bv.IsNil(): 148 w.printf("nil != %# v", formatter{v: bv, quote: true}) 149 case !av.IsNil() && bv.IsNil(): 150 w.printf("%# v != nil", formatter{v: av, quote: true}) 151 case !av.IsNil() && !bv.IsNil(): 152 w.diff(av.Elem(), bv.Elem()) 153 } 154 case reflect.Slice: 155 lenA := av.Len() 156 lenB := bv.Len() 157 if lenA != lenB { 158 w.printf("%s[%d] != %s[%d]", av.Type(), lenA, bv.Type(), lenB) 159 break 160 } 161 for i := 0; i < lenA; i++ { 162 w.relabel(fmt.Sprintf("[%d]", i)).diff(av.Index(i), bv.Index(i)) 163 } 164 case reflect.String: 165 if a, b := av.String(), bv.String(); a != b { 166 w.printf("%q != %q", a, b) 167 } 168 case reflect.Struct: 169 for i := 0; i < av.NumField(); i++ { 170 w.relabel(at.Field(i).Name).diff(av.Field(i), bv.Field(i)) 171 } 172 default: 173 panic("unknown reflect Kind: " + kind.String()) 174 } 175 } 176 177 func (d diffPrinter) relabel(name string) (d1 diffPrinter) { 178 d1 = d 179 if d.l != "" && name[0] != '[' { 180 d1.l += "." 181 } 182 d1.l += name 183 return d1 184 } 185 186 // keyEqual compares a and b for equality. 187 // Both a and b must be valid map keys. 188 func keyEqual(av, bv reflect.Value) bool { 189 if !av.IsValid() && !bv.IsValid() { 190 return true 191 } 192 if !av.IsValid() || !bv.IsValid() || av.Type() != bv.Type() { 193 return false 194 } 195 switch kind := av.Kind(); kind { 196 case reflect.Bool: 197 a, b := av.Bool(), bv.Bool() 198 return a == b 199 case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: 200 a, b := av.Int(), bv.Int() 201 return a == b 202 case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: 203 a, b := av.Uint(), bv.Uint() 204 return a == b 205 case reflect.Float32, reflect.Float64: 206 a, b := av.Float(), bv.Float() 207 return a == b 208 case reflect.Complex64, reflect.Complex128: 209 a, b := av.Complex(), bv.Complex() 210 return a == b 211 case reflect.Array: 212 for i := 0; i < av.Len(); i++ { 213 if !keyEqual(av.Index(i), bv.Index(i)) { 214 return false 215 } 216 } 217 return true 218 case reflect.Chan, reflect.UnsafePointer, reflect.Ptr: 219 a, b := av.Pointer(), bv.Pointer() 220 return a == b 221 case reflect.Interface: 222 return keyEqual(av.Elem(), bv.Elem()) 223 case reflect.String: 224 a, b := av.String(), bv.String() 225 return a == b 226 case reflect.Struct: 227 for i := 0; i < av.NumField(); i++ { 228 if !keyEqual(av.Field(i), bv.Field(i)) { 229 return false 230 } 231 } 232 return true 233 default: 234 panic("invalid map key type " + av.Type().String()) 235 } 236 } 237 238 func keyDiff(a, b []reflect.Value) (ak, both, bk []reflect.Value) { 239 for _, av := range a { 240 inBoth := false 241 for _, bv := range b { 242 if keyEqual(av, bv) { 243 inBoth = true 244 both = append(both, av) 245 break 246 } 247 } 248 if !inBoth { 249 ak = append(ak, av) 250 } 251 } 252 for _, bv := range b { 253 inBoth := false 254 for _, av := range a { 255 if keyEqual(av, bv) { 256 inBoth = true 257 break 258 } 259 } 260 if !inBoth { 261 bk = append(bk, bv) 262 } 263 } 264 return 265 }