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 fmt "fmt"
  10
  11 const arraylen = 2; // BUG: shouldn't need this
  12
  13 func P(a []string) string {
  14         s := "{";
  15         for i := 0; i < len(a); i++ {
  16                 if i > 0 {
  17                         s += ","
  18                 }
  19                 s += `"` + a[i] + `"`;
  20         }
  21         s +="}";
  22         return s;
  23 }
  24
  25 func main() {
  26         F := fmt.New();
  27
  28         // BUG: should test a map literal when there's syntax
  29
  30         mib := new(map[int] bool);
  31         mii := new(map[int] int);
  32         mfi := new(map[float] int);
  33         mif := new(map[int] float);
  34         msi := new(map[string] int);
  35         mis := new(map[int] string);
  36         mss := new(map[string] string);
  37         mspa := new(map[string] []string);
  38         // BUG need an interface map both ways too
  39
  40         type T struct {
  41                 s string;
  42                 f float;
  43         };
  44         mipT := new(map[int] *T);
  45         mpTi := new(map[*T] int);
  46         //mit := new(map[int] T);       // should be able to do a value but:  fatal error: algtype: cant find type <T>{}
  47         //mti := new(map[T] int);       // should be able to do a value but:  fatal error: algtype: cant find type <T>{}
  48
  49         type M map[int] int;
  50         mipM := new(map[int] *M);
  51
  52         const count = 100; // BUG: should be bigger but maps do linear lookup
  53         var apT [2*count]*T;
  54
  55         for i := 0; i < count; i++ {
  56                 s := F.d(i).str();
  57                 f := float(i);
  58                 apT[i] = new(T);
  59                 apT[i].s = s;
  60                 apT[i].f = f;
  61                 apT[2*i] = new(T);      // need twice as many entries as we use, for the nonexistence check
  62                 apT[2*i].s = s;
  63                 apT[2*i].f = f;
  64                 // BUG t := T(s, f);
  65                 t := new(T); t.s = s; t.f = f;
  66                 // BUG m := M(i, i+1);
  67                 m := new(M); m[i] = i+1;
  68                 mib[i] = (i != 0);
  69                 mii[i] = 10*i;
  70                 mfi[float(i)] = 10*i;
  71                 mif[i] = 10.0*f;
  72                 mis[i] = s;
  73                 msi[F.d(i).str()] = i;
  74                 mss[F.d(i).str()] = F.d(10*i).str();
  75                 mss[F.d(i).str()] = F.d(10*i).str();
  76                 as := new([arraylen]string);
  77                         as[0] = F.d(10*i).str();
  78                         as[1] = F.d(10*i).str();
  79                 mspa[F.d(i).str()] = as;
  80                 mipT[i] = t;
  81                 mpTi[apT[i]] = i;
  82                 // BUG mti[t] = i;
  83                 mipM[i] = m;
  84         }
  85
  86         // test len
  87         if len(mib) != count {
  88                 F.s("len(mib) = ").d(len(mib)).putnl();
  89         }
  90         if len(mii) != count {
  91                 F.s("len(mii) = ").d(len(mii)).putnl();
  92         }
  93         if len(mfi) != count {
  94                 F.s("len(mfi) = ").d(len(mfi)).putnl();
  95         }
  96         if len(mif) != count {
  97                 F.s("len(mif) = ").d(len(mif)).putnl();
  98         }
  99         if len(msi) != count {
 100                 F.s("len(msi) = ").d(len(msi)).putnl();
 101         }
 102         if len(mis) != count {
 103                 F.s("len(mis) = ").d(len(mis)).putnl();
 104         }
 105         if len(mss) != count {
 106                 F.s("len(mss) = ").d(len(mss)).putnl();
 107         }
 108         if len(mspa) != count {
 109                 F.s("len(mspa) = ").d(len(mspa)).putnl();
 110         }
 111         if len(mipT) != count {
 112                 F.s("len(mipT) = ").d(len(mipT)).putnl();
 113         }
 114         if len(mpTi) != count {
 115                 F.s("len(mpTi) = ").d(len(mpTi)).putnl();
 116         }
 117 //      if len(mti) != count {
 118 //              F.s("len(mti) = ").d(len(mti)).putnl();
 119 //      }
 120         if len(mipM) != count {
 121                 F.s("len(mipM) = ").d(len(mipM)).putnl();
 122         }
 123
 124         // test construction directly
 125         for i := 0; i < count; i++ {
 126                 s := F.d(i).str();
 127                 f := float(i);
 128                 // BUG t := T(s, f);
 129                 var t T; t.s = s; t.f = f;
 130                 // BUG m := M(i, i+1);
 131                 if mib[i] != (i != 0) {
 132                         F.s("mib[").d(i).s("] = ").boolean(mib[i]).putnl();
 133                 }
 134                 if(mii[i] != 10*i) {
 135                         F.s("mii[").d(i).s("] = ").d(mii[i]).putnl();
 136                 }
 137                 if(mfi[f] != 10*i) {
 138                         F.s("mfi[").d(i).s("] = ").d(mfi[f]).putnl();
 139                 }
 140                 if(mif[i] != 10.0*f) {
 141                         F.s("mif[").d(i).s("] = ").g(mif[i]).putnl();
 142                 }
 143                 if(mis[i] != s) {
 144                         F.s("mis[").d(i).s("] = ").s(mis[i]).putnl();
 145                 }
 146                 if(msi[s] != i) {
 147                         F.s("msi[").s(s).s("] = ").d(msi[s]).putnl();
 148                 }
 149                 if mss[s] != F.d(10*i).str() {
 150                         F.s("mss[").s(s).s("] = ").s(mss[s]).putnl();
 151                 }
 152                 for j := 0; j < arraylen; j++ {
 153                         if mspa[s][j] != F.d(10*i).str() {
 154                                 F.s("mspa[").s(s).s("][").d(j).s("] = ").s(mspa[s][j]).putnl();
 155                         }
 156                 }
 157                 if(mipT[i].s != s || mipT[i].f != f) {
 158                         F.s("mipT[").d(i).s("] = {").s(mipT[i].s).s(", ").g(mipT[i].f).s("}").putnl();
 159                 }
 160                 if(mpTi[apT[i]] != i) {
 161                         F.s("mpTi[apT[").d(i).s("]] = ").d(mpTi[apT[i]]).putnl();
 162                 }
 163 //              if(mti[t] != i) {
 164 //                      F.s("mti[").s(s).s("] = ").s(mti[s]).putnl();
 165 //              }
 166                 if (mipM[i][i] != i + 1) {
 167                         F.s("mipM[").d(i).s("][").d(i).s("] =").d(mipM[i][i]).putnl();
 168                 }
 169         }
 170
 171         // test existence with tuple check
 172         // failed lookups yield a false value for the boolean.
 173         for i := 0; i < count; i++ {
 174                 s := F.d(i).str();
 175                 f := float(i);
 176                 // BUG t := T(s, f);
 177                 var t T; t.s = s; t.f = f;
 178                 // BUG m := M(i, i+1);
 179                 {
 180                         a, b := mib[i];
 181                         if !b {
 182                                 F.s("tuple existence decl: mib[").d(i).s("]").putnl();
 183                         }
 184                         a, b = mib[i];
 185                         if !b {
 186                                 F.s("tuple existence assign: mib[").d(i).s("]").putnl();
 187                         }
 188                 }
 189                 {
 190                         a, b := mii[i];
 191                         if !b {
 192                                 F.s("tuple existence decl: mii[").d(i).s("]").putnl();
 193                         }
 194                         a, b = mii[i];
 195                         if !b {
 196                                 F.s("tuple existence assign: mii[").d(i).s("]").putnl();
 197                         }
 198                 }
 199                 {
 200                         a, b := mfi[f];
 201                         if !b {
 202                                 F.s("tuple existence decl: mfi[").g(f).s("]").putnl();
 203                         }
 204                         a, b = mfi[f];
 205                         if !b {
 206                                 F.s("tuple existence assign: mfi[").g(f).s("]").putnl();
 207                         }
 208                 }
 209                 {
 210                         a, b := mif[i];
 211                         if !b {
 212                                 F.s("tuple existence decl: mif[").d(i).s("]").putnl();
 213                         }
 214                         a, b = mif[i];
 215                         if !b {
 216                                 F.s("tuple existence assign: mif[").d(i).s("]").putnl();
 217                         }
 218                 }
 219                 {
 220                         a, b := mis[i];
 221                         if !b {
 222                                 F.s("tuple existence decl: mis[").d(i).s("]").putnl();
 223                         }
 224                         a, b = mis[i];
 225                         if !b {
 226                                 F.s("tuple existence assign: mis[").d(i).s("]").putnl();
 227                         }
 228                 }
 229                 {
 230                         a, b := msi[s];
 231                         if !b {
 232                                 F.s("tuple existence decl: msi[").s(s).s("]").putnl();
 233                         }
 234                         a, b = msi[s];
 235                         if !b {
 236                                 F.s("tuple existence assign: msi[").s(s).s("]").putnl();
 237                         }
 238                 }
 239                 {
 240                         a, b := mss[s];
 241                         if !b {
 242                                 F.s("tuple existence decl: mss[").s(s).s("]").putnl();
 243                         }
 244                         a, b = mss[s];
 245                         if !b {
 246                                 F.s("tuple existence assign: mss[").s(s).s("]").putnl();
 247                         }
 248                 }
 249                 {
 250                         a, b := mspa[s];
 251                         if !b {
 252                                 F.s("tuple existence decl: mspa[").s(s).s("]").putnl();
 253                         }
 254                         a, b = mspa[s];
 255                         if !b {
 256                                 F.s("tuple existence assign: mspa[").s(s).s("]").putnl();
 257                         }
 258                 }
 259                 {
 260                         a, b := mipT[i];
 261                         if !b {
 262                                 F.s("tuple existence decl: mipT[").d(i).s("]").putnl();
 263                         }
 264                         a, b = mipT[i];
 265                         if !b {
 266                                 F.s("tuple existence assign: mipT[").d(i).s("]").putnl();
 267                         }
 268                 }
 269                 {
 270                         a, b := mpTi[apT[i]];
 271                         if !b {
 272                                 F.s("tuple existence decl: mpTi[apT[").d(i).s("]]").putnl();
 273                         }
 274                         a, b = mpTi[apT[i]];
 275                         if !b {
 276                                 F.s("tuple existence assign: mpTi[apT[").d(i).s("]]").putnl();
 277                         }
 278                 }
 279 //              a,b := mti[t]...
 280 //                      emit stdout <- format("haskey mti[%s] false", string(t));
 281                 {
 282                         a, b := mipM[i];
 283                         if !b {
 284                                 F.s("tuple existence decl: mipM[").d(i).s("]").putnl();
 285                         }
 286                         a, b = mipM[i];
 287                         if !b {
 288                                 F.s("tuple existence assign: mipM[").d(i).s("]").putnl();
 289                         }
 290                 }
 291         }
 292
 293         // test nonexistence with tuple check
 294         // failed lookups yield a false value for the boolean.
 295         for i := count; i < 2*count; i++ {
 296                 s := F.d(i).str();
 297                 f := float(i);
 298                 // BUG t := T(s, f);
 299                 var t T; t.s = s; t.f = f;
 300                 // BUG m := M(i, i+1);
 301                 {
 302                         a, b := mib[i];
 303                         if b {
 304                                 F.s("tuple nonexistence decl: mib[").d(i).s("]").putnl();
 305                         }
 306                         a, b = mib[i];
 307                         if b {
 308                                 F.s("tuple nonexistence assign: mib[").d(i).s("]").putnl();
 309                         }
 310                 }
 311                 {
 312                         a, b := mii[i];
 313                         if b {
 314                                 F.s("tuple nonexistence decl: mii[").d(i).s("]").putnl();
 315                         }
 316                         a, b = mii[i];
 317                         if b {
 318                                 F.s("tuple nonexistence assign: mii[").d(i).s("]").putnl();
 319                         }
 320                 }
 321                 {
 322                         a, b := mfi[f];
 323                         if b {
 324                                 F.s("tuple nonexistence decl: mfi[").g(f).s("]").putnl();
 325                         }
 326                         a, b = mfi[f];
 327                         if b {
 328                                 F.s("tuple nonexistence assign: mfi[").g(f).s("]").putnl();
 329                         }
 330                 }
 331                 {
 332                         a, b := mif[i];
 333                         if b {
 334                                 F.s("tuple nonexistence decl: mif[").d(i).s("]").putnl();
 335                         }
 336                         a, b = mif[i];
 337                         if b {
 338                                 F.s("tuple nonexistence assign: mif[").d(i).s("]").putnl();
 339                         }
 340                 }
 341                 {
 342                         a, b := mis[i];
 343                         if b {
 344                                 F.s("tuple nonexistence decl: mis[").d(i).s("]").putnl();
 345                         }
 346                         a, b = mis[i];
 347                         if b {
 348                                 F.s("tuple nonexistence assign: mis[").d(i).s("]").putnl();
 349                         }
 350                 }
 351                 {
 352                         a, b := msi[s];
 353                         if b {
 354                                 F.s("tuple nonexistence decl: msi[").s(s).s("]").putnl();
 355                         }
 356                         a, b = msi[s];
 357                         if b {
 358                                 F.s("tuple nonexistence assign: msi[").s(s).s("]").putnl();
 359                         }
 360                 }
 361                 {
 362                         a, b := mss[s];
 363                         if b {
 364                                 F.s("tuple nonexistence decl: mss[").s(s).s("]").putnl();
 365                         }
 366                         a, b = mss[s];
 367                         if b {
 368                                 F.s("tuple nonexistence assign: mss[").s(s).s("]").putnl();
 369                         }
 370                 }
 371                 {
 372                         a, b := mspa[s];
 373                         if b {
 374                                 F.s("tuple nonexistence decl: mspa[").s(s).s("]").putnl();
 375                         }
 376                         a, b = mspa[s];
 377                         if b {
 378                                 F.s("tuple nonexistence assign: mspa[").s(s).s("]").putnl();
 379                         }
 380                 }
 381                 {
 382                         a, b := mipT[i];
 383                         if b {
 384                                 F.s("tuple nonexistence decl: mipT[").d(i).s("]").putnl();
 385                         }
 386                         a, b = mipT[i];
 387                         if b {
 388                                 F.s("tuple nonexistence assign: mipT[").d(i).s("]").putnl();
 389                         }
 390                 }
 391                 {
 392                         a, b := mpTi[apT[i]];
 393                         if b {
 394                                 F.s("tuple nonexistence decl: mpTi[apt[").d(i).s("]]").putnl();
 395                         }
 396                         a, b = mpTi[apT[i]];
 397                         if b {
 398                                 F.s("tuple nonexistence assign: mpTi[apT[").d(i).s("]]").putnl();
 399                         }
 400                 }
 401 //              a,b := mti[t]...
 402 //                      emit stdout <- format("haskey mti[%s] false", string(t));
 403                 {
 404                         a, b := mipM[i];
 405                         if b {
 406                                 F.s("tuple nonexistence decl: mipM[").d(i).s("]").putnl();
 407                         }
 408                         a, b = mipM[i];
 409                         if b {
 410                                 F.s("tuple nonexistence assign: mipM[").d(i).s("]").putnl();
 411                         }
 412                 }
 413         }
 414
 415
 416         // tests for structured map element updates
 417         for i := 0; i < count; i++ {
 418                 s := F.d(i).str();
 419                 mspa[s][i % 2] = "deleted";
 420                 if mspa[s][i % 2] != "deleted" {
 421                         F.s("mspa[").d(i).s("][").d(i).s("%2] =").s(mspa[s][i % 2]).putnl();
 422                 }
 423                 mipT[i].s = string('a' + i % 26) + mipT[i].s[1:len(s)];
 424                 first := string('a' + i % 26);
 425                 if mipT[i].s != first + s[1:len(s)] {
 426                         F.s("mit[").d(i).s("].s = ").s(mipT[i].s).putnl();
 427                 }
 428                 mipT[i].f = float(i + 1);
 429                 if (mipT[i].f != float(i + 1)) {
 430                         F.s("mipT[").d(i).s("].f = ").g(mipT[i].f).putnl();
 431                 }
 432                 mipM[i][i]++;
 433                 if mipM[i][i] != (i + 1) + 1 {
 434                         F.s("mipM[").d(i).s("][").d(i).s("] = ").d(mipM[i][i]).putnl();
 435                 }
 436         }
 437 }