test/map.go

   1 // $G $F.go && $L $F.$A && ./$A.out
   2
   3 // Copyright 2009 The Go Authors. All rights reserved.
   4 // Use of this source code is governed by a BSD-style
   5 // license that can be found in the LICENSE file.
   6
   7 package main
   8
   9 import (
  10         "fmt"
  11         "strconv"
  12 )
  13
  14 const count = 100
  15
  16 func P(a []string) string {
  17         s := "{"
  18         for i := 0; i < len(a); i++ {
  19                 if i > 0 {
  20                         s += ","
  21                 }
  22                 s += `"` + a[i] + `"`
  23         }
  24         s +="}"
  25         return s
  26 }
  27
  28 func main() {
  29         // Test a map literal.
  30         mlit := map[string] int { "0":0, "1":1, "2":2, "3":3, "4":4 }
  31         for i := 0; i < len(mlit); i++ {
  32                 s := string([]byte{byte(i)+'0'})
  33                 if mlit[s] != i {
  34                         fmt.Printf("mlit[%s] = %d\n", s, mlit[s])
  35                 }
  36         }
  37
  38         mib := make(map[int] bool)
  39         mii := make(map[int] int)
  40         mfi := make(map[float] int)
  41         mif := make(map[int] float)
  42         msi := make(map[string] int)
  43         mis := make(map[int] string)
  44         mss := make(map[string] string)
  45         mspa := make(map[string] []string)
  46         // BUG need an interface map both ways too
  47
  48         type T struct {
  49                 i int64 // can't use string here; struct values are only compared at the top level
  50                 f float
  51         }
  52         mipT := make(map[int] *T)
  53         mpTi := make(map[*T] int)
  54         mit := make(map[int] T)
  55 //      mti := make(map[T] int)
  56
  57         type M map[int] int
  58         mipM := make(map[int] M)
  59
  60         var apT [2*count]*T
  61
  62         for i := 0; i < count; i++ {
  63                 s := strconv.Itoa(i)
  64                 s10 := strconv.Itoa(i*10)
  65                 f := float(i)
  66                 t := T{int64(i),f}
  67                 apT[i] = new(T)
  68                 apT[i].i = int64(i)
  69                 apT[i].f = f
  70                 apT[2*i] = new(T)       // need twice as many entries as we use, for the nonexistence check
  71                 apT[2*i].i = int64(i)
  72                 apT[2*i].f = f
  73                 m := M{i: i+1}
  74                 mib[i] = (i != 0)
  75                 mii[i] = 10*i
  76                 mfi[float(i)] = 10*i
  77                 mif[i] = 10.0*f
  78                 mis[i] = s
  79                 msi[s] = i
  80                 mss[s] = s10
  81                 mss[s] = s10
  82                 as := make([]string, 2)
  83                         as[0] = s10
  84                         as[1] = s10
  85                 mspa[s] = as
  86                 mipT[i] = apT[i]
  87                 mpTi[apT[i]] = i
  88                 mipM[i] = m
  89                 mit[i] = t
  90         //      mti[t] = i
  91         }
  92
  93         // test len
  94         if len(mib) != count {
  95                 fmt.Printf("len(mib) = %d\n", len(mib))
  96         }
  97         if len(mii) != count {
  98                 fmt.Printf("len(mii) = %d\n", len(mii))
  99         }
 100         if len(mfi) != count {
 101                 fmt.Printf("len(mfi) = %d\n", len(mfi))
 102         }
 103         if len(mif) != count {
 104                 fmt.Printf("len(mif) = %d\n", len(mif))
 105         }
 106         if len(msi) != count {
 107                 fmt.Printf("len(msi) = %d\n", len(msi))
 108         }
 109         if len(mis) != count {
 110                 fmt.Printf("len(mis) = %d\n", len(mis))
 111         }
 112         if len(mss) != count {
 113                 fmt.Printf("len(mss) = %d\n", len(mss))
 114         }
 115         if len(mspa) != count {
 116                 fmt.Printf("len(mspa) = %d\n", len(mspa))
 117         }
 118         if len(mipT) != count {
 119                 fmt.Printf("len(mipT) = %d\n", len(mipT))
 120         }
 121         if len(mpTi) != count {
 122                 fmt.Printf("len(mpTi) = %d\n", len(mpTi))
 123         }
 124 //      if len(mti) != count {
 125 //              fmt.Printf("len(mti) = %d\n", len(mti))
 126 //      }
 127         if len(mipM) != count {
 128                 fmt.Printf("len(mipM) = %d\n", len(mipM))
 129         }
 130 //      if len(mti) != count {
 131 //              fmt.Printf("len(mti) = %d\n", len(mti))
 132 //      }
 133         if len(mit) != count {
 134                 fmt.Printf("len(mit) = %d\n", len(mit))
 135         }
 136
 137         // test construction directly
 138         for i := 0; i < count; i++ {
 139                 s := strconv.Itoa(i)
 140                 s10 := strconv.Itoa(i*10)
 141                 f := float(i)
 142                 // BUG m := M(i, i+1)
 143                 if mib[i] != (i != 0) {
 144                         fmt.Printf("mib[%d] = %t\n", i, mib[i])
 145                 }
 146                 if(mii[i] != 10*i) {
 147                         fmt.Printf("mii[%d] = %d\n", i, mii[i])
 148                 }
 149                 if(mfi[f] != 10*i) {
 150                         fmt.Printf("mfi[%d] = %d\n", i, mfi[f])
 151                 }
 152                 if(mif[i] != 10.0*f) {
 153                         fmt.Printf("mif[%d] = %g\n", i, mif[i])
 154                 }
 155                 if(mis[i] != s) {
 156                         fmt.Printf("mis[%d] = %s\n", i, mis[i])
 157                 }
 158                 if(msi[s] != i) {
 159                         fmt.Printf("msi[%s] = %d\n", s, msi[s])
 160                 }
 161                 if mss[s] != s10 {
 162                         fmt.Printf("mss[%s] = %g\n", s, mss[s])
 163                 }
 164                 for j := 0; j < len(mspa[s]); j++ {
 165                         if mspa[s][j] != s10 {
 166                                 fmt.Printf("mspa[%s][%d] = %s\n", s, j, mspa[s][j])
 167                         }
 168                 }
 169                 if(mipT[i].i != int64(i) || mipT[i].f != f) {
 170                         fmt.Printf("mipT[%d] = %v\n", i, mipT[i])
 171                 }
 172                 if(mpTi[apT[i]] != i) {
 173                         fmt.Printf("mpTi[apT[%d]] = %d\n", i, mpTi[apT[i]])
 174                 }
 175         //      if(mti[t] != i) {
 176         //              fmt.Printf("mti[%s] = %s\n", s, mti[t])
 177         //      }
 178                 if (mipM[i][i] != i + 1) {
 179                         fmt.Printf("mipM[%d][%d] = %d\n", i, i, mipM[i][i])
 180                 }
 181         //      if(mti[t] != i) {
 182         //              fmt.Printf("mti[%v] = %d\n", t, mti[t])
 183         //      }
 184                 if(mit[i].i != int64(i) || mit[i].f != f) {
 185                         fmt.Printf("mit[%d] = {%d %g}\n", i, mit[i].i, mit[i].f)
 186                 }
 187         }
 188
 189         // test existence with tuple check
 190         // failed lookups yield a false value for the boolean.
 191         for i := 0; i < count; i++ {
 192                 s := strconv.Itoa(i)
 193                 f := float(i)
 194                 {
 195                         _, b := mib[i]
 196                         if !b {
 197                                 fmt.Printf("tuple existence decl: mib[%d]\n", i)
 198                         }
 199                         _, b = mib[i]
 200                         if !b {
 201                                 fmt.Printf("tuple existence assign: mib[%d]\n", i)
 202                         }
 203                 }
 204                 {
 205                         _, b := mii[i]
 206                         if !b {
 207                                 fmt.Printf("tuple existence decl: mii[%d]\n", i)
 208                         }
 209                         _, b = mii[i]
 210                         if !b {
 211                                 fmt.Printf("tuple existence assign: mii[%d]\n", i)
 212                         }
 213                 }
 214                 {
 215                         _, b := mfi[f]
 216                         if !b {
 217                                 fmt.Printf("tuple existence decl: mfi[%d]\n", i)
 218                         }
 219                         _, b = mfi[f]
 220                         if !b {
 221                                 fmt.Printf("tuple existence assign: mfi[%d]\n", i)
 222                         }
 223                 }
 224                 {
 225                         _, b := mif[i]
 226                         if !b {
 227                                 fmt.Printf("tuple existence decl: mif[%d]\n", i)
 228                         }
 229                         _, b = mif[i]
 230                         if !b {
 231                                 fmt.Printf("tuple existence assign: mif[%d]\n", i)
 232                         }
 233                 }
 234                 {
 235                         _, b := mis[i]
 236                         if !b {
 237                                 fmt.Printf("tuple existence decl: mis[%d]\n", i)
 238                         }
 239                         _, b = mis[i]
 240                         if !b {
 241                                 fmt.Printf("tuple existence assign: mis[%d]\n", i)
 242                         }
 243                 }
 244                 {
 245                         _, b := msi[s]
 246                         if !b {
 247                                 fmt.Printf("tuple existence decl: msi[%d]\n", i)
 248                         }
 249                         _, b = msi[s]
 250                         if !b {
 251                                 fmt.Printf("tuple existence assign: msi[%d]\n", i)
 252                         }
 253                 }
 254                 {
 255                         _, b := mss[s]
 256                         if !b {
 257                                 fmt.Printf("tuple existence decl: mss[%d]\n", i)
 258                         }
 259                         _, b = mss[s]
 260                         if !b {
 261                                 fmt.Printf("tuple existence assign: mss[%d]\n", i)
 262                         }
 263                 }
 264                 {
 265                         _, b := mspa[s]
 266                         if !b {
 267                                 fmt.Printf("tuple existence decl: mspa[%d]\n", i)
 268                         }
 269                         _, b = mspa[s]
 270                         if !b {
 271                                 fmt.Printf("tuple existence assign: mspa[%d]\n", i)
 272                         }
 273                 }
 274                 {
 275                         _, b := mipT[i]
 276                         if !b {
 277                                 fmt.Printf("tuple existence decl: mipT[%d]\n", i)
 278                         }
 279                         _, b = mipT[i]
 280                         if !b {
 281                                 fmt.Printf("tuple existence assign: mipT[%d]\n", i)
 282                         }
 283                 }
 284                 {
 285                         _, b := mpTi[apT[i]]
 286                         if !b {
 287                                 fmt.Printf("tuple existence decl: mpTi[apT[%d]]\n", i)
 288                         }
 289                         _, b = mpTi[apT[i]]
 290                         if !b {
 291                                 fmt.Printf("tuple existence assign: mpTi[apT[%d]]\n", i)
 292                         }
 293                 }
 294                 {
 295                         _, b := mipM[i]
 296                         if !b {
 297                                 fmt.Printf("tuple existence decl: mipM[%d]\n", i)
 298                         }
 299                         _, b = mipM[i]
 300                         if !b {
 301                                 fmt.Printf("tuple existence assign: mipM[%d]\n", i)
 302                         }
 303                 }
 304                 {
 305                         _, b := mit[i]
 306                         if !b {
 307                                 fmt.Printf("tuple existence decl: mit[%d]\n", i)
 308                         }
 309                         _, b = mit[i]
 310                         if !b {
 311                                 fmt.Printf("tuple existence assign: mit[%d]\n", i)
 312                         }
 313                 }
 314 //              {
 315 //                      _, b := mti[t]
 316 //                      if !b {
 317 //                              fmt.Printf("tuple existence decl: mti[%d]\n", i)
 318 //                      }
 319 //                      _, b = mti[t]
 320 //                      if !b {
 321 //                              fmt.Printf("tuple existence assign: mti[%d]\n", i)
 322 //                      }
 323 //              }
 324         }
 325
 326         // test nonexistence with tuple check
 327         // failed lookups yield a false value for the boolean.
 328         for i := count; i < 2*count; i++ {
 329                 s := strconv.Itoa(i)
 330                 f := float(i)
 331                 {
 332                         _, b := mib[i]
 333                         if b {
 334                                 fmt.Printf("tuple nonexistence decl: mib[%d]", i)
 335                         }
 336                         _, b = mib[i]
 337                         if b {
 338                                 fmt.Printf("tuple nonexistence assign: mib[%d]", i)
 339                         }
 340                 }
 341                 {
 342                         _, b := mii[i]
 343                         if b {
 344                                 fmt.Printf("tuple nonexistence decl: mii[%d]", i)
 345                         }
 346                         _, b = mii[i]
 347                         if b {
 348                                 fmt.Printf("tuple nonexistence assign: mii[%d]", i)
 349                         }
 350                 }
 351                 {
 352                         _, b := mfi[f]
 353                         if b {
 354                                 fmt.Printf("tuple nonexistence decl: mfi[%d]", i)
 355                         }
 356                         _, b = mfi[f]
 357                         if b {
 358                                 fmt.Printf("tuple nonexistence assign: mfi[%d]", i)
 359                         }
 360                 }
 361                 {
 362                         _, b := mif[i]
 363                         if b {
 364                                 fmt.Printf("tuple nonexistence decl: mif[%d]", i)
 365                         }
 366                         _, b = mif[i]
 367                         if b {
 368                                 fmt.Printf("tuple nonexistence assign: mif[%d]", i)
 369                         }
 370                 }
 371                 {
 372                         _, b := mis[i]
 373                         if b {
 374                                 fmt.Printf("tuple nonexistence decl: mis[%d]", i)
 375                         }
 376                         _, b = mis[i]
 377                         if b {
 378                                 fmt.Printf("tuple nonexistence assign: mis[%d]", i)
 379                         }
 380                 }
 381                 {
 382                         _, b := msi[s]
 383                         if b {
 384                                 fmt.Printf("tuple nonexistence decl: msi[%d]", i)
 385                         }
 386                         _, b = msi[s]
 387                         if b {
 388                                 fmt.Printf("tuple nonexistence assign: msi[%d]", i)
 389                         }
 390                 }
 391                 {
 392                         _, b := mss[s]
 393                         if b {
 394                                 fmt.Printf("tuple nonexistence decl: mss[%d]", i)
 395                         }
 396                         _, b = mss[s]
 397                         if b {
 398                                 fmt.Printf("tuple nonexistence assign: mss[%d]", i)
 399                         }
 400                 }
 401                 {
 402                         _, b := mspa[s]
 403                         if b {
 404                                 fmt.Printf("tuple nonexistence decl: mspa[%d]", i)
 405                         }
 406                         _, b = mspa[s]
 407                         if b {
 408                                 fmt.Printf("tuple nonexistence assign: mspa[%d]", i)
 409                         }
 410                 }
 411                 {
 412                         _, b := mipT[i]
 413                         if b {
 414                                 fmt.Printf("tuple nonexistence decl: mipT[%d]", i)
 415                         }
 416                         _, b = mipT[i]
 417                         if b {
 418                                 fmt.Printf("tuple nonexistence assign: mipT[%d]", i)
 419                         }
 420                 }
 421                 {
 422                         _, b := mpTi[apT[i]]
 423                         if b {
 424                                 fmt.Printf("tuple nonexistence decl: mpTi[apt[%d]]", i)
 425                         }
 426                         _, b = mpTi[apT[i]]
 427                         if b {
 428                                 fmt.Printf("tuple nonexistence assign: mpTi[apT[%d]]", i)
 429                         }
 430                 }
 431                 {
 432                         _, b := mipM[i]
 433                         if b {
 434                                 fmt.Printf("tuple nonexistence decl: mipM[%d]", i)
 435                         }
 436                         _, b = mipM[i]
 437                         if b {
 438                                 fmt.Printf("tuple nonexistence assign: mipM[%d]", i)
 439                         }
 440                 }
 441 //              {
 442 //                      _, b := mti[t]
 443 //                      if b {
 444 //                              fmt.Printf("tuple nonexistence decl: mti[%d]", i)
 445 //                      }
 446 //                      _, b = mti[t]
 447 //                      if b {
 448 //                              fmt.Printf("tuple nonexistence assign: mti[%d]", i)
 449 //                      }
 450 //              }
 451                 {
 452                         _, b := mit[i]
 453                         if b {
 454                                 fmt.Printf("tuple nonexistence decl: mit[%d]", i)
 455                         }
 456                         _, b = mit[i]
 457                         if b {
 458                                 fmt.Printf("tuple nonexistence assign: mit[%d]", i)
 459                         }
 460                 }
 461         }
 462
 463
 464         // tests for structured map element updates
 465         for i := 0; i < count; i++ {
 466                 s := strconv.Itoa(i)
 467                 mspa[s][i % 2] = "deleted"
 468                 if mspa[s][i % 2] != "deleted" {
 469                         fmt.Printf("update mspa[%s][%d] = %s\n", s, i %2, mspa[s][i % 2])
 470                 }
 471
 472                 mipT[i].i += 1
 473                 if mipT[i].i != int64(i)+1 {
 474                         fmt.Printf("update mipT[%d].i = %d\n", i, mipT[i].i)
 475                 }
 476                 mipT[i].f = float(i + 1)
 477                 if (mipT[i].f != float(i + 1)) {
 478                         fmt.Printf("update mipT[%d].f = %g\n", i, mipT[i].f)
 479                 }
 480
 481                 mipM[i][i]++
 482                 if mipM[i][i] != (i + 1) + 1 {
 483                         fmt.Printf("update mipM[%d][%d] = %i\n", i, i, mipM[i][i])
 484                 }
 485         }
 486
 487         // test range on nil map
 488         var mnil map[string] int
 489         for _, _ = range mnil {
 490                 panic("range mnil")
 491         }
 492 }