Revert of [tests] Make assertOptimized()/assertUnoptimized() great again.

test/mjsunit/es6/array-iterator-turbo.js

 // Copyright 2016 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Flags: --turbo --turbo-escape --allow-natives-syntax
 
 "use strict";
 
+const kDeoptimized = 2;
+const kTurbofanned = 7;
+const kInterpreted = 8;
+
+function GetOptimizationStatus(fn) {
+  let status = %GetOptimizationStatus(fn);
+  switch (status) {
+  case kInterpreted: // Treat interpreted frames as unoptimized
+    status = kDeoptimized;
+    break;
+  }
+
+  return status;
+}
+
 let global = this;
 let tests = {
   FastElementsKind() {
     let runners = {
       FAST_SMI_ELEMENTS(array) {
         let sum = 0;
         for (let x of array) sum += x;
         return sum;
       },
 
@@ skipping 77 matching lines @@
       let { array, expected, array2, expected2 } = tests[key];
 
       // Warmup:
       fn(array);
       fn(array);
       %OptimizeFunctionOnNextCall(fn);
       fn(array);
 
       // TODO(bmeurer): FAST_HOLEY_DOUBLE_ELEMENTS maps generally deopt when
       // a hole is encountered. Test should be fixed once that is corrected.
-      let expect_deopt = /HOLEY_DOUBLE/.test(key);
+      let status = /HOLEY_DOUBLE/.test(key) ? kDeoptimized : kTurbofanned;
 
-      if (expect_deopt) {
-        assertUnoptimized(fn, '', key);
-      } else {
-        assertOptimized(fn, '', key);
-      }
+      assertEquals(status, GetOptimizationStatus(fn), key);
       assertEquals(expected, fn(array), key);
-      if (expect_deopt) {
-        assertUnoptimized(fn, '', key);
-      } else {
-        assertOptimized(fn, '', key);
-      }
+      assertEquals(status, GetOptimizationStatus(fn), key);
 
-      // Check no deopt when another array with the same map is used
+      // Check no deopt when another arra with the same map is used
       assertTrue(%HaveSameMap(array, array2), key);
-      if (expect_deopt) {
-        assertUnoptimized(fn, '', key);
-      } else {
-        assertOptimized(fn, '', key);
-      }
+      assertEquals(status, GetOptimizationStatus(fn), key);
       assertEquals(expected2, fn(array2), key);
 
       // CheckMaps bailout
       let newArray = Object.defineProperty(
           [1, 2, 3], 2, { enumerable: false, configurable: false,
                           get() { return 7; } });
       fn(newArray);
-      assertUnoptimized(fn, '', key);
+      assertEquals(kDeoptimized, GetOptimizationStatus(fn), key);
     }
   },
 
   TypedArrays() {
     let tests = {
       Uint8Array: {
         array: new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8, -1, 256]),
         expected: 291,
         array2: new Uint8Array([1, 2, 3]),
         expected2: 6
@@ skipping 67 matching lines @@
         for (let x of array) ret += x;
         return ret;
       };
 
       // Warmup
       sum(array);
       sum(array);
       %OptimizeFunctionOnNextCall(sum);
       assertEquals(expected, sum(array), key);
 
-      assertOptimized(sum, '', key);
+      assertEquals(kTurbofanned, GetOptimizationStatus(sum), key);
 
       // Not deoptimized when called on typed array of same type / map
       assertTrue(%HaveSameMap(array, array2));
       assertEquals(expected2, sum(array2), key);
-      assertOptimized(sum, '', key);
+      assertEquals(kTurbofanned, GetOptimizationStatus(sum), key);
 
       // Throw when detached
       let clone = new array.constructor(array);
       %ArrayBufferNeuter(clone.buffer);
       assertThrows(() => sum(clone), TypeError);
     }
   }
 };
 
 for (let name of Object.keys(tests)) {
   let test = tests[name];
   test();
 }